commit 2ab8df7f77d345f4e196486d62bdf79cd88bfb29 Author: Sosokker Date: Wed May 14 16:14:35 2025 +0700 initial commit diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..236ed7b --- /dev/null +++ b/.gitignore @@ -0,0 +1,310 @@ +## Core latex/pdflatex auxiliary files: +*.aux +*.lof +*.log +*.lot +*.fls +*.out +*.toc +*.fmt +*.fot +*.cb +*.cb2 +.*.lb + +## Intermediate documents: +*.dvi +*.xdv +*-converted-to.* +# these rules might exclude image files for figures etc. +# *.ps +# *.eps +# *.pdf + +## Generated if empty string is given at "Please type another file name for output:" +.pdf + +## Bibliography auxiliary files (bibtex/biblatex/biber): +*.bbl +*.bbl-SAVE-ERROR +*.bcf +*.bcf-SAVE-ERROR +*.blg +*-blx.aux +*-blx.bib +*.run.xml + +## Build tool auxiliary files: +*.fdb_latexmk +*.synctex +*.synctex(busy) +*.synctex.gz +*.synctex.gz(busy) +*.pdfsync +*.rubbercache +rubber.cache + +## Build tool directories for auxiliary files +# latexrun +latex.out/ + +## Auxiliary and intermediate files from other packages: +# algorithms +*.alg +*.loa + +# achemso +acs-*.bib + +# amsthm +*.thm + +# beamer +*.nav +*.pre +*.snm +*.vrb + +# changes +*.soc + +# comment +*.cut + +# cprotect +*.cpt + +# elsarticle (documentclass of Elsevier journals) +*.spl + +# endnotes +*.ent + +# fixme +*.lox + +# feynmf/feynmp +*.mf +*.mp +*.t[1-9] +*.t[1-9][0-9] +*.tfm + +#(r)(e)ledmac/(r)(e)ledpar +*.end +*.?end +*.[1-9] +*.[1-9][0-9] +*.[1-9][0-9][0-9] +*.[1-9]R +*.[1-9][0-9]R +*.[1-9][0-9][0-9]R +*.eledsec[1-9] +*.eledsec[1-9]R +*.eledsec[1-9][0-9] +*.eledsec[1-9][0-9]R +*.eledsec[1-9][0-9][0-9] +*.eledsec[1-9][0-9][0-9]R + +# glossaries +*.acn +*.acr +*.glg +*.glo +*.gls +*.glsdefs +*.lzo +*.lzs +*.slg +*.slo +*.sls + +# uncomment this for glossaries-extra (will ignore makeindex's style files!) +# *.ist + +# gnuplot +*.gnuplot +*.table + +# gnuplottex +*-gnuplottex-* + +# gregoriotex +*.gaux +*.glog +*.gtex + +# htlatex +*.4ct +*.4tc +*.idv +*.lg +*.trc +*.xref + +# hypdoc +*.hd + +# hyperref +*.brf + +# knitr +*-concordance.tex +# TODO Uncomment the next line if you use knitr and want to ignore its generated tikz files +# *.tikz +*-tikzDictionary + +# listings +*.lol + +# luatexja-ruby +*.ltjruby + +# makeidx +*.idx +*.ilg +*.ind + +# minitoc +*.maf +*.mlf +*.mlt +*.mtc[0-9]* +*.slf[0-9]* +*.slt[0-9]* +*.stc[0-9]* + +# minted +_minted* +*.pyg + +# morewrites +*.mw + +# newpax +*.newpax + +# nomencl +*.nlg +*.nlo +*.nls + +# pax +*.pax + +# pdfpcnotes +*.pdfpc + +# sagetex +*.sagetex.sage +*.sagetex.py +*.sagetex.scmd + +# scrwfile +*.wrt + +# svg +svg-inkscape/ + +# sympy +*.sout +*.sympy +sympy-plots-for-*.tex/ + +# pdfcomment +*.upa +*.upb + +# pythontex +*.pytxcode +pythontex-files-*/ + +# tcolorbox +*.listing + +# thmtools +*.loe + +# TikZ & PGF +*.dpth +*.md5 +*.auxlock + +# titletoc +*.ptc + +# todonotes +*.tdo + +# vhistory +*.hst +*.ver + +# easy-todo +*.lod + +# xcolor +*.xcp + +# xmpincl +*.xmpi + +# xindy +*.xdy + +# xypic precompiled matrices and outlines +*.xyc +*.xyd + +# endfloat +*.ttt +*.fff + +# Latexian +TSWLatexianTemp* + +## Editors: +# WinEdt +*.bak +*.sav + +# Texpad +.texpadtmp + +# LyX +*.lyx~ + +# Kile +*.backup + +# gummi +.*.swp + +# KBibTeX +*~[0-9]* + +# TeXnicCenter +*.tps + +# auto folder when using emacs and auctex +./auto/* +*.el + +# expex forward references with \gathertags +*-tags.tex + +# standalone packages +*.sta + +# Makeindex log files +*.lpz + +# xwatermark package +*.xwm + +# REVTeX puts footnotes in the bibliography by default, unless the nofootinbib +# option is specified. Footnotes are the stored in a file with suffix Notes.bib. +# Uncomment the next line to have this generated file ignored. +#*Notes.bib + +.node_modules/* \ No newline at end of file diff --git a/MBZUAI-Blue.eps b/MBZUAI-Blue.eps new file mode 100644 index 0000000..b707221 --- /dev/null +++ b/MBZUAI-Blue.eps @@ -0,0 +1,8374 @@ +%!PS-Adobe-3.1 EPSF-3.0 +%ADO_DSC_Encoding: Windows Roman +%%Title: MBZUAI -Brand Mark_Techno Blue -RGB.pdf +%%Creator: Adobe Acrobat 24.5.0 +%%For: Chithra.Chakra +%%CreationDate: 2/20/2025, 12:23:18 PM +%%BoundingBox: 0 0 152 133 +%%HiResBoundingBox: 0 0 151.6990 132.9020 +%%CropBox: 0 0 151.6990 132.9020 +%%LanguageLevel: 2 +%%DocumentNeededResources: (atend) +%%DocumentSuppliedResources: (atend) +%%DocumentNeededFeatures: (atend) +%%DocumentSuppliedFeatures: (atend) +%%DocumentData: Clean7Bit +%%Pages: (atend) +%%DocumentProcessColors: Cyan Magenta +%%DocumentCustomColors: (atend) +%%EndComments +%%BeginDefaults +%%ViewingOrientation: 1 0 0 1 +%%EndDefaults +%%BeginProlog +%%BeginResource: procset Adobe_AGM_Utils 1.0 0 +%%Version: 1.0 0 +%%Copyright: Copyright(C)2000-2006 Adobe Systems, Inc. All Rights Reserved. +systemdict/setpacking known +{currentpacking true setpacking}if +userdict/Adobe_AGM_Utils 75 dict dup begin put +/bdf +{bind def}bind def +/nd{null def}bdf +/xdf +{exch def}bdf +/ldf +{load def}bdf +/ddf +{put}bdf +/xddf +{3 -1 roll put}bdf +/xpt +{exch put}bdf +/ndf +{ + exch dup where{ + pop pop pop + }{ + xdf + }ifelse +}def +/cdndf +{ + exch dup currentdict exch known{ + pop pop + }{ + exch def + }ifelse +}def +/gx +{get exec}bdf +/ps_level + /languagelevel where{ + pop systemdict/languagelevel gx + }{ + 1 + }ifelse +def +/level2 + ps_level 2 ge +def +/level3 + ps_level 3 ge +def +/ps_version + {version cvr}stopped{-1}if +def +/set_gvm +{currentglobal exch setglobal}bdf +/reset_gvm +{setglobal}bdf +/makereadonlyarray +{ + /packedarray where{pop packedarray + }{ + array astore readonly}ifelse +}bdf +/map_reserved_ink_name +{ + dup type/stringtype eq{ + dup/Red eq{ + pop(_Red_) + }{ + dup/Green eq{ + pop(_Green_) + }{ + dup/Blue eq{ + pop(_Blue_) + }{ + dup()cvn eq{ + pop(Process) + }if + }ifelse + }ifelse + }ifelse + }if +}bdf +/AGMUTIL_GSTATE 22 dict def +/get_gstate +{ + AGMUTIL_GSTATE begin + /AGMUTIL_GSTATE_clr_spc currentcolorspace def + /AGMUTIL_GSTATE_clr_indx 0 def + /AGMUTIL_GSTATE_clr_comps 12 array def + mark currentcolor counttomark + {AGMUTIL_GSTATE_clr_comps AGMUTIL_GSTATE_clr_indx 3 -1 roll put + /AGMUTIL_GSTATE_clr_indx AGMUTIL_GSTATE_clr_indx 1 add def}repeat pop + /AGMUTIL_GSTATE_fnt rootfont def + /AGMUTIL_GSTATE_lw currentlinewidth def + /AGMUTIL_GSTATE_lc currentlinecap def + /AGMUTIL_GSTATE_lj currentlinejoin def + /AGMUTIL_GSTATE_ml currentmiterlimit def + currentdash/AGMUTIL_GSTATE_do xdf/AGMUTIL_GSTATE_da xdf + /AGMUTIL_GSTATE_sa currentstrokeadjust def + /AGMUTIL_GSTATE_clr_rnd currentcolorrendering def + /AGMUTIL_GSTATE_op currentoverprint def + /AGMUTIL_GSTATE_bg currentblackgeneration cvlit def + /AGMUTIL_GSTATE_ucr currentundercolorremoval cvlit def + currentcolortransfer cvlit/AGMUTIL_GSTATE_gy_xfer xdf cvlit/AGMUTIL_GSTATE_b_xfer xdf + cvlit/AGMUTIL_GSTATE_g_xfer xdf cvlit/AGMUTIL_GSTATE_r_xfer xdf + /AGMUTIL_GSTATE_ht currenthalftone def + /AGMUTIL_GSTATE_flt currentflat def + end +}def +/set_gstate +{ + AGMUTIL_GSTATE begin + AGMUTIL_GSTATE_clr_spc setcolorspace + AGMUTIL_GSTATE_clr_indx{AGMUTIL_GSTATE_clr_comps AGMUTIL_GSTATE_clr_indx 1 sub get + /AGMUTIL_GSTATE_clr_indx AGMUTIL_GSTATE_clr_indx 1 sub def}repeat setcolor + AGMUTIL_GSTATE_fnt setfont + AGMUTIL_GSTATE_lw setlinewidth + AGMUTIL_GSTATE_lc setlinecap + AGMUTIL_GSTATE_lj setlinejoin + AGMUTIL_GSTATE_ml setmiterlimit + AGMUTIL_GSTATE_da AGMUTIL_GSTATE_do setdash + AGMUTIL_GSTATE_sa setstrokeadjust + AGMUTIL_GSTATE_clr_rnd setcolorrendering + AGMUTIL_GSTATE_op setoverprint + AGMUTIL_GSTATE_bg cvx setblackgeneration + AGMUTIL_GSTATE_ucr cvx setundercolorremoval + AGMUTIL_GSTATE_r_xfer cvx AGMUTIL_GSTATE_g_xfer cvx AGMUTIL_GSTATE_b_xfer cvx + AGMUTIL_GSTATE_gy_xfer cvx setcolortransfer + AGMUTIL_GSTATE_ht/HalftoneType get dup 9 eq exch 100 eq or + { + currenthalftone/HalftoneType get AGMUTIL_GSTATE_ht/HalftoneType get ne + { + mark AGMUTIL_GSTATE_ht{sethalftone}stopped cleartomark + }if + }{ + AGMUTIL_GSTATE_ht sethalftone + }ifelse + AGMUTIL_GSTATE_flt setflat + end +}def +/get_gstate_and_matrix +{ + AGMUTIL_GSTATE begin + /AGMUTIL_GSTATE_ctm matrix currentmatrix def + end + get_gstate +}def +/set_gstate_and_matrix +{ + set_gstate + AGMUTIL_GSTATE begin + AGMUTIL_GSTATE_ctm setmatrix + end +}def +/AGMUTIL_str256 256 string def +/AGMUTIL_src256 256 string def +/AGMUTIL_dst64 64 string def +/AGMUTIL_srcLen nd +/AGMUTIL_ndx nd +/AGMUTIL_cpd nd +/capture_cpd{ + //Adobe_AGM_Utils/AGMUTIL_cpd currentpagedevice ddf +}def +/thold_halftone +{ + level3 + {sethalftone currenthalftone} + { + dup/HalftoneType get 3 eq + { + sethalftone currenthalftone + }{ + begin + Width Height mul{ + Thresholds read{pop}if + }repeat + end + currenthalftone + }ifelse + }ifelse +}def +/rdcmntline +{ + currentfile AGMUTIL_str256 readline pop + (%)anchorsearch{pop}if +}bdf +/filter_cmyk +{ + dup type/filetype ne{ + exch()/SubFileDecode filter + }{ + exch pop + } + ifelse + [ + exch + { + AGMUTIL_src256 readstring pop + dup length/AGMUTIL_srcLen exch def + /AGMUTIL_ndx 0 def + AGMCORE_plate_ndx 4 AGMUTIL_srcLen 1 sub{ + 1 index exch get + AGMUTIL_dst64 AGMUTIL_ndx 3 -1 roll put + /AGMUTIL_ndx AGMUTIL_ndx 1 add def + }for + pop + AGMUTIL_dst64 0 AGMUTIL_ndx getinterval + } + bind + /exec cvx + ]cvx +}bdf +/filter_indexed_devn +{ + cvi Names length mul names_index add Lookup exch get +}bdf +/filter_devn +{ + 4 dict begin + /srcStr xdf + /dstStr xdf + dup type/filetype ne{ + 0()/SubFileDecode filter + }if + [ + exch + [ + /devicen_colorspace_dict/AGMCORE_gget cvx/begin cvx + currentdict/srcStr get/readstring cvx/pop cvx + /dup cvx/length cvx 0/gt cvx[ + Adobe_AGM_Utils/AGMUTIL_ndx 0/ddf cvx + names_index Names length currentdict/srcStr get length 1 sub{ + 1/index cvx/exch cvx/get cvx + currentdict/dstStr get/AGMUTIL_ndx/load cvx 3 -1/roll cvx/put cvx + Adobe_AGM_Utils/AGMUTIL_ndx/AGMUTIL_ndx/load cvx 1/add cvx/ddf cvx + }for + currentdict/dstStr get 0/AGMUTIL_ndx/load cvx/getinterval cvx + ]cvx/if cvx + /end cvx + ]cvx + bind + /exec cvx + ]cvx + end +}bdf +/AGMUTIL_imagefile nd +/read_image_file +{ + AGMUTIL_imagefile 0 setfileposition + 10 dict begin + /imageDict xdf + /imbufLen Width BitsPerComponent mul 7 add 8 idiv def + /imbufIdx 0 def + /origDataSource imageDict/DataSource get def + /origMultipleDataSources imageDict/MultipleDataSources get def + /origDecode imageDict/Decode get def + /dstDataStr imageDict/Width get colorSpaceElemCnt mul string def + imageDict/MultipleDataSources known{MultipleDataSources}{false}ifelse + { + /imbufCnt imageDict/DataSource get length def + /imbufs imbufCnt array def + 0 1 imbufCnt 1 sub{ + /imbufIdx xdf + imbufs imbufIdx imbufLen string put + imageDict/DataSource get imbufIdx[AGMUTIL_imagefile imbufs imbufIdx get/readstring cvx/pop cvx]cvx put + }for + DeviceN_PS2{ + imageDict begin + /DataSource[DataSource/devn_sep_datasource cvx]cvx def + /MultipleDataSources false def + /Decode[0 1]def + end + }if + }{ + /imbuf imbufLen string def + Indexed_DeviceN level3 not and DeviceN_NoneName or{ + /srcDataStrs[imageDict begin + currentdict/MultipleDataSources known{MultipleDataSources{DataSource length}{1}ifelse}{1}ifelse + { + Width Decode length 2 div mul cvi string + }repeat + end]def + imageDict begin + /DataSource[AGMUTIL_imagefile Decode BitsPerComponent false 1/filter_indexed_devn load dstDataStr srcDataStrs devn_alt_datasource/exec cvx]cvx def + /Decode[0 1]def + end + }{ + imageDict/DataSource[1 string dup 0 AGMUTIL_imagefile Decode length 2 idiv string/readstring cvx/pop cvx names_index/get cvx/put cvx]cvx put + imageDict/Decode[0 1]put + }ifelse + }ifelse + imageDict exch + load exec + imageDict/DataSource origDataSource put + imageDict/MultipleDataSources origMultipleDataSources put + imageDict/Decode origDecode put + end +}bdf +/write_image_file +{ + begin + {(AGMUTIL_imagefile)(w+)file}stopped{ + false + }{ + Adobe_AGM_Utils/AGMUTIL_imagefile xddf + 2 dict begin + /imbufLen Width BitsPerComponent mul 7 add 8 idiv def + MultipleDataSources{DataSource 0 get}{DataSource}ifelse type/filetype eq{ + /imbuf imbufLen string def + }if + 1 1 Height MultipleDataSources not{Decode length 2 idiv mul}if{ + pop + MultipleDataSources{ + 0 1 DataSource length 1 sub{ + DataSource type dup + /arraytype eq{ + pop DataSource exch gx + }{ + /filetype eq{ + DataSource exch get imbuf readstring pop + }{ + DataSource exch get + }ifelse + }ifelse + AGMUTIL_imagefile exch writestring + }for + }{ + DataSource type dup + /arraytype eq{ + pop DataSource exec + }{ + /filetype eq{ + DataSource imbuf readstring pop + }{ + DataSource + }ifelse + }ifelse + AGMUTIL_imagefile exch writestring + }ifelse + }for + end + true + }ifelse + end +}bdf +/close_image_file +{ + AGMUTIL_imagefile closefile(AGMUTIL_imagefile)deletefile +}def +statusdict/product known userdict/AGMP_current_show known not and{ + /pstr statusdict/product get def + pstr(HP LaserJet 2200)eq + pstr(HP LaserJet 4000 Series)eq or + pstr(HP LaserJet 4050 Series )eq or + pstr(HP LaserJet 8000 Series)eq or + pstr(HP LaserJet 8100 Series)eq or + pstr(HP LaserJet 8150 Series)eq or + pstr(HP LaserJet 5000 Series)eq or + pstr(HP LaserJet 5100 Series)eq or + pstr(HP Color LaserJet 4500)eq or + pstr(HP Color LaserJet 4600)eq or + pstr(HP LaserJet 5Si)eq or + pstr(HP LaserJet 1200 Series)eq or + pstr(HP LaserJet 1300 Series)eq or + pstr(HP LaserJet 4100 Series)eq or + { + userdict/AGMP_current_show/show load put + userdict/show{ + currentcolorspace 0 get + /Pattern eq + {false charpath f} + {AGMP_current_show}ifelse + }put + }if + currentdict/pstr undef +}if +/consumeimagedata +{ + begin + AGMIMG_init_common + currentdict/MultipleDataSources known not + {/MultipleDataSources false def}if + MultipleDataSources + { + DataSource 0 get type + dup/filetype eq + { + 1 dict begin + /flushbuffer Width cvi string def + 1 1 Height cvi + { + pop + 0 1 DataSource length 1 sub + { + DataSource exch get + flushbuffer readstring pop pop + }for + }for + end + }if + dup/arraytype eq exch/packedarraytype eq or DataSource 0 get xcheck and + { + Width Height mul cvi + { + 0 1 DataSource length 1 sub + {dup DataSource exch gx length exch 0 ne{pop}if}for + dup 0 eq + {pop exit}if + sub dup 0 le + {exit}if + }loop + pop + }if + } + { + /DataSource load type + dup/filetype eq + { + 1 dict begin + /flushbuffer Width Decode length 2 idiv mul cvi string def + 1 1 Height{pop DataSource flushbuffer readstring pop pop}for + end + }if + dup/arraytype eq exch/packedarraytype eq or/DataSource load xcheck and + { + Height Width BitsPerComponent mul 8 BitsPerComponent sub add 8 idiv Decode length 2 idiv mul mul + { + DataSource length dup 0 eq + {pop exit}if + sub dup 0 le + {exit}if + }loop + pop + }if + }ifelse + end +}bdf +/addprocs +{ + 2{/exec load}repeat + 3 1 roll + [5 1 roll]bind cvx +}def +/modify_halftone_xfer +{ + currenthalftone dup length dict copy begin + currentdict 2 index known{ + 1 index load dup length dict copy begin + currentdict/TransferFunction known{ + /TransferFunction load + }{ + currenttransfer + }ifelse + addprocs/TransferFunction xdf + currentdict end def + currentdict end sethalftone + }{ + currentdict/TransferFunction known{ + /TransferFunction load + }{ + currenttransfer + }ifelse + addprocs/TransferFunction xdf + currentdict end sethalftone + pop + }ifelse +}def +/clonearray +{ + dup xcheck exch + dup length array exch + Adobe_AGM_Core/AGMCORE_tmp -1 ddf + { + Adobe_AGM_Core/AGMCORE_tmp 2 copy get 1 add ddf + dup type/dicttype eq + { + Adobe_AGM_Core/AGMCORE_tmp get + exch + clonedict + Adobe_AGM_Core/AGMCORE_tmp 4 -1 roll ddf + }if + dup type/arraytype eq + { + Adobe_AGM_Core/AGMCORE_tmp get exch + clonearray + Adobe_AGM_Core/AGMCORE_tmp 4 -1 roll ddf + }if + exch dup + Adobe_AGM_Core/AGMCORE_tmp get 4 -1 roll put + }forall + exch{cvx}if +}bdf +/clonedict +{ + dup length dict + begin + { + dup type/dicttype eq + {clonedict}if + dup type/arraytype eq + {clonearray}if + def + }forall + currentdict + end +}bdf +/DeviceN_PS2 +{ + /currentcolorspace AGMCORE_gget 0 get/DeviceN eq level3 not and +}bdf +/Indexed_DeviceN +{ + /indexed_colorspace_dict AGMCORE_gget dup null ne{ + dup/CSDBase known{ + /CSDBase get/CSD get_res/Names known + }{ + pop false + }ifelse + }{ + pop false + }ifelse +}bdf +/DeviceN_NoneName +{ + /Names where{ + pop + false Names + { + (None)eq or + }forall + }{ + false + }ifelse +}bdf +/DeviceN_PS2_inRip_seps +{ + /AGMCORE_in_rip_sep where + { + pop dup type dup/arraytype eq exch/packedarraytype eq or + { + dup 0 get/DeviceN eq level3 not and AGMCORE_in_rip_sep and + { + /currentcolorspace exch AGMCORE_gput + false + }{ + true + }ifelse + }{ + true + }ifelse + }{ + true + }ifelse +}bdf +/base_colorspace_type +{ + dup type/arraytype eq{0 get}if +}bdf +/currentdistillerparams where{pop currentdistillerparams/CoreDistVersion get 5000 lt}{true}ifelse +{ + /pdfmark_5{cleartomark}bind def +}{ + /pdfmark_5{pdfmark}bind def +}ifelse +/ReadBypdfmark_5 +{ + currentfile exch 0 exch/SubFileDecode filter + /currentdistillerparams where + {pop currentdistillerparams/CoreDistVersion get 5000 lt}{true}ifelse + {flushfile cleartomark} + {/PUT pdfmark}ifelse +}bdf +/ReadBypdfmark_5_string +{ + 2 dict begin + /makerString exch def string/tmpString exch def + { + currentfile tmpString readline not{pop exit}if + makerString anchorsearch + { + pop pop cleartomark exit + }{ + 3 copy/PUT pdfmark_5 pop 2 copy(\n)/PUT pdfmark_5 + }ifelse + }loop + end +}bdf +/xpdfm +{ + { + dup 0 get/Label eq + { + aload length[exch 1 add 1 roll/PAGELABEL + }{ + aload pop + [{ThisPage}<<5 -2 roll>>/PUT + }ifelse + pdfmark_5 + }forall +}bdf +/lmt{ + dup 2 index le{exch}if pop dup 2 index ge{exch}if pop +}bdf +/int{ + dup 2 index sub 3 index 5 index sub div 6 -2 roll sub mul exch pop add exch pop +}bdf +/ds{ + Adobe_AGM_Utils begin +}bdf +/dt{ + currentdict Adobe_AGM_Utils eq{ + end + }if +}bdf +systemdict/setpacking known +{setpacking}if +%%EndResource +%%BeginResource: procset Adobe_AGM_Core 2.0 0 +%%Version: 2.0 0 +%%Copyright: Copyright(C)1997-2007 Adobe Systems, Inc. All Rights Reserved. +systemdict/setpacking known +{ + currentpacking + true setpacking +}if +userdict/Adobe_AGM_Core 209 dict dup begin put +/Adobe_AGM_Core_Id/Adobe_AGM_Core_2.0_0 def +/AGMCORE_str256 256 string def +/AGMCORE_save nd +/AGMCORE_graphicsave nd +/AGMCORE_c 0 def +/AGMCORE_m 0 def +/AGMCORE_y 0 def +/AGMCORE_k 0 def +/AGMCORE_cmykbuf 4 array def +/AGMCORE_screen[currentscreen]cvx def +/AGMCORE_tmp 0 def +/AGMCORE_&setgray nd +/AGMCORE_&setcolor nd +/AGMCORE_&setcolorspace nd +/AGMCORE_&setcmykcolor nd +/AGMCORE_cyan_plate nd +/AGMCORE_magenta_plate nd +/AGMCORE_yellow_plate nd +/AGMCORE_black_plate nd +/AGMCORE_plate_ndx nd +/AGMCORE_get_ink_data nd +/AGMCORE_is_cmyk_sep nd +/AGMCORE_host_sep nd +/AGMCORE_avoid_L2_sep_space nd +/AGMCORE_distilling nd +/AGMCORE_composite_job nd +/AGMCORE_producing_seps nd +/AGMCORE_ps_level -1 def +/AGMCORE_ps_version -1 def +/AGMCORE_environ_ok nd +/AGMCORE_CSD_cache 0 dict def +/AGMCORE_currentoverprint false def +/AGMCORE_deltaX nd +/AGMCORE_deltaY nd +/AGMCORE_name nd +/AGMCORE_sep_special nd +/AGMCORE_err_strings 4 dict def +/AGMCORE_cur_err nd +/AGMCORE_current_spot_alias false def +/AGMCORE_inverting false def +/AGMCORE_feature_dictCount nd +/AGMCORE_feature_opCount nd +/AGMCORE_feature_ctm nd +/AGMCORE_ConvertToProcess false def +/AGMCORE_Default_CTM matrix def +/AGMCORE_Default_PageSize nd +/AGMCORE_Default_flatness nd +/AGMCORE_currentbg nd +/AGMCORE_currentucr nd +/AGMCORE_pattern_paint_type 0 def +/knockout_unitsq nd +currentglobal true setglobal +[/CSA/Gradient/Procedure] +{ + /Generic/Category findresource dup length dict copy/Category defineresource pop +}forall +setglobal +/AGMCORE_key_known +{ + where{ + /Adobe_AGM_Core_Id known + }{ + false + }ifelse +}ndf +/flushinput +{ + save + 2 dict begin + /CompareBuffer 3 -1 roll def + /readbuffer 256 string def + mark + { + currentfile readbuffer{readline}stopped + {cleartomark mark} + { + not + {pop exit} + if + CompareBuffer eq + {exit} + if + }ifelse + }loop + cleartomark + end + restore +}bdf +/getspotfunction +{ + AGMCORE_screen exch pop exch pop + dup type/dicttype eq{ + dup/HalftoneType get 1 eq{ + /SpotFunction get + }{ + dup/HalftoneType get 2 eq{ + /GraySpotFunction get + }{ + pop + { + abs exch abs 2 copy add 1 gt{ + 1 sub dup mul exch 1 sub dup mul add 1 sub + }{ + dup mul exch dup mul add 1 exch sub + }ifelse + }bind + }ifelse + }ifelse + }if +}def +/np +{newpath}bdf +/clp_npth +{clip np}def +/eoclp_npth +{eoclip np}def +/npth_clp +{np clip}def +/graphic_setup +{ + /AGMCORE_graphicsave save store + concat + 0 setgray + 0 setlinecap + 0 setlinejoin + 1 setlinewidth + []0 setdash + 10 setmiterlimit + np + false setoverprint + false setstrokeadjust + //Adobe_AGM_Core/spot_alias gx + /Adobe_AGM_Image where{ + pop + Adobe_AGM_Image/spot_alias 2 copy known{ + gx + }{ + pop pop + }ifelse + }if + /sep_colorspace_dict null AGMCORE_gput + 100 dict begin + /dictstackcount countdictstack def + /showpage{}def + mark +}def +/graphic_cleanup +{ + cleartomark + dictstackcount 1 countdictstack 1 sub{end}for + end + AGMCORE_graphicsave restore +}def +/compose_error_msg +{ + grestoreall initgraphics + /Helvetica findfont 10 scalefont setfont + /AGMCORE_deltaY 100 def + /AGMCORE_deltaX 310 def + clippath pathbbox np pop pop 36 add exch 36 add exch moveto + 0 AGMCORE_deltaY rlineto AGMCORE_deltaX 0 rlineto + 0 AGMCORE_deltaY neg rlineto AGMCORE_deltaX neg 0 rlineto closepath + 0 AGMCORE_&setgray + gsave 1 AGMCORE_&setgray fill grestore + 1 setlinewidth gsave stroke grestore + currentpoint AGMCORE_deltaY 15 sub add exch 8 add exch moveto + /AGMCORE_deltaY 12 def + /AGMCORE_tmp 0 def + AGMCORE_err_strings exch get + { + dup 32 eq + { + pop + AGMCORE_str256 0 AGMCORE_tmp getinterval + stringwidth pop currentpoint pop add AGMCORE_deltaX 28 add gt + { + currentpoint AGMCORE_deltaY sub exch pop + clippath pathbbox pop pop pop 44 add exch moveto + }if + AGMCORE_str256 0 AGMCORE_tmp getinterval show( )show + 0 1 AGMCORE_str256 length 1 sub + { + AGMCORE_str256 exch 0 put + }for + /AGMCORE_tmp 0 def + }{ + AGMCORE_str256 exch AGMCORE_tmp xpt + /AGMCORE_tmp AGMCORE_tmp 1 add def + }ifelse + }forall +}bdf +/AGMCORE_CMYKDeviceNColorspaces[ + [/Separation/None/DeviceCMYK{0 0 0}] + [/Separation(Black)/DeviceCMYK{0 0 0 4 -1 roll}bind] + [/Separation(Yellow)/DeviceCMYK{0 0 3 -1 roll 0}bind] + [/DeviceN[(Yellow)(Black)]/DeviceCMYK{0 0 4 2 roll}bind] + [/Separation(Magenta)/DeviceCMYK{0 exch 0 0}bind] + [/DeviceN[(Magenta)(Black)]/DeviceCMYK{0 3 1 roll 0 exch}bind] + [/DeviceN[(Magenta)(Yellow)]/DeviceCMYK{0 3 1 roll 0}bind] + [/DeviceN[(Magenta)(Yellow)(Black)]/DeviceCMYK{0 4 1 roll}bind] + [/Separation(Cyan)/DeviceCMYK{0 0 0}] + [/DeviceN[(Cyan)(Black)]/DeviceCMYK{0 0 3 -1 roll}bind] + [/DeviceN[(Cyan)(Yellow)]/DeviceCMYK{0 exch 0}bind] + [/DeviceN[(Cyan)(Yellow)(Black)]/DeviceCMYK{0 3 1 roll}bind] + [/DeviceN[(Cyan)(Magenta)]/DeviceCMYK{0 0}] + [/DeviceN[(Cyan)(Magenta)(Black)]/DeviceCMYK{0 exch}bind] + [/DeviceN[(Cyan)(Magenta)(Yellow)]/DeviceCMYK{0}] + [/DeviceCMYK] +]def +/ds{ + Adobe_AGM_Core begin + /currentdistillerparams where + { + pop currentdistillerparams/CoreDistVersion get 5000 lt + {<>setdistillerparams}if + }if + /AGMCORE_ps_version xdf + /AGMCORE_ps_level xdf + errordict/AGM_handleerror known not{ + errordict/AGM_handleerror errordict/handleerror get put + errordict/handleerror{ + Adobe_AGM_Core begin + $error/newerror get AGMCORE_cur_err null ne and{ + $error/newerror false put + AGMCORE_cur_err compose_error_msg + }if + $error/newerror true put + end + errordict/AGM_handleerror get exec + }bind put + }if + /AGMCORE_environ_ok + ps_level AGMCORE_ps_level ge + ps_version AGMCORE_ps_version ge and + AGMCORE_ps_level -1 eq or + def + AGMCORE_environ_ok not + {/AGMCORE_cur_err/AGMCORE_bad_environ def}if + /AGMCORE_&setgray systemdict/setgray get def + level2{ + /AGMCORE_&setcolor systemdict/setcolor get def + /AGMCORE_&setcolorspace systemdict/setcolorspace get def + }if + /AGMCORE_currentbg currentblackgeneration def + /AGMCORE_currentucr currentundercolorremoval def + /AGMCORE_Default_flatness currentflat def + /AGMCORE_distilling + /product where{ + pop systemdict/setdistillerparams known product(Adobe PostScript Parser)ne and + }{ + false + }ifelse + def + /AGMCORE_GSTATE AGMCORE_key_known not{ + /AGMCORE_GSTATE 21 dict def + /AGMCORE_tmpmatrix matrix def + /AGMCORE_gstack 64 array def + /AGMCORE_gstackptr 0 def + /AGMCORE_gstacksaveptr 0 def + /AGMCORE_gstackframekeys 14 def + /AGMCORE_&gsave/gsave ldf + /AGMCORE_&grestore/grestore ldf + /AGMCORE_&grestoreall/grestoreall ldf + /AGMCORE_&save/save ldf + /AGMCORE_&setoverprint/setoverprint ldf + /AGMCORE_gdictcopy{ + begin + {def}forall + end + }def + /AGMCORE_gput{ + AGMCORE_gstack AGMCORE_gstackptr get + 3 1 roll + put + }def + /AGMCORE_gget{ + AGMCORE_gstack AGMCORE_gstackptr get + exch + get + }def + /gsave{ + AGMCORE_&gsave + AGMCORE_gstack AGMCORE_gstackptr get + AGMCORE_gstackptr 1 add + dup 64 ge{limitcheck}if + /AGMCORE_gstackptr exch store + AGMCORE_gstack AGMCORE_gstackptr get + AGMCORE_gdictcopy + }def + /grestore{ + AGMCORE_&grestore + AGMCORE_gstackptr 1 sub + dup AGMCORE_gstacksaveptr lt{1 add}if + dup AGMCORE_gstack exch get dup/AGMCORE_currentoverprint known + {/AGMCORE_currentoverprint get setoverprint}{pop}ifelse + /AGMCORE_gstackptr exch store + }def + /grestoreall{ + AGMCORE_&grestoreall + /AGMCORE_gstackptr AGMCORE_gstacksaveptr store + }def + /save{ + AGMCORE_&save + AGMCORE_gstack AGMCORE_gstackptr get + AGMCORE_gstackptr 1 add + dup 64 ge{limitcheck}if + /AGMCORE_gstackptr exch store + /AGMCORE_gstacksaveptr AGMCORE_gstackptr store + AGMCORE_gstack AGMCORE_gstackptr get + AGMCORE_gdictcopy + }def + /setoverprint{ + dup/AGMCORE_currentoverprint exch AGMCORE_gput AGMCORE_&setoverprint + }def + 0 1 AGMCORE_gstack length 1 sub{ + AGMCORE_gstack exch AGMCORE_gstackframekeys dict put + }for + }if + level3/AGMCORE_&sysshfill AGMCORE_key_known not and + { + /AGMCORE_&sysshfill systemdict/shfill get def + /AGMCORE_&sysmakepattern systemdict/makepattern get def + /AGMCORE_&usrmakepattern/makepattern load def + }if + /currentcmykcolor[0 0 0 0]AGMCORE_gput + /currentstrokeadjust false AGMCORE_gput + /currentcolorspace[/DeviceGray]AGMCORE_gput + /sep_tint 0 AGMCORE_gput + /devicen_tints[0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0]AGMCORE_gput + /sep_colorspace_dict null AGMCORE_gput + /devicen_colorspace_dict null AGMCORE_gput + /indexed_colorspace_dict null AGMCORE_gput + /currentcolor_intent()AGMCORE_gput + /customcolor_tint 1 AGMCORE_gput + /absolute_colorimetric_crd null AGMCORE_gput + /relative_colorimetric_crd null AGMCORE_gput + /saturation_crd null AGMCORE_gput + /perceptual_crd null AGMCORE_gput + currentcolortransfer cvlit/AGMCore_gray_xfer xdf cvlit/AGMCore_b_xfer xdf + cvlit/AGMCore_g_xfer xdf cvlit/AGMCore_r_xfer xdf + << + /MaxPatternItem currentsystemparams/MaxPatternCache get + >> + setuserparams + end +}def +/ps +{ + /setcmykcolor where{ + pop + Adobe_AGM_Core/AGMCORE_&setcmykcolor/setcmykcolor load put + }if + Adobe_AGM_Core begin + /setcmykcolor + { + 4 copy AGMCORE_cmykbuf astore/currentcmykcolor exch AGMCORE_gput + 1 sub 4 1 roll + 3{ + 3 index add neg dup 0 lt{ + pop 0 + }if + 3 1 roll + }repeat + setrgbcolor pop + }ndf + /currentcmykcolor + { + /currentcmykcolor AGMCORE_gget aload pop + }ndf + /setoverprint + {pop}ndf + /currentoverprint + {false}ndf + /AGMCORE_cyan_plate 1 0 0 0 test_cmyk_color_plate def + /AGMCORE_magenta_plate 0 1 0 0 test_cmyk_color_plate def + /AGMCORE_yellow_plate 0 0 1 0 test_cmyk_color_plate def + /AGMCORE_black_plate 0 0 0 1 test_cmyk_color_plate def + /AGMCORE_plate_ndx + AGMCORE_cyan_plate{ + 0 + }{ + AGMCORE_magenta_plate{ + 1 + }{ + AGMCORE_yellow_plate{ + 2 + }{ + AGMCORE_black_plate{ + 3 + }{ + 4 + }ifelse + }ifelse + }ifelse + }ifelse + def + /AGMCORE_have_reported_unsupported_color_space false def + /AGMCORE_report_unsupported_color_space + { + AGMCORE_have_reported_unsupported_color_space false eq + { + (Warning: Job contains content that cannot be separated with on-host methods. This content appears on the black plate, and knocks out all other plates.)== + Adobe_AGM_Core/AGMCORE_have_reported_unsupported_color_space true ddf + }if + }def + /AGMCORE_composite_job + AGMCORE_cyan_plate AGMCORE_magenta_plate and AGMCORE_yellow_plate and AGMCORE_black_plate and def + /AGMCORE_in_rip_sep + /AGMCORE_in_rip_sep where{ + pop AGMCORE_in_rip_sep + }{ + AGMCORE_distilling + { + false + }{ + userdict/Adobe_AGM_OnHost_Seps known{ + false + }{ + level2{ + currentpagedevice/Separations 2 copy known{ + get + }{ + pop pop false + }ifelse + }{ + false + }ifelse + }ifelse + }ifelse + }ifelse + def + /AGMCORE_producing_seps AGMCORE_composite_job not AGMCORE_in_rip_sep or def + /AGMCORE_host_sep AGMCORE_producing_seps AGMCORE_in_rip_sep not and def + /AGM_preserve_spots + /AGM_preserve_spots where{ + pop AGM_preserve_spots + }{ + AGMCORE_distilling AGMCORE_producing_seps or + }ifelse + def + /AGM_is_distiller_preserving_spotimages + { + currentdistillerparams/PreserveOverprintSettings known + { + currentdistillerparams/PreserveOverprintSettings get + { + currentdistillerparams/ColorConversionStrategy known + { + currentdistillerparams/ColorConversionStrategy get + /sRGB ne + }{ + true + }ifelse + }{ + false + }ifelse + }{ + false + }ifelse + }def + /convert_spot_to_process where{pop}{ + /convert_spot_to_process + { + //Adobe_AGM_Core begin + dup map_alias{ + /Name get exch pop + }if + dup dup(None)eq exch(All)eq or + { + pop false + }{ + AGMCORE_host_sep + { + gsave + 1 0 0 0 setcmykcolor currentgray 1 exch sub + 0 1 0 0 setcmykcolor currentgray 1 exch sub + 0 0 1 0 setcmykcolor currentgray 1 exch sub + 0 0 0 1 setcmykcolor currentgray 1 exch sub + add add add 0 eq + { + pop false + }{ + false setoverprint + current_spot_alias false set_spot_alias + 1 1 1 1 6 -1 roll findcmykcustomcolor 1 setcustomcolor + set_spot_alias + currentgray 1 ne + }ifelse + grestore + }{ + AGMCORE_distilling + { + pop AGM_is_distiller_preserving_spotimages not + }{ + //Adobe_AGM_Core/AGMCORE_name xddf + false + //Adobe_AGM_Core/AGMCORE_pattern_paint_type get 0 eq + AGMUTIL_cpd/OverrideSeparations known and + { + AGMUTIL_cpd/OverrideSeparations get + { + /HqnSpots/ProcSet resourcestatus + { + pop pop pop true + }if + }if + }if + { + AGMCORE_name/HqnSpots/ProcSet findresource/TestSpot gx not + }{ + gsave + [/Separation AGMCORE_name/DeviceGray{}]AGMCORE_&setcolorspace + false + AGMUTIL_cpd/SeparationColorNames 2 copy known + { + get + {AGMCORE_name eq or}forall + not + }{ + pop pop pop true + }ifelse + grestore + }ifelse + }ifelse + }ifelse + }ifelse + end + }def + }ifelse + /convert_to_process where{pop}{ + /convert_to_process + { + dup length 0 eq + { + pop false + }{ + AGMCORE_host_sep + { + dup true exch + { + dup(Cyan)eq exch + dup(Magenta)eq 3 -1 roll or exch + dup(Yellow)eq 3 -1 roll or exch + dup(Black)eq 3 -1 roll or + {pop} + {convert_spot_to_process and}ifelse + } + forall + { + true exch + { + dup(Cyan)eq exch + dup(Magenta)eq 3 -1 roll or exch + dup(Yellow)eq 3 -1 roll or exch + (Black)eq or and + }forall + not + }{pop false}ifelse + }{ + false exch + { + /PhotoshopDuotoneList where{pop false}{true}ifelse + { + dup(Cyan)eq exch + dup(Magenta)eq 3 -1 roll or exch + dup(Yellow)eq 3 -1 roll or exch + dup(Black)eq 3 -1 roll or + {pop} + {convert_spot_to_process or}ifelse + } + { + convert_spot_to_process or + } + ifelse + } + forall + }ifelse + }ifelse + }def + }ifelse + /AGMCORE_avoid_L2_sep_space + version cvr 2012 lt + level2 and + AGMCORE_producing_seps not and + def + /AGMCORE_is_cmyk_sep + AGMCORE_cyan_plate AGMCORE_magenta_plate or AGMCORE_yellow_plate or AGMCORE_black_plate or + def + /AGM_avoid_0_cmyk where{ + pop AGM_avoid_0_cmyk + }{ + AGM_preserve_spots + userdict/Adobe_AGM_OnHost_Seps known + userdict/Adobe_AGM_InRip_Seps known or + not and + }ifelse + { + /setcmykcolor[ + { + 4 copy add add add 0 eq currentoverprint and{ + pop 0.0005 + }if + }/exec cvx + /AGMCORE_&setcmykcolor load dup type/operatortype ne{ + /exec cvx + }if + ]cvx def + }if + /AGMCORE_IsSeparationAProcessColor + { + dup(Cyan)eq exch dup(Magenta)eq exch dup(Yellow)eq exch(Black)eq or or or + }def + AGMCORE_host_sep{ + /setcolortransfer + { + AGMCORE_cyan_plate{ + pop pop pop + }{ + AGMCORE_magenta_plate{ + 4 3 roll pop pop pop + }{ + AGMCORE_yellow_plate{ + 4 2 roll pop pop pop + }{ + 4 1 roll pop pop pop + }ifelse + }ifelse + }ifelse + settransfer + } + def + /AGMCORE_get_ink_data + AGMCORE_cyan_plate{ + {pop pop pop} + }{ + AGMCORE_magenta_plate{ + {4 3 roll pop pop pop} + }{ + AGMCORE_yellow_plate{ + {4 2 roll pop pop pop} + }{ + {4 1 roll pop pop pop} + }ifelse + }ifelse + }ifelse + def + /AGMCORE_RemoveProcessColorNames + { + 1 dict begin + /filtername + { + dup/Cyan eq 1 index(Cyan)eq or + {pop(_cyan_)}if + dup/Magenta eq 1 index(Magenta)eq or + {pop(_magenta_)}if + dup/Yellow eq 1 index(Yellow)eq or + {pop(_yellow_)}if + dup/Black eq 1 index(Black)eq or + {pop(_black_)}if + }def + dup type/arraytype eq + {[exch{filtername}forall]} + {filtername}ifelse + end + }def + level3{ + /AGMCORE_IsCurrentColor + { + dup AGMCORE_IsSeparationAProcessColor + { + AGMCORE_plate_ndx 0 eq + {dup(Cyan)eq exch/Cyan eq or}if + AGMCORE_plate_ndx 1 eq + {dup(Magenta)eq exch/Magenta eq or}if + AGMCORE_plate_ndx 2 eq + {dup(Yellow)eq exch/Yellow eq or}if + AGMCORE_plate_ndx 3 eq + {dup(Black)eq exch/Black eq or}if + AGMCORE_plate_ndx 4 eq + {pop false}if + }{ + gsave + false setoverprint + current_spot_alias false set_spot_alias + 1 1 1 1 6 -1 roll findcmykcustomcolor 1 setcustomcolor + set_spot_alias + currentgray 1 ne + grestore + }ifelse + }def + /AGMCORE_filter_functiondatasource + { + 5 dict begin + /data_in xdf + data_in type/stringtype eq + { + /ncomp xdf + /comp xdf + /string_out data_in length ncomp idiv string def + 0 ncomp data_in length 1 sub + { + string_out exch dup ncomp idiv exch data_in exch ncomp getinterval comp get 255 exch sub put + }for + string_out + }{ + string/string_in xdf + /string_out 1 string def + /component xdf + [ + data_in string_in/readstring cvx + [component/get cvx 255/exch cvx/sub cvx string_out/exch cvx 0/exch cvx/put cvx string_out]cvx + [/pop cvx()]cvx/ifelse cvx + ]cvx/ReusableStreamDecode filter + }ifelse + end + }def + /AGMCORE_separateShadingFunction + { + 2 dict begin + /paint? xdf + /channel xdf + dup type/dicttype eq + { + begin + FunctionType 0 eq + { + /DataSource channel Range length 2 idiv DataSource AGMCORE_filter_functiondatasource def + currentdict/Decode known + {/Decode Decode channel 2 mul 2 getinterval def}if + paint? not + {/Decode[1 1]def}if + }if + FunctionType 2 eq + { + paint? + { + /C0[C0 channel get 1 exch sub]def + /C1[C1 channel get 1 exch sub]def + }{ + /C0[1]def + /C1[1]def + }ifelse + }if + FunctionType 3 eq + { + /Functions[Functions{channel paint? AGMCORE_separateShadingFunction}forall]def + }if + currentdict/Range known + {/Range[0 1]def}if + currentdict + end}{ + channel get 0 paint? AGMCORE_separateShadingFunction + }ifelse + end + }def + /AGMCORE_separateShading + { + 3 -1 roll begin + currentdict/Function known + { + currentdict/Background known + {[1 index{Background 3 index get 1 exch sub}{1}ifelse]/Background xdf}if + Function 3 1 roll AGMCORE_separateShadingFunction/Function xdf + /ColorSpace[/DeviceGray]def + }{ + ColorSpace dup type/arraytype eq{0 get}if/DeviceCMYK eq + { + /ColorSpace[/DeviceN[/_cyan_/_magenta_/_yellow_/_black_]/DeviceCMYK{}]def + }{ + ColorSpace dup 1 get AGMCORE_RemoveProcessColorNames 1 exch put + }ifelse + ColorSpace 0 get/Separation eq + { + { + [1/exch cvx/sub cvx]cvx + }{ + [/pop cvx 1]cvx + }ifelse + ColorSpace 3 3 -1 roll put + pop + }{ + { + [exch ColorSpace 1 get length 1 sub exch sub/index cvx 1/exch cvx/sub cvx ColorSpace 1 get length 1 add 1/roll cvx ColorSpace 1 get length{/pop cvx}repeat]cvx + }{ + pop[ColorSpace 1 get length{/pop cvx}repeat cvx 1]cvx + }ifelse + ColorSpace 3 3 -1 roll bind put + }ifelse + ColorSpace 2/DeviceGray put + }ifelse + end + }def + /AGMCORE_separateShadingDict + { + dup/ColorSpace get + dup type/arraytype ne + {[exch]}if + dup 0 get/DeviceCMYK eq + { + exch begin + currentdict + AGMCORE_cyan_plate + {0 true}if + AGMCORE_magenta_plate + {1 true}if + AGMCORE_yellow_plate + {2 true}if + AGMCORE_black_plate + {3 true}if + AGMCORE_plate_ndx 4 eq + {0 false}if + dup not currentoverprint and + {/AGMCORE_ignoreshade true def}if + AGMCORE_separateShading + currentdict + end exch + }if + dup 0 get/Separation eq + { + exch begin + ColorSpace 1 get dup/None ne exch/All ne and + { + ColorSpace 1 get AGMCORE_IsCurrentColor AGMCORE_plate_ndx 4 lt and ColorSpace 1 get AGMCORE_IsSeparationAProcessColor not and + { + ColorSpace 2 get dup type/arraytype eq{0 get}if/DeviceCMYK eq + { + /ColorSpace + [ + /Separation + ColorSpace 1 get + /DeviceGray + [ + ColorSpace 3 get/exec cvx + 4 AGMCORE_plate_ndx sub -1/roll cvx + 4 1/roll cvx + 3[/pop cvx]cvx/repeat cvx + 1/exch cvx/sub cvx + ]cvx + ]def + }{ + AGMCORE_report_unsupported_color_space + AGMCORE_black_plate not + { + currentdict 0 false AGMCORE_separateShading + }if + }ifelse + }{ + currentdict ColorSpace 1 get AGMCORE_IsCurrentColor + 0 exch + dup not currentoverprint and + {/AGMCORE_ignoreshade true def}if + AGMCORE_separateShading + }ifelse + }if + currentdict + end exch + }if + dup 0 get/DeviceN eq + { + exch begin + ColorSpace 1 get convert_to_process + { + ColorSpace 2 get dup type/arraytype eq{0 get}if/DeviceCMYK eq + { + /ColorSpace + [ + /DeviceN + ColorSpace 1 get + /DeviceGray + [ + ColorSpace 3 get/exec cvx + 4 AGMCORE_plate_ndx sub -1/roll cvx + 4 1/roll cvx + 3[/pop cvx]cvx/repeat cvx + 1/exch cvx/sub cvx + ]cvx + ]def + }{ + AGMCORE_report_unsupported_color_space + AGMCORE_black_plate not + { + currentdict 0 false AGMCORE_separateShading + /ColorSpace[/DeviceGray]def + }if + }ifelse + }{ + currentdict + false -1 ColorSpace 1 get + { + AGMCORE_IsCurrentColor + { + 1 add + exch pop true exch exit + }if + 1 add + }forall + exch + dup not currentoverprint and + {/AGMCORE_ignoreshade true def}if + AGMCORE_separateShading + }ifelse + currentdict + end exch + }if + dup 0 get dup/DeviceCMYK eq exch dup/Separation eq exch/DeviceN eq or or not + { + exch begin + ColorSpace dup type/arraytype eq + {0 get}if + /DeviceGray ne + { + AGMCORE_report_unsupported_color_space + AGMCORE_black_plate not + { + ColorSpace 0 get/CIEBasedA eq + { + /ColorSpace[/Separation/_ciebaseda_/DeviceGray{}]def + }if + ColorSpace 0 get dup/CIEBasedABC eq exch dup/CIEBasedDEF eq exch/DeviceRGB eq or or + { + /ColorSpace[/DeviceN[/_red_/_green_/_blue_]/DeviceRGB{}]def + }if + ColorSpace 0 get/CIEBasedDEFG eq + { + /ColorSpace[/DeviceN[/_cyan_/_magenta_/_yellow_/_black_]/DeviceCMYK{}]def + }if + currentdict 0 false AGMCORE_separateShading + }if + }if + currentdict + end exch + }if + pop + dup/AGMCORE_ignoreshade known + { + begin + /ColorSpace[/Separation(None)/DeviceGray{}]def + currentdict end + }if + }def + /shfill + { + AGMCORE_separateShadingDict + dup/AGMCORE_ignoreshade known + {pop} + {AGMCORE_&sysshfill}ifelse + }def + /makepattern + { + exch + dup/PatternType get 2 eq + { + clonedict + begin + /Shading Shading AGMCORE_separateShadingDict def + Shading/AGMCORE_ignoreshade known + currentdict end exch + {pop<>}if + exch AGMCORE_&sysmakepattern + }{ + exch AGMCORE_&usrmakepattern + }ifelse + }def + }if + }if + AGMCORE_in_rip_sep{ + /setcustomcolor + { + exch aload pop + dup 7 1 roll inRip_spot_has_ink not { + 4{4 index mul 4 1 roll} + repeat + /DeviceCMYK setcolorspace + 6 -2 roll pop pop + }{ + //Adobe_AGM_Core begin + /AGMCORE_k xdf/AGMCORE_y xdf/AGMCORE_m xdf/AGMCORE_c xdf + end + [/Separation 4 -1 roll/DeviceCMYK + {dup AGMCORE_c mul exch dup AGMCORE_m mul exch dup AGMCORE_y mul exch AGMCORE_k mul} + ] + setcolorspace + }ifelse + setcolor + }ndf + /setseparationgray + { + [/Separation(All)/DeviceGray{}]setcolorspace_opt + 1 exch sub setcolor + }ndf + }{ + /setseparationgray + { + AGMCORE_&setgray + }ndf + }ifelse + /findcmykcustomcolor + { + 5 makereadonlyarray + }ndf + /setcustomcolor + { + exch aload pop pop + 4{4 index mul 4 1 roll}repeat + setcmykcolor pop + }ndf + /has_color + /colorimage where{ + AGMCORE_producing_seps{ + pop true + }{ + systemdict eq + }ifelse + }{ + false + }ifelse + def + /map_index + { + 1 index mul exch getinterval{255 div}forall + }bdf + /map_indexed_devn + { + Lookup Names length 3 -1 roll cvi map_index + }bdf + /n_color_components + { + base_colorspace_type + dup/DeviceGray eq{ + pop 1 + }{ + /DeviceCMYK eq{ + 4 + }{ + 3 + }ifelse + }ifelse + }bdf + level2{ + /mo/moveto ldf + /li/lineto ldf + /cv/curveto ldf + /knockout_unitsq + { + 1 setgray + 0 0 1 1 rectfill + }def + level2/setcolorspace AGMCORE_key_known not and{ + /AGMCORE_&&&setcolorspace/setcolorspace ldf + /AGMCORE_ReplaceMappedColor + { + dup type dup/arraytype eq exch/packedarraytype eq or + { + /AGMCORE_SpotAliasAry2 where{ + begin + dup 0 get dup/Separation eq + { + pop + dup length array copy + dup dup 1 get + current_spot_alias + { + dup map_alias + { + false set_spot_alias + dup 1 exch setsepcolorspace + true set_spot_alias + begin + /sep_colorspace_dict currentdict AGMCORE_gput + pop pop pop + [ + /Separation Name + CSA map_csa + MappedCSA + /sep_colorspace_proc load + ] + dup Name + end + }if + }if + map_reserved_ink_name 1 xpt + }{ + /DeviceN eq + { + dup length array copy + dup dup 1 get[ + exch{ + current_spot_alias{ + dup map_alias{ + /Name get exch pop + }if + }if + map_reserved_ink_name + }forall + ]1 xpt + }if + }ifelse + end + }if + }if + }def + /setcolorspace + { + dup type dup/arraytype eq exch/packedarraytype eq or + { + dup 0 get/Indexed eq + { + AGMCORE_distilling + { + /PhotoshopDuotoneList where + { + pop false + }{ + true + }ifelse + }{ + true + }ifelse + { + aload pop 3 -1 roll + AGMCORE_ReplaceMappedColor + 3 1 roll 4 array astore + }if + }{ + AGMCORE_ReplaceMappedColor + }ifelse + }if + DeviceN_PS2_inRip_seps{AGMCORE_&&&setcolorspace}if + }def + }if + }{ + /adj + { + currentstrokeadjust{ + transform + 0.25 sub round 0.25 add exch + 0.25 sub round 0.25 add exch + itransform + }if + }def + /mo{ + adj moveto + }def + /li{ + adj lineto + }def + /cv{ + 6 2 roll adj + 6 2 roll adj + 6 2 roll adj curveto + }def + /knockout_unitsq + { + 1 setgray + 8 8 1[8 0 0 8 0 0]{}image + }def + /currentstrokeadjust{ + /currentstrokeadjust AGMCORE_gget + }def + /setstrokeadjust{ + /currentstrokeadjust exch AGMCORE_gput + }def + /setcolorspace + { + /currentcolorspace exch AGMCORE_gput + }def + /currentcolorspace + { + /currentcolorspace AGMCORE_gget + }def + /setcolor_devicecolor + { + base_colorspace_type + dup/DeviceGray eq{ + pop setgray + }{ + /DeviceCMYK eq{ + setcmykcolor + }{ + setrgbcolor + }ifelse + }ifelse + }def + /setcolor + { + currentcolorspace 0 get + dup/DeviceGray ne{ + dup/DeviceCMYK ne{ + dup/DeviceRGB ne{ + dup/Separation eq{ + pop + currentcolorspace 3 gx + currentcolorspace 2 get + }{ + dup/Indexed eq{ + pop + currentcolorspace 3 get dup type/stringtype eq{ + currentcolorspace 1 get n_color_components + 3 -1 roll map_index + }{ + exec + }ifelse + currentcolorspace 1 get + }{ + /AGMCORE_cur_err/AGMCORE_invalid_color_space def + AGMCORE_invalid_color_space + }ifelse + }ifelse + }if + }if + }if + setcolor_devicecolor + }def + }ifelse + /sop/setoverprint ldf + /lw/setlinewidth ldf + /lc/setlinecap ldf + /lj/setlinejoin ldf + /ml/setmiterlimit ldf + /dsh/setdash ldf + /sadj/setstrokeadjust ldf + /gry/setgray ldf + /rgb/setrgbcolor ldf + /cmyk[ + /currentcolorspace[/DeviceCMYK]/AGMCORE_gput cvx + /setcmykcolor load dup type/operatortype ne{/exec cvx}if + ]cvx bdf + level3 AGMCORE_host_sep not and{ + /nzopmsc{ + 6 dict begin + /kk exch def + /yy exch def + /mm exch def + /cc exch def + /sum 0 def + cc 0 ne{/sum sum 2#1000 or def cc}if + mm 0 ne{/sum sum 2#0100 or def mm}if + yy 0 ne{/sum sum 2#0010 or def yy}if + kk 0 ne{/sum sum 2#0001 or def kk}if + AGMCORE_CMYKDeviceNColorspaces sum get setcolorspace + sum 0 eq{0}if + end + setcolor + }bdf + }{ + /nzopmsc/cmyk ldf + }ifelse + /sep/setsepcolor ldf + /devn/setdevicencolor ldf + /idx/setindexedcolor ldf + /colr/setcolor ldf + /csacrd/set_csa_crd ldf + /sepcs/setsepcolorspace ldf + /devncs/setdevicencolorspace ldf + /idxcs/setindexedcolorspace ldf + /cp/closepath ldf + /clp/clp_npth ldf + /eclp/eoclp_npth ldf + /f/fill ldf + /ef/eofill ldf + /@/stroke ldf + /nclp/npth_clp ldf + /gset/graphic_setup ldf + /gcln/graphic_cleanup ldf + /ct/concat ldf + /cf/currentfile ldf + /fl/filter ldf + /rs/readstring ldf + /AGMCORE_def_ht currenthalftone def + /clonedict Adobe_AGM_Utils begin/clonedict load end def + /clonearray Adobe_AGM_Utils begin/clonearray load end def + currentdict{ + dup xcheck 1 index type dup/arraytype eq exch/packedarraytype eq or and{ + bind + }if + def + }forall + /getrampcolor + { + /indx exch def + 0 1 NumComp 1 sub + { + dup + Samples exch get + dup type/stringtype eq{indx get}if + exch + Scaling exch get aload pop + 3 1 roll + mul add + }for + ColorSpaceFamily/Separation eq + {sep} + { + ColorSpaceFamily/DeviceN eq + {devn}{setcolor}ifelse + }ifelse + }bdf + /sssetbackground{ + aload pop + ColorSpaceFamily/Separation eq + {sep} + { + ColorSpaceFamily/DeviceN eq + {devn}{setcolor}ifelse + }ifelse + }bdf + /RadialShade + { + 40 dict begin + /ColorSpaceFamily xdf + /background xdf + /ext1 xdf + /ext0 xdf + /BBox xdf + /r2 xdf + /c2y xdf + /c2x xdf + /r1 xdf + /c1y xdf + /c1x xdf + /rampdict xdf + /setinkoverprint where{pop/setinkoverprint{pop}def}if + gsave + BBox length 0 gt + { + np + BBox 0 get BBox 1 get moveto + BBox 2 get BBox 0 get sub 0 rlineto + 0 BBox 3 get BBox 1 get sub rlineto + BBox 2 get BBox 0 get sub neg 0 rlineto + closepath + clip + np + }if + c1x c2x eq + { + c1y c2y lt{/theta 90 def}{/theta 270 def}ifelse + }{ + /slope c2y c1y sub c2x c1x sub div def + /theta slope 1 atan def + c2x c1x lt c2y c1y ge and{/theta theta 180 sub def}if + c2x c1x lt c2y c1y lt and{/theta theta 180 add def}if + }ifelse + gsave + clippath + c1x c1y translate + theta rotate + -90 rotate + {pathbbox}stopped + {0 0 0 0}if + /yMax xdf + /xMax xdf + /yMin xdf + /xMin xdf + grestore + xMax xMin eq yMax yMin eq or + { + grestore + end + }{ + /max{2 copy gt{pop}{exch pop}ifelse}bdf + /min{2 copy lt{pop}{exch pop}ifelse}bdf + rampdict begin + 40 dict begin + background length 0 gt{background sssetbackground gsave clippath fill grestore}if + gsave + c1x c1y translate + theta rotate + -90 rotate + /c2y c1x c2x sub dup mul c1y c2y sub dup mul add sqrt def + /c1y 0 def + /c1x 0 def + /c2x 0 def + ext0 + { + 0 getrampcolor + c2y r2 add r1 sub 0.0001 lt + { + c1x c1y r1 360 0 arcn + pathbbox + /aymax exch def + /axmax exch def + /aymin exch def + /axmin exch def + /bxMin xMin axmin min def + /byMin yMin aymin min def + /bxMax xMax axmax max def + /byMax yMax aymax max def + bxMin byMin moveto + bxMax byMin lineto + bxMax byMax lineto + bxMin byMax lineto + bxMin byMin lineto + eofill + }{ + c2y r1 add r2 le + { + c1x c1y r1 0 360 arc + fill + } + { + c2x c2y r2 0 360 arc fill + r1 r2 eq + { + /p1x r1 neg def + /p1y c1y def + /p2x r1 def + /p2y c1y def + p1x p1y moveto p2x p2y lineto p2x yMin lineto p1x yMin lineto + fill + }{ + /AA r2 r1 sub c2y div def + AA -1 eq + {/theta 89.99 def} + {/theta AA 1 AA dup mul sub sqrt div 1 atan def} + ifelse + /SS1 90 theta add dup sin exch cos div def + /p1x r1 SS1 SS1 mul SS1 SS1 mul 1 add div sqrt mul neg def + /p1y p1x SS1 div neg def + /SS2 90 theta sub dup sin exch cos div def + /p2x r1 SS2 SS2 mul SS2 SS2 mul 1 add div sqrt mul def + /p2y p2x SS2 div neg def + r1 r2 gt + { + /L1maxX p1x yMin p1y sub SS1 div add def + /L2maxX p2x yMin p2y sub SS2 div add def + }{ + /L1maxX 0 def + /L2maxX 0 def + }ifelse + p1x p1y moveto p2x p2y lineto L2maxX L2maxX p2x sub SS2 mul p2y add lineto + L1maxX L1maxX p1x sub SS1 mul p1y add lineto + fill + }ifelse + }ifelse + }ifelse + }if + c1x c2x sub dup mul + c1y c2y sub dup mul + add 0.5 exp + 0 dtransform + dup mul exch dup mul add 0.5 exp 72 div + 0 72 matrix defaultmatrix dtransform dup mul exch dup mul add sqrt + 72 0 matrix defaultmatrix dtransform dup mul exch dup mul add sqrt + 1 index 1 index lt{exch}if pop + /hires xdf + hires mul + /numpix xdf + /numsteps NumSamples def + /rampIndxInc 1 def + /subsampling false def + numpix 0 ne + { + NumSamples numpix div 0.5 gt + { + /numsteps numpix 2 div round cvi dup 1 le{pop 2}if def + /rampIndxInc NumSamples 1 sub numsteps div def + /subsampling true def + }if + }if + /xInc c2x c1x sub numsteps div def + /yInc c2y c1y sub numsteps div def + /rInc r2 r1 sub numsteps div def + /cx c1x def + /cy c1y def + /radius r1 def + np + xInc 0 eq yInc 0 eq rInc 0 eq and and + { + 0 getrampcolor + cx cy radius 0 360 arc + stroke + NumSamples 1 sub getrampcolor + cx cy radius 72 hires div add 0 360 arc + 0 setlinewidth + stroke + }{ + 0 + numsteps + { + dup + subsampling{round cvi}if + getrampcolor + cx cy radius 0 360 arc + /cx cx xInc add def + /cy cy yInc add def + /radius radius rInc add def + cx cy radius 360 0 arcn + eofill + rampIndxInc add + }repeat + pop + }ifelse + ext1 + { + c2y r2 add r1 lt + { + c2x c2y r2 0 360 arc + fill + }{ + c2y r1 add r2 sub 0.0001 le + { + c2x c2y r2 360 0 arcn + pathbbox + /aymax exch def + /axmax exch def + /aymin exch def + /axmin exch def + /bxMin xMin axmin min def + /byMin yMin aymin min def + /bxMax xMax axmax max def + /byMax yMax aymax max def + bxMin byMin moveto + bxMax byMin lineto + bxMax byMax lineto + bxMin byMax lineto + bxMin byMin lineto + eofill + }{ + c2x c2y r2 0 360 arc fill + r1 r2 eq + { + /p1x r2 neg def + /p1y c2y def + /p2x r2 def + /p2y c2y def + p1x p1y moveto p2x p2y lineto p2x yMax lineto p1x yMax lineto + fill + }{ + /AA r2 r1 sub c2y div def + AA -1 eq + {/theta 89.99 def} + {/theta AA 1 AA dup mul sub sqrt div 1 atan def} + ifelse + /SS1 90 theta add dup sin exch cos div def + /p1x r2 SS1 SS1 mul SS1 SS1 mul 1 add div sqrt mul neg def + /p1y c2y p1x SS1 div sub def + /SS2 90 theta sub dup sin exch cos div def + /p2x r2 SS2 SS2 mul SS2 SS2 mul 1 add div sqrt mul def + /p2y c2y p2x SS2 div sub def + r1 r2 lt + { + /L1maxX p1x yMax p1y sub SS1 div add def + /L2maxX p2x yMax p2y sub SS2 div add def + }{ + /L1maxX 0 def + /L2maxX 0 def + }ifelse + p1x p1y moveto p2x p2y lineto L2maxX L2maxX p2x sub SS2 mul p2y add lineto + L1maxX L1maxX p1x sub SS1 mul p1y add lineto + fill + }ifelse + }ifelse + }ifelse + }if + grestore + grestore + end + end + end + }ifelse + }bdf + /GenStrips + { + 40 dict begin + /ColorSpaceFamily xdf + /background xdf + /ext1 xdf + /ext0 xdf + /BBox xdf + /y2 xdf + /x2 xdf + /y1 xdf + /x1 xdf + /rampdict xdf + /setinkoverprint where{pop/setinkoverprint{pop}def}if + gsave + BBox length 0 gt + { + np + BBox 0 get BBox 1 get moveto + BBox 2 get BBox 0 get sub 0 rlineto + 0 BBox 3 get BBox 1 get sub rlineto + BBox 2 get BBox 0 get sub neg 0 rlineto + closepath + clip + np + }if + x1 x2 eq + { + y1 y2 lt{/theta 90 def}{/theta 270 def}ifelse + }{ + /slope y2 y1 sub x2 x1 sub div def + /theta slope 1 atan def + x2 x1 lt y2 y1 ge and{/theta theta 180 sub def}if + x2 x1 lt y2 y1 lt and{/theta theta 180 add def}if + } + ifelse + gsave + clippath + x1 y1 translate + theta rotate + {pathbbox}stopped + {0 0 0 0}if + /yMax exch def + /xMax exch def + /yMin exch def + /xMin exch def + grestore + xMax xMin eq yMax yMin eq or + { + grestore + end + }{ + rampdict begin + 20 dict begin + background length 0 gt{background sssetbackground gsave clippath fill grestore}if + gsave + x1 y1 translate + theta rotate + /xStart 0 def + /xEnd x2 x1 sub dup mul y2 y1 sub dup mul add 0.5 exp def + /ySpan yMax yMin sub def + /numsteps NumSamples def + /rampIndxInc 1 def + /subsampling false def + xStart 0 transform + xEnd 0 transform + 3 -1 roll + sub dup mul + 3 1 roll + sub dup mul + add 0.5 exp 72 div + 0 72 matrix defaultmatrix dtransform dup mul exch dup mul add sqrt + 72 0 matrix defaultmatrix dtransform dup mul exch dup mul add sqrt + 1 index 1 index lt{exch}if pop + mul + /numpix xdf + numpix 0 ne + { + NumSamples numpix div 0.5 gt + { + /numsteps numpix 2 div round cvi dup 1 le{pop 2}if def + /rampIndxInc NumSamples 1 sub numsteps div def + /subsampling true def + }if + }if + ext0 + { + 0 getrampcolor + xMin xStart lt + { + xMin yMin xMin neg ySpan rectfill + }if + }if + /xInc xEnd xStart sub numsteps div def + /x xStart def + 0 + numsteps + { + dup + subsampling{round cvi}if + getrampcolor + x yMin xInc ySpan rectfill + /x x xInc add def + rampIndxInc add + }repeat + pop + ext1{ + xMax xEnd gt + { + xEnd yMin xMax xEnd sub ySpan rectfill + }if + }if + grestore + grestore + end + end + end + }ifelse + }bdf +}def +/pt +{ + end +}def +/dt{ +}def +/pgsv{ + //Adobe_AGM_Core/AGMCORE_save save put +}def +/pgrs{ + //Adobe_AGM_Core/AGMCORE_save get restore +}def +systemdict/findcolorrendering known{ + /findcolorrendering systemdict/findcolorrendering get def +}if +systemdict/setcolorrendering known{ + /setcolorrendering systemdict/setcolorrendering get def +}if +/test_cmyk_color_plate +{ + gsave + setcmykcolor currentgray 1 ne + grestore +}def +/inRip_spot_has_ink +{ + dup//Adobe_AGM_Core/AGMCORE_name xddf + convert_spot_to_process not +}def +/map255_to_range +{ + 1 index sub + 3 -1 roll 255 div mul add +}def +/set_csa_crd +{ + /sep_colorspace_dict null AGMCORE_gput + begin + CSA get_csa_by_name setcolorspace_opt + set_crd + end +} +def +/map_csa +{ + currentdict/MappedCSA known{MappedCSA null ne}{false}ifelse + {pop}{get_csa_by_name/MappedCSA xdf}ifelse +}def +/setsepcolor +{ + /sep_colorspace_dict AGMCORE_gget begin + dup/sep_tint exch AGMCORE_gput + TintProc + end +}def +/setdevicencolor +{ + /devicen_colorspace_dict AGMCORE_gget begin + Names length copy + Names length 1 sub -1 0 + { + /devicen_tints AGMCORE_gget 3 1 roll xpt + }for + TintProc + end +}def +/sep_colorspace_proc +{ + /AGMCORE_tmp exch store + /sep_colorspace_dict AGMCORE_gget begin + currentdict/Components known{ + Components aload pop + TintMethod/Lab eq{ + 2{AGMCORE_tmp mul NComponents 1 roll}repeat + LMax sub AGMCORE_tmp mul LMax add NComponents 1 roll + }{ + TintMethod/Subtractive eq{ + NComponents{ + AGMCORE_tmp mul NComponents 1 roll + }repeat + }{ + NComponents{ + 1 sub AGMCORE_tmp mul 1 add NComponents 1 roll + }repeat + }ifelse + }ifelse + }{ + ColorLookup AGMCORE_tmp ColorLookup length 1 sub mul round cvi get + aload pop + }ifelse + end +}def +/sep_colorspace_gray_proc +{ + /AGMCORE_tmp exch store + /sep_colorspace_dict AGMCORE_gget begin + GrayLookup AGMCORE_tmp GrayLookup length 1 sub mul round cvi get + end +}def +/sep_proc_name +{ + dup 0 get + dup/DeviceRGB eq exch/DeviceCMYK eq or level2 not and has_color not and{ + pop[/DeviceGray] + /sep_colorspace_gray_proc + }{ + /sep_colorspace_proc + }ifelse +}def +/setsepcolorspace +{ + current_spot_alias{ + dup begin + Name map_alias{ + exch pop + }if + end + }if + dup/sep_colorspace_dict exch AGMCORE_gput + begin + CSA map_csa + /AGMCORE_sep_special Name dup()eq exch(All)eq or store + AGMCORE_avoid_L2_sep_space{ + [/Indexed MappedCSA sep_proc_name 255 exch + {255 div}/exec cvx 3 -1 roll[4 1 roll load/exec cvx]cvx + ]setcolorspace_opt + /TintProc{ + 255 mul round cvi setcolor + }bdf + }{ + MappedCSA 0 get/DeviceCMYK eq + currentdict/Components known and + AGMCORE_sep_special not and{ + /TintProc[ + Components aload pop Name findcmykcustomcolor + /exch cvx/setcustomcolor cvx + ]cvx bdf + }{ + AGMCORE_host_sep Name(All)eq and{ + /TintProc{ + 1 exch sub setseparationgray + }bdf + }{ + AGMCORE_in_rip_sep MappedCSA 0 get/DeviceCMYK eq and + AGMCORE_host_sep or + Name()eq and{ + /TintProc[ + MappedCSA sep_proc_name exch 0 get/DeviceCMYK eq{ + cvx/setcmykcolor cvx + }{ + cvx/setgray cvx + }ifelse + ]cvx bdf + }{ + AGMCORE_producing_seps MappedCSA 0 get dup/DeviceCMYK eq exch/DeviceGray eq or and AGMCORE_sep_special not and{ + /TintProc[ + /dup cvx + MappedCSA sep_proc_name cvx exch + 0 get/DeviceGray eq{ + 1/exch cvx/sub cvx 0 0 0 4 -1/roll cvx + }if + /Name cvx/findcmykcustomcolor cvx/exch cvx + AGMCORE_host_sep{ + AGMCORE_is_cmyk_sep + /Name cvx + /AGMCORE_IsSeparationAProcessColor load/exec cvx + /not cvx/and cvx + }{ + Name inRip_spot_has_ink not + }ifelse + [ + /pop cvx 1 + ]cvx/if cvx + /setcustomcolor cvx + ]cvx bdf + }{ + /TintProc{setcolor}bdf + [/Separation Name MappedCSA sep_proc_name load]setcolorspace_opt + }ifelse + }ifelse + }ifelse + }ifelse + }ifelse + set_crd + setsepcolor + end +}def +/additive_blend +{ + 3 dict begin + /numarrays xdf + /numcolors xdf + 0 1 numcolors 1 sub + { + /c1 xdf + 1 + 0 1 numarrays 1 sub + { + 1 exch add/index cvx + c1/get cvx/mul cvx + }for + numarrays 1 add 1/roll cvx + }for + numarrays[/pop cvx]cvx/repeat cvx + end +}def +/subtractive_blend +{ + 3 dict begin + /numarrays xdf + /numcolors xdf + 0 1 numcolors 1 sub + { + /c1 xdf + 1 1 + 0 1 numarrays 1 sub + { + 1 3 3 -1 roll add/index cvx + c1/get cvx/sub cvx/mul cvx + }for + /sub cvx + numarrays 1 add 1/roll cvx + }for + numarrays[/pop cvx]cvx/repeat cvx + end +}def +/exec_tint_transform +{ + /TintProc[ + /TintTransform cvx/setcolor cvx + ]cvx bdf + MappedCSA setcolorspace_opt +}bdf +/devn_makecustomcolor +{ + 2 dict begin + /names_index xdf + /Names xdf + 1 1 1 1 Names names_index get findcmykcustomcolor + /devicen_tints AGMCORE_gget names_index get setcustomcolor + Names length{pop}repeat + end +}bdf +/setdevicencolorspace +{ + dup/AliasedColorants known{false}{true}ifelse + current_spot_alias and{ + 7 dict begin + /names_index 0 def + dup/names_len exch/Names get length def + /new_names names_len array def + /new_LookupTables names_len array def + /alias_cnt 0 def + dup/Names get + { + dup map_alias{ + exch pop + dup/ColorLookup known{ + dup begin + new_LookupTables names_index ColorLookup put + end + }{ + dup/Components known{ + dup begin + new_LookupTables names_index Components put + end + }{ + dup begin + new_LookupTables names_index[null null null null]put + end + }ifelse + }ifelse + new_names names_index 3 -1 roll/Name get put + /alias_cnt alias_cnt 1 add def + }{ + /name xdf + new_names names_index name put + dup/LookupTables known{ + dup begin + new_LookupTables names_index LookupTables names_index get put + end + }{ + dup begin + new_LookupTables names_index[null null null null]put + end + }ifelse + }ifelse + /names_index names_index 1 add def + }forall + alias_cnt 0 gt{ + /AliasedColorants true def + /lut_entry_len new_LookupTables 0 get dup length 256 ge{0 get length}{length}ifelse def + 0 1 names_len 1 sub{ + /names_index xdf + new_LookupTables names_index get dup length 256 ge{0 get length}{length}ifelse lut_entry_len ne{ + /AliasedColorants false def + exit + }{ + new_LookupTables names_index get 0 get null eq{ + dup/Names get names_index get/name xdf + name(Cyan)eq name(Magenta)eq name(Yellow)eq name(Black)eq + or or or not{ + /AliasedColorants false def + exit + }if + }if + }ifelse + }for + lut_entry_len 1 eq{ + /AliasedColorants false def + }if + AliasedColorants{ + dup begin + /Names new_names def + /LookupTables new_LookupTables def + /AliasedColorants true def + /NComponents lut_entry_len def + /TintMethod NComponents 4 eq{/Subtractive}{/Additive}ifelse def + /MappedCSA TintMethod/Additive eq{/DeviceRGB}{/DeviceCMYK}ifelse def + currentdict/TTTablesIdx known not{ + /TTTablesIdx -1 def + }if + end + }if + }if + end + }if + dup/devicen_colorspace_dict exch AGMCORE_gput + begin + currentdict/AliasedColorants known{ + AliasedColorants + }{ + false + }ifelse + dup not{ + CSA map_csa + }if + /TintTransform load type/nulltype eq or{ + /TintTransform[ + 0 1 Names length 1 sub + { + /TTTablesIdx TTTablesIdx 1 add def + dup LookupTables exch get dup 0 get null eq + { + 1 index + Names exch get + dup(Cyan)eq + { + pop exch + LookupTables length exch sub + /index cvx + 0 0 0 + } + { + dup(Magenta)eq + { + pop exch + LookupTables length exch sub + /index cvx + 0/exch cvx 0 0 + }{ + (Yellow)eq + { + exch + LookupTables length exch sub + /index cvx + 0 0 3 -1/roll cvx 0 + }{ + exch + LookupTables length exch sub + /index cvx + 0 0 0 4 -1/roll cvx + }ifelse + }ifelse + }ifelse + 5 -1/roll cvx/astore cvx + }{ + dup length 1 sub + LookupTables length 4 -1 roll sub 1 add + /index cvx/mul cvx/round cvx/cvi cvx/get cvx + }ifelse + Names length TTTablesIdx add 1 add 1/roll cvx + }for + Names length[/pop cvx]cvx/repeat cvx + NComponents Names length + TintMethod/Subtractive eq + { + subtractive_blend + }{ + additive_blend + }ifelse + ]cvx bdf + }if + AGMCORE_host_sep{ + Names convert_to_process{ + exec_tint_transform + } + { + currentdict/AliasedColorants known{ + AliasedColorants not + }{ + false + }ifelse + 5 dict begin + /AvoidAliasedColorants xdf + /painted? false def + /names_index 0 def + /names_len Names length def + AvoidAliasedColorants{ + /currentspotalias current_spot_alias def + false set_spot_alias + }if + Names{ + AGMCORE_is_cmyk_sep{ + dup(Cyan)eq AGMCORE_cyan_plate and exch + dup(Magenta)eq AGMCORE_magenta_plate and exch + dup(Yellow)eq AGMCORE_yellow_plate and exch + (Black)eq AGMCORE_black_plate and or or or{ + /devicen_colorspace_dict AGMCORE_gget/TintProc[ + Names names_index/devn_makecustomcolor cvx + ]cvx ddf + /painted? true def + }if + painted?{exit}if + }{ + 0 0 0 0 5 -1 roll findcmykcustomcolor 1 setcustomcolor currentgray 0 eq{ + /devicen_colorspace_dict AGMCORE_gget/TintProc[ + Names names_index/devn_makecustomcolor cvx + ]cvx ddf + /painted? true def + exit + }if + }ifelse + /names_index names_index 1 add def + }forall + AvoidAliasedColorants{ + currentspotalias set_spot_alias + }if + painted?{ + /devicen_colorspace_dict AGMCORE_gget/names_index names_index put + }{ + /devicen_colorspace_dict AGMCORE_gget/TintProc[ + names_len[/pop cvx]cvx/repeat cvx 1/setseparationgray cvx + 0 0 0 0/setcmykcolor cvx + ]cvx ddf + }ifelse + end + }ifelse + } + { + AGMCORE_in_rip_sep{ + Names convert_to_process not + }{ + level3 + }ifelse + { + [/DeviceN Names MappedCSA/TintTransform load]setcolorspace_opt + /TintProc level3 not AGMCORE_in_rip_sep and{ + [ + Names/length cvx[/pop cvx]cvx/repeat cvx + ]cvx bdf + }{ + {setcolor}bdf + }ifelse + }{ + exec_tint_transform + }ifelse + }ifelse + set_crd + /AliasedColorants false def + end +}def +/setindexedcolorspace +{ + dup/indexed_colorspace_dict exch AGMCORE_gput + begin + currentdict/CSDBase known{ + CSDBase/CSD get_res begin + currentdict/Names known{ + currentdict devncs + }{ + 1 currentdict sepcs + }ifelse + AGMCORE_host_sep{ + 4 dict begin + /compCnt/Names where{pop Names length}{1}ifelse def + /NewLookup HiVal 1 add string def + 0 1 HiVal{ + /tableIndex xdf + Lookup dup type/stringtype eq{ + compCnt tableIndex map_index + }{ + exec + }ifelse + /Names where{ + pop setdevicencolor + }{ + setsepcolor + }ifelse + currentgray + tableIndex exch + 255 mul cvi + NewLookup 3 1 roll put + }for + [/Indexed currentcolorspace HiVal NewLookup]setcolorspace_opt + end + }{ + level3 + { + currentdict/Names known{ + [/Indexed[/DeviceN Names MappedCSA/TintTransform load]HiVal Lookup]setcolorspace_opt + }{ + [/Indexed[/Separation Name MappedCSA sep_proc_name load]HiVal Lookup]setcolorspace_opt + }ifelse + }{ + [/Indexed MappedCSA HiVal + [ + currentdict/Names known{ + Lookup dup type/stringtype eq + {/exch cvx CSDBase/CSD get_res/Names get length dup/mul cvx exch/getinterval cvx{255 div}/forall cvx} + {/exec cvx}ifelse + /TintTransform load/exec cvx + }{ + Lookup dup type/stringtype eq + {/exch cvx/get cvx 255/div cvx} + {/exec cvx}ifelse + CSDBase/CSD get_res/MappedCSA get sep_proc_name exch pop/load cvx/exec cvx + }ifelse + ]cvx + ]setcolorspace_opt + }ifelse + }ifelse + end + set_crd + } + { + CSA map_csa + AGMCORE_host_sep level2 not and{ + 0 0 0 0 setcmykcolor + }{ + [/Indexed MappedCSA + level2 not has_color not and{ + dup 0 get dup/DeviceRGB eq exch/DeviceCMYK eq or{ + pop[/DeviceGray] + }if + HiVal GrayLookup + }{ + HiVal + currentdict/RangeArray known{ + { + /indexed_colorspace_dict AGMCORE_gget begin + Lookup exch + dup HiVal gt{ + pop HiVal + }if + NComponents mul NComponents getinterval{}forall + NComponents 1 sub -1 0{ + RangeArray exch 2 mul 2 getinterval aload pop map255_to_range + NComponents 1 roll + }for + end + }bind + }{ + Lookup + }ifelse + }ifelse + ]setcolorspace_opt + set_crd + }ifelse + }ifelse + end +}def +/setindexedcolor +{ + AGMCORE_host_sep{ + /indexed_colorspace_dict AGMCORE_gget + begin + currentdict/CSDBase known{ + CSDBase/CSD get_res begin + currentdict/Names known{ + map_indexed_devn + devn + } + { + Lookup 1 3 -1 roll map_index + sep + }ifelse + end + }{ + Lookup MappedCSA/DeviceCMYK eq{4}{1}ifelse 3 -1 roll + map_index + MappedCSA/DeviceCMYK eq{setcmykcolor}{setgray}ifelse + }ifelse + end + }{ + level3 not AGMCORE_in_rip_sep and/indexed_colorspace_dict AGMCORE_gget/CSDBase known and{ + /indexed_colorspace_dict AGMCORE_gget/CSDBase get/CSD get_res begin + map_indexed_devn + devn + end + } + { + setcolor + }ifelse + }ifelse +}def +/ignoreimagedata +{ + currentoverprint not{ + gsave + dup clonedict begin + 1 setgray + /Decode[0 1]def + /DataSourcedef + /MultipleDataSources false def + /BitsPerComponent 8 def + currentdict end + systemdict/image gx + grestore + }if + consumeimagedata +}def +/add_res +{ + dup/CSD eq{ + pop + //Adobe_AGM_Core begin + /AGMCORE_CSD_cache load 3 1 roll put + end + }{ + defineresource pop + }ifelse +}def +/del_res +{ + { + aload pop exch + dup/CSD eq{ + pop + {//Adobe_AGM_Core/AGMCORE_CSD_cache get exch undef}forall + }{ + exch + {1 index undefineresource}forall + pop + }ifelse + }forall +}def +/get_res +{ + dup/CSD eq{ + pop + dup type dup/nametype eq exch/stringtype eq or{ + AGMCORE_CSD_cache exch get + }if + }{ + findresource + }ifelse +}def +/get_csa_by_name +{ + dup type dup/nametype eq exch/stringtype eq or{ + /CSA get_res + }if +}def +/paintproc_buf_init +{ + /count get 0 0 put +}def +/paintproc_buf_next +{ + dup/count get dup 0 get + dup 3 1 roll + 1 add 0 xpt + get +}def +/cachepaintproc_compress +{ + 5 dict begin + currentfile exch 0 exch/SubFileDecode filter/ReadFilter exch def + /ppdict 20 dict def + /string_size 16000 def + /readbuffer string_size string def + currentglobal true setglobal + ppdict 1 array dup 0 1 put/count xpt + setglobal + /LZWFilter + { + exch + dup length 0 eq{ + pop + }{ + ppdict dup length 1 sub 3 -1 roll put + }ifelse + {string_size}{0}ifelse string + }/LZWEncode filter def + { + ReadFilter readbuffer readstring + exch LZWFilter exch writestring + not{exit}if + }loop + LZWFilter closefile + ppdict + end +}def +/cachepaintproc +{ + 2 dict begin + currentfile exch 0 exch/SubFileDecode filter/ReadFilter exch def + /ppdict 20 dict def + currentglobal true setglobal + ppdict 1 array dup 0 1 put/count xpt + setglobal + { + ReadFilter 16000 string readstring exch + ppdict dup length 1 sub 3 -1 roll put + not{exit}if + }loop + ppdict dup dup length 1 sub()put + end +}def +/make_pattern +{ + exch clonedict exch + dup matrix currentmatrix matrix concatmatrix 0 0 3 2 roll itransform + exch 3 index/XStep get 1 index exch 2 copy div cvi mul sub sub + exch 3 index/YStep get 1 index exch 2 copy div cvi mul sub sub + matrix translate exch matrix concatmatrix + 1 index begin + BBox 0 get XStep div cvi XStep mul/xshift exch neg def + BBox 1 get YStep div cvi YStep mul/yshift exch neg def + BBox 0 get xshift add + BBox 1 get yshift add + BBox 2 get xshift add + BBox 3 get yshift add + 4 array astore + /BBox exch def + [xshift yshift/translate load null/exec load]dup + 3/PaintProc load put cvx/PaintProc exch def + end + gsave 0 setgray + makepattern + grestore +}def +/set_pattern +{ + dup/PatternType get 1 eq{ + dup/PaintType get 1 eq{ + currentoverprint sop[/DeviceGray]setcolorspace 0 setgray + }if + }if + setpattern +}def +/setcolorspace_opt +{ + dup currentcolorspace eq{pop}{setcolorspace}ifelse +}def +/updatecolorrendering +{ + currentcolorrendering/RenderingIntent known{ + currentcolorrendering/RenderingIntent get + } + { + Intent/AbsoluteColorimetric eq + { + /absolute_colorimetric_crd AGMCORE_gget dup null eq + } + { + Intent/RelativeColorimetric eq + { + /relative_colorimetric_crd AGMCORE_gget dup null eq + } + { + Intent/Saturation eq + { + /saturation_crd AGMCORE_gget dup null eq + } + { + /perceptual_crd AGMCORE_gget dup null eq + }ifelse + }ifelse + }ifelse + { + pop null + } + { + /RenderingIntent known{null}{Intent}ifelse + }ifelse + }ifelse + Intent ne{ + Intent/ColorRendering{findresource}stopped + { + pop pop systemdict/findcolorrendering known + { + Intent findcolorrendering + { + /ColorRendering findresource true exch + } + { + /ColorRendering findresource + product(Xerox Phaser 5400)ne + exch + }ifelse + dup Intent/AbsoluteColorimetric eq + { + /absolute_colorimetric_crd exch AGMCORE_gput + } + { + Intent/RelativeColorimetric eq + { + /relative_colorimetric_crd exch AGMCORE_gput + } + { + Intent/Saturation eq + { + /saturation_crd exch AGMCORE_gput + } + { + Intent/Perceptual eq + { + /perceptual_crd exch AGMCORE_gput + } + { + pop + }ifelse + }ifelse + }ifelse + }ifelse + 1 index{exch}{pop}ifelse + } + {false}ifelse + } + {true}ifelse + { + dup begin + currentdict/TransformPQR known{ + currentdict/TransformPQR get aload pop + 3{{}eq 3 1 roll}repeat or or + } + {true}ifelse + currentdict/MatrixPQR known{ + currentdict/MatrixPQR get aload pop + 1.0 eq 9 1 roll 0.0 eq 9 1 roll 0.0 eq 9 1 roll + 0.0 eq 9 1 roll 1.0 eq 9 1 roll 0.0 eq 9 1 roll + 0.0 eq 9 1 roll 0.0 eq 9 1 roll 1.0 eq + and and and and and and and and + } + {true}ifelse + end + or + { + clonedict begin + /TransformPQR[ + {4 -1 roll 3 get dup 3 1 roll sub 5 -1 roll 3 get 3 -1 roll sub div + 3 -1 roll 3 get 3 -1 roll 3 get dup 4 1 roll sub mul add}bind + {4 -1 roll 4 get dup 3 1 roll sub 5 -1 roll 4 get 3 -1 roll sub div + 3 -1 roll 4 get 3 -1 roll 4 get dup 4 1 roll sub mul add}bind + {4 -1 roll 5 get dup 3 1 roll sub 5 -1 roll 5 get 3 -1 roll sub div + 3 -1 roll 5 get 3 -1 roll 5 get dup 4 1 roll sub mul add}bind + ]def + /MatrixPQR[0.8951 -0.7502 0.0389 0.2664 1.7135 -0.0685 -0.1614 0.0367 1.0296]def + /RangePQR[-0.3227950745 2.3229645538 -1.5003771057 3.5003465881 -0.1369979095 2.136967392]def + currentdict end + }if + setcolorrendering_opt + }if + }if +}def +/set_crd +{ + AGMCORE_host_sep not level2 and{ + currentdict/ColorRendering known{ + ColorRendering/ColorRendering{findresource}stopped not{setcolorrendering_opt}if + }{ + currentdict/Intent known{ + updatecolorrendering + }if + }ifelse + currentcolorspace dup type/arraytype eq + {0 get}if + /DeviceRGB eq + { + currentdict/UCR known + {/UCR}{/AGMCORE_currentucr}ifelse + load setundercolorremoval + currentdict/BG known + {/BG}{/AGMCORE_currentbg}ifelse + load setblackgeneration + }if + }if +}def +/set_ucrbg +{ + dup null eq {pop /AGMCORE_currentbg load}{/Procedure get_res}ifelse + dup currentblackgeneration eq {pop}{setblackgeneration}ifelse + dup null eq {pop /AGMCORE_currentucr load}{/Procedure get_res}ifelse + dup currentundercolorremoval eq {pop}{setundercolorremoval}ifelse +}def +/setcolorrendering_opt +{ + dup currentcolorrendering eq{ + pop + }{ + product(HP Color LaserJet 2605)anchorsearch{ + pop pop pop + }{ + pop + clonedict + begin + /Intent Intent def + currentdict + end + setcolorrendering + }ifelse + }ifelse +}def +/cpaint_gcomp +{ + convert_to_process//Adobe_AGM_Core/AGMCORE_ConvertToProcess xddf + //Adobe_AGM_Core/AGMCORE_ConvertToProcess get not + { + (%end_cpaint_gcomp)flushinput + }if +}def +/cpaint_gsep +{ + //Adobe_AGM_Core/AGMCORE_ConvertToProcess get + { + (%end_cpaint_gsep)flushinput + }if +}def +/cpaint_gend +{np}def +/T1_path +{ + currentfile token pop currentfile token pop mo + { + currentfile token pop dup type/stringtype eq + {pop exit}if + 0 exch rlineto + currentfile token pop dup type/stringtype eq + {pop exit}if + 0 rlineto + }loop +}def +/T1_gsave + level3 + {/clipsave} + {/gsave}ifelse + load def +/T1_grestore + level3 + {/cliprestore} + {/grestore}ifelse + load def +/set_spot_alias_ary +{ + dup inherit_aliases + //Adobe_AGM_Core/AGMCORE_SpotAliasAry xddf +}def +/set_spot_normalization_ary +{ + dup inherit_aliases + dup length + /AGMCORE_SpotAliasAry where{pop AGMCORE_SpotAliasAry length add}if + array + //Adobe_AGM_Core/AGMCORE_SpotAliasAry2 xddf + /AGMCORE_SpotAliasAry where{ + pop + AGMCORE_SpotAliasAry2 0 AGMCORE_SpotAliasAry putinterval + AGMCORE_SpotAliasAry length + }{0}ifelse + AGMCORE_SpotAliasAry2 3 1 roll exch putinterval + true set_spot_alias +}def +/inherit_aliases +{ + {dup/Name get map_alias{/CSD put}{pop}ifelse}forall +}def +/set_spot_alias +{ + /AGMCORE_SpotAliasAry2 where{ + /AGMCORE_current_spot_alias 3 -1 roll put + }{ + pop + }ifelse +}def +/current_spot_alias +{ + /AGMCORE_SpotAliasAry2 where{ + /AGMCORE_current_spot_alias get + }{ + false + }ifelse +}def +/map_alias +{ + /AGMCORE_SpotAliasAry2 where{ + begin + /AGMCORE_name xdf + false + AGMCORE_SpotAliasAry2{ + dup/Name get AGMCORE_name eq{ + /CSD get/CSD get_res + exch pop true + exit + }{ + pop + }ifelse + }forall + end + }{ + pop false + }ifelse +}bdf +/spot_alias +{ + true set_spot_alias + /AGMCORE_&setcustomcolor AGMCORE_key_known not{ + //Adobe_AGM_Core/AGMCORE_&setcustomcolor/setcustomcolor load put + }if + /customcolor_tint 1 AGMCORE_gput + //Adobe_AGM_Core begin + /setcustomcolor + { + //Adobe_AGM_Core begin + dup/customcolor_tint exch AGMCORE_gput + 1 index aload pop pop 1 eq exch 1 eq and exch 1 eq and exch 1 eq and not + current_spot_alias and{1 index 4 get map_alias}{false}ifelse + { + false set_spot_alias + /sep_colorspace_dict AGMCORE_gget null ne + {/sep_colorspace_dict AGMCORE_gget/ForeignContent known not}{false}ifelse + 3 1 roll 2 index{ + exch pop/sep_tint AGMCORE_gget exch + }if + mark 3 1 roll + setsepcolorspace + counttomark 0 ne{ + setsepcolor + }if + pop + not{/sep_tint 1.0 AGMCORE_gput/sep_colorspace_dict AGMCORE_gget/ForeignContent true put}if + pop + true set_spot_alias + }{ + AGMCORE_&setcustomcolor + }ifelse + end + }bdf + end +}def +/begin_feature +{ + Adobe_AGM_Core/AGMCORE_feature_dictCount countdictstack put + count Adobe_AGM_Core/AGMCORE_feature_opCount 3 -1 roll put + {Adobe_AGM_Core/AGMCORE_feature_ctm matrix currentmatrix put}if +}def +/end_feature +{ + 2 dict begin + /spd/setpagedevice load def + /setpagedevice{get_gstate spd set_gstate}def + stopped{$error/newerror false put}if + end + count Adobe_AGM_Core/AGMCORE_feature_opCount get sub dup 0 gt{{pop}repeat}{pop}ifelse + countdictstack Adobe_AGM_Core/AGMCORE_feature_dictCount get sub dup 0 gt{{end}repeat}{pop}ifelse + {Adobe_AGM_Core/AGMCORE_feature_ctm get setmatrix}if +}def +/set_negative +{ + //Adobe_AGM_Core begin + /AGMCORE_inverting exch def + level2{ + currentpagedevice/NegativePrint known AGMCORE_distilling not and{ + currentpagedevice/NegativePrint get//Adobe_AGM_Core/AGMCORE_inverting get ne{ + true begin_feature true{ + <>setpagedevice + }end_feature + }if + /AGMCORE_inverting false def + }if + }if + AGMCORE_inverting{ + [{1 exch sub}/exec load dup currenttransfer exch]cvx bind settransfer + AGMCORE_distilling{ + erasepage + }{ + gsave np clippath 1/setseparationgray where{pop setseparationgray}{setgray}ifelse + /AGMIRS_&fill where{pop AGMIRS_&fill}{fill}ifelse grestore + }ifelse + }if + end +}def +/lw_save_restore_override{ + /md where{ + pop + md begin + initializepage + /initializepage{}def + /pmSVsetup{}def + /endp{}def + /pse{}def + /psb{}def + /orig_showpage where + {pop} + {/orig_showpage/showpage load def} + ifelse + /showpage{orig_showpage gR}def + end + }if +}def +/pscript_showpage_override{ + /NTPSOct95 where + { + begin + showpage + save + /showpage/restore load def + /restore{exch pop}def + end + }if +}def +/driver_media_override +{ + /md where{ + pop + md/initializepage known{ + md/initializepage{}put + }if + md/rC known{ + md/rC{4{pop}repeat}put + }if + }if + /mysetup where{ + /mysetup[1 0 0 1 0 0]put + }if + Adobe_AGM_Core/AGMCORE_Default_CTM matrix currentmatrix put + level2 + {Adobe_AGM_Core/AGMCORE_Default_PageSize currentpagedevice/PageSize get put}if +}def +/capture_mysetup +{ + /Pscript_Win_Data where{ + pop + Pscript_Win_Data/mysetup known{ + Adobe_AGM_Core/save_mysetup Pscript_Win_Data/mysetup get put + }if + }if +}def +/restore_mysetup +{ + /Pscript_Win_Data where{ + pop + Pscript_Win_Data/mysetup known{ + Adobe_AGM_Core/save_mysetup known{ + Pscript_Win_Data/mysetup Adobe_AGM_Core/save_mysetup get put + Adobe_AGM_Core/save_mysetup undef + }if + }if + }if +}def +/driver_check_media_override +{ + /PrepsDict where + {pop} + { + Adobe_AGM_Core/AGMCORE_Default_CTM get matrix currentmatrix ne + Adobe_AGM_Core/AGMCORE_Default_PageSize get type/arraytype eq + { + Adobe_AGM_Core/AGMCORE_Default_PageSize get 0 get currentpagedevice/PageSize get 0 get eq and + Adobe_AGM_Core/AGMCORE_Default_PageSize get 1 get currentpagedevice/PageSize get 1 get eq and + }if + { + Adobe_AGM_Core/AGMCORE_Default_CTM get setmatrix + }if + }ifelse +}def +AGMCORE_err_strings begin + /AGMCORE_bad_environ(Environment not satisfactory for this job. Ensure that the PPD is correct or that the PostScript level requested is supported by this printer. )def + /AGMCORE_color_space_onhost_seps(This job contains colors that will not separate with on-host methods. )def + /AGMCORE_invalid_color_space(This job contains an invalid color space. )def +end +/set_def_ht +{AGMCORE_def_ht sethalftone}def +/set_def_flat +{AGMCORE_Default_flatness setflat}def +end +systemdict/setpacking known +{setpacking}if +%%EndResource +%%BeginResource: procset Adobe_CoolType_Core 2.31 0 +%%Copyright: Copyright 1997-2006 Adobe Systems Incorporated. All Rights Reserved. +%%Version: 2.31 0 +10 dict begin +/Adobe_CoolType_Passthru currentdict def +/Adobe_CoolType_Core_Defined userdict/Adobe_CoolType_Core known def +Adobe_CoolType_Core_Defined + {/Adobe_CoolType_Core userdict/Adobe_CoolType_Core get def} +if +userdict/Adobe_CoolType_Core 70 dict dup begin put +/Adobe_CoolType_Version 2.31 def +/Level2? + systemdict/languagelevel known dup + {pop systemdict/languagelevel get 2 ge} + if def +Level2? not + { + /currentglobal false def + /setglobal/pop load def + /gcheck{pop false}bind def + /currentpacking false def + /setpacking/pop load def + /SharedFontDirectory 0 dict def + } +if +currentpacking +true setpacking +currentglobal false setglobal +userdict/Adobe_CoolType_Data 2 copy known not + {2 copy 10 dict put} +if +get + begin + /@opStackCountByLevel 32 dict def + /@opStackLevel 0 def + /@dictStackCountByLevel 32 dict def + /@dictStackLevel 0 def + end +setglobal +currentglobal true setglobal +userdict/Adobe_CoolType_GVMFonts known not + {userdict/Adobe_CoolType_GVMFonts 10 dict put} +if +setglobal +currentglobal false setglobal +userdict/Adobe_CoolType_LVMFonts known not + {userdict/Adobe_CoolType_LVMFonts 10 dict put} +if +setglobal +/ct_VMDictPut + { + dup gcheck{Adobe_CoolType_GVMFonts}{Adobe_CoolType_LVMFonts}ifelse + 3 1 roll put + }bind def +/ct_VMDictUndef + { + dup Adobe_CoolType_GVMFonts exch known + {Adobe_CoolType_GVMFonts exch undef} + { + dup Adobe_CoolType_LVMFonts exch known + {Adobe_CoolType_LVMFonts exch undef} + {pop} + ifelse + }ifelse + }bind def +/ct_str1 1 string def +/ct_xshow +{ + /_ct_na exch def + /_ct_i 0 def + currentpoint + /_ct_y exch def + /_ct_x exch def + { + pop pop + ct_str1 exch 0 exch put + ct_str1 show + {_ct_na _ct_i get}stopped + {pop pop} + { + _ct_x _ct_y moveto + 0 + rmoveto + } + ifelse + /_ct_i _ct_i 1 add def + currentpoint + /_ct_y exch def + /_ct_x exch def + } + exch + @cshow +}bind def +/ct_yshow +{ + /_ct_na exch def + /_ct_i 0 def + currentpoint + /_ct_y exch def + /_ct_x exch def + { + pop pop + ct_str1 exch 0 exch put + ct_str1 show + {_ct_na _ct_i get}stopped + {pop pop} + { + _ct_x _ct_y moveto + 0 exch + rmoveto + } + ifelse + /_ct_i _ct_i 1 add def + currentpoint + /_ct_y exch def + /_ct_x exch def + } + exch + @cshow +}bind def +/ct_xyshow +{ + /_ct_na exch def + /_ct_i 0 def + currentpoint + /_ct_y exch def + /_ct_x exch def + { + pop pop + ct_str1 exch 0 exch put + ct_str1 show + {_ct_na _ct_i get}stopped + {pop pop} + { + {_ct_na _ct_i 1 add get}stopped + {pop pop pop} + { + _ct_x _ct_y moveto + rmoveto + } + ifelse + } + ifelse + /_ct_i _ct_i 2 add def + currentpoint + /_ct_y exch def + /_ct_x exch def + } + exch + @cshow +}bind def +/xsh{{@xshow}stopped{Adobe_CoolType_Data begin ct_xshow end}if}bind def +/ysh{{@yshow}stopped{Adobe_CoolType_Data begin ct_yshow end}if}bind def +/xysh{{@xyshow}stopped{Adobe_CoolType_Data begin ct_xyshow end}if}bind def +currentglobal true setglobal +/ct_T3Defs +{ +/BuildChar +{ + 1 index/Encoding get exch get + 1 index/BuildGlyph get exec +}bind def +/BuildGlyph +{ + exch begin + GlyphProcs exch get exec + end +}bind def +}bind def +setglobal +/@_SaveStackLevels + { + Adobe_CoolType_Data + begin + /@vmState currentglobal def false setglobal + @opStackCountByLevel + @opStackLevel + 2 copy known not + { + 2 copy + 3 dict dup/args + 7 index + 5 add array put + put get + } + { + get dup/args get dup length 3 index lt + { + dup length 5 add array exch + 1 index exch 0 exch putinterval + 1 index exch/args exch put + } + {pop} + ifelse + } + ifelse + begin + count 1 sub + 1 index lt + {pop count} + if + dup/argCount exch def + dup 0 gt + { + args exch 0 exch getinterval + astore pop + } + {pop} + ifelse + count + /restCount exch def + end + /@opStackLevel @opStackLevel 1 add def + countdictstack 1 sub + @dictStackCountByLevel exch @dictStackLevel exch put + /@dictStackLevel @dictStackLevel 1 add def + @vmState setglobal + end + }bind def +/@_RestoreStackLevels + { + Adobe_CoolType_Data + begin + /@opStackLevel @opStackLevel 1 sub def + @opStackCountByLevel @opStackLevel get + begin + count restCount sub dup 0 gt + {{pop}repeat} + {pop} + ifelse + args 0 argCount getinterval{}forall + end + /@dictStackLevel @dictStackLevel 1 sub def + @dictStackCountByLevel @dictStackLevel get + end + countdictstack exch sub dup 0 gt + {{end}repeat} + {pop} + ifelse + }bind def +/@_PopStackLevels + { + Adobe_CoolType_Data + begin + /@opStackLevel @opStackLevel 1 sub def + /@dictStackLevel @dictStackLevel 1 sub def + end + }bind def +/@Raise + { + exch cvx exch errordict exch get exec + stop + }bind def +/@ReRaise + { + cvx $error/errorname get errordict exch get exec + stop + }bind def +/@Stopped + { + 0 @#Stopped + }bind def +/@#Stopped + { + @_SaveStackLevels + stopped + {@_RestoreStackLevels true} + {@_PopStackLevels false} + ifelse + }bind def +/@Arg + { + Adobe_CoolType_Data + begin + @opStackCountByLevel @opStackLevel 1 sub get + begin + args exch + argCount 1 sub exch sub get + end + end + }bind def +currentglobal true setglobal +/CTHasResourceForAllBug + Level2? + { + 1 dict dup + /@shouldNotDisappearDictValue true def + Adobe_CoolType_Data exch/@shouldNotDisappearDict exch put + begin + count @_SaveStackLevels + {(*){pop stop}128 string/Category resourceforall} + stopped pop + @_RestoreStackLevels + currentdict Adobe_CoolType_Data/@shouldNotDisappearDict get dup 3 1 roll ne dup 3 1 roll + { + /@shouldNotDisappearDictValue known + { + { + end + currentdict 1 index eq + {pop exit} + if + } + loop + } + if + } + { + pop + end + } + ifelse + } + {false} + ifelse + def +true setglobal +/CTHasResourceStatusBug + Level2? + { + mark + {/steveamerige/Category resourcestatus} + stopped + {cleartomark true} + {cleartomark currentglobal not} + ifelse + } + {false} + ifelse + def +setglobal +/CTResourceStatus + { + mark 3 1 roll + /Category findresource + begin + ({ResourceStatus}stopped)0()/SubFileDecode filter cvx exec + {cleartomark false} + {{3 2 roll pop true}{cleartomark false}ifelse} + ifelse + end + }bind def +/CTWorkAroundBugs + { + Level2? + { + /cid_PreLoad/ProcSet resourcestatus + { + pop pop + currentglobal + mark + { + (*) + { + dup/CMap CTHasResourceStatusBug + {CTResourceStatus} + {resourcestatus} + ifelse + { + pop dup 0 eq exch 1 eq or + { + dup/CMap findresource gcheck setglobal + /CMap undefineresource + } + { + pop CTHasResourceForAllBug + {exit} + {stop} + ifelse + } + ifelse + } + {pop} + ifelse + } + 128 string/CMap resourceforall + } + stopped + {cleartomark} + stopped pop + setglobal + } + if + } + if + }bind def +/ds + { + Adobe_CoolType_Core + begin + CTWorkAroundBugs + /mo/moveto load def + /nf/newencodedfont load def + /msf{makefont setfont}bind def + /uf{dup undefinefont ct_VMDictUndef}bind def + /ur/undefineresource load def + /chp/charpath load def + /awsh/awidthshow load def + /wsh/widthshow load def + /ash/ashow load def + /@xshow/xshow load def + /@yshow/yshow load def + /@xyshow/xyshow load def + /@cshow/cshow load def + /sh/show load def + /rp/repeat load def + /.n/.notdef def + end + currentglobal false setglobal + userdict/Adobe_CoolType_Data 2 copy known not + {2 copy 10 dict put} + if + get + begin + /AddWidths? false def + /CC 0 def + /charcode 2 string def + /@opStackCountByLevel 32 dict def + /@opStackLevel 0 def + /@dictStackCountByLevel 32 dict def + /@dictStackLevel 0 def + /InVMFontsByCMap 10 dict def + /InVMDeepCopiedFonts 10 dict def + end + setglobal + }bind def +/dt + { + currentdict Adobe_CoolType_Core eq + {end} + if + }bind def +/ps + { + Adobe_CoolType_Core begin + Adobe_CoolType_GVMFonts begin + Adobe_CoolType_LVMFonts begin + SharedFontDirectory begin + }bind def +/pt + { + end + end + end + end + }bind def +/unload + { + systemdict/languagelevel known + { + systemdict/languagelevel get 2 ge + { + userdict/Adobe_CoolType_Core 2 copy known + {undef} + {pop pop} + ifelse + } + if + } + if + }bind def +/ndf + { + 1 index where + {pop pop pop} + {dup xcheck{bind}if def} + ifelse + }def +/findfont systemdict + begin + userdict + begin + /globaldict where{/globaldict get begin}if + dup where pop exch get + /globaldict where{pop end}if + end + end +Adobe_CoolType_Core_Defined + {/systemfindfont exch def} + { + /findfont 1 index def + /systemfindfont exch def + } +ifelse +/undefinefont + {pop}ndf +/copyfont + { + currentglobal 3 1 roll + 1 index gcheck setglobal + dup null eq{0}{dup length}ifelse + 2 index length add 1 add dict + begin + exch + { + 1 index/FID eq + {pop pop} + {def} + ifelse + } + forall + dup null eq + {pop} + {{def}forall} + ifelse + currentdict + end + exch setglobal + }bind def +/copyarray + { + currentglobal exch + dup gcheck setglobal + dup length array copy + exch setglobal + }bind def +/newencodedfont + { + currentglobal + { + SharedFontDirectory 3 index known + {SharedFontDirectory 3 index get/FontReferenced known} + {false} + ifelse + } + { + FontDirectory 3 index known + {FontDirectory 3 index get/FontReferenced known} + { + SharedFontDirectory 3 index known + {SharedFontDirectory 3 index get/FontReferenced known} + {false} + ifelse + } + ifelse + } + ifelse + dup + { + 3 index findfont/FontReferenced get + 2 index dup type/nametype eq + {findfont} + if ne + {pop false} + if + } + if + dup + { + 1 index dup type/nametype eq + {findfont} + if + dup/CharStrings known + { + /CharStrings get length + 4 index findfont/CharStrings get length + ne + { + pop false + } + if + } + {pop} + ifelse + } + if + { + pop + 1 index findfont + /Encoding get exch + 0 1 255 + {2 copy get 3 index 3 1 roll put} + for + pop pop pop + } + { + currentglobal + 4 1 roll + dup type/nametype eq + {findfont} + if + dup gcheck setglobal + dup dup maxlength 2 add dict + begin + exch + { + 1 index/FID ne + 2 index/Encoding ne and + {def} + {pop pop} + ifelse + } + forall + /FontReferenced exch def + /Encoding exch dup length array copy def + /FontName 1 index dup type/stringtype eq{cvn}if def dup + currentdict + end + definefont ct_VMDictPut + setglobal + } + ifelse + }bind def +/SetSubstituteStrategy + { + $SubstituteFont + begin + dup type/dicttype ne + {0 dict} + if + currentdict/$Strategies known + { + exch $Strategies exch + 2 copy known + { + get + 2 copy maxlength exch maxlength add dict + begin + {def}forall + {def}forall + currentdict + dup/$Init known + {dup/$Init get exec} + if + end + /$Strategy exch def + } + {pop pop pop} + ifelse + } + {pop pop} + ifelse + end + }bind def +/scff + { + $SubstituteFont + begin + dup type/stringtype eq + {dup length exch} + {null} + ifelse + /$sname exch def + /$slen exch def + /$inVMIndex + $sname null eq + { + 1 index $str cvs + dup length $slen sub $slen getinterval cvn + } + {$sname} + ifelse def + end + {findfont} + @Stopped + { + dup length 8 add string exch + 1 index 0(BadFont:)putinterval + 1 index exch 8 exch dup length string cvs putinterval cvn + {findfont} + @Stopped + {pop/Courier findfont} + if + } + if + $SubstituteFont + begin + /$sname null def + /$slen 0 def + /$inVMIndex null def + end + }bind def +/isWidthsOnlyFont + { + dup/WidthsOnly known + {pop pop true} + { + dup/FDepVector known + {/FDepVector get{isWidthsOnlyFont dup{exit}if}forall} + { + dup/FDArray known + {/FDArray get{isWidthsOnlyFont dup{exit}if}forall} + {pop} + ifelse + } + ifelse + } + ifelse + }bind def +/ct_StyleDicts 4 dict dup begin + /Adobe-Japan1 4 dict dup begin + Level2? + { + /Serif + /HeiseiMin-W3-83pv-RKSJ-H/Font resourcestatus + {pop pop/HeiseiMin-W3} + { + /CIDFont/Category resourcestatus + { + pop pop + /HeiseiMin-W3/CIDFont resourcestatus + {pop pop/HeiseiMin-W3} + {/Ryumin-Light} + ifelse + } + {/Ryumin-Light} + ifelse + } + ifelse + def + /SansSerif + /HeiseiKakuGo-W5-83pv-RKSJ-H/Font resourcestatus + {pop pop/HeiseiKakuGo-W5} + { + /CIDFont/Category resourcestatus + { + pop pop + /HeiseiKakuGo-W5/CIDFont resourcestatus + {pop pop/HeiseiKakuGo-W5} + {/GothicBBB-Medium} + ifelse + } + {/GothicBBB-Medium} + ifelse + } + ifelse + def + /HeiseiMaruGo-W4-83pv-RKSJ-H/Font resourcestatus + {pop pop/HeiseiMaruGo-W4} + { + /CIDFont/Category resourcestatus + { + pop pop + /HeiseiMaruGo-W4/CIDFont resourcestatus + {pop pop/HeiseiMaruGo-W4} + { + /Jun101-Light-RKSJ-H/Font resourcestatus + {pop pop/Jun101-Light} + {SansSerif} + ifelse + } + ifelse + } + { + /Jun101-Light-RKSJ-H/Font resourcestatus + {pop pop/Jun101-Light} + {SansSerif} + ifelse + } + ifelse + } + ifelse + /RoundSansSerif exch def + /Default Serif def + } + { + /Serif/Ryumin-Light def + /SansSerif/GothicBBB-Medium def + { + (fonts/Jun101-Light-83pv-RKSJ-H)status + }stopped + {pop}{ + {pop pop pop pop/Jun101-Light} + {SansSerif} + ifelse + /RoundSansSerif exch def + }ifelse + /Default Serif def + } + ifelse + end + def + /Adobe-Korea1 4 dict dup begin + /Serif/HYSMyeongJo-Medium def + /SansSerif/HYGoThic-Medium def + /RoundSansSerif SansSerif def + /Default Serif def + end + def + /Adobe-GB1 4 dict dup begin + /Serif/STSong-Light def + /SansSerif/STHeiti-Regular def + /RoundSansSerif SansSerif def + /Default Serif def + end + def + /Adobe-CNS1 4 dict dup begin + /Serif/MKai-Medium def + /SansSerif/MHei-Medium def + /RoundSansSerif SansSerif def + /Default Serif def + end + def +end +def +Level2?{currentglobal true setglobal}if +/ct_BoldRomanWidthProc + { + stringwidth 1 index 0 ne{exch .03 add exch}if setcharwidth + 0 0 + }bind def +/ct_Type0WidthProc + { + dup stringwidth 0 0 moveto + 2 index true charpath pathbbox + 0 -1 + 7 index 2 div .88 + setcachedevice2 + pop + 0 0 + }bind def +/ct_Type0WMode1WidthProc + { + dup stringwidth + pop 2 div neg -0.88 + 2 copy + moveto + 0 -1 + 5 -1 roll true charpath pathbbox + setcachedevice + }bind def +/cHexEncoding +[/c00/c01/c02/c03/c04/c05/c06/c07/c08/c09/c0A/c0B/c0C/c0D/c0E/c0F/c10/c11/c12 +/c13/c14/c15/c16/c17/c18/c19/c1A/c1B/c1C/c1D/c1E/c1F/c20/c21/c22/c23/c24/c25 +/c26/c27/c28/c29/c2A/c2B/c2C/c2D/c2E/c2F/c30/c31/c32/c33/c34/c35/c36/c37/c38 +/c39/c3A/c3B/c3C/c3D/c3E/c3F/c40/c41/c42/c43/c44/c45/c46/c47/c48/c49/c4A/c4B +/c4C/c4D/c4E/c4F/c50/c51/c52/c53/c54/c55/c56/c57/c58/c59/c5A/c5B/c5C/c5D/c5E +/c5F/c60/c61/c62/c63/c64/c65/c66/c67/c68/c69/c6A/c6B/c6C/c6D/c6E/c6F/c70/c71 +/c72/c73/c74/c75/c76/c77/c78/c79/c7A/c7B/c7C/c7D/c7E/c7F/c80/c81/c82/c83/c84 +/c85/c86/c87/c88/c89/c8A/c8B/c8C/c8D/c8E/c8F/c90/c91/c92/c93/c94/c95/c96/c97 +/c98/c99/c9A/c9B/c9C/c9D/c9E/c9F/cA0/cA1/cA2/cA3/cA4/cA5/cA6/cA7/cA8/cA9/cAA +/cAB/cAC/cAD/cAE/cAF/cB0/cB1/cB2/cB3/cB4/cB5/cB6/cB7/cB8/cB9/cBA/cBB/cBC/cBD +/cBE/cBF/cC0/cC1/cC2/cC3/cC4/cC5/cC6/cC7/cC8/cC9/cCA/cCB/cCC/cCD/cCE/cCF/cD0 +/cD1/cD2/cD3/cD4/cD5/cD6/cD7/cD8/cD9/cDA/cDB/cDC/cDD/cDE/cDF/cE0/cE1/cE2/cE3 +/cE4/cE5/cE6/cE7/cE8/cE9/cEA/cEB/cEC/cED/cEE/cEF/cF0/cF1/cF2/cF3/cF4/cF5/cF6 +/cF7/cF8/cF9/cFA/cFB/cFC/cFD/cFE/cFF]def +/ct_BoldBaseFont + 11 dict begin + /FontType 3 def + /FontMatrix[1 0 0 1 0 0]def + /FontBBox[0 0 1 1]def + /Encoding cHexEncoding def + /_setwidthProc/ct_BoldRomanWidthProc load def + /_bcstr1 1 string def + /BuildChar + { + exch begin + _basefont setfont + _bcstr1 dup 0 4 -1 roll put + dup + _setwidthProc + 3 copy + moveto + show + _basefonto setfont + moveto + show + end + }bind def + currentdict + end +def +systemdict/composefont known +{ +/ct_DefineIdentity-H +{ + /Identity-H/CMap resourcestatus + { + pop pop + } + { + /CIDInit/ProcSet findresource begin + 12 dict begin + begincmap + /CIDSystemInfo 3 dict dup begin + /Registry(Adobe)def + /Ordering(Identity)def + /Supplement 0 def + end def + /CMapName/Identity-H def + /CMapVersion 1.000 def + /CMapType 1 def + 1 begincodespacerange + <0000> + endcodespacerange + 1 begincidrange + <0000>0 + endcidrange + endcmap + CMapName currentdict/CMap defineresource pop + end + end + } + ifelse +} +def +/ct_BoldBaseCIDFont + 11 dict begin + /CIDFontType 1 def + /CIDFontName/ct_BoldBaseCIDFont def + /FontMatrix[1 0 0 1 0 0]def + /FontBBox[0 0 1 1]def + /_setwidthProc/ct_Type0WidthProc load def + /_bcstr2 2 string def + /BuildGlyph + { + exch begin + _basefont setfont + _bcstr2 1 2 index 256 mod put + _bcstr2 0 3 -1 roll 256 idiv put + _bcstr2 dup _setwidthProc + 3 copy + moveto + show + _basefonto setfont + moveto + show + end + }bind def + currentdict + end +def +}if +Level2?{setglobal}if +/ct_CopyFont{ + { + 1 index/FID ne 2 index/UniqueID ne and + {def}{pop pop}ifelse + }forall +}bind def +/ct_Type0CopyFont +{ + exch + dup length dict + begin + ct_CopyFont + [ + exch + FDepVector + { + dup/FontType get 0 eq + { + 1 index ct_Type0CopyFont + /_ctType0 exch definefont + } + { + /_ctBaseFont exch + 2 index exec + } + ifelse + exch + } + forall + pop + ] + /FDepVector exch def + currentdict + end +}bind def +/ct_MakeBoldFont +{ + dup/ct_SyntheticBold known + { + dup length 3 add dict begin + ct_CopyFont + /ct_StrokeWidth .03 0 FontMatrix idtransform pop def + /ct_SyntheticBold true def + currentdict + end + definefont + } + { + dup dup length 3 add dict + begin + ct_CopyFont + /PaintType 2 def + /StrokeWidth .03 0 FontMatrix idtransform pop def + /dummybold currentdict + end + definefont + dup/FontType get dup 9 ge exch 11 le and + { + ct_BoldBaseCIDFont + dup length 3 add dict copy begin + dup/CIDSystemInfo get/CIDSystemInfo exch def + ct_DefineIdentity-H + /_Type0Identity/Identity-H 3 -1 roll[exch]composefont + /_basefont exch def + /_Type0Identity/Identity-H 3 -1 roll[exch]composefont + /_basefonto exch def + currentdict + end + /CIDFont defineresource + } + { + ct_BoldBaseFont + dup length 3 add dict copy begin + /_basefont exch def + /_basefonto exch def + currentdict + end + definefont + } + ifelse + } + ifelse +}bind def +/ct_MakeBold{ + 1 index + 1 index + findfont + currentglobal 5 1 roll + dup gcheck setglobal + dup + /FontType get 0 eq + { + dup/WMode known{dup/WMode get 1 eq}{false}ifelse + version length 4 ge + and + {version 0 4 getinterval cvi 2015 ge} + {true} + ifelse + {/ct_Type0WidthProc} + {/ct_Type0WMode1WidthProc} + ifelse + ct_BoldBaseFont/_setwidthProc 3 -1 roll load put + {ct_MakeBoldFont}ct_Type0CopyFont definefont + } + { + dup/_fauxfont known not 1 index/SubstMaster known not and + { + ct_BoldBaseFont/_setwidthProc /ct_BoldRomanWidthProc load put + ct_MakeBoldFont + } + { + 2 index 2 index eq + {exch pop } + { + dup length dict begin + ct_CopyFont + currentdict + end + definefont + } + ifelse + } + ifelse + } + ifelse + pop pop pop + setglobal +}bind def +/?str1 256 string def +/?set + { + $SubstituteFont + begin + /$substituteFound false def + /$fontname 1 index def + /$doSmartSub false def + end + dup + findfont + $SubstituteFont + begin + $substituteFound + {false} + { + dup/FontName known + { + dup/FontName get $fontname eq + 1 index/DistillerFauxFont known not and + /currentdistillerparams where + {pop false 2 index isWidthsOnlyFont not and} + if + } + {false} + ifelse + } + ifelse + exch pop + /$doSmartSub true def + end + { + 5 1 roll pop pop pop pop + findfont + } + { + 1 index + findfont + dup/FontType get 3 eq + { + 6 1 roll pop pop pop pop pop false + } + {pop true} + ifelse + { + $SubstituteFont + begin + pop pop + /$styleArray 1 index def + /$regOrdering 2 index def + pop pop + 0 1 $styleArray length 1 sub + { + $styleArray exch get + ct_StyleDicts $regOrdering + 2 copy known + { + get + exch 2 copy known not + {pop/Default} + if + get + dup type/nametype eq + { + ?str1 cvs length dup 1 add exch + ?str1 exch(-)putinterval + exch dup length exch ?str1 exch 3 index exch putinterval + add ?str1 exch 0 exch getinterval cvn + } + { + pop pop/Unknown + } + ifelse + } + { + pop pop pop pop/Unknown + } + ifelse + } + for + end + findfont + }if + } + ifelse + currentglobal false setglobal 3 1 roll + null copyfont definefont pop + setglobal + }bind def +setpacking +userdict/$SubstituteFont 25 dict put +1 dict + begin + /SubstituteFont + dup $error exch 2 copy known + {get} + {pop pop{pop/Courier}bind} + ifelse def + /currentdistillerparams where dup + { + pop pop + currentdistillerparams/CannotEmbedFontPolicy 2 copy known + {get/Error eq} + {pop pop false} + ifelse + } + if not + { + countdictstack array dictstack 0 get + begin + userdict + begin + $SubstituteFont + begin + /$str 128 string def + /$fontpat 128 string def + /$slen 0 def + /$sname null def + /$match false def + /$fontname null def + /$substituteFound false def + /$inVMIndex null def + /$doSmartSub true def + /$depth 0 def + /$fontname null def + /$italicangle 26.5 def + /$dstack null def + /$Strategies 10 dict dup + begin + /$Type3Underprint + { + currentglobal exch false setglobal + 11 dict + begin + /UseFont exch + $WMode 0 ne + { + dup length dict copy + dup/WMode $WMode put + /UseFont exch definefont + } + if def + /FontName $fontname dup type/stringtype eq{cvn}if def + /FontType 3 def + /FontMatrix[.001 0 0 .001 0 0]def + /Encoding 256 array dup 0 1 255{/.notdef put dup}for pop def + /FontBBox[0 0 0 0]def + /CCInfo 7 dict dup + begin + /cc null def + /x 0 def + /y 0 def + end def + /BuildChar + { + exch + begin + CCInfo + begin + 1 string dup 0 3 index put exch pop + /cc exch def + UseFont 1000 scalefont setfont + cc stringwidth/y exch def/x exch def + x y setcharwidth + $SubstituteFont/$Strategy get/$Underprint get exec + 0 0 moveto cc show + x y moveto + end + end + }bind def + currentdict + end + exch setglobal + }bind def + /$GetaTint + 2 dict dup + begin + /$BuildFont + { + dup/WMode known + {dup/WMode get} + {0} + ifelse + /$WMode exch def + $fontname exch + dup/FontName known + { + dup/FontName get + dup type/stringtype eq{cvn}if + } + {/unnamedfont} + ifelse + exch + Adobe_CoolType_Data/InVMDeepCopiedFonts get + 1 index/FontName get known + { + pop + Adobe_CoolType_Data/InVMDeepCopiedFonts get + 1 index get + null copyfont + } + {$deepcopyfont} + ifelse + exch 1 index exch/FontBasedOn exch put + dup/FontName $fontname dup type/stringtype eq{cvn}if put + definefont + Adobe_CoolType_Data/InVMDeepCopiedFonts get + begin + dup/FontBasedOn get 1 index def + end + }bind def + /$Underprint + { + gsave + x abs y abs gt + {/y 1000 def} + {/x -1000 def 500 120 translate} + ifelse + Level2? + { + [/Separation(All)/DeviceCMYK{0 0 0 1 pop}] + setcolorspace + } + {0 setgray} + ifelse + 10 setlinewidth + x .8 mul + [7 3] + { + y mul 8 div 120 sub x 10 div exch moveto + 0 y 4 div neg rlineto + dup 0 rlineto + 0 y 4 div rlineto + closepath + gsave + Level2? + {.2 setcolor} + {.8 setgray} + ifelse + fill grestore + stroke + } + forall + pop + grestore + }bind def + end def + /$Oblique + 1 dict dup + begin + /$BuildFont + { + currentglobal exch dup gcheck setglobal + null copyfont + begin + /FontBasedOn + currentdict/FontName known + { + FontName + dup type/stringtype eq{cvn}if + } + {/unnamedfont} + ifelse + def + /FontName $fontname dup type/stringtype eq{cvn}if def + /currentdistillerparams where + {pop} + { + /FontInfo currentdict/FontInfo known + {FontInfo null copyfont} + {2 dict} + ifelse + dup + begin + /ItalicAngle $italicangle def + /FontMatrix FontMatrix + [1 0 ItalicAngle dup sin exch cos div 1 0 0] + matrix concatmatrix readonly + end + 4 2 roll def + def + } + ifelse + FontName currentdict + end + definefont + exch setglobal + }bind def + end def + /$None + 1 dict dup + begin + /$BuildFont{}bind def + end def + end def + /$Oblique SetSubstituteStrategy + /$findfontByEnum + { + dup type/stringtype eq{cvn}if + dup/$fontname exch def + $sname null eq + {$str cvs dup length $slen sub $slen getinterval} + {pop $sname} + ifelse + $fontpat dup 0(fonts/*)putinterval exch 7 exch putinterval + /$match false def + $SubstituteFont/$dstack countdictstack array dictstack put + mark + { + $fontpat 0 $slen 7 add getinterval + {/$match exch def exit} + $str filenameforall + } + stopped + { + cleardictstack + currentdict + true + $SubstituteFont/$dstack get + { + exch + { + 1 index eq + {pop false} + {true} + ifelse + } + {begin false} + ifelse + } + forall + pop + } + if + cleartomark + /$slen 0 def + $match false ne + {$match(fonts/)anchorsearch pop pop cvn} + {/Courier} + ifelse + }bind def + /$ROS 1 dict dup + begin + /Adobe 4 dict dup + begin + /Japan1 [/Ryumin-Light/HeiseiMin-W3 + /GothicBBB-Medium/HeiseiKakuGo-W5 + /HeiseiMaruGo-W4/Jun101-Light]def + /Korea1 [/HYSMyeongJo-Medium/HYGoThic-Medium]def + /GB1 [/STSong-Light/STHeiti-Regular]def + /CNS1 [/MKai-Medium/MHei-Medium]def + end def + end def + /$cmapname null def + /$deepcopyfont + { + dup/FontType get 0 eq + { + 1 dict dup/FontName/copied put copyfont + begin + /FDepVector FDepVector copyarray + 0 1 2 index length 1 sub + { + 2 copy get $deepcopyfont + dup/FontName/copied put + /copied exch definefont + 3 copy put pop pop + } + for + def + currentdict + end + } + {$Strategies/$Type3Underprint get exec} + ifelse + }bind def + /$buildfontname + { + dup/CIDFont findresource/CIDSystemInfo get + begin + Registry length Ordering length Supplement 8 string cvs + 3 copy length 2 add add add string + dup 5 1 roll dup 0 Registry putinterval + dup 4 index(-)putinterval + dup 4 index 1 add Ordering putinterval + 4 2 roll add 1 add 2 copy(-)putinterval + end + 1 add 2 copy 0 exch getinterval $cmapname $fontpat cvs exch + anchorsearch + {pop pop 3 2 roll putinterval cvn/$cmapname exch def} + {pop pop pop pop pop} + ifelse + length + $str 1 index(-)putinterval 1 add + $str 1 index $cmapname $fontpat cvs putinterval + $cmapname length add + $str exch 0 exch getinterval cvn + }bind def + /$findfontByROS + { + /$fontname exch def + $ROS Registry 2 copy known + { + get Ordering 2 copy known + {get} + {pop pop[]} + ifelse + } + {pop pop[]} + ifelse + false exch + { + dup/CIDFont resourcestatus + { + pop pop + save + 1 index/CIDFont findresource + dup/WidthsOnly known + {dup/WidthsOnly get} + {false} + ifelse + exch pop + exch restore + {pop} + {exch pop true exit} + ifelse + } + {pop} + ifelse + } + forall + {$str cvs $buildfontname} + { + false(*) + { + save exch + dup/CIDFont findresource + dup/WidthsOnly known + {dup/WidthsOnly get not} + {true} + ifelse + exch/CIDSystemInfo get + dup/Registry get Registry eq + exch/Ordering get Ordering eq and and + {exch restore exch pop true exit} + {pop restore} + ifelse + } + $str/CIDFont resourceforall + {$buildfontname} + {$fontname $findfontByEnum} + ifelse + } + ifelse + }bind def + end + end + currentdict/$error known currentdict/languagelevel known and dup + {pop $error/SubstituteFont known} + if + dup + {$error} + {Adobe_CoolType_Core} + ifelse + begin + { + /SubstituteFont + /CMap/Category resourcestatus + { + pop pop + { + $SubstituteFont + begin + /$substituteFound true def + dup length $slen gt + $sname null ne or + $slen 0 gt and + { + $sname null eq + {dup $str cvs dup length $slen sub $slen getinterval cvn} + {$sname} + ifelse + Adobe_CoolType_Data/InVMFontsByCMap get + 1 index 2 copy known + { + get + false exch + { + pop + currentglobal + { + GlobalFontDirectory 1 index known + {exch pop true exit} + {pop} + ifelse + } + { + FontDirectory 1 index known + {exch pop true exit} + { + GlobalFontDirectory 1 index known + {exch pop true exit} + {pop} + ifelse + } + ifelse + } + ifelse + } + forall + } + {pop pop false} + ifelse + { + exch pop exch pop + } + { + dup/CMap resourcestatus + { + pop pop + dup/$cmapname exch def + /CMap findresource/CIDSystemInfo get{def}forall + $findfontByROS + } + { + 128 string cvs + dup(-)search + { + 3 1 roll search + { + 3 1 roll pop + {dup cvi} + stopped + {pop pop pop pop pop $findfontByEnum} + { + 4 2 roll pop pop + exch length + exch + 2 index length + 2 index + sub + exch 1 sub -1 0 + { + $str cvs dup length + 4 index + 0 + 4 index + 4 3 roll add + getinterval + exch 1 index exch 3 index exch + putinterval + dup/CMap resourcestatus + { + pop pop + 4 1 roll pop pop pop + dup/$cmapname exch def + /CMap findresource/CIDSystemInfo get{def}forall + $findfontByROS + true exit + } + {pop} + ifelse + } + for + dup type/booleantype eq + {pop} + {pop pop pop $findfontByEnum} + ifelse + } + ifelse + } + {pop pop pop $findfontByEnum} + ifelse + } + {pop pop $findfontByEnum} + ifelse + } + ifelse + } + ifelse + } + {//SubstituteFont exec} + ifelse + /$slen 0 def + end + } + } + { + { + $SubstituteFont + begin + /$substituteFound true def + dup length $slen gt + $sname null ne or + $slen 0 gt and + {$findfontByEnum} + {//SubstituteFont exec} + ifelse + end + } + } + ifelse + bind readonly def + Adobe_CoolType_Core/scfindfont/systemfindfont load put + } + { + /scfindfont + { + $SubstituteFont + begin + dup systemfindfont + dup/FontName known + {dup/FontName get dup 3 index ne} + {/noname true} + ifelse + dup + { + /$origfontnamefound 2 index def + /$origfontname 4 index def/$substituteFound true def + } + if + exch pop + { + $slen 0 gt + $sname null ne + 3 index length $slen gt or and + { + pop dup $findfontByEnum findfont + dup maxlength 1 add dict + begin + {1 index/FID eq{pop pop}{def}ifelse} + forall + currentdict + end + definefont + dup/FontName known{dup/FontName get}{null}ifelse + $origfontnamefound ne + { + $origfontname $str cvs print + ( substitution revised, using )print + dup/FontName known + {dup/FontName get}{(unspecified font)} + ifelse + $str cvs print(.\n)print + } + if + } + {exch pop} + ifelse + } + {exch pop} + ifelse + end + }bind def + } + ifelse + end + end + Adobe_CoolType_Core_Defined not + { + Adobe_CoolType_Core/findfont + { + $SubstituteFont + begin + $depth 0 eq + { + /$fontname 1 index dup type/stringtype ne{$str cvs}if def + /$substituteFound false def + } + if + /$depth $depth 1 add def + end + scfindfont + $SubstituteFont + begin + /$depth $depth 1 sub def + $substituteFound $depth 0 eq and + { + $inVMIndex null ne + {dup $inVMIndex $AddInVMFont} + if + $doSmartSub + { + currentdict/$Strategy known + {$Strategy/$BuildFont get exec} + if + } + if + } + if + end + }bind put + } + if + } + if + end +/$AddInVMFont + { + exch/FontName 2 copy known + { + get + 1 dict dup begin exch 1 index gcheck def end exch + Adobe_CoolType_Data/InVMFontsByCMap get exch + $DictAdd + } + {pop pop pop} + ifelse + }bind def +/$DictAdd + { + 2 copy known not + {2 copy 4 index length dict put} + if + Level2? not + { + 2 copy get dup maxlength exch length 4 index length add lt + 2 copy get dup length 4 index length add exch maxlength 1 index lt + { + 2 mul dict + begin + 2 copy get{forall}def + 2 copy currentdict put + end + } + {pop} + ifelse + } + if + get + begin + {def} + forall + end + }bind def +end +end +%%EndResource +currentglobal true setglobal +%%BeginResource: procset Adobe_CoolType_Utility_MAKEOCF 1.23 0 +%%Copyright: Copyright 1987-2006 Adobe Systems Incorporated. +%%Version: 1.23 0 +systemdict/languagelevel known dup + {currentglobal false setglobal} + {false} +ifelse +exch +userdict/Adobe_CoolType_Utility 2 copy known + {2 copy get dup maxlength 27 add dict copy} + {27 dict} +ifelse put +Adobe_CoolType_Utility + begin + /@eexecStartData + def + /@recognizeCIDFont null def + /ct_Level2? exch def + /ct_Clone? 1183615869 internaldict dup + /CCRun known not + exch/eCCRun known not + ct_Level2? and or def +ct_Level2? + {globaldict begin currentglobal true setglobal} +if + /ct_AddStdCIDMap + ct_Level2? + {{ + mark + Adobe_CoolType_Utility/@recognizeCIDFont currentdict put + { + ((Hex)57 StartData + 0615 1e27 2c39 1c60 d8a8 cc31 fe2b f6e0 + 7aa3 e541 e21c 60d8 a8c9 c3d0 6d9e 1c60 + d8a8 c9c2 02d7 9a1c 60d8 a849 1c60 d8a8 + cc36 74f4 1144 b13b 77)0()/SubFileDecode filter cvx exec + } + stopped + { + cleartomark + Adobe_CoolType_Utility/@recognizeCIDFont get + countdictstack dup array dictstack + exch 1 sub -1 0 + { + 2 copy get 3 index eq + {1 index length exch sub 1 sub{end}repeat exit} + {pop} + ifelse + } + for + pop pop + Adobe_CoolType_Utility/@eexecStartData get eexec + } + {cleartomark} + ifelse + }} + {{ + Adobe_CoolType_Utility/@eexecStartData get eexec + }} + ifelse bind def +userdict/cid_extensions known +dup{cid_extensions/cid_UpdateDB known and}if + { + cid_extensions + begin + /cid_GetCIDSystemInfo + { + 1 index type/stringtype eq + {exch cvn exch} + if + cid_extensions + begin + dup load 2 index known + { + 2 copy + cid_GetStatusInfo + dup null ne + { + 1 index load + 3 index get + dup null eq + {pop pop cid_UpdateDB} + { + exch + 1 index/Created get eq + {exch pop exch pop} + {pop cid_UpdateDB} + ifelse + } + ifelse + } + {pop cid_UpdateDB} + ifelse + } + {cid_UpdateDB} + ifelse + end + }bind def + end + } +if +ct_Level2? + {end setglobal} +if + /ct_UseNativeCapability? systemdict/composefont known def + /ct_MakeOCF 35 dict def + /ct_Vars 25 dict def + /ct_GlyphDirProcs 6 dict def + /ct_BuildCharDict 15 dict dup + begin + /charcode 2 string def + /dst_string 1500 string def + /nullstring()def + /usewidths? true def + end def + ct_Level2?{setglobal}{pop}ifelse + ct_GlyphDirProcs + begin + /GetGlyphDirectory + { + systemdict/languagelevel known + {pop/CIDFont findresource/GlyphDirectory get} + { + 1 index/CIDFont findresource/GlyphDirectory + get dup type/dicttype eq + { + dup dup maxlength exch length sub 2 index lt + { + dup length 2 index add dict copy 2 index + /CIDFont findresource/GlyphDirectory 2 index put + } + if + } + if + exch pop exch pop + } + ifelse + + + }def + /+ + { + systemdict/languagelevel known + { + currentglobal false setglobal + 3 dict begin + /vm exch def + } + {1 dict begin} + ifelse + /$ exch def + systemdict/languagelevel known + { + vm setglobal + /gvm currentglobal def + $ gcheck setglobal + } + if + ?{$ begin}if + }def + /?{$ type/dicttype eq}def + /|{ + userdict/Adobe_CoolType_Data known + { + Adobe_CoolType_Data/AddWidths? known + { + currentdict Adobe_CoolType_Data + begin + begin + AddWidths? + { + Adobe_CoolType_Data/CC 3 index put + ?{def}{$ 3 1 roll put}ifelse + CC charcode exch 1 index 0 2 index 256 idiv put + 1 index exch 1 exch 256 mod put + stringwidth 2 array astore + currentfont/Widths get exch CC exch put + } + {?{def}{$ 3 1 roll put}ifelse} + ifelse + end + end + } + {?{def}{$ 3 1 roll put}ifelse} ifelse + } + {?{def}{$ 3 1 roll put}ifelse} + ifelse + }def + /! + { + ?{end}if + systemdict/languagelevel known + {gvm setglobal} + if + end + }def + /:{string currentfile exch readstring pop}executeonly def + end + ct_MakeOCF + begin + /ct_cHexEncoding + [/c00/c01/c02/c03/c04/c05/c06/c07/c08/c09/c0A/c0B/c0C/c0D/c0E/c0F/c10/c11/c12 + /c13/c14/c15/c16/c17/c18/c19/c1A/c1B/c1C/c1D/c1E/c1F/c20/c21/c22/c23/c24/c25 + /c26/c27/c28/c29/c2A/c2B/c2C/c2D/c2E/c2F/c30/c31/c32/c33/c34/c35/c36/c37/c38 + /c39/c3A/c3B/c3C/c3D/c3E/c3F/c40/c41/c42/c43/c44/c45/c46/c47/c48/c49/c4A/c4B + /c4C/c4D/c4E/c4F/c50/c51/c52/c53/c54/c55/c56/c57/c58/c59/c5A/c5B/c5C/c5D/c5E + /c5F/c60/c61/c62/c63/c64/c65/c66/c67/c68/c69/c6A/c6B/c6C/c6D/c6E/c6F/c70/c71 + /c72/c73/c74/c75/c76/c77/c78/c79/c7A/c7B/c7C/c7D/c7E/c7F/c80/c81/c82/c83/c84 + /c85/c86/c87/c88/c89/c8A/c8B/c8C/c8D/c8E/c8F/c90/c91/c92/c93/c94/c95/c96/c97 + /c98/c99/c9A/c9B/c9C/c9D/c9E/c9F/cA0/cA1/cA2/cA3/cA4/cA5/cA6/cA7/cA8/cA9/cAA + /cAB/cAC/cAD/cAE/cAF/cB0/cB1/cB2/cB3/cB4/cB5/cB6/cB7/cB8/cB9/cBA/cBB/cBC/cBD + /cBE/cBF/cC0/cC1/cC2/cC3/cC4/cC5/cC6/cC7/cC8/cC9/cCA/cCB/cCC/cCD/cCE/cCF/cD0 + /cD1/cD2/cD3/cD4/cD5/cD6/cD7/cD8/cD9/cDA/cDB/cDC/cDD/cDE/cDF/cE0/cE1/cE2/cE3 + /cE4/cE5/cE6/cE7/cE8/cE9/cEA/cEB/cEC/cED/cEE/cEF/cF0/cF1/cF2/cF3/cF4/cF5/cF6 + /cF7/cF8/cF9/cFA/cFB/cFC/cFD/cFE/cFF]def + /ct_CID_STR_SIZE 8000 def + /ct_mkocfStr100 100 string def + /ct_defaultFontMtx[.001 0 0 .001 0 0]def + /ct_1000Mtx[1000 0 0 1000 0 0]def + /ct_raise{exch cvx exch errordict exch get exec stop}bind def + /ct_reraise + {cvx $error/errorname get(Error: )print dup( )cvs print + errordict exch get exec stop + }bind def + /ct_cvnsi + { + 1 index add 1 sub 1 exch 0 4 1 roll + { + 2 index exch get + exch 8 bitshift + add + } + for + exch pop + }bind def + /ct_GetInterval + { + Adobe_CoolType_Utility/ct_BuildCharDict get + begin + /dst_index 0 def + dup dst_string length gt + {dup string/dst_string exch def} + if + 1 index ct_CID_STR_SIZE idiv + /arrayIndex exch def + 2 index arrayIndex get + 2 index + arrayIndex ct_CID_STR_SIZE mul + sub + { + dup 3 index add 2 index length le + { + 2 index getinterval + dst_string dst_index 2 index putinterval + length dst_index add/dst_index exch def + exit + } + { + 1 index length 1 index sub + dup 4 1 roll + getinterval + dst_string dst_index 2 index putinterval + pop dup dst_index add/dst_index exch def + sub + /arrayIndex arrayIndex 1 add def + 2 index dup length arrayIndex gt + {arrayIndex get} + { + pop + exit + } + ifelse + 0 + } + ifelse + } + loop + pop pop pop + dst_string 0 dst_index getinterval + end + }bind def + ct_Level2? + { + /ct_resourcestatus + currentglobal mark true setglobal + {/unknowninstancename/Category resourcestatus} + stopped + {cleartomark setglobal true} + {cleartomark currentglobal not exch setglobal} + ifelse + { + { + mark 3 1 roll/Category findresource + begin + ct_Vars/vm currentglobal put + ({ResourceStatus}stopped)0()/SubFileDecode filter cvx exec + {cleartomark false} + {{3 2 roll pop true}{cleartomark false}ifelse} + ifelse + ct_Vars/vm get setglobal + end + } + } + {{resourcestatus}} + ifelse bind def + /CIDFont/Category ct_resourcestatus + {pop pop} + { + currentglobal true setglobal + /Generic/Category findresource + dup length dict copy + dup/InstanceType/dicttype put + /CIDFont exch/Category defineresource pop + setglobal + } + ifelse + ct_UseNativeCapability? + { + /CIDInit/ProcSet findresource begin + 12 dict begin + begincmap + /CIDSystemInfo 3 dict dup begin + /Registry(Adobe)def + /Ordering(Identity)def + /Supplement 0 def + end def + /CMapName/Identity-H def + /CMapVersion 1.000 def + /CMapType 1 def + 1 begincodespacerange + <0000> + endcodespacerange + 1 begincidrange + <0000>0 + endcidrange + endcmap + CMapName currentdict/CMap defineresource pop + end + end + } + if + } + { + /ct_Category 2 dict begin + /CIDFont 10 dict def + /ProcSet 2 dict def + currentdict + end + def + /defineresource + { + ct_Category 1 index 2 copy known + { + get + dup dup maxlength exch length eq + { + dup length 10 add dict copy + ct_Category 2 index 2 index put + } + if + 3 index 3 index put + pop exch pop + } + {pop pop/defineresource/undefined ct_raise} + ifelse + }bind def + /findresource + { + ct_Category 1 index 2 copy known + { + get + 2 index 2 copy known + {get 3 1 roll pop pop} + {pop pop/findresource/undefinedresource ct_raise} + ifelse + } + {pop pop/findresource/undefined ct_raise} + ifelse + }bind def + /resourcestatus + { + ct_Category 1 index 2 copy known + { + get + 2 index known + exch pop exch pop + { + 0 -1 true + } + { + false + } + ifelse + } + {pop pop/findresource/undefined ct_raise} + ifelse + }bind def + /ct_resourcestatus/resourcestatus load def + } + ifelse + /ct_CIDInit 2 dict + begin + /ct_cidfont_stream_init + { + { + dup(Binary)eq + { + pop + null + currentfile + ct_Level2? + { + {cid_BYTE_COUNT()/SubFileDecode filter} + stopped + {pop pop pop} + if + } + if + /readstring load + exit + } + if + dup(Hex)eq + { + pop + currentfile + ct_Level2? + { + {null exch/ASCIIHexDecode filter/readstring} + stopped + {pop exch pop(>)exch/readhexstring} + if + } + {(>)exch/readhexstring} + ifelse + load + exit + } + if + /StartData/typecheck ct_raise + } + loop + cid_BYTE_COUNT ct_CID_STR_SIZE le + { + 2 copy cid_BYTE_COUNT string exch exec + pop + 1 array dup + 3 -1 roll + 0 exch put + } + { + cid_BYTE_COUNT ct_CID_STR_SIZE div ceiling cvi + dup array exch 2 sub 0 exch 1 exch + { + 2 copy + 5 index + ct_CID_STR_SIZE + string + 6 index exec + pop + put + pop + } + for + 2 index + cid_BYTE_COUNT ct_CID_STR_SIZE mod string + 3 index exec + pop + 1 index exch + 1 index length 1 sub + exch put + } + ifelse + cid_CIDFONT exch/GlyphData exch put + 2 index null eq + { + pop pop pop + } + { + pop/readstring load + 1 string exch + { + 3 copy exec + pop + dup length 0 eq + { + pop pop pop pop pop + true exit + } + if + 4 index + eq + { + pop pop pop pop + false exit + } + if + } + loop + pop + } + ifelse + }bind def + /StartData + { + mark + { + currentdict + dup/FDArray get 0 get/FontMatrix get + 0 get 0.001 eq + { + dup/CDevProc known not + { + /CDevProc 1183615869 internaldict/stdCDevProc 2 copy known + {get} + { + pop pop + {pop pop pop pop pop 0 -1000 7 index 2 div 880} + } + ifelse + def + } + if + } + { + /CDevProc + { + pop pop pop pop pop + 0 + 1 cid_temp/cid_CIDFONT get + /FDArray get 0 get + /FontMatrix get 0 get div + 7 index 2 div + 1 index 0.88 mul + }def + } + ifelse + /cid_temp 15 dict def + cid_temp + begin + /cid_CIDFONT exch def + 3 copy pop + dup/cid_BYTE_COUNT exch def 0 gt + { + ct_cidfont_stream_init + FDArray + { + /Private get + dup/SubrMapOffset known + { + begin + /Subrs SubrCount array def + Subrs + SubrMapOffset + SubrCount + SDBytes + ct_Level2? + { + currentdict dup/SubrMapOffset undef + dup/SubrCount undef + /SDBytes undef + } + if + end + /cid_SD_BYTES exch def + /cid_SUBR_COUNT exch def + /cid_SUBR_MAP_OFFSET exch def + /cid_SUBRS exch def + cid_SUBR_COUNT 0 gt + { + GlyphData cid_SUBR_MAP_OFFSET cid_SD_BYTES ct_GetInterval + 0 cid_SD_BYTES ct_cvnsi + 0 1 cid_SUBR_COUNT 1 sub + { + exch 1 index + 1 add + cid_SD_BYTES mul cid_SUBR_MAP_OFFSET add + GlyphData exch cid_SD_BYTES ct_GetInterval + 0 cid_SD_BYTES ct_cvnsi + cid_SUBRS 4 2 roll + GlyphData exch + 4 index + 1 index + sub + ct_GetInterval + dup length string copy put + } + for + pop + } + if + } + {pop} + ifelse + } + forall + } + if + cleartomark pop pop + end + CIDFontName currentdict/CIDFont defineresource pop + end end + } + stopped + {cleartomark/StartData ct_reraise} + if + }bind def + currentdict + end def + /ct_saveCIDInit + { + /CIDInit/ProcSet ct_resourcestatus + {true} + {/CIDInitC/ProcSet ct_resourcestatus} + ifelse + { + pop pop + /CIDInit/ProcSet findresource + ct_UseNativeCapability? + {pop null} + {/CIDInit ct_CIDInit/ProcSet defineresource pop} + ifelse + } + {/CIDInit ct_CIDInit/ProcSet defineresource pop null} + ifelse + ct_Vars exch/ct_oldCIDInit exch put + }bind def + /ct_restoreCIDInit + { + ct_Vars/ct_oldCIDInit get dup null ne + {/CIDInit exch/ProcSet defineresource pop} + {pop} + ifelse + }bind def + /ct_BuildCharSetUp + { + 1 index + begin + CIDFont + begin + Adobe_CoolType_Utility/ct_BuildCharDict get + begin + /ct_dfCharCode exch def + /ct_dfDict exch def + CIDFirstByte ct_dfCharCode add + dup CIDCount ge + {pop 0} + if + /cid exch def + { + GlyphDirectory cid 2 copy known + {get} + {pop pop nullstring} + ifelse + dup length FDBytes sub 0 gt + { + dup + FDBytes 0 ne + {0 FDBytes ct_cvnsi} + {pop 0} + ifelse + /fdIndex exch def + dup length FDBytes sub FDBytes exch getinterval + /charstring exch def + exit + } + { + pop + cid 0 eq + {/charstring nullstring def exit} + if + /cid 0 def + } + ifelse + } + loop + }def + /ct_SetCacheDevice + { + 0 0 moveto + dup stringwidth + 3 -1 roll + true charpath + pathbbox + 0 -1000 + 7 index 2 div 880 + setcachedevice2 + 0 0 moveto + }def + /ct_CloneSetCacheProc + { + 1 eq + { + stringwidth + pop -2 div -880 + 0 -1000 setcharwidth + moveto + } + { + usewidths? + { + currentfont/Widths get cid + 2 copy known + {get exch pop aload pop} + {pop pop stringwidth} + ifelse + } + {stringwidth} + ifelse + setcharwidth + 0 0 moveto + } + ifelse + }def + /ct_Type3ShowCharString + { + ct_FDDict fdIndex 2 copy known + {get} + { + currentglobal 3 1 roll + 1 index gcheck setglobal + ct_Type1FontTemplate dup maxlength dict copy + begin + FDArray fdIndex get + dup/FontMatrix 2 copy known + {get} + {pop pop ct_defaultFontMtx} + ifelse + /FontMatrix exch dup length array copy def + /Private get + /Private exch def + /Widths rootfont/Widths get def + /CharStrings 1 dict dup/.notdef + dup length string copy put def + currentdict + end + /ct_Type1Font exch definefont + dup 5 1 roll put + setglobal + } + ifelse + dup/CharStrings get 1 index/Encoding get + ct_dfCharCode get charstring put + rootfont/WMode 2 copy known + {get} + {pop pop 0} + ifelse + exch + 1000 scalefont setfont + ct_str1 0 ct_dfCharCode put + ct_str1 exch ct_dfSetCacheProc + ct_SyntheticBold + { + currentpoint + ct_str1 show + newpath + moveto + ct_str1 true charpath + ct_StrokeWidth setlinewidth + stroke + } + {ct_str1 show} + ifelse + }def + /ct_Type4ShowCharString + { + ct_dfDict ct_dfCharCode charstring + FDArray fdIndex get + dup/FontMatrix get dup ct_defaultFontMtx ct_matrixeq not + {ct_1000Mtx matrix concatmatrix concat} + {pop} + ifelse + /Private get + Adobe_CoolType_Utility/ct_Level2? get not + { + ct_dfDict/Private + 3 -1 roll + {put} + 1183615869 internaldict/superexec get exec + } + if + 1183615869 internaldict + Adobe_CoolType_Utility/ct_Level2? get + {1 index} + {3 index/Private get mark 6 1 roll} + ifelse + dup/RunInt known + {/RunInt get} + {pop/CCRun} + ifelse + get exec + Adobe_CoolType_Utility/ct_Level2? get not + {cleartomark} + if + }bind def + /ct_BuildCharIncremental + { + { + Adobe_CoolType_Utility/ct_MakeOCF get begin + ct_BuildCharSetUp + ct_ShowCharString + } + stopped + {stop} + if + end + end + end + end + }bind def + /BaseFontNameStr(BF00)def + /ct_Type1FontTemplate 14 dict + begin + /FontType 1 def + /FontMatrix [0.001 0 0 0.001 0 0]def + /FontBBox [-250 -250 1250 1250]def + /Encoding ct_cHexEncoding def + /PaintType 0 def + currentdict + end def + /BaseFontTemplate 11 dict + begin + /FontMatrix [0.001 0 0 0.001 0 0]def + /FontBBox [-250 -250 1250 1250]def + /Encoding ct_cHexEncoding def + /BuildChar/ct_BuildCharIncremental load def + ct_Clone? + { + /FontType 3 def + /ct_ShowCharString/ct_Type3ShowCharString load def + /ct_dfSetCacheProc/ct_CloneSetCacheProc load def + /ct_SyntheticBold false def + /ct_StrokeWidth 1 def + } + { + /FontType 4 def + /Private 1 dict dup/lenIV 4 put def + /CharStrings 1 dict dup/.notdefput def + /PaintType 0 def + /ct_ShowCharString/ct_Type4ShowCharString load def + } + ifelse + /ct_str1 1 string def + currentdict + end def + /BaseFontDictSize BaseFontTemplate length 5 add def + /ct_matrixeq + { + true 0 1 5 + { + dup 4 index exch get exch 3 index exch get eq and + dup not + {exit} + if + } + for + exch pop exch pop + }bind def + /ct_makeocf + { + 15 dict + begin + exch/WMode exch def + exch/FontName exch def + /FontType 0 def + /FMapType 2 def + dup/FontMatrix known + {dup/FontMatrix get/FontMatrix exch def} + {/FontMatrix matrix def} + ifelse + /bfCount 1 index/CIDCount get 256 idiv 1 add + dup 256 gt{pop 256}if def + /Encoding + 256 array 0 1 bfCount 1 sub{2 copy dup put pop}for + bfCount 1 255{2 copy bfCount put pop}for + def + /FDepVector bfCount dup 256 lt{1 add}if array def + BaseFontTemplate BaseFontDictSize dict copy + begin + /CIDFont exch def + CIDFont/FontBBox known + {CIDFont/FontBBox get/FontBBox exch def} + if + CIDFont/CDevProc known + {CIDFont/CDevProc get/CDevProc exch def} + if + currentdict + end + BaseFontNameStr 3(0)putinterval + 0 1 bfCount dup 256 eq{1 sub}if + { + FDepVector exch + 2 index BaseFontDictSize dict copy + begin + dup/CIDFirstByte exch 256 mul def + FontType 3 eq + {/ct_FDDict 2 dict def} + if + currentdict + end + 1 index 16 + BaseFontNameStr 2 2 getinterval cvrs pop + BaseFontNameStr exch definefont + put + } + for + ct_Clone? + {/Widths 1 index/CIDFont get/GlyphDirectory get length dict def} + if + FontName + currentdict + end + definefont + ct_Clone? + { + gsave + dup 1000 scalefont setfont + ct_BuildCharDict + begin + /usewidths? false def + currentfont/Widths get + begin + exch/CIDFont get/GlyphDirectory get + { + pop + dup charcode exch 1 index 0 2 index 256 idiv put + 1 index exch 1 exch 256 mod put + stringwidth 2 array astore def + } + forall + end + /usewidths? true def + end + grestore + } + {exch pop} + ifelse + }bind def + currentglobal true setglobal + /ct_ComposeFont + { + ct_UseNativeCapability? + { + 2 index/CMap ct_resourcestatus + {pop pop exch pop} + { + /CIDInit/ProcSet findresource + begin + 12 dict + begin + begincmap + /CMapName 3 index def + /CMapVersion 1.000 def + /CMapType 1 def + exch/WMode exch def + /CIDSystemInfo 3 dict dup + begin + /Registry(Adobe)def + /Ordering + CMapName ct_mkocfStr100 cvs + (Adobe-)search + { + pop pop + (-)search + { + dup length string copy + exch pop exch pop + } + {pop(Identity)} + ifelse + } + {pop (Identity)} + ifelse + def + /Supplement 0 def + end def + 1 begincodespacerange + <0000> + endcodespacerange + 1 begincidrange + <0000>0 + endcidrange + endcmap + CMapName currentdict/CMap defineresource pop + end + end + } + ifelse + composefont + } + { + 3 2 roll pop + 0 get/CIDFont findresource + ct_makeocf + } + ifelse + }bind def + setglobal + /ct_MakeIdentity + { + ct_UseNativeCapability? + { + 1 index/CMap ct_resourcestatus + {pop pop} + { + /CIDInit/ProcSet findresource begin + 12 dict begin + begincmap + /CMapName 2 index def + /CMapVersion 1.000 def + /CMapType 1 def + /CIDSystemInfo 3 dict dup + begin + /Registry(Adobe)def + /Ordering + CMapName ct_mkocfStr100 cvs + (Adobe-)search + { + pop pop + (-)search + {dup length string copy exch pop exch pop} + {pop(Identity)} + ifelse + } + {pop(Identity)} + ifelse + def + /Supplement 0 def + end def + 1 begincodespacerange + <0000> + endcodespacerange + 1 begincidrange + <0000>0 + endcidrange + endcmap + CMapName currentdict/CMap defineresource pop + end + end + } + ifelse + composefont + } + { + exch pop + 0 get/CIDFont findresource + ct_makeocf + } + ifelse + }bind def + currentdict readonly pop + end + end +%%EndResource +setglobal +%%BeginResource: procset Adobe_CoolType_Utility_T42 1.0 0 +%%Copyright: Copyright 1987-2004 Adobe Systems Incorporated. +%%Version: 1.0 0 +userdict/ct_T42Dict 15 dict put +ct_T42Dict begin +/Is2015? +{ + version + cvi + 2015 + ge +}bind def +/AllocGlyphStorage +{ + Is2015? + { + pop + } + { + {string}forall + }ifelse +}bind def +/Type42DictBegin +{ +25 dict begin + /FontName exch def + /CharStrings 256 dict +begin + /.notdef 0 def + currentdict +end def + /Encoding exch def + /PaintType 0 def + /FontType 42 def + /FontMatrix[1 0 0 1 0 0]def + 4 array astore cvx/FontBBox exch def + /sfnts +}bind def +/Type42DictEnd +{ + currentdict dup/FontName get exch definefont end +ct_T42Dict exch +dup/FontName get exch put +}bind def +/RD{string currentfile exch readstring pop}executeonly def +/PrepFor2015 +{ +Is2015? +{ + /GlyphDirectory + 16 + dict def + sfnts 0 get + dup + 2 index + (glyx) + putinterval + 2 index + (locx) + putinterval + pop + pop +} +{ + pop + pop +}ifelse +}bind def +/AddT42Char +{ +Is2015? +{ + /GlyphDirectory get + begin + def + end + pop + pop +} +{ + /sfnts get + 4 index + get + 3 index + 2 index + putinterval + pop + pop + pop + pop +}ifelse +}bind def +/T0AddT42Mtx2 +{ +/CIDFont findresource/Metrics2 get begin def end +}bind def +end +%%EndResource +currentglobal true setglobal +%%BeginFile: MMFauxFont.prc +%%Copyright: Copyright 1987-2001 Adobe Systems Incorporated. +%%All Rights Reserved. +userdict /ct_EuroDict 10 dict put +ct_EuroDict begin +/ct_CopyFont +{ + { 1 index /FID ne {def} {pop pop} ifelse} forall +} def +/ct_GetGlyphOutline +{ + gsave + initmatrix newpath + exch findfont dup + length 1 add dict + begin + ct_CopyFont + /Encoding Encoding dup length array copy + dup + 4 -1 roll + 0 exch put + def + currentdict + end + /ct_EuroFont exch definefont + 1000 scalefont setfont + 0 0 moveto + [ + <00> stringwidth + <00> false charpath + pathbbox + [ + {/m cvx} {/l cvx} {/c cvx} {/cp cvx} pathforall + grestore + counttomark 8 add +} +def +/ct_MakeGlyphProc +{ + ] cvx + /ct_PSBuildGlyph cvx + ] cvx +} def +/ct_PSBuildGlyph +{ + gsave + 8 -1 roll pop + 7 1 roll + 6 -2 roll ct_FontMatrix transform 6 2 roll + 4 -2 roll ct_FontMatrix transform 4 2 roll + ct_FontMatrix transform + currentdict /PaintType 2 copy known {get 2 eq}{pop pop false} ifelse + dup 9 1 roll + { + currentdict /StrokeWidth 2 copy known + { + get 2 div + 0 ct_FontMatrix dtransform pop + 5 1 roll + 4 -1 roll 4 index sub + 4 1 roll + 3 -1 roll 4 index sub + 3 1 roll + exch 4 index add exch + 4 index add + 5 -1 roll pop + } + { + pop pop + } + ifelse + } + if + setcachedevice + ct_FontMatrix concat + ct_PSPathOps begin + exec + end + { + currentdict /StrokeWidth 2 copy known + { get } + { pop pop 0 } + ifelse + setlinewidth stroke + } + { + fill + } + ifelse + grestore +} def +/ct_PSPathOps 4 dict dup begin + /m {moveto} def + /l {lineto} def + /c {curveto} def + /cp {closepath} def +end +def +/ct_matrix1000 [1000 0 0 1000 0 0] def +/ct_AddGlyphProc +{ + 2 index findfont dup length 4 add dict + begin + ct_CopyFont + /CharStrings CharStrings dup length 1 add dict copy + begin + 3 1 roll def + currentdict + end + def + /ct_FontMatrix ct_matrix1000 FontMatrix matrix concatmatrix def + /ct_PSBuildGlyph /ct_PSBuildGlyph load def + /ct_PSPathOps /ct_PSPathOps load def + currentdict + end + definefont pop +} +def +systemdict /languagelevel known +{ + /ct_AddGlyphToPrinterFont { + 2 copy + ct_GetGlyphOutline 3 add -1 roll restore + ct_MakeGlyphProc + ct_AddGlyphProc + } def +} +{ + /ct_AddGlyphToPrinterFont { + pop pop restore + Adobe_CTFauxDict /$$$FONTNAME get + /Euro + Adobe_CTFauxDict /$$$SUBSTITUTEBASE get + ct_EuroDict exch get + ct_AddGlyphProc + } def +} ifelse +/AdobeSansMM +{ +556 0 24 -19 541 703 + { + 541 628 m + 510 669 442 703 354 703 c + 201 703 117 607 101 444 c + 50 444 l + 25 372 l + 97 372 l + 97 301 l + 49 301 l + 24 229 l + 103 229 l + 124 67 209 -19 350 -19 c + 435 -19 501 25 509 32 c + 509 131 l + 492 105 417 60 343 60 c + 267 60 204 127 197 229 c + 406 229 l + 430 301 l + 191 301 l + 191 372 l + 455 372 l + 479 444 l + 194 444 l + 201 531 245 624 348 624 c + 433 624 484 583 509 534 c + cp + 556 0 m + } +ct_PSBuildGlyph +} def +/AdobeSerifMM +{ +500 0 10 -12 484 692 + { + 347 298 m + 171 298 l + 170 310 170 322 170 335 c + 170 362 l + 362 362 l + 374 403 l + 172 403 l + 184 580 244 642 308 642 c + 380 642 434 574 457 457 c + 481 462 l + 474 691 l + 449 691 l + 433 670 429 657 410 657 c + 394 657 360 692 299 692 c + 204 692 94 604 73 403 c + 22 403 l + 10 362 l + 70 362 l + 69 352 69 341 69 330 c + 69 319 69 308 70 298 c + 22 298 l + 10 257 l + 73 257 l + 97 57 216 -12 295 -12 c + 364 -12 427 25 484 123 c + 458 142 l + 425 101 384 37 316 37 c + 256 37 189 84 173 257 c + 335 257 l + cp + 500 0 m + } +ct_PSBuildGlyph +} def +end +%%EndFile +setglobal +Adobe_CoolType_Core begin /$None SetSubstituteStrategy end +%%BeginResource: procset Adobe_AGM_Image 1.0 0 +%%Version: 1.0 0 +%%Copyright: Copyright(C)2000-2006 Adobe Systems, Inc. All Rights Reserved. +systemdict/setpacking known +{ + currentpacking + true setpacking +}if +userdict/Adobe_AGM_Image 71 dict dup begin put +/Adobe_AGM_Image_Id/Adobe_AGM_Image_1.0_0 def +/nd{ + null def +}bind def +/AGMIMG_&image nd +/AGMIMG_&colorimage nd +/AGMIMG_&imagemask nd +/AGMIMG_mbuf()def +/AGMIMG_ybuf()def +/AGMIMG_kbuf()def +/AGMIMG_c 0 def +/AGMIMG_m 0 def +/AGMIMG_y 0 def +/AGMIMG_k 0 def +/AGMIMG_tmp nd +/AGMIMG_imagestring0 nd +/AGMIMG_imagestring1 nd +/AGMIMG_imagestring2 nd +/AGMIMG_imagestring3 nd +/AGMIMG_imagestring4 nd +/AGMIMG_imagestring5 nd +/AGMIMG_cnt nd +/AGMIMG_fsave nd +/AGMIMG_colorAry nd +/AGMIMG_override nd +/AGMIMG_name nd +/AGMIMG_maskSource nd +/AGMIMG_flushfilters nd +/invert_image_samples nd +/knockout_image_samples nd +/img nd +/sepimg nd +/devnimg nd +/idximg nd +/ds +{ + Adobe_AGM_Core begin + Adobe_AGM_Image begin + /AGMIMG_&image systemdict/image get def + /AGMIMG_&imagemask systemdict/imagemask get def + /colorimage where{ + pop + /AGMIMG_&colorimage/colorimage ldf + }if + end + end +}def +/ps +{ + Adobe_AGM_Image begin + /AGMIMG_ccimage_exists{/customcolorimage where + { + pop + /Adobe_AGM_OnHost_Seps where + { + pop false + }{ + /Adobe_AGM_InRip_Seps where + { + pop false + }{ + true + }ifelse + }ifelse + }{ + false + }ifelse + }bdf + level2{ + /invert_image_samples + { + Adobe_AGM_Image/AGMIMG_tmp Decode length ddf + /Decode[Decode 1 get Decode 0 get]def + }def + /knockout_image_samples + { + Operator/imagemask ne{ + /Decode[1 1]def + }if + }def + }{ + /invert_image_samples + { + {1 exch sub}currenttransfer addprocs settransfer + }def + /knockout_image_samples + { + {pop 1}currenttransfer addprocs settransfer + }def + }ifelse + /img/imageormask ldf + /sepimg/sep_imageormask ldf + /devnimg/devn_imageormask ldf + /idximg/indexed_imageormask ldf + /_ctype 7 def + currentdict{ + dup xcheck 1 index type dup/arraytype eq exch/packedarraytype eq or and{ + bind + }if + def + }forall +}def +/pt +{ + end +}def +/dt +{ +}def +/AGMIMG_flushfilters +{ + dup type/arraytype ne + {1 array astore}if + dup 0 get currentfile ne + {dup 0 get flushfile}if + { + dup type/filetype eq + { + dup status 1 index currentfile ne and + {closefile} + {pop} + ifelse + }{pop}ifelse + }forall +}def +/AGMIMG_init_common +{ + currentdict/T known{/ImageType/T ldf currentdict/T undef}if + currentdict/W known{/Width/W ldf currentdict/W undef}if + currentdict/H known{/Height/H ldf currentdict/H undef}if + currentdict/M known{/ImageMatrix/M ldf currentdict/M undef}if + currentdict/BC known{/BitsPerComponent/BC ldf currentdict/BC undef}if + currentdict/D known{/Decode/D ldf currentdict/D undef}if + currentdict/DS known{/DataSource/DS ldf currentdict/DS undef}if + currentdict/O known{ + /Operator/O load 1 eq{ + /imagemask + }{ + /O load 2 eq{ + /image + }{ + /colorimage + }ifelse + }ifelse + def + currentdict/O undef + }if + currentdict/HSCI known{/HostSepColorImage/HSCI ldf currentdict/HSCI undef}if + currentdict/MD known{/MultipleDataSources/MD ldf currentdict/MD undef}if + currentdict/I known{/Interpolate/I ldf currentdict/I undef}if + currentdict/SI known{/SkipImageProc/SI ldf currentdict/SI undef}if + /DataSource load xcheck not{ + DataSource type/arraytype eq{ + DataSource 0 get type/filetype eq{ + /_Filters DataSource def + currentdict/MultipleDataSources known not{ + /DataSource DataSource dup length 1 sub get def + }if + }if + }if + currentdict/MultipleDataSources known not{ + /MultipleDataSources DataSource type/arraytype eq{ + DataSource length 1 gt + } + {false}ifelse def + }if + }if + /NComponents Decode length 2 div def + currentdict/SkipImageProc known not{/SkipImageProc{false}def}if +}bdf +/imageormask_sys +{ + begin + AGMIMG_init_common + save mark + level2{ + currentdict + Operator/imagemask eq{ + AGMIMG_&imagemask + }{ + use_mask{ + process_mask AGMIMG_&image + }{ + AGMIMG_&image + }ifelse + }ifelse + }{ + Width Height + Operator/imagemask eq{ + Decode 0 get 1 eq Decode 1 get 0 eq and + ImageMatrix/DataSource load + AGMIMG_&imagemask + }{ + BitsPerComponent ImageMatrix/DataSource load + AGMIMG_&image + }ifelse + }ifelse + currentdict/_Filters known{_Filters AGMIMG_flushfilters}if + cleartomark restore + end +}def +/overprint_plate +{ + currentoverprint{ + 0 get dup type/nametype eq{ + dup/DeviceGray eq{ + pop AGMCORE_black_plate not + }{ + /DeviceCMYK eq{ + AGMCORE_is_cmyk_sep not + }if + }ifelse + }{ + false exch + { + AGMOHS_sepink eq or + }forall + not + }ifelse + }{ + pop false + }ifelse +}def +/process_mask +{ + level3{ + dup begin + /ImageType 1 def + end + 4 dict begin + /DataDict exch def + /ImageType 3 def + /InterleaveType 3 def + /MaskDict 9 dict begin + /ImageType 1 def + /Width DataDict dup/MaskWidth known{/MaskWidth}{/Width}ifelse get def + /Height DataDict dup/MaskHeight known{/MaskHeight}{/Height}ifelse get def + /ImageMatrix[Width 0 0 Height neg 0 Height]def + /NComponents 1 def + /BitsPerComponent 1 def + /Decode DataDict dup/MaskD known{/MaskD}{[1 0]}ifelse get def + /DataSource Adobe_AGM_Core/AGMIMG_maskSource get def + currentdict end def + currentdict end + }if +}def +/use_mask +{ + dup/Mask known {dup/Mask get}{false}ifelse +}def +/imageormask +{ + begin + AGMIMG_init_common + SkipImageProc{ + currentdict consumeimagedata + } + { + save mark + level2 AGMCORE_host_sep not and{ + currentdict + Operator/imagemask eq DeviceN_PS2 not and{ + imagemask + }{ + AGMCORE_in_rip_sep currentoverprint and currentcolorspace 0 get/DeviceGray eq and{ + [/Separation/Black/DeviceGray{}]setcolorspace + /Decode[Decode 1 get Decode 0 get]def + }if + use_mask{ + process_mask image + }{ + DeviceN_NoneName DeviceN_PS2 Indexed_DeviceN level3 not and or or AGMCORE_in_rip_sep and + { + Names convert_to_process not{ + 2 dict begin + /imageDict xdf + /names_index 0 def + gsave + imageDict write_image_file{ + Names{ + dup(None)ne{ + [/Separation 3 -1 roll/DeviceGray{1 exch sub}]setcolorspace + Operator imageDict read_image_file + names_index 0 eq{true setoverprint}if + /names_index names_index 1 add def + }{ + pop + }ifelse + }forall + close_image_file + }if + grestore + end + }{ + Operator/imagemask eq{ + imagemask + }{ + image + }ifelse + }ifelse + }{ + Operator/imagemask eq{ + imagemask + }{ + image + }ifelse + }ifelse + }ifelse + }ifelse + }{ + Width Height + Operator/imagemask eq{ + Decode 0 get 1 eq Decode 1 get 0 eq and + ImageMatrix/DataSource load + /Adobe_AGM_OnHost_Seps where{ + pop imagemask + }{ + currentgray 1 ne{ + currentdict imageormask_sys + }{ + currentoverprint not{ + 1 AGMCORE_&setgray + currentdict imageormask_sys + }{ + currentdict ignoreimagedata + }ifelse + }ifelse + }ifelse + }{ + BitsPerComponent ImageMatrix + MultipleDataSources{ + 0 1 NComponents 1 sub{ + DataSource exch get + }for + }{ + /DataSource load + }ifelse + Operator/colorimage eq{ + AGMCORE_host_sep{ + MultipleDataSources level2 or NComponents 4 eq and{ + AGMCORE_is_cmyk_sep{ + MultipleDataSources{ + /DataSource DataSource 0 get xcheck + { + [ + DataSource 0 get/exec cvx + DataSource 1 get/exec cvx + DataSource 2 get/exec cvx + DataSource 3 get/exec cvx + /AGMCORE_get_ink_data cvx + ]cvx + }{ + DataSource aload pop AGMCORE_get_ink_data + }ifelse def + }{ + /DataSource + Width BitsPerComponent mul 7 add 8 idiv Height mul 4 mul + /DataSource load + filter_cmyk 0()/SubFileDecode filter def + }ifelse + /Decode[Decode 0 get Decode 1 get]def + /MultipleDataSources false def + /NComponents 1 def + /Operator/image def + invert_image_samples + 1 AGMCORE_&setgray + currentdict imageormask_sys + }{ + currentoverprint not Operator/imagemask eq and{ + 1 AGMCORE_&setgray + currentdict imageormask_sys + }{ + currentdict ignoreimagedata + }ifelse + }ifelse + }{ + MultipleDataSources NComponents AGMIMG_&colorimage + }ifelse + }{ + true NComponents colorimage + }ifelse + }{ + Operator/image eq{ + AGMCORE_host_sep{ + /DoImage true def + currentdict/HostSepColorImage known{HostSepColorImage not}{false}ifelse + { + AGMCORE_black_plate not Operator/imagemask ne and{ + /DoImage false def + currentdict ignoreimagedata + }if + }if + 1 AGMCORE_&setgray + DoImage + {currentdict imageormask_sys}if + }{ + use_mask{ + process_mask image + }{ + image + }ifelse + }ifelse + }{ + Operator/knockout eq{ + pop pop pop pop pop + currentcolorspace overprint_plate not{ + knockout_unitsq + }if + }if + }ifelse + }ifelse + }ifelse + }ifelse + cleartomark restore + }ifelse + currentdict/_Filters known{_Filters AGMIMG_flushfilters}if + end +}def +/sep_imageormask +{ + /sep_colorspace_dict AGMCORE_gget begin + CSA map_csa + begin + AGMIMG_init_common + SkipImageProc{ + currentdict consumeimagedata + }{ + save mark + AGMCORE_avoid_L2_sep_space{ + /Decode[Decode 0 get 255 mul Decode 1 get 255 mul]def + }if + AGMIMG_ccimage_exists + MappedCSA 0 get/DeviceCMYK eq and + currentdict/Components known and + Name()ne and + Name(All)ne and + Operator/image eq and + AGMCORE_producing_seps not and + level2 not and + { + Width Height BitsPerComponent ImageMatrix + [ + /DataSource load/exec cvx + { + 0 1 2 index length 1 sub{ + 1 index exch + 2 copy get 255 xor put + }for + }/exec cvx + ]cvx bind + MappedCSA 0 get/DeviceCMYK eq{ + Components aload pop + }{ + 0 0 0 Components aload pop 1 exch sub + }ifelse + Name findcmykcustomcolor + customcolorimage + }{ + AGMCORE_producing_seps not{ + level2{ + //Adobe_AGM_Core/AGMCORE_pattern_paint_type get 2 ne AGMCORE_avoid_L2_sep_space not and currentcolorspace 0 get/Separation ne and{ + [/Separation Name MappedCSA sep_proc_name exch dup 0 get 15 string cvs(/Device)anchorsearch{pop pop 0 get}{pop}ifelse exch load]setcolorspace_opt + /sep_tint AGMCORE_gget setcolor + }if + currentdict imageormask + }{ + currentdict + Operator/imagemask eq{ + imageormask + }{ + sep_imageormask_lev1 + }ifelse + }ifelse + }{ + AGMCORE_host_sep{ + Operator/knockout eq{ + currentdict/ImageMatrix get concat + knockout_unitsq + }{ + currentgray 1 ne{ + AGMCORE_is_cmyk_sep Name(All)ne and{ + level2{ + Name AGMCORE_IsSeparationAProcessColor + { + Operator/imagemask eq{ + //Adobe_AGM_Core/AGMCORE_pattern_paint_type get 2 ne{ + /sep_tint AGMCORE_gget 1 exch sub AGMCORE_&setcolor + }if + }{ + invert_image_samples + }ifelse + }{ + //Adobe_AGM_Core/AGMCORE_pattern_paint_type get 2 ne{ + [/Separation Name[/DeviceGray] + { + sep_colorspace_proc AGMCORE_get_ink_data + 1 exch sub + }bind + ]AGMCORE_&setcolorspace + /sep_tint AGMCORE_gget AGMCORE_&setcolor + }if + }ifelse + currentdict imageormask_sys + }{ + currentdict + Operator/imagemask eq{ + imageormask_sys + }{ + sep_image_lev1_sep + }ifelse + }ifelse + }{ + Operator/imagemask ne{ + invert_image_samples + }if + currentdict imageormask_sys + }ifelse + }{ + currentoverprint not Name(All)eq or Operator/imagemask eq and{ + currentdict imageormask_sys + }{ + currentoverprint not + { + gsave + knockout_unitsq + grestore + }if + currentdict consumeimagedata + }ifelse + }ifelse + }ifelse + }{ + //Adobe_AGM_Core/AGMCORE_pattern_paint_type get 2 ne{ + currentcolorspace 0 get/Separation ne{ + [/Separation Name MappedCSA sep_proc_name exch 0 get exch load]setcolorspace_opt + /sep_tint AGMCORE_gget setcolor + }if + }if + currentoverprint + MappedCSA 0 get/DeviceCMYK eq and + Name AGMCORE_IsSeparationAProcessColor not and + //Adobe_AGM_Core/AGMCORE_pattern_paint_type get 2 ne{Name inRip_spot_has_ink not and}{false}ifelse + Name(All)ne and{ + imageormask_l2_overprint + }{ + currentdict imageormask + }ifelse + }ifelse + }ifelse + }ifelse + cleartomark restore + }ifelse + currentdict/_Filters known{_Filters AGMIMG_flushfilters}if + end + end +}def +/colorSpaceElemCnt +{ + mark currentcolor counttomark dup 2 add 1 roll cleartomark +}bdf +/devn_sep_datasource +{ + 1 dict begin + /dataSource xdf + [ + 0 1 dataSource length 1 sub{ + dup currentdict/dataSource get/exch cvx/get cvx/exec cvx + /exch cvx names_index/ne cvx[/pop cvx]cvx/if cvx + }for + ]cvx bind + end +}bdf +/devn_alt_datasource +{ + 11 dict begin + /convProc xdf + /origcolorSpaceElemCnt xdf + /origMultipleDataSources xdf + /origBitsPerComponent xdf + /origDecode xdf + /origDataSource xdf + /dsCnt origMultipleDataSources{origDataSource length}{1}ifelse def + /DataSource origMultipleDataSources + { + [ + BitsPerComponent 8 idiv origDecode length 2 idiv mul string + 0 1 origDecode length 2 idiv 1 sub + { + dup 7 mul 1 add index exch dup BitsPerComponent 8 idiv mul exch + origDataSource exch get 0()/SubFileDecode filter + BitsPerComponent 8 idiv string/readstring cvx/pop cvx/putinterval cvx + }for + ]bind cvx + }{origDataSource}ifelse 0()/SubFileDecode filter def + [ + origcolorSpaceElemCnt string + 0 2 origDecode length 2 sub + { + dup origDecode exch get dup 3 -1 roll 1 add origDecode exch get exch sub 2 BitsPerComponent exp 1 sub div + 1 BitsPerComponent 8 idiv{DataSource/read cvx/not cvx{0}/if cvx/mul cvx}repeat/mul cvx/add cvx + }for + /convProc load/exec cvx + origcolorSpaceElemCnt 1 sub -1 0 + { + /dup cvx 2/add cvx/index cvx + 3 1/roll cvx/exch cvx 255/mul cvx/cvi cvx/put cvx + }for + ]bind cvx 0()/SubFileDecode filter + end +}bdf +/devn_imageormask +{ + /devicen_colorspace_dict AGMCORE_gget begin + CSA map_csa + 2 dict begin + dup + /srcDataStrs[3 -1 roll begin + AGMIMG_init_common + currentdict/MultipleDataSources known{MultipleDataSources{DataSource length}{1}ifelse}{1}ifelse + { + Width Decode length 2 div mul cvi + { + dup 65535 gt{1 add 2 div cvi}{exit}ifelse + }loop + string + }repeat + end]def + /dstDataStr srcDataStrs 0 get length string def + begin + AGMIMG_init_common + SkipImageProc{ + currentdict consumeimagedata + }{ + save mark + AGMCORE_producing_seps not{ + level3 not{ + Operator/imagemask ne{ + /DataSource[[ + DataSource Decode BitsPerComponent currentdict/MultipleDataSources known{MultipleDataSources}{false}ifelse + colorSpaceElemCnt/devicen_colorspace_dict AGMCORE_gget/TintTransform get + devn_alt_datasource 1/string cvx/readstring cvx/pop cvx]cvx colorSpaceElemCnt 1 sub{dup}repeat]def + /MultipleDataSources true def + /Decode colorSpaceElemCnt[exch{0 1}repeat]def + }if + }if + currentdict imageormask + }{ + AGMCORE_host_sep{ + Names convert_to_process{ + CSA get_csa_by_name 0 get/DeviceCMYK eq{ + /DataSource + Width BitsPerComponent mul 7 add 8 idiv Height mul 4 mul + DataSource Decode BitsPerComponent currentdict/MultipleDataSources known{MultipleDataSources}{false}ifelse + 4/devicen_colorspace_dict AGMCORE_gget/TintTransform get + devn_alt_datasource + filter_cmyk 0()/SubFileDecode filter def + /MultipleDataSources false def + /Decode[1 0]def + /DeviceGray setcolorspace + currentdict imageormask_sys + }{ + AGMCORE_report_unsupported_color_space + AGMCORE_black_plate{ + /DataSource + DataSource Decode BitsPerComponent currentdict/MultipleDataSources known{MultipleDataSources}{false}ifelse + CSA get_csa_by_name 0 get/DeviceRGB eq{3}{1}ifelse/devicen_colorspace_dict AGMCORE_gget/TintTransform get + devn_alt_datasource + /MultipleDataSources false def + /Decode colorSpaceElemCnt[exch{0 1}repeat]def + currentdict imageormask_sys + }{ + gsave + knockout_unitsq + grestore + currentdict consumeimagedata + }ifelse + }ifelse + } + { + /devicen_colorspace_dict AGMCORE_gget/names_index known{ + Operator/imagemask ne{ + MultipleDataSources{ + /DataSource[DataSource devn_sep_datasource/exec cvx]cvx def + /MultipleDataSources false def + }{ + /DataSource/DataSource load dstDataStr srcDataStrs 0 get filter_devn def + }ifelse + invert_image_samples + }if + currentdict imageormask_sys + }{ + currentoverprint not Operator/imagemask eq and{ + currentdict imageormask_sys + }{ + currentoverprint not + { + gsave + knockout_unitsq + grestore + }if + currentdict consumeimagedata + }ifelse + }ifelse + }ifelse + }{ + currentdict imageormask + }ifelse + }ifelse + cleartomark restore + }ifelse + currentdict/_Filters known{_Filters AGMIMG_flushfilters}if + end + end + end +}def +/imageormask_l2_overprint +{ + currentdict + currentcmykcolor add add add 0 eq{ + currentdict consumeimagedata + }{ + level3{ + currentcmykcolor + /AGMIMG_k xdf + /AGMIMG_y xdf + /AGMIMG_m xdf + /AGMIMG_c xdf + Operator/imagemask eq{ + [/DeviceN[ + AGMIMG_c 0 ne{/Cyan}if + AGMIMG_m 0 ne{/Magenta}if + AGMIMG_y 0 ne{/Yellow}if + AGMIMG_k 0 ne{/Black}if + ]/DeviceCMYK{}]setcolorspace + AGMIMG_c 0 ne{AGMIMG_c}if + AGMIMG_m 0 ne{AGMIMG_m}if + AGMIMG_y 0 ne{AGMIMG_y}if + AGMIMG_k 0 ne{AGMIMG_k}if + setcolor + }{ + /Decode[Decode 0 get 255 mul Decode 1 get 255 mul]def + [/Indexed + [ + /DeviceN[ + AGMIMG_c 0 ne{/Cyan}if + AGMIMG_m 0 ne{/Magenta}if + AGMIMG_y 0 ne{/Yellow}if + AGMIMG_k 0 ne{/Black}if + ] + /DeviceCMYK{ + AGMIMG_k 0 eq{0}if + AGMIMG_y 0 eq{0 exch}if + AGMIMG_m 0 eq{0 3 1 roll}if + AGMIMG_c 0 eq{0 4 1 roll}if + } + ] + 255 + { + 255 div + mark exch + dup dup dup + AGMIMG_k 0 ne{ + /sep_tint AGMCORE_gget mul MappedCSA sep_proc_name exch pop load exec 4 1 roll pop pop pop + counttomark 1 roll + }{ + pop + }ifelse + AGMIMG_y 0 ne{ + /sep_tint AGMCORE_gget mul MappedCSA sep_proc_name exch pop load exec 4 2 roll pop pop pop + counttomark 1 roll + }{ + pop + }ifelse + AGMIMG_m 0 ne{ + /sep_tint AGMCORE_gget mul MappedCSA sep_proc_name exch pop load exec 4 3 roll pop pop pop + counttomark 1 roll + }{ + pop + }ifelse + AGMIMG_c 0 ne{ + /sep_tint AGMCORE_gget mul MappedCSA sep_proc_name exch pop load exec pop pop pop + counttomark 1 roll + }{ + pop + }ifelse + counttomark 1 add -1 roll pop + } + ]setcolorspace + }ifelse + imageormask_sys + }{ + write_image_file{ + currentcmykcolor + 0 ne{ + [/Separation/Black/DeviceGray{}]setcolorspace + gsave + /Black + [{1 exch sub/sep_tint AGMCORE_gget mul}/exec cvx MappedCSA sep_proc_name cvx exch pop{4 1 roll pop pop pop 1 exch sub}/exec cvx] + cvx modify_halftone_xfer + Operator currentdict read_image_file + grestore + }if + 0 ne{ + [/Separation/Yellow/DeviceGray{}]setcolorspace + gsave + /Yellow + [{1 exch sub/sep_tint AGMCORE_gget mul}/exec cvx MappedCSA sep_proc_name cvx exch pop{4 2 roll pop pop pop 1 exch sub}/exec cvx] + cvx modify_halftone_xfer + Operator currentdict read_image_file + grestore + }if + 0 ne{ + [/Separation/Magenta/DeviceGray{}]setcolorspace + gsave + /Magenta + [{1 exch sub/sep_tint AGMCORE_gget mul}/exec cvx MappedCSA sep_proc_name cvx exch pop{4 3 roll pop pop pop 1 exch sub}/exec cvx] + cvx modify_halftone_xfer + Operator currentdict read_image_file + grestore + }if + 0 ne{ + [/Separation/Cyan/DeviceGray{}]setcolorspace + gsave + /Cyan + [{1 exch sub/sep_tint AGMCORE_gget mul}/exec cvx MappedCSA sep_proc_name cvx exch pop{pop pop pop 1 exch sub}/exec cvx] + cvx modify_halftone_xfer + Operator currentdict read_image_file + grestore + }if + close_image_file + }{ + imageormask + }ifelse + }ifelse + }ifelse +}def +/indexed_imageormask +{ + begin + AGMIMG_init_common + save mark + currentdict + AGMCORE_host_sep{ + Operator/knockout eq{ + /indexed_colorspace_dict AGMCORE_gget dup/CSA known{ + /CSA get get_csa_by_name + }{ + /Names get + }ifelse + overprint_plate not{ + knockout_unitsq + }if + }{ + Indexed_DeviceN{ + /devicen_colorspace_dict AGMCORE_gget dup/names_index known exch/Names get convert_to_process or{ + indexed_image_lev2_sep + }{ + currentoverprint not{ + knockout_unitsq + }if + currentdict consumeimagedata + }ifelse + }{ + AGMCORE_is_cmyk_sep{ + Operator/imagemask eq{ + imageormask_sys + }{ + level2{ + indexed_image_lev2_sep + }{ + indexed_image_lev1_sep + }ifelse + }ifelse + }{ + currentoverprint not{ + knockout_unitsq + }if + currentdict consumeimagedata + }ifelse + }ifelse + }ifelse + }{ + level2{ + Indexed_DeviceN{ + /indexed_colorspace_dict AGMCORE_gget begin + }{ + /indexed_colorspace_dict AGMCORE_gget dup null ne + { + begin + currentdict/CSDBase known{CSDBase/CSD get_res/MappedCSA get}{CSA}ifelse + get_csa_by_name 0 get/DeviceCMYK eq ps_level 3 ge and ps_version 3015.007 lt and + AGMCORE_in_rip_sep and{ + [/Indexed[/DeviceN[/Cyan/Magenta/Yellow/Black]/DeviceCMYK{}]HiVal Lookup] + setcolorspace + }if + end + } + {pop}ifelse + }ifelse + imageormask + Indexed_DeviceN{ + end + }if + }{ + Operator/imagemask eq{ + imageormask + }{ + indexed_imageormask_lev1 + }ifelse + }ifelse + }ifelse + cleartomark restore + currentdict/_Filters known{_Filters AGMIMG_flushfilters}if + end +}def +/indexed_image_lev2_sep +{ + /indexed_colorspace_dict AGMCORE_gget begin + begin + Indexed_DeviceN not{ + currentcolorspace + dup 1/DeviceGray put + dup 3 + currentcolorspace 2 get 1 add string + 0 1 2 3 AGMCORE_get_ink_data 4 currentcolorspace 3 get length 1 sub + { + dup 4 idiv exch currentcolorspace 3 get exch get 255 exch sub 2 index 3 1 roll put + }for + put setcolorspace + }if + currentdict + Operator/imagemask eq{ + AGMIMG_&imagemask + }{ + use_mask{ + process_mask AGMIMG_&image + }{ + AGMIMG_&image + }ifelse + }ifelse + end end +}def + /OPIimage + { + dup type/dicttype ne{ + 10 dict begin + /DataSource xdf + /ImageMatrix xdf + /BitsPerComponent xdf + /Height xdf + /Width xdf + /ImageType 1 def + /Decode[0 1 def] + currentdict + end + }if + dup begin + /NComponents 1 cdndf + /MultipleDataSources false cdndf + /SkipImageProc{false}cdndf + /Decode[ + 0 + currentcolorspace 0 get/Indexed eq{ + 2 BitsPerComponent exp 1 sub + }{ + 1 + }ifelse + ]cdndf + /Operator/image cdndf + end + /sep_colorspace_dict AGMCORE_gget null eq{ + imageormask + }{ + gsave + dup begin invert_image_samples end + sep_imageormask + grestore + }ifelse + }def +/cachemask_level2 +{ + 3 dict begin + /LZWEncode filter/WriteFilter xdf + /readBuffer 256 string def + /ReadFilter + currentfile + 0(%EndMask)/SubFileDecode filter + /ASCII85Decode filter + /RunLengthDecode filter + def + { + ReadFilter readBuffer readstring exch + WriteFilter exch writestring + not{exit}if + }loop + WriteFilter closefile + end +}def +/spot_alias +{ + /mapto_sep_imageormask + { + dup type/dicttype ne{ + 12 dict begin + /ImageType 1 def + /DataSource xdf + /ImageMatrix xdf + /BitsPerComponent xdf + /Height xdf + /Width xdf + /MultipleDataSources false def + }{ + begin + }ifelse + /Decode[/customcolor_tint AGMCORE_gget 0]def + /Operator/image def + /SkipImageProc{false}def + currentdict + end + sep_imageormask + }bdf + /customcolorimage + { + Adobe_AGM_Image/AGMIMG_colorAry xddf + /customcolor_tint AGMCORE_gget + << + /Name AGMIMG_colorAry 4 get + /CSA[/DeviceCMYK] + /TintMethod/Subtractive + /TintProc null + /MappedCSA null + /NComponents 4 + /Components[AGMIMG_colorAry aload pop pop] + >> + setsepcolorspace + mapto_sep_imageormask + }ndf + Adobe_AGM_Image/AGMIMG_&customcolorimage/customcolorimage load put + /customcolorimage + { + Adobe_AGM_Image/AGMIMG_override false put + current_spot_alias{dup 4 get map_alias}{false}ifelse + { + false set_spot_alias + /customcolor_tint AGMCORE_gget exch setsepcolorspace + pop + mapto_sep_imageormask + true set_spot_alias + }{ + //Adobe_AGM_Image/AGMIMG_&customcolorimage get exec + }ifelse + }bdf +}def +/snap_to_device +{ + 6 dict begin + matrix currentmatrix + dup 0 get 0 eq 1 index 3 get 0 eq and + 1 index 1 get 0 eq 2 index 2 get 0 eq and or exch pop + { + 1 1 dtransform 0 gt exch 0 gt/AGMIMG_xSign? exch def/AGMIMG_ySign? exch def + 0 0 transform + AGMIMG_ySign?{floor 0.1 sub}{ceiling 0.1 add}ifelse exch + AGMIMG_xSign?{floor 0.1 sub}{ceiling 0.1 add}ifelse exch + itransform/AGMIMG_llY exch def/AGMIMG_llX exch def + 1 1 transform + AGMIMG_ySign?{ceiling 0.1 add}{floor 0.1 sub}ifelse exch + AGMIMG_xSign?{ceiling 0.1 add}{floor 0.1 sub}ifelse exch + itransform/AGMIMG_urY exch def/AGMIMG_urX exch def + [AGMIMG_urX AGMIMG_llX sub 0 0 AGMIMG_urY AGMIMG_llY sub AGMIMG_llX AGMIMG_llY]concat + }{ + }ifelse + end +}def +level2 not{ + /colorbuf + { + 0 1 2 index length 1 sub{ + dup 2 index exch get + 255 exch sub + 2 index + 3 1 roll + put + }for + }def + /tint_image_to_color + { + begin + Width Height BitsPerComponent ImageMatrix + /DataSource load + end + Adobe_AGM_Image begin + /AGMIMG_mbuf 0 string def + /AGMIMG_ybuf 0 string def + /AGMIMG_kbuf 0 string def + { + colorbuf dup length AGMIMG_mbuf length ne + { + dup length dup dup + /AGMIMG_mbuf exch string def + /AGMIMG_ybuf exch string def + /AGMIMG_kbuf exch string def + }if + dup AGMIMG_mbuf copy AGMIMG_ybuf copy AGMIMG_kbuf copy pop + } + addprocs + {AGMIMG_mbuf}{AGMIMG_ybuf}{AGMIMG_kbuf}true 4 colorimage + end + }def + /sep_imageormask_lev1 + { + begin + MappedCSA 0 get dup/DeviceRGB eq exch/DeviceCMYK eq or has_color not and{ + { + 255 mul round cvi GrayLookup exch get + }currenttransfer addprocs settransfer + currentdict imageormask + }{ + /sep_colorspace_dict AGMCORE_gget/Components known{ + MappedCSA 0 get/DeviceCMYK eq{ + Components aload pop + }{ + 0 0 0 Components aload pop 1 exch sub + }ifelse + Adobe_AGM_Image/AGMIMG_k xddf + Adobe_AGM_Image/AGMIMG_y xddf + Adobe_AGM_Image/AGMIMG_m xddf + Adobe_AGM_Image/AGMIMG_c xddf + AGMIMG_y 0.0 eq AGMIMG_m 0.0 eq and AGMIMG_c 0.0 eq and{ + {AGMIMG_k mul 1 exch sub}currenttransfer addprocs settransfer + currentdict imageormask + }{ + currentcolortransfer + {AGMIMG_k mul 1 exch sub}exch addprocs 4 1 roll + {AGMIMG_y mul 1 exch sub}exch addprocs 4 1 roll + {AGMIMG_m mul 1 exch sub}exch addprocs 4 1 roll + {AGMIMG_c mul 1 exch sub}exch addprocs 4 1 roll + setcolortransfer + currentdict tint_image_to_color + }ifelse + }{ + MappedCSA 0 get/DeviceGray eq{ + {255 mul round cvi ColorLookup exch get 0 get}currenttransfer addprocs settransfer + currentdict imageormask + }{ + MappedCSA 0 get/DeviceCMYK eq{ + currentcolortransfer + {255 mul round cvi ColorLookup exch get 3 get 1 exch sub}exch addprocs 4 1 roll + {255 mul round cvi ColorLookup exch get 2 get 1 exch sub}exch addprocs 4 1 roll + {255 mul round cvi ColorLookup exch get 1 get 1 exch sub}exch addprocs 4 1 roll + {255 mul round cvi ColorLookup exch get 0 get 1 exch sub}exch addprocs 4 1 roll + setcolortransfer + currentdict tint_image_to_color + }{ + currentcolortransfer + {pop 1}exch addprocs 4 1 roll + {255 mul round cvi ColorLookup exch get 2 get}exch addprocs 4 1 roll + {255 mul round cvi ColorLookup exch get 1 get}exch addprocs 4 1 roll + {255 mul round cvi ColorLookup exch get 0 get}exch addprocs 4 1 roll + setcolortransfer + currentdict tint_image_to_color + }ifelse + }ifelse + }ifelse + }ifelse + end + }def + /sep_image_lev1_sep + { + begin + /sep_colorspace_dict AGMCORE_gget/Components known{ + Components aload pop + Adobe_AGM_Image/AGMIMG_k xddf + Adobe_AGM_Image/AGMIMG_y xddf + Adobe_AGM_Image/AGMIMG_m xddf + Adobe_AGM_Image/AGMIMG_c xddf + {AGMIMG_c mul 1 exch sub} + {AGMIMG_m mul 1 exch sub} + {AGMIMG_y mul 1 exch sub} + {AGMIMG_k mul 1 exch sub} + }{ + {255 mul round cvi ColorLookup exch get 0 get 1 exch sub} + {255 mul round cvi ColorLookup exch get 1 get 1 exch sub} + {255 mul round cvi ColorLookup exch get 2 get 1 exch sub} + {255 mul round cvi ColorLookup exch get 3 get 1 exch sub} + }ifelse + AGMCORE_get_ink_data currenttransfer addprocs settransfer + currentdict imageormask_sys + end + }def + /indexed_imageormask_lev1 + { + /indexed_colorspace_dict AGMCORE_gget begin + begin + currentdict + MappedCSA 0 get dup/DeviceRGB eq exch/DeviceCMYK eq or has_color not and{ + {HiVal mul round cvi GrayLookup exch get HiVal div}currenttransfer addprocs settransfer + imageormask + }{ + MappedCSA 0 get/DeviceGray eq{ + {HiVal mul round cvi Lookup exch get HiVal div}currenttransfer addprocs settransfer + imageormask + }{ + MappedCSA 0 get/DeviceCMYK eq{ + currentcolortransfer + {4 mul HiVal mul round cvi 3 add Lookup exch get HiVal div 1 exch sub}exch addprocs 4 1 roll + {4 mul HiVal mul round cvi 2 add Lookup exch get HiVal div 1 exch sub}exch addprocs 4 1 roll + {4 mul HiVal mul round cvi 1 add Lookup exch get HiVal div 1 exch sub}exch addprocs 4 1 roll + {4 mul HiVal mul round cvi Lookup exch get HiVal div 1 exch sub}exch addprocs 4 1 roll + setcolortransfer + tint_image_to_color + }{ + currentcolortransfer + {pop 1}exch addprocs 4 1 roll + {3 mul HiVal mul round cvi 2 add Lookup exch get HiVal div}exch addprocs 4 1 roll + {3 mul HiVal mul round cvi 1 add Lookup exch get HiVal div}exch addprocs 4 1 roll + {3 mul HiVal mul round cvi Lookup exch get HiVal div}exch addprocs 4 1 roll + setcolortransfer + tint_image_to_color + }ifelse + }ifelse + }ifelse + end end + }def + /indexed_image_lev1_sep + { + /indexed_colorspace_dict AGMCORE_gget begin + begin + {4 mul HiVal mul round cvi Lookup exch get HiVal div 1 exch sub} + {4 mul HiVal mul round cvi 1 add Lookup exch get HiVal div 1 exch sub} + {4 mul HiVal mul round cvi 2 add Lookup exch get HiVal div 1 exch sub} + {4 mul HiVal mul round cvi 3 add Lookup exch get HiVal div 1 exch sub} + AGMCORE_get_ink_data currenttransfer addprocs settransfer + currentdict imageormask_sys + end end + }def +}if +end +systemdict/setpacking known +{setpacking}if +%%EndResource +currentdict Adobe_AGM_Utils eq {end} if +%%EndProlog +%%BeginSetup +Adobe_AGM_Utils begin +2 2010 Adobe_AGM_Core/ds gx +Adobe_CoolType_Core/ds get exec +Adobe_AGM_Image/ds gx +[/NamespacePush pdfmark_5 +[/_objdef {Doc_Metadata} /type /stream /OBJ pdfmark_5 +[{Doc_Metadata} 27730 (% &end XMP packet& %) ReadBypdfmark_5_string + + + + + + + MBZUAI -Brand Mark_Techno Blue -RGB + + + + + + + + + + + + + + + + + + + + + + + + + + Cyan + Magenta + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +% &end XMP packet& % + +[{Doc_Metadata} 2 dict begin /Type /Metadata def /Subtype /XML def currentdict end /PUT pdfmark_5 +[/Document 1 dict begin /Metadata {Doc_Metadata} def currentdict end /BDC pdfmark_5 +[/NamespacePop pdfmark_5 +currentdict Adobe_AGM_Utils eq {end} if +%%EndSetup +%%Page: 1 1 +%%EndPageComments +%%BeginPageSetup +Adobe_AGM_Utils begin +Adobe_AGM_Core/ps gx +Adobe_AGM_Core/capture_mysetup gx +Adobe_AGM_Utils/capture_cpd gx +Adobe_CoolType_Core/ps get exec +Adobe_AGM_Image/ps gx +Adobe_AGM_Core/ps gx +gsave +/0 +[/DeviceCMYK] /CSA add_res +grestore +Adobe_AGM_Core/pt gx +%%EndPageSetup +1 -1 scale 0 -132.902 translate +pgsv +[1 0 0 1 0 0 ]ct +gsave +np +gsave +0 0 mo +0 132.902 li +151.699 132.902 li +151.699 0 li +cp +clp +gsave +0 0 mo +151.699 0 li +151.699 132.902 li +0 132.902 li +cp +clp +grestore +gsave +0 0 mo +151.699 0 li +151.699 132.902 li +0 132.902 li +cp +clp +97.139 81.1432 mo +94.362 78.3662 90.044 78.1152 86.994 80.3592 cv +82.469 75.8392 li +83.524 74.4392 84.173 72.7142 84.173 70.8282 cv +84.173 66.2052 80.425 62.4592 75.799 62.4592 cv +71.177 62.4592 67.425 66.2052 67.425 70.8282 cv +67.425 75.4532 71.177 79.2002 75.799 79.2002 cv +77.687 79.2002 79.408 78.5522 80.808 77.5002 cv +85.332 82.0242 li +83.356 84.7142 83.32 88.3692 85.24 91.1082 cv +80.726 95.3992 li +79.378 94.4212 77.679 93.8072 75.799 93.8072 cv +71.491 93.8072 67.999 96.8972 67.999 100.707 cv +67.999 104.523 71.491 107.614 75.799 107.614 cv +80.106 107.614 83.598 104.523 83.598 100.707 cv +83.598 99.3642 83.145 98.1202 82.394 97.0582 cv +86.878 92.7962 li +89.953 95.1892 94.37 95.0202 97.178 92.2102 cv +100.222 89.1632 100.211 84.2062 97.139 81.1432 cv +false sop +.799466 .507378 0 0 cmyk +f +66.4994 50.7226 mo +71.2934 46.4236 li +72.5684 47.2256 74.1154 47.7066 75.7984 47.7066 cv +77.4834 47.7066 79.0324 47.2256 80.3044 46.4216 cv +85.1134 50.7306 li +83.1984 53.7036 83.5734 57.7506 86.2264 60.4036 cv +88.8694 63.0446 92.8914 63.4236 95.8584 61.5356 cv +100.079 66.2916 li +99.2664 67.5736 98.7744 69.1316 98.7744 70.8276 cv +98.7744 75.1346 101.867 78.6266 105.681 78.6266 cv +109.489 78.6266 112.58 75.1346 112.58 70.8276 cv +112.58 66.5166 109.489 63.0276 105.681 63.0276 cv +104.168 63.0276 102.783 63.5906 101.645 64.5186 cv +97.5934 59.9566 li +100.073 56.9486 99.8984 52.4676 97.0284 49.5966 cv +94.1734 46.7426 89.7114 46.5556 86.7034 49.0056 cv +82.0834 44.8636 li +83.0264 43.7216 83.5984 42.3266 83.5984 40.8046 cv +83.5984 36.9926 80.1064 33.9036 75.7984 33.9036 cv +71.4914 33.9036 67.9994 36.9926 67.9994 40.8046 cv +67.9994 42.3266 68.5724 43.7216 69.5144 44.8636 cv +64.8964 49.0026 li +62.1464 46.7326 58.2704 46.5736 55.4234 48.5666 cv +52.4444 45.4626 li +54.1434 43.2366 54.4634 40.4166 53.3614 38.2256 cv +57.3034 34.8836 li +59.6884 36.7346 63.3614 36.5356 66.0154 34.2316 cv +68.9914 31.6476 69.5464 27.4186 67.2634 24.7896 cv +66.1074 23.4556 64.4424 22.7866 62.6964 22.7866 cv +60.9934 22.7866 59.2094 23.4226 57.7404 24.6996 cv +55.1324 26.9626 54.3854 30.4876 55.7764 33.0946 cv +51.8854 36.3916 li +49.3504 34.3336 45.3924 34.7266 42.7854 37.4166 cv +40.0384 40.2436 39.8444 44.4986 42.3454 46.9316 cv +44.5474 49.0656 48.0904 49.0706 50.7814 47.1246 cv +53.7394 50.2046 li +51.3934 53.2686 51.6184 57.6766 54.4554 60.5146 cv +57.5384 63.5986 62.5064 63.6266 65.5544 60.5866 cv +68.2194 57.9216 68.5284 53.7856 66.4994 50.7226 cv +f +45.7754 63.0276 mo +41.9634 63.0276 38.8714 66.5166 38.8714 70.8276 cv +38.8714 72.5846 39.4044 74.1896 40.2724 75.4916 cv +37.1124 79.2126 li +35.9744 78.3486 34.6014 77.8636 33.1404 77.9696 cv +32.0424 78.0536 31.0504 78.4766 30.1934 79.1036 cv +26.2854 74.4456 li +26.7934 73.3896 27.1004 72.1596 27.1004 70.8276 cv +27.1004 69.4676 26.7854 68.2076 26.2554 67.1386 cv +29.9964 62.5596 li +30.8394 63.1596 31.8064 63.5626 32.8764 63.6426 cv +36.3484 63.9046 39.4054 60.9316 39.7004 57.0016 cv +39.9984 53.0746 37.4164 49.6806 33.9394 49.4226 cv +32.8834 49.3386 31.8784 49.5876 30.9674 50.0436 cv +28.7634 46.2806 li +28.9564 46.0376 29.1494 45.7946 29.3224 45.5266 cv +31.1294 42.7266 31.0804 39.6656 29.2054 38.6966 cv +28.8164 38.4936 28.3794 38.3976 27.9134 38.3976 cv +26.1434 38.3976 23.9724 39.7896 22.5374 42.0086 cv +20.7284 44.8146 20.7784 47.8696 22.6494 48.8376 cv +23.8534 49.4626 25.5114 49.0666 27.0274 47.9666 cv +29.0794 51.4676 li +27.9944 52.6516 27.2514 54.2436 27.1134 56.0606 cv +26.9804 57.8586 27.4694 59.5306 28.3524 60.8556 cv +24.8104 65.1876 li +23.9334 64.3956 22.8704 63.9206 21.7164 63.9206 cv +18.7454 63.9206 16.3364 67.0136 16.3364 70.8276 cv +16.3364 74.6456 18.7454 77.7376 21.7164 77.7376 cv +22.8964 77.7376 23.9794 77.2366 24.8674 76.4096 cv +28.5704 80.8276 li +27.7184 82.1426 27.2454 83.7846 27.3784 85.5566 cv +27.6754 89.4816 30.7314 92.4506 34.2044 92.1906 cv +37.6804 91.9306 40.2574 88.5396 39.9674 84.6076 cv +39.8624 83.2316 39.4054 81.9876 38.7264 80.9456 cv +41.8654 77.2486 li +42.9774 78.1136 44.3234 78.6256 45.7754 78.6256 cv +49.5874 78.6256 52.6794 75.1346 52.6794 70.8276 cv +52.6794 66.5166 49.5874 63.0276 45.7754 63.0276 cv +f +130.066 63.9205 mo +128.884 63.9205 127.811 64.4615 126.938 65.3425 cv +123.056 60.7845 li +123.888 59.4795 124.35 57.8535 124.218 56.1025 cv +124.092 54.4065 123.43 52.9135 122.461 51.7595 cv +124.306 48.9255 li +125.899 50.2235 127.7 50.6765 128.965 49.8805 cv +130.788 48.7275 130.796 45.4595 128.979 42.5785 cv +127.595 40.3795 125.552 39.0405 123.848 39.0405 cv +123.32 39.0405 122.824 39.1705 122.392 39.4425 cv +120.566 40.5895 120.56 43.8575 122.373 46.7425 cv +122.464 46.8855 122.567 47.0055 122.662 47.1395 cv +120.649 50.2355 li +119.667 49.6805 118.558 49.3815 117.392 49.4685 cv +113.914 49.7265 111.339 53.1195 111.632 57.0515 cv +111.927 60.9765 114.983 63.9475 118.46 63.6875 cv +119.578 63.6015 120.584 63.1715 121.448 62.5245 cv +125.587 67.3825 li +125.143 68.3995 124.868 69.5665 124.868 70.8275 cv +124.868 74.6455 127.196 77.7375 130.066 77.7375 cv +132.937 77.7375 135.265 74.6455 135.265 70.8275 cv +135.265 67.0145 132.937 63.9205 130.066 63.9205 cv +f +40.075 33.3888 mo +41.833 31.7778 42.747 29.7418 42.65 28.0958 cv +47.096 24.8918 li +48.329 25.3518 50.068 25.2318 51.85 24.4168 cv +54.807 23.0598 56.736 20.3308 56.156 18.3238 cv +55.795 17.0608 54.537 16.3808 52.921 16.3808 cv +51.953 16.3808 50.861 16.6258 49.753 17.1328 cv +46.814 18.4788 44.891 21.1808 45.434 23.1898 cv +41.595 25.9598 li +40.006 24.7288 37.083 25.3188 34.757 27.4538 cv +32.244 29.7538 31.4 32.9488 32.871 34.5848 cv +34.34 36.2248 37.566 35.6888 40.075 33.3888 cv +f +127.892 92.6216 mo +126.756 92.0876 125.243 92.4626 123.844 93.4546 cv +122.282 90.4556 li +123.499 89.2566 124.328 87.5456 124.472 85.5996 cv +124.768 81.6736 122.188 78.2766 118.715 78.0146 cv +118.573 78.0056 118.43 77.9986 118.291 77.9986 cv +114.993 77.9986 112.169 80.8876 111.886 84.6566 cv +111.767 86.2656 112.148 87.7696 112.855 89.0196 cv +108.257 93.8556 li +105.727 92.3146 102.161 92.8636 99.7565 95.3466 cv +97.0145 98.1726 96.8165 102.433 99.3165 104.859 cv +101.382 106.862 104.628 106.963 107.242 105.36 cv +110.644 109.647 li +108.714 111.844 108.003 114.404 109.093 115.668 cv +109.507 116.145 110.123 116.376 110.854 116.382 cv +110.909 116.382 li +112.328 116.37 114.163 115.524 115.782 114 cv +118.253 111.667 119.271 108.634 118.051 107.221 cv +116.993 106 114.606 106.402 112.378 108.048 cv +109.047 103.848 li +111.263 101.344 111.602 97.8776 109.955 95.4806 cv +114.353 90.8576 li +115.277 91.6356 116.398 92.1436 117.646 92.2366 cv +118.584 92.3076 119.484 92.1266 120.315 91.7716 cv +122.069 95.1386 li +121.811 95.4606 121.566 95.8066 121.342 96.1776 cv +119.626 99.0266 119.765 102.057 121.659 102.947 cv +123.553 103.838 126.482 102.245 128.203 99.3926 cv +129.925 96.5436 129.785 93.5106 127.892 92.6216 cv +f +grestore +grestore +grestore +pgrs +%%PageTrailer +[ +[/CSA [/0 ]] +] del_res +Adobe_AGM_Image/pt gx +Adobe_CoolType_Core/pt get exec +Adobe_AGM_Core/restore_mysetup gx +Adobe_AGM_Core/pt gx +currentdict Adobe_AGM_Utils eq {end} if +%%Trailer +Adobe_AGM_Utils begin +[/EMC pdfmark_5 +currentdict Adobe_AGM_Utils eq {end} if +Adobe_AGM_Image/dt get exec +Adobe_CoolType_Core/dt get exec +Adobe_AGM_Core/dt get exec +%%Pages: 1 +%%DocumentNeededResources: +%%DocumentSuppliedResources: procset Adobe_AGM_Image 1.0 0 +%%+ procset Adobe_CoolType_Utility_T42 1.0 0 +%%+ procset Adobe_CoolType_Utility_MAKEOCF 1.23 0 +%%+ procset Adobe_CoolType_Core 2.31 0 +%%+ procset Adobe_AGM_Core 2.0 0 +%%+ procset Adobe_AGM_Utils 1.0 0 +%%DocumentNeededFeatures: +%%DocumentSuppliedFeatures: +%%DocumentCustomColors: +%%CMYKCustomColor: +%%RGBCustomColor: +%%EOF diff --git a/assets/api-doc.png b/assets/api-doc.png new file mode 100644 index 0000000..bda9115 Binary files /dev/null and b/assets/api-doc.png differ diff --git a/assets/gant.png b/assets/gant.png new file mode 100644 index 0000000..3e066b4 Binary files /dev/null and b/assets/gant.png differ diff --git a/assets/logging.png b/assets/logging.png new file mode 100644 index 0000000..6d19a92 Binary files /dev/null and b/assets/logging.png differ diff --git a/assets/pipeline.png b/assets/pipeline.png new file mode 100644 index 0000000..95e0962 Binary files /dev/null and b/assets/pipeline.png differ diff --git a/assets/vertex/model-versioning.png b/assets/vertex/model-versioning.png new file mode 100644 index 0000000..1fee11c Binary files /dev/null and b/assets/vertex/model-versioning.png differ diff --git a/bibliography/keylatex.bib b/bibliography/keylatex.bib new file mode 100644 index 0000000..b95a5ed --- /dev/null +++ b/bibliography/keylatex.bib @@ -0,0 +1,101 @@ + + +@article{al2020generalizing, + title={Generalizing AI: challenges and opportunities for plug and play AI solutions}, + author={Al Ridhawi, Ismaeel and Otoum, Safa and Aloqaily, Moayad}, + journal={IEEE Network}, + volume={35}, + number={1}, + pages={372--379}, + year={2020}, + publisher={IEEE} +} + +@article{elayan2021digital, + title={Digital Twin for Intelligent Context-Aware IoT Healthcare Systems}, + author={Elayan, Haya and Aloqaily, Moayad and Guizani, Mohsen}, + journal={IEEE Internet of Things Journal}, + year={2021}, + publisher={IEEE} +} + +@article{10223206, + author={Iklassov, Zangir and Sobirov, Ikboljon and Solozabal, Ruben and Takáč, Martin}, + journal={IEEE Access}, + title={Reinforcement Learning Approach to Stochastic Vehicle Routing Problem With Correlated Demands}, + year={2023}, + volume={11}, + number={}, + pages={87958-87969}, + doi={10.1109/ACCESS.2023.3306076} +} + + +@article{JLL2025, + author = {JLL Research}, + journal = {JLL Global Real Estate Perspective}, + title = {Global Real Estate Perspective February 2025: A positive but nuanced outlook for 2025}, + year = {2025}, + month = {February}, + publisher = {Jones Lang LaSalle IP, Inc.}, + url = {https://www.jll.co.th/en/trends-and-insights/research/global/gmp} +} + + +@article{nationthailand1, + author = {Nationthailand}, + journal = {Nationthailand}, + title = {8 key trends shaping Thai real estate after rollercoaster year}, + year = {2025}, + month = {January}, + url = {https://www.nationthailand.com/business/property/40044774} +} + + +@article{bangkokpost1, + author = {Bangkok Post}, + journal = {Bangkok Post}, + title = {Real Estate Information Center targets better data gathering to head off crises}, + year = {2024}, + month = {Jule}, + url = {https://www.bangkokpost.com/property/2836667/real-estate-information-center-targets-better-data-gathering-to-head-off-crises} +} + +@misc{ST-RAP, + title={ST-RAP: A Spatio-Temporal Framework for Real Estate Appraisal}, + author={Hojoon Lee and Hawon Jeong and Byungkun Lee and Kyungyup Lee and Jaegul Choo}, + year={2023}, + eprint={2308.10609}, + archivePrefix={arXiv}, + primaryClass={cs.LG}, + url={https://arxiv.org/abs/2308.10609}, +} + +@Manual{kernelshap, + title = {kernelshap: Kernel SHAP}, + author = {Michael Mayer and David Watson}, + year = {2024}, + note = {R package version 0.7.1}, + url = {https://github.com/ModelOriented/kernelshap}, +} + +@misc{veličković2018graphattentionnetworks, + title={Graph Attention Networks}, + author={Petar Veličković and Guillem Cucurull and Arantxa Casanova and Adriana Romero and Pietro Liò and Yoshua Bengio}, + year={2018}, + eprint={1710.10903}, + archivePrefix={arXiv}, + primaryClass={stat.ML}, + url={https://arxiv.org/abs/1710.10903}, +} + +@inproceedings{Chen_2016, series={KDD ’16}, + title={XGBoost: A Scalable Tree Boosting System}, + url={http://dx.doi.org/10.1145/2939672.2939785}, + DOI={10.1145/2939672.2939785}, + booktitle={Proceedings of the 22nd ACM SIGKDD International Conference on Knowledge Discovery and Data Mining}, + publisher={ACM}, + author={Chen, Tianqi and Guestrin, Carlos}, + year={2016}, + month=aug, pages={785–794}, + collection={KDD ’16} } diff --git a/contents/main_content.tex b/contents/main_content.tex new file mode 100644 index 0000000..18f7468 --- /dev/null +++ b/contents/main_content.tex @@ -0,0 +1,128 @@ +\section{Executive Summary} + +This development period, we focused on implementing the \textbf{Customizable Automated Data Integration Pipeline}. +Approximately 90\% of this feature is completed, including: +\begin{itemize} + \item Data aggregation and pipeline management systems + \item An AI data mapping module for unified dataset creation +\end{itemize} + +Remaining work involves completing the frontend-backend connection and refining the user interface for this module. + +\section{Detailed Development Description} + +\subsection{Overview} +The development scope focused on creating a data integration pipeline that automates the collection, processing, and unification of diverse data sources. Our objective was to implement an system capable of handling heterogeneous datasets from pipeline while minimizing manual configuration requirements. We adopted an iterative development approach, prioritizing core pipeline functionality before addressing user interface components. + +\subsection{Key Classes and Modules Developed} + +\begin{itemize} + \item \textbf{pipeline/**}: This core module contains all components related to the Automated Data Integration Pipeline functionality + \item \textbf{pipeline/ingestion/ingestors/mapping/mapping\_ingest.py}: Contains the AI mapping function that consolidates diverse data sources into a unified dataset structure + \item \textbf{frontend/**}: Contains all user interface components, with specific emphasis on the pipeline configuration and monitoring interfaces +\end{itemize} + +\subsection{Implementation Details and Challenges} +The data integration pipeline was implemented using a fastAPI combine with model fine-tuning on Vertex AI. +Here are lists of things we've developed + +\begin{itemize} + \item Data adaptor which consume data from API, File, and Scraping sources + \item Data ingestor to help aggregate the data from each adaptor including AI ingestor module (AI data mapping module) + \item Scheduling service to help manage pipeline + \item Data store to save the pipeline configuration + \item UI interface for pipeline service +\end{itemize} + +We faced several challenges. First, the scraping adapter doesn’t work on Windows right now. Second, the scheduling service was poorly designed, which caused many problems and now needs to be redesigned. We also had trouble building stable data connectors for different data sources. It was hard to create a smart mapping system that could understand how different data formats are related. Changing the data while keeping it correct was another challenge. Finally, making sure the system can handle a large amount of data was also difficult. + +\subsection{Screenshots} + +\begin{figure}[H] + \centering + \includegraphics[width=0.8\textwidth]{assets/api-doc.png} + \caption{API documentation interface for pipeline management endpoints, providing comprehensive testing capabilities for backend functionality} + \label{fig:api-doc} +\end{figure} + +\begin{figure}[H] + \centering + \includegraphics[width=0.8\textwidth]{assets/vertex/model-versioning.png} + \caption{Data Mapping LLM models with multiple versions} + \label{fig:model-versioning} +\end{figure} + +Figure 2 display versions of data schema apping model that we fine-tune on Vertex AI platform. + +\begin{figure}[H] + \centering + \includegraphics[width=0.8\textwidth]{assets/pipeline.png} + \caption{Pipeline status UI interface} + \label{fig:pipeline-status-ui} +\end{figure} + +Figure 3 is an example of UI interface we have been developed along with the pipeline backend service. + + +\subsection{Experimental Results} + +Performance metrics are based on 2 metrics: + \begin{itemize} + \item \textbf{JSON Syntactic Validity}: Parse the output string and check for validity. + \item \textbf{Pydantic Schema Conformance}: Check with pre-defined pydantic schema to ensure that it output the desire data scheme. + \end{itemize} + +There is a problem on the training data so conformance scores are low, we will fix it. + + +\begin{table}[htbp] + \centering + \caption{Model Validation Metrics} + \label{tab:model_comparison} + \begin{tabular}{llc} + \toprule + \textbf{Model Version} & \textbf{Metric} & \textbf{Value (\%)} \\ + \midrule + \textbf{BORBANN\_PIPELINE\_2} + & JSON Syntactic Validity & 91.67\% \\ + & Pydantic Schema Conformance & 63.64\% \\ + \midrule + \textbf{BORBANN\_PIPELINE\_3} + & JSON Syntactic Validity & 100.00\% \\ + & Pydantic Schema Conformance & 0.00\% \\ + \midrule + \textbf{BORBANN\_PIPELINE\_4} + & JSON Syntactic Validity & 100.00\% \\ + & Pydantic Schema Conformance & 0.00\% \\ + \bottomrule + \end{tabular} +\end{table} + +\subsection{Datasets Acquired or Used} + +We mainly based on two sources; data from implemented pipeline service and generated data from LLM + +\begin{itemize} + \item \textbf{Collected from pipeline service} -- Combine the data output from pipeline with specific prompt to create user role and define the target canonical dataset for model role + \item \textbf{Generate with Gemini 2.5 Flash Preview 04-17 with this prompt} -- Craft prompt to more synthetic datas and cover more cases +\end{itemize} + +\subsection{Updated Development Plan} + +Here is the updated gantt chart + +\begin{figure}[H] + \centering + \includegraphics[width=0.8\textwidth]{assets/gant.png} + \caption{Gantt Chart} + \label{fig:gantt} +\end{figure} + + +\subsection{Self-evaluation} + +I think this pass month we have done a lot of things such as system design and UI design, our progress is faster on the frontend side +and we think that on the backend is a bit slower due to challenges such as integrity of data in pipeline, so we need to redesign the pipeline service many times. +Also, we have a bit problem on the scheduling of pipeline too, so we need to rewrite it too due to bad design. + +Overall, We think that we need to work harder if we want to finish this project in time with good quality. \ No newline at end of file diff --git a/document.pdf b/document.pdf new file mode 100644 index 0000000..ca90724 Binary files /dev/null and b/document.pdf differ diff --git a/document.tex b/document.tex new file mode 100644 index 0000000..e337c32 --- /dev/null +++ b/document.tex @@ -0,0 +1,50 @@ +\documentclass[12pt,oneside,openany]{article} + +\usepackage{ifthen} +\newboolean{PrintVersion} +\setboolean{PrintVersion}{false} +\usepackage{lipsum} +\usepackage{tikz} +\usepackage{tabularx} +\usepackage{subcaption} +\usepackage[utf8]{inputenc} +\usepackage{graphicx} +\usepackage{float} +\usepackage{pgfgantt} % For Gantt charts +\usepackage{hyperref} +\usepackage{booktabs} +\usepackage{enumitem} +\usepackage[margin=2.5cm]{geometry} +\usepackage{xcolor} +\usepackage{listings} +\usepackage{fancyhdr} +\usepackage{textcomp} + +\definecolor{codegreen}{rgb}{0,0.6,0} +\definecolor{codegray}{rgb}{0.5,0.5,0.5} +\definecolor{codepurple}{rgb}{0.58,0,0.82} +\definecolor{backcolour}{rgb}{0.95,0.95,0.92} + +\input{thesis-preamble} +\input{private/thesis-margins-and-spaces} + +\begin{document} + +\newcommand{\thesisauthor}{Pattadon Loyprasert 6510545608} +\newcommand{\thesecondsisauthor}{Sirin Phungkun 6510545730} +\newcommand{\thesistitlecoverpage}{BorBann\\ A Real Estate Information Platform\\ (End-of-Semester Progress Report)} +\newcommand{\nameofprogram}{01219395 Innovative Software Group Project Preparation} +\newcommand{\academicunit}{\nameofprogram} +\newcommand{\faculty}{Faculty of Engineering} +\newcommand{\graduationyear}{2025} + +\input{private/frontpage} +\input{private/approvalpage} + +\newpage +\pagenumbering{arabic} +\pagestyle{headings} + +\include{contents/main_content} + +\end{document} diff --git a/node_modules/.bin/prettier b/node_modules/.bin/prettier new file mode 100644 index 0000000..5944261 --- /dev/null +++ b/node_modules/.bin/prettier @@ -0,0 +1,16 @@ +#!/bin/sh +basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')") + +case `uname` in + *CYGWIN*|*MINGW*|*MSYS*) + if command -v cygpath > /dev/null 2>&1; then + basedir=`cygpath -w "$basedir"` + fi + ;; +esac + +if [ -x "$basedir/node" ]; then + exec "$basedir/node" "$basedir/../prettier/bin/prettier.cjs" "$@" +else + exec node "$basedir/../prettier/bin/prettier.cjs" "$@" +fi diff --git a/node_modules/.bin/prettier.cmd b/node_modules/.bin/prettier.cmd new file mode 100644 index 0000000..e0fa0f7 --- /dev/null +++ b/node_modules/.bin/prettier.cmd @@ -0,0 +1,17 @@ +@ECHO off +GOTO start +:find_dp0 +SET dp0=%~dp0 +EXIT /b +:start +SETLOCAL +CALL :find_dp0 + +IF EXIST "%dp0%\node.exe" ( + SET "_prog=%dp0%\node.exe" +) ELSE ( + SET "_prog=node" + SET PATHEXT=%PATHEXT:;.JS;=;% +) + +endLocal & goto #_undefined_# 2>NUL || title %COMSPEC% & "%_prog%" "%dp0%\..\prettier\bin\prettier.cjs" %* diff --git a/node_modules/.bin/prettier.ps1 b/node_modules/.bin/prettier.ps1 new file mode 100644 index 0000000..8359dd9 --- /dev/null +++ b/node_modules/.bin/prettier.ps1 @@ -0,0 +1,28 @@ +#!/usr/bin/env pwsh +$basedir=Split-Path $MyInvocation.MyCommand.Definition -Parent + +$exe="" +if ($PSVersionTable.PSVersion -lt "6.0" -or $IsWindows) { + # Fix case when both the Windows and Linux builds of Node + # are installed in the same directory + $exe=".exe" +} +$ret=0 +if (Test-Path "$basedir/node$exe") { + # Support pipeline input + if ($MyInvocation.ExpectingInput) { + $input | & "$basedir/node$exe" "$basedir/../prettier/bin/prettier.cjs" $args + } else { + & "$basedir/node$exe" "$basedir/../prettier/bin/prettier.cjs" $args + } + $ret=$LASTEXITCODE +} else { + # Support pipeline input + if ($MyInvocation.ExpectingInput) { + $input | & "node$exe" "$basedir/../prettier/bin/prettier.cjs" $args + } else { + & "node$exe" "$basedir/../prettier/bin/prettier.cjs" $args + } + $ret=$LASTEXITCODE +} +exit $ret diff --git a/node_modules/.package-lock.json b/node_modules/.package-lock.json new file mode 100644 index 0000000..44b2ece --- /dev/null +++ b/node_modules/.package-lock.json @@ -0,0 +1,525 @@ +{ + "name": "srs", + "lockfileVersion": 3, + "requires": true, + "packages": { + "node_modules/@types/unist": { + "version": "2.0.11", + "resolved": "https://registry.npmjs.org/@types/unist/-/unist-2.0.11.tgz", + "integrity": "sha512-CmBKiL6NNo/OqgmMn95Fk9Whlp2mtvIv+KNpQKN2F4SjvrEesubTRWGYSg+BnWZOnlCaSTU1sMpsBOzgbYhnsA==", + "dev": true, + "license": "MIT" + }, + "node_modules/@unified-latex/unified-latex-builder": { + "version": "1.8.0", + "resolved": "https://registry.npmjs.org/@unified-latex/unified-latex-builder/-/unified-latex-builder-1.8.0.tgz", + "integrity": "sha512-1s5MIan/qaYeqJI1Tk3bfUwdkk0jIrQXRJt0dF0j3JWT9RG60WbiXp+593eOJgFYJtn+h3FdM0bvalfa+ZzTXg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@unified-latex/unified-latex-types": "^1.8.0" + } + }, + "node_modules/@unified-latex/unified-latex-ctan": { + "version": "1.8.2", + "resolved": "https://registry.npmjs.org/@unified-latex/unified-latex-ctan/-/unified-latex-ctan-1.8.2.tgz", + "integrity": "sha512-VuOEU3Kzed/b+lm+nypYtV1IiqIuFWpwx92WNtBW1w3S+Ba/Ffolx+/LoAd8uuCcyCmygkQi3eZJNHxarzyVIg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@unified-latex/unified-latex-builder": "^1.8.0", + "@unified-latex/unified-latex-types": "^1.8.0", + "@unified-latex/unified-latex-util-argspec": "^1.8.2", + "@unified-latex/unified-latex-util-arguments": "^1.8.2", + "@unified-latex/unified-latex-util-comments": "^1.8.2", + "@unified-latex/unified-latex-util-match": "^1.8.0", + "@unified-latex/unified-latex-util-pegjs": "^1.8.1", + "@unified-latex/unified-latex-util-print-raw": "^1.8.0", + "@unified-latex/unified-latex-util-render-info": "^1.8.2", + "@unified-latex/unified-latex-util-replace": "^1.8.2", + "@unified-latex/unified-latex-util-scan": "^1.8.0", + "@unified-latex/unified-latex-util-split": "^1.8.0", + "@unified-latex/unified-latex-util-trim": "^1.8.2", + "@unified-latex/unified-latex-util-visit": "^1.8.2", + "color": "^4.2.3" + } + }, + "node_modules/@unified-latex/unified-latex-prettier": { + "version": "2.4.2", + "resolved": "https://registry.npmjs.org/@unified-latex/unified-latex-prettier/-/unified-latex-prettier-2.4.2.tgz", + "integrity": "sha512-gMvlKGiGi9zOWVHXPhzeURhPYwPIJ7MBht42et/sVb4Z2wTjhcn+bU7kookT067ywOptVZNBgJw+iAgSORAd+w==", + "deprecated": "Incorrect version number", + "dev": true, + "license": "MIT", + "dependencies": { + "@unified-latex/unified-latex-ctan": "^1.4.1", + "@unified-latex/unified-latex-types": "^1.3.1", + "@unified-latex/unified-latex-util-align": "^1.4.0", + "@unified-latex/unified-latex-util-match": "^1.4.0", + "@unified-latex/unified-latex-util-parse": "^1.4.1", + "@unified-latex/unified-latex-util-pgfkeys": "^1.4.0", + "@unified-latex/unified-latex-util-print-raw": "^1.4.0", + "@unified-latex/unified-latex-util-trim": "^1.4.0", + "@unified-latex/unified-latex-util-visit": "^1.4.0", + "prettier": "^3.0.3", + "unified": "^10.1.2" + } + }, + "node_modules/@unified-latex/unified-latex-types": { + "version": "1.8.0", + "resolved": "https://registry.npmjs.org/@unified-latex/unified-latex-types/-/unified-latex-types-1.8.0.tgz", + "integrity": "sha512-GLJbBmmfDOWtdEbpQCLb7++zPxXin36aC9XOVCuiVNMR9VYv3szOJa+ZdTilVCFHpOeFhKh6zRws96vJgz2tGA==", + "dev": true, + "license": "MIT" + }, + "node_modules/@unified-latex/unified-latex-util-align": { + "version": "1.8.1", + "resolved": "https://registry.npmjs.org/@unified-latex/unified-latex-util-align/-/unified-latex-util-align-1.8.1.tgz", + "integrity": "sha512-csJxLrvziRc5ZkhcRsYI7gSQBGC4fXucPtwNkTscbSIy7PfYF7BfWBPc61sb9jXQg4T4R6MLdG/Tz6Pgb6z1bw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@unified-latex/unified-latex-types": "^1.8.0", + "@unified-latex/unified-latex-util-match": "^1.8.0", + "@unified-latex/unified-latex-util-pegjs": "^1.8.1" + } + }, + "node_modules/@unified-latex/unified-latex-util-argspec": { + "version": "1.8.2", + "resolved": "https://registry.npmjs.org/@unified-latex/unified-latex-util-argspec/-/unified-latex-util-argspec-1.8.2.tgz", + "integrity": "sha512-ts+6Ha9JhcMCt+rbajjiG0srxCz2jHcNrIe3zma2HQzmKNOGxpoTdA7+E4sG2wJgQK1+eQ9MrjGeLBCNXH7fGg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@unified-latex/unified-latex-util-pegjs": "^1.8.1" + } + }, + "node_modules/@unified-latex/unified-latex-util-arguments": { + "version": "1.8.2", + "resolved": "https://registry.npmjs.org/@unified-latex/unified-latex-util-arguments/-/unified-latex-util-arguments-1.8.2.tgz", + "integrity": "sha512-81OqsLoVUhVFgp64z7Jrtndgl5fJGvZKV1eipNWH4IH2hFEM8RZ0fmLxyOn7S/NjYuqWeOJ3WhjOvRHtmLLf2Q==", + "dev": true, + "license": "MIT", + "dependencies": { + "@unified-latex/unified-latex-builder": "^1.8.0", + "@unified-latex/unified-latex-types": "^1.8.0", + "@unified-latex/unified-latex-util-argspec": "^1.8.2", + "@unified-latex/unified-latex-util-match": "^1.8.0", + "@unified-latex/unified-latex-util-render-info": "^1.8.2", + "@unified-latex/unified-latex-util-scan": "^1.8.0", + "@unified-latex/unified-latex-util-visit": "^1.8.2", + "unified": "^10.1.2" + } + }, + "node_modules/@unified-latex/unified-latex-util-catcode": { + "version": "1.8.2", + "resolved": "https://registry.npmjs.org/@unified-latex/unified-latex-util-catcode/-/unified-latex-util-catcode-1.8.2.tgz", + "integrity": "sha512-zChzwfcXufJ5tMkBNC06GdMFj3ldWnlL1eLszFNtcWPvB6KyXHjOPRSZ9aILjbZEd2ogBc8lOKc5ug+iBFBVxA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@unified-latex/unified-latex-types": "^1.8.0", + "@unified-latex/unified-latex-util-match": "^1.8.0", + "@unified-latex/unified-latex-util-visit": "^1.8.2" + } + }, + "node_modules/@unified-latex/unified-latex-util-comments": { + "version": "1.8.2", + "resolved": "https://registry.npmjs.org/@unified-latex/unified-latex-util-comments/-/unified-latex-util-comments-1.8.2.tgz", + "integrity": "sha512-OGeT3BYzLT6hRgyRrPqXTJBpD/JaJl5yIcpQfm5wpcDFBVfcDOCZ8/Xc7UwosOvCjM5EHVTJIxmDQ1epZg3IzA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@unified-latex/unified-latex-types": "^1.8.0", + "@unified-latex/unified-latex-util-match": "^1.8.0", + "@unified-latex/unified-latex-util-replace": "^1.8.2" + } + }, + "node_modules/@unified-latex/unified-latex-util-environments": { + "version": "1.8.2", + "resolved": "https://registry.npmjs.org/@unified-latex/unified-latex-util-environments/-/unified-latex-util-environments-1.8.2.tgz", + "integrity": "sha512-ZaL28+sUtVOSsWv2LfcGXmOJoQJ0Vu4se/7R83awutr2cS3YIZsyCIRFfhz1jYyedWfGLtq+a/2MWJfcIcd7Jg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@unified-latex/unified-latex-types": "^1.8.0", + "@unified-latex/unified-latex-util-arguments": "^1.8.2", + "@unified-latex/unified-latex-util-match": "^1.8.0", + "@unified-latex/unified-latex-util-print-raw": "^1.8.0", + "@unified-latex/unified-latex-util-render-info": "^1.8.2", + "@unified-latex/unified-latex-util-visit": "^1.8.2", + "unified": "^10.1.2" + } + }, + "node_modules/@unified-latex/unified-latex-util-match": { + "version": "1.8.0", + "resolved": "https://registry.npmjs.org/@unified-latex/unified-latex-util-match/-/unified-latex-util-match-1.8.0.tgz", + "integrity": "sha512-fjuLI1KVhWTHkfWn0kR8/RhM2oD2hxWhzgskUMLJ/IZMye9ESvVo8ItG4y+BtpwGFWpTmCtpMNXHjknIQxza9Q==", + "dev": true, + "license": "MIT", + "dependencies": { + "@unified-latex/unified-latex-types": "^1.8.0", + "@unified-latex/unified-latex-util-print-raw": "^1.8.0" + } + }, + "node_modules/@unified-latex/unified-latex-util-parse": { + "version": "1.8.2", + "resolved": "https://registry.npmjs.org/@unified-latex/unified-latex-util-parse/-/unified-latex-util-parse-1.8.2.tgz", + "integrity": "sha512-PyHQTZWS7/BCVa8ojBEmVl5a3iXs5ZSOqhp2R/bbroe7+OEmQbqULPq4GigHA6ClEbPmP8uxmgHZDFGH2cfR7A==", + "dev": true, + "license": "MIT", + "dependencies": { + "@unified-latex/unified-latex-ctan": "^1.8.2", + "@unified-latex/unified-latex-types": "^1.8.0", + "@unified-latex/unified-latex-util-arguments": "^1.8.2", + "@unified-latex/unified-latex-util-catcode": "^1.8.2", + "@unified-latex/unified-latex-util-environments": "^1.8.2", + "@unified-latex/unified-latex-util-match": "^1.8.0", + "@unified-latex/unified-latex-util-pegjs": "^1.8.1", + "@unified-latex/unified-latex-util-print-raw": "^1.8.0", + "@unified-latex/unified-latex-util-trim": "^1.8.2", + "@unified-latex/unified-latex-util-visit": "^1.8.2", + "unified": "^10.1.2" + } + }, + "node_modules/@unified-latex/unified-latex-util-pegjs": { + "version": "1.8.1", + "resolved": "https://registry.npmjs.org/@unified-latex/unified-latex-util-pegjs/-/unified-latex-util-pegjs-1.8.1.tgz", + "integrity": "sha512-1N6WknnzKGACFCmgaEZ2j89j5C2dKhmAOCfy6moD+AMm6nUb69Xp9pJ1jDfqz+Uz9+zRo5I6ksr6q5GgmAJvtw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@unified-latex/unified-latex-types": "^1.8.0", + "@unified-latex/unified-latex-util-match": "^1.8.0" + } + }, + "node_modules/@unified-latex/unified-latex-util-pgfkeys": { + "version": "1.8.1", + "resolved": "https://registry.npmjs.org/@unified-latex/unified-latex-util-pgfkeys/-/unified-latex-util-pgfkeys-1.8.1.tgz", + "integrity": "sha512-VwZeUzmPgKwO2sZ9xx4Ul0Mp82DVdWg32krOlH9dzW4ZQDOBTnRtvx6LQmg9b7Iz3F2pHLYU0LCCaJlvFNBm1A==", + "dev": true, + "license": "MIT", + "dependencies": { + "@unified-latex/unified-latex-types": "^1.8.0", + "@unified-latex/unified-latex-util-match": "^1.8.0", + "@unified-latex/unified-latex-util-pegjs": "^1.8.1", + "@unified-latex/unified-latex-util-print-raw": "^1.8.0" + } + }, + "node_modules/@unified-latex/unified-latex-util-print-raw": { + "version": "1.8.0", + "resolved": "https://registry.npmjs.org/@unified-latex/unified-latex-util-print-raw/-/unified-latex-util-print-raw-1.8.0.tgz", + "integrity": "sha512-lMuLqnHXCDNqrjslf6hBAA2McEI+oaaxvjA9zfeAeWZyZh+DUJjkmwiuxYejwHHKbQvqzregNP4wtb9OvaC21g==", + "dev": true, + "license": "MIT", + "dependencies": { + "@unified-latex/unified-latex-types": "^1.8.0" + } + }, + "node_modules/@unified-latex/unified-latex-util-render-info": { + "version": "1.8.2", + "resolved": "https://registry.npmjs.org/@unified-latex/unified-latex-util-render-info/-/unified-latex-util-render-info-1.8.2.tgz", + "integrity": "sha512-Hjqt8Kx2/pYWwd/S3H397zyenLFwoZsmo7BL/Q7mJfj5wNs35ZMdoHQa0O8tLeZjezkWB2eejODVBsu5xDDCjw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@unified-latex/unified-latex-types": "^1.8.0", + "@unified-latex/unified-latex-util-visit": "^1.8.2" + } + }, + "node_modules/@unified-latex/unified-latex-util-replace": { + "version": "1.8.2", + "resolved": "https://registry.npmjs.org/@unified-latex/unified-latex-util-replace/-/unified-latex-util-replace-1.8.2.tgz", + "integrity": "sha512-89GNj4p5wJmSUGAmdFlGnb/SaV4WykroK85bYbY3Fwppp7kO6sVYSRGfrTEIFob1S4HGL6xrYYUnCueI0+ZzhQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "@unified-latex/unified-latex-types": "^1.8.0", + "@unified-latex/unified-latex-util-match": "^1.8.0", + "@unified-latex/unified-latex-util-split": "^1.8.0", + "@unified-latex/unified-latex-util-trim": "^1.8.2", + "@unified-latex/unified-latex-util-visit": "^1.8.2", + "unified": "^10.1.2" + } + }, + "node_modules/@unified-latex/unified-latex-util-scan": { + "version": "1.8.0", + "resolved": "https://registry.npmjs.org/@unified-latex/unified-latex-util-scan/-/unified-latex-util-scan-1.8.0.tgz", + "integrity": "sha512-4WWDTcLOhlkZsGmGl/IZA0Jg2rTitVwGf6ktxs57AyuCEdzHA5ZeNwzSewW8wpHQdLfnPX+LNEnaukwEdWfF1g==", + "dev": true, + "license": "MIT", + "dependencies": { + "@unified-latex/unified-latex-types": "^1.8.0", + "@unified-latex/unified-latex-util-match": "^1.8.0", + "@unified-latex/unified-latex-util-print-raw": "^1.8.0", + "trie-prefix-tree": "^1.5.1" + } + }, + "node_modules/@unified-latex/unified-latex-util-split": { + "version": "1.8.0", + "resolved": "https://registry.npmjs.org/@unified-latex/unified-latex-util-split/-/unified-latex-util-split-1.8.0.tgz", + "integrity": "sha512-gRlRge72wcvLRs6bEoVbh0fDACbkioEPDJOr7XaCuQqjNNu1VTXlcvImZQVXCdMG6CJ4lqiaJRwnUupK4rsmsA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@unified-latex/unified-latex-types": "^1.8.0", + "@unified-latex/unified-latex-util-match": "^1.8.0" + } + }, + "node_modules/@unified-latex/unified-latex-util-trim": { + "version": "1.8.2", + "resolved": "https://registry.npmjs.org/@unified-latex/unified-latex-util-trim/-/unified-latex-util-trim-1.8.2.tgz", + "integrity": "sha512-zshEykIuLvngWNl7RnMP86KE3yieVLK2u+byPioh6JVQCwkHoz/UiPzl+fuPw/u+93LPNSJBRa16a03sviqyBA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@unified-latex/unified-latex-types": "^1.8.0", + "@unified-latex/unified-latex-util-match": "^1.8.0", + "@unified-latex/unified-latex-util-visit": "^1.8.2", + "unified": "^10.1.2" + } + }, + "node_modules/@unified-latex/unified-latex-util-visit": { + "version": "1.8.2", + "resolved": "https://registry.npmjs.org/@unified-latex/unified-latex-util-visit/-/unified-latex-util-visit-1.8.2.tgz", + "integrity": "sha512-Xq8516ZTKCfjB/txSIbUWtdIR2NdWO8/LlhjMLljFCEO4IE1KfhCCgKgwxNa7uuCkGG0e0BwVEHQIjH4TQZARQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "@unified-latex/unified-latex-types": "^1.8.0", + "@unified-latex/unified-latex-util-match": "^1.8.0" + } + }, + "node_modules/bail": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/bail/-/bail-2.0.2.tgz", + "integrity": "sha512-0xO6mYd7JB2YesxDKplafRpsiOzPt9V02ddPCLbY1xYGPOX24NTyN50qnUxgCPcSoYMhKpAuBTjQoRZCAkUDRw==", + "dev": true, + "license": "MIT", + "funding": { + "type": "github", + "url": "https://github.com/sponsors/wooorm" + } + }, + "node_modules/color": { + "version": "4.2.3", + "resolved": "https://registry.npmjs.org/color/-/color-4.2.3.tgz", + "integrity": "sha512-1rXeuUUiGGrykh+CeBdu5Ie7OJwinCgQY0bc7GCRxy5xVHy+moaqkpL/jqQq0MtQOeYcrqEz4abc5f0KtU7W4A==", + "dev": true, + "license": "MIT", + "dependencies": { + "color-convert": "^2.0.1", + "color-string": "^1.9.0" + }, + "engines": { + "node": ">=12.5.0" + } + }, + "node_modules/color-convert": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz", + "integrity": "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "color-name": "~1.1.4" + }, + "engines": { + "node": ">=7.0.0" + } + }, + "node_modules/color-name": { + "version": "1.1.4", + "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz", + "integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==", + "dev": true, + "license": "MIT" + }, + "node_modules/color-string": { + "version": "1.9.1", + "resolved": "https://registry.npmjs.org/color-string/-/color-string-1.9.1.tgz", + "integrity": "sha512-shrVawQFojnZv6xM40anx4CkoDP+fZsw/ZerEMsW/pyzsRbElpsL/DBVW7q3ExxwusdNXI3lXpuhEZkzs8p5Eg==", + "dev": true, + "license": "MIT", + "dependencies": { + "color-name": "^1.0.0", + "simple-swizzle": "^0.2.2" + } + }, + "node_modules/extend": { + "version": "3.0.2", + "resolved": "https://registry.npmjs.org/extend/-/extend-3.0.2.tgz", + "integrity": "sha512-fjquC59cD7CyW6urNXK0FBufkZcoiGG80wTuPujX590cB5Ttln20E2UB4S/WARVqhXffZl2LNgS+gQdPIIim/g==", + "dev": true, + "license": "MIT" + }, + "node_modules/is-arrayish": { + "version": "0.3.2", + "resolved": "https://registry.npmjs.org/is-arrayish/-/is-arrayish-0.3.2.tgz", + "integrity": "sha512-eVRqCvVlZbuw3GrM63ovNSNAeA1K16kaR/LRY/92w0zxQ5/1YzwblUX652i4Xs9RwAGjW9d9y6X88t8OaAJfWQ==", + "dev": true, + "license": "MIT" + }, + "node_modules/is-buffer": { + "version": "2.0.5", + "resolved": "https://registry.npmjs.org/is-buffer/-/is-buffer-2.0.5.tgz", + "integrity": "sha512-i2R6zNFDwgEHJyQUtJEk0XFi1i0dPFn/oqjK3/vPCcDeJvW5NQ83V8QbicfF1SupOaB0h8ntgBC2YiE7dfyctQ==", + "dev": true, + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/feross" + }, + { + "type": "patreon", + "url": "https://www.patreon.com/feross" + }, + { + "type": "consulting", + "url": "https://feross.org/support" + } + ], + "license": "MIT", + "engines": { + "node": ">=4" + } + }, + "node_modules/is-plain-obj": { + "version": "4.1.0", + "resolved": "https://registry.npmjs.org/is-plain-obj/-/is-plain-obj-4.1.0.tgz", + "integrity": "sha512-+Pgi+vMuUNkJyExiMBt5IlFoMyKnr5zhJ4Uspz58WOhBF5QoIZkFyNHIbBAtHwzVAgk5RtndVNsDRN61/mmDqg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=12" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/prettier": { + "version": "3.5.3", + "resolved": "https://registry.npmjs.org/prettier/-/prettier-3.5.3.tgz", + "integrity": "sha512-QQtaxnoDJeAkDvDKWCLiwIXkTgRhwYDEQCghU9Z6q03iyek/rxRh/2lC3HB7P8sWT2xC/y5JDctPLBIGzHKbhw==", + "dev": true, + "license": "MIT", + "bin": { + "prettier": "bin/prettier.cjs" + }, + "engines": { + "node": ">=14" + }, + "funding": { + "url": "https://github.com/prettier/prettier?sponsor=1" + } + }, + "node_modules/prettier-plugin-latex": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/prettier-plugin-latex/-/prettier-plugin-latex-2.0.1.tgz", + "integrity": "sha512-xIKGN0uWU+JwGHI92ixohngGLpy2nGQhYnmTtVue/jbw+K0fFPddQ3pMXx3fjtmmUhlbZisYXehJtcJ9Ford0g==", + "dev": true, + "license": "MIT", + "dependencies": { + "@unified-latex/unified-latex-prettier": "^2.4.2", + "prettier": "^3.0.3" + }, + "engines": { + "node": ">= 18.0" + } + }, + "node_modules/simple-swizzle": { + "version": "0.2.2", + "resolved": "https://registry.npmjs.org/simple-swizzle/-/simple-swizzle-0.2.2.tgz", + "integrity": "sha512-JA//kQgZtbuY83m+xT+tXJkmJncGMTFT+C+g2h2R9uxkYIrE2yy9sgmcLhCnw57/WSD+Eh3J97FPEDFnbXnDUg==", + "dev": true, + "license": "MIT", + "dependencies": { + "is-arrayish": "^0.3.1" + } + }, + "node_modules/trie-prefix-tree": { + "version": "1.5.1", + "resolved": "https://registry.npmjs.org/trie-prefix-tree/-/trie-prefix-tree-1.5.1.tgz", + "integrity": "sha512-Jjvj/dA97wXnabG/NLJUgo4IQMj6vucH+Qxm7of/omfWSmZlPqdRU6Ta4GmQqCZH+n3/iYZUwfvUoEhB0Hs83Q==", + "dev": true, + "license": "MIT" + }, + "node_modules/trough": { + "version": "2.2.0", + "resolved": "https://registry.npmjs.org/trough/-/trough-2.2.0.tgz", + "integrity": "sha512-tmMpK00BjZiUyVyvrBK7knerNgmgvcV/KLVyuma/SC+TQN167GrMRciANTz09+k3zW8L8t60jWO1GpfkZdjTaw==", + "dev": true, + "license": "MIT", + "funding": { + "type": "github", + "url": "https://github.com/sponsors/wooorm" + } + }, + "node_modules/unified": { + "version": "10.1.2", + "resolved": "https://registry.npmjs.org/unified/-/unified-10.1.2.tgz", + "integrity": "sha512-pUSWAi/RAnVy1Pif2kAoeWNBa3JVrx0MId2LASj8G+7AiHWoKZNTomq6LG326T68U7/e263X6fTdcXIy7XnF7Q==", + "dev": true, + "license": "MIT", + "dependencies": { + "@types/unist": "^2.0.0", + "bail": "^2.0.0", + "extend": "^3.0.0", + "is-buffer": "^2.0.0", + "is-plain-obj": "^4.0.0", + "trough": "^2.0.0", + "vfile": "^5.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, + "node_modules/unist-util-stringify-position": { + "version": "3.0.3", + "resolved": "https://registry.npmjs.org/unist-util-stringify-position/-/unist-util-stringify-position-3.0.3.tgz", + "integrity": "sha512-k5GzIBZ/QatR8N5X2y+drfpWG8IDBzdnVj6OInRNWm1oXrzydiaAT2OQiA8DPRRZyAKb9b6I2a6PxYklZD0gKg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@types/unist": "^2.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, + "node_modules/vfile": { + "version": "5.3.7", + "resolved": "https://registry.npmjs.org/vfile/-/vfile-5.3.7.tgz", + "integrity": "sha512-r7qlzkgErKjobAmyNIkkSpizsFPYiUPuJb5pNW1RB4JcYVZhs4lIbVqk8XPk033CV/1z8ss5pkax8SuhGpcG8g==", + "dev": true, + "license": "MIT", + "dependencies": { + "@types/unist": "^2.0.0", + "is-buffer": "^2.0.0", + "unist-util-stringify-position": "^3.0.0", + "vfile-message": "^3.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, + "node_modules/vfile-message": { + "version": "3.1.4", + "resolved": "https://registry.npmjs.org/vfile-message/-/vfile-message-3.1.4.tgz", + "integrity": "sha512-fa0Z6P8HUrQN4BZaX05SIVXic+7kE3b05PWAtPuYP9QLHsLKYR7/AlLW3NtOrpXRLeawpDLMsVkmk5DG0NXgWw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@types/unist": "^2.0.0", + "unist-util-stringify-position": "^3.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + } + } +} diff --git a/node_modules/@types/unist/LICENSE b/node_modules/@types/unist/LICENSE new file mode 100644 index 0000000..9e841e7 --- /dev/null +++ b/node_modules/@types/unist/LICENSE @@ -0,0 +1,21 @@ + MIT License + + Copyright (c) Microsoft Corporation. + + Permission is hereby granted, free of charge, to any person obtaining a copy + of this software and associated documentation files (the "Software"), to deal + in the Software without restriction, including without limitation the rights + to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + copies of the Software, and to permit persons to whom the Software is + furnished to do so, subject to the following conditions: + + The above copyright notice and this permission notice shall be included in all + copies or substantial portions of the Software. + + THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + SOFTWARE diff --git a/node_modules/@types/unist/README.md b/node_modules/@types/unist/README.md new file mode 100644 index 0000000..c64ed29 --- /dev/null +++ b/node_modules/@types/unist/README.md @@ -0,0 +1,122 @@ +# Installation +> `npm install --save @types/unist` + +# Summary +This package contains type definitions for unist (https://github.com/syntax-tree/unist). + +# Details +Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/unist/v2. +## [index.d.ts](https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/unist/v2/index.d.ts) +````ts +/** + * Syntactic units in unist syntax trees are called nodes. + * + * @typeParam TData Information from the ecosystem. Useful for more specific {@link Node.data}. + */ +export interface Node { + /** + * The variant of a node. + */ + type: string; + + /** + * Information from the ecosystem. + */ + data?: TData | undefined; + + /** + * Location of a node in a source document. + * Must not be present if a node is generated. + */ + position?: Position | undefined; +} + +/** + * Information associated by the ecosystem with the node. + * Space is guaranteed to never be specified by unist or specifications + * implementing unist. + */ +export interface Data { + [key: string]: unknown; +} + +/** + * Location of a node in a source file. + */ +export interface Position { + /** + * Place of the first character of the parsed source region. + */ + start: Point; + + /** + * Place of the first character after the parsed source region. + */ + end: Point; + + /** + * Start column at each index (plus start line) in the source region, + * for elements that span multiple lines. + */ + indent?: number[] | undefined; +} + +/** + * One place in a source file. + */ +export interface Point { + /** + * Line in a source file (1-indexed integer). + */ + line: number; + + /** + * Column in a source file (1-indexed integer). + */ + column: number; + /** + * Character in a source file (0-indexed integer). + */ + offset?: number | undefined; +} + +/** + * Util for extracting type of {@link Node.data} + * + * @typeParam TNode Specific node type such as {@link Node} with {@link Data}, {@link Literal}, etc. + * + * @example `NodeData>` -> `{ key: string }` + */ +export type NodeData> = TNode extends Node ? TData : never; + +/** + * Nodes containing other nodes. + * + * @typeParam ChildNode Node item of {@link Parent.children} + */ +export interface Parent = Node, TData extends object = NodeData> + extends Node +{ + /** + * List representing the children of a node. + */ + children: ChildNode[]; +} + +/** + * Nodes containing a value. + * + * @typeParam Value Specific value type of {@link Literal.value} such as `string` for `Text` node + */ +export interface Literal extends Node { + value: Value; +} + +```` + +### Additional Details + * Last updated: Thu, 15 Aug 2024 02:18:53 GMT + * Dependencies: none + +# Credits +These definitions were written by [bizen241](https://github.com/bizen241), [Jun Lu](https://github.com/lujun2), [Hernan Rajchert](https://github.com/hrajchert), [Titus Wormer](https://github.com/wooorm), [Junyoung Choi](https://github.com/rokt33r), [Ben Moon](https://github.com/GuiltyDolphin), and [JounQin](https://github.com/JounQin). diff --git a/node_modules/@types/unist/index.d.ts b/node_modules/@types/unist/index.d.ts new file mode 100644 index 0000000..b019d38 --- /dev/null +++ b/node_modules/@types/unist/index.d.ts @@ -0,0 +1,103 @@ +/** + * Syntactic units in unist syntax trees are called nodes. + * + * @typeParam TData Information from the ecosystem. Useful for more specific {@link Node.data}. + */ +export interface Node { + /** + * The variant of a node. + */ + type: string; + + /** + * Information from the ecosystem. + */ + data?: TData | undefined; + + /** + * Location of a node in a source document. + * Must not be present if a node is generated. + */ + position?: Position | undefined; +} + +/** + * Information associated by the ecosystem with the node. + * Space is guaranteed to never be specified by unist or specifications + * implementing unist. + */ +export interface Data { + [key: string]: unknown; +} + +/** + * Location of a node in a source file. + */ +export interface Position { + /** + * Place of the first character of the parsed source region. + */ + start: Point; + + /** + * Place of the first character after the parsed source region. + */ + end: Point; + + /** + * Start column at each index (plus start line) in the source region, + * for elements that span multiple lines. + */ + indent?: number[] | undefined; +} + +/** + * One place in a source file. + */ +export interface Point { + /** + * Line in a source file (1-indexed integer). + */ + line: number; + + /** + * Column in a source file (1-indexed integer). + */ + column: number; + /** + * Character in a source file (0-indexed integer). + */ + offset?: number | undefined; +} + +/** + * Util for extracting type of {@link Node.data} + * + * @typeParam TNode Specific node type such as {@link Node} with {@link Data}, {@link Literal}, etc. + * + * @example `NodeData>` -> `{ key: string }` + */ +export type NodeData> = TNode extends Node ? TData : never; + +/** + * Nodes containing other nodes. + * + * @typeParam ChildNode Node item of {@link Parent.children} + */ +export interface Parent = Node, TData extends object = NodeData> + extends Node +{ + /** + * List representing the children of a node. + */ + children: ChildNode[]; +} + +/** + * Nodes containing a value. + * + * @typeParam Value Specific value type of {@link Literal.value} such as `string` for `Text` node + */ +export interface Literal extends Node { + value: Value; +} diff --git a/node_modules/@types/unist/package.json b/node_modules/@types/unist/package.json new file mode 100644 index 0000000..01cb5b0 --- /dev/null +++ b/node_modules/@types/unist/package.json @@ -0,0 +1,55 @@ +{ + "name": "@types/unist", + "version": "2.0.11", + "description": "TypeScript definitions for unist", + "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/unist", + "license": "MIT", + "contributors": [ + { + "name": "bizen241", + "githubUsername": "bizen241", + "url": "https://github.com/bizen241" + }, + { + "name": "Jun Lu", + "githubUsername": "lujun2", + "url": "https://github.com/lujun2" + }, + { + "name": "Hernan Rajchert", + "githubUsername": "hrajchert", + "url": "https://github.com/hrajchert" + }, + { + "name": "Titus Wormer", + "githubUsername": "wooorm", + "url": "https://github.com/wooorm" + }, + { + "name": "Junyoung Choi", + "githubUsername": "rokt33r", + "url": "https://github.com/rokt33r" + }, + { + "name": "Ben Moon", + "githubUsername": "GuiltyDolphin", + "url": "https://github.com/GuiltyDolphin" + }, + { + "name": "JounQin", + "githubUsername": "JounQin", + "url": "https://github.com/JounQin" + } + ], + "main": "", + "types": "index.d.ts", + "repository": { + "type": "git", + "url": "https://github.com/DefinitelyTyped/DefinitelyTyped.git", + "directory": "types/unist" + }, + "scripts": {}, + "dependencies": {}, + "typesPublisherContentHash": "6e36525a6db49ae5517fe0751796ca8f6c65099098415046d4f1ad6c2ef1a33c", + "typeScriptVersion": "4.8" +} \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-builder/README.md b/node_modules/@unified-latex/unified-latex-builder/README.md new file mode 100644 index 0000000..15ceb53 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-builder/README.md @@ -0,0 +1,178 @@ + + + + +# unified-latex-builder + +## What is this? + +Functions to help build a `unified-latex` Abstract Syntax Tree (AST) +with [hyperscript](https://github.com/dominictarr/hyperscript)-like syntax. + +## When should I use this? + +If you want to programmatically create `Ast.Node` nodes. + +## Install + +```bash +npm install @unified-latex/unified-latex-builder +``` + +This package contains both esm and commonjs exports. To explicitly access the esm export, +import the `.js` file. To explicitly access the commonjs export, import the `.cjs` file. + +# Functions + +## `arg(args, special)` + +Create an Argument. `special.braces` can optionally specify +the signature of the open/close marks that each argument uses. For example + + arg("a", { braces: "[]" }); + +will result in arguments `[a]`. Valid braces are `*`, `[`, `{`, `<`, and `(`. + +`null` may be passed as the value of an empty optional argument. If `null` is passed, +the `openBrace` and `closeBrace` of the argument will be set to empty strings and the +contents will be set to an empty array. For example, + + args([null, "b"], { braces: "[]{}" }); + +will produce the same structure as if the the first "optional argument" were omitted in regular parsing. + +```typescript +function arg( + args: CoercibleArgument | Ast.Node[], + special: ArgumentSpecialOptions +): Ast.Argument; +``` + +**Parameters** + +| Param | Type | +| :------ | :-------------------------------- | +| args | Omitted | +| special | `ArgumentSpecialOptions` | + +where + +```typescript +type ArgumentSpecialOptions = { + braces?: string; + openMark?: string; + closeMark?: string; +}; +``` + +## `args(args, special)` + +Create an Argument list. `special.braces` can optionally specify +the signature of the open/close marks that each argument uses. For example + + args(["a", "b"], { braces: "[]{}" }); + +will result in arguments `[a]{b}`. Valid braces are `*`, `[`, `{`, `(`, and `<`. + +`null` may be passed as the value of an empty optional argument. If `null` is passed, +the `openBrace` and `closeBrace` of the argument will be set to empty strings and the +contents will be set to an empty array. For example, + + args([null, "b"], { braces: "[]{}" }); + +will produce the same structure as if the the first "optional argument" were omitted in regular parsing. + +```typescript +function args( + args: CoercibleArgument | CoercibleArgument[], + special: ArgumentsSpecialOptions +): Ast.Argument[]; +``` + +**Parameters** + +| Param | Type | +| :------ | :-------------------------------- | +| args | Omitted | +| special | `ArgumentsSpecialOptions` | + +where + +```typescript +type ArgumentsSpecialOptions = { + braces?: string; + defaultOpenMark?: string; + defaultCloseMark?: string; +}; +``` + +## `env(name, body, envArgs, special)` + +Create an Environment node. + +```typescript +function env( + name: String, + body: CoercibleNode | CoercibleNode[], + envArgs: CoercibleArgument | CoercibleArgument[], + special: {} +): Ast.Environment; +``` + +**Parameters** + +| Param | Type | +| :------ | :-------------------------------- | +| name | `String` | +| body | Omitted | +| envArgs | Omitted | +| special | `{}` | + +## `m(name, marcoArgs, special)` + +Create a Macro with the given `name`. The macro +may be followed by any number of arguments. + +```typescript +function m( + name: String, + marcoArgs: CoercibleArgument | CoercibleArgument[], + special: MacroSpecialOptions +): Ast.Macro; +``` + +**Parameters** + +| Param | Type | +| :-------- | :-------------------------------- | +| name | `String` | +| marcoArgs | Omitted | +| special | `MacroSpecialOptions` | + +where + +```typescript +type MacroSpecialOptions = { + escapeToken?: string; +}; +``` + +## `s(value)` + +Create a String node from `value` + +```typescript +function s(value: string | Ast.String): Ast.String; +``` + +**Parameters** + +| Param | Type | +| :---- | :--------------------- | +| value | `string \| Ast.String` | + +# Constants + +| Name | Type | Description | +| :--- | :--------------- | :--------------- | +| `SP` | `Ast.Whitespace` | Whitespace node. | diff --git a/node_modules/@unified-latex/unified-latex-builder/index.cjs b/node_modules/@unified-latex/unified-latex-builder/index.cjs new file mode 100644 index 0000000..18eb981 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-builder/index.cjs @@ -0,0 +1,142 @@ +"use strict"; +Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" }); +function normalizeNode(node) { + if (typeof node === "string") { + return s(node); + } + return node; +} +function normalizeArgument(arg2, openMark = "{", closeMark = "}") { + if (arg2 == null) { + return { type: "argument", content: [], openMark: "", closeMark: "" }; + } + if (typeof arg2 === "string") { + return { + type: "argument", + openMark, + closeMark, + content: [s(arg2)] + }; + } + if (arg2.type === "argument") { + return arg2; + } + return { type: "argument", openMark, closeMark, content: [arg2] }; +} +function normalizeArgumentsList(args2, openMark = "{", closeMark = "}") { + if (args2 == null) { + return []; + } + if (Array.isArray(args2)) { + return args2.map((arg2) => normalizeArgument(arg2, openMark, closeMark)); + } + return [normalizeArgument(args2, openMark, closeMark)]; +} +const BRACES_MAP = { + "*": { openMark: "", closeMark: "" }, + "{": { openMark: "{", closeMark: "}" }, + "[": { openMark: "[", closeMark: "]" }, + "(": { openMark: "(", closeMark: ")" }, + "<": { openMark: "<", closeMark: ">" } +}; +const CLOSE_BRACES = new Set( + Object.values(BRACES_MAP).map((x) => x.closeMark).filter((x) => x) +); +function bracesToOpenAndCloseMarks(braces) { + const ret = []; + for (const char of braces.split("")) { + if (CLOSE_BRACES.has(char)) { + continue; + } + const braces2 = BRACES_MAP[char]; + if (braces2 == null) { + throw new Error(`Unknown open/close mark type "${char}"`); + } + ret.push(braces2); + } + return ret; +} +function args(args2, special) { + if (!Array.isArray(args2)) { + args2 = [args2]; + } + if (special == null ? void 0 : special.braces) { + const braces = bracesToOpenAndCloseMarks(special.braces); + if (braces.length !== args2.length) { + throw new Error( + `There is a difference between the number of supplied braces and the number of supplied arguments. ${args2.length} supplied with braces signature ${special.braces}` + ); + } + return args2.map( + (arg2, i) => normalizeArgument(arg2, braces[i].openMark, braces[i].closeMark) + ); + } + const openMark = (special == null ? void 0 : special.defaultOpenMark) ?? "{"; + const closeMark = (special == null ? void 0 : special.defaultCloseMark) ?? "}"; + return normalizeArgumentsList(args2, openMark, closeMark); +} +function arg(args2, special) { + if (args2 == null) { + return { type: "argument", content: [], openMark: "", closeMark: "" }; + } + if (typeof args2 === "string") { + args2 = s(args2); + } + if (!Array.isArray(args2) && args2.type === "argument") { + return args2; + } + let openMark = (special == null ? void 0 : special.openMark) ?? "{"; + let closeMark = (special == null ? void 0 : special.closeMark) ?? "}"; + if (special == null ? void 0 : special.braces) { + const braces = bracesToOpenAndCloseMarks(special.braces); + if (braces[0]) { + openMark = braces[0].openMark; + closeMark = braces[0].closeMark; + } + } + if (!Array.isArray(args2)) { + args2 = [args2]; + } + return { type: "argument", content: args2, openMark, closeMark }; +} +function m(name, marcoArgs, special) { + const args2 = normalizeArgumentsList(marcoArgs); + const escapeToken = special == null ? void 0 : special.escapeToken; + const ret = { type: "macro", content: name }; + if (args2.length > 0) { + ret.args = args2; + } + if (escapeToken != null) { + ret.escapeToken = escapeToken; + } + return ret; +} +function s(value) { + if (typeof value === "string") { + return { type: "string", content: value }; + } + return value; +} +function env(name, body, envArgs, special) { + if (!Array.isArray(body)) { + body = [body]; + } + const args2 = normalizeArgumentsList(envArgs, "[", "]"); + const ret = { + type: "environment", + env: name, + content: body.map(normalizeNode) + }; + if (args2.length > 0) { + ret.args = args2; + } + return ret; +} +const SP = { type: "whitespace" }; +exports.SP = SP; +exports.arg = arg; +exports.args = args; +exports.env = env; +exports.m = m; +exports.s = s; +//# sourceMappingURL=index.cjs.map diff --git a/node_modules/@unified-latex/unified-latex-builder/index.cjs.map b/node_modules/@unified-latex/unified-latex-builder/index.cjs.map new file mode 100644 index 0000000..6cbddc7 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-builder/index.cjs.map @@ -0,0 +1 @@ +{"version":3,"file":"index.cjs","sources":["../libs/builders.ts"],"sourcesContent":["import type * as Ast from \"@unified-latex/unified-latex-types\";\n\ntype CoercibleNode = string | Ast.Node;\ntype CoercibleArgument = null | CoercibleNode | Ast.Argument;\ntype MacroSpecialOptions = {\n escapeToken?: string;\n};\ntype ArgumentsSpecialOptions = {\n braces?: string;\n defaultOpenMark?: string;\n defaultCloseMark?: string;\n};\ntype ArgumentSpecialOptions = {\n braces?: string;\n openMark?: string;\n closeMark?: string;\n};\n\nfunction normalizeNode(node: CoercibleNode): Ast.Node {\n if (typeof node === \"string\") {\n return s(node);\n }\n return node;\n}\n\nfunction normalizeArgument(\n arg: CoercibleArgument,\n openMark = \"{\",\n closeMark = \"}\"\n): Ast.Argument {\n if (arg == null) {\n return { type: \"argument\", content: [], openMark: \"\", closeMark: \"\" };\n }\n if (typeof arg === \"string\") {\n return {\n type: \"argument\",\n openMark,\n closeMark,\n content: [s(arg)],\n };\n }\n if (arg.type === \"argument\") {\n return arg;\n }\n return { type: \"argument\", openMark, closeMark, content: [arg] };\n}\n\nfunction normalizeArgumentsList(\n args?: CoercibleArgument | CoercibleArgument[],\n openMark = \"{\",\n closeMark = \"}\"\n): Ast.Argument[] {\n if (args == null) {\n return [];\n }\n if (Array.isArray(args)) {\n return args.map((arg) => normalizeArgument(arg, openMark, closeMark));\n }\n return [normalizeArgument(args, openMark, closeMark)];\n}\n\ntype BracesPair = { openMark: string; closeMark: string };\nconst BRACES_MAP: Record = {\n \"*\": { openMark: \"\", closeMark: \"\" },\n \"{\": { openMark: \"{\", closeMark: \"}\" },\n \"[\": { openMark: \"[\", closeMark: \"]\" },\n \"(\": { openMark: \"(\", closeMark: \")\" },\n \"<\": { openMark: \"<\", closeMark: \">\" },\n};\nconst CLOSE_BRACES = new Set(\n Object.values(BRACES_MAP)\n .map((x) => x.closeMark)\n .filter((x) => x)\n);\n\n/**\n * Turn a braces signature into an array of braces.\n */\nfunction bracesToOpenAndCloseMarks(braces: string): BracesPair[] {\n const ret: BracesPair[] = [];\n\n for (const char of braces.split(\"\")) {\n if (CLOSE_BRACES.has(char)) {\n continue;\n }\n const braces = BRACES_MAP[char];\n if (braces == null) {\n throw new Error(`Unknown open/close mark type \"${char}\"`);\n }\n braces;\n ret.push(braces);\n }\n\n return ret;\n}\n\n/**\n * Create an Argument list. `special.braces` can optionally specify\n * the signature of the open/close marks that each argument uses. For example\n * ```\n * args([\"a\", \"b\"], { braces: \"[]{}\" });\n * ```\n * will result in arguments `[a]{b}`. Valid braces are `*`, `[`, `{`, `(`, and `<`.\n *\n * `null` may be passed as the value of an empty optional argument. If `null` is passed,\n * the `openBrace` and `closeBrace` of the argument will be set to empty strings and the\n * contents will be set to an empty array. For example,\n * ```\n * args([null, \"b\"], { braces: \"[]{}\" });\n * ```\n * will produce the same structure as if the the first \"optional argument\" were omitted in regular parsing.\n */\nexport function args(\n args: CoercibleArgument | CoercibleArgument[],\n special?: ArgumentsSpecialOptions\n): Ast.Argument[] {\n if (!Array.isArray(args)) {\n args = [args];\n }\n if (special?.braces) {\n const braces = bracesToOpenAndCloseMarks(special.braces);\n if (braces.length !== args.length) {\n throw new Error(\n `There is a difference between the number of supplied braces and the number of supplied arguments. ${args.length} supplied with braces signature ${special.braces}`\n );\n }\n return args.map((arg, i) =>\n normalizeArgument(arg, braces[i].openMark, braces[i].closeMark)\n );\n }\n\n const openMark = special?.defaultOpenMark ?? \"{\";\n const closeMark = special?.defaultCloseMark ?? \"}\";\n return normalizeArgumentsList(args, openMark, closeMark);\n}\n\n/**\n * Create an Argument. `special.braces` can optionally specify\n * the signature of the open/close marks that each argument uses. For example\n * ```\n * arg(\"a\", { braces: \"[]\" });\n * ```\n * will result in arguments `[a]`. Valid braces are `*`, `[`, `{`, `<`, and `(`.\n *\n * `null` may be passed as the value of an empty optional argument. If `null` is passed,\n * the `openBrace` and `closeBrace` of the argument will be set to empty strings and the\n * contents will be set to an empty array. For example,\n * ```\n * args([null, \"b\"], { braces: \"[]{}\" });\n * ```\n * will produce the same structure as if the the first \"optional argument\" were omitted in regular parsing.\n */\nexport function arg(\n args: CoercibleArgument | Ast.Node[],\n special?: ArgumentSpecialOptions\n): Ast.Argument {\n if (args == null) {\n return { type: \"argument\", content: [], openMark: \"\", closeMark: \"\" };\n }\n if (typeof args === \"string\") {\n args = s(args);\n }\n if (!Array.isArray(args) && args.type === \"argument\") {\n return args;\n }\n\n let openMark = special?.openMark ?? \"{\";\n let closeMark = special?.closeMark ?? \"}\";\n if (special?.braces) {\n const braces = bracesToOpenAndCloseMarks(special.braces);\n if (braces[0]) {\n openMark = braces[0].openMark;\n closeMark = braces[0].closeMark;\n }\n }\n\n if (!Array.isArray(args)) {\n args = [args];\n }\n\n return { type: \"argument\", content: args, openMark, closeMark };\n}\n\n/**\n * Create a Macro with the given `name`. The macro\n * may be followed by any number of arguments.\n */\nexport function m(\n name: string,\n marcoArgs?: CoercibleArgument | CoercibleArgument[],\n special?: MacroSpecialOptions\n): Ast.Macro {\n const args = normalizeArgumentsList(marcoArgs);\n const escapeToken = special?.escapeToken;\n const ret: Ast.Macro = { type: \"macro\", content: name };\n\n if (args.length > 0) {\n ret.args = args;\n }\n if (escapeToken != null) {\n ret.escapeToken = escapeToken;\n }\n\n return ret;\n}\n\n/**\n * Create a String node from `value`\n */\nexport function s(value: string | Ast.String): Ast.String {\n if (typeof value === \"string\") {\n return { type: \"string\", content: value };\n }\n return value;\n}\n\n/**\n * Create an Environment node.\n */\nexport function env(\n name: string,\n body: CoercibleNode | CoercibleNode[],\n envArgs?: CoercibleArgument | CoercibleArgument[],\n special?: unknown\n): Ast.Environment {\n if (!Array.isArray(body)) {\n body = [body];\n }\n const args = normalizeArgumentsList(envArgs, \"[\", \"]\");\n const ret: Ast.Environment = {\n type: \"environment\",\n env: name,\n content: body.map(normalizeNode),\n };\n if (args.length > 0) {\n ret.args = args;\n }\n\n return ret;\n}\n\n/**\n * Whitespace node.\n */\nexport const SP: Ast.Whitespace = { type: \"whitespace\" };\n"],"names":["arg","args","braces"],"mappings":"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"} \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-builder/index.d.ts b/node_modules/@unified-latex/unified-latex-builder/index.d.ts new file mode 100644 index 0000000..0efa0e9 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-builder/index.d.ts @@ -0,0 +1,80 @@ +import type * as Ast from '@unified-latex/unified-latex-types'; + +/** + * Create an Argument. `special.braces` can optionally specify + * the signature of the open/close marks that each argument uses. For example + * ``` + * arg("a", { braces: "[]" }); + * ``` + * will result in arguments `[a]`. Valid braces are `*`, `[`, `{`, `<`, and `(`. + * + * `null` may be passed as the value of an empty optional argument. If `null` is passed, + * the `openBrace` and `closeBrace` of the argument will be set to empty strings and the + * contents will be set to an empty array. For example, + * ``` + * args([null, "b"], { braces: "[]{}" }); + * ``` + * will produce the same structure as if the the first "optional argument" were omitted in regular parsing. + */ +export declare function arg(args: CoercibleArgument | Ast.Node[], special?: ArgumentSpecialOptions): Ast.Argument; + +/** + * Create an Argument list. `special.braces` can optionally specify + * the signature of the open/close marks that each argument uses. For example + * ``` + * args(["a", "b"], { braces: "[]{}" }); + * ``` + * will result in arguments `[a]{b}`. Valid braces are `*`, `[`, `{`, `(`, and `<`. + * + * `null` may be passed as the value of an empty optional argument. If `null` is passed, + * the `openBrace` and `closeBrace` of the argument will be set to empty strings and the + * contents will be set to an empty array. For example, + * ``` + * args([null, "b"], { braces: "[]{}" }); + * ``` + * will produce the same structure as if the the first "optional argument" were omitted in regular parsing. + */ +export declare function args(args: CoercibleArgument | CoercibleArgument[], special?: ArgumentsSpecialOptions): Ast.Argument[]; + +declare type ArgumentSpecialOptions = { + braces?: string; + openMark?: string; + closeMark?: string; +}; + +declare type ArgumentsSpecialOptions = { + braces?: string; + defaultOpenMark?: string; + defaultCloseMark?: string; +}; + +declare type CoercibleArgument = null | CoercibleNode | Ast.Argument; + +declare type CoercibleNode = string | Ast.Node; + +/** + * Create an Environment node. + */ +export declare function env(name: string, body: CoercibleNode | CoercibleNode[], envArgs?: CoercibleArgument | CoercibleArgument[], special?: unknown): Ast.Environment; + +/** + * Create a Macro with the given `name`. The macro + * may be followed by any number of arguments. + */ +export declare function m(name: string, marcoArgs?: CoercibleArgument | CoercibleArgument[], special?: MacroSpecialOptions): Ast.Macro; + +declare type MacroSpecialOptions = { + escapeToken?: string; +}; + +/** + * Create a String node from `value` + */ +export declare function s(value: string | Ast.String): Ast.String; + +/** + * Whitespace node. + */ +export declare const SP: Ast.Whitespace; + +export { } diff --git a/node_modules/@unified-latex/unified-latex-builder/index.js b/node_modules/@unified-latex/unified-latex-builder/index.js new file mode 100644 index 0000000..0ef2294 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-builder/index.js @@ -0,0 +1,142 @@ +function normalizeNode(node) { + if (typeof node === "string") { + return s(node); + } + return node; +} +function normalizeArgument(arg2, openMark = "{", closeMark = "}") { + if (arg2 == null) { + return { type: "argument", content: [], openMark: "", closeMark: "" }; + } + if (typeof arg2 === "string") { + return { + type: "argument", + openMark, + closeMark, + content: [s(arg2)] + }; + } + if (arg2.type === "argument") { + return arg2; + } + return { type: "argument", openMark, closeMark, content: [arg2] }; +} +function normalizeArgumentsList(args2, openMark = "{", closeMark = "}") { + if (args2 == null) { + return []; + } + if (Array.isArray(args2)) { + return args2.map((arg2) => normalizeArgument(arg2, openMark, closeMark)); + } + return [normalizeArgument(args2, openMark, closeMark)]; +} +const BRACES_MAP = { + "*": { openMark: "", closeMark: "" }, + "{": { openMark: "{", closeMark: "}" }, + "[": { openMark: "[", closeMark: "]" }, + "(": { openMark: "(", closeMark: ")" }, + "<": { openMark: "<", closeMark: ">" } +}; +const CLOSE_BRACES = new Set( + Object.values(BRACES_MAP).map((x) => x.closeMark).filter((x) => x) +); +function bracesToOpenAndCloseMarks(braces) { + const ret = []; + for (const char of braces.split("")) { + if (CLOSE_BRACES.has(char)) { + continue; + } + const braces2 = BRACES_MAP[char]; + if (braces2 == null) { + throw new Error(`Unknown open/close mark type "${char}"`); + } + ret.push(braces2); + } + return ret; +} +function args(args2, special) { + if (!Array.isArray(args2)) { + args2 = [args2]; + } + if (special == null ? void 0 : special.braces) { + const braces = bracesToOpenAndCloseMarks(special.braces); + if (braces.length !== args2.length) { + throw new Error( + `There is a difference between the number of supplied braces and the number of supplied arguments. ${args2.length} supplied with braces signature ${special.braces}` + ); + } + return args2.map( + (arg2, i) => normalizeArgument(arg2, braces[i].openMark, braces[i].closeMark) + ); + } + const openMark = (special == null ? void 0 : special.defaultOpenMark) ?? "{"; + const closeMark = (special == null ? void 0 : special.defaultCloseMark) ?? "}"; + return normalizeArgumentsList(args2, openMark, closeMark); +} +function arg(args2, special) { + if (args2 == null) { + return { type: "argument", content: [], openMark: "", closeMark: "" }; + } + if (typeof args2 === "string") { + args2 = s(args2); + } + if (!Array.isArray(args2) && args2.type === "argument") { + return args2; + } + let openMark = (special == null ? void 0 : special.openMark) ?? "{"; + let closeMark = (special == null ? void 0 : special.closeMark) ?? "}"; + if (special == null ? void 0 : special.braces) { + const braces = bracesToOpenAndCloseMarks(special.braces); + if (braces[0]) { + openMark = braces[0].openMark; + closeMark = braces[0].closeMark; + } + } + if (!Array.isArray(args2)) { + args2 = [args2]; + } + return { type: "argument", content: args2, openMark, closeMark }; +} +function m(name, marcoArgs, special) { + const args2 = normalizeArgumentsList(marcoArgs); + const escapeToken = special == null ? void 0 : special.escapeToken; + const ret = { type: "macro", content: name }; + if (args2.length > 0) { + ret.args = args2; + } + if (escapeToken != null) { + ret.escapeToken = escapeToken; + } + return ret; +} +function s(value) { + if (typeof value === "string") { + return { type: "string", content: value }; + } + return value; +} +function env(name, body, envArgs, special) { + if (!Array.isArray(body)) { + body = [body]; + } + const args2 = normalizeArgumentsList(envArgs, "[", "]"); + const ret = { + type: "environment", + env: name, + content: body.map(normalizeNode) + }; + if (args2.length > 0) { + ret.args = args2; + } + return ret; +} +const SP = { type: "whitespace" }; +export { + SP, + arg, + args, + env, + m, + s +}; +//# sourceMappingURL=index.js.map diff --git a/node_modules/@unified-latex/unified-latex-builder/index.js.map b/node_modules/@unified-latex/unified-latex-builder/index.js.map new file mode 100644 index 0000000..82a9f10 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-builder/index.js.map @@ -0,0 +1 @@ +{"version":3,"file":"index.js","sources":["../libs/builders.ts"],"sourcesContent":["import type * as Ast from \"@unified-latex/unified-latex-types\";\n\ntype CoercibleNode = string | Ast.Node;\ntype CoercibleArgument = null | CoercibleNode | Ast.Argument;\ntype MacroSpecialOptions = {\n escapeToken?: string;\n};\ntype ArgumentsSpecialOptions = {\n braces?: string;\n defaultOpenMark?: string;\n defaultCloseMark?: string;\n};\ntype ArgumentSpecialOptions = {\n braces?: string;\n openMark?: string;\n closeMark?: string;\n};\n\nfunction normalizeNode(node: CoercibleNode): Ast.Node {\n if (typeof node === \"string\") {\n return s(node);\n }\n return node;\n}\n\nfunction normalizeArgument(\n arg: CoercibleArgument,\n openMark = \"{\",\n closeMark = \"}\"\n): Ast.Argument {\n if (arg == null) {\n return { type: \"argument\", content: [], openMark: \"\", closeMark: \"\" };\n }\n if (typeof arg === \"string\") {\n return {\n type: \"argument\",\n openMark,\n closeMark,\n content: [s(arg)],\n };\n }\n if (arg.type === \"argument\") {\n return arg;\n }\n return { type: \"argument\", openMark, closeMark, content: [arg] };\n}\n\nfunction normalizeArgumentsList(\n args?: CoercibleArgument | CoercibleArgument[],\n openMark = \"{\",\n closeMark = \"}\"\n): Ast.Argument[] {\n if (args == null) {\n return [];\n }\n if (Array.isArray(args)) {\n return args.map((arg) => normalizeArgument(arg, openMark, closeMark));\n }\n return [normalizeArgument(args, openMark, closeMark)];\n}\n\ntype BracesPair = { openMark: string; closeMark: string };\nconst BRACES_MAP: Record = {\n \"*\": { openMark: \"\", closeMark: \"\" },\n \"{\": { openMark: \"{\", closeMark: \"}\" },\n \"[\": { openMark: \"[\", closeMark: \"]\" },\n \"(\": { openMark: \"(\", closeMark: \")\" },\n \"<\": { openMark: \"<\", closeMark: \">\" },\n};\nconst CLOSE_BRACES = new Set(\n Object.values(BRACES_MAP)\n .map((x) => x.closeMark)\n .filter((x) => x)\n);\n\n/**\n * Turn a braces signature into an array of braces.\n */\nfunction bracesToOpenAndCloseMarks(braces: string): BracesPair[] {\n const ret: BracesPair[] = [];\n\n for (const char of braces.split(\"\")) {\n if (CLOSE_BRACES.has(char)) {\n continue;\n }\n const braces = BRACES_MAP[char];\n if (braces == null) {\n throw new Error(`Unknown open/close mark type \"${char}\"`);\n }\n braces;\n ret.push(braces);\n }\n\n return ret;\n}\n\n/**\n * Create an Argument list. `special.braces` can optionally specify\n * the signature of the open/close marks that each argument uses. For example\n * ```\n * args([\"a\", \"b\"], { braces: \"[]{}\" });\n * ```\n * will result in arguments `[a]{b}`. Valid braces are `*`, `[`, `{`, `(`, and `<`.\n *\n * `null` may be passed as the value of an empty optional argument. If `null` is passed,\n * the `openBrace` and `closeBrace` of the argument will be set to empty strings and the\n * contents will be set to an empty array. For example,\n * ```\n * args([null, \"b\"], { braces: \"[]{}\" });\n * ```\n * will produce the same structure as if the the first \"optional argument\" were omitted in regular parsing.\n */\nexport function args(\n args: CoercibleArgument | CoercibleArgument[],\n special?: ArgumentsSpecialOptions\n): Ast.Argument[] {\n if (!Array.isArray(args)) {\n args = [args];\n }\n if (special?.braces) {\n const braces = bracesToOpenAndCloseMarks(special.braces);\n if (braces.length !== args.length) {\n throw new Error(\n `There is a difference between the number of supplied braces and the number of supplied arguments. ${args.length} supplied with braces signature ${special.braces}`\n );\n }\n return args.map((arg, i) =>\n normalizeArgument(arg, braces[i].openMark, braces[i].closeMark)\n );\n }\n\n const openMark = special?.defaultOpenMark ?? \"{\";\n const closeMark = special?.defaultCloseMark ?? \"}\";\n return normalizeArgumentsList(args, openMark, closeMark);\n}\n\n/**\n * Create an Argument. `special.braces` can optionally specify\n * the signature of the open/close marks that each argument uses. For example\n * ```\n * arg(\"a\", { braces: \"[]\" });\n * ```\n * will result in arguments `[a]`. Valid braces are `*`, `[`, `{`, `<`, and `(`.\n *\n * `null` may be passed as the value of an empty optional argument. If `null` is passed,\n * the `openBrace` and `closeBrace` of the argument will be set to empty strings and the\n * contents will be set to an empty array. For example,\n * ```\n * args([null, \"b\"], { braces: \"[]{}\" });\n * ```\n * will produce the same structure as if the the first \"optional argument\" were omitted in regular parsing.\n */\nexport function arg(\n args: CoercibleArgument | Ast.Node[],\n special?: ArgumentSpecialOptions\n): Ast.Argument {\n if (args == null) {\n return { type: \"argument\", content: [], openMark: \"\", closeMark: \"\" };\n }\n if (typeof args === \"string\") {\n args = s(args);\n }\n if (!Array.isArray(args) && args.type === \"argument\") {\n return args;\n }\n\n let openMark = special?.openMark ?? \"{\";\n let closeMark = special?.closeMark ?? \"}\";\n if (special?.braces) {\n const braces = bracesToOpenAndCloseMarks(special.braces);\n if (braces[0]) {\n openMark = braces[0].openMark;\n closeMark = braces[0].closeMark;\n }\n }\n\n if (!Array.isArray(args)) {\n args = [args];\n }\n\n return { type: \"argument\", content: args, openMark, closeMark };\n}\n\n/**\n * Create a Macro with the given `name`. The macro\n * may be followed by any number of arguments.\n */\nexport function m(\n name: string,\n marcoArgs?: CoercibleArgument | CoercibleArgument[],\n special?: MacroSpecialOptions\n): Ast.Macro {\n const args = normalizeArgumentsList(marcoArgs);\n const escapeToken = special?.escapeToken;\n const ret: Ast.Macro = { type: \"macro\", content: name };\n\n if (args.length > 0) {\n ret.args = args;\n }\n if (escapeToken != null) {\n ret.escapeToken = escapeToken;\n }\n\n return ret;\n}\n\n/**\n * Create a String node from `value`\n */\nexport function s(value: string | Ast.String): Ast.String {\n if (typeof value === \"string\") {\n return { type: \"string\", content: value };\n }\n return value;\n}\n\n/**\n * Create an Environment node.\n */\nexport function env(\n name: string,\n body: CoercibleNode | CoercibleNode[],\n envArgs?: CoercibleArgument | CoercibleArgument[],\n special?: unknown\n): Ast.Environment {\n if (!Array.isArray(body)) {\n body = [body];\n }\n const args = normalizeArgumentsList(envArgs, \"[\", \"]\");\n const ret: Ast.Environment = {\n type: \"environment\",\n env: name,\n content: body.map(normalizeNode),\n };\n if (args.length > 0) {\n ret.args = args;\n }\n\n return ret;\n}\n\n/**\n * Whitespace node.\n */\nexport const SP: Ast.Whitespace = { type: \"whitespace\" };\n"],"names":["arg","args","braces"],"mappings":"AAkBA,SAAS,cAAc,MAA+B;AAC9C,MAAA,OAAO,SAAS,UAAU;AAC1B,WAAO,EAAE,IAAI;AAAA,EACjB;AACO,SAAA;AACX;AAEA,SAAS,kBACLA,MACA,WAAW,KACX,YAAY,KACA;AACZ,MAAIA,QAAO,MAAM;AACN,WAAA,EAAE,MAAM,YAAY,SAAS,CAAA,GAAI,UAAU,IAAI,WAAW;EACrE;AACI,MAAA,OAAOA,SAAQ,UAAU;AAClB,WAAA;AAAA,MACH,MAAM;AAAA,MACN;AAAA,MACA;AAAA,MACA,SAAS,CAAC,EAAEA,IAAG,CAAC;AAAA,IAAA;AAAA,EAExB;AACIA,MAAAA,KAAI,SAAS,YAAY;AAClBA,WAAAA;AAAAA,EACX;AACO,SAAA,EAAE,MAAM,YAAY,UAAU,WAAW,SAAS,CAACA,IAAG;AACjE;AAEA,SAAS,uBACLC,OACA,WAAW,KACX,YAAY,KACE;AACd,MAAIA,SAAQ,MAAM;AACd,WAAO;EACX;AACI,MAAA,MAAM,QAAQA,KAAI,GAAG;AACdA,WAAAA,MAAK,IAAI,CAACD,SAAQ,kBAAkBA,MAAK,UAAU,SAAS,CAAC;AAAA,EACxE;AACA,SAAO,CAAC,kBAAkBC,OAAM,UAAU,SAAS,CAAC;AACxD;AAGA,MAAM,aAAyC;AAAA,EAC3C,KAAK,EAAE,UAAU,IAAI,WAAW,GAAG;AAAA,EACnC,KAAK,EAAE,UAAU,KAAK,WAAW,IAAI;AAAA,EACrC,KAAK,EAAE,UAAU,KAAK,WAAW,IAAI;AAAA,EACrC,KAAK,EAAE,UAAU,KAAK,WAAW,IAAI;AAAA,EACrC,KAAK,EAAE,UAAU,KAAK,WAAW,IAAI;AACzC;AACA,MAAM,eAAe,IAAI;AAAA,EACrB,OAAO,OAAO,UAAU,EACnB,IAAI,CAAC,MAAM,EAAE,SAAS,EACtB,OAAO,CAAC,MAAM,CAAC;AACxB;AAKA,SAAS,0BAA0B,QAA8B;AAC7D,QAAM,MAAoB,CAAA;AAE1B,aAAW,QAAQ,OAAO,MAAM,EAAE,GAAG;AAC7B,QAAA,aAAa,IAAI,IAAI,GAAG;AACxB;AAAA,IACJ;AACMC,UAAAA,UAAS,WAAW,IAAI;AAC9B,QAAIA,WAAU,MAAM;AAChB,YAAM,IAAI,MAAM,iCAAiC,IAAI,GAAG;AAAA,IAC5D;AAEA,QAAI,KAAKA,OAAM;AAAA,EACnB;AAEO,SAAA;AACX;AAkBgB,SAAA,KACZD,OACA,SACc;AACd,MAAI,CAAC,MAAM,QAAQA,KAAI,GAAG;AACtBA,YAAO,CAACA,KAAI;AAAA,EAChB;AACA,MAAI,mCAAS,QAAQ;AACX,UAAA,SAAS,0BAA0B,QAAQ,MAAM;AACnD,QAAA,OAAO,WAAWA,MAAK,QAAQ;AAC/B,YAAM,IAAI;AAAA,QACN,qGAAqGA,MAAK,MAAM,mCAAmC,QAAQ,MAAM;AAAA,MAAA;AAAA,IAEzK;AACA,WAAOA,MAAK;AAAA,MAAI,CAACD,MAAK,MAClB,kBAAkBA,MAAK,OAAO,CAAC,EAAE,UAAU,OAAO,CAAC,EAAE,SAAS;AAAA,IAAA;AAAA,EAEtE;AAEM,QAAA,YAAW,mCAAS,oBAAmB;AACvC,QAAA,aAAY,mCAAS,qBAAoB;AACxC,SAAA,uBAAuBC,OAAM,UAAU,SAAS;AAC3D;AAkBgB,SAAA,IACZA,OACA,SACY;AACZ,MAAIA,SAAQ,MAAM;AACP,WAAA,EAAE,MAAM,YAAY,SAAS,CAAA,GAAI,UAAU,IAAI,WAAW;EACrE;AACI,MAAA,OAAOA,UAAS,UAAU;AAC1BA,YAAO,EAAEA,KAAI;AAAA,EACjB;AACA,MAAI,CAAC,MAAM,QAAQA,KAAI,KAAKA,MAAK,SAAS,YAAY;AAC3CA,WAAAA;AAAAA,EACX;AAEI,MAAA,YAAW,mCAAS,aAAY;AAChC,MAAA,aAAY,mCAAS,cAAa;AACtC,MAAI,mCAAS,QAAQ;AACX,UAAA,SAAS,0BAA0B,QAAQ,MAAM;AACnD,QAAA,OAAO,CAAC,GAAG;AACA,iBAAA,OAAO,CAAC,EAAE;AACT,kBAAA,OAAO,CAAC,EAAE;AAAA,IAC1B;AAAA,EACJ;AAEA,MAAI,CAAC,MAAM,QAAQA,KAAI,GAAG;AACtBA,YAAO,CAACA,KAAI;AAAA,EAChB;AAEA,SAAO,EAAE,MAAM,YAAY,SAASA,OAAM,UAAU;AACxD;AAMgB,SAAA,EACZ,MACA,WACA,SACS;AACHA,QAAAA,QAAO,uBAAuB,SAAS;AAC7C,QAAM,cAAc,mCAAS;AAC7B,QAAM,MAAiB,EAAE,MAAM,SAAS,SAAS,KAAK;AAElDA,MAAAA,MAAK,SAAS,GAAG;AACjB,QAAI,OAAOA;AAAAA,EACf;AACA,MAAI,eAAe,MAAM;AACrB,QAAI,cAAc;AAAA,EACtB;AAEO,SAAA;AACX;AAKO,SAAS,EAAE,OAAwC;AAClD,MAAA,OAAO,UAAU,UAAU;AAC3B,WAAO,EAAE,MAAM,UAAU,SAAS,MAAM;AAAA,EAC5C;AACO,SAAA;AACX;AAKO,SAAS,IACZ,MACA,MACA,SACA,SACe;AACf,MAAI,CAAC,MAAM,QAAQ,IAAI,GAAG;AACtB,WAAO,CAAC,IAAI;AAAA,EAChB;AACA,QAAMA,QAAO,uBAAuB,SAAS,KAAK,GAAG;AACrD,QAAM,MAAuB;AAAA,IACzB,MAAM;AAAA,IACN,KAAK;AAAA,IACL,SAAS,KAAK,IAAI,aAAa;AAAA,EAAA;AAE/BA,MAAAA,MAAK,SAAS,GAAG;AACjB,QAAI,OAAOA;AAAAA,EACf;AAEO,SAAA;AACX;AAKa,MAAA,KAAqB,EAAE,MAAM,aAAa;"} \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-builder/package.json b/node_modules/@unified-latex/unified-latex-builder/package.json new file mode 100644 index 0000000..e6a2471 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-builder/package.json @@ -0,0 +1,51 @@ +{ + "name": "@unified-latex/unified-latex-builder", + "version": "1.8.0", + "description": "Tools for constructing unified-latex ASTs", + "main": "index.js", + "type": "module", + "dependencies": { + "@unified-latex/unified-latex-types": "^1.8.0" + }, + "repository": { + "type": "git", + "url": "git+https://github.com/siefkenj/unified-latex.git" + }, + "keywords": [ + "pegjs", + "latex", + "parser", + "prettier", + "unified-latex", + "unified" + ], + "author": "Jason Siefken", + "license": "MIT", + "bugs": { + "url": "https://github.com/siefkenj/unified-latex/issues" + }, + "homepage": "https://github.com/siefkenj/unified-latex#readme", + "exports": { + ".": { + "import": "./index.js", + "require": "./index.cjs", + "types": "./index.d.ts" + }, + "./*js": "./*js", + "./*": { + "import": "./*/index.js", + "require": "./*/index.cjs", + "types": "./*/index.d.ts" + }, + "./*/index": { + "import": "./*/index.js", + "require": "./*/index.cjs" + } + }, + "files": [ + "**/*ts", + "**/*js", + "**/*.map", + "**/*.json" + ] +} \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-ctan/README.md b/node_modules/@unified-latex/unified-latex-ctan/README.md new file mode 100644 index 0000000..52734d5 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-ctan/README.md @@ -0,0 +1,46 @@ + + + + +# unified-latex-ctan + +## What is this? + +Macro/environment definitions and utilities for specific LaTeX packages from CTAN. + +Note: basic LaTeX macro/environment definitions come from the `latex2e` package, even though +this is technically not a CTAN "package". + +## When should I use this? + +If you want information about special functions/macros from particular CTAN packages, or +you need to parse special environments. + +## Notes + +By default all macros/environments that are exported get processed. If multiple packages +export a macro with the same name, then the later-exported one takes precedence. If two packages +export a macro/environment of the same name but with conflicting argument signatures, this can +cause issues when another unified-latex package processes arguments positionally. For example, +by default `\textbf` takes one argument, but the beamer version of `\textbf` takes two arguments. +During HTML conversion, if arguments are referenced positionally, this may cause previously-working +code to fail with when beamer macro signatures are used. A workaround is provided: `_renderInfo.namedArguments`. +If `_renderInfo.namedArguments` is specified on both the original macro/environment definition +**and** the conflicting one, other unified-latex commands can reference arguments by name instead +of by position. + +## Install + +```bash +npm install @unified-latex/unified-latex-ctan +``` + +This package contains both esm and commonjs exports. To explicitly access the esm export, +import the `.js` file. To explicitly access the commonjs export, import the `.cjs` file. + +# Constants + +| Name | Type | Description | +| :---------------- | :--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :------------------------------------------------------------------------------------------------------------------- | +| `environmentInfo` | `{ amsart: EnvInfoRecord; cleveref: EnvInfoRecord; exam: EnvInfoRecord; geometry: EnvInfoRecord; hyperref: EnvInfoRecord; ... 11 more ...; multicol: EnvInfoRecord; }` | Info about the environments for available ctan packages. `latex2e` contains the standard environments for LaTeX. | +| `macroInfo` | `{ amsart: MacroInfoRecord; cleveref: MacroInfoRecord; exam: MacroInfoRecord; geometry: MacroInfoRecord; hyperref: MacroInfoRecord; ... 11 more ...; multicol: MacroInfoRecord; }` | Info about the macros for available ctan packages. `latex2e` contains the standard macros for LaTeX. | diff --git a/node_modules/@unified-latex/unified-latex-ctan/enumerate-DSh8p1uS.cjs b/node_modules/@unified-latex/unified-latex-ctan/enumerate-DSh8p1uS.cjs new file mode 100644 index 0000000..1bec2ca --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-ctan/enumerate-DSh8p1uS.cjs @@ -0,0 +1,68 @@ +"use strict"; +const unifiedLatexBuilder = require("@unified-latex/unified-latex-builder"); +const unifiedLatexUtilMatch = require("@unified-latex/unified-latex-util-match"); +const unifiedLatexUtilRenderInfo = require("@unified-latex/unified-latex-util-render-info"); +const unifiedLatexUtilReplace = require("@unified-latex/unified-latex-util-replace"); +const unifiedLatexUtilSplit = require("@unified-latex/unified-latex-util-split"); +const unifiedLatexUtilTrim = require("@unified-latex/unified-latex-util-trim"); +function cleanEnumerateBody(ast, itemName = "item") { + let { segments, macros } = unifiedLatexUtilSplit.splitOnMacro(ast, itemName); + for (let i = 0; i < segments.length; i++) { + const segment = segments[i]; + if (i === 0) { + unifiedLatexUtilTrim.trimEnd(segment); + } else { + unifiedLatexUtilTrim.trim(segment); + } + if (segment.length > 0 && i > 0) { + segment.unshift({ type: "whitespace" }); + } + } + let insertParbreakBefore = /* @__PURE__ */ new WeakSet(); + let body = macros.flatMap((node, i) => { + var _a; + const segment = segments[i + 1]; + const trailingComments = popTrailingComments(segment); + node.args = node.args || []; + node.args.push(unifiedLatexBuilder.arg(segment, { openMark: "", closeMark: "" })); + unifiedLatexUtilRenderInfo.updateRenderInfo(node, { inParMode: true }); + if (i > 0 || ((_a = segments[0]) == null ? void 0 : _a.length) > 0) { + insertParbreakBefore.add(node); + } + return [node, ...trailingComments]; + }); + body = body.flatMap( + (node) => insertParbreakBefore.has(node) ? [{ type: "parbreak" }, node] : node + ); + body.unshift(...segments[0]); + for (let i = 0; i < body.length - 1; i++) { + const node = body[i]; + const nextNode = body[i + 1]; + if (!unifiedLatexUtilMatch.match.parbreak(nextNode)) { + continue; + } + if (unifiedLatexUtilMatch.match.comment(node)) { + node.suffixParbreak = true; + } + if (unifiedLatexUtilMatch.match.macro(node) && node.args && node.args[node.args.length - 1].closeMark === "") { + const args = node.args[node.args.length - 1].content; + const lastArg = args[args.length - 1]; + if (unifiedLatexUtilMatch.match.comment(lastArg)) { + lastArg.suffixParbreak = true; + } + } + } + return body; +} +function popTrailingComments(nodes) { + let lastNodeIndex = unifiedLatexUtilReplace.lastSignificantNodeIndex(nodes, true); + if (lastNodeIndex === nodes.length - 1 || lastNodeIndex == null && nodes.length === 0) { + return []; + } + if (lastNodeIndex == null) { + lastNodeIndex = -1; + } + return nodes.splice(lastNodeIndex + 1); +} +exports.cleanEnumerateBody = cleanEnumerateBody; +//# sourceMappingURL=enumerate-DSh8p1uS.cjs.map diff --git a/node_modules/@unified-latex/unified-latex-ctan/enumerate-DSh8p1uS.cjs.map b/node_modules/@unified-latex/unified-latex-ctan/enumerate-DSh8p1uS.cjs.map new file mode 100644 index 0000000..135f037 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-ctan/enumerate-DSh8p1uS.cjs.map @@ -0,0 +1 @@ +{"version":3,"file":"enumerate-DSh8p1uS.cjs","sources":["../utils/enumerate.ts"],"sourcesContent":["import { arg } from \"@unified-latex/unified-latex-builder\";\nimport * as Ast from \"@unified-latex/unified-latex-types\";\nimport { match } from \"@unified-latex/unified-latex-util-match\";\nimport { printRaw } from \"@unified-latex/unified-latex-util-print-raw\";\nimport { updateRenderInfo } from \"@unified-latex/unified-latex-util-render-info\";\nimport {\n lastSignificantNode,\n lastSignificantNodeIndex,\n} from \"@unified-latex/unified-latex-util-replace\";\nimport { splitOnMacro } from \"@unified-latex/unified-latex-util-split\";\nimport { trim, trimEnd } from \"@unified-latex/unified-latex-util-trim\";\n\n/**\n * Clean up any whitespace issues in an enumerate environment. In particular,\n * * Remove any leading or ending whitespace\n * * Ensure there is a par between occurrences of `\\item`\n * * Ensure there is whitespace after each occurrence of `\\item` provided there is content there\n * `itemName` can be used to set what the \"item\" macro is called.\n *\n * This function attaches content following a `\\item` to the `\\item` macro with\n * `openMark` and `closeMark` set to empty. This allows hanging-indents to be rendered.\n */\nexport function cleanEnumerateBody(\n ast: Ast.Node[],\n itemName = \"item\"\n): Ast.Node[] {\n let { segments, macros } = splitOnMacro(ast, itemName);\n // Trim the content of each block, but make sure there is a space\n // between each macro and the content. Since the first segment of content\n // appears *before* any macro, don't add a space there.\n for (let i = 0; i < segments.length; i++) {\n const segment = segments[i];\n if (i === 0) {\n // The very first segment might be comment with leading whitespace. We don't want to trim that off\n trimEnd(segment);\n } else {\n trim(segment);\n }\n // The very first segment comes before any `\\item` macros. It is either\n // blank or contains comments (or is invalid LaTeX). We don't insert a space\n // in this case.\n if (segment.length > 0 && i > 0) {\n segment.unshift({ type: \"whitespace\" });\n }\n }\n\n let insertParbreakBefore: WeakSet = new WeakSet();\n\n // We want a trailing indent for the `\\item` nodes. We will\n // do this with a trick: we will add an argument to the index node\n // with openMark=\" \" and closeMark=\"\"\n let body: Ast.Node[] = macros.flatMap((node, i) => {\n const segment = segments[i + 1];\n const trailingComments = popTrailingComments(segment);\n node.args = node.args || [];\n node.args.push(arg(segment, { openMark: \"\", closeMark: \"\" }));\n updateRenderInfo(node, { inParMode: true });\n\n // The stream contains a mix of `\\item` macros and comments/parbreaks. We only\n // want to insert parbreaks before `\\item` macros, so we record these for later.\n if (i > 0 || segments[0]?.length > 0) {\n insertParbreakBefore.add(node);\n }\n\n return [node, ...trailingComments];\n });\n\n // We want a parbreak between each `\\item` block and the preceding content.\n // We've already logged the `\\item` macros in `insertParbreakBefore`.\n body = body.flatMap((node) =>\n insertParbreakBefore.has(node) ? [{ type: \"parbreak\" }, node] : node\n );\n\n body.unshift(...segments[0]);\n\n // We have inserted parbreaks so some comments need to be told that there is a suffix parbreak\n for (let i = 0; i < body.length - 1; i++) {\n const node = body[i];\n const nextNode = body[i + 1];\n if (!match.parbreak(nextNode)) {\n continue;\n }\n if (match.comment(node)) {\n node.suffixParbreak = true;\n }\n // The heuristic for detecting an `item`-like node is that its last argument has no close mark.\n // Regardless of what it is, if there is no close mark, when rendered we don't want two newlines to\n // appear.\n if (\n match.macro(node) &&\n node.args &&\n node.args[node.args.length - 1].closeMark === \"\"\n ) {\n const args = node.args[node.args.length - 1].content;\n const lastArg = args[args.length - 1];\n if (match.comment(lastArg)) {\n lastArg.suffixParbreak = true;\n }\n }\n }\n\n return body;\n}\n\n/**\n * Removes and returns any number of trailing comments/parbreaks from `nodes`.\n */\nfunction popTrailingComments(nodes: Ast.Node[]): Ast.Node[] {\n let lastNodeIndex = lastSignificantNodeIndex(nodes, true);\n if (\n lastNodeIndex === nodes.length - 1 ||\n (lastNodeIndex == null && nodes.length === 0)\n ) {\n return [];\n }\n\n // If `nodes` has a non-zero length and we didn't find a significant node, everything is comments!\n if (lastNodeIndex == null) {\n lastNodeIndex = -1;\n }\n return nodes.splice(lastNodeIndex + 1);\n}\n"],"names":["splitOnMacro","trimEnd","trim","arg","updateRenderInfo","match","lastSignificantNodeIndex"],"mappings":";;;;;;;AAsBgB,SAAA,mBACZ,KACA,WAAW,QACD;AACV,MAAI,EAAE,UAAU,OAAA,IAAWA,sBAAAA,aAAa,KAAK,QAAQ;AAIrD,WAAS,IAAI,GAAG,IAAI,SAAS,QAAQ,KAAK;AAChC,UAAA,UAAU,SAAS,CAAC;AAC1B,QAAI,MAAM,GAAG;AAETC,2BAAAA,QAAQ,OAAO;AAAA,IAAA,OACZ;AACHC,2BAAAA,KAAK,OAAO;AAAA,IAAA;AAKhB,QAAI,QAAQ,SAAS,KAAK,IAAI,GAAG;AAC7B,cAAQ,QAAQ,EAAE,MAAM,aAAA,CAAc;AAAA,IAAA;AAAA,EAC1C;AAGA,MAAA,2CAA8C,QAAQ;AAK1D,MAAI,OAAmB,OAAO,QAAQ,CAAC,MAAM,MAAM;;AACzC,UAAA,UAAU,SAAS,IAAI,CAAC;AACxB,UAAA,mBAAmB,oBAAoB,OAAO;AAC/C,SAAA,OAAO,KAAK,QAAQ,CAAC;AACrB,SAAA,KAAK,KAAKC,oBAAAA,IAAI,SAAS,EAAE,UAAU,IAAI,WAAW,GAAG,CAAC,CAAC;AAC5DC,+BAAAA,iBAAiB,MAAM,EAAE,WAAW,KAAA,CAAM;AAI1C,QAAI,IAAI,OAAK,cAAS,CAAC,MAAV,mBAAa,UAAS,GAAG;AAClC,2BAAqB,IAAI,IAAI;AAAA,IAAA;AAG1B,WAAA,CAAC,MAAM,GAAG,gBAAgB;AAAA,EAAA,CACpC;AAID,SAAO,KAAK;AAAA,IAAQ,CAAC,SACjB,qBAAqB,IAAI,IAAI,IAAI,CAAC,EAAE,MAAM,cAAc,IAAI,IAAI;AAAA,EACpE;AAEA,OAAK,QAAQ,GAAG,SAAS,CAAC,CAAC;AAG3B,WAAS,IAAI,GAAG,IAAI,KAAK,SAAS,GAAG,KAAK;AAChC,UAAA,OAAO,KAAK,CAAC;AACb,UAAA,WAAW,KAAK,IAAI,CAAC;AAC3B,QAAI,CAACC,sBAAA,MAAM,SAAS,QAAQ,GAAG;AAC3B;AAAA,IAAA;AAEA,QAAAA,sBAAA,MAAM,QAAQ,IAAI,GAAG;AACrB,WAAK,iBAAiB;AAAA,IAAA;AAK1B,QACIA,sBAAAA,MAAM,MAAM,IAAI,KAChB,KAAK,QACL,KAAK,KAAK,KAAK,KAAK,SAAS,CAAC,EAAE,cAAc,IAChD;AACE,YAAM,OAAO,KAAK,KAAK,KAAK,KAAK,SAAS,CAAC,EAAE;AAC7C,YAAM,UAAU,KAAK,KAAK,SAAS,CAAC;AAChC,UAAAA,sBAAA,MAAM,QAAQ,OAAO,GAAG;AACxB,gBAAQ,iBAAiB;AAAA,MAAA;AAAA,IAC7B;AAAA,EACJ;AAGG,SAAA;AACX;AAKA,SAAS,oBAAoB,OAA+B;AACpD,MAAA,gBAAgBC,wBAAAA,yBAAyB,OAAO,IAAI;AAEpD,MAAA,kBAAkB,MAAM,SAAS,KAChC,iBAAiB,QAAQ,MAAM,WAAW,GAC7C;AACE,WAAO,CAAC;AAAA,EAAA;AAIZ,MAAI,iBAAiB,MAAM;AACP,oBAAA;AAAA,EAAA;AAEb,SAAA,MAAM,OAAO,gBAAgB,CAAC;AACzC;;"} \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-ctan/enumerate-wQeKG6-C.js b/node_modules/@unified-latex/unified-latex-ctan/enumerate-wQeKG6-C.js new file mode 100644 index 0000000..ec2c0c6 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-ctan/enumerate-wQeKG6-C.js @@ -0,0 +1,69 @@ +import { arg } from "@unified-latex/unified-latex-builder"; +import { match } from "@unified-latex/unified-latex-util-match"; +import { updateRenderInfo } from "@unified-latex/unified-latex-util-render-info"; +import { lastSignificantNodeIndex } from "@unified-latex/unified-latex-util-replace"; +import { splitOnMacro } from "@unified-latex/unified-latex-util-split"; +import { trimEnd, trim } from "@unified-latex/unified-latex-util-trim"; +function cleanEnumerateBody(ast, itemName = "item") { + let { segments, macros } = splitOnMacro(ast, itemName); + for (let i = 0; i < segments.length; i++) { + const segment = segments[i]; + if (i === 0) { + trimEnd(segment); + } else { + trim(segment); + } + if (segment.length > 0 && i > 0) { + segment.unshift({ type: "whitespace" }); + } + } + let insertParbreakBefore = /* @__PURE__ */ new WeakSet(); + let body = macros.flatMap((node, i) => { + var _a; + const segment = segments[i + 1]; + const trailingComments = popTrailingComments(segment); + node.args = node.args || []; + node.args.push(arg(segment, { openMark: "", closeMark: "" })); + updateRenderInfo(node, { inParMode: true }); + if (i > 0 || ((_a = segments[0]) == null ? void 0 : _a.length) > 0) { + insertParbreakBefore.add(node); + } + return [node, ...trailingComments]; + }); + body = body.flatMap( + (node) => insertParbreakBefore.has(node) ? [{ type: "parbreak" }, node] : node + ); + body.unshift(...segments[0]); + for (let i = 0; i < body.length - 1; i++) { + const node = body[i]; + const nextNode = body[i + 1]; + if (!match.parbreak(nextNode)) { + continue; + } + if (match.comment(node)) { + node.suffixParbreak = true; + } + if (match.macro(node) && node.args && node.args[node.args.length - 1].closeMark === "") { + const args = node.args[node.args.length - 1].content; + const lastArg = args[args.length - 1]; + if (match.comment(lastArg)) { + lastArg.suffixParbreak = true; + } + } + } + return body; +} +function popTrailingComments(nodes) { + let lastNodeIndex = lastSignificantNodeIndex(nodes, true); + if (lastNodeIndex === nodes.length - 1 || lastNodeIndex == null && nodes.length === 0) { + return []; + } + if (lastNodeIndex == null) { + lastNodeIndex = -1; + } + return nodes.splice(lastNodeIndex + 1); +} +export { + cleanEnumerateBody as c +}; +//# sourceMappingURL=enumerate-wQeKG6-C.js.map diff --git a/node_modules/@unified-latex/unified-latex-ctan/enumerate-wQeKG6-C.js.map b/node_modules/@unified-latex/unified-latex-ctan/enumerate-wQeKG6-C.js.map new file mode 100644 index 0000000..33b778f --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-ctan/enumerate-wQeKG6-C.js.map @@ -0,0 +1 @@ +{"version":3,"file":"enumerate-wQeKG6-C.js","sources":["../utils/enumerate.ts"],"sourcesContent":["import { arg } from \"@unified-latex/unified-latex-builder\";\nimport * as Ast from \"@unified-latex/unified-latex-types\";\nimport { match } from \"@unified-latex/unified-latex-util-match\";\nimport { printRaw } from \"@unified-latex/unified-latex-util-print-raw\";\nimport { updateRenderInfo } from \"@unified-latex/unified-latex-util-render-info\";\nimport {\n lastSignificantNode,\n lastSignificantNodeIndex,\n} from \"@unified-latex/unified-latex-util-replace\";\nimport { splitOnMacro } from \"@unified-latex/unified-latex-util-split\";\nimport { trim, trimEnd } from \"@unified-latex/unified-latex-util-trim\";\n\n/**\n * Clean up any whitespace issues in an enumerate environment. In particular,\n * * Remove any leading or ending whitespace\n * * Ensure there is a par between occurrences of `\\item`\n * * Ensure there is whitespace after each occurrence of `\\item` provided there is content there\n * `itemName` can be used to set what the \"item\" macro is called.\n *\n * This function attaches content following a `\\item` to the `\\item` macro with\n * `openMark` and `closeMark` set to empty. This allows hanging-indents to be rendered.\n */\nexport function cleanEnumerateBody(\n ast: Ast.Node[],\n itemName = \"item\"\n): Ast.Node[] {\n let { segments, macros } = splitOnMacro(ast, itemName);\n // Trim the content of each block, but make sure there is a space\n // between each macro and the content. Since the first segment of content\n // appears *before* any macro, don't add a space there.\n for (let i = 0; i < segments.length; i++) {\n const segment = segments[i];\n if (i === 0) {\n // The very first segment might be comment with leading whitespace. We don't want to trim that off\n trimEnd(segment);\n } else {\n trim(segment);\n }\n // The very first segment comes before any `\\item` macros. It is either\n // blank or contains comments (or is invalid LaTeX). We don't insert a space\n // in this case.\n if (segment.length > 0 && i > 0) {\n segment.unshift({ type: \"whitespace\" });\n }\n }\n\n let insertParbreakBefore: WeakSet = new WeakSet();\n\n // We want a trailing indent for the `\\item` nodes. We will\n // do this with a trick: we will add an argument to the index node\n // with openMark=\" \" and closeMark=\"\"\n let body: Ast.Node[] = macros.flatMap((node, i) => {\n const segment = segments[i + 1];\n const trailingComments = popTrailingComments(segment);\n node.args = node.args || [];\n node.args.push(arg(segment, { openMark: \"\", closeMark: \"\" }));\n updateRenderInfo(node, { inParMode: true });\n\n // The stream contains a mix of `\\item` macros and comments/parbreaks. We only\n // want to insert parbreaks before `\\item` macros, so we record these for later.\n if (i > 0 || segments[0]?.length > 0) {\n insertParbreakBefore.add(node);\n }\n\n return [node, ...trailingComments];\n });\n\n // We want a parbreak between each `\\item` block and the preceding content.\n // We've already logged the `\\item` macros in `insertParbreakBefore`.\n body = body.flatMap((node) =>\n insertParbreakBefore.has(node) ? [{ type: \"parbreak\" }, node] : node\n );\n\n body.unshift(...segments[0]);\n\n // We have inserted parbreaks so some comments need to be told that there is a suffix parbreak\n for (let i = 0; i < body.length - 1; i++) {\n const node = body[i];\n const nextNode = body[i + 1];\n if (!match.parbreak(nextNode)) {\n continue;\n }\n if (match.comment(node)) {\n node.suffixParbreak = true;\n }\n // The heuristic for detecting an `item`-like node is that its last argument has no close mark.\n // Regardless of what it is, if there is no close mark, when rendered we don't want two newlines to\n // appear.\n if (\n match.macro(node) &&\n node.args &&\n node.args[node.args.length - 1].closeMark === \"\"\n ) {\n const args = node.args[node.args.length - 1].content;\n const lastArg = args[args.length - 1];\n if (match.comment(lastArg)) {\n lastArg.suffixParbreak = true;\n }\n }\n }\n\n return body;\n}\n\n/**\n * Removes and returns any number of trailing comments/parbreaks from `nodes`.\n */\nfunction popTrailingComments(nodes: Ast.Node[]): Ast.Node[] {\n let lastNodeIndex = lastSignificantNodeIndex(nodes, true);\n if (\n lastNodeIndex === nodes.length - 1 ||\n (lastNodeIndex == null && nodes.length === 0)\n ) {\n return [];\n }\n\n // If `nodes` has a non-zero length and we didn't find a significant node, everything is comments!\n if (lastNodeIndex == null) {\n lastNodeIndex = -1;\n }\n return nodes.splice(lastNodeIndex + 1);\n}\n"],"names":[],"mappings":";;;;;;AAsBgB,SAAA,mBACZ,KACA,WAAW,QACD;AACV,MAAI,EAAE,UAAU,OAAA,IAAW,aAAa,KAAK,QAAQ;AAIrD,WAAS,IAAI,GAAG,IAAI,SAAS,QAAQ,KAAK;AAChC,UAAA,UAAU,SAAS,CAAC;AAC1B,QAAI,MAAM,GAAG;AAET,cAAQ,OAAO;AAAA,IAAA,OACZ;AACH,WAAK,OAAO;AAAA,IAAA;AAKhB,QAAI,QAAQ,SAAS,KAAK,IAAI,GAAG;AAC7B,cAAQ,QAAQ,EAAE,MAAM,aAAA,CAAc;AAAA,IAAA;AAAA,EAC1C;AAGA,MAAA,2CAA8C,QAAQ;AAK1D,MAAI,OAAmB,OAAO,QAAQ,CAAC,MAAM,MAAM;;AACzC,UAAA,UAAU,SAAS,IAAI,CAAC;AACxB,UAAA,mBAAmB,oBAAoB,OAAO;AAC/C,SAAA,OAAO,KAAK,QAAQ,CAAC;AACrB,SAAA,KAAK,KAAK,IAAI,SAAS,EAAE,UAAU,IAAI,WAAW,GAAG,CAAC,CAAC;AAC5D,qBAAiB,MAAM,EAAE,WAAW,KAAA,CAAM;AAI1C,QAAI,IAAI,OAAK,cAAS,CAAC,MAAV,mBAAa,UAAS,GAAG;AAClC,2BAAqB,IAAI,IAAI;AAAA,IAAA;AAG1B,WAAA,CAAC,MAAM,GAAG,gBAAgB;AAAA,EAAA,CACpC;AAID,SAAO,KAAK;AAAA,IAAQ,CAAC,SACjB,qBAAqB,IAAI,IAAI,IAAI,CAAC,EAAE,MAAM,cAAc,IAAI,IAAI;AAAA,EACpE;AAEA,OAAK,QAAQ,GAAG,SAAS,CAAC,CAAC;AAG3B,WAAS,IAAI,GAAG,IAAI,KAAK,SAAS,GAAG,KAAK;AAChC,UAAA,OAAO,KAAK,CAAC;AACb,UAAA,WAAW,KAAK,IAAI,CAAC;AAC3B,QAAI,CAAC,MAAM,SAAS,QAAQ,GAAG;AAC3B;AAAA,IAAA;AAEA,QAAA,MAAM,QAAQ,IAAI,GAAG;AACrB,WAAK,iBAAiB;AAAA,IAAA;AAK1B,QACI,MAAM,MAAM,IAAI,KAChB,KAAK,QACL,KAAK,KAAK,KAAK,KAAK,SAAS,CAAC,EAAE,cAAc,IAChD;AACE,YAAM,OAAO,KAAK,KAAK,KAAK,KAAK,SAAS,CAAC,EAAE;AAC7C,YAAM,UAAU,KAAK,KAAK,SAAS,CAAC;AAChC,UAAA,MAAM,QAAQ,OAAO,GAAG;AACxB,gBAAQ,iBAAiB;AAAA,MAAA;AAAA,IAC7B;AAAA,EACJ;AAGG,SAAA;AACX;AAKA,SAAS,oBAAoB,OAA+B;AACpD,MAAA,gBAAgB,yBAAyB,OAAO,IAAI;AAEpD,MAAA,kBAAkB,MAAM,SAAS,KAChC,iBAAiB,QAAQ,MAAM,WAAW,GAC7C;AACE,WAAO,CAAC;AAAA,EAAA;AAIZ,MAAI,iBAAiB,MAAM;AACP,oBAAA;AAAA,EAAA;AAEb,SAAA,MAAM,OAAO,gBAAgB,CAAC;AACzC;"} \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-ctan/index-BuqJUpao.cjs b/node_modules/@unified-latex/unified-latex-ctan/index-BuqJUpao.cjs new file mode 100644 index 0000000..b0281e2 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-ctan/index-BuqJUpao.cjs @@ -0,0 +1,21 @@ +"use strict"; +(function() { + if (typeof globalThis === "object") { + return; + } + Object.defineProperty(Object.prototype, "__magic__", { + get: function() { + return this; + }, + configurable: true + // This makes it possible to `delete` the getter later. + }); + __magic__.globalThis = __magic__; + delete Object.prototype.__magic__; +})(); +const clone = typeof globalThis.structuredClone === "function" ? globalThis.structuredClone : (obj) => JSON.parse(JSON.stringify(obj)); +function structuredClone(obj) { + return clone(obj); +} +exports.structuredClone = structuredClone; +//# sourceMappingURL=index-BuqJUpao.cjs.map diff --git a/node_modules/@unified-latex/unified-latex-ctan/index-BuqJUpao.cjs.map b/node_modules/@unified-latex/unified-latex-ctan/index-BuqJUpao.cjs.map new file mode 100644 index 0000000..05372c1 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-ctan/index-BuqJUpao.cjs.map @@ -0,0 +1 @@ +{"version":3,"file":"index-BuqJUpao.cjs","sources":["../../structured-clone/index.ts"],"sourcesContent":["// globalThis polyfill from https://mathiasbynens.be/notes/globalthis\n(function () {\n if (typeof globalThis === \"object\") {\n return;\n }\n Object.defineProperty(Object.prototype, \"__magic__\", {\n get: function () {\n return this;\n },\n configurable: true, // This makes it possible to `delete` the getter later.\n });\n __magic__.globalThis = __magic__; // lolwat\n delete Object.prototype.__magic__;\n})();\n\nconst clone =\n typeof globalThis.structuredClone === \"function\"\n ? globalThis.structuredClone\n : (obj: any) => JSON.parse(JSON.stringify(obj));\n\n/**\n * Wrapper around the built-in structured clone. Uses `JSON.parse(JSON.stringify(...))`\n * as a fallback.\n */\nexport function structuredClone(obj: T): T {\n return clone(obj);\n}\n\ndeclare global {\n const __magic__: any;\n interface Object {\n __magic__?: any;\n }\n}\n"],"names":[],"mappings":";CACC,WAAY;AACL,MAAA,OAAO,eAAe,UAAU;AAChC;AAAA,EAAA;AAEG,SAAA,eAAe,OAAO,WAAW,aAAa;AAAA,IACjD,KAAK,WAAY;AACN,aAAA;AAAA,IACX;AAAA,IACA,cAAc;AAAA;AAAA,EAAA,CACjB;AACD,YAAU,aAAa;AACvB,SAAO,OAAO,UAAU;AAC5B,GAAG;AAEH,MAAM,QACF,OAAO,WAAW,oBAAoB,aAChC,WAAW,kBACX,CAAC,QAAa,KAAK,MAAM,KAAK,UAAU,GAAG,CAAC;AAM/C,SAAS,gBAAmB,KAAW;AAC1C,SAAO,MAAM,GAAG;AACpB;;"} \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-ctan/index-NHd3tQDq.js b/node_modules/@unified-latex/unified-latex-ctan/index-NHd3tQDq.js new file mode 100644 index 0000000..2073ad8 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-ctan/index-NHd3tQDq.js @@ -0,0 +1,22 @@ +(function() { + if (typeof globalThis === "object") { + return; + } + Object.defineProperty(Object.prototype, "__magic__", { + get: function() { + return this; + }, + configurable: true + // This makes it possible to `delete` the getter later. + }); + __magic__.globalThis = __magic__; + delete Object.prototype.__magic__; +})(); +const clone = typeof globalThis.structuredClone === "function" ? globalThis.structuredClone : (obj) => JSON.parse(JSON.stringify(obj)); +function structuredClone(obj) { + return clone(obj); +} +export { + structuredClone as s +}; +//# sourceMappingURL=index-NHd3tQDq.js.map diff --git a/node_modules/@unified-latex/unified-latex-ctan/index-NHd3tQDq.js.map b/node_modules/@unified-latex/unified-latex-ctan/index-NHd3tQDq.js.map new file mode 100644 index 0000000..7e666a2 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-ctan/index-NHd3tQDq.js.map @@ -0,0 +1 @@ +{"version":3,"file":"index-NHd3tQDq.js","sources":["../../structured-clone/index.ts"],"sourcesContent":["// globalThis polyfill from https://mathiasbynens.be/notes/globalthis\n(function () {\n if (typeof globalThis === \"object\") {\n return;\n }\n Object.defineProperty(Object.prototype, \"__magic__\", {\n get: function () {\n return this;\n },\n configurable: true, // This makes it possible to `delete` the getter later.\n });\n __magic__.globalThis = __magic__; // lolwat\n delete Object.prototype.__magic__;\n})();\n\nconst clone =\n typeof globalThis.structuredClone === \"function\"\n ? globalThis.structuredClone\n : (obj: any) => JSON.parse(JSON.stringify(obj));\n\n/**\n * Wrapper around the built-in structured clone. Uses `JSON.parse(JSON.stringify(...))`\n * as a fallback.\n */\nexport function structuredClone(obj: T): T {\n return clone(obj);\n}\n\ndeclare global {\n const __magic__: any;\n interface Object {\n __magic__?: any;\n }\n}\n"],"names":[],"mappings":"CACC,WAAY;AACL,MAAA,OAAO,eAAe,UAAU;AAChC;AAAA,EAAA;AAEG,SAAA,eAAe,OAAO,WAAW,aAAa;AAAA,IACjD,KAAK,WAAY;AACN,aAAA;AAAA,IACX;AAAA,IACA,cAAc;AAAA;AAAA,EAAA,CACjB;AACD,YAAU,aAAa;AACvB,SAAO,OAAO,UAAU;AAC5B,GAAG;AAEH,MAAM,QACF,OAAO,WAAW,oBAAoB,aAChC,WAAW,kBACX,CAAC,QAAa,KAAK,MAAM,KAAK,UAAU,GAAG,CAAC;AAM/C,SAAS,gBAAmB,KAAW;AAC1C,SAAO,MAAM,GAAG;AACpB;"} \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-ctan/index.cjs b/node_modules/@unified-latex/unified-latex-ctan/index.cjs new file mode 100644 index 0000000..afb057b --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-ctan/index.cjs @@ -0,0 +1,71 @@ +"use strict"; +Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" }); +const index$9 = require("./package/amsart/index.cjs"); +const index$8 = require("./package/cleveref/index.cjs"); +const provides$4 = require("./provides-gOjhEUvC.cjs"); +const index$7 = require("./package/geometry/index.cjs"); +const index$6 = require("./package/hyperref/index.cjs"); +const provides$3 = require("./provides-DdQzqlsT.cjs"); +const provides$2 = require("./provides-BjJALsf_.cjs"); +const index$5 = require("./package/makeidx/index.cjs"); +const index$4 = require("./package/mathtools/index.cjs"); +const provides$1 = require("./provides-Bdw2Aj_V.cjs"); +const index$3 = require("./package/nicematrix/index.cjs"); +const provides = require("./provides-CwtnTL9q.cjs"); +require("@unified-latex/unified-latex-util-match"); +require("@unified-latex/unified-latex-util-pegjs"); +require("@unified-latex/unified-latex-util-print-raw"); +require("@unified-latex/unified-latex-util-split"); +require("./index-BuqJUpao.cjs"); +require("@unified-latex/unified-latex-util-comments"); +require("@unified-latex/unified-latex-util-visit"); +require("@unified-latex/unified-latex-util-render-info"); +require("@unified-latex/unified-latex-util-arguments"); +const parser = require("./parser-9Q3EtimU.cjs"); +require("@unified-latex/unified-latex-util-trim"); +const xcolor = require("./xcolor-BEfsW_1K.cjs"); +require("@unified-latex/unified-latex-builder"); +const index$2 = require("./package/xparse/index.cjs"); +const index$1 = require("./package/beamer/index.cjs"); +const index = require("./package/multicol/index.cjs"); +const macroInfo = { + amsart: index$9.macros, + cleveref: index$8.macros, + exam: provides$4.macros, + geometry: index$7.macros, + hyperref: index$6.macros, + latex2e: provides$3.macros, + listings: provides$2.macros, + makeidx: index$5.macros, + mathtools: index$4.macros, + minted: provides$1.macros, + nicematrix: index$3.macros, + systeme: provides.macros, + tikz: parser.macros, + xcolor: xcolor.macros, + xparse: index$2.macros, + beamer: index$1.macros, + multicol: index.macros +}; +const environmentInfo = { + amsart: index$9.environments, + cleveref: index$8.environments, + exam: provides$4.environments, + geometry: index$7.environments, + hyperref: index$6.environments, + latex2e: provides$3.environments, + listings: provides$2.environments, + makeidx: index$5.environments, + mathtools: index$4.environments, + minted: provides$1.environments, + nicematrix: index$3.environments, + systeme: provides.environments, + tikz: parser.environments, + xcolor: xcolor.environments, + xparse: index$2.environments, + beamer: index$1.environments, + multicol: index.environments +}; +exports.environmentInfo = environmentInfo; +exports.macroInfo = macroInfo; +//# sourceMappingURL=index.cjs.map diff --git a/node_modules/@unified-latex/unified-latex-ctan/index.cjs.map b/node_modules/@unified-latex/unified-latex-ctan/index.cjs.map new file mode 100644 index 0000000..39f1564 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-ctan/index.cjs.map @@ -0,0 +1 @@ +{"version":3,"file":"index.cjs","sources":["../index.ts"],"sourcesContent":["import * as amsart from \"./package/amsart\";\nimport * as cleveref from \"./package/cleveref\";\nimport * as exam from \"./package/exam\";\nimport * as geometry from \"./package/geometry\";\nimport * as hyperref from \"./package/hyperref\";\nimport * as latex2e from \"./package/latex2e\";\nimport * as listings from \"./package/listings\";\nimport * as makeidx from \"./package/makeidx\";\nimport * as mathtools from \"./package/mathtools\";\nimport * as minted from \"./package/minted\";\nimport * as nicematrix from \"./package/nicematrix\";\nimport * as systeme from \"./package/systeme\";\nimport * as tikz from \"./package/tikz\";\nimport * as xcolor from \"./package/xcolor\";\nimport * as xparse from \"./package/xparse\";\nimport * as beamer from \"./package/beamer\";\nimport * as multicol from \"./package/multicol\";\n\n/**\n * Info about the macros for available ctan packages. `latex2e` contains\n * the standard macros for LaTeX.\n */\nexport const macroInfo = {\n amsart: amsart.macros,\n cleveref: cleveref.macros,\n exam: exam.macros,\n geometry: geometry.macros,\n hyperref: hyperref.macros,\n latex2e: latex2e.macros,\n listings: listings.macros,\n makeidx: makeidx.macros,\n mathtools: mathtools.macros,\n minted: minted.macros,\n nicematrix: nicematrix.macros,\n systeme: systeme.macros,\n tikz: tikz.macros,\n xcolor: xcolor.macros,\n xparse: xparse.macros,\n beamer: beamer.macros,\n multicol: multicol.macros,\n};\n\n/**\n * Info about the environments for available ctan packages. `latex2e` contains\n * the standard environments for LaTeX.\n */\nexport const environmentInfo = {\n amsart: amsart.environments,\n cleveref: cleveref.environments,\n exam: exam.environments,\n geometry: geometry.environments,\n hyperref: hyperref.environments,\n latex2e: latex2e.environments,\n listings: listings.environments,\n makeidx: makeidx.environments,\n mathtools: mathtools.environments,\n minted: minted.environments,\n nicematrix: nicematrix.environments,\n systeme: systeme.environments,\n tikz: tikz.environments,\n xcolor: xcolor.environments,\n xparse: xparse.environments,\n beamer: beamer.environments,\n multicol: multicol.environments,\n};\n\n// NOTE: The docstring comment must be the last item in the index.ts file!\n/**\n * ## What is this?\n *\n * Macro/environment definitions and utilities for specific LaTeX packages from CTAN.\n *\n * Note: basic LaTeX macro/environment definitions come from the `latex2e` package, even though\n * this is technically not a CTAN \"package\".\n *\n * ## When should I use this?\n *\n * If you want information about special functions/macros from particular CTAN packages, or\n * you need to parse special environments.\n *\n * ## Notes\n *\n * By default all macros/environments that are exported get processed. If multiple packages\n * export a macro with the same name, then the later-exported one takes precedence. If two packages\n * export a macro/environment of the same name but with conflicting argument signatures, this can\n * cause issues when another unified-latex package processes arguments positionally. For example,\n * by default `\\textbf` takes one argument, but the beamer version of `\\textbf` takes two arguments.\n * During HTML conversion, if arguments are referenced positionally, this may cause previously-working\n * code to fail with when beamer macro signatures are used. A workaround is provided: `_renderInfo.namedArguments`.\n * If `_renderInfo.namedArguments` is specified on both the original macro/environment definition\n * **and** the conflicting one, other unified-latex commands can reference arguments by name instead\n * of by position.\n */\n"],"names":["amsart.macros","cleveref.macros","exam.macros","geometry.macros","hyperref.macros","latex2e.macros","listings.macros","makeidx.macros","mathtools.macros","minted.macros","nicematrix.macros","systeme.macros","tikz.macros","xcolor.macros","xparse.macros","beamer.macros","multicol.macros","amsart.environments","cleveref.environments","exam.environments","geometry.environments","hyperref.environments","latex2e.environments","listings.environments","makeidx.environments","mathtools.environments","minted.environments","nicematrix.environments","systeme.environments","tikz.environments","xcolor.environments","xparse.environments","beamer.environments","multicol.environments"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsBO,MAAM,YAAY;AAAA,EACrB,QAAQA,QAAO;AAAA,EACf,UAAUC,QAAS;AAAA,EACnB,MAAMC,WAAK;AAAA,EACX,UAAUC,QAAS;AAAA,EACnB,UAAUC,QAAS;AAAA,EACnB,SAASC,WAAQ;AAAA,EACjB,UAAUC,WAAS;AAAA,EACnB,SAASC,QAAQ;AAAA,EACjB,WAAWC,QAAU;AAAA,EACrB,QAAQC,WAAO;AAAA,EACf,YAAYC,QAAW;AAAA,EACvB,SAASC,SAAQ;AAAA,EACjB,MAAMC,OAAK;AAAA,EACX,QAAQC,OAAO;AAAA,EACf,QAAQC,QAAO;AAAA,EACf,QAAQC,QAAO;AAAA,EACf,UAAUC,MAAAA;AACd;AAMO,MAAM,kBAAkB;AAAA,EAC3B,QAAQC,QAAO;AAAA,EACf,UAAUC,QAAS;AAAA,EACnB,MAAMC,WAAK;AAAA,EACX,UAAUC,QAAS;AAAA,EACnB,UAAUC,QAAS;AAAA,EACnB,SAASC,WAAQ;AAAA,EACjB,UAAUC,WAAS;AAAA,EACnB,SAASC,QAAQ;AAAA,EACjB,WAAWC,QAAU;AAAA,EACrB,QAAQC,WAAO;AAAA,EACf,YAAYC,QAAW;AAAA,EACvB,SAASC,SAAQ;AAAA,EACjB,MAAMC,OAAK;AAAA,EACX,QAAQC,OAAO;AAAA,EACf,QAAQC,QAAO;AAAA,EACf,QAAQC,QAAO;AAAA,EACf,UAAUC,MAAAA;AACd;;;"} \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-ctan/index.d.ts b/node_modules/@unified-latex/unified-latex-ctan/index.d.ts new file mode 100644 index 0000000..69a4680 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-ctan/index.d.ts @@ -0,0 +1,73 @@ +/** + * Info about the macros for available ctan packages. `latex2e` contains + * the standard macros for LaTeX. + */ +export declare const macroInfo: { + amsart: import('@unified-latex/unified-latex-types').MacroInfoRecord; + cleveref: import('@unified-latex/unified-latex-types').MacroInfoRecord; + exam: import('@unified-latex/unified-latex-types').MacroInfoRecord; + geometry: import('@unified-latex/unified-latex-types').MacroInfoRecord; + hyperref: import('@unified-latex/unified-latex-types').MacroInfoRecord; + latex2e: import('@unified-latex/unified-latex-types').MacroInfoRecord; + listings: import('@unified-latex/unified-latex-types').MacroInfoRecord; + makeidx: import('@unified-latex/unified-latex-types').MacroInfoRecord; + mathtools: import('@unified-latex/unified-latex-types').MacroInfoRecord; + minted: import('@unified-latex/unified-latex-types').MacroInfoRecord; + nicematrix: import('@unified-latex/unified-latex-types').MacroInfoRecord; + systeme: import('@unified-latex/unified-latex-types').MacroInfoRecord; + tikz: import('@unified-latex/unified-latex-types').MacroInfoRecord; + xcolor: import('@unified-latex/unified-latex-types').MacroInfoRecord; + xparse: import('@unified-latex/unified-latex-types').MacroInfoRecord; + beamer: import('@unified-latex/unified-latex-types').MacroInfoRecord; + multicol: import('@unified-latex/unified-latex-types').MacroInfoRecord; +}; +/** + * Info about the environments for available ctan packages. `latex2e` contains + * the standard environments for LaTeX. + */ +export declare const environmentInfo: { + amsart: import('@unified-latex/unified-latex-types').EnvInfoRecord; + cleveref: import('@unified-latex/unified-latex-types').EnvInfoRecord; + exam: import('@unified-latex/unified-latex-types').EnvInfoRecord; + geometry: import('@unified-latex/unified-latex-types').EnvInfoRecord; + hyperref: import('@unified-latex/unified-latex-types').EnvInfoRecord; + latex2e: import('@unified-latex/unified-latex-types').EnvInfoRecord; + listings: import('@unified-latex/unified-latex-types').EnvInfoRecord; + makeidx: import('@unified-latex/unified-latex-types').EnvInfoRecord; + mathtools: import('@unified-latex/unified-latex-types').EnvInfoRecord; + minted: import('@unified-latex/unified-latex-types').EnvInfoRecord; + nicematrix: import('@unified-latex/unified-latex-types').EnvInfoRecord; + systeme: import('@unified-latex/unified-latex-types').EnvInfoRecord; + tikz: import('@unified-latex/unified-latex-types').EnvInfoRecord; + xcolor: import('@unified-latex/unified-latex-types').EnvInfoRecord; + xparse: import('@unified-latex/unified-latex-types').EnvInfoRecord; + beamer: import('@unified-latex/unified-latex-types').EnvInfoRecord; + multicol: import('@unified-latex/unified-latex-types').EnvInfoRecord; +}; +/** + * ## What is this? + * + * Macro/environment definitions and utilities for specific LaTeX packages from CTAN. + * + * Note: basic LaTeX macro/environment definitions come from the `latex2e` package, even though + * this is technically not a CTAN "package". + * + * ## When should I use this? + * + * If you want information about special functions/macros from particular CTAN packages, or + * you need to parse special environments. + * + * ## Notes + * + * By default all macros/environments that are exported get processed. If multiple packages + * export a macro with the same name, then the later-exported one takes precedence. If two packages + * export a macro/environment of the same name but with conflicting argument signatures, this can + * cause issues when another unified-latex package processes arguments positionally. For example, + * by default `\textbf` takes one argument, but the beamer version of `\textbf` takes two arguments. + * During HTML conversion, if arguments are referenced positionally, this may cause previously-working + * code to fail with when beamer macro signatures are used. A workaround is provided: `_renderInfo.namedArguments`. + * If `_renderInfo.namedArguments` is specified on both the original macro/environment definition + * **and** the conflicting one, other unified-latex commands can reference arguments by name instead + * of by position. + */ +//# sourceMappingURL=index.d.ts.map \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-ctan/index.js b/node_modules/@unified-latex/unified-latex-ctan/index.js new file mode 100644 index 0000000..d79d4d8 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-ctan/index.js @@ -0,0 +1,71 @@ +import { macros as macros$g, environments as environments$g } from "./package/amsart/index.js"; +import { macros as macros$f, environments as environments$f } from "./package/cleveref/index.js"; +import { m as macros$e, e as environments$e } from "./provides-B-HiB8uu.js"; +import { macros as macros$d, environments as environments$d } from "./package/geometry/index.js"; +import { macros as macros$c, environments as environments$c } from "./package/hyperref/index.js"; +import { m as macros$b, e as environments$b } from "./provides-BUHzyq9A.js"; +import { m as macros$a, e as environments$a } from "./provides-Ch0mvkO_.js"; +import { macros as macros$9, environments as environments$9 } from "./package/makeidx/index.js"; +import { macros as macros$8, environments as environments$8 } from "./package/mathtools/index.js"; +import { m as macros$7, e as environments$7 } from "./provides-sdqk_ZBm.js"; +import { macros as macros$6, environments as environments$6 } from "./package/nicematrix/index.js"; +import { m as macros$5, e as environments$5 } from "./provides-yGf6-zdY.js"; +import "@unified-latex/unified-latex-util-match"; +import "@unified-latex/unified-latex-util-pegjs"; +import "@unified-latex/unified-latex-util-print-raw"; +import "@unified-latex/unified-latex-util-split"; +import "./index-NHd3tQDq.js"; +import "@unified-latex/unified-latex-util-comments"; +import "@unified-latex/unified-latex-util-visit"; +import "@unified-latex/unified-latex-util-render-info"; +import "@unified-latex/unified-latex-util-arguments"; +import { m as macros$4, e as environments$4 } from "./parser-BBXMi7mQ.js"; +import "@unified-latex/unified-latex-util-trim"; +import { m as macros$3, e as environments$3 } from "./xcolor-CIejE3rZ.js"; +import "@unified-latex/unified-latex-builder"; +import { macros as macros$2, environments as environments$2 } from "./package/xparse/index.js"; +import { macros as macros$1, environments as environments$1 } from "./package/beamer/index.js"; +import { macros, environments } from "./package/multicol/index.js"; +const macroInfo = { + amsart: macros$g, + cleveref: macros$f, + exam: macros$e, + geometry: macros$d, + hyperref: macros$c, + latex2e: macros$b, + listings: macros$a, + makeidx: macros$9, + mathtools: macros$8, + minted: macros$7, + nicematrix: macros$6, + systeme: macros$5, + tikz: macros$4, + xcolor: macros$3, + xparse: macros$2, + beamer: macros$1, + multicol: macros +}; +const environmentInfo = { + amsart: environments$g, + cleveref: environments$f, + exam: environments$e, + geometry: environments$d, + hyperref: environments$c, + latex2e: environments$b, + listings: environments$a, + makeidx: environments$9, + mathtools: environments$8, + minted: environments$7, + nicematrix: environments$6, + systeme: environments$5, + tikz: environments$4, + xcolor: environments$3, + xparse: environments$2, + beamer: environments$1, + multicol: environments +}; +export { + environmentInfo, + macroInfo +}; +//# sourceMappingURL=index.js.map diff --git a/node_modules/@unified-latex/unified-latex-ctan/index.js.map b/node_modules/@unified-latex/unified-latex-ctan/index.js.map new file mode 100644 index 0000000..fac03f2 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-ctan/index.js.map @@ -0,0 +1 @@ +{"version":3,"file":"index.js","sources":["../index.ts"],"sourcesContent":["import * as amsart from \"./package/amsart\";\nimport * as cleveref from \"./package/cleveref\";\nimport * as exam from \"./package/exam\";\nimport * as geometry from \"./package/geometry\";\nimport * as hyperref from \"./package/hyperref\";\nimport * as latex2e from \"./package/latex2e\";\nimport * as listings from \"./package/listings\";\nimport * as makeidx from \"./package/makeidx\";\nimport * as mathtools from \"./package/mathtools\";\nimport * as minted from \"./package/minted\";\nimport * as nicematrix from \"./package/nicematrix\";\nimport * as systeme from \"./package/systeme\";\nimport * as tikz from \"./package/tikz\";\nimport * as xcolor from \"./package/xcolor\";\nimport * as xparse from \"./package/xparse\";\nimport * as beamer from \"./package/beamer\";\nimport * as multicol from \"./package/multicol\";\n\n/**\n * Info about the macros for available ctan packages. `latex2e` contains\n * the standard macros for LaTeX.\n */\nexport const macroInfo = {\n amsart: amsart.macros,\n cleveref: cleveref.macros,\n exam: exam.macros,\n geometry: geometry.macros,\n hyperref: hyperref.macros,\n latex2e: latex2e.macros,\n listings: listings.macros,\n makeidx: makeidx.macros,\n mathtools: mathtools.macros,\n minted: minted.macros,\n nicematrix: nicematrix.macros,\n systeme: systeme.macros,\n tikz: tikz.macros,\n xcolor: xcolor.macros,\n xparse: xparse.macros,\n beamer: beamer.macros,\n multicol: multicol.macros,\n};\n\n/**\n * Info about the environments for available ctan packages. `latex2e` contains\n * the standard environments for LaTeX.\n */\nexport const environmentInfo = {\n amsart: amsart.environments,\n cleveref: cleveref.environments,\n exam: exam.environments,\n geometry: geometry.environments,\n hyperref: hyperref.environments,\n latex2e: latex2e.environments,\n listings: listings.environments,\n makeidx: makeidx.environments,\n mathtools: mathtools.environments,\n minted: minted.environments,\n nicematrix: nicematrix.environments,\n systeme: systeme.environments,\n tikz: tikz.environments,\n xcolor: xcolor.environments,\n xparse: xparse.environments,\n beamer: beamer.environments,\n multicol: multicol.environments,\n};\n\n// NOTE: The docstring comment must be the last item in the index.ts file!\n/**\n * ## What is this?\n *\n * Macro/environment definitions and utilities for specific LaTeX packages from CTAN.\n *\n * Note: basic LaTeX macro/environment definitions come from the `latex2e` package, even though\n * this is technically not a CTAN \"package\".\n *\n * ## When should I use this?\n *\n * If you want information about special functions/macros from particular CTAN packages, or\n * you need to parse special environments.\n *\n * ## Notes\n *\n * By default all macros/environments that are exported get processed. If multiple packages\n * export a macro with the same name, then the later-exported one takes precedence. If two packages\n * export a macro/environment of the same name but with conflicting argument signatures, this can\n * cause issues when another unified-latex package processes arguments positionally. For example,\n * by default `\\textbf` takes one argument, but the beamer version of `\\textbf` takes two arguments.\n * During HTML conversion, if arguments are referenced positionally, this may cause previously-working\n * code to fail with when beamer macro signatures are used. A workaround is provided: `_renderInfo.namedArguments`.\n * If `_renderInfo.namedArguments` is specified on both the original macro/environment definition\n * **and** the conflicting one, other unified-latex commands can reference arguments by name instead\n * of by position.\n */\n"],"names":["amsart.macros","cleveref.macros","exam.macros","geometry.macros","hyperref.macros","latex2e.macros","listings.macros","makeidx.macros","mathtools.macros","minted.macros","nicematrix.macros","systeme.macros","tikz.macros","xcolor.macros","xparse.macros","beamer.macros","multicol.macros","amsart.environments","cleveref.environments","exam.environments","geometry.environments","hyperref.environments","latex2e.environments","listings.environments","makeidx.environments","mathtools.environments","minted.environments","nicematrix.environments","systeme.environments","tikz.environments","xcolor.environments","xparse.environments","beamer.environments","multicol.environments"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsBO,MAAM,YAAY;AAAA,EACrB,QAAQA;AAAAA,EACR,UAAUC;AAAAA,EACV,MAAMC;AAAAA,EACN,UAAUC;AAAAA,EACV,UAAUC;AAAAA,EACV,SAASC;AAAAA,EACT,UAAUC;AAAAA,EACV,SAASC;AAAAA,EACT,WAAWC;AAAAA,EACX,QAAQC;AAAAA,EACR,YAAYC;AAAAA,EACZ,SAASC;AAAAA,EACT,MAAMC;AAAAA,EACN,QAAQC;AAAAA,EACR,QAAQC;AAAAA,EACR,QAAQC;AAAAA,EACR,UAAUC;AACd;AAMO,MAAM,kBAAkB;AAAA,EAC3B,QAAQC;AAAAA,EACR,UAAUC;AAAAA,EACV,MAAMC;AAAAA,EACN,UAAUC;AAAAA,EACV,UAAUC;AAAAA,EACV,SAASC;AAAAA,EACT,UAAUC;AAAAA,EACV,SAASC;AAAAA,EACT,WAAWC;AAAAA,EACX,QAAQC;AAAAA,EACR,YAAYC;AAAAA,EACZ,SAASC;AAAAA,EACT,MAAMC;AAAAA,EACN,QAAQC;AAAAA,EACR,QAAQC;AAAAA,EACR,QAAQC;AAAAA,EACR,UAAUC;AACd;"} \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-ctan/package.json b/node_modules/@unified-latex/unified-latex-ctan/package.json new file mode 100644 index 0000000..05278d4 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-ctan/package.json @@ -0,0 +1,65 @@ +{ + "name": "@unified-latex/unified-latex-ctan", + "version": "1.8.2", + "description": "unified-latex tools relating to specific CTAN packages", + "main": "index.js", + "type": "module", + "dependencies": { + "@unified-latex/unified-latex-builder": "^1.8.0", + "@unified-latex/unified-latex-types": "^1.8.0", + "@unified-latex/unified-latex-util-argspec": "^1.8.2", + "@unified-latex/unified-latex-util-arguments": "^1.8.2", + "@unified-latex/unified-latex-util-comments": "^1.8.2", + "@unified-latex/unified-latex-util-match": "^1.8.0", + "@unified-latex/unified-latex-util-pegjs": "^1.8.1", + "@unified-latex/unified-latex-util-print-raw": "^1.8.0", + "@unified-latex/unified-latex-util-render-info": "^1.8.2", + "@unified-latex/unified-latex-util-replace": "^1.8.2", + "@unified-latex/unified-latex-util-scan": "^1.8.0", + "@unified-latex/unified-latex-util-split": "^1.8.0", + "@unified-latex/unified-latex-util-trim": "^1.8.2", + "@unified-latex/unified-latex-util-visit": "^1.8.2", + "color": "^4.2.3" + }, + "repository": { + "type": "git", + "url": "git+https://github.com/siefkenj/unified-latex.git" + }, + "keywords": [ + "pegjs", + "latex", + "parser", + "prettier", + "unified-latex", + "unified" + ], + "author": "Jason Siefken", + "license": "MIT", + "bugs": { + "url": "https://github.com/siefkenj/unified-latex/issues" + }, + "homepage": "https://github.com/siefkenj/unified-latex#readme", + "exports": { + ".": { + "import": "./index.js", + "require": "./index.cjs", + "types": "./index.d.ts" + }, + "./*js": "./*js", + "./*": { + "import": "./*/index.js", + "require": "./*/index.cjs", + "types": "./*/index.d.ts" + }, + "./*/index": { + "import": "./*/index.js", + "require": "./*/index.cjs" + } + }, + "files": [ + "**/*ts", + "**/*js", + "**/*.map", + "**/*.json" + ] +} \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-ctan/package/amsart/index.cjs b/node_modules/@unified-latex/unified-latex-ctan/package/amsart/index.cjs new file mode 100644 index 0000000..c08772c --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-ctan/package/amsart/index.cjs @@ -0,0 +1,32 @@ +"use strict"; +Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" }); +const macros = { + author: { + signature: "o m", + renderInfo: { breakAround: true, inParMode: true } + }, + address: { + signature: "o m", + renderInfo: { breakAround: true, inParMode: true } + }, + curraddr: { + signature: "o m", + renderInfo: { breakAround: true, inParMode: true } + }, + email: { + signature: "o m", + renderInfo: { breakAround: true, inParMode: true } + }, + title: { + signature: "o m", + renderInfo: { breakAround: true, inParMode: true } + }, + urladdr: { + signature: "o m", + renderInfo: { breakAround: true, inParMode: true } + } +}; +const environments = {}; +exports.environments = environments; +exports.macros = macros; +//# sourceMappingURL=index.cjs.map diff --git a/node_modules/@unified-latex/unified-latex-ctan/package/amsart/index.cjs.map b/node_modules/@unified-latex/unified-latex-ctan/package/amsart/index.cjs.map new file mode 100644 index 0000000..d9da74f --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-ctan/package/amsart/index.cjs.map @@ -0,0 +1 @@ +{"version":3,"file":"index.cjs","sources":["../../../package/amsart/provides.ts"],"sourcesContent":["import {\n MacroInfoRecord,\n EnvInfoRecord,\n} from \"@unified-latex/unified-latex-types\";\n\nexport const macros: MacroInfoRecord = {\n author: {\n signature: \"o m\",\n renderInfo: { breakAround: true, inParMode: true },\n },\n address: {\n signature: \"o m\",\n renderInfo: { breakAround: true, inParMode: true },\n },\n curraddr: {\n signature: \"o m\",\n renderInfo: { breakAround: true, inParMode: true },\n },\n email: {\n signature: \"o m\",\n renderInfo: { breakAround: true, inParMode: true },\n },\n title: {\n signature: \"o m\",\n renderInfo: { breakAround: true, inParMode: true },\n },\n urladdr: {\n signature: \"o m\",\n renderInfo: { breakAround: true, inParMode: true },\n }\n}\n\nexport const environments: EnvInfoRecord = {};\n"],"names":[],"mappings":";;AAKO,MAAM,SAA0B;AAAA,EACnC,QAAQ;AAAA,IACJ,WAAW;AAAA,IACX,YAAY,EAAE,aAAa,MAAM,WAAW,KAAK;AAAA,EACrD;AAAA,EACA,SAAS;AAAA,IACL,WAAW;AAAA,IACX,YAAY,EAAE,aAAa,MAAM,WAAW,KAAK;AAAA,EACrD;AAAA,EACA,UAAU;AAAA,IACN,WAAW;AAAA,IACX,YAAY,EAAE,aAAa,MAAM,WAAW,KAAK;AAAA,EACrD;AAAA,EACA,OAAO;AAAA,IACH,WAAW;AAAA,IACX,YAAY,EAAE,aAAa,MAAM,WAAW,KAAK;AAAA,EACrD;AAAA,EACA,OAAO;AAAA,IACH,WAAW;AAAA,IACX,YAAY,EAAE,aAAa,MAAM,WAAW,KAAK;AAAA,EACrD;AAAA,EACA,SAAS;AAAA,IACL,WAAW;AAAA,IACX,YAAY,EAAE,aAAa,MAAM,WAAW,KAAK;AAAA,EAAA;AAEzD;AAEO,MAAM,eAA8B,CAAA;;;"} \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-ctan/package/amsart/index.d.ts b/node_modules/@unified-latex/unified-latex-ctan/package/amsart/index.d.ts new file mode 100644 index 0000000..981b287 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-ctan/package/amsart/index.d.ts @@ -0,0 +1,2 @@ +export * from './provides'; +//# sourceMappingURL=index.d.ts.map \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-ctan/package/amsart/index.js b/node_modules/@unified-latex/unified-latex-ctan/package/amsart/index.js new file mode 100644 index 0000000..b3e0666 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-ctan/package/amsart/index.js @@ -0,0 +1,32 @@ +const macros = { + author: { + signature: "o m", + renderInfo: { breakAround: true, inParMode: true } + }, + address: { + signature: "o m", + renderInfo: { breakAround: true, inParMode: true } + }, + curraddr: { + signature: "o m", + renderInfo: { breakAround: true, inParMode: true } + }, + email: { + signature: "o m", + renderInfo: { breakAround: true, inParMode: true } + }, + title: { + signature: "o m", + renderInfo: { breakAround: true, inParMode: true } + }, + urladdr: { + signature: "o m", + renderInfo: { breakAround: true, inParMode: true } + } +}; +const environments = {}; +export { + environments, + macros +}; +//# sourceMappingURL=index.js.map diff --git a/node_modules/@unified-latex/unified-latex-ctan/package/amsart/index.js.map b/node_modules/@unified-latex/unified-latex-ctan/package/amsart/index.js.map new file mode 100644 index 0000000..bc37509 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-ctan/package/amsart/index.js.map @@ -0,0 +1 @@ +{"version":3,"file":"index.js","sources":["../../../package/amsart/provides.ts"],"sourcesContent":["import {\n MacroInfoRecord,\n EnvInfoRecord,\n} from \"@unified-latex/unified-latex-types\";\n\nexport const macros: MacroInfoRecord = {\n author: {\n signature: \"o m\",\n renderInfo: { breakAround: true, inParMode: true },\n },\n address: {\n signature: \"o m\",\n renderInfo: { breakAround: true, inParMode: true },\n },\n curraddr: {\n signature: \"o m\",\n renderInfo: { breakAround: true, inParMode: true },\n },\n email: {\n signature: \"o m\",\n renderInfo: { breakAround: true, inParMode: true },\n },\n title: {\n signature: \"o m\",\n renderInfo: { breakAround: true, inParMode: true },\n },\n urladdr: {\n signature: \"o m\",\n renderInfo: { breakAround: true, inParMode: true },\n }\n}\n\nexport const environments: EnvInfoRecord = {};\n"],"names":[],"mappings":"AAKO,MAAM,SAA0B;AAAA,EACnC,QAAQ;AAAA,IACJ,WAAW;AAAA,IACX,YAAY,EAAE,aAAa,MAAM,WAAW,KAAK;AAAA,EACrD;AAAA,EACA,SAAS;AAAA,IACL,WAAW;AAAA,IACX,YAAY,EAAE,aAAa,MAAM,WAAW,KAAK;AAAA,EACrD;AAAA,EACA,UAAU;AAAA,IACN,WAAW;AAAA,IACX,YAAY,EAAE,aAAa,MAAM,WAAW,KAAK;AAAA,EACrD;AAAA,EACA,OAAO;AAAA,IACH,WAAW;AAAA,IACX,YAAY,EAAE,aAAa,MAAM,WAAW,KAAK;AAAA,EACrD;AAAA,EACA,OAAO;AAAA,IACH,WAAW;AAAA,IACX,YAAY,EAAE,aAAa,MAAM,WAAW,KAAK;AAAA,EACrD;AAAA,EACA,SAAS;AAAA,IACL,WAAW;AAAA,IACX,YAAY,EAAE,aAAa,MAAM,WAAW,KAAK;AAAA,EAAA;AAEzD;AAEO,MAAM,eAA8B,CAAA;"} \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-ctan/package/amsart/provides.d.ts b/node_modules/@unified-latex/unified-latex-ctan/package/amsart/provides.d.ts new file mode 100644 index 0000000..88c6521 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-ctan/package/amsart/provides.d.ts @@ -0,0 +1,4 @@ +import { MacroInfoRecord, EnvInfoRecord } from '@unified-latex/unified-latex-types'; +export declare const macros: MacroInfoRecord; +export declare const environments: EnvInfoRecord; +//# sourceMappingURL=provides.d.ts.map \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-ctan/package/beamer/index.cjs b/node_modules/@unified-latex/unified-latex-ctan/package/beamer/index.cjs new file mode 100644 index 0000000..6a12fca --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-ctan/package/beamer/index.cjs @@ -0,0 +1,204 @@ +"use strict"; +Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" }); +const macros = { + mode: { signature: "s d<> d{}", renderInfo: { breakAround: true } }, + insertnavigation: { signature: "m", renderInfo: { breakAround: true } }, + insertsectionnavigation: { + signature: "m", + renderInfo: { breakAround: true } + }, + insertsectionnavigationhorizontal: { + signature: "m m m", + renderInfo: { breakAround: true } + }, + insertauthor: { signature: "o", renderInfo: { breakAround: true } }, + insertshortauthor: { signature: "o", renderInfo: { breakAround: true } }, + insertshortdate: { signature: "o", renderInfo: { breakAround: true } }, + insertshortinstitute: { signature: "o", renderInfo: { breakAround: true } }, + insertshortpart: { signature: "o", renderInfo: { breakAround: true } }, + insertshorttitle: { signature: "o", renderInfo: { breakAround: true } }, + insertsubsectionnavigation: { + signature: "m", + renderInfo: { breakAround: true } + }, + insertsubsectionnavigationhorizontal: { + signature: "m m m", + renderInfo: { breakAround: true } + }, + insertverticalnavigation: { + signature: "m", + renderInfo: { breakAround: true } + }, + usebeamercolor: { signature: "s m", renderInfo: { breakAround: true } }, + usebeamertemplate: { signature: "s m", renderInfo: { breakAround: true } }, + setbeamercolor: { + signature: "m m", + renderInfo: { breakAround: true, pgfkeysArgs: true } + }, + setbeamersize: { + signature: "m o o", + renderInfo: { breakAround: true, pgfkeysArgs: true } + }, + setbeamertemplate: { + signature: "m o o d{}", + renderInfo: { breakAround: true, pgfkeysArgs: true } + }, + newcommand: { + signature: "s d<> +m o +o +m", + renderInfo: { + breakAround: true, + namedArguments: [ + "starred", + null, + "name", + "numArgs", + "default", + "body" + ] + } + }, + renewcommand: { + signature: "s d<> +m o +o +m", + renderInfo: { + breakAround: true, + namedArguments: [ + "starred", + null, + "name", + "numArgs", + "default", + "body" + ] + } + }, + newenvironment: { + signature: "s d<> m o o m m", + renderInfo: { breakAround: true } + }, + renewenvironment: { + signature: "s d<> m o o m m", + renderInfo: { breakAround: true } + }, + resetcounteronoverlays: { + signature: "m", + renderInfo: { breakAround: true } + }, + resetcountonoverlays: { signature: "m", renderInfo: { breakAround: true } }, + logo: { signature: "m", renderInfo: { breakAround: true } }, + frametitle: { signature: "d<> o m", renderInfo: { breakAround: true } }, + framesubtitle: { signature: "d<> m", renderInfo: { breakAround: true } }, + pause: { signature: "o" }, + onslide: { signature: "t+ t* d<> d{}" }, + only: { signature: "d<> m d<>" }, + uncover: { signature: "d<> m" }, + visible: { signature: "d<> m" }, + invisible: { signature: "d<> m" }, + alt: { signature: "d<> m m d<>" }, + temporal: { signature: "r<> m m m" }, + item: { + signature: "d<> o d<>", + renderInfo: { + hangingIndent: true, + namedArguments: [null, "label", null] + } + }, + label: { signature: "d<> o m" }, + // cleveref adds an optional argument to label; this gives maximum compatibility. + action: { signature: "d<> m" }, + beamerdefaultoverlayspecification: { signature: "m" }, + titlegraphic: { signature: "m", renderInfo: { breakAround: true } }, + subject: { signature: "m", renderInfo: { breakAround: true } }, + keywords: { signature: "m", renderInfo: { breakAround: true } }, + lecture: { signature: "o m m", renderInfo: { breakAround: true } }, + partpage: { renderInfo: { breakAround: true } }, + sectionpage: { renderInfo: { breakAround: true } }, + subsectionpage: { renderInfo: { breakAround: true } }, + AtBeginLecture: { signature: "m", renderInfo: { breakAround: true } }, + AtBeginPart: { signature: "m", renderInfo: { breakAround: true } }, + tableofcontents: { + signature: "o", + renderInfo: { breakAround: true, pgfkeysArgs: true } + }, + againframe: { signature: "d<> o o m", renderInfo: { breakAround: true } }, + framezoom: { + signature: "r<> r<> o r() r()", + renderInfo: { breakAround: true } + }, + column: { signature: "d<> o m", renderInfo: { breakAround: true } }, + animate: { signature: "r<>", renderInfo: { breakAround: true } }, + animatevalue: { signature: "r<> m m m", renderInfo: { breakAround: true } }, + sound: { + signature: "o m m", + renderInfo: { breakAround: true, pgfkeysArgs: true } + }, + hyperlinksound: { + signature: "o m m", + renderInfo: { breakAround: true, pgfkeysArgs: true } + }, + hyperlinkmute: { signature: "m", renderInfo: { breakAround: true } }, + // These signatures conflict with the default signatures. + // Care must be taken when processing an AST. + section: { + signature: "s d<> o m", + renderInfo: { + breakAround: true, + namedArguments: ["starred", null, "tocTitle", "title"] + } + }, + subsection: { + signature: "s d<> o m", + renderInfo: { + breakAround: true, + namedArguments: ["starred", null, "tocTitle", "title"] + } + }, + subsubsection: { + signature: "s d<> o m", + renderInfo: { + breakAround: true, + namedArguments: ["starred", null, "tocTitle", "title"] + } + }, + part: { + signature: "s d<> o m", + renderInfo: { + breakAround: true, + namedArguments: ["starred", null, "tocTitle", "title"] + } + }, + bibitem: { + signature: "s d<> o m", + renderInfo: { + hangingIndent: true, + namedArguments: ["starred", null, "tocTitle", "title"] + } + } +}; +const environments = { + frame: { + signature: "!d<> !o !o !d{} !d{}" + }, + block: { + signature: "!d<> !d{} !d<>" + }, + alertblock: { + signature: "!d<> !d{} !d<>" + }, + exampleblock: { + signature: "!d<> !d{} !d<>" + }, + onlyenv: { + signature: "!d<>" + }, + altenv: { + signature: "!d<> m m m m !d<>" + }, + overlayarea: { signature: "m m" }, + overprint: { signature: "o" }, + actionenv: { signature: "!d<>" }, + columns: { signature: "d<> o" }, + column: { signature: "d<> o m" } +}; +exports.environments = environments; +exports.macros = macros; +//# sourceMappingURL=index.cjs.map diff --git a/node_modules/@unified-latex/unified-latex-ctan/package/beamer/index.cjs.map b/node_modules/@unified-latex/unified-latex-ctan/package/beamer/index.cjs.map new file mode 100644 index 0000000..2ea5a5e --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-ctan/package/beamer/index.cjs.map @@ -0,0 +1 @@ +{"version":3,"file":"index.cjs","sources":["../../../package/beamer/provides.ts"],"sourcesContent":["import {\n MacroInfoRecord,\n EnvInfoRecord,\n} from \"@unified-latex/unified-latex-types\";\n\nexport const macros: MacroInfoRecord = {\n mode: { signature: \"s d<> d{}\", renderInfo: { breakAround: true } },\n insertnavigation: { signature: \"m\", renderInfo: { breakAround: true } },\n insertsectionnavigation: {\n signature: \"m\",\n renderInfo: { breakAround: true },\n },\n insertsectionnavigationhorizontal: {\n signature: \"m m m\",\n renderInfo: { breakAround: true },\n },\n insertauthor: { signature: \"o\", renderInfo: { breakAround: true } },\n insertshortauthor: { signature: \"o\", renderInfo: { breakAround: true } },\n insertshortdate: { signature: \"o\", renderInfo: { breakAround: true } },\n insertshortinstitute: { signature: \"o\", renderInfo: { breakAround: true } },\n insertshortpart: { signature: \"o\", renderInfo: { breakAround: true } },\n insertshorttitle: { signature: \"o\", renderInfo: { breakAround: true } },\n insertsubsectionnavigation: {\n signature: \"m\",\n renderInfo: { breakAround: true },\n },\n insertsubsectionnavigationhorizontal: {\n signature: \"m m m\",\n renderInfo: { breakAround: true },\n },\n insertverticalnavigation: {\n signature: \"m\",\n renderInfo: { breakAround: true },\n },\n usebeamercolor: { signature: \"s m\", renderInfo: { breakAround: true } },\n usebeamertemplate: { signature: \"s m\", renderInfo: { breakAround: true } },\n setbeamercolor: {\n signature: \"m m\",\n renderInfo: { breakAround: true, pgfkeysArgs: true },\n },\n setbeamersize: {\n signature: \"m o o\",\n renderInfo: { breakAround: true, pgfkeysArgs: true },\n },\n setbeamertemplate: {\n signature: \"m o o d{}\",\n renderInfo: { breakAround: true, pgfkeysArgs: true },\n },\n\n newcommand: {\n signature: \"s d<> +m o +o +m\",\n renderInfo: {\n breakAround: true,\n namedArguments: [\n \"starred\",\n null,\n \"name\",\n \"numArgs\",\n \"default\",\n \"body\",\n ],\n },\n },\n renewcommand: {\n signature: \"s d<> +m o +o +m\",\n renderInfo: {\n breakAround: true,\n namedArguments: [\n \"starred\",\n null,\n \"name\",\n \"numArgs\",\n \"default\",\n \"body\",\n ],\n },\n },\n newenvironment: {\n signature: \"s d<> m o o m m\",\n renderInfo: { breakAround: true },\n },\n renewenvironment: {\n signature: \"s d<> m o o m m\",\n renderInfo: { breakAround: true },\n },\n resetcounteronoverlays: {\n signature: \"m\",\n renderInfo: { breakAround: true },\n },\n resetcountonoverlays: { signature: \"m\", renderInfo: { breakAround: true } },\n\n logo: { signature: \"m\", renderInfo: { breakAround: true } },\n frametitle: { signature: \"d<> o m\", renderInfo: { breakAround: true } },\n framesubtitle: { signature: \"d<> m\", renderInfo: { breakAround: true } },\n pause: { signature: \"o\" },\n onslide: { signature: \"t+ t* d<> d{}\" },\n only: { signature: \"d<> m d<>\" },\n uncover: { signature: \"d<> m\" },\n visible: { signature: \"d<> m\" },\n invisible: { signature: \"d<> m\" },\n alt: { signature: \"d<> m m d<>\" },\n temporal: { signature: \"r<> m m m\" },\n item: {\n signature: \"d<> o d<>\",\n renderInfo: {\n hangingIndent: true,\n namedArguments: [null, \"label\", null],\n },\n },\n label: { signature: \"d<> o m\" }, // cleveref adds an optional argument to label; this gives maximum compatibility.\n action: { signature: \"d<> m\" },\n beamerdefaultoverlayspecification: { signature: \"m\" },\n\n titlegraphic: { signature: \"m\", renderInfo: { breakAround: true } },\n subject: { signature: \"m\", renderInfo: { breakAround: true } },\n keywords: { signature: \"m\", renderInfo: { breakAround: true } },\n\n lecture: { signature: \"o m m\", renderInfo: { breakAround: true } },\n partpage: { renderInfo: { breakAround: true } },\n sectionpage: { renderInfo: { breakAround: true } },\n subsectionpage: { renderInfo: { breakAround: true } },\n AtBeginLecture: { signature: \"m\", renderInfo: { breakAround: true } },\n AtBeginPart: { signature: \"m\", renderInfo: { breakAround: true } },\n tableofcontents: {\n signature: \"o\",\n renderInfo: { breakAround: true, pgfkeysArgs: true },\n },\n againframe: { signature: \"d<> o o m\", renderInfo: { breakAround: true } },\n framezoom: {\n signature: \"r<> r<> o r() r()\",\n renderInfo: { breakAround: true },\n },\n column: { signature: \"d<> o m\", renderInfo: { breakAround: true } },\n\n animate: { signature: \"r<>\", renderInfo: { breakAround: true } },\n animatevalue: { signature: \"r<> m m m\", renderInfo: { breakAround: true } },\n sound: {\n signature: \"o m m\",\n renderInfo: { breakAround: true, pgfkeysArgs: true },\n },\n hyperlinksound: {\n signature: \"o m m\",\n renderInfo: { breakAround: true, pgfkeysArgs: true },\n },\n hyperlinkmute: { signature: \"m\", renderInfo: { breakAround: true } },\n\n // These signatures conflict with the default signatures.\n // Care must be taken when processing an AST.\n section: {\n signature: \"s d<> o m\",\n renderInfo: {\n breakAround: true,\n namedArguments: [\"starred\", null, \"tocTitle\", \"title\"],\n },\n },\n subsection: {\n signature: \"s d<> o m\",\n renderInfo: {\n breakAround: true,\n namedArguments: [\"starred\", null, \"tocTitle\", \"title\"],\n },\n },\n subsubsection: {\n signature: \"s d<> o m\",\n renderInfo: {\n breakAround: true,\n namedArguments: [\"starred\", null, \"tocTitle\", \"title\"],\n },\n },\n part: {\n signature: \"s d<> o m\",\n renderInfo: {\n breakAround: true,\n namedArguments: [\"starred\", null, \"tocTitle\", \"title\"],\n },\n },\n bibitem: {\n signature: \"s d<> o m\",\n renderInfo: {\n hangingIndent: true,\n namedArguments: [\"starred\", null, \"tocTitle\", \"title\"],\n },\n },\n};\n\nexport const environments: EnvInfoRecord = {\n frame: {\n signature: \"!d<> !o !o !d{} !d{}\",\n },\n block: {\n signature: \"!d<> !d{} !d<>\",\n },\n alertblock: {\n signature: \"!d<> !d{} !d<>\",\n },\n exampleblock: {\n signature: \"!d<> !d{} !d<>\",\n },\n onlyenv: {\n signature: \"!d<>\",\n },\n altenv: {\n signature: \"!d<> m m m m !d<>\",\n },\n overlayarea: { signature: \"m m\" },\n overprint: { signature: \"o\" },\n actionenv: { signature: \"!d<>\" },\n columns: { signature: \"d<> o\" },\n column: { signature: \"d<> o m\" },\n};\n"],"names":[],"mappings":";;AAKO,MAAM,SAA0B;AAAA,EACnC,MAAM,EAAE,WAAW,aAAa,YAAY,EAAE,aAAa,OAAO;AAAA,EAClE,kBAAkB,EAAE,WAAW,KAAK,YAAY,EAAE,aAAa,OAAO;AAAA,EACtE,yBAAyB;AAAA,IACrB,WAAW;AAAA,IACX,YAAY,EAAE,aAAa,KAAK;AAAA,EACpC;AAAA,EACA,mCAAmC;AAAA,IAC/B,WAAW;AAAA,IACX,YAAY,EAAE,aAAa,KAAK;AAAA,EACpC;AAAA,EACA,cAAc,EAAE,WAAW,KAAK,YAAY,EAAE,aAAa,OAAO;AAAA,EAClE,mBAAmB,EAAE,WAAW,KAAK,YAAY,EAAE,aAAa,OAAO;AAAA,EACvE,iBAAiB,EAAE,WAAW,KAAK,YAAY,EAAE,aAAa,OAAO;AAAA,EACrE,sBAAsB,EAAE,WAAW,KAAK,YAAY,EAAE,aAAa,OAAO;AAAA,EAC1E,iBAAiB,EAAE,WAAW,KAAK,YAAY,EAAE,aAAa,OAAO;AAAA,EACrE,kBAAkB,EAAE,WAAW,KAAK,YAAY,EAAE,aAAa,OAAO;AAAA,EACtE,4BAA4B;AAAA,IACxB,WAAW;AAAA,IACX,YAAY,EAAE,aAAa,KAAK;AAAA,EACpC;AAAA,EACA,sCAAsC;AAAA,IAClC,WAAW;AAAA,IACX,YAAY,EAAE,aAAa,KAAK;AAAA,EACpC;AAAA,EACA,0BAA0B;AAAA,IACtB,WAAW;AAAA,IACX,YAAY,EAAE,aAAa,KAAK;AAAA,EACpC;AAAA,EACA,gBAAgB,EAAE,WAAW,OAAO,YAAY,EAAE,aAAa,OAAO;AAAA,EACtE,mBAAmB,EAAE,WAAW,OAAO,YAAY,EAAE,aAAa,OAAO;AAAA,EACzE,gBAAgB;AAAA,IACZ,WAAW;AAAA,IACX,YAAY,EAAE,aAAa,MAAM,aAAa,KAAK;AAAA,EACvD;AAAA,EACA,eAAe;AAAA,IACX,WAAW;AAAA,IACX,YAAY,EAAE,aAAa,MAAM,aAAa,KAAK;AAAA,EACvD;AAAA,EACA,mBAAmB;AAAA,IACf,WAAW;AAAA,IACX,YAAY,EAAE,aAAa,MAAM,aAAa,KAAK;AAAA,EACvD;AAAA,EAEA,YAAY;AAAA,IACR,WAAW;AAAA,IACX,YAAY;AAAA,MACR,aAAa;AAAA,MACb,gBAAgB;AAAA,QACZ;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,MAAA;AAAA,IACJ;AAAA,EAER;AAAA,EACA,cAAc;AAAA,IACV,WAAW;AAAA,IACX,YAAY;AAAA,MACR,aAAa;AAAA,MACb,gBAAgB;AAAA,QACZ;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,MAAA;AAAA,IACJ;AAAA,EAER;AAAA,EACA,gBAAgB;AAAA,IACZ,WAAW;AAAA,IACX,YAAY,EAAE,aAAa,KAAK;AAAA,EACpC;AAAA,EACA,kBAAkB;AAAA,IACd,WAAW;AAAA,IACX,YAAY,EAAE,aAAa,KAAK;AAAA,EACpC;AAAA,EACA,wBAAwB;AAAA,IACpB,WAAW;AAAA,IACX,YAAY,EAAE,aAAa,KAAK;AAAA,EACpC;AAAA,EACA,sBAAsB,EAAE,WAAW,KAAK,YAAY,EAAE,aAAa,OAAO;AAAA,EAE1E,MAAM,EAAE,WAAW,KAAK,YAAY,EAAE,aAAa,OAAO;AAAA,EAC1D,YAAY,EAAE,WAAW,WAAW,YAAY,EAAE,aAAa,OAAO;AAAA,EACtE,eAAe,EAAE,WAAW,SAAS,YAAY,EAAE,aAAa,OAAO;AAAA,EACvE,OAAO,EAAE,WAAW,IAAI;AAAA,EACxB,SAAS,EAAE,WAAW,gBAAgB;AAAA,EACtC,MAAM,EAAE,WAAW,YAAY;AAAA,EAC/B,SAAS,EAAE,WAAW,QAAQ;AAAA,EAC9B,SAAS,EAAE,WAAW,QAAQ;AAAA,EAC9B,WAAW,EAAE,WAAW,QAAQ;AAAA,EAChC,KAAK,EAAE,WAAW,cAAc;AAAA,EAChC,UAAU,EAAE,WAAW,YAAY;AAAA,EACnC,MAAM;AAAA,IACF,WAAW;AAAA,IACX,YAAY;AAAA,MACR,eAAe;AAAA,MACf,gBAAgB,CAAC,MAAM,SAAS,IAAI;AAAA,IAAA;AAAA,EAE5C;AAAA,EACA,OAAO,EAAE,WAAW,UAAU;AAAA;AAAA,EAC9B,QAAQ,EAAE,WAAW,QAAQ;AAAA,EAC7B,mCAAmC,EAAE,WAAW,IAAI;AAAA,EAEpD,cAAc,EAAE,WAAW,KAAK,YAAY,EAAE,aAAa,OAAO;AAAA,EAClE,SAAS,EAAE,WAAW,KAAK,YAAY,EAAE,aAAa,OAAO;AAAA,EAC7D,UAAU,EAAE,WAAW,KAAK,YAAY,EAAE,aAAa,OAAO;AAAA,EAE9D,SAAS,EAAE,WAAW,SAAS,YAAY,EAAE,aAAa,OAAO;AAAA,EACjE,UAAU,EAAE,YAAY,EAAE,aAAa,OAAO;AAAA,EAC9C,aAAa,EAAE,YAAY,EAAE,aAAa,OAAO;AAAA,EACjD,gBAAgB,EAAE,YAAY,EAAE,aAAa,OAAO;AAAA,EACpD,gBAAgB,EAAE,WAAW,KAAK,YAAY,EAAE,aAAa,OAAO;AAAA,EACpE,aAAa,EAAE,WAAW,KAAK,YAAY,EAAE,aAAa,OAAO;AAAA,EACjE,iBAAiB;AAAA,IACb,WAAW;AAAA,IACX,YAAY,EAAE,aAAa,MAAM,aAAa,KAAK;AAAA,EACvD;AAAA,EACA,YAAY,EAAE,WAAW,aAAa,YAAY,EAAE,aAAa,OAAO;AAAA,EACxE,WAAW;AAAA,IACP,WAAW;AAAA,IACX,YAAY,EAAE,aAAa,KAAK;AAAA,EACpC;AAAA,EACA,QAAQ,EAAE,WAAW,WAAW,YAAY,EAAE,aAAa,OAAO;AAAA,EAElE,SAAS,EAAE,WAAW,OAAO,YAAY,EAAE,aAAa,OAAO;AAAA,EAC/D,cAAc,EAAE,WAAW,aAAa,YAAY,EAAE,aAAa,OAAO;AAAA,EAC1E,OAAO;AAAA,IACH,WAAW;AAAA,IACX,YAAY,EAAE,aAAa,MAAM,aAAa,KAAK;AAAA,EACvD;AAAA,EACA,gBAAgB;AAAA,IACZ,WAAW;AAAA,IACX,YAAY,EAAE,aAAa,MAAM,aAAa,KAAK;AAAA,EACvD;AAAA,EACA,eAAe,EAAE,WAAW,KAAK,YAAY,EAAE,aAAa,OAAO;AAAA;AAAA;AAAA,EAInE,SAAS;AAAA,IACL,WAAW;AAAA,IACX,YAAY;AAAA,MACR,aAAa;AAAA,MACb,gBAAgB,CAAC,WAAW,MAAM,YAAY,OAAO;AAAA,IAAA;AAAA,EAE7D;AAAA,EACA,YAAY;AAAA,IACR,WAAW;AAAA,IACX,YAAY;AAAA,MACR,aAAa;AAAA,MACb,gBAAgB,CAAC,WAAW,MAAM,YAAY,OAAO;AAAA,IAAA;AAAA,EAE7D;AAAA,EACA,eAAe;AAAA,IACX,WAAW;AAAA,IACX,YAAY;AAAA,MACR,aAAa;AAAA,MACb,gBAAgB,CAAC,WAAW,MAAM,YAAY,OAAO;AAAA,IAAA;AAAA,EAE7D;AAAA,EACA,MAAM;AAAA,IACF,WAAW;AAAA,IACX,YAAY;AAAA,MACR,aAAa;AAAA,MACb,gBAAgB,CAAC,WAAW,MAAM,YAAY,OAAO;AAAA,IAAA;AAAA,EAE7D;AAAA,EACA,SAAS;AAAA,IACL,WAAW;AAAA,IACX,YAAY;AAAA,MACR,eAAe;AAAA,MACf,gBAAgB,CAAC,WAAW,MAAM,YAAY,OAAO;AAAA,IAAA;AAAA,EACzD;AAER;AAEO,MAAM,eAA8B;AAAA,EACvC,OAAO;AAAA,IACH,WAAW;AAAA,EACf;AAAA,EACA,OAAO;AAAA,IACH,WAAW;AAAA,EACf;AAAA,EACA,YAAY;AAAA,IACR,WAAW;AAAA,EACf;AAAA,EACA,cAAc;AAAA,IACV,WAAW;AAAA,EACf;AAAA,EACA,SAAS;AAAA,IACL,WAAW;AAAA,EACf;AAAA,EACA,QAAQ;AAAA,IACJ,WAAW;AAAA,EACf;AAAA,EACA,aAAa,EAAE,WAAW,MAAM;AAAA,EAChC,WAAW,EAAE,WAAW,IAAI;AAAA,EAC5B,WAAW,EAAE,WAAW,OAAO;AAAA,EAC/B,SAAS,EAAE,WAAW,QAAQ;AAAA,EAC9B,QAAQ,EAAE,WAAW,UAAU;AACnC;;;"} \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-ctan/package/beamer/index.d.ts b/node_modules/@unified-latex/unified-latex-ctan/package/beamer/index.d.ts new file mode 100644 index 0000000..981b287 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-ctan/package/beamer/index.d.ts @@ -0,0 +1,2 @@ +export * from './provides'; +//# sourceMappingURL=index.d.ts.map \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-ctan/package/beamer/index.js b/node_modules/@unified-latex/unified-latex-ctan/package/beamer/index.js new file mode 100644 index 0000000..8e723bb --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-ctan/package/beamer/index.js @@ -0,0 +1,204 @@ +const macros = { + mode: { signature: "s d<> d{}", renderInfo: { breakAround: true } }, + insertnavigation: { signature: "m", renderInfo: { breakAround: true } }, + insertsectionnavigation: { + signature: "m", + renderInfo: { breakAround: true } + }, + insertsectionnavigationhorizontal: { + signature: "m m m", + renderInfo: { breakAround: true } + }, + insertauthor: { signature: "o", renderInfo: { breakAround: true } }, + insertshortauthor: { signature: "o", renderInfo: { breakAround: true } }, + insertshortdate: { signature: "o", renderInfo: { breakAround: true } }, + insertshortinstitute: { signature: "o", renderInfo: { breakAround: true } }, + insertshortpart: { signature: "o", renderInfo: { breakAround: true } }, + insertshorttitle: { signature: "o", renderInfo: { breakAround: true } }, + insertsubsectionnavigation: { + signature: "m", + renderInfo: { breakAround: true } + }, + insertsubsectionnavigationhorizontal: { + signature: "m m m", + renderInfo: { breakAround: true } + }, + insertverticalnavigation: { + signature: "m", + renderInfo: { breakAround: true } + }, + usebeamercolor: { signature: "s m", renderInfo: { breakAround: true } }, + usebeamertemplate: { signature: "s m", renderInfo: { breakAround: true } }, + setbeamercolor: { + signature: "m m", + renderInfo: { breakAround: true, pgfkeysArgs: true } + }, + setbeamersize: { + signature: "m o o", + renderInfo: { breakAround: true, pgfkeysArgs: true } + }, + setbeamertemplate: { + signature: "m o o d{}", + renderInfo: { breakAround: true, pgfkeysArgs: true } + }, + newcommand: { + signature: "s d<> +m o +o +m", + renderInfo: { + breakAround: true, + namedArguments: [ + "starred", + null, + "name", + "numArgs", + "default", + "body" + ] + } + }, + renewcommand: { + signature: "s d<> +m o +o +m", + renderInfo: { + breakAround: true, + namedArguments: [ + "starred", + null, + "name", + "numArgs", + "default", + "body" + ] + } + }, + newenvironment: { + signature: "s d<> m o o m m", + renderInfo: { breakAround: true } + }, + renewenvironment: { + signature: "s d<> m o o m m", + renderInfo: { breakAround: true } + }, + resetcounteronoverlays: { + signature: "m", + renderInfo: { breakAround: true } + }, + resetcountonoverlays: { signature: "m", renderInfo: { breakAround: true } }, + logo: { signature: "m", renderInfo: { breakAround: true } }, + frametitle: { signature: "d<> o m", renderInfo: { breakAround: true } }, + framesubtitle: { signature: "d<> m", renderInfo: { breakAround: true } }, + pause: { signature: "o" }, + onslide: { signature: "t+ t* d<> d{}" }, + only: { signature: "d<> m d<>" }, + uncover: { signature: "d<> m" }, + visible: { signature: "d<> m" }, + invisible: { signature: "d<> m" }, + alt: { signature: "d<> m m d<>" }, + temporal: { signature: "r<> m m m" }, + item: { + signature: "d<> o d<>", + renderInfo: { + hangingIndent: true, + namedArguments: [null, "label", null] + } + }, + label: { signature: "d<> o m" }, + // cleveref adds an optional argument to label; this gives maximum compatibility. + action: { signature: "d<> m" }, + beamerdefaultoverlayspecification: { signature: "m" }, + titlegraphic: { signature: "m", renderInfo: { breakAround: true } }, + subject: { signature: "m", renderInfo: { breakAround: true } }, + keywords: { signature: "m", renderInfo: { breakAround: true } }, + lecture: { signature: "o m m", renderInfo: { breakAround: true } }, + partpage: { renderInfo: { breakAround: true } }, + sectionpage: { renderInfo: { breakAround: true } }, + subsectionpage: { renderInfo: { breakAround: true } }, + AtBeginLecture: { signature: "m", renderInfo: { breakAround: true } }, + AtBeginPart: { signature: "m", renderInfo: { breakAround: true } }, + tableofcontents: { + signature: "o", + renderInfo: { breakAround: true, pgfkeysArgs: true } + }, + againframe: { signature: "d<> o o m", renderInfo: { breakAround: true } }, + framezoom: { + signature: "r<> r<> o r() r()", + renderInfo: { breakAround: true } + }, + column: { signature: "d<> o m", renderInfo: { breakAround: true } }, + animate: { signature: "r<>", renderInfo: { breakAround: true } }, + animatevalue: { signature: "r<> m m m", renderInfo: { breakAround: true } }, + sound: { + signature: "o m m", + renderInfo: { breakAround: true, pgfkeysArgs: true } + }, + hyperlinksound: { + signature: "o m m", + renderInfo: { breakAround: true, pgfkeysArgs: true } + }, + hyperlinkmute: { signature: "m", renderInfo: { breakAround: true } }, + // These signatures conflict with the default signatures. + // Care must be taken when processing an AST. + section: { + signature: "s d<> o m", + renderInfo: { + breakAround: true, + namedArguments: ["starred", null, "tocTitle", "title"] + } + }, + subsection: { + signature: "s d<> o m", + renderInfo: { + breakAround: true, + namedArguments: ["starred", null, "tocTitle", "title"] + } + }, + subsubsection: { + signature: "s d<> o m", + renderInfo: { + breakAround: true, + namedArguments: ["starred", null, "tocTitle", "title"] + } + }, + part: { + signature: "s d<> o m", + renderInfo: { + breakAround: true, + namedArguments: ["starred", null, "tocTitle", "title"] + } + }, + bibitem: { + signature: "s d<> o m", + renderInfo: { + hangingIndent: true, + namedArguments: ["starred", null, "tocTitle", "title"] + } + } +}; +const environments = { + frame: { + signature: "!d<> !o !o !d{} !d{}" + }, + block: { + signature: "!d<> !d{} !d<>" + }, + alertblock: { + signature: "!d<> !d{} !d<>" + }, + exampleblock: { + signature: "!d<> !d{} !d<>" + }, + onlyenv: { + signature: "!d<>" + }, + altenv: { + signature: "!d<> m m m m !d<>" + }, + overlayarea: { signature: "m m" }, + overprint: { signature: "o" }, + actionenv: { signature: "!d<>" }, + columns: { signature: "d<> o" }, + column: { signature: "d<> o m" } +}; +export { + environments, + macros +}; +//# sourceMappingURL=index.js.map diff --git a/node_modules/@unified-latex/unified-latex-ctan/package/beamer/index.js.map b/node_modules/@unified-latex/unified-latex-ctan/package/beamer/index.js.map new file mode 100644 index 0000000..1abc800 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-ctan/package/beamer/index.js.map @@ -0,0 +1 @@ +{"version":3,"file":"index.js","sources":["../../../package/beamer/provides.ts"],"sourcesContent":["import {\n MacroInfoRecord,\n EnvInfoRecord,\n} from \"@unified-latex/unified-latex-types\";\n\nexport const macros: MacroInfoRecord = {\n mode: { signature: \"s d<> d{}\", renderInfo: { breakAround: true } },\n insertnavigation: { signature: \"m\", renderInfo: { breakAround: true } },\n insertsectionnavigation: {\n signature: \"m\",\n renderInfo: { breakAround: true },\n },\n insertsectionnavigationhorizontal: {\n signature: \"m m m\",\n renderInfo: { breakAround: true },\n },\n insertauthor: { signature: \"o\", renderInfo: { breakAround: true } },\n insertshortauthor: { signature: \"o\", renderInfo: { breakAround: true } },\n insertshortdate: { signature: \"o\", renderInfo: { breakAround: true } },\n insertshortinstitute: { signature: \"o\", renderInfo: { breakAround: true } },\n insertshortpart: { signature: \"o\", renderInfo: { breakAround: true } },\n insertshorttitle: { signature: \"o\", renderInfo: { breakAround: true } },\n insertsubsectionnavigation: {\n signature: \"m\",\n renderInfo: { breakAround: true },\n },\n insertsubsectionnavigationhorizontal: {\n signature: \"m m m\",\n renderInfo: { breakAround: true },\n },\n insertverticalnavigation: {\n signature: \"m\",\n renderInfo: { breakAround: true },\n },\n usebeamercolor: { signature: \"s m\", renderInfo: { breakAround: true } },\n usebeamertemplate: { signature: \"s m\", renderInfo: { breakAround: true } },\n setbeamercolor: {\n signature: \"m m\",\n renderInfo: { breakAround: true, pgfkeysArgs: true },\n },\n setbeamersize: {\n signature: \"m o o\",\n renderInfo: { breakAround: true, pgfkeysArgs: true },\n },\n setbeamertemplate: {\n signature: \"m o o d{}\",\n renderInfo: { breakAround: true, pgfkeysArgs: true },\n },\n\n newcommand: {\n signature: \"s d<> +m o +o +m\",\n renderInfo: {\n breakAround: true,\n namedArguments: [\n \"starred\",\n null,\n \"name\",\n \"numArgs\",\n \"default\",\n \"body\",\n ],\n },\n },\n renewcommand: {\n signature: \"s d<> +m o +o +m\",\n renderInfo: {\n breakAround: true,\n namedArguments: [\n \"starred\",\n null,\n \"name\",\n \"numArgs\",\n \"default\",\n \"body\",\n ],\n },\n },\n newenvironment: {\n signature: \"s d<> m o o m m\",\n renderInfo: { breakAround: true },\n },\n renewenvironment: {\n signature: \"s d<> m o o m m\",\n renderInfo: { breakAround: true },\n },\n resetcounteronoverlays: {\n signature: \"m\",\n renderInfo: { breakAround: true },\n },\n resetcountonoverlays: { signature: \"m\", renderInfo: { breakAround: true } },\n\n logo: { signature: \"m\", renderInfo: { breakAround: true } },\n frametitle: { signature: \"d<> o m\", renderInfo: { breakAround: true } },\n framesubtitle: { signature: \"d<> m\", renderInfo: { breakAround: true } },\n pause: { signature: \"o\" },\n onslide: { signature: \"t+ t* d<> d{}\" },\n only: { signature: \"d<> m d<>\" },\n uncover: { signature: \"d<> m\" },\n visible: { signature: \"d<> m\" },\n invisible: { signature: \"d<> m\" },\n alt: { signature: \"d<> m m d<>\" },\n temporal: { signature: \"r<> m m m\" },\n item: {\n signature: \"d<> o d<>\",\n renderInfo: {\n hangingIndent: true,\n namedArguments: [null, \"label\", null],\n },\n },\n label: { signature: \"d<> o m\" }, // cleveref adds an optional argument to label; this gives maximum compatibility.\n action: { signature: \"d<> m\" },\n beamerdefaultoverlayspecification: { signature: \"m\" },\n\n titlegraphic: { signature: \"m\", renderInfo: { breakAround: true } },\n subject: { signature: \"m\", renderInfo: { breakAround: true } },\n keywords: { signature: \"m\", renderInfo: { breakAround: true } },\n\n lecture: { signature: \"o m m\", renderInfo: { breakAround: true } },\n partpage: { renderInfo: { breakAround: true } },\n sectionpage: { renderInfo: { breakAround: true } },\n subsectionpage: { renderInfo: { breakAround: true } },\n AtBeginLecture: { signature: \"m\", renderInfo: { breakAround: true } },\n AtBeginPart: { signature: \"m\", renderInfo: { breakAround: true } },\n tableofcontents: {\n signature: \"o\",\n renderInfo: { breakAround: true, pgfkeysArgs: true },\n },\n againframe: { signature: \"d<> o o m\", renderInfo: { breakAround: true } },\n framezoom: {\n signature: \"r<> r<> o r() r()\",\n renderInfo: { breakAround: true },\n },\n column: { signature: \"d<> o m\", renderInfo: { breakAround: true } },\n\n animate: { signature: \"r<>\", renderInfo: { breakAround: true } },\n animatevalue: { signature: \"r<> m m m\", renderInfo: { breakAround: true } },\n sound: {\n signature: \"o m m\",\n renderInfo: { breakAround: true, pgfkeysArgs: true },\n },\n hyperlinksound: {\n signature: \"o m m\",\n renderInfo: { breakAround: true, pgfkeysArgs: true },\n },\n hyperlinkmute: { signature: \"m\", renderInfo: { breakAround: true } },\n\n // These signatures conflict with the default signatures.\n // Care must be taken when processing an AST.\n section: {\n signature: \"s d<> o m\",\n renderInfo: {\n breakAround: true,\n namedArguments: [\"starred\", null, \"tocTitle\", \"title\"],\n },\n },\n subsection: {\n signature: \"s d<> o m\",\n renderInfo: {\n breakAround: true,\n namedArguments: [\"starred\", null, \"tocTitle\", \"title\"],\n },\n },\n subsubsection: {\n signature: \"s d<> o m\",\n renderInfo: {\n breakAround: true,\n namedArguments: [\"starred\", null, \"tocTitle\", \"title\"],\n },\n },\n part: {\n signature: \"s d<> o m\",\n renderInfo: {\n breakAround: true,\n namedArguments: [\"starred\", null, \"tocTitle\", \"title\"],\n },\n },\n bibitem: {\n signature: \"s d<> o m\",\n renderInfo: {\n hangingIndent: true,\n namedArguments: [\"starred\", null, \"tocTitle\", \"title\"],\n },\n },\n};\n\nexport const environments: EnvInfoRecord = {\n frame: {\n signature: \"!d<> !o !o !d{} !d{}\",\n },\n block: {\n signature: \"!d<> !d{} !d<>\",\n },\n alertblock: {\n signature: \"!d<> !d{} !d<>\",\n },\n exampleblock: {\n signature: \"!d<> !d{} !d<>\",\n },\n onlyenv: {\n signature: \"!d<>\",\n },\n altenv: {\n signature: \"!d<> m m m m !d<>\",\n },\n overlayarea: { signature: \"m m\" },\n overprint: { signature: \"o\" },\n actionenv: { signature: \"!d<>\" },\n columns: { signature: \"d<> o\" },\n column: { signature: \"d<> o m\" },\n};\n"],"names":[],"mappings":"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"} \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-ctan/package/beamer/provides.d.ts b/node_modules/@unified-latex/unified-latex-ctan/package/beamer/provides.d.ts new file mode 100644 index 0000000..88c6521 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-ctan/package/beamer/provides.d.ts @@ -0,0 +1,4 @@ +import { MacroInfoRecord, EnvInfoRecord } from '@unified-latex/unified-latex-types'; +export declare const macros: MacroInfoRecord; +export declare const environments: EnvInfoRecord; +//# sourceMappingURL=provides.d.ts.map \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-ctan/package/cleveref/index.cjs b/node_modules/@unified-latex/unified-latex-ctan/package/cleveref/index.cjs new file mode 100644 index 0000000..05e9ef7 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-ctan/package/cleveref/index.cjs @@ -0,0 +1,30 @@ +"use strict"; +Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" }); +const macros = { + cref: { signature: "s m" }, + Cref: { signature: "s m" }, + crefrange: { signature: "s m m" }, + Crefrange: { signature: "s m m" }, + cpageref: { signature: "s m" }, + Cpageref: { signature: "s m" }, + ref: { signature: "m" }, + pageref: { signature: "m" }, + namecref: { signature: "m" }, + nameCref: { signature: "m" }, + lcnamecref: { signature: "m" }, + namecrefs: { signature: "m" }, + nameCrefs: { signature: "m" }, + lcnamecrefs: { signature: "m" }, + labelcref: { signature: "m" }, + labelcpageref: { signature: "m" }, + crefalias: { signature: "m m" }, + crefname: { signature: "m m m" }, + // XXX there are many more obscure commands to add here + // https://ctan.org/pkg/cleveref + crefdefaultlabelformat: { signature: "m" }, + crefrangeconjunction: { signature: "m" } +}; +const environments = {}; +exports.environments = environments; +exports.macros = macros; +//# sourceMappingURL=index.cjs.map diff --git a/node_modules/@unified-latex/unified-latex-ctan/package/cleveref/index.cjs.map b/node_modules/@unified-latex/unified-latex-ctan/package/cleveref/index.cjs.map new file mode 100644 index 0000000..bc55434 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-ctan/package/cleveref/index.cjs.map @@ -0,0 +1 @@ +{"version":3,"file":"index.cjs","sources":["../../../package/cleveref/provides.ts"],"sourcesContent":["import {\n MacroInfoRecord,\n EnvInfoRecord,\n} from \"@unified-latex/unified-latex-types\";\n\nexport const macros: MacroInfoRecord = {\n cref: { signature: \"s m\" },\n Cref: { signature: \"s m\" },\n crefrange: { signature: \"s m m\" },\n Crefrange: { signature: \"s m m\" },\n cpageref: { signature: \"s m\" },\n Cpageref: { signature: \"s m\" },\n ref: { signature: \"m\" },\n pageref: { signature: \"m\" },\n namecref: { signature: \"m\" },\n nameCref: { signature: \"m\" },\n lcnamecref: { signature: \"m\" },\n namecrefs: { signature: \"m\" },\n nameCrefs: { signature: \"m\" },\n lcnamecrefs: { signature: \"m\" },\n labelcref: { signature: \"m\" },\n labelcpageref: { signature: \"m\" },\n crefalias: { signature: \"m m\" },\n crefname: { signature: \"m m m\" },\n // XXX there are many more obscure commands to add here\n // https://ctan.org/pkg/cleveref\n crefdefaultlabelformat: { signature: \"m\" },\n crefrangeconjunction: { signature: \"m\" },\n};\n\nexport const environments: EnvInfoRecord = {};\n"],"names":[],"mappings":";;AAKO,MAAM,SAA0B;AAAA,EACnC,MAAM,EAAE,WAAW,MAAM;AAAA,EACzB,MAAM,EAAE,WAAW,MAAM;AAAA,EACzB,WAAW,EAAE,WAAW,QAAQ;AAAA,EAChC,WAAW,EAAE,WAAW,QAAQ;AAAA,EAChC,UAAU,EAAE,WAAW,MAAM;AAAA,EAC7B,UAAU,EAAE,WAAW,MAAM;AAAA,EAC7B,KAAK,EAAE,WAAW,IAAI;AAAA,EACtB,SAAS,EAAE,WAAW,IAAI;AAAA,EAC1B,UAAU,EAAE,WAAW,IAAI;AAAA,EAC3B,UAAU,EAAE,WAAW,IAAI;AAAA,EAC3B,YAAY,EAAE,WAAW,IAAI;AAAA,EAC7B,WAAW,EAAE,WAAW,IAAI;AAAA,EAC5B,WAAW,EAAE,WAAW,IAAI;AAAA,EAC5B,aAAa,EAAE,WAAW,IAAI;AAAA,EAC9B,WAAW,EAAE,WAAW,IAAI;AAAA,EAC5B,eAAe,EAAE,WAAW,IAAI;AAAA,EAChC,WAAW,EAAE,WAAW,MAAM;AAAA,EAC9B,UAAU,EAAE,WAAW,QAAQ;AAAA;AAAA;AAAA,EAG/B,wBAAwB,EAAE,WAAW,IAAI;AAAA,EACzC,sBAAsB,EAAE,WAAW,IAAI;AAC3C;AAEO,MAAM,eAA8B,CAAA;;;"} \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-ctan/package/cleveref/index.d.ts b/node_modules/@unified-latex/unified-latex-ctan/package/cleveref/index.d.ts new file mode 100644 index 0000000..981b287 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-ctan/package/cleveref/index.d.ts @@ -0,0 +1,2 @@ +export * from './provides'; +//# sourceMappingURL=index.d.ts.map \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-ctan/package/cleveref/index.js b/node_modules/@unified-latex/unified-latex-ctan/package/cleveref/index.js new file mode 100644 index 0000000..2a034ed --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-ctan/package/cleveref/index.js @@ -0,0 +1,30 @@ +const macros = { + cref: { signature: "s m" }, + Cref: { signature: "s m" }, + crefrange: { signature: "s m m" }, + Crefrange: { signature: "s m m" }, + cpageref: { signature: "s m" }, + Cpageref: { signature: "s m" }, + ref: { signature: "m" }, + pageref: { signature: "m" }, + namecref: { signature: "m" }, + nameCref: { signature: "m" }, + lcnamecref: { signature: "m" }, + namecrefs: { signature: "m" }, + nameCrefs: { signature: "m" }, + lcnamecrefs: { signature: "m" }, + labelcref: { signature: "m" }, + labelcpageref: { signature: "m" }, + crefalias: { signature: "m m" }, + crefname: { signature: "m m m" }, + // XXX there are many more obscure commands to add here + // https://ctan.org/pkg/cleveref + crefdefaultlabelformat: { signature: "m" }, + crefrangeconjunction: { signature: "m" } +}; +const environments = {}; +export { + environments, + macros +}; +//# sourceMappingURL=index.js.map diff --git a/node_modules/@unified-latex/unified-latex-ctan/package/cleveref/index.js.map b/node_modules/@unified-latex/unified-latex-ctan/package/cleveref/index.js.map new file mode 100644 index 0000000..5f16d21 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-ctan/package/cleveref/index.js.map @@ -0,0 +1 @@ +{"version":3,"file":"index.js","sources":["../../../package/cleveref/provides.ts"],"sourcesContent":["import {\n MacroInfoRecord,\n EnvInfoRecord,\n} from \"@unified-latex/unified-latex-types\";\n\nexport const macros: MacroInfoRecord = {\n cref: { signature: \"s m\" },\n Cref: { signature: \"s m\" },\n crefrange: { signature: \"s m m\" },\n Crefrange: { signature: \"s m m\" },\n cpageref: { signature: \"s m\" },\n Cpageref: { signature: \"s m\" },\n ref: { signature: \"m\" },\n pageref: { signature: \"m\" },\n namecref: { signature: \"m\" },\n nameCref: { signature: \"m\" },\n lcnamecref: { signature: \"m\" },\n namecrefs: { signature: \"m\" },\n nameCrefs: { signature: \"m\" },\n lcnamecrefs: { signature: \"m\" },\n labelcref: { signature: \"m\" },\n labelcpageref: { signature: \"m\" },\n crefalias: { signature: \"m m\" },\n crefname: { signature: \"m m m\" },\n // XXX there are many more obscure commands to add here\n // https://ctan.org/pkg/cleveref\n crefdefaultlabelformat: { signature: \"m\" },\n crefrangeconjunction: { signature: \"m\" },\n};\n\nexport const environments: EnvInfoRecord = {};\n"],"names":[],"mappings":"AAKO,MAAM,SAA0B;AAAA,EACnC,MAAM,EAAE,WAAW,MAAM;AAAA,EACzB,MAAM,EAAE,WAAW,MAAM;AAAA,EACzB,WAAW,EAAE,WAAW,QAAQ;AAAA,EAChC,WAAW,EAAE,WAAW,QAAQ;AAAA,EAChC,UAAU,EAAE,WAAW,MAAM;AAAA,EAC7B,UAAU,EAAE,WAAW,MAAM;AAAA,EAC7B,KAAK,EAAE,WAAW,IAAI;AAAA,EACtB,SAAS,EAAE,WAAW,IAAI;AAAA,EAC1B,UAAU,EAAE,WAAW,IAAI;AAAA,EAC3B,UAAU,EAAE,WAAW,IAAI;AAAA,EAC3B,YAAY,EAAE,WAAW,IAAI;AAAA,EAC7B,WAAW,EAAE,WAAW,IAAI;AAAA,EAC5B,WAAW,EAAE,WAAW,IAAI;AAAA,EAC5B,aAAa,EAAE,WAAW,IAAI;AAAA,EAC9B,WAAW,EAAE,WAAW,IAAI;AAAA,EAC5B,eAAe,EAAE,WAAW,IAAI;AAAA,EAChC,WAAW,EAAE,WAAW,MAAM;AAAA,EAC9B,UAAU,EAAE,WAAW,QAAQ;AAAA;AAAA;AAAA,EAG/B,wBAAwB,EAAE,WAAW,IAAI;AAAA,EACzC,sBAAsB,EAAE,WAAW,IAAI;AAC3C;AAEO,MAAM,eAA8B,CAAA;"} \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-ctan/package/cleveref/provides.d.ts b/node_modules/@unified-latex/unified-latex-ctan/package/cleveref/provides.d.ts new file mode 100644 index 0000000..88c6521 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-ctan/package/cleveref/provides.d.ts @@ -0,0 +1,4 @@ +import { MacroInfoRecord, EnvInfoRecord } from '@unified-latex/unified-latex-types'; +export declare const macros: MacroInfoRecord; +export declare const environments: EnvInfoRecord; +//# sourceMappingURL=provides.d.ts.map \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-ctan/package/exam/index.cjs b/node_modules/@unified-latex/unified-latex-ctan/package/exam/index.cjs new file mode 100644 index 0000000..df99273 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-ctan/package/exam/index.cjs @@ -0,0 +1,6 @@ +"use strict"; +Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" }); +const provides = require("../../provides-gOjhEUvC.cjs"); +exports.environments = provides.environments; +exports.macros = provides.macros; +//# sourceMappingURL=index.cjs.map diff --git a/node_modules/@unified-latex/unified-latex-ctan/package/exam/index.cjs.map b/node_modules/@unified-latex/unified-latex-ctan/package/exam/index.cjs.map new file mode 100644 index 0000000..5f0f93e --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-ctan/package/exam/index.cjs.map @@ -0,0 +1 @@ +{"version":3,"file":"index.cjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;"} \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-ctan/package/exam/index.d.ts b/node_modules/@unified-latex/unified-latex-ctan/package/exam/index.d.ts new file mode 100644 index 0000000..981b287 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-ctan/package/exam/index.d.ts @@ -0,0 +1,2 @@ +export * from './provides'; +//# sourceMappingURL=index.d.ts.map \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-ctan/package/exam/index.js b/node_modules/@unified-latex/unified-latex-ctan/package/exam/index.js new file mode 100644 index 0000000..601fb6e --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-ctan/package/exam/index.js @@ -0,0 +1,6 @@ +import { e, m } from "../../provides-B-HiB8uu.js"; +export { + e as environments, + m as macros +}; +//# sourceMappingURL=index.js.map diff --git a/node_modules/@unified-latex/unified-latex-ctan/package/exam/index.js.map b/node_modules/@unified-latex/unified-latex-ctan/package/exam/index.js.map new file mode 100644 index 0000000..594ae09 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-ctan/package/exam/index.js.map @@ -0,0 +1 @@ +{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";"} \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-ctan/package/exam/provides.d.ts b/node_modules/@unified-latex/unified-latex-ctan/package/exam/provides.d.ts new file mode 100644 index 0000000..88c6521 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-ctan/package/exam/provides.d.ts @@ -0,0 +1,4 @@ +import { MacroInfoRecord, EnvInfoRecord } from '@unified-latex/unified-latex-types'; +export declare const macros: MacroInfoRecord; +export declare const environments: EnvInfoRecord; +//# sourceMappingURL=provides.d.ts.map \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-ctan/package/geometry/index.cjs b/node_modules/@unified-latex/unified-latex-ctan/package/geometry/index.cjs new file mode 100644 index 0000000..f22211f --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-ctan/package/geometry/index.cjs @@ -0,0 +1,12 @@ +"use strict"; +Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" }); +const macros = { + geometry: { + signature: "m", + renderInfo: { breakAround: true, pgfkeysArgs: true } + } +}; +const environments = {}; +exports.environments = environments; +exports.macros = macros; +//# sourceMappingURL=index.cjs.map diff --git a/node_modules/@unified-latex/unified-latex-ctan/package/geometry/index.cjs.map b/node_modules/@unified-latex/unified-latex-ctan/package/geometry/index.cjs.map new file mode 100644 index 0000000..2a24af6 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-ctan/package/geometry/index.cjs.map @@ -0,0 +1 @@ +{"version":3,"file":"index.cjs","sources":["../../../package/geometry/provides.ts"],"sourcesContent":["import {\n MacroInfoRecord,\n EnvInfoRecord,\n} from \"@unified-latex/unified-latex-types\";\n\nexport const macros: MacroInfoRecord = {\n geometry: {\n signature: \"m\",\n renderInfo: { breakAround: true, pgfkeysArgs: true },\n },\n};\n\nexport const environments: EnvInfoRecord = {};\n"],"names":[],"mappings":";;AAKO,MAAM,SAA0B;AAAA,EACnC,UAAU;AAAA,IACN,WAAW;AAAA,IACX,YAAY,EAAE,aAAa,MAAM,aAAa,KAAK;AAAA,EAAA;AAE3D;AAEO,MAAM,eAA8B,CAAA;;;"} \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-ctan/package/geometry/index.d.ts b/node_modules/@unified-latex/unified-latex-ctan/package/geometry/index.d.ts new file mode 100644 index 0000000..981b287 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-ctan/package/geometry/index.d.ts @@ -0,0 +1,2 @@ +export * from './provides'; +//# sourceMappingURL=index.d.ts.map \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-ctan/package/geometry/index.js b/node_modules/@unified-latex/unified-latex-ctan/package/geometry/index.js new file mode 100644 index 0000000..fd8b868 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-ctan/package/geometry/index.js @@ -0,0 +1,12 @@ +const macros = { + geometry: { + signature: "m", + renderInfo: { breakAround: true, pgfkeysArgs: true } + } +}; +const environments = {}; +export { + environments, + macros +}; +//# sourceMappingURL=index.js.map diff --git a/node_modules/@unified-latex/unified-latex-ctan/package/geometry/index.js.map b/node_modules/@unified-latex/unified-latex-ctan/package/geometry/index.js.map new file mode 100644 index 0000000..ae40216 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-ctan/package/geometry/index.js.map @@ -0,0 +1 @@ +{"version":3,"file":"index.js","sources":["../../../package/geometry/provides.ts"],"sourcesContent":["import {\n MacroInfoRecord,\n EnvInfoRecord,\n} from \"@unified-latex/unified-latex-types\";\n\nexport const macros: MacroInfoRecord = {\n geometry: {\n signature: \"m\",\n renderInfo: { breakAround: true, pgfkeysArgs: true },\n },\n};\n\nexport const environments: EnvInfoRecord = {};\n"],"names":[],"mappings":"AAKO,MAAM,SAA0B;AAAA,EACnC,UAAU;AAAA,IACN,WAAW;AAAA,IACX,YAAY,EAAE,aAAa,MAAM,aAAa,KAAK;AAAA,EAAA;AAE3D;AAEO,MAAM,eAA8B,CAAA;"} \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-ctan/package/geometry/provides.d.ts b/node_modules/@unified-latex/unified-latex-ctan/package/geometry/provides.d.ts new file mode 100644 index 0000000..88c6521 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-ctan/package/geometry/provides.d.ts @@ -0,0 +1,4 @@ +import { MacroInfoRecord, EnvInfoRecord } from '@unified-latex/unified-latex-types'; +export declare const macros: MacroInfoRecord; +export declare const environments: EnvInfoRecord; +//# sourceMappingURL=provides.d.ts.map \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-ctan/package/hyperref/index.cjs b/node_modules/@unified-latex/unified-latex-ctan/package/hyperref/index.cjs new file mode 100644 index 0000000..7625d1f --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-ctan/package/hyperref/index.cjs @@ -0,0 +1,32 @@ +"use strict"; +Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" }); +const macros = { + hypersetup: { + signature: "m", + renderInfo: { breakAround: true, pgfkeysArgs: true } + }, + href: { signature: "o m m" }, + url: { signature: "m" }, + nolinkurl: { signature: "m" }, + hyperbaseurl: { signature: "m" }, + hyperimage: { signature: "m m" }, + hyperdef: { signature: "m m m" }, + hyperref: { signature: "o m" }, + hyperlink: { signature: "m m" }, + hypertarget: { signature: "m m" }, + autoref: { signature: "s m" }, + pageref: { signature: "s m" }, + autopageref: { signature: "s m" }, + pdfstringdef: { signature: "m m" }, + pdfbookmark: { signature: "o m m" }, + currentpdfbookmark: { signature: "m m" }, + subpdfbookmark: { signature: "m m" }, + belowpdfbookmark: { signature: "m m" }, + texorpdfstring: { signature: "m m" }, + thispdfpagelabel: { signature: "m" }, + hypercalcbp: { signature: "m" } +}; +const environments = {}; +exports.environments = environments; +exports.macros = macros; +//# sourceMappingURL=index.cjs.map diff --git a/node_modules/@unified-latex/unified-latex-ctan/package/hyperref/index.cjs.map b/node_modules/@unified-latex/unified-latex-ctan/package/hyperref/index.cjs.map new file mode 100644 index 0000000..41356fc --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-ctan/package/hyperref/index.cjs.map @@ -0,0 +1 @@ +{"version":3,"file":"index.cjs","sources":["../../../package/hyperref/provides.ts"],"sourcesContent":["import {\n MacroInfoRecord,\n EnvInfoRecord,\n} from \"@unified-latex/unified-latex-types\";\n\nexport const macros: MacroInfoRecord = {\n hypersetup: {\n signature: \"m\",\n renderInfo: { breakAround: true, pgfkeysArgs: true },\n },\n href: { signature: \"o m m\" },\n url: { signature: \"m\" },\n nolinkurl: { signature: \"m\" },\n hyperbaseurl: { signature: \"m\" },\n hyperimage: { signature: \"m m\" },\n hyperdef: { signature: \"m m m\" },\n hyperref: { signature: \"o m\" },\n hyperlink: { signature: \"m m\" },\n hypertarget: { signature: \"m m\" },\n autoref: { signature: \"s m\" },\n pageref: { signature: \"s m\" },\n autopageref: { signature: \"s m\" },\n pdfstringdef: { signature: \"m m\" },\n pdfbookmark: { signature: \"o m m\" },\n currentpdfbookmark: { signature: \"m m\" },\n subpdfbookmark: { signature: \"m m\" },\n belowpdfbookmark: { signature: \"m m\" },\n texorpdfstring: { signature: \"m m\" },\n thispdfpagelabel: { signature: \"m\" },\n hypercalcbp: { signature: \"m\" },\n};\n\nexport const environments: EnvInfoRecord = {};\n"],"names":[],"mappings":";;AAKO,MAAM,SAA0B;AAAA,EACnC,YAAY;AAAA,IACR,WAAW;AAAA,IACX,YAAY,EAAE,aAAa,MAAM,aAAa,KAAK;AAAA,EACvD;AAAA,EACA,MAAM,EAAE,WAAW,QAAQ;AAAA,EAC3B,KAAK,EAAE,WAAW,IAAI;AAAA,EACtB,WAAW,EAAE,WAAW,IAAI;AAAA,EAC5B,cAAc,EAAE,WAAW,IAAI;AAAA,EAC/B,YAAY,EAAE,WAAW,MAAM;AAAA,EAC/B,UAAU,EAAE,WAAW,QAAQ;AAAA,EAC/B,UAAU,EAAE,WAAW,MAAM;AAAA,EAC7B,WAAW,EAAE,WAAW,MAAM;AAAA,EAC9B,aAAa,EAAE,WAAW,MAAM;AAAA,EAChC,SAAS,EAAE,WAAW,MAAM;AAAA,EAC5B,SAAS,EAAE,WAAW,MAAM;AAAA,EAC5B,aAAa,EAAE,WAAW,MAAM;AAAA,EAChC,cAAc,EAAE,WAAW,MAAM;AAAA,EACjC,aAAa,EAAE,WAAW,QAAQ;AAAA,EAClC,oBAAoB,EAAE,WAAW,MAAM;AAAA,EACvC,gBAAgB,EAAE,WAAW,MAAM;AAAA,EACnC,kBAAkB,EAAE,WAAW,MAAM;AAAA,EACrC,gBAAgB,EAAE,WAAW,MAAM;AAAA,EACnC,kBAAkB,EAAE,WAAW,IAAI;AAAA,EACnC,aAAa,EAAE,WAAW,IAAI;AAClC;AAEO,MAAM,eAA8B,CAAA;;;"} \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-ctan/package/hyperref/index.d.ts b/node_modules/@unified-latex/unified-latex-ctan/package/hyperref/index.d.ts new file mode 100644 index 0000000..981b287 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-ctan/package/hyperref/index.d.ts @@ -0,0 +1,2 @@ +export * from './provides'; +//# sourceMappingURL=index.d.ts.map \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-ctan/package/hyperref/index.js b/node_modules/@unified-latex/unified-latex-ctan/package/hyperref/index.js new file mode 100644 index 0000000..f9352ee --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-ctan/package/hyperref/index.js @@ -0,0 +1,32 @@ +const macros = { + hypersetup: { + signature: "m", + renderInfo: { breakAround: true, pgfkeysArgs: true } + }, + href: { signature: "o m m" }, + url: { signature: "m" }, + nolinkurl: { signature: "m" }, + hyperbaseurl: { signature: "m" }, + hyperimage: { signature: "m m" }, + hyperdef: { signature: "m m m" }, + hyperref: { signature: "o m" }, + hyperlink: { signature: "m m" }, + hypertarget: { signature: "m m" }, + autoref: { signature: "s m" }, + pageref: { signature: "s m" }, + autopageref: { signature: "s m" }, + pdfstringdef: { signature: "m m" }, + pdfbookmark: { signature: "o m m" }, + currentpdfbookmark: { signature: "m m" }, + subpdfbookmark: { signature: "m m" }, + belowpdfbookmark: { signature: "m m" }, + texorpdfstring: { signature: "m m" }, + thispdfpagelabel: { signature: "m" }, + hypercalcbp: { signature: "m" } +}; +const environments = {}; +export { + environments, + macros +}; +//# sourceMappingURL=index.js.map diff --git a/node_modules/@unified-latex/unified-latex-ctan/package/hyperref/index.js.map b/node_modules/@unified-latex/unified-latex-ctan/package/hyperref/index.js.map new file mode 100644 index 0000000..d52d9e8 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-ctan/package/hyperref/index.js.map @@ -0,0 +1 @@ +{"version":3,"file":"index.js","sources":["../../../package/hyperref/provides.ts"],"sourcesContent":["import {\n MacroInfoRecord,\n EnvInfoRecord,\n} from \"@unified-latex/unified-latex-types\";\n\nexport const macros: MacroInfoRecord = {\n hypersetup: {\n signature: \"m\",\n renderInfo: { breakAround: true, pgfkeysArgs: true },\n },\n href: { signature: \"o m m\" },\n url: { signature: \"m\" },\n nolinkurl: { signature: \"m\" },\n hyperbaseurl: { signature: \"m\" },\n hyperimage: { signature: \"m m\" },\n hyperdef: { signature: \"m m m\" },\n hyperref: { signature: \"o m\" },\n hyperlink: { signature: \"m m\" },\n hypertarget: { signature: \"m m\" },\n autoref: { signature: \"s m\" },\n pageref: { signature: \"s m\" },\n autopageref: { signature: \"s m\" },\n pdfstringdef: { signature: \"m m\" },\n pdfbookmark: { signature: \"o m m\" },\n currentpdfbookmark: { signature: \"m m\" },\n subpdfbookmark: { signature: \"m m\" },\n belowpdfbookmark: { signature: \"m m\" },\n texorpdfstring: { signature: \"m m\" },\n thispdfpagelabel: { signature: \"m\" },\n hypercalcbp: { signature: \"m\" },\n};\n\nexport const environments: EnvInfoRecord = {};\n"],"names":[],"mappings":"AAKO,MAAM,SAA0B;AAAA,EACnC,YAAY;AAAA,IACR,WAAW;AAAA,IACX,YAAY,EAAE,aAAa,MAAM,aAAa,KAAK;AAAA,EACvD;AAAA,EACA,MAAM,EAAE,WAAW,QAAQ;AAAA,EAC3B,KAAK,EAAE,WAAW,IAAI;AAAA,EACtB,WAAW,EAAE,WAAW,IAAI;AAAA,EAC5B,cAAc,EAAE,WAAW,IAAI;AAAA,EAC/B,YAAY,EAAE,WAAW,MAAM;AAAA,EAC/B,UAAU,EAAE,WAAW,QAAQ;AAAA,EAC/B,UAAU,EAAE,WAAW,MAAM;AAAA,EAC7B,WAAW,EAAE,WAAW,MAAM;AAAA,EAC9B,aAAa,EAAE,WAAW,MAAM;AAAA,EAChC,SAAS,EAAE,WAAW,MAAM;AAAA,EAC5B,SAAS,EAAE,WAAW,MAAM;AAAA,EAC5B,aAAa,EAAE,WAAW,MAAM;AAAA,EAChC,cAAc,EAAE,WAAW,MAAM;AAAA,EACjC,aAAa,EAAE,WAAW,QAAQ;AAAA,EAClC,oBAAoB,EAAE,WAAW,MAAM;AAAA,EACvC,gBAAgB,EAAE,WAAW,MAAM;AAAA,EACnC,kBAAkB,EAAE,WAAW,MAAM;AAAA,EACrC,gBAAgB,EAAE,WAAW,MAAM;AAAA,EACnC,kBAAkB,EAAE,WAAW,IAAI;AAAA,EACnC,aAAa,EAAE,WAAW,IAAI;AAClC;AAEO,MAAM,eAA8B,CAAA;"} \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-ctan/package/hyperref/provides.d.ts b/node_modules/@unified-latex/unified-latex-ctan/package/hyperref/provides.d.ts new file mode 100644 index 0000000..88c6521 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-ctan/package/hyperref/provides.d.ts @@ -0,0 +1,4 @@ +import { MacroInfoRecord, EnvInfoRecord } from '@unified-latex/unified-latex-types'; +export declare const macros: MacroInfoRecord; +export declare const environments: EnvInfoRecord; +//# sourceMappingURL=provides.d.ts.map \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-ctan/package/latex2e/index.cjs b/node_modules/@unified-latex/unified-latex-ctan/package/latex2e/index.cjs new file mode 100644 index 0000000..bf0ea17 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-ctan/package/latex2e/index.cjs @@ -0,0 +1,6 @@ +"use strict"; +Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" }); +const provides = require("../../provides-DdQzqlsT.cjs"); +exports.environments = provides.environments; +exports.macros = provides.macros; +//# sourceMappingURL=index.cjs.map diff --git a/node_modules/@unified-latex/unified-latex-ctan/package/latex2e/index.cjs.map b/node_modules/@unified-latex/unified-latex-ctan/package/latex2e/index.cjs.map new file mode 100644 index 0000000..5f0f93e --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-ctan/package/latex2e/index.cjs.map @@ -0,0 +1 @@ +{"version":3,"file":"index.cjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;"} \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-ctan/package/latex2e/index.d.ts b/node_modules/@unified-latex/unified-latex-ctan/package/latex2e/index.d.ts new file mode 100644 index 0000000..981b287 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-ctan/package/latex2e/index.d.ts @@ -0,0 +1,2 @@ +export * from './provides'; +//# sourceMappingURL=index.d.ts.map \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-ctan/package/latex2e/index.js b/node_modules/@unified-latex/unified-latex-ctan/package/latex2e/index.js new file mode 100644 index 0000000..f0da88c --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-ctan/package/latex2e/index.js @@ -0,0 +1,6 @@ +import { e, m } from "../../provides-BUHzyq9A.js"; +export { + e as environments, + m as macros +}; +//# sourceMappingURL=index.js.map diff --git a/node_modules/@unified-latex/unified-latex-ctan/package/latex2e/index.js.map b/node_modules/@unified-latex/unified-latex-ctan/package/latex2e/index.js.map new file mode 100644 index 0000000..594ae09 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-ctan/package/latex2e/index.js.map @@ -0,0 +1 @@ +{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";"} \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-ctan/package/latex2e/provides.d.ts b/node_modules/@unified-latex/unified-latex-ctan/package/latex2e/provides.d.ts new file mode 100644 index 0000000..88c6521 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-ctan/package/latex2e/provides.d.ts @@ -0,0 +1,4 @@ +import { MacroInfoRecord, EnvInfoRecord } from '@unified-latex/unified-latex-types'; +export declare const macros: MacroInfoRecord; +export declare const environments: EnvInfoRecord; +//# sourceMappingURL=provides.d.ts.map \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-ctan/package/listings/index.cjs b/node_modules/@unified-latex/unified-latex-ctan/package/listings/index.cjs new file mode 100644 index 0000000..21808b2 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-ctan/package/listings/index.cjs @@ -0,0 +1,6 @@ +"use strict"; +Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" }); +const provides = require("../../provides-BjJALsf_.cjs"); +exports.environments = provides.environments; +exports.macros = provides.macros; +//# sourceMappingURL=index.cjs.map diff --git a/node_modules/@unified-latex/unified-latex-ctan/package/listings/index.cjs.map b/node_modules/@unified-latex/unified-latex-ctan/package/listings/index.cjs.map new file mode 100644 index 0000000..5f0f93e --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-ctan/package/listings/index.cjs.map @@ -0,0 +1 @@ +{"version":3,"file":"index.cjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;"} \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-ctan/package/listings/index.d.ts b/node_modules/@unified-latex/unified-latex-ctan/package/listings/index.d.ts new file mode 100644 index 0000000..981b287 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-ctan/package/listings/index.d.ts @@ -0,0 +1,2 @@ +export * from './provides'; +//# sourceMappingURL=index.d.ts.map \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-ctan/package/listings/index.js b/node_modules/@unified-latex/unified-latex-ctan/package/listings/index.js new file mode 100644 index 0000000..79a3b6c --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-ctan/package/listings/index.js @@ -0,0 +1,6 @@ +import { e, m } from "../../provides-Ch0mvkO_.js"; +export { + e as environments, + m as macros +}; +//# sourceMappingURL=index.js.map diff --git a/node_modules/@unified-latex/unified-latex-ctan/package/listings/index.js.map b/node_modules/@unified-latex/unified-latex-ctan/package/listings/index.js.map new file mode 100644 index 0000000..594ae09 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-ctan/package/listings/index.js.map @@ -0,0 +1 @@ +{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";"} \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-ctan/package/listings/libs/argument-parser.d.ts b/node_modules/@unified-latex/unified-latex-ctan/package/listings/libs/argument-parser.d.ts new file mode 100644 index 0000000..ef07baa --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-ctan/package/listings/libs/argument-parser.d.ts @@ -0,0 +1,8 @@ +import { ArgumentParser } from '@unified-latex/unified-latex-types'; +/** + * This argument parser parses arguments in the form of + * - [⟨key=value list⟩]⟨character⟩⟨source code⟩⟨same character⟩ + * - [⟨key=value list⟩]{⟨source code⟩} + */ +export declare const argumentParser: ArgumentParser; +//# sourceMappingURL=argument-parser.d.ts.map \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-ctan/package/listings/provides.d.ts b/node_modules/@unified-latex/unified-latex-ctan/package/listings/provides.d.ts new file mode 100644 index 0000000..88c6521 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-ctan/package/listings/provides.d.ts @@ -0,0 +1,4 @@ +import { MacroInfoRecord, EnvInfoRecord } from '@unified-latex/unified-latex-types'; +export declare const macros: MacroInfoRecord; +export declare const environments: EnvInfoRecord; +//# sourceMappingURL=provides.d.ts.map \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-ctan/package/makeidx/index.cjs b/node_modules/@unified-latex/unified-latex-ctan/package/makeidx/index.cjs new file mode 100644 index 0000000..a613609 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-ctan/package/makeidx/index.cjs @@ -0,0 +1,13 @@ +"use strict"; +Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" }); +const macros = { + see: { signature: "m m" }, + seealso: { signature: "m m" }, + seename: { signature: "m" }, + alsoname: { signature: "m" }, + index: { signature: "m" } +}; +const environments = {}; +exports.environments = environments; +exports.macros = macros; +//# sourceMappingURL=index.cjs.map diff --git a/node_modules/@unified-latex/unified-latex-ctan/package/makeidx/index.cjs.map b/node_modules/@unified-latex/unified-latex-ctan/package/makeidx/index.cjs.map new file mode 100644 index 0000000..8e0feab --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-ctan/package/makeidx/index.cjs.map @@ -0,0 +1 @@ +{"version":3,"file":"index.cjs","sources":["../../../package/makeidx/provides.ts"],"sourcesContent":["import {\n MacroInfoRecord,\n EnvInfoRecord,\n} from \"@unified-latex/unified-latex-types\";\n\nexport const macros: MacroInfoRecord = {\n see: { signature: \"m m\" },\n seealso: { signature: \"m m\" },\n seename: { signature: \"m\" },\n alsoname: { signature: \"m\" },\n index: { signature: \"m\" },\n};\n\nexport const environments: EnvInfoRecord = {};\n"],"names":[],"mappings":";;AAKO,MAAM,SAA0B;AAAA,EACnC,KAAK,EAAE,WAAW,MAAM;AAAA,EACxB,SAAS,EAAE,WAAW,MAAM;AAAA,EAC5B,SAAS,EAAE,WAAW,IAAI;AAAA,EAC1B,UAAU,EAAE,WAAW,IAAI;AAAA,EAC3B,OAAO,EAAE,WAAW,IAAI;AAC5B;AAEO,MAAM,eAA8B,CAAA;;;"} \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-ctan/package/makeidx/index.d.ts b/node_modules/@unified-latex/unified-latex-ctan/package/makeidx/index.d.ts new file mode 100644 index 0000000..981b287 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-ctan/package/makeidx/index.d.ts @@ -0,0 +1,2 @@ +export * from './provides'; +//# sourceMappingURL=index.d.ts.map \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-ctan/package/makeidx/index.js b/node_modules/@unified-latex/unified-latex-ctan/package/makeidx/index.js new file mode 100644 index 0000000..ba89487 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-ctan/package/makeidx/index.js @@ -0,0 +1,13 @@ +const macros = { + see: { signature: "m m" }, + seealso: { signature: "m m" }, + seename: { signature: "m" }, + alsoname: { signature: "m" }, + index: { signature: "m" } +}; +const environments = {}; +export { + environments, + macros +}; +//# sourceMappingURL=index.js.map diff --git a/node_modules/@unified-latex/unified-latex-ctan/package/makeidx/index.js.map b/node_modules/@unified-latex/unified-latex-ctan/package/makeidx/index.js.map new file mode 100644 index 0000000..d3fcb35 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-ctan/package/makeidx/index.js.map @@ -0,0 +1 @@ +{"version":3,"file":"index.js","sources":["../../../package/makeidx/provides.ts"],"sourcesContent":["import {\n MacroInfoRecord,\n EnvInfoRecord,\n} from \"@unified-latex/unified-latex-types\";\n\nexport const macros: MacroInfoRecord = {\n see: { signature: \"m m\" },\n seealso: { signature: \"m m\" },\n seename: { signature: \"m\" },\n alsoname: { signature: \"m\" },\n index: { signature: \"m\" },\n};\n\nexport const environments: EnvInfoRecord = {};\n"],"names":[],"mappings":"AAKO,MAAM,SAA0B;AAAA,EACnC,KAAK,EAAE,WAAW,MAAM;AAAA,EACxB,SAAS,EAAE,WAAW,MAAM;AAAA,EAC5B,SAAS,EAAE,WAAW,IAAI;AAAA,EAC1B,UAAU,EAAE,WAAW,IAAI;AAAA,EAC3B,OAAO,EAAE,WAAW,IAAI;AAC5B;AAEO,MAAM,eAA8B,CAAA;"} \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-ctan/package/makeidx/provides.d.ts b/node_modules/@unified-latex/unified-latex-ctan/package/makeidx/provides.d.ts new file mode 100644 index 0000000..88c6521 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-ctan/package/makeidx/provides.d.ts @@ -0,0 +1,4 @@ +import { MacroInfoRecord, EnvInfoRecord } from '@unified-latex/unified-latex-types'; +export declare const macros: MacroInfoRecord; +export declare const environments: EnvInfoRecord; +//# sourceMappingURL=provides.d.ts.map \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-ctan/package/mathtools/index.cjs b/node_modules/@unified-latex/unified-latex-ctan/package/mathtools/index.cjs new file mode 100644 index 0000000..a16f5ce --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-ctan/package/mathtools/index.cjs @@ -0,0 +1,217 @@ +"use strict"; +Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" }); +const macros = { + mathtoolsset: { + signature: "m", + renderInfo: { breakAround: true, pgfkeysArgs: true } + }, + mathllap: { + signature: "o m" + }, + mathrlap: { + signature: "o m" + }, + mathclap: { + signature: "o m" + }, + clap: { + signature: "m" + }, + mathmbox: { + signature: "m" + }, + mathmakebox: { + signature: "o o m" + }, + cramped: { + signature: "o m" + }, + crampedllap: { + signature: "o m" + }, + crampedrlap: { + signature: "o m" + }, + crampedclap: { + signature: "o m" + }, + crampedsubstack: { + signature: "o m" + }, + smashoperator: { + signature: "o m" + }, + newtagform: { + signature: "m o m m" + }, + renewtagform: { + signature: "m o m m" + }, + usetagform: { + signature: "m" + }, + xleftrightarrow: { signature: "o m" }, + xLeftarrow: { signature: "o m" }, + xhookleftarrow: { signature: "o m" }, + xmapsto: { signature: "o m" }, + xRightarrow: { signature: "o m" }, + xLeftrightarrow: { signature: "o m" }, + xhookrightarrow: { signature: "o m" }, + underbracket: { signature: "o o m" }, + overbracket: { signature: "o o m" }, + underbrace: { signature: "m" }, + overbrace: { signature: "m" }, + shoveleft: { signature: "o m" }, + shoveright: { signature: "o m" }, + ArrowBetweenLines: { signature: "s o" }, + vdotswithin: { signature: "m" }, + shortdotswithin: { signature: "s m" }, + DeclarePairedDelimiter: { + signature: "m m m", + renderInfo: { breakAround: true } + }, + DeclarePairedDelimiterX: { + signature: "m o m m m", + renderInfo: { breakAround: true } + }, + DeclarePairedDelimiterXPP: { + signature: "m o m m m m m", + renderInfo: { breakAround: true } + }, + prescript: { signature: "m m m" }, + DeclareMathSizes: { signature: "m m m m" }, + newgathered: { signature: "m m m m" }, + renewgathered: { signature: "m m m m" }, + splitfrac: { signature: "m m" }, + splitdfrac: { signature: "m m" }, + xmathstrut: { signature: "o m" }, + // amsthm + newtheorem: { signature: "s m o m o", renderInfo: { breakAround: true } }, + theoremstyle: { signature: "m", renderInfo: { breakAround: true } }, + newtheoremstyle: { + signature: "m m m m m m m m m", + renderInfo: { breakAround: true } + }, + // amsmath + text: { signature: "m", renderInfo: { inMathMode: false } }, + // amsfonts + mathbb: { signature: "m" }, + mathscr: { signature: "m" }, + mathfrak: { signature: "m" }, + frak: { signature: "m" }, + Bdd: { signature: "m" }, + bold: { signature: "m" }, + // amsopn + operatorname: { signature: "s m" }, + DeclareMathOperator: { + signature: "s m m", + renderInfo: { breakAround: true } + } +}; +const environments = { + crampedsubarray: { + signature: "m", + renderInfo: { alignContent: true, inMathMode: true } + }, + matrix: { renderInfo: { alignContent: true, inMathMode: true } }, + bmatrix: { renderInfo: { alignContent: true, inMathMode: true } }, + pmatrix: { renderInfo: { alignContent: true, inMathMode: true } }, + vmatrix: { renderInfo: { alignContent: true, inMathMode: true } }, + Bmatrix: { renderInfo: { alignContent: true, inMathMode: true } }, + Vmatrix: { renderInfo: { alignContent: true, inMathMode: true } }, + smallmatrix: { renderInfo: { alignContent: true, inMathMode: true } }, + psmallmatrix: { renderInfo: { alignContent: true, inMathMode: true } }, + vsmallmatrix: { renderInfo: { alignContent: true, inMathMode: true } }, + bsmallmatrix: { renderInfo: { alignContent: true, inMathMode: true } }, + Bsmallmatrix: { renderInfo: { alignContent: true, inMathMode: true } }, + Vsmallmatrix: { renderInfo: { alignContent: true, inMathMode: true } }, + "matrix*": { + signature: "o", + renderInfo: { alignContent: true, inMathMode: true } + }, + "bmatrix*": { + signature: "o", + renderInfo: { alignContent: true, inMathMode: true } + }, + "pmatrix*": { + signature: "o", + renderInfo: { alignContent: true, inMathMode: true } + }, + "vmatrix*": { + signature: "o", + renderInfo: { alignContent: true, inMathMode: true } + }, + "Bmatrix*": { + signature: "o", + renderInfo: { alignContent: true, inMathMode: true } + }, + "Vmatrix*": { + signature: "o", + renderInfo: { alignContent: true, inMathMode: true } + }, + "smallmatrix*": { + signature: "o", + renderInfo: { alignContent: true, inMathMode: true } + }, + "psmallmatrix*": { + signature: "o", + renderInfo: { alignContent: true, inMathMode: true } + }, + "bsmallmatrix*": { + signature: "o", + renderInfo: { alignContent: true, inMathMode: true } + }, + "vsmallmatrix*": { + signature: "o", + renderInfo: { alignContent: true, inMathMode: true } + }, + "Bsmallmatrix*": { + signature: "o", + renderInfo: { alignContent: true, inMathMode: true } + }, + "Vsmallmatrix*": { + signature: "o", + renderInfo: { alignContent: true, inMathMode: true } + }, + multilined: { signature: "o o", renderInfo: { inMathMode: true } }, + cases: { renderInfo: { alignContent: true, inMathMode: true } }, + "cases*": { renderInfo: { alignContent: true, inMathMode: true } }, + dcases: { renderInfo: { alignContent: true, inMathMode: true } }, + "dcases*": { renderInfo: { alignContent: true, inMathMode: true } }, + rcases: { renderInfo: { alignContent: true, inMathMode: true } }, + "rcases*": { renderInfo: { alignContent: true, inMathMode: true } }, + drcases: { renderInfo: { alignContent: true, inMathMode: true } }, + "drcases*": { renderInfo: { alignContent: true, inMathMode: true } }, + spreadlines: { signature: "m", renderInfo: { inMathMode: true } }, + lgathered: { signature: "o", renderInfo: { inMathMode: true } }, + rgathered: { signature: "o", renderInfo: { inMathMode: true } }, + // amsmath + "align*": { renderInfo: { inMathMode: true, alignContent: true } }, + align: { renderInfo: { inMathMode: true, alignContent: true } }, + aligned: { renderInfo: { inMathMode: true, alignContent: true } }, + "alignat*": { renderInfo: { inMathMode: true, alignContent: true } }, + alignat: { renderInfo: { inMathMode: true, alignContent: true } }, + "equation*": { renderInfo: { inMathMode: true } }, + equation: { renderInfo: { inMathMode: true } }, + "gather*": { renderInfo: { inMathMode: true } }, + gather: { renderInfo: { inMathMode: true } }, + "multline*": { renderInfo: { inMathMode: true } }, + multline: { renderInfo: { inMathMode: true } }, + "flalign*": { renderInfo: { inMathMode: true, alignContent: true } }, + flalign: { renderInfo: { inMathMode: true, alignContent: true } }, + split: { renderInfo: { inMathMode: true } }, + // Math environments + displaymath: { renderInfo: { inMathMode: true } }, + // Typical amsthm environments + theorem: { signature: "o" }, + lemma: { signature: "o" }, + definition: { signature: "o" }, + proposition: { signature: "o" }, + corollary: { signature: "o" }, + remark: { signature: "!o" }, + example: { signature: "!o" }, + proof: { signature: "o" } +}; +exports.environments = environments; +exports.macros = macros; +//# sourceMappingURL=index.cjs.map diff --git a/node_modules/@unified-latex/unified-latex-ctan/package/mathtools/index.cjs.map b/node_modules/@unified-latex/unified-latex-ctan/package/mathtools/index.cjs.map new file mode 100644 index 0000000..57d593a --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-ctan/package/mathtools/index.cjs.map @@ -0,0 +1 @@ +{"version":3,"file":"index.cjs","sources":["../../../package/mathtools/provides.ts"],"sourcesContent":["import {\n MacroInfoRecord,\n EnvInfoRecord,\n} from \"@unified-latex/unified-latex-types\";\n\nexport const macros: MacroInfoRecord = {\n mathtoolsset: {\n signature: \"m\",\n renderInfo: { breakAround: true, pgfkeysArgs: true },\n },\n mathllap: {\n signature: \"o m\",\n },\n mathrlap: {\n signature: \"o m\",\n },\n mathclap: {\n signature: \"o m\",\n },\n clap: {\n signature: \"m\",\n },\n mathmbox: {\n signature: \"m\",\n },\n mathmakebox: {\n signature: \"o o m\",\n },\n cramped: {\n signature: \"o m\",\n },\n crampedllap: {\n signature: \"o m\",\n },\n crampedrlap: {\n signature: \"o m\",\n },\n crampedclap: {\n signature: \"o m\",\n },\n crampedsubstack: {\n signature: \"o m\",\n },\n smashoperator: {\n signature: \"o m\",\n },\n newtagform: {\n signature: \"m o m m\",\n },\n renewtagform: {\n signature: \"m o m m\",\n },\n usetagform: {\n signature: \"m\",\n },\n xleftrightarrow: { signature: \"o m\" },\n xLeftarrow: { signature: \"o m\" },\n xhookleftarrow: { signature: \"o m\" },\n xmapsto: { signature: \"o m\" },\n xRightarrow: { signature: \"o m\" },\n xLeftrightarrow: { signature: \"o m\" },\n xhookrightarrow: { signature: \"o m\" },\n underbracket: { signature: \"o o m\" },\n overbracket: { signature: \"o o m\" },\n underbrace: { signature: \"m\" },\n overbrace: { signature: \"m\" },\n shoveleft: { signature: \"o m\" },\n shoveright: { signature: \"o m\" },\n ArrowBetweenLines: { signature: \"s o\" },\n vdotswithin: { signature: \"m\" },\n shortdotswithin: { signature: \"s m\" },\n DeclarePairedDelimiter: {\n signature: \"m m m\",\n renderInfo: { breakAround: true },\n },\n DeclarePairedDelimiterX: {\n signature: \"m o m m m\",\n renderInfo: { breakAround: true },\n },\n DeclarePairedDelimiterXPP: {\n signature: \"m o m m m m m\",\n renderInfo: { breakAround: true },\n },\n prescript: { signature: \"m m m\" },\n DeclareMathSizes: { signature: \"m m m m\" },\n newgathered: { signature: \"m m m m\" },\n renewgathered: { signature: \"m m m m\" },\n splitfrac: { signature: \"m m\" },\n splitdfrac: { signature: \"m m\" },\n xmathstrut: { signature: \"o m\" },\n // amsthm\n newtheorem: { signature: \"s m o m o\", renderInfo: { breakAround: true } },\n theoremstyle: { signature: \"m\", renderInfo: { breakAround: true } },\n newtheoremstyle: {\n signature: \"m m m m m m m m m\",\n renderInfo: { breakAround: true },\n },\n // amsmath\n text: { signature: \"m\", renderInfo: { inMathMode: false } },\n // amsfonts\n mathbb: { signature: \"m\" },\n mathscr: { signature: \"m\" },\n mathfrak: { signature: \"m\" },\n frak: { signature: \"m\" },\n Bdd: { signature: \"m\" },\n bold: { signature: \"m\" },\n // amsopn\n operatorname: { signature: \"s m\" },\n DeclareMathOperator: {\n signature: \"s m m\",\n renderInfo: { breakAround: true },\n },\n};\n\nexport const environments: EnvInfoRecord = {\n crampedsubarray: {\n signature: \"m\",\n renderInfo: { alignContent: true, inMathMode: true },\n },\n matrix: { renderInfo: { alignContent: true, inMathMode: true } },\n bmatrix: { renderInfo: { alignContent: true, inMathMode: true } },\n pmatrix: { renderInfo: { alignContent: true, inMathMode: true } },\n vmatrix: { renderInfo: { alignContent: true, inMathMode: true } },\n Bmatrix: { renderInfo: { alignContent: true, inMathMode: true } },\n Vmatrix: { renderInfo: { alignContent: true, inMathMode: true } },\n smallmatrix: { renderInfo: { alignContent: true, inMathMode: true } },\n psmallmatrix: { renderInfo: { alignContent: true, inMathMode: true } },\n vsmallmatrix: { renderInfo: { alignContent: true, inMathMode: true } },\n bsmallmatrix: { renderInfo: { alignContent: true, inMathMode: true } },\n Bsmallmatrix: { renderInfo: { alignContent: true, inMathMode: true } },\n Vsmallmatrix: { renderInfo: { alignContent: true, inMathMode: true } },\n \"matrix*\": {\n signature: \"o\",\n renderInfo: { alignContent: true, inMathMode: true },\n },\n \"bmatrix*\": {\n signature: \"o\",\n renderInfo: { alignContent: true, inMathMode: true },\n },\n \"pmatrix*\": {\n signature: \"o\",\n renderInfo: { alignContent: true, inMathMode: true },\n },\n \"vmatrix*\": {\n signature: \"o\",\n renderInfo: { alignContent: true, inMathMode: true },\n },\n \"Bmatrix*\": {\n signature: \"o\",\n renderInfo: { alignContent: true, inMathMode: true },\n },\n \"Vmatrix*\": {\n signature: \"o\",\n renderInfo: { alignContent: true, inMathMode: true },\n },\n \"smallmatrix*\": {\n signature: \"o\",\n renderInfo: { alignContent: true, inMathMode: true },\n },\n \"psmallmatrix*\": {\n signature: \"o\",\n renderInfo: { alignContent: true, inMathMode: true },\n },\n \"bsmallmatrix*\": {\n signature: \"o\",\n renderInfo: { alignContent: true, inMathMode: true },\n },\n \"vsmallmatrix*\": {\n signature: \"o\",\n renderInfo: { alignContent: true, inMathMode: true },\n },\n \"Bsmallmatrix*\": {\n signature: \"o\",\n renderInfo: { alignContent: true, inMathMode: true },\n },\n \"Vsmallmatrix*\": {\n signature: \"o\",\n renderInfo: { alignContent: true, inMathMode: true },\n },\n multilined: { signature: \"o o\", renderInfo: { inMathMode: true } },\n cases: { renderInfo: { alignContent: true, inMathMode: true } },\n \"cases*\": { renderInfo: { alignContent: true, inMathMode: true } },\n dcases: { renderInfo: { alignContent: true, inMathMode: true } },\n \"dcases*\": { renderInfo: { alignContent: true, inMathMode: true } },\n rcases: { renderInfo: { alignContent: true, inMathMode: true } },\n \"rcases*\": { renderInfo: { alignContent: true, inMathMode: true } },\n drcases: { renderInfo: { alignContent: true, inMathMode: true } },\n \"drcases*\": { renderInfo: { alignContent: true, inMathMode: true } },\n spreadlines: { signature: \"m\", renderInfo: { inMathMode: true } },\n lgathered: { signature: \"o\", renderInfo: { inMathMode: true } },\n rgathered: { signature: \"o\", renderInfo: { inMathMode: true } },\n // amsmath\n \"align*\": { renderInfo: { inMathMode: true, alignContent: true } },\n align: { renderInfo: { inMathMode: true, alignContent: true } },\n aligned: { renderInfo: { inMathMode: true, alignContent: true } },\n \"alignat*\": { renderInfo: { inMathMode: true, alignContent: true } },\n alignat: { renderInfo: { inMathMode: true, alignContent: true } },\n \"equation*\": { renderInfo: { inMathMode: true } },\n equation: { renderInfo: { inMathMode: true } },\n \"gather*\": { renderInfo: { inMathMode: true } },\n gather: { renderInfo: { inMathMode: true } },\n \"multline*\": { renderInfo: { inMathMode: true } },\n multline: { renderInfo: { inMathMode: true } },\n \"flalign*\": { renderInfo: { inMathMode: true, alignContent: true } },\n flalign: { renderInfo: { inMathMode: true, alignContent: true } },\n split: { renderInfo: { inMathMode: true } },\n // Math environments\n displaymath: { renderInfo: { inMathMode: true } },\n // Typical amsthm environments\n theorem: { signature: \"o\" },\n lemma: { signature: \"o\" },\n definition: { signature: \"o\" },\n proposition: { signature: \"o\" },\n corollary: { signature: \"o\" },\n remark: { signature: \"!o\" },\n example: { signature: \"!o\" },\n proof: { signature: \"o\" },\n};\n"],"names":[],"mappings":"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"} \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-ctan/package/mathtools/index.d.ts b/node_modules/@unified-latex/unified-latex-ctan/package/mathtools/index.d.ts new file mode 100644 index 0000000..981b287 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-ctan/package/mathtools/index.d.ts @@ -0,0 +1,2 @@ +export * from './provides'; +//# sourceMappingURL=index.d.ts.map \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-ctan/package/mathtools/index.js b/node_modules/@unified-latex/unified-latex-ctan/package/mathtools/index.js new file mode 100644 index 0000000..024649d --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-ctan/package/mathtools/index.js @@ -0,0 +1,217 @@ +const macros = { + mathtoolsset: { + signature: "m", + renderInfo: { breakAround: true, pgfkeysArgs: true } + }, + mathllap: { + signature: "o m" + }, + mathrlap: { + signature: "o m" + }, + mathclap: { + signature: "o m" + }, + clap: { + signature: "m" + }, + mathmbox: { + signature: "m" + }, + mathmakebox: { + signature: "o o m" + }, + cramped: { + signature: "o m" + }, + crampedllap: { + signature: "o m" + }, + crampedrlap: { + signature: "o m" + }, + crampedclap: { + signature: "o m" + }, + crampedsubstack: { + signature: "o m" + }, + smashoperator: { + signature: "o m" + }, + newtagform: { + signature: "m o m m" + }, + renewtagform: { + signature: "m o m m" + }, + usetagform: { + signature: "m" + }, + xleftrightarrow: { signature: "o m" }, + xLeftarrow: { signature: "o m" }, + xhookleftarrow: { signature: "o m" }, + xmapsto: { signature: "o m" }, + xRightarrow: { signature: "o m" }, + xLeftrightarrow: { signature: "o m" }, + xhookrightarrow: { signature: "o m" }, + underbracket: { signature: "o o m" }, + overbracket: { signature: "o o m" }, + underbrace: { signature: "m" }, + overbrace: { signature: "m" }, + shoveleft: { signature: "o m" }, + shoveright: { signature: "o m" }, + ArrowBetweenLines: { signature: "s o" }, + vdotswithin: { signature: "m" }, + shortdotswithin: { signature: "s m" }, + DeclarePairedDelimiter: { + signature: "m m m", + renderInfo: { breakAround: true } + }, + DeclarePairedDelimiterX: { + signature: "m o m m m", + renderInfo: { breakAround: true } + }, + DeclarePairedDelimiterXPP: { + signature: "m o m m m m m", + renderInfo: { breakAround: true } + }, + prescript: { signature: "m m m" }, + DeclareMathSizes: { signature: "m m m m" }, + newgathered: { signature: "m m m m" }, + renewgathered: { signature: "m m m m" }, + splitfrac: { signature: "m m" }, + splitdfrac: { signature: "m m" }, + xmathstrut: { signature: "o m" }, + // amsthm + newtheorem: { signature: "s m o m o", renderInfo: { breakAround: true } }, + theoremstyle: { signature: "m", renderInfo: { breakAround: true } }, + newtheoremstyle: { + signature: "m m m m m m m m m", + renderInfo: { breakAround: true } + }, + // amsmath + text: { signature: "m", renderInfo: { inMathMode: false } }, + // amsfonts + mathbb: { signature: "m" }, + mathscr: { signature: "m" }, + mathfrak: { signature: "m" }, + frak: { signature: "m" }, + Bdd: { signature: "m" }, + bold: { signature: "m" }, + // amsopn + operatorname: { signature: "s m" }, + DeclareMathOperator: { + signature: "s m m", + renderInfo: { breakAround: true } + } +}; +const environments = { + crampedsubarray: { + signature: "m", + renderInfo: { alignContent: true, inMathMode: true } + }, + matrix: { renderInfo: { alignContent: true, inMathMode: true } }, + bmatrix: { renderInfo: { alignContent: true, inMathMode: true } }, + pmatrix: { renderInfo: { alignContent: true, inMathMode: true } }, + vmatrix: { renderInfo: { alignContent: true, inMathMode: true } }, + Bmatrix: { renderInfo: { alignContent: true, inMathMode: true } }, + Vmatrix: { renderInfo: { alignContent: true, inMathMode: true } }, + smallmatrix: { renderInfo: { alignContent: true, inMathMode: true } }, + psmallmatrix: { renderInfo: { alignContent: true, inMathMode: true } }, + vsmallmatrix: { renderInfo: { alignContent: true, inMathMode: true } }, + bsmallmatrix: { renderInfo: { alignContent: true, inMathMode: true } }, + Bsmallmatrix: { renderInfo: { alignContent: true, inMathMode: true } }, + Vsmallmatrix: { renderInfo: { alignContent: true, inMathMode: true } }, + "matrix*": { + signature: "o", + renderInfo: { alignContent: true, inMathMode: true } + }, + "bmatrix*": { + signature: "o", + renderInfo: { alignContent: true, inMathMode: true } + }, + "pmatrix*": { + signature: "o", + renderInfo: { alignContent: true, inMathMode: true } + }, + "vmatrix*": { + signature: "o", + renderInfo: { alignContent: true, inMathMode: true } + }, + "Bmatrix*": { + signature: "o", + renderInfo: { alignContent: true, inMathMode: true } + }, + "Vmatrix*": { + signature: "o", + renderInfo: { alignContent: true, inMathMode: true } + }, + "smallmatrix*": { + signature: "o", + renderInfo: { alignContent: true, inMathMode: true } + }, + "psmallmatrix*": { + signature: "o", + renderInfo: { alignContent: true, inMathMode: true } + }, + "bsmallmatrix*": { + signature: "o", + renderInfo: { alignContent: true, inMathMode: true } + }, + "vsmallmatrix*": { + signature: "o", + renderInfo: { alignContent: true, inMathMode: true } + }, + "Bsmallmatrix*": { + signature: "o", + renderInfo: { alignContent: true, inMathMode: true } + }, + "Vsmallmatrix*": { + signature: "o", + renderInfo: { alignContent: true, inMathMode: true } + }, + multilined: { signature: "o o", renderInfo: { inMathMode: true } }, + cases: { renderInfo: { alignContent: true, inMathMode: true } }, + "cases*": { renderInfo: { alignContent: true, inMathMode: true } }, + dcases: { renderInfo: { alignContent: true, inMathMode: true } }, + "dcases*": { renderInfo: { alignContent: true, inMathMode: true } }, + rcases: { renderInfo: { alignContent: true, inMathMode: true } }, + "rcases*": { renderInfo: { alignContent: true, inMathMode: true } }, + drcases: { renderInfo: { alignContent: true, inMathMode: true } }, + "drcases*": { renderInfo: { alignContent: true, inMathMode: true } }, + spreadlines: { signature: "m", renderInfo: { inMathMode: true } }, + lgathered: { signature: "o", renderInfo: { inMathMode: true } }, + rgathered: { signature: "o", renderInfo: { inMathMode: true } }, + // amsmath + "align*": { renderInfo: { inMathMode: true, alignContent: true } }, + align: { renderInfo: { inMathMode: true, alignContent: true } }, + aligned: { renderInfo: { inMathMode: true, alignContent: true } }, + "alignat*": { renderInfo: { inMathMode: true, alignContent: true } }, + alignat: { renderInfo: { inMathMode: true, alignContent: true } }, + "equation*": { renderInfo: { inMathMode: true } }, + equation: { renderInfo: { inMathMode: true } }, + "gather*": { renderInfo: { inMathMode: true } }, + gather: { renderInfo: { inMathMode: true } }, + "multline*": { renderInfo: { inMathMode: true } }, + multline: { renderInfo: { inMathMode: true } }, + "flalign*": { renderInfo: { inMathMode: true, alignContent: true } }, + flalign: { renderInfo: { inMathMode: true, alignContent: true } }, + split: { renderInfo: { inMathMode: true } }, + // Math environments + displaymath: { renderInfo: { inMathMode: true } }, + // Typical amsthm environments + theorem: { signature: "o" }, + lemma: { signature: "o" }, + definition: { signature: "o" }, + proposition: { signature: "o" }, + corollary: { signature: "o" }, + remark: { signature: "!o" }, + example: { signature: "!o" }, + proof: { signature: "o" } +}; +export { + environments, + macros +}; +//# sourceMappingURL=index.js.map diff --git a/node_modules/@unified-latex/unified-latex-ctan/package/mathtools/index.js.map b/node_modules/@unified-latex/unified-latex-ctan/package/mathtools/index.js.map new file mode 100644 index 0000000..985bce8 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-ctan/package/mathtools/index.js.map @@ -0,0 +1 @@ +{"version":3,"file":"index.js","sources":["../../../package/mathtools/provides.ts"],"sourcesContent":["import {\n MacroInfoRecord,\n EnvInfoRecord,\n} from \"@unified-latex/unified-latex-types\";\n\nexport const macros: MacroInfoRecord = {\n mathtoolsset: {\n signature: \"m\",\n renderInfo: { breakAround: true, pgfkeysArgs: true },\n },\n mathllap: {\n signature: \"o m\",\n },\n mathrlap: {\n signature: \"o m\",\n },\n mathclap: {\n signature: \"o m\",\n },\n clap: {\n signature: \"m\",\n },\n mathmbox: {\n signature: \"m\",\n },\n mathmakebox: {\n signature: \"o o m\",\n },\n cramped: {\n signature: \"o m\",\n },\n crampedllap: {\n signature: \"o m\",\n },\n crampedrlap: {\n signature: \"o m\",\n },\n crampedclap: {\n signature: \"o m\",\n },\n crampedsubstack: {\n signature: \"o m\",\n },\n smashoperator: {\n signature: \"o m\",\n },\n newtagform: {\n signature: \"m o m m\",\n },\n renewtagform: {\n signature: \"m o m m\",\n },\n usetagform: {\n signature: \"m\",\n },\n xleftrightarrow: { signature: \"o m\" },\n xLeftarrow: { signature: \"o m\" },\n xhookleftarrow: { signature: \"o m\" },\n xmapsto: { signature: \"o m\" },\n xRightarrow: { signature: \"o m\" },\n xLeftrightarrow: { signature: \"o m\" },\n xhookrightarrow: { signature: \"o m\" },\n underbracket: { signature: \"o o m\" },\n overbracket: { signature: \"o o m\" },\n underbrace: { signature: \"m\" },\n overbrace: { signature: \"m\" },\n shoveleft: { signature: \"o m\" },\n shoveright: { signature: \"o m\" },\n ArrowBetweenLines: { signature: \"s o\" },\n vdotswithin: { signature: \"m\" },\n shortdotswithin: { signature: \"s m\" },\n DeclarePairedDelimiter: {\n signature: \"m m m\",\n renderInfo: { breakAround: true },\n },\n DeclarePairedDelimiterX: {\n signature: \"m o m m m\",\n renderInfo: { breakAround: true },\n },\n DeclarePairedDelimiterXPP: {\n signature: \"m o m m m m m\",\n renderInfo: { breakAround: true },\n },\n prescript: { signature: \"m m m\" },\n DeclareMathSizes: { signature: \"m m m m\" },\n newgathered: { signature: \"m m m m\" },\n renewgathered: { signature: \"m m m m\" },\n splitfrac: { signature: \"m m\" },\n splitdfrac: { signature: \"m m\" },\n xmathstrut: { signature: \"o m\" },\n // amsthm\n newtheorem: { signature: \"s m o m o\", renderInfo: { breakAround: true } },\n theoremstyle: { signature: \"m\", renderInfo: { breakAround: true } },\n newtheoremstyle: {\n signature: \"m m m m m m m m m\",\n renderInfo: { breakAround: true },\n },\n // amsmath\n text: { signature: \"m\", renderInfo: { inMathMode: false } },\n // amsfonts\n mathbb: { signature: \"m\" },\n mathscr: { signature: \"m\" },\n mathfrak: { signature: \"m\" },\n frak: { signature: \"m\" },\n Bdd: { signature: \"m\" },\n bold: { signature: \"m\" },\n // amsopn\n operatorname: { signature: \"s m\" },\n DeclareMathOperator: {\n signature: \"s m m\",\n renderInfo: { breakAround: true },\n },\n};\n\nexport const environments: EnvInfoRecord = {\n crampedsubarray: {\n signature: \"m\",\n renderInfo: { alignContent: true, inMathMode: true },\n },\n matrix: { renderInfo: { alignContent: true, inMathMode: true } },\n bmatrix: { renderInfo: { alignContent: true, inMathMode: true } },\n pmatrix: { renderInfo: { alignContent: true, inMathMode: true } },\n vmatrix: { renderInfo: { alignContent: true, inMathMode: true } },\n Bmatrix: { renderInfo: { alignContent: true, inMathMode: true } },\n Vmatrix: { renderInfo: { alignContent: true, inMathMode: true } },\n smallmatrix: { renderInfo: { alignContent: true, inMathMode: true } },\n psmallmatrix: { renderInfo: { alignContent: true, inMathMode: true } },\n vsmallmatrix: { renderInfo: { alignContent: true, inMathMode: true } },\n bsmallmatrix: { renderInfo: { alignContent: true, inMathMode: true } },\n Bsmallmatrix: { renderInfo: { alignContent: true, inMathMode: true } },\n Vsmallmatrix: { renderInfo: { alignContent: true, inMathMode: true } },\n \"matrix*\": {\n signature: \"o\",\n renderInfo: { alignContent: true, inMathMode: true },\n },\n \"bmatrix*\": {\n signature: \"o\",\n renderInfo: { alignContent: true, inMathMode: true },\n },\n \"pmatrix*\": {\n signature: \"o\",\n renderInfo: { alignContent: true, inMathMode: true },\n },\n \"vmatrix*\": {\n signature: \"o\",\n renderInfo: { alignContent: true, inMathMode: true },\n },\n \"Bmatrix*\": {\n signature: \"o\",\n renderInfo: { alignContent: true, inMathMode: true },\n },\n \"Vmatrix*\": {\n signature: \"o\",\n renderInfo: { alignContent: true, inMathMode: true },\n },\n \"smallmatrix*\": {\n signature: \"o\",\n renderInfo: { alignContent: true, inMathMode: true },\n },\n \"psmallmatrix*\": {\n signature: \"o\",\n renderInfo: { alignContent: true, inMathMode: true },\n },\n \"bsmallmatrix*\": {\n signature: \"o\",\n renderInfo: { alignContent: true, inMathMode: true },\n },\n \"vsmallmatrix*\": {\n signature: \"o\",\n renderInfo: { alignContent: true, inMathMode: true },\n },\n \"Bsmallmatrix*\": {\n signature: \"o\",\n renderInfo: { alignContent: true, inMathMode: true },\n },\n \"Vsmallmatrix*\": {\n signature: \"o\",\n renderInfo: { alignContent: true, inMathMode: true },\n },\n multilined: { signature: \"o o\", renderInfo: { inMathMode: true } },\n cases: { renderInfo: { alignContent: true, inMathMode: true } },\n \"cases*\": { renderInfo: { alignContent: true, inMathMode: true } },\n dcases: { renderInfo: { alignContent: true, inMathMode: true } },\n \"dcases*\": { renderInfo: { alignContent: true, inMathMode: true } },\n rcases: { renderInfo: { alignContent: true, inMathMode: true } },\n \"rcases*\": { renderInfo: { alignContent: true, inMathMode: true } },\n drcases: { renderInfo: { alignContent: true, inMathMode: true } },\n \"drcases*\": { renderInfo: { alignContent: true, inMathMode: true } },\n spreadlines: { signature: \"m\", renderInfo: { inMathMode: true } },\n lgathered: { signature: \"o\", renderInfo: { inMathMode: true } },\n rgathered: { signature: \"o\", renderInfo: { inMathMode: true } },\n // amsmath\n \"align*\": { renderInfo: { inMathMode: true, alignContent: true } },\n align: { renderInfo: { inMathMode: true, alignContent: true } },\n aligned: { renderInfo: { inMathMode: true, alignContent: true } },\n \"alignat*\": { renderInfo: { inMathMode: true, alignContent: true } },\n alignat: { renderInfo: { inMathMode: true, alignContent: true } },\n \"equation*\": { renderInfo: { inMathMode: true } },\n equation: { renderInfo: { inMathMode: true } },\n \"gather*\": { renderInfo: { inMathMode: true } },\n gather: { renderInfo: { inMathMode: true } },\n \"multline*\": { renderInfo: { inMathMode: true } },\n multline: { renderInfo: { inMathMode: true } },\n \"flalign*\": { renderInfo: { inMathMode: true, alignContent: true } },\n flalign: { renderInfo: { inMathMode: true, alignContent: true } },\n split: { renderInfo: { inMathMode: true } },\n // Math environments\n displaymath: { renderInfo: { inMathMode: true } },\n // Typical amsthm environments\n theorem: { signature: \"o\" },\n lemma: { signature: \"o\" },\n definition: { signature: \"o\" },\n proposition: { signature: \"o\" },\n corollary: { signature: \"o\" },\n remark: { signature: \"!o\" },\n example: { signature: \"!o\" },\n proof: { signature: \"o\" },\n};\n"],"names":[],"mappings":"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"} \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-ctan/package/mathtools/provides.d.ts b/node_modules/@unified-latex/unified-latex-ctan/package/mathtools/provides.d.ts new file mode 100644 index 0000000..88c6521 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-ctan/package/mathtools/provides.d.ts @@ -0,0 +1,4 @@ +import { MacroInfoRecord, EnvInfoRecord } from '@unified-latex/unified-latex-types'; +export declare const macros: MacroInfoRecord; +export declare const environments: EnvInfoRecord; +//# sourceMappingURL=provides.d.ts.map \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-ctan/package/minted/index.cjs b/node_modules/@unified-latex/unified-latex-ctan/package/minted/index.cjs new file mode 100644 index 0000000..ccba19b --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-ctan/package/minted/index.cjs @@ -0,0 +1,6 @@ +"use strict"; +Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" }); +const provides = require("../../provides-Bdw2Aj_V.cjs"); +exports.environments = provides.environments; +exports.macros = provides.macros; +//# sourceMappingURL=index.cjs.map diff --git a/node_modules/@unified-latex/unified-latex-ctan/package/minted/index.cjs.map b/node_modules/@unified-latex/unified-latex-ctan/package/minted/index.cjs.map new file mode 100644 index 0000000..5f0f93e --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-ctan/package/minted/index.cjs.map @@ -0,0 +1 @@ +{"version":3,"file":"index.cjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;"} \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-ctan/package/minted/index.d.ts b/node_modules/@unified-latex/unified-latex-ctan/package/minted/index.d.ts new file mode 100644 index 0000000..981b287 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-ctan/package/minted/index.d.ts @@ -0,0 +1,2 @@ +export * from './provides'; +//# sourceMappingURL=index.d.ts.map \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-ctan/package/minted/index.js b/node_modules/@unified-latex/unified-latex-ctan/package/minted/index.js new file mode 100644 index 0000000..c90c181 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-ctan/package/minted/index.js @@ -0,0 +1,6 @@ +import { e, m } from "../../provides-sdqk_ZBm.js"; +export { + e as environments, + m as macros +}; +//# sourceMappingURL=index.js.map diff --git a/node_modules/@unified-latex/unified-latex-ctan/package/minted/index.js.map b/node_modules/@unified-latex/unified-latex-ctan/package/minted/index.js.map new file mode 100644 index 0000000..594ae09 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-ctan/package/minted/index.js.map @@ -0,0 +1 @@ +{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";"} \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-ctan/package/minted/libs/argument-parser.d.ts b/node_modules/@unified-latex/unified-latex-ctan/package/minted/libs/argument-parser.d.ts new file mode 100644 index 0000000..c8aaa27 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-ctan/package/minted/libs/argument-parser.d.ts @@ -0,0 +1,8 @@ +import { ArgumentParser } from '@unified-latex/unified-latex-types'; +/** + * This argument parser parses arguments in the form of + * - [⟨options⟩]{⟨language⟩}⟨delim⟩⟨code⟩⟨delim⟩ + * - [⟨options⟩]{⟨language⟩}{⟨code⟩} + */ +export declare const argumentParser: ArgumentParser; +//# sourceMappingURL=argument-parser.d.ts.map \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-ctan/package/minted/provides.d.ts b/node_modules/@unified-latex/unified-latex-ctan/package/minted/provides.d.ts new file mode 100644 index 0000000..88c6521 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-ctan/package/minted/provides.d.ts @@ -0,0 +1,4 @@ +import { MacroInfoRecord, EnvInfoRecord } from '@unified-latex/unified-latex-types'; +export declare const macros: MacroInfoRecord; +export declare const environments: EnvInfoRecord; +//# sourceMappingURL=provides.d.ts.map \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-ctan/package/multicol/index.cjs b/node_modules/@unified-latex/unified-latex-ctan/package/multicol/index.cjs new file mode 100644 index 0000000..741b54b --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-ctan/package/multicol/index.cjs @@ -0,0 +1,16 @@ +"use strict"; +Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" }); +const macros = { + columnbreak: { renderInfo: { breakAround: true } } +}; +const environments = { + multicols: { + signature: "m o o" + }, + "multicols*": { + signature: "m o o" + } +}; +exports.environments = environments; +exports.macros = macros; +//# sourceMappingURL=index.cjs.map diff --git a/node_modules/@unified-latex/unified-latex-ctan/package/multicol/index.cjs.map b/node_modules/@unified-latex/unified-latex-ctan/package/multicol/index.cjs.map new file mode 100644 index 0000000..50058b1 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-ctan/package/multicol/index.cjs.map @@ -0,0 +1 @@ +{"version":3,"file":"index.cjs","sources":["../../../package/multicol/provides.ts"],"sourcesContent":["import {\n MacroInfoRecord,\n EnvInfoRecord,\n} from \"@unified-latex/unified-latex-types\";\n\nexport const macros: MacroInfoRecord = {\n columnbreak: { renderInfo: { breakAround: true } },\n};\n\nexport const environments: EnvInfoRecord = {\n multicols: {\n signature: \"m o o\",\n },\n \"multicols*\": {\n signature: \"m o o\",\n },\n};\n"],"names":[],"mappings":";;AAKO,MAAM,SAA0B;AAAA,EACnC,aAAa,EAAE,YAAY,EAAE,aAAa,KAAO,EAAA;AACrD;AAEO,MAAM,eAA8B;AAAA,EACvC,WAAW;AAAA,IACP,WAAW;AAAA,EACf;AAAA,EACA,cAAc;AAAA,IACV,WAAW;AAAA,EAAA;AAEnB;;;"} \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-ctan/package/multicol/index.d.ts b/node_modules/@unified-latex/unified-latex-ctan/package/multicol/index.d.ts new file mode 100644 index 0000000..981b287 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-ctan/package/multicol/index.d.ts @@ -0,0 +1,2 @@ +export * from './provides'; +//# sourceMappingURL=index.d.ts.map \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-ctan/package/multicol/index.js b/node_modules/@unified-latex/unified-latex-ctan/package/multicol/index.js new file mode 100644 index 0000000..810d485 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-ctan/package/multicol/index.js @@ -0,0 +1,16 @@ +const macros = { + columnbreak: { renderInfo: { breakAround: true } } +}; +const environments = { + multicols: { + signature: "m o o" + }, + "multicols*": { + signature: "m o o" + } +}; +export { + environments, + macros +}; +//# sourceMappingURL=index.js.map diff --git a/node_modules/@unified-latex/unified-latex-ctan/package/multicol/index.js.map b/node_modules/@unified-latex/unified-latex-ctan/package/multicol/index.js.map new file mode 100644 index 0000000..94fcf4d --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-ctan/package/multicol/index.js.map @@ -0,0 +1 @@ +{"version":3,"file":"index.js","sources":["../../../package/multicol/provides.ts"],"sourcesContent":["import {\n MacroInfoRecord,\n EnvInfoRecord,\n} from \"@unified-latex/unified-latex-types\";\n\nexport const macros: MacroInfoRecord = {\n columnbreak: { renderInfo: { breakAround: true } },\n};\n\nexport const environments: EnvInfoRecord = {\n multicols: {\n signature: \"m o o\",\n },\n \"multicols*\": {\n signature: \"m o o\",\n },\n};\n"],"names":[],"mappings":"AAKO,MAAM,SAA0B;AAAA,EACnC,aAAa,EAAE,YAAY,EAAE,aAAa,KAAO,EAAA;AACrD;AAEO,MAAM,eAA8B;AAAA,EACvC,WAAW;AAAA,IACP,WAAW;AAAA,EACf;AAAA,EACA,cAAc;AAAA,IACV,WAAW;AAAA,EAAA;AAEnB;"} \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-ctan/package/multicol/provides.d.ts b/node_modules/@unified-latex/unified-latex-ctan/package/multicol/provides.d.ts new file mode 100644 index 0000000..88c6521 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-ctan/package/multicol/provides.d.ts @@ -0,0 +1,4 @@ +import { MacroInfoRecord, EnvInfoRecord } from '@unified-latex/unified-latex-types'; +export declare const macros: MacroInfoRecord; +export declare const environments: EnvInfoRecord; +//# sourceMappingURL=provides.d.ts.map \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-ctan/package/nicematrix/index.cjs b/node_modules/@unified-latex/unified-latex-ctan/package/nicematrix/index.cjs new file mode 100644 index 0000000..a5636b2 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-ctan/package/nicematrix/index.cjs @@ -0,0 +1,73 @@ +"use strict"; +Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" }); +const macros = { + NiceMatrixOptions: { + signature: "m", + renderInfo: { pgfkeysArgs: true, breakAround: true } + } +}; +const environments = { + NiceTabular: { + signature: "o m !o", + renderInfo: { pgfkeysArgs: true, alignContent: true } + }, + NiceMatrixBlock: { + signature: "!o", + renderInfo: { pgfkeysArgs: true, alignContent: true } + }, + NiceArrayWithDelims: { + signature: "m m o m !o", + renderInfo: { pgfkeysArgs: true, alignContent: true } + }, + NiceArray: { + signature: "o m !o", + renderInfo: { pgfkeysArgs: true, alignContent: true } + }, + pNiceArray: { + signature: "o m !o", + renderInfo: { pgfkeysArgs: true, alignContent: true } + }, + bNiceArray: { + signature: "o m !o", + renderInfo: { pgfkeysArgs: true, alignContent: true } + }, + BNiceArray: { + signature: "o m !o", + renderInfo: { pgfkeysArgs: true, alignContent: true } + }, + vNiceArray: { + signature: "o m !o", + renderInfo: { pgfkeysArgs: true, alignContent: true } + }, + VNiceArray: { + signature: "o m !o", + renderInfo: { pgfkeysArgs: true, alignContent: true } + }, + NiceMatrix: { + signature: "!o", + renderInfo: { pgfkeysArgs: true, alignContent: true } + }, + pNiceMatrix: { + signature: "!o", + renderInfo: { pgfkeysArgs: true, alignContent: true } + }, + bNiceMatrix: { + signature: "!o", + renderInfo: { pgfkeysArgs: true, alignContent: true } + }, + BNiceMatrix: { + signature: "!o", + renderInfo: { pgfkeysArgs: true, alignContent: true } + }, + vNiceMatrix: { + signature: "!o", + renderInfo: { pgfkeysArgs: true, alignContent: true } + }, + VNiceMatrix: { + signature: "!o", + renderInfo: { pgfkeysArgs: true, alignContent: true } + } +}; +exports.environments = environments; +exports.macros = macros; +//# sourceMappingURL=index.cjs.map diff --git a/node_modules/@unified-latex/unified-latex-ctan/package/nicematrix/index.cjs.map b/node_modules/@unified-latex/unified-latex-ctan/package/nicematrix/index.cjs.map new file mode 100644 index 0000000..b67a221 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-ctan/package/nicematrix/index.cjs.map @@ -0,0 +1 @@ +{"version":3,"file":"index.cjs","sources":["../../../package/nicematrix/provides.ts"],"sourcesContent":["import {\n MacroInfoRecord,\n EnvInfoRecord,\n} from \"@unified-latex/unified-latex-types\";\n\nexport const macros: MacroInfoRecord = {\n NiceMatrixOptions: {\n signature: \"m\",\n renderInfo: { pgfkeysArgs: true, breakAround: true },\n },\n};\n\nexport const environments: EnvInfoRecord = {\n NiceTabular: {\n signature: \"o m !o\",\n renderInfo: { pgfkeysArgs: true, alignContent: true },\n },\n NiceMatrixBlock: {\n signature: \"!o\",\n renderInfo: { pgfkeysArgs: true, alignContent: true },\n },\n NiceArrayWithDelims: {\n signature: \"m m o m !o\",\n renderInfo: { pgfkeysArgs: true, alignContent: true },\n },\n NiceArray: {\n signature: \"o m !o\",\n renderInfo: { pgfkeysArgs: true, alignContent: true },\n },\n pNiceArray: {\n signature: \"o m !o\",\n renderInfo: { pgfkeysArgs: true, alignContent: true },\n },\n bNiceArray: {\n signature: \"o m !o\",\n renderInfo: { pgfkeysArgs: true, alignContent: true },\n },\n BNiceArray: {\n signature: \"o m !o\",\n renderInfo: { pgfkeysArgs: true, alignContent: true },\n },\n vNiceArray: {\n signature: \"o m !o\",\n renderInfo: { pgfkeysArgs: true, alignContent: true },\n },\n VNiceArray: {\n signature: \"o m !o\",\n renderInfo: { pgfkeysArgs: true, alignContent: true },\n },\n NiceMatrix: {\n signature: \"!o\",\n renderInfo: { pgfkeysArgs: true, alignContent: true },\n },\n pNiceMatrix: {\n signature: \"!o\",\n renderInfo: { pgfkeysArgs: true, alignContent: true },\n },\n bNiceMatrix: {\n signature: \"!o\",\n renderInfo: { pgfkeysArgs: true, alignContent: true },\n },\n BNiceMatrix: {\n signature: \"!o\",\n renderInfo: { pgfkeysArgs: true, alignContent: true },\n },\n vNiceMatrix: {\n signature: \"!o\",\n renderInfo: { pgfkeysArgs: true, alignContent: true },\n },\n VNiceMatrix: {\n signature: \"!o\",\n renderInfo: { pgfkeysArgs: true, alignContent: true },\n },\n};\n"],"names":[],"mappings":";;AAKO,MAAM,SAA0B;AAAA,EACnC,mBAAmB;AAAA,IACf,WAAW;AAAA,IACX,YAAY,EAAE,aAAa,MAAM,aAAa,KAAK;AAAA,EAAA;AAE3D;AAEO,MAAM,eAA8B;AAAA,EACvC,aAAa;AAAA,IACT,WAAW;AAAA,IACX,YAAY,EAAE,aAAa,MAAM,cAAc,KAAK;AAAA,EACxD;AAAA,EACA,iBAAiB;AAAA,IACb,WAAW;AAAA,IACX,YAAY,EAAE,aAAa,MAAM,cAAc,KAAK;AAAA,EACxD;AAAA,EACA,qBAAqB;AAAA,IACjB,WAAW;AAAA,IACX,YAAY,EAAE,aAAa,MAAM,cAAc,KAAK;AAAA,EACxD;AAAA,EACA,WAAW;AAAA,IACP,WAAW;AAAA,IACX,YAAY,EAAE,aAAa,MAAM,cAAc,KAAK;AAAA,EACxD;AAAA,EACA,YAAY;AAAA,IACR,WAAW;AAAA,IACX,YAAY,EAAE,aAAa,MAAM,cAAc,KAAK;AAAA,EACxD;AAAA,EACA,YAAY;AAAA,IACR,WAAW;AAAA,IACX,YAAY,EAAE,aAAa,MAAM,cAAc,KAAK;AAAA,EACxD;AAAA,EACA,YAAY;AAAA,IACR,WAAW;AAAA,IACX,YAAY,EAAE,aAAa,MAAM,cAAc,KAAK;AAAA,EACxD;AAAA,EACA,YAAY;AAAA,IACR,WAAW;AAAA,IACX,YAAY,EAAE,aAAa,MAAM,cAAc,KAAK;AAAA,EACxD;AAAA,EACA,YAAY;AAAA,IACR,WAAW;AAAA,IACX,YAAY,EAAE,aAAa,MAAM,cAAc,KAAK;AAAA,EACxD;AAAA,EACA,YAAY;AAAA,IACR,WAAW;AAAA,IACX,YAAY,EAAE,aAAa,MAAM,cAAc,KAAK;AAAA,EACxD;AAAA,EACA,aAAa;AAAA,IACT,WAAW;AAAA,IACX,YAAY,EAAE,aAAa,MAAM,cAAc,KAAK;AAAA,EACxD;AAAA,EACA,aAAa;AAAA,IACT,WAAW;AAAA,IACX,YAAY,EAAE,aAAa,MAAM,cAAc,KAAK;AAAA,EACxD;AAAA,EACA,aAAa;AAAA,IACT,WAAW;AAAA,IACX,YAAY,EAAE,aAAa,MAAM,cAAc,KAAK;AAAA,EACxD;AAAA,EACA,aAAa;AAAA,IACT,WAAW;AAAA,IACX,YAAY,EAAE,aAAa,MAAM,cAAc,KAAK;AAAA,EACxD;AAAA,EACA,aAAa;AAAA,IACT,WAAW;AAAA,IACX,YAAY,EAAE,aAAa,MAAM,cAAc,KAAK;AAAA,EAAA;AAE5D;;;"} \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-ctan/package/nicematrix/index.d.ts b/node_modules/@unified-latex/unified-latex-ctan/package/nicematrix/index.d.ts new file mode 100644 index 0000000..981b287 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-ctan/package/nicematrix/index.d.ts @@ -0,0 +1,2 @@ +export * from './provides'; +//# sourceMappingURL=index.d.ts.map \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-ctan/package/nicematrix/index.js b/node_modules/@unified-latex/unified-latex-ctan/package/nicematrix/index.js new file mode 100644 index 0000000..e2515b0 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-ctan/package/nicematrix/index.js @@ -0,0 +1,73 @@ +const macros = { + NiceMatrixOptions: { + signature: "m", + renderInfo: { pgfkeysArgs: true, breakAround: true } + } +}; +const environments = { + NiceTabular: { + signature: "o m !o", + renderInfo: { pgfkeysArgs: true, alignContent: true } + }, + NiceMatrixBlock: { + signature: "!o", + renderInfo: { pgfkeysArgs: true, alignContent: true } + }, + NiceArrayWithDelims: { + signature: "m m o m !o", + renderInfo: { pgfkeysArgs: true, alignContent: true } + }, + NiceArray: { + signature: "o m !o", + renderInfo: { pgfkeysArgs: true, alignContent: true } + }, + pNiceArray: { + signature: "o m !o", + renderInfo: { pgfkeysArgs: true, alignContent: true } + }, + bNiceArray: { + signature: "o m !o", + renderInfo: { pgfkeysArgs: true, alignContent: true } + }, + BNiceArray: { + signature: "o m !o", + renderInfo: { pgfkeysArgs: true, alignContent: true } + }, + vNiceArray: { + signature: "o m !o", + renderInfo: { pgfkeysArgs: true, alignContent: true } + }, + VNiceArray: { + signature: "o m !o", + renderInfo: { pgfkeysArgs: true, alignContent: true } + }, + NiceMatrix: { + signature: "!o", + renderInfo: { pgfkeysArgs: true, alignContent: true } + }, + pNiceMatrix: { + signature: "!o", + renderInfo: { pgfkeysArgs: true, alignContent: true } + }, + bNiceMatrix: { + signature: "!o", + renderInfo: { pgfkeysArgs: true, alignContent: true } + }, + BNiceMatrix: { + signature: "!o", + renderInfo: { pgfkeysArgs: true, alignContent: true } + }, + vNiceMatrix: { + signature: "!o", + renderInfo: { pgfkeysArgs: true, alignContent: true } + }, + VNiceMatrix: { + signature: "!o", + renderInfo: { pgfkeysArgs: true, alignContent: true } + } +}; +export { + environments, + macros +}; +//# sourceMappingURL=index.js.map diff --git a/node_modules/@unified-latex/unified-latex-ctan/package/nicematrix/index.js.map b/node_modules/@unified-latex/unified-latex-ctan/package/nicematrix/index.js.map new file mode 100644 index 0000000..1398453 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-ctan/package/nicematrix/index.js.map @@ -0,0 +1 @@ +{"version":3,"file":"index.js","sources":["../../../package/nicematrix/provides.ts"],"sourcesContent":["import {\n MacroInfoRecord,\n EnvInfoRecord,\n} from \"@unified-latex/unified-latex-types\";\n\nexport const macros: MacroInfoRecord = {\n NiceMatrixOptions: {\n signature: \"m\",\n renderInfo: { pgfkeysArgs: true, breakAround: true },\n },\n};\n\nexport const environments: EnvInfoRecord = {\n NiceTabular: {\n signature: \"o m !o\",\n renderInfo: { pgfkeysArgs: true, alignContent: true },\n },\n NiceMatrixBlock: {\n signature: \"!o\",\n renderInfo: { pgfkeysArgs: true, alignContent: true },\n },\n NiceArrayWithDelims: {\n signature: \"m m o m !o\",\n renderInfo: { pgfkeysArgs: true, alignContent: true },\n },\n NiceArray: {\n signature: \"o m !o\",\n renderInfo: { pgfkeysArgs: true, alignContent: true },\n },\n pNiceArray: {\n signature: \"o m !o\",\n renderInfo: { pgfkeysArgs: true, alignContent: true },\n },\n bNiceArray: {\n signature: \"o m !o\",\n renderInfo: { pgfkeysArgs: true, alignContent: true },\n },\n BNiceArray: {\n signature: \"o m !o\",\n renderInfo: { pgfkeysArgs: true, alignContent: true },\n },\n vNiceArray: {\n signature: \"o m !o\",\n renderInfo: { pgfkeysArgs: true, alignContent: true },\n },\n VNiceArray: {\n signature: \"o m !o\",\n renderInfo: { pgfkeysArgs: true, alignContent: true },\n },\n NiceMatrix: {\n signature: \"!o\",\n renderInfo: { pgfkeysArgs: true, alignContent: true },\n },\n pNiceMatrix: {\n signature: \"!o\",\n renderInfo: { pgfkeysArgs: true, alignContent: true },\n },\n bNiceMatrix: {\n signature: \"!o\",\n renderInfo: { pgfkeysArgs: true, alignContent: true },\n },\n BNiceMatrix: {\n signature: \"!o\",\n renderInfo: { pgfkeysArgs: true, alignContent: true },\n },\n vNiceMatrix: {\n signature: \"!o\",\n renderInfo: { pgfkeysArgs: true, alignContent: true },\n },\n VNiceMatrix: {\n signature: \"!o\",\n renderInfo: { pgfkeysArgs: true, alignContent: true },\n },\n};\n"],"names":[],"mappings":"AAKO,MAAM,SAA0B;AAAA,EACnC,mBAAmB;AAAA,IACf,WAAW;AAAA,IACX,YAAY,EAAE,aAAa,MAAM,aAAa,KAAK;AAAA,EAAA;AAE3D;AAEO,MAAM,eAA8B;AAAA,EACvC,aAAa;AAAA,IACT,WAAW;AAAA,IACX,YAAY,EAAE,aAAa,MAAM,cAAc,KAAK;AAAA,EACxD;AAAA,EACA,iBAAiB;AAAA,IACb,WAAW;AAAA,IACX,YAAY,EAAE,aAAa,MAAM,cAAc,KAAK;AAAA,EACxD;AAAA,EACA,qBAAqB;AAAA,IACjB,WAAW;AAAA,IACX,YAAY,EAAE,aAAa,MAAM,cAAc,KAAK;AAAA,EACxD;AAAA,EACA,WAAW;AAAA,IACP,WAAW;AAAA,IACX,YAAY,EAAE,aAAa,MAAM,cAAc,KAAK;AAAA,EACxD;AAAA,EACA,YAAY;AAAA,IACR,WAAW;AAAA,IACX,YAAY,EAAE,aAAa,MAAM,cAAc,KAAK;AAAA,EACxD;AAAA,EACA,YAAY;AAAA,IACR,WAAW;AAAA,IACX,YAAY,EAAE,aAAa,MAAM,cAAc,KAAK;AAAA,EACxD;AAAA,EACA,YAAY;AAAA,IACR,WAAW;AAAA,IACX,YAAY,EAAE,aAAa,MAAM,cAAc,KAAK;AAAA,EACxD;AAAA,EACA,YAAY;AAAA,IACR,WAAW;AAAA,IACX,YAAY,EAAE,aAAa,MAAM,cAAc,KAAK;AAAA,EACxD;AAAA,EACA,YAAY;AAAA,IACR,WAAW;AAAA,IACX,YAAY,EAAE,aAAa,MAAM,cAAc,KAAK;AAAA,EACxD;AAAA,EACA,YAAY;AAAA,IACR,WAAW;AAAA,IACX,YAAY,EAAE,aAAa,MAAM,cAAc,KAAK;AAAA,EACxD;AAAA,EACA,aAAa;AAAA,IACT,WAAW;AAAA,IACX,YAAY,EAAE,aAAa,MAAM,cAAc,KAAK;AAAA,EACxD;AAAA,EACA,aAAa;AAAA,IACT,WAAW;AAAA,IACX,YAAY,EAAE,aAAa,MAAM,cAAc,KAAK;AAAA,EACxD;AAAA,EACA,aAAa;AAAA,IACT,WAAW;AAAA,IACX,YAAY,EAAE,aAAa,MAAM,cAAc,KAAK;AAAA,EACxD;AAAA,EACA,aAAa;AAAA,IACT,WAAW;AAAA,IACX,YAAY,EAAE,aAAa,MAAM,cAAc,KAAK;AAAA,EACxD;AAAA,EACA,aAAa;AAAA,IACT,WAAW;AAAA,IACX,YAAY,EAAE,aAAa,MAAM,cAAc,KAAK;AAAA,EAAA;AAE5D;"} \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-ctan/package/nicematrix/provides.d.ts b/node_modules/@unified-latex/unified-latex-ctan/package/nicematrix/provides.d.ts new file mode 100644 index 0000000..88c6521 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-ctan/package/nicematrix/provides.d.ts @@ -0,0 +1,4 @@ +import { MacroInfoRecord, EnvInfoRecord } from '@unified-latex/unified-latex-types'; +export declare const macros: MacroInfoRecord; +export declare const environments: EnvInfoRecord; +//# sourceMappingURL=provides.d.ts.map \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-ctan/package/systeme/index.cjs b/node_modules/@unified-latex/unified-latex-ctan/package/systeme/index.cjs new file mode 100644 index 0000000..2d7ca0d --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-ctan/package/systeme/index.cjs @@ -0,0 +1,331 @@ +"use strict"; +Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" }); +const provides = require("../../provides-CwtnTL9q.cjs"); +const unifiedLatexUtilMatch = require("@unified-latex/unified-latex-util-match"); +const unifiedLatexUtilPegjs = require("@unified-latex/unified-latex-util-pegjs"); +const unifiedLatexUtilPrintRaw = require("@unified-latex/unified-latex-util-print-raw"); +const unifiedLatexUtilSplit = require("@unified-latex/unified-latex-util-split"); +const index = require("../../index-BuqJUpao.cjs"); +const unifiedLatexUtilComments = require("@unified-latex/unified-latex-util-comments"); +const unifiedLatexUtilVisit = require("@unified-latex/unified-latex-util-visit"); +const unifiedLatexUtilRenderInfo = require("@unified-latex/unified-latex-util-render-info"); +const unifiedLatexUtilArguments = require("@unified-latex/unified-latex-util-arguments"); +function createMatchers({ + at = "@", + equals = "=", + equationSeparator = ",", + mathOperations = ["+", "-"], + whitelistedVariables +} = {}) { + let isVar = (node) => unifiedLatexUtilMatch.match.anyString(node) && !!node.content.match(/[a-zA-Z]/); + if (whitelistedVariables) { + whitelistedVariables = whitelistedVariables.map( + (v) => unifiedLatexUtilMatch.match.anyString(v) ? v.content : v + ); + const macros = whitelistedVariables.filter( + (v) => unifiedLatexUtilMatch.match.anyMacro(v) + ); + const strings = whitelistedVariables.filter( + (v) => typeof v === "string" + ); + const macroHash = Object.fromEntries(macros.map((v) => [v.content, v])); + const stringHash = Object.fromEntries(strings.map((s) => [s, s])); + const macroMatcher = unifiedLatexUtilMatch.match.createMacroMatcher(macroHash); + isVar = (node) => macroMatcher(node) || unifiedLatexUtilMatch.match.anyString(node) && !!stringHash[node.content]; + } + return { + isSep: (node) => unifiedLatexUtilMatch.match.string(node, equationSeparator), + isVar, + isOperation: (node) => mathOperations.some((op) => unifiedLatexUtilMatch.match.string(node, op)), + isEquals: (node) => unifiedLatexUtilMatch.match.string(node, equals), + isAt: (node) => unifiedLatexUtilMatch.match.string(node, at), + isSubscript: (node) => unifiedLatexUtilMatch.match.macro(node, "_") && node.escapeToken === "", + isWhitespace: unifiedLatexUtilMatch.match.whitespace, + isSameLineComment: (node) => unifiedLatexUtilMatch.match.comment(node) && node.sameline, + isOwnLineComment: (node) => unifiedLatexUtilMatch.match.comment(node) && !node.sameline + }; +} +function parse(ast, options) { + if (!Array.isArray(ast)) { + throw new Error("You must pass an array of nodes"); + } + ast = unifiedLatexUtilPegjs.decorateArrayForPegjs([...ast]); + return unifiedLatexUtilPegjs.SystemePegParser.parse( + ast, + createMatchers(options || {}) + ); +} +function printRaw(node, root = false) { + if (typeof node === "string") { + return node; + } + if (Array.isArray(node)) { + const sepToken = root ? " " : ""; + return node.map((tok) => printRaw(tok)).join(sepToken); + } + switch (node.type) { + case "annotation": + return `${unifiedLatexUtilPrintRaw.printRaw(node.marker)}${unifiedLatexUtilPrintRaw.printRaw( + node.content + )}`; + case "item": + return `${node.op ? unifiedLatexUtilPrintRaw.printRaw(node.op) : ""}${unifiedLatexUtilPrintRaw.printRaw( + node.content + )}`; + case "equation": + const left = node.left.map((n) => printRaw(n)).join(""); + const right = unifiedLatexUtilPrintRaw.printRaw(node.right); + const equals = node.equals ? unifiedLatexUtilPrintRaw.printRaw(node.equals) : ""; + return `${left}${equals}${right}`; + case "line": + const equation = node.equation ? printRaw(node.equation) : ""; + const annotation = node.annotation ? printRaw(node.annotation) : ""; + const sep = node.sep ? unifiedLatexUtilPrintRaw.printRaw(node.sep) : ""; + const body = `${equation}${annotation}${sep}`; + if (node.trailingComment) { + return unifiedLatexUtilPrintRaw.printRaw([body, node.trailingComment]); + } + return body; + default: + console.warn( + `Unknown node type "${node.type}" for node`, + node + ); + return ""; + } +} +const AMP = { type: "string", content: "&" }; +const SEP = { type: "macro", content: "\\" }; +const QUAD = { type: "macro", content: "quad" }; +const PLUS = { type: "string", content: "+" }; +const COLUMN_KERN_ADJUSTMENT = [ + { type: "string", content: "@" }, + { + type: "group", + content: [ + { type: "macro", content: "mkern" }, + { type: "string", content: "5mu" } + ] + } +]; +function sortVariables(vars, whitelistedVariables) { + const varMap = new Map(vars.map((v) => [v, unifiedLatexUtilPrintRaw.printRaw(v)])); + const varNames = Array.from(new Set(varMap.values())); + varNames.sort(); + const nameToPos = whitelistedVariables ? new Map(whitelistedVariables.map((v, i) => [unifiedLatexUtilPrintRaw.printRaw(v), i])) : new Map(varNames.map((name, i) => [name, i])); + return new Map( + Array.from(varMap.entries()).map(([variable, name]) => { + return [variable, nameToPos.get(name) ?? -1]; + }) + ); +} +function processLine(line, numVars, varOrder, hasEquals, hasAnnotation) { + const ret = []; + if (line.equation) { + const nonVarItems = line.equation.left.filter( + (item) => item.variable == null + ); + const varItems = line.equation.left.filter( + (item) => item.variable != null + ); + let nonVarTerm = null; + if (nonVarItems.length === 1) { + nonVarTerm = nonVarItems[0]; + } else if (nonVarItems.length > 1) { + nonVarTerm = { + ...nonVarItems[0], + content: nonVarItems[0].content.concat( + nonVarItems.slice(1).flatMap((item) => { + if (item.op) { + return [item.op, ...item.content]; + } + return [PLUS, ...item.content]; + }) + ) + }; + } + const allItems = nonVarTerm ? varItems.concat(nonVarTerm) : varItems; + const indexToItem = new Map( + allItems.map((item) => { + if (item.variable == null) { + return [numVars - 1, item]; + } + return [varOrder.get(item.variable), item]; + }) + ); + let isFirstItem = true; + for (let i = 0; i < numVars; i++) { + const item = indexToItem.get(i); + if (item) { + if (isFirstItem && (unifiedLatexUtilMatch.match.string(item.op, "+") || item.op == null)) { + ret.push([]); + ret.push(item.content); + } else { + ret.push([item.op || PLUS]); + ret.push(item.content); + } + isFirstItem = false; + } else { + ret.push([]); + ret.push([]); + } + } + if (hasEquals) { + const equalsPart = (line.equation.equals ? [line.equation.equals] : []).concat(line.equation.right); + ret.push(equalsPart); + } + } + if (hasAnnotation) { + ret.push(line.annotation ? line.annotation.content : []); + } + return ret; +} +function arraySpecToSpacedArraySpec(spec, hasAnnotation) { + const annotationSpec = hasAnnotation ? spec.charAt(spec.length - 1) : ""; + const bodySpec = hasAnnotation ? spec.slice(0, spec.length - 1) : spec; + const bodyStrings = Array.from(bodySpec).map((x) => [ + { type: "string", content: x } + ]); + const body = unifiedLatexUtilSplit.arrayJoin(bodyStrings, COLUMN_KERN_ADJUSTMENT); + return annotationSpec ? body.concat({ type: "string", content: annotationSpec }) : body; +} +function extractVariables(nodes) { + return nodes.flatMap((node) => { + if (node.type === "line" && node.equation) { + return extractVariables(node.equation.left); + } + if (node.type === "equation") { + return node.left.flatMap( + (item) => item.variable ? [item.variable] : [] + ); + } + if (node.type === "item") { + return node.variable ? [node.variable] : []; + } + return []; + }); +} +function normalizeVariableWhitelist(vars) { + if (!vars) { + return null; + } + const normalized = vars.map( + (v) => typeof v === "string" ? { type: "string", content: v } : v + ); + const ret = normalized.filter( + (v) => (unifiedLatexUtilMatch.match.anyMacro(v) || unifiedLatexUtilMatch.match.anyString(v)) && !unifiedLatexUtilMatch.match.string(v, " ") && !unifiedLatexUtilMatch.match.whitespace(v) + ); + return ret; +} +function systemeContentsToArray(nodes, options) { + nodes = index.structuredClone(nodes); + unifiedLatexUtilComments.deleteComments(nodes); + const { properSpacing = true, whitelistedVariables } = options || {}; + const coercedWhitelistedVariables = normalizeVariableWhitelist(whitelistedVariables); + const systemeAst = parse(nodes, { whitelistedVariables }); + const vars = extractVariables(systemeAst); + const varOrder = sortVariables(vars, coercedWhitelistedVariables); + let numVars = coercedWhitelistedVariables ? coercedWhitelistedVariables.length : Math.max(...Array.from(varOrder.values())) + 1; + if (systemeAst.some((line) => { + if (line.equation) { + return line.equation.left.some((item) => item.variable == null); + } + })) { + numVars += 1; + } + const hasEquals = systemeAst.some( + (line) => line.equation && line.equation.equals + ); + const hasAnnotation = systemeAst.some((line) => line.annotation); + let rows = systemeAst.map( + (line) => processLine(line, numVars, varOrder, hasEquals, hasAnnotation) + ); + const noLeadingOperation = rows.every((row) => row[0].length === 0); + let arraySignature = Array.from({ length: numVars }, () => "cr").join(""); + if (noLeadingOperation) { + arraySignature = arraySignature.slice(1); + rows = rows.map((row) => row.slice(1)); + } + if (hasEquals) { + arraySignature += "l"; + } + if (hasAnnotation) { + arraySignature += "l"; + rows = rows.map((row) => { + if (row[row.length - 1].length === 0) { + return row; + } + return [ + ...row.slice(0, row.length - 1), + [QUAD, { type: "whitespace" }, ...row[row.length - 1]] + ]; + }); + } + const arraySignatureWithSpacing = properSpacing ? arraySpecToSpacedArraySpec(arraySignature, hasAnnotation) : [{ type: "string", content: arraySignature }]; + const bodyRows = rows.map((row) => unifiedLatexUtilSplit.arrayJoin(row, AMP)); + const body = unifiedLatexUtilSplit.arrayJoin(bodyRows, SEP); + const ret = { + type: "environment", + env: "array", + args: [ + { + type: "argument", + openMark: "{", + closeMark: "}", + content: arraySignatureWithSpacing + } + ], + content: body + }; + return ret; +} +function attachSystemeSettingsAsRenderInfo(ast) { + const systemeMatcher = unifiedLatexUtilMatch.match.createMacroMatcher(["systeme", "sysdelim"]); + unifiedLatexUtilVisit.visit( + ast, + (nodes, info) => { + if (!info.context.inMathMode || !nodes.some(systemeMatcher)) { + return; + } + const systemeLocations = nodes.flatMap( + (node, i) => unifiedLatexUtilMatch.match.macro(node, "systeme") ? i : [] + ); + const sysdelimLocations = nodes.flatMap( + (node, i) => unifiedLatexUtilMatch.match.macro(node, "sysdelim") ? i : [] + ); + if (systemeLocations.length === 0 || sysdelimLocations.length === 0) { + return; + } + for (const i of systemeLocations) { + const lastSysdelim = Math.max( + ...sysdelimLocations.filter((loc) => loc < i) + ); + if (lastSysdelim >= 0) { + const node = nodes[i]; + const sysdelimMacro = nodes[lastSysdelim]; + if (!unifiedLatexUtilMatch.match.anyMacro(sysdelimMacro)) { + throw new Error( + `Expecting sysdelim macro but found "${unifiedLatexUtilPrintRaw.printRaw( + sysdelimMacro + )}"` + ); + } + const args = unifiedLatexUtilArguments.getArgsContent(sysdelimMacro); + unifiedLatexUtilRenderInfo.updateRenderInfo(node, { sysdelims: args }); + } + } + }, + { + test: Array.isArray, + includeArrays: true + } + ); +} +exports.environments = provides.environments; +exports.macros = provides.macros; +exports.attachSystemeSettingsAsRenderInfo = attachSystemeSettingsAsRenderInfo; +exports.extractVariables = extractVariables; +exports.parse = parse; +exports.printRaw = printRaw; +exports.systemeContentsToArray = systemeContentsToArray; +//# sourceMappingURL=index.cjs.map diff --git a/node_modules/@unified-latex/unified-latex-ctan/package/systeme/index.cjs.map b/node_modules/@unified-latex/unified-latex-ctan/package/systeme/index.cjs.map new file mode 100644 index 0000000..97a0bbb --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-ctan/package/systeme/index.cjs.map @@ -0,0 +1 @@ +{"version":3,"file":"index.cjs","sources":["../../../package/systeme/libs/parser.ts","../../../package/systeme/libs/print-raw.ts","../../../package/systeme/libs/systeme.ts"],"sourcesContent":["import * as Ast from \"@unified-latex/unified-latex-types\";\nimport * as SystemeSpec from \"./types\";\nimport { match } from \"@unified-latex/unified-latex-util-match\";\nimport { decorateArrayForPegjs } from \"@unified-latex/unified-latex-util-pegjs\";\nimport { SystemePegParser } from \"@unified-latex/unified-latex-util-pegjs\";\n\ntype SystemeMatchers = {\n at?: string;\n equals?: string;\n equationSeparator?: string;\n mathOperations?: string[];\n whitelistedVariables?: (string | Ast.String | Ast.Macro)[];\n};\n\nfunction createMatchers({\n at = \"@\",\n equals = \"=\",\n equationSeparator = \",\",\n mathOperations = [\"+\", \"-\"],\n whitelistedVariables,\n}: SystemeMatchers = {}) {\n let isVar: (node: Ast.Node) => boolean = (node: Ast.Node) =>\n match.anyString(node) && !!node.content.match(/[a-zA-Z]/);\n if (whitelistedVariables) {\n // Unwrap all strings\n whitelistedVariables = whitelistedVariables.map((v) =>\n match.anyString(v) ? v.content : v\n );\n const macros = whitelistedVariables.filter((v) =>\n match.anyMacro(v)\n ) as Ast.Macro[];\n const strings = whitelistedVariables.filter(\n (v) => typeof v === \"string\"\n ) as string[];\n const macroHash = Object.fromEntries(macros.map((v) => [v.content, v]));\n const stringHash = Object.fromEntries(strings.map((s) => [s, s]));\n const macroMatcher = match.createMacroMatcher(macroHash);\n isVar = (node: Ast.Node) =>\n macroMatcher(node) ||\n (match.anyString(node) && !!stringHash[node.content]);\n }\n return {\n isSep: (node: Ast.Node) => match.string(node, equationSeparator),\n isVar,\n isOperation: (node: Ast.Node) =>\n mathOperations.some((op) => match.string(node, op)),\n isEquals: (node: Ast.Node) => match.string(node, equals),\n isAt: (node: Ast.Node) => match.string(node, at),\n isSubscript: (node: Ast.Node) =>\n match.macro(node, \"_\") && node.escapeToken === \"\",\n isWhitespace: match.whitespace,\n isSameLineComment: (node: Ast.Node) =>\n match.comment(node) && node.sameline,\n isOwnLineComment: (node: Ast.Node) =>\n match.comment(node) && !node.sameline,\n };\n}\n\n/**\n * Parse the contents of the `\\systeme{...}` macro\n */\nexport function parse(\n ast: Ast.Node[],\n options?: SystemeMatchers\n): SystemeSpec.Line[] {\n if (!Array.isArray(ast)) {\n throw new Error(\"You must pass an array of nodes\");\n }\n // We need to at functions to `nodes` so that it imitates\n // a Javascript string. Because we're mutating, make a copy first\n ast = decorateArrayForPegjs([...ast]);\n // matchers are passed in via the second argument (the `options` argument)\n // so they are available from within the Pegjs grammar.\n return SystemePegParser.parse(\n ast,\n createMatchers(options || {})\n ) as SystemeSpec.Line[];\n}\n","import { printRaw as latexPrintRaw } from \"@unified-latex/unified-latex-util-print-raw\";\nimport * as SystemeSpec from \"./types\";\n\n/**\n * Print an `systeme` argument specification AST to a string.\n */\nexport function printRaw(node: SystemeSpec.Ast, root = false): string {\n if (typeof node === \"string\") {\n return node;\n }\n\n if (Array.isArray(node)) {\n const sepToken = root ? \" \" : \"\";\n return node.map((tok) => printRaw(tok)).join(sepToken);\n }\n\n switch (node.type) {\n case \"annotation\":\n return `${latexPrintRaw(node.marker)}${latexPrintRaw(\n node.content\n )}`;\n case \"item\":\n return `${node.op ? latexPrintRaw(node.op) : \"\"}${latexPrintRaw(\n node.content\n )}`;\n case \"equation\":\n const left = node.left.map((n) => printRaw(n)).join(\"\");\n const right = latexPrintRaw(node.right);\n const equals = node.equals ? latexPrintRaw(node.equals) : \"\";\n return `${left}${equals}${right}`;\n case \"line\":\n const equation = node.equation ? printRaw(node.equation) : \"\";\n const annotation = node.annotation ? printRaw(node.annotation) : \"\";\n const sep = node.sep ? latexPrintRaw(node.sep) : \"\";\n\n const body = `${equation}${annotation}${sep}`;\n if (node.trailingComment) {\n return latexPrintRaw([body, node.trailingComment]);\n }\n\n return body;\n\n default:\n console.warn(\n `Unknown node type \"${(node as any).type}\" for node`,\n node\n );\n return \"\";\n }\n}\n","import * as SystemeSpec from \"./types\";\nimport * as Ast from \"@unified-latex/unified-latex-types\";\nimport { printRaw } from \"@unified-latex/unified-latex-util-print-raw\";\nimport { match } from \"@unified-latex/unified-latex-util-match\";\nimport { arrayJoin } from \"@unified-latex/unified-latex-util-split\";\nimport { parse } from \"./parser\";\nimport { structuredClone } from \"@unified-latex/structured-clone\";\nimport { deleteComments } from \"@unified-latex/unified-latex-util-comments\";\nimport { visit } from \"@unified-latex/unified-latex-util-visit\";\nimport { updateRenderInfo } from \"@unified-latex/unified-latex-util-render-info\";\nimport { getArgsContent } from \"@unified-latex/unified-latex-util-arguments\";\n\nconst AMP: Ast.String = { type: \"string\", content: \"&\" };\nconst SEP: Ast.Macro = { type: \"macro\", content: \"\\\\\" };\nconst QUAD: Ast.Macro = { type: \"macro\", content: \"quad\" };\nconst PLUS: Ast.String = { type: \"string\", content: \"+\" };\nconst COLUMN_KERN_ADJUSTMENT: Ast.Node[] = [\n { type: \"string\", content: \"@\" },\n {\n type: \"group\",\n content: [\n { type: \"macro\", content: \"mkern\" },\n { type: \"string\", content: \"5mu\" },\n ],\n },\n];\n\n/**\n * Return a map giving the sorted index of each variable in `vars`. There\n * may be duplicated variables in `vars`. The map will send duplicates to the same index.\n *\n * @param {Ast.Node[][]} vars\n * @returns\n */\nfunction sortVariables(\n vars: Ast.Node[][],\n whitelistedVariables?: Ast.Node[] | null\n) {\n const varMap = new Map(vars.map((v) => [v, printRaw(v)]));\n const varNames = Array.from(new Set(varMap.values()));\n varNames.sort();\n const nameToPos = whitelistedVariables\n ? new Map(whitelistedVariables.map((v, i) => [printRaw(v), i]))\n : new Map(varNames.map((name, i) => [name, i]));\n\n return new Map(\n Array.from(varMap.entries()).map(([variable, name]) => {\n return [variable, nameToPos.get(name) ?? -1];\n })\n );\n}\n\n/**\n * Make an array of arrays representing the operation/content of each item in an equation\n * + the annotation. The return value is suitable to be joined with `&` for the body of an array.\n */\nfunction processLine(\n line: SystemeSpec.Line,\n numVars: number,\n varOrder: Map,\n hasEquals: boolean,\n hasAnnotation: boolean\n) {\n const ret: Ast.Node[][] = [];\n if (line.equation) {\n // We need to combine all non-var items into a single expression\n const nonVarItems = line.equation.left.filter(\n (item) => item.variable == null\n );\n const varItems = line.equation.left.filter(\n (item) => item.variable != null\n );\n let nonVarTerm: SystemeSpec.Item | null = null;\n if (nonVarItems.length === 1) {\n nonVarTerm = nonVarItems[0];\n } else if (nonVarItems.length > 1) {\n // We need to combine all the items. We do so by constructing a new item with the rest of the item's contents\n // added on the back\n nonVarTerm = {\n ...nonVarItems[0],\n content: nonVarItems[0].content.concat(\n nonVarItems.slice(1).flatMap((item) => {\n if (item.op) {\n return [item.op, ...item.content];\n }\n return [PLUS, ...item.content];\n })\n ),\n };\n }\n\n const allItems = nonVarTerm ? varItems.concat(nonVarTerm) : varItems;\n\n const indexToItem = new Map(\n allItems.map((item) => {\n if (item.variable == null) {\n return [numVars - 1, item];\n }\n return [varOrder.get(item.variable), item];\n })\n );\n\n let isFirstItem = true;\n for (let i = 0; i < numVars; i++) {\n const item = indexToItem.get(i);\n if (item) {\n if (\n isFirstItem &&\n (match.string(item.op, \"+\") || item.op == null)\n ) {\n // If the first item starts with a plus or doesn't have a starting operation,\n // we don't use a starting symbol.\n ret.push([]);\n ret.push(item.content);\n } else {\n // If we are not the first item, we always push an operation\n ret.push([item.op || PLUS]);\n ret.push(item.content);\n }\n isFirstItem = false;\n } else {\n // If there is no item for this position, we push a blank operation and content\n ret.push([]);\n ret.push([]);\n }\n }\n // If we have an equals, we need to push its contents\n if (hasEquals) {\n const equalsPart = (\n line.equation.equals ? [line.equation.equals] : []\n ).concat(line.equation.right);\n ret.push(equalsPart);\n }\n }\n // If we have an annotation, we need to push it or a blank\n if (hasAnnotation) {\n ret.push(line.annotation ? line.annotation.content : []);\n }\n\n return ret;\n}\n\n/**\n * Add kerning information to the array specification. E.g. `crl` becomes `c@{\\mkern5mu}r@{\\mkern5mu}l`.\n * This is so the operations when typesetting a system of equations are properly spaced.\n */\nfunction arraySpecToSpacedArraySpec(spec: string, hasAnnotation?: boolean) {\n const annotationSpec = hasAnnotation ? spec.charAt(spec.length - 1) : \"\";\n const bodySpec = hasAnnotation ? spec.slice(0, spec.length - 1) : spec;\n\n const bodyStrings: Ast.Node[][] = Array.from(bodySpec).map((x) => [\n { type: \"string\", content: x },\n ]);\n const body = arrayJoin(bodyStrings, COLUMN_KERN_ADJUSTMENT);\n return annotationSpec\n ? body.concat({ type: \"string\", content: annotationSpec })\n : body;\n}\n\n/**\n * Extract the variables from a systeme system of equations.\n */\nexport function extractVariables(nodes: SystemeSpec.Node[]): Ast.Node[][] {\n return nodes.flatMap((node) => {\n if (node.type === \"line\" && node.equation) {\n return extractVariables(node.equation.left);\n }\n if (node.type === \"equation\") {\n return node.left.flatMap((item) =>\n item.variable ? [item.variable] : []\n );\n }\n if (node.type === \"item\") {\n return node.variable ? [node.variable] : [];\n }\n return [];\n });\n}\n\n/**\n * Remove any whitespace from the variable list (including an explicit \" \" string).\n * As well, filter out any non-macro/non-string items.\n */\nfunction normalizeVariableWhitelist(\n vars: (string | Ast.Node)[] | null | undefined\n) {\n if (!vars) {\n return null;\n }\n const normalized: Ast.Node[] = vars.map((v) =>\n typeof v === \"string\" ? { type: \"string\", content: v } : v\n );\n const ret = normalized.filter(\n (v) =>\n (match.anyMacro(v) || match.anyString(v)) &&\n !match.string(v, \" \") &&\n !match.whitespace(v)\n ) as (Ast.Macro | Ast.String)[];\n return ret;\n}\n\n/**\n * Lays out the contents of a \\systeme{...} macro as an array. This function sorts the variables\n * in alphabetical order and lays out any annotations. An `\\begin{array}...\\end{array}` environment\n * is returned.\n *\n * If `properSpacing=true` then kerning information will be included in the array specification to space\n * the operators correctly. This kerning information will make the specification long (and may make it incompatible\n * with KaTeX).\n *\n * An optional whitelist of variables may be supplied. If supplied, only listed items will count as variables and\n * the order of variable appearance will be the same as the order of the whitelisted variables.\n */\nexport function systemeContentsToArray(\n nodes: Ast.Node[],\n options?: {\n properSpacing?: boolean;\n whitelistedVariables?: (string | Ast.String | Ast.Macro)[];\n }\n) {\n nodes = structuredClone(nodes);\n deleteComments(nodes);\n const { properSpacing = true, whitelistedVariables } = options || {};\n const coercedWhitelistedVariables =\n normalizeVariableWhitelist(whitelistedVariables);\n const systemeAst = parse(nodes, { whitelistedVariables });\n const vars = extractVariables(systemeAst);\n const varOrder = sortVariables(vars, coercedWhitelistedVariables);\n let numVars = coercedWhitelistedVariables\n ? coercedWhitelistedVariables.length\n : Math.max(...Array.from(varOrder.values())) + 1;\n // If there are terms with no variable, we need a spot for them\n if (\n systemeAst.some((line) => {\n if (line.equation) {\n return line.equation.left.some((item) => item.variable == null);\n }\n })\n ) {\n numVars += 1;\n }\n const hasEquals = systemeAst.some(\n (line) => line.equation && line.equation.equals\n );\n const hasAnnotation = systemeAst.some((line) => line.annotation);\n\n let rows = systemeAst.map((line) =>\n processLine(line, numVars, varOrder, hasEquals, hasAnnotation)\n );\n // If we have no leading `-` signs (e.g., only leading `+` or bank signs)\n // We don't need space for the first operation to be stored\n const noLeadingOperation = rows.every((row) => row[0].length === 0);\n\n // Every item in an equation has a centered operation and a right-aligned variable part.\n let arraySignature = Array.from({ length: numVars }, () => \"cr\").join(\"\");\n if (noLeadingOperation) {\n // We might not have a leading operation on the first item(s)\n arraySignature = arraySignature.slice(1);\n rows = rows.map((row) => row.slice(1));\n }\n if (hasEquals) {\n // The part after the equals is left-aligned\n arraySignature += \"l\";\n }\n if (hasAnnotation) {\n // The annotation is left-aligned\n arraySignature += \"l\";\n // We also manually insert space in front of any annotation\n rows = rows.map((row) => {\n if (row[row.length - 1].length === 0) {\n return row;\n }\n return [\n ...row.slice(0, row.length - 1),\n [QUAD, { type: \"whitespace\" }, ...row[row.length - 1]],\n ];\n });\n }\n\n // By default, the array signature will put lots of space between items.\n // We can correct for that manually.\n const arraySignatureWithSpacing: Ast.Node[] = properSpacing\n ? arraySpecToSpacedArraySpec(arraySignature, hasAnnotation)\n : [{ type: \"string\", content: arraySignature }];\n\n const bodyRows = rows.map((row) => arrayJoin(row, AMP));\n const body = arrayJoin(bodyRows, SEP);\n\n const ret: Ast.Environment = {\n type: \"environment\",\n env: \"array\",\n args: [\n {\n type: \"argument\",\n openMark: \"{\",\n closeMark: \"}\",\n content: arraySignatureWithSpacing,\n },\n ],\n content: body,\n };\n\n return ret;\n}\n\n/**\n * Find any systeme definitions, e.g. `\\sysdelim{.}{.}`, and attach their information\n * to the renderInfo of of the systeme macros.\n *\n */\nexport function attachSystemeSettingsAsRenderInfo(ast: Ast.Ast) {\n const systemeMatcher = match.createMacroMatcher([\"systeme\", \"sysdelim\"]);\n\n visit(\n ast,\n (nodes, info) => {\n if (!info.context.inMathMode || !nodes.some(systemeMatcher)) {\n return;\n }\n // Find the positions of the systeme and sysdelim macros\n const systemeLocations = nodes.flatMap((node, i) =>\n match.macro(node, \"systeme\") ? i : []\n );\n const sysdelimLocations = nodes.flatMap((node, i) =>\n match.macro(node, \"sysdelim\") ? i : []\n );\n\n if (\n systemeLocations.length === 0 ||\n sysdelimLocations.length === 0\n ) {\n return;\n }\n\n for (const i of systemeLocations) {\n // Find any sysdelim macros that occur before\n const lastSysdelim = Math.max(\n ...sysdelimLocations.filter((loc) => loc < i)\n );\n if (lastSysdelim >= 0) {\n const node = nodes[i];\n const sysdelimMacro = nodes[lastSysdelim];\n if (!match.anyMacro(sysdelimMacro)) {\n throw new Error(\n `Expecting sysdelim macro but found \"${printRaw(\n sysdelimMacro\n )}\"`\n );\n }\n const args = getArgsContent(sysdelimMacro);\n updateRenderInfo(node, { sysdelims: args });\n }\n }\n },\n {\n test: Array.isArray,\n includeArrays: true,\n }\n );\n}\n"],"names":["match","decorateArrayForPegjs","SystemePegParser","latexPrintRaw","printRaw","arrayJoin","structuredClone","deleteComments","visit","getArgsContent","updateRenderInfo"],"mappings":"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"} \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-ctan/package/systeme/index.d.ts b/node_modules/@unified-latex/unified-latex-ctan/package/systeme/index.d.ts new file mode 100644 index 0000000..5632dad --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-ctan/package/systeme/index.d.ts @@ -0,0 +1,6 @@ +export * from './provides'; +export * from './libs/parser'; +export * from './libs/print-raw'; +export * from './libs/types'; +export * from './libs/systeme'; +//# sourceMappingURL=index.d.ts.map \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-ctan/package/systeme/index.js b/node_modules/@unified-latex/unified-latex-ctan/package/systeme/index.js new file mode 100644 index 0000000..c91ca80 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-ctan/package/systeme/index.js @@ -0,0 +1,331 @@ +import { e, m } from "../../provides-yGf6-zdY.js"; +import { match } from "@unified-latex/unified-latex-util-match"; +import { decorateArrayForPegjs, SystemePegParser } from "@unified-latex/unified-latex-util-pegjs"; +import { printRaw as printRaw$1 } from "@unified-latex/unified-latex-util-print-raw"; +import { arrayJoin } from "@unified-latex/unified-latex-util-split"; +import { s as structuredClone } from "../../index-NHd3tQDq.js"; +import { deleteComments } from "@unified-latex/unified-latex-util-comments"; +import { visit } from "@unified-latex/unified-latex-util-visit"; +import { updateRenderInfo } from "@unified-latex/unified-latex-util-render-info"; +import { getArgsContent } from "@unified-latex/unified-latex-util-arguments"; +function createMatchers({ + at = "@", + equals = "=", + equationSeparator = ",", + mathOperations = ["+", "-"], + whitelistedVariables +} = {}) { + let isVar = (node) => match.anyString(node) && !!node.content.match(/[a-zA-Z]/); + if (whitelistedVariables) { + whitelistedVariables = whitelistedVariables.map( + (v) => match.anyString(v) ? v.content : v + ); + const macros = whitelistedVariables.filter( + (v) => match.anyMacro(v) + ); + const strings = whitelistedVariables.filter( + (v) => typeof v === "string" + ); + const macroHash = Object.fromEntries(macros.map((v) => [v.content, v])); + const stringHash = Object.fromEntries(strings.map((s) => [s, s])); + const macroMatcher = match.createMacroMatcher(macroHash); + isVar = (node) => macroMatcher(node) || match.anyString(node) && !!stringHash[node.content]; + } + return { + isSep: (node) => match.string(node, equationSeparator), + isVar, + isOperation: (node) => mathOperations.some((op) => match.string(node, op)), + isEquals: (node) => match.string(node, equals), + isAt: (node) => match.string(node, at), + isSubscript: (node) => match.macro(node, "_") && node.escapeToken === "", + isWhitespace: match.whitespace, + isSameLineComment: (node) => match.comment(node) && node.sameline, + isOwnLineComment: (node) => match.comment(node) && !node.sameline + }; +} +function parse(ast, options) { + if (!Array.isArray(ast)) { + throw new Error("You must pass an array of nodes"); + } + ast = decorateArrayForPegjs([...ast]); + return SystemePegParser.parse( + ast, + createMatchers(options || {}) + ); +} +function printRaw(node, root = false) { + if (typeof node === "string") { + return node; + } + if (Array.isArray(node)) { + const sepToken = root ? " " : ""; + return node.map((tok) => printRaw(tok)).join(sepToken); + } + switch (node.type) { + case "annotation": + return `${printRaw$1(node.marker)}${printRaw$1( + node.content + )}`; + case "item": + return `${node.op ? printRaw$1(node.op) : ""}${printRaw$1( + node.content + )}`; + case "equation": + const left = node.left.map((n) => printRaw(n)).join(""); + const right = printRaw$1(node.right); + const equals = node.equals ? printRaw$1(node.equals) : ""; + return `${left}${equals}${right}`; + case "line": + const equation = node.equation ? printRaw(node.equation) : ""; + const annotation = node.annotation ? printRaw(node.annotation) : ""; + const sep = node.sep ? printRaw$1(node.sep) : ""; + const body = `${equation}${annotation}${sep}`; + if (node.trailingComment) { + return printRaw$1([body, node.trailingComment]); + } + return body; + default: + console.warn( + `Unknown node type "${node.type}" for node`, + node + ); + return ""; + } +} +const AMP = { type: "string", content: "&" }; +const SEP = { type: "macro", content: "\\" }; +const QUAD = { type: "macro", content: "quad" }; +const PLUS = { type: "string", content: "+" }; +const COLUMN_KERN_ADJUSTMENT = [ + { type: "string", content: "@" }, + { + type: "group", + content: [ + { type: "macro", content: "mkern" }, + { type: "string", content: "5mu" } + ] + } +]; +function sortVariables(vars, whitelistedVariables) { + const varMap = new Map(vars.map((v) => [v, printRaw$1(v)])); + const varNames = Array.from(new Set(varMap.values())); + varNames.sort(); + const nameToPos = whitelistedVariables ? new Map(whitelistedVariables.map((v, i) => [printRaw$1(v), i])) : new Map(varNames.map((name, i) => [name, i])); + return new Map( + Array.from(varMap.entries()).map(([variable, name]) => { + return [variable, nameToPos.get(name) ?? -1]; + }) + ); +} +function processLine(line, numVars, varOrder, hasEquals, hasAnnotation) { + const ret = []; + if (line.equation) { + const nonVarItems = line.equation.left.filter( + (item) => item.variable == null + ); + const varItems = line.equation.left.filter( + (item) => item.variable != null + ); + let nonVarTerm = null; + if (nonVarItems.length === 1) { + nonVarTerm = nonVarItems[0]; + } else if (nonVarItems.length > 1) { + nonVarTerm = { + ...nonVarItems[0], + content: nonVarItems[0].content.concat( + nonVarItems.slice(1).flatMap((item) => { + if (item.op) { + return [item.op, ...item.content]; + } + return [PLUS, ...item.content]; + }) + ) + }; + } + const allItems = nonVarTerm ? varItems.concat(nonVarTerm) : varItems; + const indexToItem = new Map( + allItems.map((item) => { + if (item.variable == null) { + return [numVars - 1, item]; + } + return [varOrder.get(item.variable), item]; + }) + ); + let isFirstItem = true; + for (let i = 0; i < numVars; i++) { + const item = indexToItem.get(i); + if (item) { + if (isFirstItem && (match.string(item.op, "+") || item.op == null)) { + ret.push([]); + ret.push(item.content); + } else { + ret.push([item.op || PLUS]); + ret.push(item.content); + } + isFirstItem = false; + } else { + ret.push([]); + ret.push([]); + } + } + if (hasEquals) { + const equalsPart = (line.equation.equals ? [line.equation.equals] : []).concat(line.equation.right); + ret.push(equalsPart); + } + } + if (hasAnnotation) { + ret.push(line.annotation ? line.annotation.content : []); + } + return ret; +} +function arraySpecToSpacedArraySpec(spec, hasAnnotation) { + const annotationSpec = hasAnnotation ? spec.charAt(spec.length - 1) : ""; + const bodySpec = hasAnnotation ? spec.slice(0, spec.length - 1) : spec; + const bodyStrings = Array.from(bodySpec).map((x) => [ + { type: "string", content: x } + ]); + const body = arrayJoin(bodyStrings, COLUMN_KERN_ADJUSTMENT); + return annotationSpec ? body.concat({ type: "string", content: annotationSpec }) : body; +} +function extractVariables(nodes) { + return nodes.flatMap((node) => { + if (node.type === "line" && node.equation) { + return extractVariables(node.equation.left); + } + if (node.type === "equation") { + return node.left.flatMap( + (item) => item.variable ? [item.variable] : [] + ); + } + if (node.type === "item") { + return node.variable ? [node.variable] : []; + } + return []; + }); +} +function normalizeVariableWhitelist(vars) { + if (!vars) { + return null; + } + const normalized = vars.map( + (v) => typeof v === "string" ? { type: "string", content: v } : v + ); + const ret = normalized.filter( + (v) => (match.anyMacro(v) || match.anyString(v)) && !match.string(v, " ") && !match.whitespace(v) + ); + return ret; +} +function systemeContentsToArray(nodes, options) { + nodes = structuredClone(nodes); + deleteComments(nodes); + const { properSpacing = true, whitelistedVariables } = options || {}; + const coercedWhitelistedVariables = normalizeVariableWhitelist(whitelistedVariables); + const systemeAst = parse(nodes, { whitelistedVariables }); + const vars = extractVariables(systemeAst); + const varOrder = sortVariables(vars, coercedWhitelistedVariables); + let numVars = coercedWhitelistedVariables ? coercedWhitelistedVariables.length : Math.max(...Array.from(varOrder.values())) + 1; + if (systemeAst.some((line) => { + if (line.equation) { + return line.equation.left.some((item) => item.variable == null); + } + })) { + numVars += 1; + } + const hasEquals = systemeAst.some( + (line) => line.equation && line.equation.equals + ); + const hasAnnotation = systemeAst.some((line) => line.annotation); + let rows = systemeAst.map( + (line) => processLine(line, numVars, varOrder, hasEquals, hasAnnotation) + ); + const noLeadingOperation = rows.every((row) => row[0].length === 0); + let arraySignature = Array.from({ length: numVars }, () => "cr").join(""); + if (noLeadingOperation) { + arraySignature = arraySignature.slice(1); + rows = rows.map((row) => row.slice(1)); + } + if (hasEquals) { + arraySignature += "l"; + } + if (hasAnnotation) { + arraySignature += "l"; + rows = rows.map((row) => { + if (row[row.length - 1].length === 0) { + return row; + } + return [ + ...row.slice(0, row.length - 1), + [QUAD, { type: "whitespace" }, ...row[row.length - 1]] + ]; + }); + } + const arraySignatureWithSpacing = properSpacing ? arraySpecToSpacedArraySpec(arraySignature, hasAnnotation) : [{ type: "string", content: arraySignature }]; + const bodyRows = rows.map((row) => arrayJoin(row, AMP)); + const body = arrayJoin(bodyRows, SEP); + const ret = { + type: "environment", + env: "array", + args: [ + { + type: "argument", + openMark: "{", + closeMark: "}", + content: arraySignatureWithSpacing + } + ], + content: body + }; + return ret; +} +function attachSystemeSettingsAsRenderInfo(ast) { + const systemeMatcher = match.createMacroMatcher(["systeme", "sysdelim"]); + visit( + ast, + (nodes, info) => { + if (!info.context.inMathMode || !nodes.some(systemeMatcher)) { + return; + } + const systemeLocations = nodes.flatMap( + (node, i) => match.macro(node, "systeme") ? i : [] + ); + const sysdelimLocations = nodes.flatMap( + (node, i) => match.macro(node, "sysdelim") ? i : [] + ); + if (systemeLocations.length === 0 || sysdelimLocations.length === 0) { + return; + } + for (const i of systemeLocations) { + const lastSysdelim = Math.max( + ...sysdelimLocations.filter((loc) => loc < i) + ); + if (lastSysdelim >= 0) { + const node = nodes[i]; + const sysdelimMacro = nodes[lastSysdelim]; + if (!match.anyMacro(sysdelimMacro)) { + throw new Error( + `Expecting sysdelim macro but found "${printRaw$1( + sysdelimMacro + )}"` + ); + } + const args = getArgsContent(sysdelimMacro); + updateRenderInfo(node, { sysdelims: args }); + } + } + }, + { + test: Array.isArray, + includeArrays: true + } + ); +} +export { + attachSystemeSettingsAsRenderInfo, + e as environments, + extractVariables, + m as macros, + parse, + printRaw, + systemeContentsToArray +}; +//# sourceMappingURL=index.js.map diff --git a/node_modules/@unified-latex/unified-latex-ctan/package/systeme/index.js.map b/node_modules/@unified-latex/unified-latex-ctan/package/systeme/index.js.map new file mode 100644 index 0000000..f2db1f1 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-ctan/package/systeme/index.js.map @@ -0,0 +1 @@ +{"version":3,"file":"index.js","sources":["../../../package/systeme/libs/parser.ts","../../../package/systeme/libs/print-raw.ts","../../../package/systeme/libs/systeme.ts"],"sourcesContent":["import * as Ast from \"@unified-latex/unified-latex-types\";\nimport * as SystemeSpec from \"./types\";\nimport { match } from \"@unified-latex/unified-latex-util-match\";\nimport { decorateArrayForPegjs } from \"@unified-latex/unified-latex-util-pegjs\";\nimport { SystemePegParser } from \"@unified-latex/unified-latex-util-pegjs\";\n\ntype SystemeMatchers = {\n at?: string;\n equals?: string;\n equationSeparator?: string;\n mathOperations?: string[];\n whitelistedVariables?: (string | Ast.String | Ast.Macro)[];\n};\n\nfunction createMatchers({\n at = \"@\",\n equals = \"=\",\n equationSeparator = \",\",\n mathOperations = [\"+\", \"-\"],\n whitelistedVariables,\n}: SystemeMatchers = {}) {\n let isVar: (node: Ast.Node) => boolean = (node: Ast.Node) =>\n match.anyString(node) && !!node.content.match(/[a-zA-Z]/);\n if (whitelistedVariables) {\n // Unwrap all strings\n whitelistedVariables = whitelistedVariables.map((v) =>\n match.anyString(v) ? v.content : v\n );\n const macros = whitelistedVariables.filter((v) =>\n match.anyMacro(v)\n ) as Ast.Macro[];\n const strings = whitelistedVariables.filter(\n (v) => typeof v === \"string\"\n ) as string[];\n const macroHash = Object.fromEntries(macros.map((v) => [v.content, v]));\n const stringHash = Object.fromEntries(strings.map((s) => [s, s]));\n const macroMatcher = match.createMacroMatcher(macroHash);\n isVar = (node: Ast.Node) =>\n macroMatcher(node) ||\n (match.anyString(node) && !!stringHash[node.content]);\n }\n return {\n isSep: (node: Ast.Node) => match.string(node, equationSeparator),\n isVar,\n isOperation: (node: Ast.Node) =>\n mathOperations.some((op) => match.string(node, op)),\n isEquals: (node: Ast.Node) => match.string(node, equals),\n isAt: (node: Ast.Node) => match.string(node, at),\n isSubscript: (node: Ast.Node) =>\n match.macro(node, \"_\") && node.escapeToken === \"\",\n isWhitespace: match.whitespace,\n isSameLineComment: (node: Ast.Node) =>\n match.comment(node) && node.sameline,\n isOwnLineComment: (node: Ast.Node) =>\n match.comment(node) && !node.sameline,\n };\n}\n\n/**\n * Parse the contents of the `\\systeme{...}` macro\n */\nexport function parse(\n ast: Ast.Node[],\n options?: SystemeMatchers\n): SystemeSpec.Line[] {\n if (!Array.isArray(ast)) {\n throw new Error(\"You must pass an array of nodes\");\n }\n // We need to at functions to `nodes` so that it imitates\n // a Javascript string. Because we're mutating, make a copy first\n ast = decorateArrayForPegjs([...ast]);\n // matchers are passed in via the second argument (the `options` argument)\n // so they are available from within the Pegjs grammar.\n return SystemePegParser.parse(\n ast,\n createMatchers(options || {})\n ) as SystemeSpec.Line[];\n}\n","import { printRaw as latexPrintRaw } from \"@unified-latex/unified-latex-util-print-raw\";\nimport * as SystemeSpec from \"./types\";\n\n/**\n * Print an `systeme` argument specification AST to a string.\n */\nexport function printRaw(node: SystemeSpec.Ast, root = false): string {\n if (typeof node === \"string\") {\n return node;\n }\n\n if (Array.isArray(node)) {\n const sepToken = root ? \" \" : \"\";\n return node.map((tok) => printRaw(tok)).join(sepToken);\n }\n\n switch (node.type) {\n case \"annotation\":\n return `${latexPrintRaw(node.marker)}${latexPrintRaw(\n node.content\n )}`;\n case \"item\":\n return `${node.op ? latexPrintRaw(node.op) : \"\"}${latexPrintRaw(\n node.content\n )}`;\n case \"equation\":\n const left = node.left.map((n) => printRaw(n)).join(\"\");\n const right = latexPrintRaw(node.right);\n const equals = node.equals ? latexPrintRaw(node.equals) : \"\";\n return `${left}${equals}${right}`;\n case \"line\":\n const equation = node.equation ? printRaw(node.equation) : \"\";\n const annotation = node.annotation ? printRaw(node.annotation) : \"\";\n const sep = node.sep ? latexPrintRaw(node.sep) : \"\";\n\n const body = `${equation}${annotation}${sep}`;\n if (node.trailingComment) {\n return latexPrintRaw([body, node.trailingComment]);\n }\n\n return body;\n\n default:\n console.warn(\n `Unknown node type \"${(node as any).type}\" for node`,\n node\n );\n return \"\";\n }\n}\n","import * as SystemeSpec from \"./types\";\nimport * as Ast from \"@unified-latex/unified-latex-types\";\nimport { printRaw } from \"@unified-latex/unified-latex-util-print-raw\";\nimport { match } from \"@unified-latex/unified-latex-util-match\";\nimport { arrayJoin } from \"@unified-latex/unified-latex-util-split\";\nimport { parse } from \"./parser\";\nimport { structuredClone } from \"@unified-latex/structured-clone\";\nimport { deleteComments } from \"@unified-latex/unified-latex-util-comments\";\nimport { visit } from \"@unified-latex/unified-latex-util-visit\";\nimport { updateRenderInfo } from \"@unified-latex/unified-latex-util-render-info\";\nimport { getArgsContent } from \"@unified-latex/unified-latex-util-arguments\";\n\nconst AMP: Ast.String = { type: \"string\", content: \"&\" };\nconst SEP: Ast.Macro = { type: \"macro\", content: \"\\\\\" };\nconst QUAD: Ast.Macro = { type: \"macro\", content: \"quad\" };\nconst PLUS: Ast.String = { type: \"string\", content: \"+\" };\nconst COLUMN_KERN_ADJUSTMENT: Ast.Node[] = [\n { type: \"string\", content: \"@\" },\n {\n type: \"group\",\n content: [\n { type: \"macro\", content: \"mkern\" },\n { type: \"string\", content: \"5mu\" },\n ],\n },\n];\n\n/**\n * Return a map giving the sorted index of each variable in `vars`. There\n * may be duplicated variables in `vars`. The map will send duplicates to the same index.\n *\n * @param {Ast.Node[][]} vars\n * @returns\n */\nfunction sortVariables(\n vars: Ast.Node[][],\n whitelistedVariables?: Ast.Node[] | null\n) {\n const varMap = new Map(vars.map((v) => [v, printRaw(v)]));\n const varNames = Array.from(new Set(varMap.values()));\n varNames.sort();\n const nameToPos = whitelistedVariables\n ? new Map(whitelistedVariables.map((v, i) => [printRaw(v), i]))\n : new Map(varNames.map((name, i) => [name, i]));\n\n return new Map(\n Array.from(varMap.entries()).map(([variable, name]) => {\n return [variable, nameToPos.get(name) ?? -1];\n })\n );\n}\n\n/**\n * Make an array of arrays representing the operation/content of each item in an equation\n * + the annotation. The return value is suitable to be joined with `&` for the body of an array.\n */\nfunction processLine(\n line: SystemeSpec.Line,\n numVars: number,\n varOrder: Map,\n hasEquals: boolean,\n hasAnnotation: boolean\n) {\n const ret: Ast.Node[][] = [];\n if (line.equation) {\n // We need to combine all non-var items into a single expression\n const nonVarItems = line.equation.left.filter(\n (item) => item.variable == null\n );\n const varItems = line.equation.left.filter(\n (item) => item.variable != null\n );\n let nonVarTerm: SystemeSpec.Item | null = null;\n if (nonVarItems.length === 1) {\n nonVarTerm = nonVarItems[0];\n } else if (nonVarItems.length > 1) {\n // We need to combine all the items. We do so by constructing a new item with the rest of the item's contents\n // added on the back\n nonVarTerm = {\n ...nonVarItems[0],\n content: nonVarItems[0].content.concat(\n nonVarItems.slice(1).flatMap((item) => {\n if (item.op) {\n return [item.op, ...item.content];\n }\n return [PLUS, ...item.content];\n })\n ),\n };\n }\n\n const allItems = nonVarTerm ? varItems.concat(nonVarTerm) : varItems;\n\n const indexToItem = new Map(\n allItems.map((item) => {\n if (item.variable == null) {\n return [numVars - 1, item];\n }\n return [varOrder.get(item.variable), item];\n })\n );\n\n let isFirstItem = true;\n for (let i = 0; i < numVars; i++) {\n const item = indexToItem.get(i);\n if (item) {\n if (\n isFirstItem &&\n (match.string(item.op, \"+\") || item.op == null)\n ) {\n // If the first item starts with a plus or doesn't have a starting operation,\n // we don't use a starting symbol.\n ret.push([]);\n ret.push(item.content);\n } else {\n // If we are not the first item, we always push an operation\n ret.push([item.op || PLUS]);\n ret.push(item.content);\n }\n isFirstItem = false;\n } else {\n // If there is no item for this position, we push a blank operation and content\n ret.push([]);\n ret.push([]);\n }\n }\n // If we have an equals, we need to push its contents\n if (hasEquals) {\n const equalsPart = (\n line.equation.equals ? [line.equation.equals] : []\n ).concat(line.equation.right);\n ret.push(equalsPart);\n }\n }\n // If we have an annotation, we need to push it or a blank\n if (hasAnnotation) {\n ret.push(line.annotation ? line.annotation.content : []);\n }\n\n return ret;\n}\n\n/**\n * Add kerning information to the array specification. E.g. `crl` becomes `c@{\\mkern5mu}r@{\\mkern5mu}l`.\n * This is so the operations when typesetting a system of equations are properly spaced.\n */\nfunction arraySpecToSpacedArraySpec(spec: string, hasAnnotation?: boolean) {\n const annotationSpec = hasAnnotation ? spec.charAt(spec.length - 1) : \"\";\n const bodySpec = hasAnnotation ? spec.slice(0, spec.length - 1) : spec;\n\n const bodyStrings: Ast.Node[][] = Array.from(bodySpec).map((x) => [\n { type: \"string\", content: x },\n ]);\n const body = arrayJoin(bodyStrings, COLUMN_KERN_ADJUSTMENT);\n return annotationSpec\n ? body.concat({ type: \"string\", content: annotationSpec })\n : body;\n}\n\n/**\n * Extract the variables from a systeme system of equations.\n */\nexport function extractVariables(nodes: SystemeSpec.Node[]): Ast.Node[][] {\n return nodes.flatMap((node) => {\n if (node.type === \"line\" && node.equation) {\n return extractVariables(node.equation.left);\n }\n if (node.type === \"equation\") {\n return node.left.flatMap((item) =>\n item.variable ? [item.variable] : []\n );\n }\n if (node.type === \"item\") {\n return node.variable ? [node.variable] : [];\n }\n return [];\n });\n}\n\n/**\n * Remove any whitespace from the variable list (including an explicit \" \" string).\n * As well, filter out any non-macro/non-string items.\n */\nfunction normalizeVariableWhitelist(\n vars: (string | Ast.Node)[] | null | undefined\n) {\n if (!vars) {\n return null;\n }\n const normalized: Ast.Node[] = vars.map((v) =>\n typeof v === \"string\" ? { type: \"string\", content: v } : v\n );\n const ret = normalized.filter(\n (v) =>\n (match.anyMacro(v) || match.anyString(v)) &&\n !match.string(v, \" \") &&\n !match.whitespace(v)\n ) as (Ast.Macro | Ast.String)[];\n return ret;\n}\n\n/**\n * Lays out the contents of a \\systeme{...} macro as an array. This function sorts the variables\n * in alphabetical order and lays out any annotations. An `\\begin{array}...\\end{array}` environment\n * is returned.\n *\n * If `properSpacing=true` then kerning information will be included in the array specification to space\n * the operators correctly. This kerning information will make the specification long (and may make it incompatible\n * with KaTeX).\n *\n * An optional whitelist of variables may be supplied. If supplied, only listed items will count as variables and\n * the order of variable appearance will be the same as the order of the whitelisted variables.\n */\nexport function systemeContentsToArray(\n nodes: Ast.Node[],\n options?: {\n properSpacing?: boolean;\n whitelistedVariables?: (string | Ast.String | Ast.Macro)[];\n }\n) {\n nodes = structuredClone(nodes);\n deleteComments(nodes);\n const { properSpacing = true, whitelistedVariables } = options || {};\n const coercedWhitelistedVariables =\n normalizeVariableWhitelist(whitelistedVariables);\n const systemeAst = parse(nodes, { whitelistedVariables });\n const vars = extractVariables(systemeAst);\n const varOrder = sortVariables(vars, coercedWhitelistedVariables);\n let numVars = coercedWhitelistedVariables\n ? coercedWhitelistedVariables.length\n : Math.max(...Array.from(varOrder.values())) + 1;\n // If there are terms with no variable, we need a spot for them\n if (\n systemeAst.some((line) => {\n if (line.equation) {\n return line.equation.left.some((item) => item.variable == null);\n }\n })\n ) {\n numVars += 1;\n }\n const hasEquals = systemeAst.some(\n (line) => line.equation && line.equation.equals\n );\n const hasAnnotation = systemeAst.some((line) => line.annotation);\n\n let rows = systemeAst.map((line) =>\n processLine(line, numVars, varOrder, hasEquals, hasAnnotation)\n );\n // If we have no leading `-` signs (e.g., only leading `+` or bank signs)\n // We don't need space for the first operation to be stored\n const noLeadingOperation = rows.every((row) => row[0].length === 0);\n\n // Every item in an equation has a centered operation and a right-aligned variable part.\n let arraySignature = Array.from({ length: numVars }, () => \"cr\").join(\"\");\n if (noLeadingOperation) {\n // We might not have a leading operation on the first item(s)\n arraySignature = arraySignature.slice(1);\n rows = rows.map((row) => row.slice(1));\n }\n if (hasEquals) {\n // The part after the equals is left-aligned\n arraySignature += \"l\";\n }\n if (hasAnnotation) {\n // The annotation is left-aligned\n arraySignature += \"l\";\n // We also manually insert space in front of any annotation\n rows = rows.map((row) => {\n if (row[row.length - 1].length === 0) {\n return row;\n }\n return [\n ...row.slice(0, row.length - 1),\n [QUAD, { type: \"whitespace\" }, ...row[row.length - 1]],\n ];\n });\n }\n\n // By default, the array signature will put lots of space between items.\n // We can correct for that manually.\n const arraySignatureWithSpacing: Ast.Node[] = properSpacing\n ? arraySpecToSpacedArraySpec(arraySignature, hasAnnotation)\n : [{ type: \"string\", content: arraySignature }];\n\n const bodyRows = rows.map((row) => arrayJoin(row, AMP));\n const body = arrayJoin(bodyRows, SEP);\n\n const ret: Ast.Environment = {\n type: \"environment\",\n env: \"array\",\n args: [\n {\n type: \"argument\",\n openMark: \"{\",\n closeMark: \"}\",\n content: arraySignatureWithSpacing,\n },\n ],\n content: body,\n };\n\n return ret;\n}\n\n/**\n * Find any systeme definitions, e.g. `\\sysdelim{.}{.}`, and attach their information\n * to the renderInfo of of the systeme macros.\n *\n */\nexport function attachSystemeSettingsAsRenderInfo(ast: Ast.Ast) {\n const systemeMatcher = match.createMacroMatcher([\"systeme\", \"sysdelim\"]);\n\n visit(\n ast,\n (nodes, info) => {\n if (!info.context.inMathMode || !nodes.some(systemeMatcher)) {\n return;\n }\n // Find the positions of the systeme and sysdelim macros\n const systemeLocations = nodes.flatMap((node, i) =>\n match.macro(node, \"systeme\") ? i : []\n );\n const sysdelimLocations = nodes.flatMap((node, i) =>\n match.macro(node, \"sysdelim\") ? i : []\n );\n\n if (\n systemeLocations.length === 0 ||\n sysdelimLocations.length === 0\n ) {\n return;\n }\n\n for (const i of systemeLocations) {\n // Find any sysdelim macros that occur before\n const lastSysdelim = Math.max(\n ...sysdelimLocations.filter((loc) => loc < i)\n );\n if (lastSysdelim >= 0) {\n const node = nodes[i];\n const sysdelimMacro = nodes[lastSysdelim];\n if (!match.anyMacro(sysdelimMacro)) {\n throw new Error(\n `Expecting sysdelim macro but found \"${printRaw(\n sysdelimMacro\n )}\"`\n );\n }\n const args = getArgsContent(sysdelimMacro);\n updateRenderInfo(node, { sysdelims: args });\n }\n }\n },\n {\n test: Array.isArray,\n includeArrays: true,\n }\n );\n}\n"],"names":["latexPrintRaw","printRaw"],"mappings":"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"} \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-ctan/package/systeme/libs/parser.d.ts b/node_modules/@unified-latex/unified-latex-ctan/package/systeme/libs/parser.d.ts new file mode 100644 index 0000000..b483900 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-ctan/package/systeme/libs/parser.d.ts @@ -0,0 +1,15 @@ +import * as Ast from "@unified-latex/unified-latex-types"; +import * as SystemeSpec from "./types"; +type SystemeMatchers = { + at?: string; + equals?: string; + equationSeparator?: string; + mathOperations?: string[]; + whitelistedVariables?: (string | Ast.String | Ast.Macro)[]; +}; +/** + * Parse the contents of the `\systeme{...}` macro + */ +export declare function parse(ast: Ast.Node[], options?: SystemeMatchers): SystemeSpec.Line[]; +export {}; +//# sourceMappingURL=parser.d.ts.map \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-ctan/package/systeme/libs/print-raw.d.ts b/node_modules/@unified-latex/unified-latex-ctan/package/systeme/libs/print-raw.d.ts new file mode 100644 index 0000000..fc7ab3b --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-ctan/package/systeme/libs/print-raw.d.ts @@ -0,0 +1,6 @@ +import * as SystemeSpec from "./types"; +/** + * Print an `systeme` argument specification AST to a string. + */ +export declare function printRaw(node: SystemeSpec.Ast, root?: boolean): string; +//# sourceMappingURL=print-raw.d.ts.map \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-ctan/package/systeme/libs/systeme.d.ts b/node_modules/@unified-latex/unified-latex-ctan/package/systeme/libs/systeme.d.ts new file mode 100644 index 0000000..c3362f0 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-ctan/package/systeme/libs/systeme.d.ts @@ -0,0 +1,29 @@ +import * as SystemeSpec from "./types"; +import * as Ast from "@unified-latex/unified-latex-types"; +/** + * Extract the variables from a systeme system of equations. + */ +export declare function extractVariables(nodes: SystemeSpec.Node[]): Ast.Node[][]; +/** + * Lays out the contents of a \systeme{...} macro as an array. This function sorts the variables + * in alphabetical order and lays out any annotations. An `\begin{array}...\end{array}` environment + * is returned. + * + * If `properSpacing=true` then kerning information will be included in the array specification to space + * the operators correctly. This kerning information will make the specification long (and may make it incompatible + * with KaTeX). + * + * An optional whitelist of variables may be supplied. If supplied, only listed items will count as variables and + * the order of variable appearance will be the same as the order of the whitelisted variables. + */ +export declare function systemeContentsToArray(nodes: Ast.Node[], options?: { + properSpacing?: boolean; + whitelistedVariables?: (string | Ast.String | Ast.Macro)[]; +}): Ast.Environment; +/** + * Find any systeme definitions, e.g. `\sysdelim{.}{.}`, and attach their information + * to the renderInfo of of the systeme macros. + * + */ +export declare function attachSystemeSettingsAsRenderInfo(ast: Ast.Ast): void; +//# sourceMappingURL=systeme.d.ts.map \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-ctan/package/systeme/libs/types.d.ts b/node_modules/@unified-latex/unified-latex-ctan/package/systeme/libs/types.d.ts new file mode 100644 index 0000000..4343c81 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-ctan/package/systeme/libs/types.d.ts @@ -0,0 +1,33 @@ +import * as LatexAst from "@unified-latex/unified-latex-types"; +export type Ast = Node | Node[]; +export type Node = Line | Equation | Item | Annotation; +export type SystemeNode = Node; +interface AstNode { + type: string; +} +export interface Line extends AstNode { + type: "line"; + equation?: Equation | null; + annotation?: Annotation | null; + sep?: LatexAst.Node[] | null; + trailingComment: LatexAst.Comment | null; +} +interface Equation extends AstNode { + type: "equation"; + left: Item[]; + right: LatexAst.Node[]; + equals?: LatexAst.Node | null; +} +export interface Item extends AstNode { + type: "item"; + op: LatexAst.Node | null; + variable: LatexAst.Node[] | null; + content: LatexAst.Node[]; +} +interface Annotation extends AstNode { + type: "annotation"; + marker: LatexAst.Node; + content: LatexAst.Node[]; +} +export {}; +//# sourceMappingURL=types.d.ts.map \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-ctan/package/systeme/provides.d.ts b/node_modules/@unified-latex/unified-latex-ctan/package/systeme/provides.d.ts new file mode 100644 index 0000000..88c6521 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-ctan/package/systeme/provides.d.ts @@ -0,0 +1,4 @@ +import { MacroInfoRecord, EnvInfoRecord } from '@unified-latex/unified-latex-types'; +export declare const macros: MacroInfoRecord; +export declare const environments: EnvInfoRecord; +//# sourceMappingURL=provides.d.ts.map \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-ctan/package/tabularx/index.cjs b/node_modules/@unified-latex/unified-latex-ctan/package/tabularx/index.cjs new file mode 100644 index 0000000..3776886 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-ctan/package/tabularx/index.cjs @@ -0,0 +1,93 @@ +"use strict"; +Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" }); +const unifiedLatexUtilPegjs = require("@unified-latex/unified-latex-util-pegjs"); +const unifiedLatexUtilMatch = require("@unified-latex/unified-latex-util-match"); +const unifiedLatexUtilPrintRaw = require("@unified-latex/unified-latex-util-print-raw"); +const macros = {}; +const environments = { + tabularx: { signature: "m o m", renderInfo: { alignContent: true } } +}; +function createMatchers() { + return { + matchChar: (node, char) => unifiedLatexUtilMatch.match.string(node, char), + isWhitespace: unifiedLatexUtilMatch.match.whitespace, + isGroup: unifiedLatexUtilMatch.match.group + }; +} +function parseTabularSpec(ast) { + if (!Array.isArray(ast)) { + throw new Error("You must pass an array of nodes"); + } + ast = unifiedLatexUtilPegjs.splitStringsIntoSingleChars(ast); + ast = unifiedLatexUtilPegjs.decorateArrayForPegjs([...ast]); + return unifiedLatexUtilPegjs.TabularPegParser.parse(ast, createMatchers()); +} +function printRaw(node, root = false) { + if (typeof node === "string") { + return node; + } + if (Array.isArray(node)) { + const sepToken = root ? " " : ""; + return node.map((tok) => printRaw(tok)).join(sepToken); + } + switch (node.type) { + case "vert_divider": + return "|"; + case "at_divider": + return `@{${unifiedLatexUtilPrintRaw.printRaw(node.content)}}`; + case "bang_divider": + return `!{${unifiedLatexUtilPrintRaw.printRaw(node.content)}}`; + case "alignment": + if (node.alignment === "left") { + return "l"; + } + if (node.alignment === "right") { + return "r"; + } + if (node.alignment === "center") { + return "c"; + } + if (node.alignment === "X") { + return "X"; + } + if (node.alignment === "parbox") { + if (node.baseline === "top") { + return `p{${unifiedLatexUtilPrintRaw.printRaw(node.size)}}`; + } + if (node.baseline === "default") { + return `m{${unifiedLatexUtilPrintRaw.printRaw(node.size)}}`; + } + if (node.baseline === "bottom") { + return `b{${unifiedLatexUtilPrintRaw.printRaw(node.size)}}`; + } + return `w{${unifiedLatexUtilPrintRaw.printRaw(node.baseline)}}{${unifiedLatexUtilPrintRaw.printRaw( + node.size + )}}`; + } + break; + case "decl_code": + return unifiedLatexUtilPrintRaw.printRaw(node.code); + case "column": + const end_code = node.before_end_code ? `<{${printRaw(node.before_end_code)}}` : ""; + const start_code = node.before_start_code ? `>{${printRaw(node.before_start_code)}}` : ""; + return [ + printRaw(node.pre_dividers), + start_code, + printRaw(node.alignment), + end_code, + printRaw(node.post_dividers) + ].join(""); + default: + console.warn( + `Unknown node type "${node.type}" for node`, + node + ); + return ""; + } + return ""; +} +exports.environments = environments; +exports.macros = macros; +exports.parseTabularSpec = parseTabularSpec; +exports.printRaw = printRaw; +//# sourceMappingURL=index.cjs.map diff --git a/node_modules/@unified-latex/unified-latex-ctan/package/tabularx/index.cjs.map b/node_modules/@unified-latex/unified-latex-ctan/package/tabularx/index.cjs.map new file mode 100644 index 0000000..3f76d3d --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-ctan/package/tabularx/index.cjs.map @@ -0,0 +1 @@ +{"version":3,"file":"index.cjs","sources":["../../../package/tabularx/provides.ts","../../../package/tabularx/libs/parser.ts","../../../package/tabularx/libs/print-raw.ts"],"sourcesContent":["import {\n MacroInfoRecord,\n EnvInfoRecord,\n} from \"@unified-latex/unified-latex-types\";\n\nexport const macros: MacroInfoRecord = {};\n\nexport const environments: EnvInfoRecord = {\n tabularx: { signature: \"m o m\", renderInfo: { alignContent: true } },\n};\n","import { TabularPegParser } from \"@unified-latex/unified-latex-util-pegjs\";\nimport * as Ast from \"@unified-latex/unified-latex-types\";\nimport { match } from \"@unified-latex/unified-latex-util-match\";\nimport {\n decorateArrayForPegjs,\n splitStringsIntoSingleChars,\n} from \"@unified-latex/unified-latex-util-pegjs\";\nimport * as TabularSpec from \"./types\";\n\nfunction createMatchers() {\n return {\n matchChar: (node: Ast.Node, char: string) => match.string(node, char),\n isWhitespace: match.whitespace,\n isGroup: match.group,\n };\n}\n\n/**\n * Parse a tabular/tabularx specification, e.g. `\"|c|r|r|\"`. This parser assumes the specification has\n * already been parsed as LaTeX.\n */\nexport function parseTabularSpec(ast: Ast.Node[]): TabularSpec.TabularColumn[] {\n if (!Array.isArray(ast)) {\n throw new Error(\"You must pass an array of nodes\");\n }\n // All tabular spec commands are single letters, so we pre-split all strings\n // for easy parsing.\n ast = splitStringsIntoSingleChars(ast);\n // We need to at functions to `nodes` so that it imitates\n // a Javascript string. Because we're mutating, make a copy first\n ast = decorateArrayForPegjs([...ast]);\n // matchers are passed in via the second argument (the `options` argument)\n // so they are available from within the Pegjs grammar.\n return TabularPegParser.parse(ast, createMatchers());\n}\n","import * as TabularSpec from \"./types\";\nimport { printRaw as latexPrintRaw } from \"@unified-latex/unified-latex-util-print-raw\";\n\n/**\n * Print a tabular/tabularx argument specification AST to a string.\n */\nexport function printRaw(node: TabularSpec.Ast, root = false): string {\n if (typeof node === \"string\") {\n return node;\n }\n\n if (Array.isArray(node)) {\n const sepToken = root ? \" \" : \"\";\n return node.map((tok) => printRaw(tok)).join(sepToken);\n }\n\n switch (node.type) {\n case \"vert_divider\":\n return \"|\";\n case \"at_divider\":\n return `@{${latexPrintRaw(node.content)}}`;\n case \"bang_divider\":\n return `!{${latexPrintRaw(node.content)}}`;\n case \"alignment\":\n if (node.alignment === \"left\") {\n return \"l\";\n }\n if (node.alignment === \"right\") {\n return \"r\";\n }\n if (node.alignment === \"center\") {\n return \"c\";\n }\n if (node.alignment === \"X\") {\n return \"X\";\n }\n if (node.alignment === \"parbox\") {\n if (node.baseline === \"top\") {\n return `p{${latexPrintRaw(node.size)}}`;\n }\n if (node.baseline === \"default\") {\n return `m{${latexPrintRaw(node.size)}}`;\n }\n if (node.baseline === \"bottom\") {\n return `b{${latexPrintRaw(node.size)}}`;\n }\n return `w{${latexPrintRaw(node.baseline)}}{${latexPrintRaw(\n node.size\n )}}`;\n }\n break;\n case \"decl_code\":\n return latexPrintRaw(node.code);\n\n case \"column\":\n const end_code = node.before_end_code\n ? `<{${printRaw(node.before_end_code)}}`\n : \"\";\n const start_code = node.before_start_code\n ? `>{${printRaw(node.before_start_code)}}`\n : \"\";\n return [\n printRaw(node.pre_dividers),\n start_code,\n printRaw(node.alignment),\n end_code,\n printRaw(node.post_dividers),\n ].join(\"\");\n\n default:\n console.warn(\n `Unknown node type \"${(node as any).type}\" for node`,\n node\n );\n return \"\";\n }\n return \"\";\n}\n"],"names":["match","splitStringsIntoSingleChars","decorateArrayForPegjs","TabularPegParser","latexPrintRaw"],"mappings":";;;;;AAKO,MAAM,SAA0B,CAAA;AAEhC,MAAM,eAA8B;AAAA,EACvC,UAAU,EAAE,WAAW,SAAS,YAAY,EAAE,cAAc,KAAO,EAAA;AACvE;ACAA,SAAS,iBAAiB;AACf,SAAA;AAAA,IACH,WAAW,CAAC,MAAgB,SAAiBA,sBAAM,MAAA,OAAO,MAAM,IAAI;AAAA,IACpE,cAAcA,sBAAM,MAAA;AAAA,IACpB,SAASA,sBAAAA,MAAM;AAAA,EACnB;AACJ;AAMO,SAAS,iBAAiB,KAA8C;AAC3E,MAAI,CAAC,MAAM,QAAQ,GAAG,GAAG;AACf,UAAA,IAAI,MAAM,iCAAiC;AAAA,EAAA;AAIrD,QAAMC,kDAA4B,GAAG;AAGrC,QAAMC,sBAAsB,sBAAA,CAAC,GAAG,GAAG,CAAC;AAGpC,SAAOC,uCAAiB,MAAM,KAAK,eAAA,CAAgB;AACvD;AC5BgB,SAAA,SAAS,MAAuB,OAAO,OAAe;AAC9D,MAAA,OAAO,SAAS,UAAU;AACnB,WAAA;AAAA,EAAA;AAGP,MAAA,MAAM,QAAQ,IAAI,GAAG;AACf,UAAA,WAAW,OAAO,MAAM;AACvB,WAAA,KAAK,IAAI,CAAC,QAAQ,SAAS,GAAG,CAAC,EAAE,KAAK,QAAQ;AAAA,EAAA;AAGzD,UAAQ,KAAK,MAAM;AAAA,IACf,KAAK;AACM,aAAA;AAAA,IACX,KAAK;AACD,aAAO,KAAKC,yBAAA,SAAc,KAAK,OAAO,CAAC;AAAA,IAC3C,KAAK;AACD,aAAO,KAAKA,yBAAA,SAAc,KAAK,OAAO,CAAC;AAAA,IAC3C,KAAK;AACG,UAAA,KAAK,cAAc,QAAQ;AACpB,eAAA;AAAA,MAAA;AAEP,UAAA,KAAK,cAAc,SAAS;AACrB,eAAA;AAAA,MAAA;AAEP,UAAA,KAAK,cAAc,UAAU;AACtB,eAAA;AAAA,MAAA;AAEP,UAAA,KAAK,cAAc,KAAK;AACjB,eAAA;AAAA,MAAA;AAEP,UAAA,KAAK,cAAc,UAAU;AACzB,YAAA,KAAK,aAAa,OAAO;AACzB,iBAAO,KAAKA,yBAAA,SAAc,KAAK,IAAI,CAAC;AAAA,QAAA;AAEpC,YAAA,KAAK,aAAa,WAAW;AAC7B,iBAAO,KAAKA,yBAAA,SAAc,KAAK,IAAI,CAAC;AAAA,QAAA;AAEpC,YAAA,KAAK,aAAa,UAAU;AAC5B,iBAAO,KAAKA,yBAAA,SAAc,KAAK,IAAI,CAAC;AAAA,QAAA;AAExC,eAAO,KAAKA,yBAAA,SAAc,KAAK,QAAQ,CAAC,KAAKA,yBAAA;AAAA,UACzC,KAAK;AAAA,QACR,CAAA;AAAA,MAAA;AAEL;AAAA,IACJ,KAAK;AACM,aAAAA,yBAAA,SAAc,KAAK,IAAI;AAAA,IAElC,KAAK;AACK,YAAA,WAAW,KAAK,kBAChB,KAAK,SAAS,KAAK,eAAe,CAAC,MACnC;AACA,YAAA,aAAa,KAAK,oBAClB,KAAK,SAAS,KAAK,iBAAiB,CAAC,MACrC;AACC,aAAA;AAAA,QACH,SAAS,KAAK,YAAY;AAAA,QAC1B;AAAA,QACA,SAAS,KAAK,SAAS;AAAA,QACvB;AAAA,QACA,SAAS,KAAK,aAAa;AAAA,MAAA,EAC7B,KAAK,EAAE;AAAA,IAEb;AACY,cAAA;AAAA,QACJ,sBAAuB,KAAa,IAAI;AAAA,QACxC;AAAA,MACJ;AACO,aAAA;AAAA,EAAA;AAER,SAAA;AACX;;;;;"} \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-ctan/package/tabularx/index.d.ts b/node_modules/@unified-latex/unified-latex-ctan/package/tabularx/index.d.ts new file mode 100644 index 0000000..671bac1 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-ctan/package/tabularx/index.d.ts @@ -0,0 +1,5 @@ +export * from './provides'; +export * from './libs/types'; +export * from './libs/parser'; +export * from './libs/print-raw'; +//# sourceMappingURL=index.d.ts.map \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-ctan/package/tabularx/index.js b/node_modules/@unified-latex/unified-latex-ctan/package/tabularx/index.js new file mode 100644 index 0000000..e3c3a20 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-ctan/package/tabularx/index.js @@ -0,0 +1,93 @@ +import { splitStringsIntoSingleChars, decorateArrayForPegjs, TabularPegParser } from "@unified-latex/unified-latex-util-pegjs"; +import { match } from "@unified-latex/unified-latex-util-match"; +import { printRaw as printRaw$1 } from "@unified-latex/unified-latex-util-print-raw"; +const macros = {}; +const environments = { + tabularx: { signature: "m o m", renderInfo: { alignContent: true } } +}; +function createMatchers() { + return { + matchChar: (node, char) => match.string(node, char), + isWhitespace: match.whitespace, + isGroup: match.group + }; +} +function parseTabularSpec(ast) { + if (!Array.isArray(ast)) { + throw new Error("You must pass an array of nodes"); + } + ast = splitStringsIntoSingleChars(ast); + ast = decorateArrayForPegjs([...ast]); + return TabularPegParser.parse(ast, createMatchers()); +} +function printRaw(node, root = false) { + if (typeof node === "string") { + return node; + } + if (Array.isArray(node)) { + const sepToken = root ? " " : ""; + return node.map((tok) => printRaw(tok)).join(sepToken); + } + switch (node.type) { + case "vert_divider": + return "|"; + case "at_divider": + return `@{${printRaw$1(node.content)}}`; + case "bang_divider": + return `!{${printRaw$1(node.content)}}`; + case "alignment": + if (node.alignment === "left") { + return "l"; + } + if (node.alignment === "right") { + return "r"; + } + if (node.alignment === "center") { + return "c"; + } + if (node.alignment === "X") { + return "X"; + } + if (node.alignment === "parbox") { + if (node.baseline === "top") { + return `p{${printRaw$1(node.size)}}`; + } + if (node.baseline === "default") { + return `m{${printRaw$1(node.size)}}`; + } + if (node.baseline === "bottom") { + return `b{${printRaw$1(node.size)}}`; + } + return `w{${printRaw$1(node.baseline)}}{${printRaw$1( + node.size + )}}`; + } + break; + case "decl_code": + return printRaw$1(node.code); + case "column": + const end_code = node.before_end_code ? `<{${printRaw(node.before_end_code)}}` : ""; + const start_code = node.before_start_code ? `>{${printRaw(node.before_start_code)}}` : ""; + return [ + printRaw(node.pre_dividers), + start_code, + printRaw(node.alignment), + end_code, + printRaw(node.post_dividers) + ].join(""); + default: + console.warn( + `Unknown node type "${node.type}" for node`, + node + ); + return ""; + } + return ""; +} +export { + environments, + macros, + parseTabularSpec, + printRaw +}; +//# sourceMappingURL=index.js.map diff --git a/node_modules/@unified-latex/unified-latex-ctan/package/tabularx/index.js.map b/node_modules/@unified-latex/unified-latex-ctan/package/tabularx/index.js.map new file mode 100644 index 0000000..8f75273 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-ctan/package/tabularx/index.js.map @@ -0,0 +1 @@ +{"version":3,"file":"index.js","sources":["../../../package/tabularx/provides.ts","../../../package/tabularx/libs/parser.ts","../../../package/tabularx/libs/print-raw.ts"],"sourcesContent":["import {\n MacroInfoRecord,\n EnvInfoRecord,\n} from \"@unified-latex/unified-latex-types\";\n\nexport const macros: MacroInfoRecord = {};\n\nexport const environments: EnvInfoRecord = {\n tabularx: { signature: \"m o m\", renderInfo: { alignContent: true } },\n};\n","import { TabularPegParser } from \"@unified-latex/unified-latex-util-pegjs\";\nimport * as Ast from \"@unified-latex/unified-latex-types\";\nimport { match } from \"@unified-latex/unified-latex-util-match\";\nimport {\n decorateArrayForPegjs,\n splitStringsIntoSingleChars,\n} from \"@unified-latex/unified-latex-util-pegjs\";\nimport * as TabularSpec from \"./types\";\n\nfunction createMatchers() {\n return {\n matchChar: (node: Ast.Node, char: string) => match.string(node, char),\n isWhitespace: match.whitespace,\n isGroup: match.group,\n };\n}\n\n/**\n * Parse a tabular/tabularx specification, e.g. `\"|c|r|r|\"`. This parser assumes the specification has\n * already been parsed as LaTeX.\n */\nexport function parseTabularSpec(ast: Ast.Node[]): TabularSpec.TabularColumn[] {\n if (!Array.isArray(ast)) {\n throw new Error(\"You must pass an array of nodes\");\n }\n // All tabular spec commands are single letters, so we pre-split all strings\n // for easy parsing.\n ast = splitStringsIntoSingleChars(ast);\n // We need to at functions to `nodes` so that it imitates\n // a Javascript string. Because we're mutating, make a copy first\n ast = decorateArrayForPegjs([...ast]);\n // matchers are passed in via the second argument (the `options` argument)\n // so they are available from within the Pegjs grammar.\n return TabularPegParser.parse(ast, createMatchers());\n}\n","import * as TabularSpec from \"./types\";\nimport { printRaw as latexPrintRaw } from \"@unified-latex/unified-latex-util-print-raw\";\n\n/**\n * Print a tabular/tabularx argument specification AST to a string.\n */\nexport function printRaw(node: TabularSpec.Ast, root = false): string {\n if (typeof node === \"string\") {\n return node;\n }\n\n if (Array.isArray(node)) {\n const sepToken = root ? \" \" : \"\";\n return node.map((tok) => printRaw(tok)).join(sepToken);\n }\n\n switch (node.type) {\n case \"vert_divider\":\n return \"|\";\n case \"at_divider\":\n return `@{${latexPrintRaw(node.content)}}`;\n case \"bang_divider\":\n return `!{${latexPrintRaw(node.content)}}`;\n case \"alignment\":\n if (node.alignment === \"left\") {\n return \"l\";\n }\n if (node.alignment === \"right\") {\n return \"r\";\n }\n if (node.alignment === \"center\") {\n return \"c\";\n }\n if (node.alignment === \"X\") {\n return \"X\";\n }\n if (node.alignment === \"parbox\") {\n if (node.baseline === \"top\") {\n return `p{${latexPrintRaw(node.size)}}`;\n }\n if (node.baseline === \"default\") {\n return `m{${latexPrintRaw(node.size)}}`;\n }\n if (node.baseline === \"bottom\") {\n return `b{${latexPrintRaw(node.size)}}`;\n }\n return `w{${latexPrintRaw(node.baseline)}}{${latexPrintRaw(\n node.size\n )}}`;\n }\n break;\n case \"decl_code\":\n return latexPrintRaw(node.code);\n\n case \"column\":\n const end_code = node.before_end_code\n ? `<{${printRaw(node.before_end_code)}}`\n : \"\";\n const start_code = node.before_start_code\n ? `>{${printRaw(node.before_start_code)}}`\n : \"\";\n return [\n printRaw(node.pre_dividers),\n start_code,\n printRaw(node.alignment),\n end_code,\n printRaw(node.post_dividers),\n ].join(\"\");\n\n default:\n console.warn(\n `Unknown node type \"${(node as any).type}\" for node`,\n node\n );\n return \"\";\n }\n return \"\";\n}\n"],"names":["latexPrintRaw"],"mappings":";;;AAKO,MAAM,SAA0B,CAAA;AAEhC,MAAM,eAA8B;AAAA,EACvC,UAAU,EAAE,WAAW,SAAS,YAAY,EAAE,cAAc,KAAO,EAAA;AACvE;ACAA,SAAS,iBAAiB;AACf,SAAA;AAAA,IACH,WAAW,CAAC,MAAgB,SAAiB,MAAM,OAAO,MAAM,IAAI;AAAA,IACpE,cAAc,MAAM;AAAA,IACpB,SAAS,MAAM;AAAA,EACnB;AACJ;AAMO,SAAS,iBAAiB,KAA8C;AAC3E,MAAI,CAAC,MAAM,QAAQ,GAAG,GAAG;AACf,UAAA,IAAI,MAAM,iCAAiC;AAAA,EAAA;AAIrD,QAAM,4BAA4B,GAAG;AAGrC,QAAM,sBAAsB,CAAC,GAAG,GAAG,CAAC;AAGpC,SAAO,iBAAiB,MAAM,KAAK,eAAA,CAAgB;AACvD;AC5BgB,SAAA,SAAS,MAAuB,OAAO,OAAe;AAC9D,MAAA,OAAO,SAAS,UAAU;AACnB,WAAA;AAAA,EAAA;AAGP,MAAA,MAAM,QAAQ,IAAI,GAAG;AACf,UAAA,WAAW,OAAO,MAAM;AACvB,WAAA,KAAK,IAAI,CAAC,QAAQ,SAAS,GAAG,CAAC,EAAE,KAAK,QAAQ;AAAA,EAAA;AAGzD,UAAQ,KAAK,MAAM;AAAA,IACf,KAAK;AACM,aAAA;AAAA,IACX,KAAK;AACD,aAAO,KAAKA,WAAc,KAAK,OAAO,CAAC;AAAA,IAC3C,KAAK;AACD,aAAO,KAAKA,WAAc,KAAK,OAAO,CAAC;AAAA,IAC3C,KAAK;AACG,UAAA,KAAK,cAAc,QAAQ;AACpB,eAAA;AAAA,MAAA;AAEP,UAAA,KAAK,cAAc,SAAS;AACrB,eAAA;AAAA,MAAA;AAEP,UAAA,KAAK,cAAc,UAAU;AACtB,eAAA;AAAA,MAAA;AAEP,UAAA,KAAK,cAAc,KAAK;AACjB,eAAA;AAAA,MAAA;AAEP,UAAA,KAAK,cAAc,UAAU;AACzB,YAAA,KAAK,aAAa,OAAO;AACzB,iBAAO,KAAKA,WAAc,KAAK,IAAI,CAAC;AAAA,QAAA;AAEpC,YAAA,KAAK,aAAa,WAAW;AAC7B,iBAAO,KAAKA,WAAc,KAAK,IAAI,CAAC;AAAA,QAAA;AAEpC,YAAA,KAAK,aAAa,UAAU;AAC5B,iBAAO,KAAKA,WAAc,KAAK,IAAI,CAAC;AAAA,QAAA;AAExC,eAAO,KAAKA,WAAc,KAAK,QAAQ,CAAC,KAAKA;AAAAA,UACzC,KAAK;AAAA,QACR,CAAA;AAAA,MAAA;AAEL;AAAA,IACJ,KAAK;AACM,aAAAA,WAAc,KAAK,IAAI;AAAA,IAElC,KAAK;AACK,YAAA,WAAW,KAAK,kBAChB,KAAK,SAAS,KAAK,eAAe,CAAC,MACnC;AACA,YAAA,aAAa,KAAK,oBAClB,KAAK,SAAS,KAAK,iBAAiB,CAAC,MACrC;AACC,aAAA;AAAA,QACH,SAAS,KAAK,YAAY;AAAA,QAC1B;AAAA,QACA,SAAS,KAAK,SAAS;AAAA,QACvB;AAAA,QACA,SAAS,KAAK,aAAa;AAAA,MAAA,EAC7B,KAAK,EAAE;AAAA,IAEb;AACY,cAAA;AAAA,QACJ,sBAAuB,KAAa,IAAI;AAAA,QACxC;AAAA,MACJ;AACO,aAAA;AAAA,EAAA;AAER,SAAA;AACX;"} \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-ctan/package/tabularx/libs/parser.d.ts b/node_modules/@unified-latex/unified-latex-ctan/package/tabularx/libs/parser.d.ts new file mode 100644 index 0000000..16f01ab --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-ctan/package/tabularx/libs/parser.d.ts @@ -0,0 +1,8 @@ +import * as Ast from "@unified-latex/unified-latex-types"; +import * as TabularSpec from "./types"; +/** + * Parse a tabular/tabularx specification, e.g. `"|c|r|r|"`. This parser assumes the specification has + * already been parsed as LaTeX. + */ +export declare function parseTabularSpec(ast: Ast.Node[]): TabularSpec.TabularColumn[]; +//# sourceMappingURL=parser.d.ts.map \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-ctan/package/tabularx/libs/print-raw.d.ts b/node_modules/@unified-latex/unified-latex-ctan/package/tabularx/libs/print-raw.d.ts new file mode 100644 index 0000000..b3bbbd3 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-ctan/package/tabularx/libs/print-raw.d.ts @@ -0,0 +1,6 @@ +import * as TabularSpec from "./types"; +/** + * Print a tabular/tabularx argument specification AST to a string. + */ +export declare function printRaw(node: TabularSpec.Ast, root?: boolean): string; +//# sourceMappingURL=print-raw.d.ts.map \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-ctan/package/tabularx/libs/types.d.ts b/node_modules/@unified-latex/unified-latex-ctan/package/tabularx/libs/types.d.ts new file mode 100644 index 0000000..012b07e --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-ctan/package/tabularx/libs/types.d.ts @@ -0,0 +1,40 @@ +import * as LatexAst from "@unified-latex/unified-latex-types"; +export type Ast = Node | Node[]; +export type Node = Column | BasicAlignment | ParboxAlignment | Code | Divider; +export type TabularColumn = Column; +interface AstNode { + type: string; +} +interface Column extends AstNode { + type: "column"; + pre_dividers: Divider[]; + post_dividers: Divider[]; + before_start_code: Code | null; + before_end_code: Code | null; + alignment: BasicAlignment | ParboxAlignment; +} +interface BasicAlignment extends AstNode { + type: "alignment"; + alignment: "left" | "right" | "center" | "X"; +} +interface ParboxAlignment extends AstNode { + type: "alignment"; + alignment: "parbox"; + baseline: LatexAst.Node[] | "top" | "default" | "bottom"; + size: LatexAst.Node[]; +} +interface Code extends AstNode { + type: "decl_code"; + code: LatexAst.Node[]; +} +type Divider = { + type: "vert_divider"; +} | { + type: "bang_divider"; + content: LatexAst.Node[]; +} | { + type: "at_divider"; + content: LatexAst.Node[]; +}; +export {}; +//# sourceMappingURL=types.d.ts.map \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-ctan/package/tabularx/provides.d.ts b/node_modules/@unified-latex/unified-latex-ctan/package/tabularx/provides.d.ts new file mode 100644 index 0000000..88c6521 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-ctan/package/tabularx/provides.d.ts @@ -0,0 +1,4 @@ +import { MacroInfoRecord, EnvInfoRecord } from '@unified-latex/unified-latex-types'; +export declare const macros: MacroInfoRecord; +export declare const environments: EnvInfoRecord; +//# sourceMappingURL=provides.d.ts.map \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-ctan/package/tikz/index.cjs b/node_modules/@unified-latex/unified-latex-ctan/package/tikz/index.cjs new file mode 100644 index 0000000..0eed9cd --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-ctan/package/tikz/index.cjs @@ -0,0 +1,104 @@ +"use strict"; +Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" }); +const parser = require("../../parser-9Q3EtimU.cjs"); +const unifiedLatexUtilPrintRaw = require("@unified-latex/unified-latex-util-print-raw"); +const unifiedLatexUtilTrim = require("@unified-latex/unified-latex-util-trim"); +function printRaw(node, root = false) { + if (typeof node === "string") { + return node; + } + if (Array.isArray(node)) { + const sepToken = root ? " " : ""; + const printed = []; + for (let i = 0; i < node.length; i++) { + const tok = node[i]; + const prevTok = node[i - 1]; + if (!prevTok) { + printed.push(printRaw(tok)); + continue; + } + if (prevTok.type === "comment") { + printed.push(printRaw(tok)); + continue; + } + if (tok.type !== "comment") { + printed.push(sepToken); + } + printed.push(printRaw(tok)); + } + return printed.join(""); + } + const type = node.type; + switch (type) { + case "path_spec": + return printRaw(node.content, root = true); + case "coordinate": + return `${unifiedLatexUtilPrintRaw.printRaw(node.prefix)}(${unifiedLatexUtilPrintRaw.printRaw( + node.content + )})`; + case "operation": + return unifiedLatexUtilPrintRaw.printRaw(node.content); + case "comment": + return unifiedLatexUtilPrintRaw.printRaw(node); + case "line_to": + return node.command; + case "curve_to": { + const comments = node.comments.map((c) => unifiedLatexUtilPrintRaw.printRaw({ ...c, leadingWhitespace: false })).join(""); + if (node.controls.length === 1) { + return `${comments}.. controls ${printRaw( + node.controls[0] + )} ..`; + } else { + return `${comments}.. controls ${printRaw( + node.controls[0] + )} and ${printRaw(node.controls[1])} ..`; + } + } + case "unknown": + return unifiedLatexUtilPrintRaw.printRaw(node.content); + case "square_brace_group": + return `[${unifiedLatexUtilPrintRaw.printRaw(node.content)}]`; + case "foreach": { + const comments = node.comments.map((c) => unifiedLatexUtilPrintRaw.printRaw({ ...c, leadingWhitespace: false })).join(""); + let options = ""; + if (node.options) { + options = ` [${unifiedLatexUtilPrintRaw.printRaw(node.options)}]`; + } + const start = unifiedLatexUtilPrintRaw.printRaw(node.start); + const variables = [...node.variables]; + unifiedLatexUtilTrim.trim(variables); + let printedVariables = unifiedLatexUtilPrintRaw.printRaw(variables); + if (printedVariables.length > 0) { + printedVariables = " " + printedVariables; + } + const command = node.command.type === "foreach" ? printRaw(node.command) : unifiedLatexUtilPrintRaw.printRaw(node.command); + return `${comments}${start}${printedVariables}${options} in ${unifiedLatexUtilPrintRaw.printRaw( + node.list + )} ${command}`; + } + case "svg_operation": { + const comments = node.comments.map((c) => unifiedLatexUtilPrintRaw.printRaw({ ...c, leadingWhitespace: false })).join(""); + let options = ""; + if (node.options) { + options = `[${unifiedLatexUtilPrintRaw.printRaw(node.options)}]`; + } + return `${comments}svg${options} ${unifiedLatexUtilPrintRaw.printRaw(node.content)}`; + } + case "animation": { + const comments = node.comments.map((c) => unifiedLatexUtilPrintRaw.printRaw({ ...c, leadingWhitespace: false })).join(""); + return `${comments}:${node.attribute} = {${unifiedLatexUtilPrintRaw.printRaw( + node.content + )}}`; + } + default: + const unprintedType = type; + console.warn(`Unknown node type "${unprintedType}" for node`, node); + return ""; + } +} +exports.conditionalMacros = parser.conditionalMacros; +exports.environments = parser.environments; +exports.macros = parser.macros; +exports.parse = parser.parse; +exports.printRaw = printRaw; +//# sourceMappingURL=index.cjs.map diff --git a/node_modules/@unified-latex/unified-latex-ctan/package/tikz/index.cjs.map b/node_modules/@unified-latex/unified-latex-ctan/package/tikz/index.cjs.map new file mode 100644 index 0000000..bf9aef3 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-ctan/package/tikz/index.cjs.map @@ -0,0 +1 @@ +{"version":3,"file":"index.cjs","sources":["../../../package/tikz/libs/print-raw.ts"],"sourcesContent":["import { printRaw as latexPrintRaw } from \"@unified-latex/unified-latex-util-print-raw\";\nimport { trim } from \"@unified-latex/unified-latex-util-trim\";\nimport * as TikzSpec from \"./types\";\n\n/**\n * Print an `systeme` argument specification AST to a string.\n */\nexport function printRaw(node: TikzSpec.Ast, root = false): string {\n if (typeof node === \"string\") {\n return node;\n }\n\n if (Array.isArray(node)) {\n const sepToken = root ? \" \" : \"\";\n const printed: string[] = [];\n for (let i = 0; i < node.length; i++) {\n const tok = node[i];\n const prevTok = node[i - 1];\n if (!prevTok) {\n printed.push(printRaw(tok));\n continue;\n }\n if (prevTok.type === \"comment\") {\n printed.push(printRaw(tok));\n continue;\n }\n if (tok.type !== \"comment\") {\n printed.push(sepToken);\n }\n printed.push(printRaw(tok));\n }\n return printed.join(\"\");\n }\n const type = node.type;\n\n switch (type) {\n case \"path_spec\":\n return printRaw(node.content, (root = true));\n case \"coordinate\":\n return `${latexPrintRaw(node.prefix)}(${latexPrintRaw(\n node.content\n )})`;\n case \"operation\":\n return latexPrintRaw(node.content);\n case \"comment\":\n return latexPrintRaw(node);\n case \"line_to\":\n return node.command;\n case \"curve_to\": {\n const comments = node.comments\n .map((c) => latexPrintRaw({ ...c, leadingWhitespace: false }))\n .join(\"\");\n if (node.controls.length === 1) {\n return `${comments}.. controls ${printRaw(\n node.controls[0]\n )} ..`;\n } else {\n return `${comments}.. controls ${printRaw(\n node.controls[0]\n )} and ${printRaw(node.controls[1])} ..`;\n }\n }\n case \"unknown\":\n return latexPrintRaw(node.content);\n case \"square_brace_group\":\n return `[${latexPrintRaw(node.content)}]`;\n case \"foreach\": {\n const comments = node.comments\n .map((c) => latexPrintRaw({ ...c, leadingWhitespace: false }))\n .join(\"\");\n let options = \"\";\n if (node.options) {\n options = ` [${latexPrintRaw(node.options)}]`;\n }\n const start = latexPrintRaw(node.start);\n const variables = [...node.variables];\n trim(variables);\n let printedVariables = latexPrintRaw(variables);\n // It is possible that the variables are specified as `[var=\\p]`, in the optional argument, instead of as `\\p`\n // In this case, `node.variables` will be empty and we don't want an extra space showing up.\n if (printedVariables.length > 0) {\n printedVariables = \" \" + printedVariables;\n }\n\n const command =\n node.command.type === \"foreach\"\n ? printRaw(node.command)\n : latexPrintRaw(node.command);\n\n return `${comments}${start}${printedVariables}${options} in ${latexPrintRaw(\n node.list\n )} ${command}`;\n }\n case \"svg_operation\": {\n const comments = node.comments\n .map((c) => latexPrintRaw({ ...c, leadingWhitespace: false }))\n .join(\"\");\n let options = \"\";\n if (node.options) {\n options = `[${latexPrintRaw(node.options)}]`;\n }\n\n return `${comments}svg${options} ${latexPrintRaw(node.content)}`;\n }\n case \"animation\": {\n const comments = node.comments\n .map((c) => latexPrintRaw({ ...c, leadingWhitespace: false }))\n .join(\"\");\n\n return `${comments}:${node.attribute} = {${latexPrintRaw(\n node.content\n )}}`;\n }\n\n default:\n const unprintedType: void = type;\n console.warn(`Unknown node type \"${unprintedType}\" for node`, node);\n return \"\";\n }\n}\n"],"names":["latexPrintRaw","trim"],"mappings":"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"} \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-ctan/package/tikz/index.d.ts b/node_modules/@unified-latex/unified-latex-ctan/package/tikz/index.d.ts new file mode 100644 index 0000000..9ff2358 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-ctan/package/tikz/index.d.ts @@ -0,0 +1,5 @@ +export * from './provides'; +export * from './libs/types'; +export * from './libs/print-raw'; +export * from './libs/parser'; +//# sourceMappingURL=index.d.ts.map \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-ctan/package/tikz/index.js b/node_modules/@unified-latex/unified-latex-ctan/package/tikz/index.js new file mode 100644 index 0000000..369f959 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-ctan/package/tikz/index.js @@ -0,0 +1,104 @@ +import { c, e, m, p } from "../../parser-BBXMi7mQ.js"; +import { printRaw as printRaw$1 } from "@unified-latex/unified-latex-util-print-raw"; +import { trim } from "@unified-latex/unified-latex-util-trim"; +function printRaw(node, root = false) { + if (typeof node === "string") { + return node; + } + if (Array.isArray(node)) { + const sepToken = root ? " " : ""; + const printed = []; + for (let i = 0; i < node.length; i++) { + const tok = node[i]; + const prevTok = node[i - 1]; + if (!prevTok) { + printed.push(printRaw(tok)); + continue; + } + if (prevTok.type === "comment") { + printed.push(printRaw(tok)); + continue; + } + if (tok.type !== "comment") { + printed.push(sepToken); + } + printed.push(printRaw(tok)); + } + return printed.join(""); + } + const type = node.type; + switch (type) { + case "path_spec": + return printRaw(node.content, root = true); + case "coordinate": + return `${printRaw$1(node.prefix)}(${printRaw$1( + node.content + )})`; + case "operation": + return printRaw$1(node.content); + case "comment": + return printRaw$1(node); + case "line_to": + return node.command; + case "curve_to": { + const comments = node.comments.map((c2) => printRaw$1({ ...c2, leadingWhitespace: false })).join(""); + if (node.controls.length === 1) { + return `${comments}.. controls ${printRaw( + node.controls[0] + )} ..`; + } else { + return `${comments}.. controls ${printRaw( + node.controls[0] + )} and ${printRaw(node.controls[1])} ..`; + } + } + case "unknown": + return printRaw$1(node.content); + case "square_brace_group": + return `[${printRaw$1(node.content)}]`; + case "foreach": { + const comments = node.comments.map((c2) => printRaw$1({ ...c2, leadingWhitespace: false })).join(""); + let options = ""; + if (node.options) { + options = ` [${printRaw$1(node.options)}]`; + } + const start = printRaw$1(node.start); + const variables = [...node.variables]; + trim(variables); + let printedVariables = printRaw$1(variables); + if (printedVariables.length > 0) { + printedVariables = " " + printedVariables; + } + const command = node.command.type === "foreach" ? printRaw(node.command) : printRaw$1(node.command); + return `${comments}${start}${printedVariables}${options} in ${printRaw$1( + node.list + )} ${command}`; + } + case "svg_operation": { + const comments = node.comments.map((c2) => printRaw$1({ ...c2, leadingWhitespace: false })).join(""); + let options = ""; + if (node.options) { + options = `[${printRaw$1(node.options)}]`; + } + return `${comments}svg${options} ${printRaw$1(node.content)}`; + } + case "animation": { + const comments = node.comments.map((c2) => printRaw$1({ ...c2, leadingWhitespace: false })).join(""); + return `${comments}:${node.attribute} = {${printRaw$1( + node.content + )}}`; + } + default: + const unprintedType = type; + console.warn(`Unknown node type "${unprintedType}" for node`, node); + return ""; + } +} +export { + c as conditionalMacros, + e as environments, + m as macros, + p as parse, + printRaw +}; +//# sourceMappingURL=index.js.map diff --git a/node_modules/@unified-latex/unified-latex-ctan/package/tikz/index.js.map b/node_modules/@unified-latex/unified-latex-ctan/package/tikz/index.js.map new file mode 100644 index 0000000..18ebcf4 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-ctan/package/tikz/index.js.map @@ -0,0 +1 @@ +{"version":3,"file":"index.js","sources":["../../../package/tikz/libs/print-raw.ts"],"sourcesContent":["import { printRaw as latexPrintRaw } from \"@unified-latex/unified-latex-util-print-raw\";\nimport { trim } from \"@unified-latex/unified-latex-util-trim\";\nimport * as TikzSpec from \"./types\";\n\n/**\n * Print an `systeme` argument specification AST to a string.\n */\nexport function printRaw(node: TikzSpec.Ast, root = false): string {\n if (typeof node === \"string\") {\n return node;\n }\n\n if (Array.isArray(node)) {\n const sepToken = root ? \" \" : \"\";\n const printed: string[] = [];\n for (let i = 0; i < node.length; i++) {\n const tok = node[i];\n const prevTok = node[i - 1];\n if (!prevTok) {\n printed.push(printRaw(tok));\n continue;\n }\n if (prevTok.type === \"comment\") {\n printed.push(printRaw(tok));\n continue;\n }\n if (tok.type !== \"comment\") {\n printed.push(sepToken);\n }\n printed.push(printRaw(tok));\n }\n return printed.join(\"\");\n }\n const type = node.type;\n\n switch (type) {\n case \"path_spec\":\n return printRaw(node.content, (root = true));\n case \"coordinate\":\n return `${latexPrintRaw(node.prefix)}(${latexPrintRaw(\n node.content\n )})`;\n case \"operation\":\n return latexPrintRaw(node.content);\n case \"comment\":\n return latexPrintRaw(node);\n case \"line_to\":\n return node.command;\n case \"curve_to\": {\n const comments = node.comments\n .map((c) => latexPrintRaw({ ...c, leadingWhitespace: false }))\n .join(\"\");\n if (node.controls.length === 1) {\n return `${comments}.. controls ${printRaw(\n node.controls[0]\n )} ..`;\n } else {\n return `${comments}.. controls ${printRaw(\n node.controls[0]\n )} and ${printRaw(node.controls[1])} ..`;\n }\n }\n case \"unknown\":\n return latexPrintRaw(node.content);\n case \"square_brace_group\":\n return `[${latexPrintRaw(node.content)}]`;\n case \"foreach\": {\n const comments = node.comments\n .map((c) => latexPrintRaw({ ...c, leadingWhitespace: false }))\n .join(\"\");\n let options = \"\";\n if (node.options) {\n options = ` [${latexPrintRaw(node.options)}]`;\n }\n const start = latexPrintRaw(node.start);\n const variables = [...node.variables];\n trim(variables);\n let printedVariables = latexPrintRaw(variables);\n // It is possible that the variables are specified as `[var=\\p]`, in the optional argument, instead of as `\\p`\n // In this case, `node.variables` will be empty and we don't want an extra space showing up.\n if (printedVariables.length > 0) {\n printedVariables = \" \" + printedVariables;\n }\n\n const command =\n node.command.type === \"foreach\"\n ? printRaw(node.command)\n : latexPrintRaw(node.command);\n\n return `${comments}${start}${printedVariables}${options} in ${latexPrintRaw(\n node.list\n )} ${command}`;\n }\n case \"svg_operation\": {\n const comments = node.comments\n .map((c) => latexPrintRaw({ ...c, leadingWhitespace: false }))\n .join(\"\");\n let options = \"\";\n if (node.options) {\n options = `[${latexPrintRaw(node.options)}]`;\n }\n\n return `${comments}svg${options} ${latexPrintRaw(node.content)}`;\n }\n case \"animation\": {\n const comments = node.comments\n .map((c) => latexPrintRaw({ ...c, leadingWhitespace: false }))\n .join(\"\");\n\n return `${comments}:${node.attribute} = {${latexPrintRaw(\n node.content\n )}}`;\n }\n\n default:\n const unprintedType: void = type;\n console.warn(`Unknown node type \"${unprintedType}\" for node`, node);\n return \"\";\n }\n}\n"],"names":["latexPrintRaw","c"],"mappings":"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"} \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-ctan/package/tikz/libs/parser.d.ts b/node_modules/@unified-latex/unified-latex-ctan/package/tikz/libs/parser.d.ts new file mode 100644 index 0000000..6c3b30f --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-ctan/package/tikz/libs/parser.d.ts @@ -0,0 +1,13 @@ +import * as Ast from "@unified-latex/unified-latex-types"; +import * as TikzSpec from "./types"; +type TikzParseOptions = { + startRule?: "path_spec" | "foreach_body"; +}; +/** + * Parse the contents of the `\systeme{...}` macro + */ +export declare function parse(ast: Ast.Node[], options?: Options): Options extends { + startRule: infer R; +} ? R extends "path_spec" ? TikzSpec.PathSpec : TikzSpec.ForeachBody : TikzSpec.PathSpec; +export {}; +//# sourceMappingURL=parser.d.ts.map \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-ctan/package/tikz/libs/print-raw.d.ts b/node_modules/@unified-latex/unified-latex-ctan/package/tikz/libs/print-raw.d.ts new file mode 100644 index 0000000..2541df3 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-ctan/package/tikz/libs/print-raw.d.ts @@ -0,0 +1,6 @@ +import * as TikzSpec from "./types"; +/** + * Print an `systeme` argument specification AST to a string. + */ +export declare function printRaw(node: TikzSpec.Ast, root?: boolean): string; +//# sourceMappingURL=print-raw.d.ts.map \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-ctan/package/tikz/libs/tikz-command-argument-parser.d.ts b/node_modules/@unified-latex/unified-latex-ctan/package/tikz/libs/tikz-command-argument-parser.d.ts new file mode 100644 index 0000000..70c7016 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-ctan/package/tikz/libs/tikz-command-argument-parser.d.ts @@ -0,0 +1,10 @@ +import { ArgumentParser } from '@unified-latex/unified-latex-types'; +/** + * Find the arguments of a tikz command. Many tikz commands accept either + * the a group as their only argument, or they scan their arguments until the first + * `;` is found. + * + * This behavior cannot be achieved via a standard xparse spec. + */ +export declare const tikzCommandArgumentParser: ArgumentParser; +//# sourceMappingURL=tikz-command-argument-parser.d.ts.map \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-ctan/package/tikz/libs/types.d.ts b/node_modules/@unified-latex/unified-latex-ctan/package/tikz/libs/types.d.ts new file mode 100644 index 0000000..971a2ae --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-ctan/package/tikz/libs/types.d.ts @@ -0,0 +1,63 @@ +import * as LatexAst from "@unified-latex/unified-latex-types"; +export type Ast = Node | Node[]; +export type Node = PathSpecNode | PathSpec; +export type PathSpecNode = SquareBraceGroup | Coordinate | CurveTo | LineTo | Foreach | Operation | Unknown | Svg | Animation | LatexAst.Comment; +interface AstNode { + type: string; +} +export interface PathSpec extends AstNode { + type: "path_spec"; + content: PathSpecNode[]; +} +export interface SquareBraceGroup extends AstNode { + type: "square_brace_group"; + content: LatexAst.Node[]; +} +export interface Coordinate extends AstNode { + type: "coordinate"; + content: LatexAst.Node[]; + prefix: LatexAst.String[]; +} +export interface CurveTo extends AstNode { + type: "curve_to"; + controls: [Coordinate] | [Coordinate, Coordinate]; + comments: LatexAst.Comment[]; +} +export interface LineTo extends AstNode { + type: "line_to"; + command: "--" | "|-" | "-|"; +} +export interface Svg extends AstNode { + type: "svg_operation"; + options: null | LatexAst.Node[]; + content: LatexAst.Group; + comments: LatexAst.Comment[]; +} +export interface ForeachBody extends AstNode { + type: "foreach_body"; + variables: LatexAst.Node[]; + options: null | LatexAst.Node[]; + list: LatexAst.Group | LatexAst.Macro; + command: LatexAst.Group | LatexAst.Macro | Foreach; + comments: LatexAst.Comment[]; +} +export interface Foreach extends Omit { + type: "foreach"; + start: LatexAst.String | LatexAst.Macro; +} +export interface Operation extends AstNode { + type: "operation"; + content: LatexAst.String; +} +export interface Unknown extends AstNode { + type: "unknown"; + content: LatexAst.Node; +} +export interface Animation extends AstNode { + type: "animation"; + content: LatexAst.Node[]; + comments: LatexAst.Comment[]; + attribute: string; +} +export {}; +//# sourceMappingURL=types.d.ts.map \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-ctan/package/tikz/provides.d.ts b/node_modules/@unified-latex/unified-latex-ctan/package/tikz/provides.d.ts new file mode 100644 index 0000000..648c708 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-ctan/package/tikz/provides.d.ts @@ -0,0 +1,8 @@ +import { MacroInfoRecord, EnvInfoRecord } from '@unified-latex/unified-latex-types'; +export declare const macros: MacroInfoRecord; +export declare const environments: EnvInfoRecord; +/** + * Macros that are only parsed inside a tikz environment. + */ +export declare const conditionalMacros: MacroInfoRecord; +//# sourceMappingURL=provides.d.ts.map \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-ctan/package/xcolor/index.cjs b/node_modules/@unified-latex/unified-latex-ctan/package/xcolor/index.cjs new file mode 100644 index 0000000..0024afc --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-ctan/package/xcolor/index.cjs @@ -0,0 +1,92 @@ +"use strict"; +Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" }); +const xcolor = require("../../xcolor-BEfsW_1K.cjs"); +const unifiedLatexUtilArguments = require("@unified-latex/unified-latex-util-arguments"); +const unifiedLatexUtilPrintRaw = require("@unified-latex/unified-latex-util-print-raw"); +const index = require("../../index-BuqJUpao.cjs"); +const unifiedLatexUtilComments = require("@unified-latex/unified-latex-util-comments"); +const unifiedLatexBuilder = require("@unified-latex/unified-latex-builder"); +function printRaw(node, root = false) { + if (typeof node === "string") { + return node; + } + if (Array.isArray(node)) { + const sepToken = root ? " " : ""; + return node.map((tok) => printRaw(tok)).join(sepToken); + } + if (node.type === "invalid_spec") { + return node.content; + } + switch (node.type) { + case "postfix": + if (node.plusses != null) { + return `!!${node.plusses}`; + } else { + return `!![${node.num}]`; + } + case "complete_mix": + return `!${node.mix_percent}!${node.name}`; + case "partial_mix": + return `!${node.mix_percent}`; + case "expr": + return `${node.prefix || ""}${node.name}${node.mix_expr.map((mix) => printRaw(mix)).join("")}${node.postfix ? printRaw(node.postfix) : ""}`; + case "weighted_expr": + return `${printRaw(node.color)},${node.weight}`; + case "extended_expr": + let prefix = node.core_model; + if (node.div) { + prefix += `,${node.div}`; + } + return `${prefix}:${node.expressions.map((expr) => printRaw(expr)).join(";")}`; + case "function": + return `>${node.name},${node.args.map((a) => "" + a).join(",")}`; + case "color": + return printRaw(node.color) + node.functions.map((f) => printRaw(f)).join(""); + default: + console.warn( + `Unknown node type "${node.type}" for node`, + node + ); + return ""; + } +} +function xcolorMacroToHex(node) { + node = index.structuredClone(node); + unifiedLatexUtilComments.deleteComments(node); + const args = unifiedLatexUtilArguments.getArgsContent(node); + const model = args[0] && unifiedLatexUtilPrintRaw.printRaw(args[0]); + const colorStr = unifiedLatexUtilPrintRaw.printRaw(args[1] || []); + let hex = null; + try { + hex = xcolor.xcolorColorToHex(colorStr, model); + } catch (e) { + } + const cssVarName = "--" + colorStr.replace(/[^a-zA-Z0-9-_]/g, "-"); + return { hex, cssVarName }; +} +function colorToTextcolorMacro(content, origMacro) { + if (!Array.isArray(content)) { + content = [content]; + } + const args = (origMacro.args ? origMacro.args : [unifiedLatexBuilder.arg([], { closeMark: "", openMark: "" }), unifiedLatexBuilder.arg([])]).concat(unifiedLatexBuilder.arg(content)); + return { + type: "macro", + content: "textcolor", + args, + _renderInfo: { inParMode: true } + }; +} +exports.DVI_PS_NAMES = xcolor.DVI_PS_NAMES; +exports.PREDEFINED_XCOLOR_COLORS = xcolor.PREDEFINED_XCOLOR_COLORS; +exports.SVG_NAMES = xcolor.SVG_NAMES; +exports.X11_NAMES = xcolor.X11_NAMES; +exports.XColorCoreModelToColor = xcolor.XColorCoreModelToColor; +exports.computeColor = xcolor.computeColor; +exports.environments = xcolor.environments; +exports.macros = xcolor.macros; +exports.parse = xcolor.parse; +exports.xcolorColorToHex = xcolor.xcolorColorToHex; +exports.colorToTextcolorMacro = colorToTextcolorMacro; +exports.printRaw = printRaw; +exports.xcolorMacroToHex = xcolorMacroToHex; +//# sourceMappingURL=index.cjs.map diff --git a/node_modules/@unified-latex/unified-latex-ctan/package/xcolor/index.cjs.map b/node_modules/@unified-latex/unified-latex-ctan/package/xcolor/index.cjs.map new file mode 100644 index 0000000..1942de9 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-ctan/package/xcolor/index.cjs.map @@ -0,0 +1 @@ +{"version":3,"file":"index.cjs","sources":["../../../package/xcolor/libs/print-raw.ts","../../../package/xcolor/libs/xcolor-macro-to-hex.ts","../../../package/xcolor/libs/color-to-textcolor-macro.ts"],"sourcesContent":["import * as XColorSpec from \"./types\";\n\n/**\n * Print an `xcolor` argument specification AST to a string.\n */\nexport function printRaw(node: XColorSpec.Ast, root = false): string {\n if (typeof node === \"string\") {\n return node;\n }\n\n if (Array.isArray(node)) {\n const sepToken = root ? \" \" : \"\";\n return node.map((tok) => printRaw(tok)).join(sepToken);\n }\n\n if (node.type === \"invalid_spec\") {\n return node.content;\n }\n\n switch (node.type) {\n case \"postfix\":\n if (node.plusses != null) {\n return `!!${node.plusses}`;\n } else {\n return `!![${node.num}]`;\n }\n case \"complete_mix\":\n return `!${node.mix_percent}!${node.name}`;\n case \"partial_mix\":\n return `!${node.mix_percent}`;\n case \"expr\":\n return `${node.prefix || \"\"}${node.name}${node.mix_expr\n .map((mix) => printRaw(mix))\n .join(\"\")}${node.postfix ? printRaw(node.postfix) : \"\"}`;\n case \"weighted_expr\":\n return `${printRaw(node.color)},${node.weight}`;\n case \"extended_expr\":\n let prefix = node.core_model;\n if (node.div) {\n prefix += `,${node.div}`;\n }\n return `${prefix}:${node.expressions\n .map((expr) => printRaw(expr))\n .join(\";\")}`;\n case \"function\":\n return `>${node.name},${node.args.map((a) => \"\" + a).join(\",\")}`;\n case \"color\":\n return (\n printRaw(node.color) +\n node.functions.map((f) => printRaw(f)).join(\"\")\n );\n\n default:\n console.warn(\n `Unknown node type \"${(node as any).type}\" for node`,\n node\n );\n return \"\";\n }\n}\n","import * as Ast from \"@unified-latex/unified-latex-types\";\nimport { getArgsContent } from \"@unified-latex/unified-latex-util-arguments\";\nimport { printRaw } from \"@unified-latex/unified-latex-util-print-raw\";\nimport { xcolorColorToHex } from \"./xcolor\";\nimport { structuredClone } from \"@unified-latex/structured-clone\";\nimport { deleteComments } from \"@unified-latex/unified-latex-util-comments\";\n\n/**\n * Compute the hex representation of a color specified by an xcolor color command.\n * For example `\\color[rgb]{1 .5 .5}` or `\\textcolor{red}{foo}`. If the color cannot be parsed,\n * `null` is returned for the hex value. In all cases a css variable name (prefixed with \"--\"\")\n * is returned. This can be used to set up CSS for custom colors.\n */\nexport function xcolorMacroToHex(node: Ast.Macro): {\n hex: string | null;\n cssVarName: string;\n} {\n // We do some destructive operations on the node, so clone it first.\n node = structuredClone(node);\n deleteComments(node);\n\n // We assume the node has signature \"o m\" where o is the model and\n // m is the color spec.\n\n const args = getArgsContent(node);\n const model = args[0] && printRaw(args[0]);\n const colorStr = printRaw(args[1] || []);\n let hex: string | null = null;\n try {\n hex = xcolorColorToHex(colorStr, model);\n } catch (e) {}\n\n const cssVarName = \"--\" + colorStr.replace(/[^a-zA-Z0-9-_]/g, \"-\");\n\n return { hex, cssVarName };\n}\n","import { arg } from \"@unified-latex/unified-latex-builder\";\nimport * as Ast from \"@unified-latex/unified-latex-types\";\n\n/**\n * Create a `\\textcolor` macro. Color arguments are taken from `origMacro`.\n */\nexport function colorToTextcolorMacro(\n content: Ast.Node | Ast.Node[],\n origMacro: Ast.Macro\n): Ast.Macro {\n if (!Array.isArray(content)) {\n content = [content];\n }\n // Signature of \\color is \"o m\".\n // We want to carry through the same arguments\n const args = (\n origMacro.args\n ? origMacro.args\n : [arg([], { closeMark: \"\", openMark: \"\" }), arg([])]\n ).concat(arg(content));\n\n return {\n type: \"macro\",\n content: \"textcolor\",\n args,\n _renderInfo: { inParMode: true },\n };\n}\n"],"names":["structuredClone","deleteComments","getArgsContent","printRaw","xcolorColorToHex","arg"],"mappings":";;;;;;;;AAKgB,SAAA,SAAS,MAAsB,OAAO,OAAe;AAC7D,MAAA,OAAO,SAAS,UAAU;AACnB,WAAA;AAAA,EAAA;AAGP,MAAA,MAAM,QAAQ,IAAI,GAAG;AACf,UAAA,WAAW,OAAO,MAAM;AACvB,WAAA,KAAK,IAAI,CAAC,QAAQ,SAAS,GAAG,CAAC,EAAE,KAAK,QAAQ;AAAA,EAAA;AAGrD,MAAA,KAAK,SAAS,gBAAgB;AAC9B,WAAO,KAAK;AAAA,EAAA;AAGhB,UAAQ,KAAK,MAAM;AAAA,IACf,KAAK;AACG,UAAA,KAAK,WAAW,MAAM;AACf,eAAA,KAAK,KAAK,OAAO;AAAA,MAAA,OACrB;AACI,eAAA,MAAM,KAAK,GAAG;AAAA,MAAA;AAAA,IAE7B,KAAK;AACD,aAAO,IAAI,KAAK,WAAW,IAAI,KAAK,IAAI;AAAA,IAC5C,KAAK;AACM,aAAA,IAAI,KAAK,WAAW;AAAA,IAC/B,KAAK;AACM,aAAA,GAAG,KAAK,UAAU,EAAE,GAAG,KAAK,IAAI,GAAG,KAAK,SAC1C,IAAI,CAAC,QAAQ,SAAS,GAAG,CAAC,EAC1B,KAAK,EAAE,CAAC,GAAG,KAAK,UAAU,SAAS,KAAK,OAAO,IAAI,EAAE;AAAA,IAC9D,KAAK;AACD,aAAO,GAAG,SAAS,KAAK,KAAK,CAAC,IAAI,KAAK,MAAM;AAAA,IACjD,KAAK;AACD,UAAI,SAAS,KAAK;AAClB,UAAI,KAAK,KAAK;AACA,kBAAA,IAAI,KAAK,GAAG;AAAA,MAAA;AAE1B,aAAO,GAAG,MAAM,IAAI,KAAK,YACpB,IAAI,CAAC,SAAS,SAAS,IAAI,CAAC,EAC5B,KAAK,GAAG,CAAC;AAAA,IAClB,KAAK;AACD,aAAO,IAAI,KAAK,IAAI,IAAI,KAAK,KAAK,IAAI,CAAC,MAAM,KAAK,CAAC,EAAE,KAAK,GAAG,CAAC;AAAA,IAClE,KAAK;AACD,aACI,SAAS,KAAK,KAAK,IACnB,KAAK,UAAU,IAAI,CAAC,MAAM,SAAS,CAAC,CAAC,EAAE,KAAK,EAAE;AAAA,IAGtD;AACY,cAAA;AAAA,QACJ,sBAAuB,KAAa,IAAI;AAAA,QACxC;AAAA,MACJ;AACO,aAAA;AAAA,EAAA;AAEnB;AC9CO,SAAS,iBAAiB,MAG/B;AAEE,SAAOA,sBAAgB,IAAI;AAC3BC,2BAAAA,eAAe,IAAI;AAKb,QAAA,OAAOC,yCAAe,IAAI;AAChC,QAAM,QAAQ,KAAK,CAAC,KAAKC,yBAAAA,SAAS,KAAK,CAAC,CAAC;AACzC,QAAM,WAAWA,yBAAS,SAAA,KAAK,CAAC,KAAK,CAAA,CAAE;AACvC,MAAI,MAAqB;AACrB,MAAA;AACM,UAAAC,OAAAA,iBAAiB,UAAU,KAAK;AAAA,WACjC,GAAG;AAAA,EAAA;AAEZ,QAAM,aAAa,OAAO,SAAS,QAAQ,mBAAmB,GAAG;AAE1D,SAAA,EAAE,KAAK,WAAW;AAC7B;AC7BgB,SAAA,sBACZ,SACA,WACS;AACT,MAAI,CAAC,MAAM,QAAQ,OAAO,GAAG;AACzB,cAAU,CAAC,OAAO;AAAA,EAAA;AAIhB,QAAA,QACF,UAAU,OACJ,UAAU,OACV,CAACC,oBAAAA,IAAI,CAAI,GAAA,EAAE,WAAW,IAAI,UAAU,IAAI,GAAGA,wBAAI,CAAA,CAAE,CAAC,GAC1D,OAAOA,wBAAI,OAAO,CAAC;AAEd,SAAA;AAAA,IACH,MAAM;AAAA,IACN,SAAS;AAAA,IACT;AAAA,IACA,aAAa,EAAE,WAAW,KAAK;AAAA,EACnC;AACJ;;;;;;;;;;;;;;"} \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-ctan/package/xcolor/index.d.ts b/node_modules/@unified-latex/unified-latex-ctan/package/xcolor/index.d.ts new file mode 100644 index 0000000..d8cfcdf --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-ctan/package/xcolor/index.d.ts @@ -0,0 +1,9 @@ +export * from './provides'; +export * from './libs/xcolor'; +export * from './libs/types'; +export * from './libs/parser'; +export * from './libs/print-raw'; +export * from './libs/predefined-colors'; +export * from './libs/xcolor-macro-to-hex'; +export * from './libs/color-to-textcolor-macro'; +//# sourceMappingURL=index.d.ts.map \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-ctan/package/xcolor/index.js b/node_modules/@unified-latex/unified-latex-ctan/package/xcolor/index.js new file mode 100644 index 0000000..8b20cec --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-ctan/package/xcolor/index.js @@ -0,0 +1,93 @@ +import { x as xcolorColorToHex } from "../../xcolor-CIejE3rZ.js"; +import { D, P, S, a, X, c, e, m, p } from "../../xcolor-CIejE3rZ.js"; +import { getArgsContent } from "@unified-latex/unified-latex-util-arguments"; +import { printRaw as printRaw$1 } from "@unified-latex/unified-latex-util-print-raw"; +import { s as structuredClone } from "../../index-NHd3tQDq.js"; +import { deleteComments } from "@unified-latex/unified-latex-util-comments"; +import { arg } from "@unified-latex/unified-latex-builder"; +function printRaw(node, root = false) { + if (typeof node === "string") { + return node; + } + if (Array.isArray(node)) { + const sepToken = root ? " " : ""; + return node.map((tok) => printRaw(tok)).join(sepToken); + } + if (node.type === "invalid_spec") { + return node.content; + } + switch (node.type) { + case "postfix": + if (node.plusses != null) { + return `!!${node.plusses}`; + } else { + return `!![${node.num}]`; + } + case "complete_mix": + return `!${node.mix_percent}!${node.name}`; + case "partial_mix": + return `!${node.mix_percent}`; + case "expr": + return `${node.prefix || ""}${node.name}${node.mix_expr.map((mix) => printRaw(mix)).join("")}${node.postfix ? printRaw(node.postfix) : ""}`; + case "weighted_expr": + return `${printRaw(node.color)},${node.weight}`; + case "extended_expr": + let prefix = node.core_model; + if (node.div) { + prefix += `,${node.div}`; + } + return `${prefix}:${node.expressions.map((expr) => printRaw(expr)).join(";")}`; + case "function": + return `>${node.name},${node.args.map((a2) => "" + a2).join(",")}`; + case "color": + return printRaw(node.color) + node.functions.map((f) => printRaw(f)).join(""); + default: + console.warn( + `Unknown node type "${node.type}" for node`, + node + ); + return ""; + } +} +function xcolorMacroToHex(node) { + node = structuredClone(node); + deleteComments(node); + const args = getArgsContent(node); + const model = args[0] && printRaw$1(args[0]); + const colorStr = printRaw$1(args[1] || []); + let hex = null; + try { + hex = xcolorColorToHex(colorStr, model); + } catch (e2) { + } + const cssVarName = "--" + colorStr.replace(/[^a-zA-Z0-9-_]/g, "-"); + return { hex, cssVarName }; +} +function colorToTextcolorMacro(content, origMacro) { + if (!Array.isArray(content)) { + content = [content]; + } + const args = (origMacro.args ? origMacro.args : [arg([], { closeMark: "", openMark: "" }), arg([])]).concat(arg(content)); + return { + type: "macro", + content: "textcolor", + args, + _renderInfo: { inParMode: true } + }; +} +export { + D as DVI_PS_NAMES, + P as PREDEFINED_XCOLOR_COLORS, + S as SVG_NAMES, + a as X11_NAMES, + X as XColorCoreModelToColor, + colorToTextcolorMacro, + c as computeColor, + e as environments, + m as macros, + p as parse, + printRaw, + xcolorColorToHex, + xcolorMacroToHex +}; +//# sourceMappingURL=index.js.map diff --git a/node_modules/@unified-latex/unified-latex-ctan/package/xcolor/index.js.map b/node_modules/@unified-latex/unified-latex-ctan/package/xcolor/index.js.map new file mode 100644 index 0000000..a515675 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-ctan/package/xcolor/index.js.map @@ -0,0 +1 @@ +{"version":3,"file":"index.js","sources":["../../../package/xcolor/libs/print-raw.ts","../../../package/xcolor/libs/xcolor-macro-to-hex.ts","../../../package/xcolor/libs/color-to-textcolor-macro.ts"],"sourcesContent":["import * as XColorSpec from \"./types\";\n\n/**\n * Print an `xcolor` argument specification AST to a string.\n */\nexport function printRaw(node: XColorSpec.Ast, root = false): string {\n if (typeof node === \"string\") {\n return node;\n }\n\n if (Array.isArray(node)) {\n const sepToken = root ? \" \" : \"\";\n return node.map((tok) => printRaw(tok)).join(sepToken);\n }\n\n if (node.type === \"invalid_spec\") {\n return node.content;\n }\n\n switch (node.type) {\n case \"postfix\":\n if (node.plusses != null) {\n return `!!${node.plusses}`;\n } else {\n return `!![${node.num}]`;\n }\n case \"complete_mix\":\n return `!${node.mix_percent}!${node.name}`;\n case \"partial_mix\":\n return `!${node.mix_percent}`;\n case \"expr\":\n return `${node.prefix || \"\"}${node.name}${node.mix_expr\n .map((mix) => printRaw(mix))\n .join(\"\")}${node.postfix ? printRaw(node.postfix) : \"\"}`;\n case \"weighted_expr\":\n return `${printRaw(node.color)},${node.weight}`;\n case \"extended_expr\":\n let prefix = node.core_model;\n if (node.div) {\n prefix += `,${node.div}`;\n }\n return `${prefix}:${node.expressions\n .map((expr) => printRaw(expr))\n .join(\";\")}`;\n case \"function\":\n return `>${node.name},${node.args.map((a) => \"\" + a).join(\",\")}`;\n case \"color\":\n return (\n printRaw(node.color) +\n node.functions.map((f) => printRaw(f)).join(\"\")\n );\n\n default:\n console.warn(\n `Unknown node type \"${(node as any).type}\" for node`,\n node\n );\n return \"\";\n }\n}\n","import * as Ast from \"@unified-latex/unified-latex-types\";\nimport { getArgsContent } from \"@unified-latex/unified-latex-util-arguments\";\nimport { printRaw } from \"@unified-latex/unified-latex-util-print-raw\";\nimport { xcolorColorToHex } from \"./xcolor\";\nimport { structuredClone } from \"@unified-latex/structured-clone\";\nimport { deleteComments } from \"@unified-latex/unified-latex-util-comments\";\n\n/**\n * Compute the hex representation of a color specified by an xcolor color command.\n * For example `\\color[rgb]{1 .5 .5}` or `\\textcolor{red}{foo}`. If the color cannot be parsed,\n * `null` is returned for the hex value. In all cases a css variable name (prefixed with \"--\"\")\n * is returned. This can be used to set up CSS for custom colors.\n */\nexport function xcolorMacroToHex(node: Ast.Macro): {\n hex: string | null;\n cssVarName: string;\n} {\n // We do some destructive operations on the node, so clone it first.\n node = structuredClone(node);\n deleteComments(node);\n\n // We assume the node has signature \"o m\" where o is the model and\n // m is the color spec.\n\n const args = getArgsContent(node);\n const model = args[0] && printRaw(args[0]);\n const colorStr = printRaw(args[1] || []);\n let hex: string | null = null;\n try {\n hex = xcolorColorToHex(colorStr, model);\n } catch (e) {}\n\n const cssVarName = \"--\" + colorStr.replace(/[^a-zA-Z0-9-_]/g, \"-\");\n\n return { hex, cssVarName };\n}\n","import { arg } from \"@unified-latex/unified-latex-builder\";\nimport * as Ast from \"@unified-latex/unified-latex-types\";\n\n/**\n * Create a `\\textcolor` macro. Color arguments are taken from `origMacro`.\n */\nexport function colorToTextcolorMacro(\n content: Ast.Node | Ast.Node[],\n origMacro: Ast.Macro\n): Ast.Macro {\n if (!Array.isArray(content)) {\n content = [content];\n }\n // Signature of \\color is \"o m\".\n // We want to carry through the same arguments\n const args = (\n origMacro.args\n ? origMacro.args\n : [arg([], { closeMark: \"\", openMark: \"\" }), arg([])]\n ).concat(arg(content));\n\n return {\n type: \"macro\",\n content: \"textcolor\",\n args,\n _renderInfo: { inParMode: true },\n };\n}\n"],"names":["a","printRaw","e"],"mappings":";;;;;;;AAKgB,SAAA,SAAS,MAAsB,OAAO,OAAe;AAC7D,MAAA,OAAO,SAAS,UAAU;AACnB,WAAA;AAAA,EAAA;AAGP,MAAA,MAAM,QAAQ,IAAI,GAAG;AACf,UAAA,WAAW,OAAO,MAAM;AACvB,WAAA,KAAK,IAAI,CAAC,QAAQ,SAAS,GAAG,CAAC,EAAE,KAAK,QAAQ;AAAA,EAAA;AAGrD,MAAA,KAAK,SAAS,gBAAgB;AAC9B,WAAO,KAAK;AAAA,EAAA;AAGhB,UAAQ,KAAK,MAAM;AAAA,IACf,KAAK;AACG,UAAA,KAAK,WAAW,MAAM;AACf,eAAA,KAAK,KAAK,OAAO;AAAA,MAAA,OACrB;AACI,eAAA,MAAM,KAAK,GAAG;AAAA,MAAA;AAAA,IAE7B,KAAK;AACD,aAAO,IAAI,KAAK,WAAW,IAAI,KAAK,IAAI;AAAA,IAC5C,KAAK;AACM,aAAA,IAAI,KAAK,WAAW;AAAA,IAC/B,KAAK;AACM,aAAA,GAAG,KAAK,UAAU,EAAE,GAAG,KAAK,IAAI,GAAG,KAAK,SAC1C,IAAI,CAAC,QAAQ,SAAS,GAAG,CAAC,EAC1B,KAAK,EAAE,CAAC,GAAG,KAAK,UAAU,SAAS,KAAK,OAAO,IAAI,EAAE;AAAA,IAC9D,KAAK;AACD,aAAO,GAAG,SAAS,KAAK,KAAK,CAAC,IAAI,KAAK,MAAM;AAAA,IACjD,KAAK;AACD,UAAI,SAAS,KAAK;AAClB,UAAI,KAAK,KAAK;AACA,kBAAA,IAAI,KAAK,GAAG;AAAA,MAAA;AAE1B,aAAO,GAAG,MAAM,IAAI,KAAK,YACpB,IAAI,CAAC,SAAS,SAAS,IAAI,CAAC,EAC5B,KAAK,GAAG,CAAC;AAAA,IAClB,KAAK;AACD,aAAO,IAAI,KAAK,IAAI,IAAI,KAAK,KAAK,IAAI,CAACA,OAAM,KAAKA,EAAC,EAAE,KAAK,GAAG,CAAC;AAAA,IAClE,KAAK;AACD,aACI,SAAS,KAAK,KAAK,IACnB,KAAK,UAAU,IAAI,CAAC,MAAM,SAAS,CAAC,CAAC,EAAE,KAAK,EAAE;AAAA,IAGtD;AACY,cAAA;AAAA,QACJ,sBAAuB,KAAa,IAAI;AAAA,QACxC;AAAA,MACJ;AACO,aAAA;AAAA,EAAA;AAEnB;AC9CO,SAAS,iBAAiB,MAG/B;AAEE,SAAO,gBAAgB,IAAI;AAC3B,iBAAe,IAAI;AAKb,QAAA,OAAO,eAAe,IAAI;AAChC,QAAM,QAAQ,KAAK,CAAC,KAAKC,WAAS,KAAK,CAAC,CAAC;AACzC,QAAM,WAAWA,WAAS,KAAK,CAAC,KAAK,CAAA,CAAE;AACvC,MAAI,MAAqB;AACrB,MAAA;AACM,UAAA,iBAAiB,UAAU,KAAK;AAAA,WACjCC,IAAG;AAAA,EAAA;AAEZ,QAAM,aAAa,OAAO,SAAS,QAAQ,mBAAmB,GAAG;AAE1D,SAAA,EAAE,KAAK,WAAW;AAC7B;AC7BgB,SAAA,sBACZ,SACA,WACS;AACT,MAAI,CAAC,MAAM,QAAQ,OAAO,GAAG;AACzB,cAAU,CAAC,OAAO;AAAA,EAAA;AAIhB,QAAA,QACF,UAAU,OACJ,UAAU,OACV,CAAC,IAAI,CAAI,GAAA,EAAE,WAAW,IAAI,UAAU,IAAI,GAAG,IAAI,CAAA,CAAE,CAAC,GAC1D,OAAO,IAAI,OAAO,CAAC;AAEd,SAAA;AAAA,IACH,MAAM;AAAA,IACN,SAAS;AAAA,IACT;AAAA,IACA,aAAa,EAAE,WAAW,KAAK;AAAA,EACnC;AACJ;"} \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-ctan/package/xcolor/libs/color-to-textcolor-macro.d.ts b/node_modules/@unified-latex/unified-latex-ctan/package/xcolor/libs/color-to-textcolor-macro.d.ts new file mode 100644 index 0000000..068ced1 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-ctan/package/xcolor/libs/color-to-textcolor-macro.d.ts @@ -0,0 +1,6 @@ +import * as Ast from "@unified-latex/unified-latex-types"; +/** + * Create a `\textcolor` macro. Color arguments are taken from `origMacro`. + */ +export declare function colorToTextcolorMacro(content: Ast.Node | Ast.Node[], origMacro: Ast.Macro): Ast.Macro; +//# sourceMappingURL=color-to-textcolor-macro.d.ts.map \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-ctan/package/xcolor/libs/parser.d.ts b/node_modules/@unified-latex/unified-latex-ctan/package/xcolor/libs/parser.d.ts new file mode 100644 index 0000000..f67dfbd --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-ctan/package/xcolor/libs/parser.d.ts @@ -0,0 +1,10 @@ +import * as XColorSpec from "./types"; +/** + * Parse an `xparse` argument specification string to an AST. + * This function caches results. Don't mutate the returned AST! + * + * @param {string} [str=""] - LaTeX string input + * @returns - AST for LaTeX string + */ +export declare function parse(str?: string): XColorSpec.Ast; +//# sourceMappingURL=parser.d.ts.map \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-ctan/package/xcolor/libs/predefined-colors.d.ts b/node_modules/@unified-latex/unified-latex-ctan/package/xcolor/libs/predefined-colors.d.ts new file mode 100644 index 0000000..2099952 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-ctan/package/xcolor/libs/predefined-colors.d.ts @@ -0,0 +1,544 @@ +import { default as Color } from 'color'; +export declare const DVI_PS_NAMES: { + Apricot: Color<"#FBB982">; + Aquamarine: Color<"#00B5BE">; + Bittersweet: Color<"#C04F17">; + Black: Color<"#221E1F">; + Blue: Color<"#2D2F92">; + BlueGreen: Color<"#00B3B8">; + BlueViolet: Color<"#473992">; + BrickRed: Color<"#B6321C">; + Brown: Color<"#792500">; + BurntOrange: Color<"#F7921D">; + CadetBlue: Color<"#74729A">; + CarnationPink: Color<"#F282B4">; + Cerulean: Color<"#00A2E3">; + CornflowerBlue: Color<"#41B0E4">; + Cyan: Color<"#00AEEF">; + Dandelion: Color<"#FDBC42">; + DarkOrchid: Color<"#A4538A">; + Emerald: Color<"#00A99D">; + ForestGreen: Color<"#009B55">; + Fuchsia: Color<"#8C368C">; + Goldenrod: Color<"#FFDF42">; + Gray: Color<"#949698">; + Green: Color<"#00A64F">; + GreenYellow: Color<"#DFE674">; + JungleGreen: Color<"#00A99A">; + Lavender: Color<"#F49EC4">; + LimeGreen: Color<"#8DC73E">; + Magenta: Color<"#EC008C">; + Mahogany: Color<"#A9341F">; + Maroon: Color<"#AF3235">; + Melon: Color<"#F89E7B">; + MidnightBlue: Color<"#006795">; + Mulberry: Color<"#A93C93">; + NavyBlue: Color<"#006EB8">; + OliveGreen: Color<"#3C8031">; + Orange: Color<"#F58137">; + OrangeRed: Color<"#ED135A">; + Orchid: Color<"#AF72B0">; + Peach: Color<"#F7965A">; + Periwinkle: Color<"#7977B8">; + PineGreen: Color<"#008B72">; + Plum: Color<"#92268F">; + ProcessBlue: Color<"#00B0F0">; + Purple: Color<"#99479B">; + RawSienna: Color<"#974006">; + Red: Color<"#ED1B23">; + RedOrange: Color<"#F26035">; + RedViolet: Color<"#A1246B">; + Rhodamine: Color<"#EF559F">; + RoyalBlue: Color<"#0071BC">; + RoyalPurple: Color<"#613F99">; + RubineRed: Color<"#ED017D">; + Salmon: Color<"#F69289">; + SeaGreen: Color<"#3FBC9D">; + Sepia: Color<"#671800">; + SkyBlue: Color<"#46C5DD">; + SpringGreen: Color<"#C6DC67">; + Tan: Color<"#DA9D76">; + TealBlue: Color<"#00AEB3">; + Thistle: Color<"#D883B7">; + Turquoise: Color<"#00B4CE">; + Violet: Color<"#58429B">; + VioletRed: Color<"#EF58A0">; + White: Color<"#FFFFFF">; + WildStrawberry: Color<"#EE2967">; + Yellow: Color<"#FFF200">; + YellowGreen: Color<"#98CC70">; + YellowOrange: Color<"#FAA21A">; +}; +export declare const SVG_NAMES: { + AliceBlue: Color; + AntiqueWhite: Color; + Aqua: Color; + Aquamarine: Color; + Azure: Color; + Beige: Color; + Bisque: Color; + Black: Color; + BlanchedAlmond: Color; + Blue: Color; + BlueViolet: Color; + Brown: Color; + BurlyWood: Color; + CadetBlue: Color; + Chartreuse: Color; + Chocolate: Color; + Coral: Color; + CornflowerBlue: Color; + Cornsilk: Color; + Crimson: Color; + Cyan: Color; + DarkBlue: Color; + DarkCyan: Color; + DarkGoldenrod: Color; + DarkGray: Color; + DarkGreen: Color; + DarkGrey: Color; + DarkKhaki: Color; + DarkMagenta: Color; + DarkOliveGreen: Color; + DarkOrange: Color; + DarkOrchid: Color; + DarkRed: Color; + DarkSalmon: Color; + DarkSeaGreen: Color; + DarkSlateBlue: Color; + DarkSlateGray: Color; + DarkSlateGrey: Color; + DarkTurquoise: Color; + DarkViolet: Color; + DeepPink: Color; + DeepSkyBlue: Color; + DimGray: Color; + DimGrey: Color; + DodgerBlue: Color; + FireBrick: Color; + FloralWhite: Color; + ForestGreen: Color; + Fuchsia: Color; + Gainsboro: Color; + GhostWhite: Color; + Gold: Color; + Goldenrod: Color; + Gray: Color; + Green: Color; + GreenYellow: Color; + Grey: Color; + Honeydew: Color; + HotPink: Color; + IndianRed: Color; + Indigo: Color; + Ivory: Color; + Khaki: Color; + Lavender: Color; + LavenderBlush: Color; + LawnGreen: Color; + LemonChiffon: Color; + LightBlue: Color; + LightCoral: Color; + LightCyan: Color; + LightGoldenrod: Color; + LightGoldenrodYellow: Color; + LightGray: Color; + LightGreen: Color; + LightGrey: Color; + LightPink: Color; + LightSalmon: Color; + LightSeaGreen: Color; + LightSkyBlue: Color; + LightSlateBlue: Color; + LightSlateGray: Color; + LightSlateGrey: Color; + LightSteelBlue: Color; + LightYellow: Color; + Lime: Color; + LimeGreen: Color; + Linen: Color; + Magenta: Color; + Maroon: Color; + MediumAquamarine: Color; + MediumBlue: Color; + MediumOrchid: Color; + MediumPurple: Color; + MediumSeaGreen: Color; + MediumSlateBlue: Color; + MediumSpringGreen: Color; + MediumTurquoise: Color; + MediumVioletRed: Color; + MidnightBlue: Color; + MintCream: Color; + MistyRose: Color; + Moccasin: Color; + NavajoWhite: Color; + Navy: Color; + NavyBlue: Color; + OldLace: Color; + Olive: Color; + OliveDrab: Color; + Orange: Color; + OrangeRed: Color; + Orchid: Color; + PaleGoldenrod: Color; + PaleGreen: Color; + PaleTurquoise: Color; + PaleVioletRed: Color; + PapayaWhip: Color; + PeachPuff: Color; + Peru: Color; + Pink: Color; + Plum: Color; + PowderBlue: Color; + Purple: Color; + Red: Color; + RosyBrown: Color; + RoyalBlue: Color; + SaddleBrown: Color; + Salmon: Color; + SandyBrown: Color; + SeaGreen: Color; + Seashell: Color; + Sienna: Color; + Silver: Color; + SkyBlue: Color; + SlateBlue: Color; + SlateGray: Color; + SlateGrey: Color; + Snow: Color; + SpringGreen: Color; + SteelBlue: Color; + Tan: Color; + Teal: Color; + Thistle: Color; + Tomato: Color; + Turquoise: Color; + Violet: Color; + VioletRed: Color; + Wheat: Color; + White: Color; + WhiteSmoke: Color; + Yellow: Color; + YellowGreen: Color; +}; +export declare const X11_NAMES: { + AntiqueWhite1: Color; + AntiqueWhite2: Color; + AntiqueWhite3: Color; + AntiqueWhite4: Color; + Aquamarine1: Color; + Aquamarine2: Color; + Aquamarine3: Color; + Aquamarine4: Color; + Azure1: Color; + Azure2: Color; + Azure3: Color; + Azure4: Color; + Bisque1: Color; + Bisque2: Color; + Bisque3: Color; + Bisque4: Color; + Blue1: Color; + Blue2: Color; + Blue3: Color; + Blue4: Color; + Brown1: Color; + Brown2: Color; + Brown3: Color; + Brown4: Color; + Burlywood1: Color; + Burlywood2: Color; + Burlywood3: Color; + Burlywood4: Color; + CadetBlue1: Color; + CadetBlue2: Color; + CadetBlue3: Color; + CadetBlue4: Color; + Chartreuse1: Color; + Chartreuse2: Color; + Chartreuse3: Color; + Chartreuse4: Color; + Chocolate1: Color; + Chocolate2: Color; + Chocolate3: Color; + Chocolate4: Color; + Coral1: Color; + Coral2: Color; + Coral3: Color; + Coral4: Color; + Cornsilk1: Color; + Cornsilk2: Color; + Cornsilk3: Color; + Cornsilk4: Color; + Cyan1: Color; + Cyan2: Color; + Cyan3: Color; + Cyan4: Color; + DarkGoldenrod1: Color; + DarkGoldenrod2: Color; + DarkGoldenrod3: Color; + DarkGoldenrod4: Color; + DarkOliveGreen1: Color; + DarkOliveGreen2: Color; + DarkOliveGreen3: Color; + DarkOliveGreen4: Color; + DarkOrange1: Color; + DarkOrange2: Color; + DarkOrange3: Color; + DarkOrange4: Color; + DarkOrchid1: Color; + DarkOrchid2: Color; + DarkOrchid3: Color; + DarkOrchid4: Color; + DarkSeaGreen1: Color; + DarkSeaGreen2: Color; + DarkSeaGreen3: Color; + DarkSeaGreen4: Color; + DarkSlateGray1: Color; + DarkSlateGray2: Color; + DarkSlateGray3: Color; + DarkSlateGray4: Color; + DeepPink1: Color; + DeepPink2: Color; + DeepPink3: Color; + DeepPink4: Color; + DeepSkyBlue1: Color; + DeepSkyBlue2: Color; + DeepSkyBlue3: Color; + DeepSkyBlue4: Color; + DodgerBlue1: Color; + DodgerBlue2: Color; + DodgerBlue3: Color; + DodgerBlue4: Color; + Firebrick1: Color; + Firebrick2: Color; + Firebrick3: Color; + Firebrick4: Color; + Gold1: Color; + Gold2: Color; + Gold3: Color; + Gold4: Color; + Goldenrod1: Color; + Goldenrod2: Color; + Goldenrod3: Color; + Goldenrod4: Color; + Green1: Color; + Green2: Color; + Green3: Color; + Green4: Color; + Honeydew1: Color; + Honeydew2: Color; + Honeydew3: Color; + Honeydew4: Color; + HotPink1: Color; + HotPink2: Color; + HotPink3: Color; + HotPink4: Color; + IndianRed1: Color; + IndianRed2: Color; + IndianRed3: Color; + IndianRed4: Color; + Ivory1: Color; + Ivory2: Color; + Ivory3: Color; + Ivory4: Color; + Khaki1: Color; + Khaki2: Color; + Khaki3: Color; + Khaki4: Color; + LavenderBlush1: Color; + LavenderBlush2: Color; + LavenderBlush3: Color; + LavenderBlush4: Color; + LemonChiffon1: Color; + LemonChiffon2: Color; + LemonChiffon3: Color; + LemonChiffon4: Color; + LightBlue1: Color; + LightBlue2: Color; + LightBlue3: Color; + LightBlue4: Color; + LightCyan1: Color; + LightCyan2: Color; + LightCyan3: Color; + LightCyan4: Color; + LightGoldenrod1: Color; + LightGoldenrod2: Color; + LightGoldenrod3: Color; + LightGoldenrod4: Color; + LightPink1: Color; + LightPink2: Color; + LightPink3: Color; + LightPink4: Color; + LightSalmon1: Color; + LightSalmon2: Color; + LightSalmon3: Color; + LightSalmon4: Color; + LightSkyBlue1: Color; + LightSkyBlue2: Color; + LightSkyBlue3: Color; + LightSkyBlue4: Color; + LightSteelBlue1: Color; + LightSteelBlue2: Color; + LightSteelBlue3: Color; + LightSteelBlue4: Color; + LightYellow1: Color; + LightYellow2: Color; + LightYellow3: Color; + LightYellow4: Color; + Magenta1: Color; + Magenta2: Color; + Magenta3: Color; + Magenta4: Color; + Maroon1: Color; + Maroon2: Color; + Maroon3: Color; + Maroon4: Color; + MediumOrchid1: Color; + MediumOrchid2: Color; + MediumOrchid3: Color; + MediumOrchid4: Color; + MediumPurple1: Color; + MediumPurple2: Color; + MediumPurple3: Color; + MediumPurple4: Color; + MistyRose1: Color; + MistyRose2: Color; + MistyRose3: Color; + MistyRose4: Color; + NavajoWhite1: Color; + NavajoWhite2: Color; + NavajoWhite3: Color; + NavajoWhite4: Color; + OliveDrab1: Color; + OliveDrab2: Color; + OliveDrab3: Color; + OliveDrab4: Color; + Orange1: Color; + Orange2: Color; + Orange3: Color; + Orange4: Color; + OrangeRed1: Color; + OrangeRed2: Color; + OrangeRed3: Color; + OrangeRed4: Color; + Orchid1: Color; + Orchid2: Color; + Orchid3: Color; + Orchid4: Color; + PaleGreen1: Color; + PaleGreen2: Color; + PaleGreen3: Color; + PaleGreen4: Color; + PaleTurquoise1: Color; + PaleTurquoise2: Color; + PaleTurquoise3: Color; + PaleTurquoise4: Color; + PaleVioletRed1: Color; + PaleVioletRed2: Color; + PaleVioletRed3: Color; + PaleVioletRed4: Color; + PeachPuff1: Color; + PeachPuff2: Color; + PeachPuff3: Color; + PeachPuff4: Color; + Pink1: Color; + Pink2: Color; + Pink3: Color; + Pink4: Color; + Plum1: Color; + Plum2: Color; + Plum3: Color; + Plum4: Color; + Purple1: Color; + Purple2: Color; + Purple3: Color; + Purple4: Color; + Red1: Color; + Red2: Color; + Red3: Color; + Red4: Color; + RosyBrown1: Color; + RosyBrown2: Color; + RosyBrown3: Color; + RosyBrown4: Color; + RoyalBlue1: Color; + RoyalBlue2: Color; + RoyalBlue3: Color; + RoyalBlue4: Color; + Salmon1: Color; + Salmon2: Color; + Salmon3: Color; + Salmon4: Color; + SeaGreen1: Color; + SeaGreen2: Color; + SeaGreen3: Color; + SeaGreen4: Color; + Seashell1: Color; + Seashell2: Color; + Seashell3: Color; + Seashell4: Color; + Sienna1: Color; + Sienna2: Color; + Sienna3: Color; + Sienna4: Color; + SkyBlue1: Color; + SkyBlue2: Color; + SkyBlue3: Color; + SkyBlue4: Color; + SlateBlue1: Color; + SlateBlue2: Color; + SlateBlue3: Color; + SlateBlue4: Color; + SlateGray1: Color; + SlateGray2: Color; + SlateGray3: Color; + SlateGray4: Color; + Snow1: Color; + Snow2: Color; + Snow3: Color; + Snow4: Color; + SpringGreen1: Color; + SpringGreen2: Color; + SpringGreen3: Color; + SpringGreen4: Color; + SteelBlue1: Color; + SteelBlue2: Color; + SteelBlue3: Color; + SteelBlue4: Color; + Tan1: Color; + Tan2: Color; + Tan3: Color; + Tan4: Color; + Thistle1: Color; + Thistle2: Color; + Thistle3: Color; + Thistle4: Color; + Tomato1: Color; + Tomato2: Color; + Tomato3: Color; + Tomato4: Color; + Turquoise1: Color; + Turquoise2: Color; + Turquoise3: Color; + Turquoise4: Color; + VioletRed1: Color; + VioletRed2: Color; + VioletRed3: Color; + VioletRed4: Color; + Wheat1: Color; + Wheat2: Color; + Wheat3: Color; + Wheat4: Color; + Yellow1: Color; + Yellow2: Color; + Yellow3: Color; + Yellow4: Color; + Gray0: Color; + Green0: Color; + Grey0: Color; + Maroon0: Color; + Purple0: Color; +}; +//# sourceMappingURL=predefined-colors.d.ts.map \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-ctan/package/xcolor/libs/print-raw.d.ts b/node_modules/@unified-latex/unified-latex-ctan/package/xcolor/libs/print-raw.d.ts new file mode 100644 index 0000000..f787558 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-ctan/package/xcolor/libs/print-raw.d.ts @@ -0,0 +1,6 @@ +import * as XColorSpec from "./types"; +/** + * Print an `xcolor` argument specification AST to a string. + */ +export declare function printRaw(node: XColorSpec.Ast, root?: boolean): string; +//# sourceMappingURL=print-raw.d.ts.map \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-ctan/package/xcolor/libs/types.d.ts b/node_modules/@unified-latex/unified-latex-ctan/package/xcolor/libs/types.d.ts new file mode 100644 index 0000000..4f84b3c --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-ctan/package/xcolor/libs/types.d.ts @@ -0,0 +1,66 @@ +export type Ast = Node; +export type Node = Color | InvalidSpec | ColorFunction | ColorExpr | ColorExtExpr | ColorMixExpr | WeightedColorExpr | Postfix | ColorSpec | ColorSpecList; +export type XColor = Color | ColorSpec | ColorSpecList; +interface AstNode { + type: string; +} +interface HexColorSpec extends AstNode { + type: "hex_spec"; + content: [string]; +} +interface NumColorSpec extends AstNode { + type: "num_spec"; + content: number[]; +} +type ColorSpec = HexColorSpec | NumColorSpec; +interface ColorSpecList extends AstNode { + type: "spec_list"; + content: ColorSpec[]; +} +interface InvalidSpec extends AstNode { + type: "invalid_spec"; + content: string; +} +interface Color extends AstNode { + type: "color"; + color: ColorExpr | ColorExtExpr; + functions: ColorFunction[]; +} +interface ColorFunction extends AstNode { + type: "function"; + name: string; + args: number[]; +} +interface ColorExtExpr extends AstNode { + type: "extended_expr"; + core_model: string; + div: number | null; + expressions: WeightedColorExpr[]; +} +interface WeightedColorExpr extends AstNode { + type: "weighted_expr"; + weight: number; + color: ColorExpr; +} +interface ColorExpr extends AstNode { + type: "expr"; + prefix: string | null; + postfix: Postfix | null; + name: string; + mix_expr: ColorMixExpr[]; +} +type ColorMixExpr = { + type: "complete_mix"; + mix_percent: number; + name: string; +} | { + type: "partial_mix"; + mix_percent: number; +}; +interface Postfix extends AstNode { + type: "postfix"; + plusses?: string; + num?: number; +} +export {}; +//# sourceMappingURL=types.d.ts.map \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-ctan/package/xcolor/libs/xcolor-macro-to-hex.d.ts b/node_modules/@unified-latex/unified-latex-ctan/package/xcolor/libs/xcolor-macro-to-hex.d.ts new file mode 100644 index 0000000..94833ea --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-ctan/package/xcolor/libs/xcolor-macro-to-hex.d.ts @@ -0,0 +1,12 @@ +import * as Ast from "@unified-latex/unified-latex-types"; +/** + * Compute the hex representation of a color specified by an xcolor color command. + * For example `\color[rgb]{1 .5 .5}` or `\textcolor{red}{foo}`. If the color cannot be parsed, + * `null` is returned for the hex value. In all cases a css variable name (prefixed with "--"") + * is returned. This can be used to set up CSS for custom colors. + */ +export declare function xcolorMacroToHex(node: Ast.Macro): { + hex: string | null; + cssVarName: string; +}; +//# sourceMappingURL=xcolor-macro-to-hex.d.ts.map \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-ctan/package/xcolor/libs/xcolor.d.ts b/node_modules/@unified-latex/unified-latex-ctan/package/xcolor/libs/xcolor.d.ts new file mode 100644 index 0000000..e608aab --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-ctan/package/xcolor/libs/xcolor.d.ts @@ -0,0 +1,28 @@ +import { default as Color } from 'color'; +import { XColor } from './types'; +export declare const XColorCoreModelToColor: { + rgb: ([r, g, b]: number[]) => Color; + cmy: ([c, m, y]: number[]) => Color; + cmyk: ([c, m, y, k]: number[]) => Color; + hsb: ([h, s, b]: number[]) => Color; + gray: ([v]: number[]) => Color; +}; +export declare const PREDEFINED_XCOLOR_COLORS: Record>; +/** + * Given a parsed `XColor`, compute the color and return a `Color` object + * (that can be used in CSS, for example). + */ +export declare function computeColor(expr: XColor, predefinedColors?: Record>): Color; +/** + * Convert the xcolor defined color to RGB Hex representation. + * If the color is unknown or cannot be computed, `null` is returned. + * + * If `model` is supplied, + * + * The most likely reason a color will be `null` is if the color is defined + * using a pre-defined color that wasn't supplied as an argument. + */ +export declare function xcolorColorToHex(color: string, model?: string | null, options?: { + predefinedColors?: Record>; +}): string | null; +//# sourceMappingURL=xcolor.d.ts.map \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-ctan/package/xcolor/provides.d.ts b/node_modules/@unified-latex/unified-latex-ctan/package/xcolor/provides.d.ts new file mode 100644 index 0000000..88c6521 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-ctan/package/xcolor/provides.d.ts @@ -0,0 +1,4 @@ +import { MacroInfoRecord, EnvInfoRecord } from '@unified-latex/unified-latex-types'; +export declare const macros: MacroInfoRecord; +export declare const environments: EnvInfoRecord; +//# sourceMappingURL=provides.d.ts.map \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-ctan/package/xparse/index.cjs b/node_modules/@unified-latex/unified-latex-ctan/package/xparse/index.cjs new file mode 100644 index 0000000..c052def --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-ctan/package/xparse/index.cjs @@ -0,0 +1,61 @@ +"use strict"; +Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" }); +const macros = { + NewDocumentCommand: { + signature: "m m m", + renderInfo: { breakAround: true } + }, + RenewDocumentCommand: { + signature: "m m m", + renderInfo: { breakAround: true } + }, + ProvideDocumentCommand: { + signature: "m m m", + renderInfo: { breakAround: true } + }, + DeclareDocumentCommand: { + signature: "m m m", + renderInfo: { breakAround: true } + }, + NewDocumentEnvironment: { + signature: "m m m m", + renderInfo: { breakAround: true } + }, + RenewDocumentEnvironment: { + signature: "m m m m", + renderInfo: { breakAround: true } + }, + ProvideDocumentEnvironment: { + signature: "m m m m", + renderInfo: { breakAround: true } + }, + DeclareDocumentEnvironment: { + signature: "m m m m", + renderInfo: { breakAround: true } + }, + NewExpandableDocumentCommand: { + signature: "m m m", + renderInfo: { breakAround: true } + }, + RenewExpandableDocumentCommand: { + signature: "m m m", + renderInfo: { breakAround: true } + }, + ProvideExpandableDocumentCommand: { + signature: "m m m", + renderInfo: { breakAround: true } + }, + DeclareExpandableDocumentCommand: { + signature: "m m m", + renderInfo: { breakAround: true } + }, + RequirePackage: { + signature: "o m", + renderInfo: { pgfkeysArgs: true, breakAround: true } + }, + DeclareOption: { signature: "m m", renderInfo: { breakAround: true } } +}; +const environments = {}; +exports.environments = environments; +exports.macros = macros; +//# sourceMappingURL=index.cjs.map diff --git a/node_modules/@unified-latex/unified-latex-ctan/package/xparse/index.cjs.map b/node_modules/@unified-latex/unified-latex-ctan/package/xparse/index.cjs.map new file mode 100644 index 0000000..dfb5c5e --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-ctan/package/xparse/index.cjs.map @@ -0,0 +1 @@ +{"version":3,"file":"index.cjs","sources":["../../../package/xparse/provides.ts"],"sourcesContent":["import {\n MacroInfoRecord,\n EnvInfoRecord,\n} from \"@unified-latex/unified-latex-types\";\n\nexport const macros: MacroInfoRecord = {\n NewDocumentCommand: {\n signature: \"m m m\",\n renderInfo: { breakAround: true },\n },\n RenewDocumentCommand: {\n signature: \"m m m\",\n renderInfo: { breakAround: true },\n },\n ProvideDocumentCommand: {\n signature: \"m m m\",\n renderInfo: { breakAround: true },\n },\n DeclareDocumentCommand: {\n signature: \"m m m\",\n renderInfo: { breakAround: true },\n },\n NewDocumentEnvironment: {\n signature: \"m m m m\",\n renderInfo: { breakAround: true },\n },\n RenewDocumentEnvironment: {\n signature: \"m m m m\",\n renderInfo: { breakAround: true },\n },\n ProvideDocumentEnvironment: {\n signature: \"m m m m\",\n renderInfo: { breakAround: true },\n },\n DeclareDocumentEnvironment: {\n signature: \"m m m m\",\n renderInfo: { breakAround: true },\n },\n NewExpandableDocumentCommand: {\n signature: \"m m m\",\n renderInfo: { breakAround: true },\n },\n RenewExpandableDocumentCommand: {\n signature: \"m m m\",\n renderInfo: { breakAround: true },\n },\n ProvideExpandableDocumentCommand: {\n signature: \"m m m\",\n renderInfo: { breakAround: true },\n },\n DeclareExpandableDocumentCommand: {\n signature: \"m m m\",\n renderInfo: { breakAround: true },\n },\n RequirePackage: {\n signature: \"o m\",\n renderInfo: { pgfkeysArgs: true, breakAround: true },\n },\n DeclareOption: { signature: \"m m\", renderInfo: { breakAround: true } },\n};\n\nexport const environments: EnvInfoRecord = {};\n"],"names":[],"mappings":";;AAKO,MAAM,SAA0B;AAAA,EACnC,oBAAoB;AAAA,IAChB,WAAW;AAAA,IACX,YAAY,EAAE,aAAa,KAAK;AAAA,EACpC;AAAA,EACA,sBAAsB;AAAA,IAClB,WAAW;AAAA,IACX,YAAY,EAAE,aAAa,KAAK;AAAA,EACpC;AAAA,EACA,wBAAwB;AAAA,IACpB,WAAW;AAAA,IACX,YAAY,EAAE,aAAa,KAAK;AAAA,EACpC;AAAA,EACA,wBAAwB;AAAA,IACpB,WAAW;AAAA,IACX,YAAY,EAAE,aAAa,KAAK;AAAA,EACpC;AAAA,EACA,wBAAwB;AAAA,IACpB,WAAW;AAAA,IACX,YAAY,EAAE,aAAa,KAAK;AAAA,EACpC;AAAA,EACA,0BAA0B;AAAA,IACtB,WAAW;AAAA,IACX,YAAY,EAAE,aAAa,KAAK;AAAA,EACpC;AAAA,EACA,4BAA4B;AAAA,IACxB,WAAW;AAAA,IACX,YAAY,EAAE,aAAa,KAAK;AAAA,EACpC;AAAA,EACA,4BAA4B;AAAA,IACxB,WAAW;AAAA,IACX,YAAY,EAAE,aAAa,KAAK;AAAA,EACpC;AAAA,EACA,8BAA8B;AAAA,IAC1B,WAAW;AAAA,IACX,YAAY,EAAE,aAAa,KAAK;AAAA,EACpC;AAAA,EACA,gCAAgC;AAAA,IAC5B,WAAW;AAAA,IACX,YAAY,EAAE,aAAa,KAAK;AAAA,EACpC;AAAA,EACA,kCAAkC;AAAA,IAC9B,WAAW;AAAA,IACX,YAAY,EAAE,aAAa,KAAK;AAAA,EACpC;AAAA,EACA,kCAAkC;AAAA,IAC9B,WAAW;AAAA,IACX,YAAY,EAAE,aAAa,KAAK;AAAA,EACpC;AAAA,EACA,gBAAgB;AAAA,IACZ,WAAW;AAAA,IACX,YAAY,EAAE,aAAa,MAAM,aAAa,KAAK;AAAA,EACvD;AAAA,EACA,eAAe,EAAE,WAAW,OAAO,YAAY,EAAE,aAAa,KAAO,EAAA;AACzE;AAEO,MAAM,eAA8B,CAAA;;;"} \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-ctan/package/xparse/index.d.ts b/node_modules/@unified-latex/unified-latex-ctan/package/xparse/index.d.ts new file mode 100644 index 0000000..981b287 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-ctan/package/xparse/index.d.ts @@ -0,0 +1,2 @@ +export * from './provides'; +//# sourceMappingURL=index.d.ts.map \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-ctan/package/xparse/index.js b/node_modules/@unified-latex/unified-latex-ctan/package/xparse/index.js new file mode 100644 index 0000000..ac50984 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-ctan/package/xparse/index.js @@ -0,0 +1,61 @@ +const macros = { + NewDocumentCommand: { + signature: "m m m", + renderInfo: { breakAround: true } + }, + RenewDocumentCommand: { + signature: "m m m", + renderInfo: { breakAround: true } + }, + ProvideDocumentCommand: { + signature: "m m m", + renderInfo: { breakAround: true } + }, + DeclareDocumentCommand: { + signature: "m m m", + renderInfo: { breakAround: true } + }, + NewDocumentEnvironment: { + signature: "m m m m", + renderInfo: { breakAround: true } + }, + RenewDocumentEnvironment: { + signature: "m m m m", + renderInfo: { breakAround: true } + }, + ProvideDocumentEnvironment: { + signature: "m m m m", + renderInfo: { breakAround: true } + }, + DeclareDocumentEnvironment: { + signature: "m m m m", + renderInfo: { breakAround: true } + }, + NewExpandableDocumentCommand: { + signature: "m m m", + renderInfo: { breakAround: true } + }, + RenewExpandableDocumentCommand: { + signature: "m m m", + renderInfo: { breakAround: true } + }, + ProvideExpandableDocumentCommand: { + signature: "m m m", + renderInfo: { breakAround: true } + }, + DeclareExpandableDocumentCommand: { + signature: "m m m", + renderInfo: { breakAround: true } + }, + RequirePackage: { + signature: "o m", + renderInfo: { pgfkeysArgs: true, breakAround: true } + }, + DeclareOption: { signature: "m m", renderInfo: { breakAround: true } } +}; +const environments = {}; +export { + environments, + macros +}; +//# sourceMappingURL=index.js.map diff --git a/node_modules/@unified-latex/unified-latex-ctan/package/xparse/index.js.map b/node_modules/@unified-latex/unified-latex-ctan/package/xparse/index.js.map new file mode 100644 index 0000000..6d341b2 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-ctan/package/xparse/index.js.map @@ -0,0 +1 @@ +{"version":3,"file":"index.js","sources":["../../../package/xparse/provides.ts"],"sourcesContent":["import {\n MacroInfoRecord,\n EnvInfoRecord,\n} from \"@unified-latex/unified-latex-types\";\n\nexport const macros: MacroInfoRecord = {\n NewDocumentCommand: {\n signature: \"m m m\",\n renderInfo: { breakAround: true },\n },\n RenewDocumentCommand: {\n signature: \"m m m\",\n renderInfo: { breakAround: true },\n },\n ProvideDocumentCommand: {\n signature: \"m m m\",\n renderInfo: { breakAround: true },\n },\n DeclareDocumentCommand: {\n signature: \"m m m\",\n renderInfo: { breakAround: true },\n },\n NewDocumentEnvironment: {\n signature: \"m m m m\",\n renderInfo: { breakAround: true },\n },\n RenewDocumentEnvironment: {\n signature: \"m m m m\",\n renderInfo: { breakAround: true },\n },\n ProvideDocumentEnvironment: {\n signature: \"m m m m\",\n renderInfo: { breakAround: true },\n },\n DeclareDocumentEnvironment: {\n signature: \"m m m m\",\n renderInfo: { breakAround: true },\n },\n NewExpandableDocumentCommand: {\n signature: \"m m m\",\n renderInfo: { breakAround: true },\n },\n RenewExpandableDocumentCommand: {\n signature: \"m m m\",\n renderInfo: { breakAround: true },\n },\n ProvideExpandableDocumentCommand: {\n signature: \"m m m\",\n renderInfo: { breakAround: true },\n },\n DeclareExpandableDocumentCommand: {\n signature: \"m m m\",\n renderInfo: { breakAround: true },\n },\n RequirePackage: {\n signature: \"o m\",\n renderInfo: { pgfkeysArgs: true, breakAround: true },\n },\n DeclareOption: { signature: \"m m\", renderInfo: { breakAround: true } },\n};\n\nexport const environments: EnvInfoRecord = {};\n"],"names":[],"mappings":"AAKO,MAAM,SAA0B;AAAA,EACnC,oBAAoB;AAAA,IAChB,WAAW;AAAA,IACX,YAAY,EAAE,aAAa,KAAK;AAAA,EACpC;AAAA,EACA,sBAAsB;AAAA,IAClB,WAAW;AAAA,IACX,YAAY,EAAE,aAAa,KAAK;AAAA,EACpC;AAAA,EACA,wBAAwB;AAAA,IACpB,WAAW;AAAA,IACX,YAAY,EAAE,aAAa,KAAK;AAAA,EACpC;AAAA,EACA,wBAAwB;AAAA,IACpB,WAAW;AAAA,IACX,YAAY,EAAE,aAAa,KAAK;AAAA,EACpC;AAAA,EACA,wBAAwB;AAAA,IACpB,WAAW;AAAA,IACX,YAAY,EAAE,aAAa,KAAK;AAAA,EACpC;AAAA,EACA,0BAA0B;AAAA,IACtB,WAAW;AAAA,IACX,YAAY,EAAE,aAAa,KAAK;AAAA,EACpC;AAAA,EACA,4BAA4B;AAAA,IACxB,WAAW;AAAA,IACX,YAAY,EAAE,aAAa,KAAK;AAAA,EACpC;AAAA,EACA,4BAA4B;AAAA,IACxB,WAAW;AAAA,IACX,YAAY,EAAE,aAAa,KAAK;AAAA,EACpC;AAAA,EACA,8BAA8B;AAAA,IAC1B,WAAW;AAAA,IACX,YAAY,EAAE,aAAa,KAAK;AAAA,EACpC;AAAA,EACA,gCAAgC;AAAA,IAC5B,WAAW;AAAA,IACX,YAAY,EAAE,aAAa,KAAK;AAAA,EACpC;AAAA,EACA,kCAAkC;AAAA,IAC9B,WAAW;AAAA,IACX,YAAY,EAAE,aAAa,KAAK;AAAA,EACpC;AAAA,EACA,kCAAkC;AAAA,IAC9B,WAAW;AAAA,IACX,YAAY,EAAE,aAAa,KAAK;AAAA,EACpC;AAAA,EACA,gBAAgB;AAAA,IACZ,WAAW;AAAA,IACX,YAAY,EAAE,aAAa,MAAM,aAAa,KAAK;AAAA,EACvD;AAAA,EACA,eAAe,EAAE,WAAW,OAAO,YAAY,EAAE,aAAa,KAAO,EAAA;AACzE;AAEO,MAAM,eAA8B,CAAA;"} \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-ctan/package/xparse/provides.d.ts b/node_modules/@unified-latex/unified-latex-ctan/package/xparse/provides.d.ts new file mode 100644 index 0000000..88c6521 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-ctan/package/xparse/provides.d.ts @@ -0,0 +1,4 @@ +import { MacroInfoRecord, EnvInfoRecord } from '@unified-latex/unified-latex-types'; +export declare const macros: MacroInfoRecord; +export declare const environments: EnvInfoRecord; +//# sourceMappingURL=provides.d.ts.map \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-ctan/parser-9Q3EtimU.cjs b/node_modules/@unified-latex/unified-latex-ctan/parser-9Q3EtimU.cjs new file mode 100644 index 0000000..fa43997 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-ctan/parser-9Q3EtimU.cjs @@ -0,0 +1,503 @@ +"use strict"; +const unifiedLatexUtilArguments = require("@unified-latex/unified-latex-util-arguments"); +const unifiedLatexBuilder = require("@unified-latex/unified-latex-builder"); +const unifiedLatexUtilArgspec = require("@unified-latex/unified-latex-util-argspec"); +const unifiedLatexUtilMatch = require("@unified-latex/unified-latex-util-match"); +const unifiedLatexUtilScan = require("@unified-latex/unified-latex-util-scan"); +const unifiedLatexUtilTrim = require("@unified-latex/unified-latex-util-trim"); +const unifiedLatexUtilPegjs = require("@unified-latex/unified-latex-util-pegjs"); +const OPTIONAL_ARGUMENT_ARG_SPEC = unifiedLatexUtilArgspec.parse("o")[0]; +function blankArg() { + return unifiedLatexBuilder.arg([], { openMark: "", closeMark: "" }); +} +const tikzCommandArgumentParser = (nodes, startPos) => { + const origStartPos = startPos; + let pos = startPos; + let nodesRemoved = 0; + const cursorPosAfterAnimations = eatAllAnimationSpecs(nodes, pos); + let animationArg = blankArg(); + if (cursorPosAfterAnimations !== pos) { + const argContent = nodes.splice(pos, cursorPosAfterAnimations - pos); + unifiedLatexUtilTrim.trim(argContent); + animationArg = unifiedLatexBuilder.arg(argContent, { + openMark: " ", + closeMark: " " + }); + } + nodesRemoved += cursorPosAfterAnimations - pos; + const { + argument: _optionalArgument, + nodesRemoved: optionalArgumentNodesRemoved + } = unifiedLatexUtilArguments.gobbleSingleArgument(nodes, OPTIONAL_ARGUMENT_ARG_SPEC, pos); + nodesRemoved += optionalArgumentNodesRemoved; + const optionalArg = _optionalArgument || blankArg(); + while (unifiedLatexUtilMatch.match.whitespace(nodes[pos])) { + pos++; + } + const firstNode = nodes[pos]; + if (!firstNode) { + return { + args: [animationArg, optionalArg, blankArg()], + nodesRemoved: 0 + }; + } + if (unifiedLatexUtilMatch.match.group(firstNode)) { + const args = [animationArg, optionalArg, unifiedLatexBuilder.arg(firstNode.content)]; + nodes.splice(origStartPos, pos - origStartPos + 1); + return { args, nodesRemoved: pos - origStartPos + 1 + nodesRemoved }; + } + const semicolonPosition = unifiedLatexUtilScan.scan(nodes, ";", { startIndex: pos }); + if (semicolonPosition != null) { + const argNodes = nodes.splice( + origStartPos, + semicolonPosition - origStartPos + 1 + ); + unifiedLatexUtilTrim.trim(argNodes); + const args = [animationArg, optionalArg, unifiedLatexBuilder.arg(argNodes)]; + return { + args, + nodesRemoved: origStartPos - semicolonPosition + 1 + nodesRemoved + }; + } + return { + args: [animationArg, optionalArg, blankArg()], + nodesRemoved: 0 + }; +}; +function eatAllAnimationSpecs(nodes, startPos) { + const colonPos = unifiedLatexUtilScan.scan(nodes, ":", { + startIndex: startPos, + allowSubstringMatches: true, + onlySkipWhitespaceAndComments: true + }); + if (!colonPos) { + return startPos; + } + let lastMatchPos = startPos; + let i = colonPos + 1; + for (; i < nodes.length; i++) { + const node = nodes[i]; + if (unifiedLatexUtilMatch.match.string(node, "[")) { + break; + } + if (unifiedLatexUtilMatch.match.string(node, "=")) { + i++; + while (unifiedLatexUtilMatch.match.whitespace(nodes[i]) || unifiedLatexUtilMatch.match.comment(nodes[i])) { + i++; + } + if (!unifiedLatexUtilMatch.match.group(nodes[i])) { + break; + } + lastMatchPos = i + 1; + const colonPos2 = unifiedLatexUtilScan.scan(nodes, ":", { + startIndex: lastMatchPos, + allowSubstringMatches: true, + onlySkipWhitespaceAndComments: true + }); + if (colonPos2 == null) { + break; + } + i = colonPos2 + 1; + } + } + return lastMatchPos; +} +const macros = { + pgfkeys: { + signature: "m", + renderInfo: { breakAround: true, pgfkeysArgs: true } + }, + tikzoption: { + signature: "m", + renderInfo: { breakAround: true, pgfkeysArgs: true } + }, + tikzstyle: { + signature: "m", + renderInfo: { breakAround: true, pgfkeysArgs: true } + }, + usetikzlibrary: { + signature: "m", + renderInfo: { breakAround: true, pgfkeysArgs: true } + }, + usepgfmodule: { signature: "m", renderInfo: { pgfkeysArgs: true } }, + usepgflibrary: { signature: "m", renderInfo: { pgfkeysArgs: true } }, + pgfplotsset: { + signature: "m", + renderInfo: { breakAround: true, pgfkeysArgs: true } + }, + pgfplotstabletypeset: { + signature: "o m", + renderInfo: { breakAround: true, pgfkeysArgs: true } + }, + tikz: { + signature: "o o m", + argumentParser: tikzCommandArgumentParser, + renderInfo: { namedArguments: ["animation", "options", "command"] } + } +}; +const environments = { + tikzpicture: { + signature: "o", + renderInfo: { pgfkeysArgs: true, tikzEnvironment: true }, + processContent: processTikzEnvironmentContent + }, + axis: { + signature: "o", + renderInfo: { pgfkeysArgs: true, tikzEnvironment: true }, + processContent: processTikzEnvironmentContent + }, + scope: { + signature: "o", + renderInfo: { pgfkeysArgs: true, tikzEnvironment: true }, + processContent: processTikzEnvironmentContent + }, + pgfonlayer: { + signature: "m", + renderInfo: { tikzEnvironment: true }, + processContent: processTikzEnvironmentContent + }, + pgflowlevelscope: { + signature: "m", + renderInfo: { tikzEnvironment: true }, + processContent: processTikzEnvironmentContent + }, + pgfviewboxscope: { + signature: "m m m m m", + renderInfo: { tikzEnvironment: true }, + processContent: processTikzEnvironmentContent + }, + pgftransparencygroup: { + signature: "o", + renderInfo: { pgfkeysArgs: true, tikzEnvironment: true }, + processContent: processTikzEnvironmentContent + }, + behindforegroundpath: { + signature: "m", + processContent: processTikzEnvironmentContent + }, + pgfmetadecoration: { + signature: "m", + processContent: processTikzEnvironmentContent + }, + colormixin: { signature: "m", renderInfo: { pgfkeysArgs: true } } +}; +function processTikzEnvironmentContent(nodes) { + unifiedLatexUtilArguments.attachMacroArgsInArray(nodes, conditionalMacros); + return nodes; +} +const conditionalMacros = { + pgfextra: { signature: "m" }, + beginpgfgraphicnamed: { signature: "m" }, + pgfrealjobname: { signature: "m" }, + pgfplotstreampoint: { signature: "m" }, + pgfplotstreampointoutlier: { signature: "m" }, + pgfplotstreamspecial: { signature: "m" }, + pgfplotxyfile: { signature: "m" }, + pgfplotxyzfile: { signature: "m" }, + pgfplotfunction: { signature: "mmm" }, + pgfplotgnuplot: { signature: "o m" }, + pgfplothandlerrecord: { signature: "m" }, + pgfdeclareplothandler: { signature: "m m m" }, + pgfdeclarelayer: { signature: "m" }, + pgfsetlayers: { signature: "m", renderInfo: { pgfkeysArgs: true } }, + pgfonlayer: { signature: "m" }, + startpgfonlayer: { signature: "m" }, + pgfdeclarehorizontalshading: { signature: "o m m m " }, + pgfdeclareradialshading: { signature: "o m m m" }, + pgfdeclarefunctionalshading: { signature: "o m m m m m" }, + pgfshadecolortorgb: { signature: "m m" }, + pgfshadecolortocmyk: { signature: "m m" }, + pgfshadecolortogray: { signature: "m m" }, + pgfuseshading: { signature: "m" }, + pgfshadepath: { signature: "m m" }, + pgfsetadditionalshadetransform: { signature: "m" }, + pgfsetstrokeopacity: { signature: "m" }, + pgfsetfillopacity: { signature: "m" }, + pgfsetblendmode: { signature: "m" }, + pgfdeclarefading: { signature: "m m" }, + pgfsetfading: { signature: "m m" }, + pgfsetfadingforcurrentpath: { signature: "m m" }, + pgfsetfadingforcurrentpathstroked: { signature: "m m" }, + pgfanimateattribute: { signature: "m m" }, + pgfsnapshot: { signature: "m" }, + pgfqpoint: { signature: "m m" }, + pgfqpointxy: { signature: "m m" }, + pgfqpointxyz: { signature: "m m m" }, + pgfqpointscale: { signature: "m m" }, + pgfpathqmoveto: { signature: "m m" }, + pgfpathqlineto: { signature: "m m" }, + pgfpathqcurveto: { signature: "m m m m m m" }, + pgfpathqcircle: { signature: "m" }, + pgfqbox: { signature: "m" }, + pgfqboxsynced: { signature: "m" }, + pgfaliasimage: { signature: "m m" }, + pgfuseimage: { signature: "m" }, + pgfimage: { signature: "o m", renderInfo: { pgfkeysArgs: true } }, + pgfdeclaremask: { signature: "o m m", renderInfo: { pgfkeysArgs: true } }, + pgfdeclarepatternformonly: { signature: "o m m m m m" }, + pgfdeclarepatterninherentlycolored: { signature: "o m m m m m" }, + pgfsetfillpattern: { signature: "m m" }, + // Coordinate canvas and nonlinear transformations + pgftransformshift: { signature: "m" }, + pgftransformxshift: { signature: "m" }, + pgftransformyshift: { signature: "m" }, + pgftransformscale: { signature: "m" }, + pgftransformxscale: { signature: "m" }, + pgftransformyscale: { signature: "m" }, + pgftransformxslant: { signature: "m" }, + pgftransformyslant: { signature: "m" }, + pgftransformrotate: { signature: "m" }, + pgftransformtriangle: { signature: "m m m" }, + pgftransformcm: { signature: "m m m m m" }, + pgftransformarrow: { signature: "m m" }, + pgftransformlineattime: { signature: "m m m" }, + pgftransformcurveattime: { signature: "m m m m m" }, + pgftransformarcaxesattime: { signature: "m m m m m m" }, + pgfgettransform: { signature: "m" }, + pgfsettransform: { signature: "m" }, + pgfgettransformentries: { signature: "m m m m m m" }, + pgfsettransformentries: { signature: "m m m m m m" }, + pgfpointtransformed: { signature: "m" }, + pgflowlevel: { signature: "m" }, + pgflowlevelobj: { signature: "m m" }, + pgflowlevelscope: { signature: "m" }, + startpgflowlevelscope: { signature: "m" }, + pgfviewboxscope: { signature: "m m m m m" }, + startpgfviewboxscope: { signature: "m m m m m" }, + pgftransformnonlinear: { signature: "m" }, + pgfpointtransformednonlinear: { signature: "m" }, + pgfsetcurvilinearbeziercurve: { signature: "m m m m" }, + pgfcurvilineardistancetotime: { signature: "m" }, + pgfpointcurvilinearbezierorthogonal: { signature: "m m" }, + pgfpointcurvilinearbezierpolar: { signature: "m m" }, + // Matrices + pgfmatrix: { signature: "m m m m m m m" }, + pgfsetmatrixcolumnsep: { signature: "m" }, + pgfmatrixnextcell: { signature: "o" }, + pgfsetmatrixrowsep: { signature: "m" }, + pgfmatrixendrow: { signature: "o" }, + // Nodes and shapes + pgfnode: { signature: "m m m m m" }, + pgfmultipartnode: { signature: "m m m m" }, + pgfcoordinate: { signature: "m m" }, + pgfnodealias: { signature: "m m" }, + pgfnoderename: { signature: "m m" }, + pgfpositionnodelater: { signature: "m" }, + pgfpositionnodenow: { signature: "m" }, + pgfnodepostsetupcode: { signature: "m m" }, + pgfpointanchor: { signature: "m m" }, + pgfpointshapeborder: { signature: "m m" }, + pgfdeclareshape: { signature: "m m" }, + saveddimen: { signature: "m m" }, + savedmacro: { signature: " m" }, + anchor: { signature: "m m" }, + deferredanchor: { signature: "m m" }, + anchorborder: { signature: "m" }, + backgroundpath: { signature: "m" }, + foregroundpath: { signature: "m" }, + behindbackgroundpath: { signature: "m" }, + beforebackgroundpath: { signature: "m" }, + beforeforegroundpath: { signature: "m" }, + behindforegroundpath: { signature: "m" }, + // Arrows + pgfdeclarearrow: { signature: "m" }, + pgfarrowssettipend: { signature: "m" }, + pgfarrowssetbackend: { signature: "m" }, + pgfarrowssetlineend: { signature: "m" }, + pgfarrowssetvisualbackend: { signature: "m" }, + pgfarrowssetvisualtipend: { signature: "m" }, + pgfarrowshullpoint: { signature: "m m" }, + pgfarrowsupperhullpoint: { signature: "m m" }, + pgfarrowssave: { signature: "m" }, + pgfarrowssavethe: { signature: "m" }, + pgfarrowsaddtooptions: { signature: "m" }, + pgfarrowsaddtolateoptions: { signature: "m" }, + pgfarrowsaddtolengthscalelist: { signature: "m" }, + pgfarrowsaddtowidthscalelist: { signature: "m" }, + pgfarrowsthreeparameters: { signature: "m" }, + pgfarrowslinewidthdependent: { signature: "m m m" }, + pgfarrowslengthdependent: { signature: "m" }, + // Path + pgfusepath: { signature: "m" }, + pgfsetlinewidth: { signature: "m" }, + pgfsetmiterlimit: { signature: "m" }, + pgfsetdash: { signature: "m m" }, + pgfsetstrokecolor: { signature: "m" }, + pgfsetcolor: { signature: "m" }, + pgfsetinnerlinewidth: { signature: "m" }, + pgfsetinnerstrokecolor: { signature: "m" }, + pgfsetarrowsstart: { signature: "m" }, + pgfsetarrowsend: { signature: "m" }, + pgfsetarrows: { signature: "m" }, + pgfsetshortenstart: { signature: "m" }, + pgfsetshortenend: { signature: "m" }, + pgfsetfillcolor: { signature: "m" }, + // Decorations + pgfdeclaredecoration: { signature: "m m m" }, + state: { signature: "m o m" }, + pgfdecoratepath: { signature: "m m" }, + startpgfdecoration: { signature: "m" }, + pgfdecoration: { signature: "m" }, + pgfdecoratecurrentpath: { signature: "m" }, + pgfsetdecorationsegmenttransformation: { signature: "m" }, + pgfdeclaremetadecorate: { signature: "m m m" }, + pgfmetadecoration: { signature: "m" }, + startpgfmetadecoration: { signature: "m" }, + // Constructing paths + pgfpathmoveto: { signature: "m" }, + pgfpathlineto: { signature: "m" }, + pgfpathcurveto: { signature: "m m m" }, + pgfpathquadraticcurveto: { signature: "m m" }, + pgfpathcurvebetweentime: { signature: "m m m m m m" }, + pgfpathcurvebetweentimecontinue: { signature: "m m m m m m" }, + pgfpatharc: { signature: "m m m" }, + pgfpatharcaxes: { signature: "m m m m" }, + pgfpatharcto: { signature: "m m m m m m" }, + pgfpatharctoprecomputed: { signature: "m m m m m m m m" }, + pgfpathellipse: { signature: "m m m" }, + pgfpathcircle: { signature: "m m" }, + pgfpathrectangle: { signature: "m m" }, + pgfpathrectanglecorners: { signature: "m m" }, + pgfpathgrid: { signature: " o m m" }, + pgfpathparabola: { signature: "m m" }, + pgfpathsine: { signature: "m" }, + pgfpathcosine: { signature: "m" }, + pgfsetcornersarced: { signature: "m" }, + "pgf@protocolsizes": { signature: "m m" }, + // Specifying coordinates + pgfpoint: { signature: "m m" }, + pgfpointpolar: { signature: "m m m" }, + pgfpointxy: { signature: "m m" }, + pgfsetxvec: { signature: "m" }, + pgfsetyvec: { signature: "m" }, + pgfpointpolarxy: { signature: "m m" }, + pgfpointxyz: { signature: "m m m" }, + pgfsetzvec: { signature: "m" }, + pgfpointcylindrical: { signature: "m m m" }, + pgfpointspherical: { signature: "m m m" }, + pgfpointadd: { signature: "m m" }, + pgfpointscale: { signature: "m m" }, + pgfpointdiff: { signature: "m m" }, + pgfpointnormalised: { signature: "m" }, + pgfpointlineattime: { signature: "m m m" }, + pgfpointlineatdistance: { signature: "m m m" }, + pgfpointarcaxesattime: { signature: "m m m m m m" }, + pgfpointcurveattime: { signature: "m m m m m" }, + pgfpointborderrectangle: { signature: "m m" }, + pgfpointborderellipse: { signature: "m m" }, + pgfpointintersectionoflines: { signature: "m m m m" }, + pgfpointintersectionofcircles: { signature: "m m m m m" }, + pgfintersectionofpaths: { signature: "m m" }, + pgfpointintersectionsolution: { signature: "m" }, + pgfextractx: { signature: "m m" }, + pgfextracty: { signature: "m m" }, + pgfgetlastxy: { signature: "m m" }, + "pgf@process": { signature: "m" }, + // Heirarchical structres ... + pgfsetbaseline: { signature: "m" }, + pgfsetbaselinepointnow: { signature: "m" }, + pgfsetbaselinepointlater: { signature: "m" }, + pgftext: { signature: "o m", renderInfo: { pgfkeysArgs: true } }, + pgfuseid: { signature: "m" }, + pgfusetype: { signature: "m" }, + pgfidrefnextuse: { signature: "m m" }, + pgfidrefprevuse: { signature: "m m" }, + pgfaliasid: { signature: "m m" }, + pgfgaliasid: { signature: "m m" }, + pgfifidreferenced: { signature: "m m m" }, + pgfrdfabout: { signature: "m" }, + pgfrdfcontent: { signature: "m" }, + pgfrdfdatatype: { signature: "m" }, + pgfrdfhref: { signature: "m" }, + pgfrdfprefix: { signature: "m" }, + pgfrdfproperty: { signature: "m" }, + pgfrdfrel: { signature: "m" }, + pgfrdfresource: { signature: "m" }, + pgfrdfrev: { signature: "m" }, + pgfrdfsrc: { signature: "m" }, + pgfrdftypeof: { signature: "m" }, + pgfrdfvocab: { signature: "m" }, + pgferror: { signature: "m" }, + pgfwarning: { signature: "m" }, + path: { + signature: "u;", + renderInfo: { breakAround: true, tikzPathCommand: true } + }, + draw: { + signature: "u;", + renderInfo: { breakAround: true, tikzPathCommand: true } + }, + fill: { + signature: "u;", + renderInfo: { breakAround: true, tikzPathCommand: true } + }, + filldraw: { + signature: "u;", + renderInfo: { breakAround: true, tikzPathCommand: true } + }, + pattern: { + signature: "u;", + renderInfo: { breakAround: true, tikzPathCommand: true } + }, + shade: { + signature: "u;", + renderInfo: { breakAround: true, tikzPathCommand: true } + }, + clip: { + signature: "u;", + renderInfo: { breakAround: true, tikzPathCommand: true } + }, + useasboundingbox: { + signature: "u;", + renderInfo: { breakAround: true, tikzPathCommand: true } + }, + node: { + signature: "u;", + renderInfo: { breakAround: true, tikzPathCommand: true } + }, + coordinate: { + signature: "u;", + renderInfo: { breakAround: true, tikzPathCommand: true } + }, + graph: { + signature: "u;", + renderInfo: { breakAround: true, tikzPathCommand: true } + }, + scoped: { + signature: "o o m", + argumentParser: tikzCommandArgumentParser, + renderInfo: { + namedArguments: ["animation", "options", "command"], + breakAround: true + } + } +}; +function createMatchers() { + return { + isChar: unifiedLatexUtilMatch.match.string, + isTerminal: (node) => unifiedLatexUtilMatch.match.string(node, ";"), + isOperation: (node) => unifiedLatexUtilMatch.match.anyString(node) && node.content.match(/[a-zA-Z]/), + isWhitespace: (node) => unifiedLatexUtilMatch.match.whitespace(node) || unifiedLatexUtilMatch.match.parbreak(node), + isComment: unifiedLatexUtilMatch.match.comment, + isGroup: unifiedLatexUtilMatch.match.group, + isMacro: unifiedLatexUtilMatch.match.macro, + isAnyMacro: unifiedLatexUtilMatch.match.anyMacro + }; +} +const matchers = createMatchers(); +function parse(ast, options) { + const { startRule = "path_spec" } = options || {}; + if (!Array.isArray(ast)) { + throw new Error("You must pass an array of nodes"); + } + ast = unifiedLatexUtilPegjs.decorateArrayForPegjs([...ast]); + return unifiedLatexUtilPegjs.TikzPegParser.parse(ast, { + ...matchers, + startRule + }); +} +exports.conditionalMacros = conditionalMacros; +exports.environments = environments; +exports.macros = macros; +exports.parse = parse; +//# sourceMappingURL=parser-9Q3EtimU.cjs.map diff --git a/node_modules/@unified-latex/unified-latex-ctan/parser-9Q3EtimU.cjs.map b/node_modules/@unified-latex/unified-latex-ctan/parser-9Q3EtimU.cjs.map new file mode 100644 index 0000000..a677e39 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-ctan/parser-9Q3EtimU.cjs.map @@ -0,0 +1 @@ +{"version":3,"file":"parser-9Q3EtimU.cjs","sources":["../package/tikz/libs/tikz-command-argument-parser.ts","../package/tikz/provides.ts","../package/tikz/libs/parser.ts"],"sourcesContent":["import { arg } from \"@unified-latex/unified-latex-builder\";\nimport * as Ast from \"@unified-latex/unified-latex-types\";\nimport {\n ArgSpecAst as ArgSpec,\n parse as parseArgspec,\n} from \"@unified-latex/unified-latex-util-argspec\";\nimport { Argument, ArgumentParser } from \"@unified-latex/unified-latex-types\";\nimport { gobbleSingleArgument } from \"@unified-latex/unified-latex-util-arguments\";\nimport { match } from \"@unified-latex/unified-latex-util-match\";\nimport { scan } from \"@unified-latex/unified-latex-util-scan\";\nimport { trim } from \"@unified-latex/unified-latex-util-trim\";\nimport { printRaw } from \"@unified-latex/unified-latex-util-print-raw\";\n\nconst OPTIONAL_ARGUMENT_ARG_SPEC = parseArgspec(\"o\")[0];\n\nfunction blankArg() {\n return arg([], { openMark: \"\", closeMark: \"\" });\n}\n\n/**\n * Find the arguments of a tikz command. Many tikz commands accept either\n * the a group as their only argument, or they scan their arguments until the first\n * `;` is found.\n *\n * This behavior cannot be achieved via a standard xparse spec.\n */\nexport const tikzCommandArgumentParser: ArgumentParser = (nodes, startPos) => {\n const origStartPos = startPos;\n let pos = startPos;\n let nodesRemoved = 0;\n\n const cursorPosAfterAnimations = eatAllAnimationSpecs(nodes, pos);\n let animationArg = blankArg();\n if (cursorPosAfterAnimations !== pos) {\n const argContent = nodes.splice(pos, cursorPosAfterAnimations - pos);\n trim(argContent);\n animationArg = arg(argContent, {\n openMark: \" \",\n closeMark: \" \",\n });\n }\n nodesRemoved += cursorPosAfterAnimations - pos;\n\n const {\n argument: _optionalArgument,\n nodesRemoved: optionalArgumentNodesRemoved,\n } = gobbleSingleArgument(nodes, OPTIONAL_ARGUMENT_ARG_SPEC, pos) as {\n argument: Argument;\n nodesRemoved: number;\n };\n nodesRemoved += optionalArgumentNodesRemoved;\n const optionalArg = _optionalArgument || blankArg();\n\n // Eat whitespace\n while (match.whitespace(nodes[pos])) {\n pos++;\n }\n const firstNode = nodes[pos];\n\n // If we're past the end of the array, give up.\n if (!firstNode) {\n return {\n args: [animationArg, optionalArg, blankArg()],\n nodesRemoved: 0,\n };\n }\n\n // If we're a group, grab the contents and call it good.\n if (match.group(firstNode)) {\n const args = [animationArg, optionalArg, arg(firstNode.content)];\n nodes.splice(origStartPos, pos - origStartPos + 1);\n return { args, nodesRemoved: pos - origStartPos + 1 + nodesRemoved };\n }\n\n // No group, so scan for a semicolon.\n const semicolonPosition = scan(nodes, \";\", { startIndex: pos });\n if (semicolonPosition != null) {\n const argNodes = nodes.splice(\n origStartPos,\n semicolonPosition - origStartPos + 1\n );\n trim(argNodes);\n const args = [animationArg, optionalArg, arg(argNodes)];\n return {\n args,\n nodesRemoved: origStartPos - semicolonPosition + 1 + nodesRemoved,\n };\n }\n\n // If there was no semicolon, give up.\n return {\n args: [animationArg, optionalArg, blankArg()],\n nodesRemoved: 0,\n };\n};\n\n/**\n * Find the next index after all animation specs. If no animation specs are present,\n * return `startPos`.\n *\n * An animation spec looks like\n * ```\n * :rotate = { 0s=\"0\", 2s=\"90\", begin on=click }\n * ```\n * Any number can be listed. They start with a colon and have an equals sign followed by a group.\n */\nfunction eatAllAnimationSpecs(nodes: Ast.Node[], startPos: number): number {\n const colonPos = scan(nodes, \":\", {\n startIndex: startPos,\n allowSubstringMatches: true,\n onlySkipWhitespaceAndComments: true,\n });\n\n if (!colonPos) {\n return startPos;\n }\n\n let lastMatchPos = startPos;\n let i = colonPos + 1;\n for (; i < nodes.length; i++) {\n const node = nodes[i];\n if (match.string(node, \"[\")) {\n // XXX As per the tikz manual, we stop scanning if we find an open square brace.\n break;\n }\n if (match.string(node, \"=\")) {\n i++;\n // Look for a group next\n while (match.whitespace(nodes[i]) || match.comment(nodes[i])) {\n i++;\n }\n if (!match.group(nodes[i])) {\n break;\n }\n // We have a match!\n lastMatchPos = i + 1;\n\n // Start the process again\n const colonPos = scan(nodes, \":\", {\n startIndex: lastMatchPos,\n allowSubstringMatches: true,\n onlySkipWhitespaceAndComments: true,\n });\n if (colonPos == null) {\n break;\n }\n i = colonPos + 1;\n }\n }\n\n return lastMatchPos;\n}\n","import {\n MacroInfoRecord,\n EnvInfoRecord,\n} from \"@unified-latex/unified-latex-types\";\nimport * as Ast from \"@unified-latex/unified-latex-types\";\nimport { attachMacroArgsInArray } from \"@unified-latex/unified-latex-util-arguments\";\nimport { tikzCommandArgumentParser } from \"./libs/tikz-command-argument-parser\";\n\nexport const macros: MacroInfoRecord = {\n pgfkeys: {\n signature: \"m\",\n renderInfo: { breakAround: true, pgfkeysArgs: true },\n },\n tikzoption: {\n signature: \"m\",\n renderInfo: { breakAround: true, pgfkeysArgs: true },\n },\n tikzstyle: {\n signature: \"m\",\n renderInfo: { breakAround: true, pgfkeysArgs: true },\n },\n usetikzlibrary: {\n signature: \"m\",\n renderInfo: { breakAround: true, pgfkeysArgs: true },\n },\n usepgfmodule: { signature: \"m\", renderInfo: { pgfkeysArgs: true } },\n usepgflibrary: { signature: \"m\", renderInfo: { pgfkeysArgs: true } },\n pgfplotsset: {\n signature: \"m\",\n renderInfo: { breakAround: true, pgfkeysArgs: true },\n },\n pgfplotstabletypeset: {\n signature: \"o m\",\n renderInfo: { breakAround: true, pgfkeysArgs: true },\n },\n tikz: {\n signature: \"o o m\",\n argumentParser: tikzCommandArgumentParser,\n renderInfo: { namedArguments: [\"animation\", \"options\", \"command\"] },\n },\n};\n\nexport const environments: EnvInfoRecord = {\n tikzpicture: {\n signature: \"o\",\n renderInfo: { pgfkeysArgs: true, tikzEnvironment: true },\n processContent: processTikzEnvironmentContent,\n },\n axis: {\n signature: \"o\",\n renderInfo: { pgfkeysArgs: true, tikzEnvironment: true },\n processContent: processTikzEnvironmentContent,\n },\n scope: {\n signature: \"o\",\n renderInfo: { pgfkeysArgs: true, tikzEnvironment: true },\n processContent: processTikzEnvironmentContent,\n },\n pgfonlayer: {\n signature: \"m\",\n renderInfo: { tikzEnvironment: true },\n processContent: processTikzEnvironmentContent,\n },\n pgflowlevelscope: {\n signature: \"m\",\n renderInfo: { tikzEnvironment: true },\n processContent: processTikzEnvironmentContent,\n },\n pgfviewboxscope: {\n signature: \"m m m m m\",\n renderInfo: { tikzEnvironment: true },\n processContent: processTikzEnvironmentContent,\n },\n pgftransparencygroup: {\n signature: \"o\",\n renderInfo: { pgfkeysArgs: true, tikzEnvironment: true },\n processContent: processTikzEnvironmentContent,\n },\n behindforegroundpath: {\n signature: \"m\",\n processContent: processTikzEnvironmentContent,\n },\n pgfmetadecoration: {\n signature: \"m\",\n processContent: processTikzEnvironmentContent,\n },\n colormixin: { signature: \"m\", renderInfo: { pgfkeysArgs: true } },\n};\n\n/**\n * Attach macro arguments for all macros that are only available within a tikz environment.\n */\nfunction processTikzEnvironmentContent(nodes: Ast.Node[]): Ast.Node[] {\n attachMacroArgsInArray(nodes, conditionalMacros);\n return nodes;\n}\n\n/**\n * Macros that are only parsed inside a tikz environment.\n */\nexport const conditionalMacros: MacroInfoRecord = {\n pgfextra: { signature: \"m\" },\n beginpgfgraphicnamed: { signature: \"m\" },\n pgfrealjobname: { signature: \"m\" },\n pgfplotstreampoint: { signature: \"m\" },\n pgfplotstreampointoutlier: { signature: \"m\" },\n pgfplotstreamspecial: { signature: \"m\" },\n pgfplotxyfile: { signature: \"m\" },\n pgfplotxyzfile: { signature: \"m\" },\n pgfplotfunction: { signature: \"mmm\" },\n pgfplotgnuplot: { signature: \"o m\" },\n pgfplothandlerrecord: { signature: \"m\" },\n pgfdeclareplothandler: { signature: \"m m m\" },\n pgfdeclarelayer: { signature: \"m\" },\n pgfsetlayers: { signature: \"m\", renderInfo: { pgfkeysArgs: true } },\n pgfonlayer: { signature: \"m\" },\n startpgfonlayer: { signature: \"m\" },\n pgfdeclarehorizontalshading: { signature: \"o m m m \" },\n pgfdeclareradialshading: { signature: \"o m m m\" },\n pgfdeclarefunctionalshading: { signature: \"o m m m m m\" },\n pgfshadecolortorgb: { signature: \"m m\" },\n pgfshadecolortocmyk: { signature: \"m m\" },\n pgfshadecolortogray: { signature: \"m m\" },\n pgfuseshading: { signature: \"m\" },\n pgfshadepath: { signature: \"m m\" },\n pgfsetadditionalshadetransform: { signature: \"m\" },\n pgfsetstrokeopacity: { signature: \"m\" },\n pgfsetfillopacity: { signature: \"m\" },\n pgfsetblendmode: { signature: \"m\" },\n pgfdeclarefading: { signature: \"m m\" },\n pgfsetfading: { signature: \"m m\" },\n pgfsetfadingforcurrentpath: { signature: \"m m\" },\n pgfsetfadingforcurrentpathstroked: { signature: \"m m\" },\n pgfanimateattribute: { signature: \"m m\" },\n pgfsnapshot: { signature: \"m\" },\n pgfqpoint: { signature: \"m m\" },\n pgfqpointxy: { signature: \"m m\" },\n pgfqpointxyz: { signature: \"m m m\" },\n pgfqpointscale: { signature: \"m m\" },\n pgfpathqmoveto: { signature: \"m m\" },\n pgfpathqlineto: { signature: \"m m\" },\n pgfpathqcurveto: { signature: \"m m m m m m\" },\n pgfpathqcircle: { signature: \"m\" },\n pgfqbox: { signature: \"m\" },\n pgfqboxsynced: { signature: \"m\" },\n pgfaliasimage: { signature: \"m m\" },\n pgfuseimage: { signature: \"m\" },\n pgfimage: { signature: \"o m\", renderInfo: { pgfkeysArgs: true } },\n pgfdeclaremask: { signature: \"o m m\", renderInfo: { pgfkeysArgs: true } },\n pgfdeclarepatternformonly: { signature: \"o m m m m m\" },\n pgfdeclarepatterninherentlycolored: { signature: \"o m m m m m\" },\n pgfsetfillpattern: { signature: \"m m\" },\n // Coordinate canvas and nonlinear transformations\n pgftransformshift: { signature: \"m\" },\n pgftransformxshift: { signature: \"m\" },\n pgftransformyshift: { signature: \"m\" },\n pgftransformscale: { signature: \"m\" },\n pgftransformxscale: { signature: \"m\" },\n pgftransformyscale: { signature: \"m\" },\n pgftransformxslant: { signature: \"m\" },\n pgftransformyslant: { signature: \"m\" },\n pgftransformrotate: { signature: \"m\" },\n pgftransformtriangle: { signature: \"m m m\" },\n pgftransformcm: { signature: \"m m m m m\" },\n pgftransformarrow: { signature: \"m m\" },\n pgftransformlineattime: { signature: \"m m m\" },\n pgftransformcurveattime: { signature: \"m m m m m\" },\n pgftransformarcaxesattime: { signature: \"m m m m m m\" },\n pgfgettransform: { signature: \"m\" },\n pgfsettransform: { signature: \"m\" },\n pgfgettransformentries: { signature: \"m m m m m m\" },\n pgfsettransformentries: { signature: \"m m m m m m\" },\n pgfpointtransformed: { signature: \"m\" },\n pgflowlevel: { signature: \"m\" },\n pgflowlevelobj: { signature: \"m m\" },\n pgflowlevelscope: { signature: \"m\" },\n startpgflowlevelscope: { signature: \"m\" },\n pgfviewboxscope: { signature: \"m m m m m\" },\n startpgfviewboxscope: { signature: \"m m m m m\" },\n pgftransformnonlinear: { signature: \"m\" },\n pgfpointtransformednonlinear: { signature: \"m\" },\n pgfsetcurvilinearbeziercurve: { signature: \"m m m m\" },\n pgfcurvilineardistancetotime: { signature: \"m\" },\n pgfpointcurvilinearbezierorthogonal: { signature: \"m m\" },\n pgfpointcurvilinearbezierpolar: { signature: \"m m\" },\n // Matrices\n pgfmatrix: { signature: \"m m m m m m m\" },\n pgfsetmatrixcolumnsep: { signature: \"m\" },\n pgfmatrixnextcell: { signature: \"o\" },\n pgfsetmatrixrowsep: { signature: \"m\" },\n pgfmatrixendrow: { signature: \"o\" },\n // Nodes and shapes\n pgfnode: { signature: \"m m m m m\" },\n pgfmultipartnode: { signature: \"m m m m\" },\n pgfcoordinate: { signature: \"m m\" },\n pgfnodealias: { signature: \"m m\" },\n pgfnoderename: { signature: \"m m\" },\n pgfpositionnodelater: { signature: \"m\" },\n pgfpositionnodenow: { signature: \"m\" },\n pgfnodepostsetupcode: { signature: \"m m\" },\n pgfpointanchor: { signature: \"m m\" },\n pgfpointshapeborder: { signature: \"m m\" },\n pgfdeclareshape: { signature: \"m m\" },\n saveddimen: { signature: \"m m\" },\n savedmacro: { signature: \" m\" },\n anchor: { signature: \"m m\" },\n deferredanchor: { signature: \"m m\" },\n anchorborder: { signature: \"m\" },\n backgroundpath: { signature: \"m\" },\n foregroundpath: { signature: \"m\" },\n behindbackgroundpath: { signature: \"m\" },\n beforebackgroundpath: { signature: \"m\" },\n beforeforegroundpath: { signature: \"m\" },\n behindforegroundpath: { signature: \"m\" },\n // Arrows\n pgfdeclarearrow: { signature: \"m\" },\n pgfarrowssettipend: { signature: \"m\" },\n pgfarrowssetbackend: { signature: \"m\" },\n pgfarrowssetlineend: { signature: \"m\" },\n pgfarrowssetvisualbackend: { signature: \"m\" },\n pgfarrowssetvisualtipend: { signature: \"m\" },\n pgfarrowshullpoint: { signature: \"m m\" },\n pgfarrowsupperhullpoint: { signature: \"m m\" },\n pgfarrowssave: { signature: \"m\" },\n pgfarrowssavethe: { signature: \"m\" },\n pgfarrowsaddtooptions: { signature: \"m\" },\n pgfarrowsaddtolateoptions: { signature: \"m\" },\n pgfarrowsaddtolengthscalelist: { signature: \"m\" },\n pgfarrowsaddtowidthscalelist: { signature: \"m\" },\n pgfarrowsthreeparameters: { signature: \"m\" },\n pgfarrowslinewidthdependent: { signature: \"m m m\" },\n pgfarrowslengthdependent: { signature: \"m\" },\n // Path\n pgfusepath: { signature: \"m\" },\n pgfsetlinewidth: { signature: \"m\" },\n pgfsetmiterlimit: { signature: \"m\" },\n pgfsetdash: { signature: \"m m\" },\n pgfsetstrokecolor: { signature: \"m\" },\n pgfsetcolor: { signature: \"m\" },\n pgfsetinnerlinewidth: { signature: \"m\" },\n pgfsetinnerstrokecolor: { signature: \"m\" },\n pgfsetarrowsstart: { signature: \"m\" },\n pgfsetarrowsend: { signature: \"m\" },\n pgfsetarrows: { signature: \"m\" },\n pgfsetshortenstart: { signature: \"m\" },\n pgfsetshortenend: { signature: \"m\" },\n pgfsetfillcolor: { signature: \"m\" },\n // Decorations\n pgfdeclaredecoration: { signature: \"m m m\" },\n state: { signature: \"m o m\" },\n pgfdecoratepath: { signature: \"m m\" },\n startpgfdecoration: { signature: \"m\" },\n pgfdecoration: { signature: \"m\" },\n pgfdecoratecurrentpath: { signature: \"m\" },\n pgfsetdecorationsegmenttransformation: { signature: \"m\" },\n pgfdeclaremetadecorate: { signature: \"m m m\" },\n pgfmetadecoration: { signature: \"m\" },\n startpgfmetadecoration: { signature: \"m\" },\n // Constructing paths\n pgfpathmoveto: { signature: \"m\" },\n pgfpathlineto: { signature: \"m\" },\n pgfpathcurveto: { signature: \"m m m\" },\n pgfpathquadraticcurveto: { signature: \"m m\" },\n pgfpathcurvebetweentime: { signature: \"m m m m m m\" },\n pgfpathcurvebetweentimecontinue: { signature: \"m m m m m m\" },\n pgfpatharc: { signature: \"m m m\" },\n pgfpatharcaxes: { signature: \"m m m m\" },\n pgfpatharcto: { signature: \"m m m m m m\" },\n pgfpatharctoprecomputed: { signature: \"m m m m m m m m\" },\n pgfpathellipse: { signature: \"m m m\" },\n pgfpathcircle: { signature: \"m m\" },\n pgfpathrectangle: { signature: \"m m\" },\n pgfpathrectanglecorners: { signature: \"m m\" },\n pgfpathgrid: { signature: \" o m m\" },\n pgfpathparabola: { signature: \"m m\" },\n pgfpathsine: { signature: \"m\" },\n pgfpathcosine: { signature: \"m\" },\n pgfsetcornersarced: { signature: \"m\" },\n \"pgf@protocolsizes\": { signature: \"m m\" },\n // Specifying coordinates\n pgfpoint: { signature: \"m m\" },\n pgfpointpolar: { signature: \"m m m\" },\n pgfpointxy: { signature: \"m m\" },\n pgfsetxvec: { signature: \"m\" },\n pgfsetyvec: { signature: \"m\" },\n pgfpointpolarxy: { signature: \"m m\" },\n pgfpointxyz: { signature: \"m m m\" },\n pgfsetzvec: { signature: \"m\" },\n pgfpointcylindrical: { signature: \"m m m\" },\n pgfpointspherical: { signature: \"m m m\" },\n pgfpointadd: { signature: \"m m\" },\n pgfpointscale: { signature: \"m m\" },\n pgfpointdiff: { signature: \"m m\" },\n pgfpointnormalised: { signature: \"m\" },\n pgfpointlineattime: { signature: \"m m m\" },\n pgfpointlineatdistance: { signature: \"m m m\" },\n pgfpointarcaxesattime: { signature: \"m m m m m m\" },\n pgfpointcurveattime: { signature: \"m m m m m\" },\n pgfpointborderrectangle: { signature: \"m m\" },\n pgfpointborderellipse: { signature: \"m m\" },\n pgfpointintersectionoflines: { signature: \"m m m m\" },\n pgfpointintersectionofcircles: { signature: \"m m m m m\" },\n pgfintersectionofpaths: { signature: \"m m\" },\n pgfpointintersectionsolution: { signature: \"m\" },\n pgfextractx: { signature: \"m m\" },\n pgfextracty: { signature: \"m m\" },\n pgfgetlastxy: { signature: \"m m\" },\n \"pgf@process\": { signature: \"m\" },\n // Heirarchical structres ...\n pgfsetbaseline: { signature: \"m\" },\n pgfsetbaselinepointnow: { signature: \"m\" },\n pgfsetbaselinepointlater: { signature: \"m\" },\n pgftext: { signature: \"o m\", renderInfo: { pgfkeysArgs: true } },\n pgfuseid: { signature: \"m\" },\n pgfusetype: { signature: \"m\" },\n pgfidrefnextuse: { signature: \"m m\" },\n pgfidrefprevuse: { signature: \"m m\" },\n pgfaliasid: { signature: \"m m\" },\n pgfgaliasid: { signature: \"m m\" },\n pgfifidreferenced: { signature: \"m m m\" },\n pgfrdfabout: { signature: \"m\" },\n pgfrdfcontent: { signature: \"m\" },\n pgfrdfdatatype: { signature: \"m\" },\n pgfrdfhref: { signature: \"m\" },\n pgfrdfprefix: { signature: \"m\" },\n pgfrdfproperty: { signature: \"m\" },\n pgfrdfrel: { signature: \"m\" },\n pgfrdfresource: { signature: \"m\" },\n pgfrdfrev: { signature: \"m\" },\n pgfrdfsrc: { signature: \"m\" },\n pgfrdftypeof: { signature: \"m\" },\n pgfrdfvocab: { signature: \"m\" },\n pgferror: { signature: \"m\" },\n pgfwarning: { signature: \"m\" },\n path: {\n signature: \"u;\",\n renderInfo: { breakAround: true, tikzPathCommand: true },\n },\n draw: {\n signature: \"u;\",\n renderInfo: { breakAround: true, tikzPathCommand: true },\n },\n fill: {\n signature: \"u;\",\n renderInfo: { breakAround: true, tikzPathCommand: true },\n },\n filldraw: {\n signature: \"u;\",\n renderInfo: { breakAround: true, tikzPathCommand: true },\n },\n pattern: {\n signature: \"u;\",\n renderInfo: { breakAround: true, tikzPathCommand: true },\n },\n shade: {\n signature: \"u;\",\n renderInfo: { breakAround: true, tikzPathCommand: true },\n },\n clip: {\n signature: \"u;\",\n renderInfo: { breakAround: true, tikzPathCommand: true },\n },\n useasboundingbox: {\n signature: \"u;\",\n renderInfo: { breakAround: true, tikzPathCommand: true },\n },\n node: {\n signature: \"u;\",\n renderInfo: { breakAround: true, tikzPathCommand: true },\n },\n coordinate: {\n signature: \"u;\",\n renderInfo: { breakAround: true, tikzPathCommand: true },\n },\n graph: {\n signature: \"u;\",\n renderInfo: { breakAround: true, tikzPathCommand: true },\n },\n scoped: {\n signature: \"o o m\",\n argumentParser: tikzCommandArgumentParser,\n renderInfo: {\n namedArguments: [\"animation\", \"options\", \"command\"],\n breakAround: true,\n },\n },\n};\n","import * as Ast from \"@unified-latex/unified-latex-types\";\nimport * as TikzSpec from \"./types\";\nimport { match } from \"@unified-latex/unified-latex-util-match\";\nimport { decorateArrayForPegjs } from \"@unified-latex/unified-latex-util-pegjs\";\nimport { TikzPegParser } from \"@unified-latex/unified-latex-util-pegjs\";\n\ntype TikzParseOptions = {\n startRule?: \"path_spec\" | \"foreach_body\";\n};\n\nfunction createMatchers() {\n return {\n isChar: match.string,\n isTerminal: (node: any) => match.string(node, \";\"),\n isOperation: (node: any) =>\n match.anyString(node) && node.content.match(/[a-zA-Z]/),\n isWhitespace: (node: any) =>\n match.whitespace(node) || match.parbreak(node),\n isComment: match.comment,\n isGroup: match.group,\n isMacro: match.macro,\n isAnyMacro: match.anyMacro,\n };\n}\n\nconst matchers = createMatchers();\n\n/**\n * Parse the contents of the `\\systeme{...}` macro\n */\nexport function parse(\n ast: Ast.Node[],\n options?: Options\n): Options extends { startRule: infer R }\n ? R extends \"path_spec\"\n ? TikzSpec.PathSpec\n : TikzSpec.ForeachBody\n : TikzSpec.PathSpec {\n const { startRule = \"path_spec\" } = options || {};\n if (!Array.isArray(ast)) {\n throw new Error(\"You must pass an array of nodes\");\n }\n // We need to at functions to `nodes` so that it imitates\n // a Javascript string. Because we're mutating, make a copy first\n ast = decorateArrayForPegjs([...ast]);\n // matchers are passed in via the second argument (the `options` argument)\n // so they are available from within the Pegjs grammar.\n return TikzPegParser.parse(ast, {\n ...matchers,\n startRule,\n });\n}\n"],"names":["parseArgspec","arg","trim","gobbleSingleArgument","match","scan","colonPos","attachMacroArgsInArray","decorateArrayForPegjs","TikzPegParser"],"mappings":"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"} \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-ctan/parser-BBXMi7mQ.js b/node_modules/@unified-latex/unified-latex-ctan/parser-BBXMi7mQ.js new file mode 100644 index 0000000..e5d6dd4 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-ctan/parser-BBXMi7mQ.js @@ -0,0 +1,504 @@ +import { gobbleSingleArgument, attachMacroArgsInArray } from "@unified-latex/unified-latex-util-arguments"; +import { arg } from "@unified-latex/unified-latex-builder"; +import { parse as parse$1 } from "@unified-latex/unified-latex-util-argspec"; +import { match } from "@unified-latex/unified-latex-util-match"; +import { scan } from "@unified-latex/unified-latex-util-scan"; +import { trim } from "@unified-latex/unified-latex-util-trim"; +import { decorateArrayForPegjs, TikzPegParser } from "@unified-latex/unified-latex-util-pegjs"; +const OPTIONAL_ARGUMENT_ARG_SPEC = parse$1("o")[0]; +function blankArg() { + return arg([], { openMark: "", closeMark: "" }); +} +const tikzCommandArgumentParser = (nodes, startPos) => { + const origStartPos = startPos; + let pos = startPos; + let nodesRemoved = 0; + const cursorPosAfterAnimations = eatAllAnimationSpecs(nodes, pos); + let animationArg = blankArg(); + if (cursorPosAfterAnimations !== pos) { + const argContent = nodes.splice(pos, cursorPosAfterAnimations - pos); + trim(argContent); + animationArg = arg(argContent, { + openMark: " ", + closeMark: " " + }); + } + nodesRemoved += cursorPosAfterAnimations - pos; + const { + argument: _optionalArgument, + nodesRemoved: optionalArgumentNodesRemoved + } = gobbleSingleArgument(nodes, OPTIONAL_ARGUMENT_ARG_SPEC, pos); + nodesRemoved += optionalArgumentNodesRemoved; + const optionalArg = _optionalArgument || blankArg(); + while (match.whitespace(nodes[pos])) { + pos++; + } + const firstNode = nodes[pos]; + if (!firstNode) { + return { + args: [animationArg, optionalArg, blankArg()], + nodesRemoved: 0 + }; + } + if (match.group(firstNode)) { + const args = [animationArg, optionalArg, arg(firstNode.content)]; + nodes.splice(origStartPos, pos - origStartPos + 1); + return { args, nodesRemoved: pos - origStartPos + 1 + nodesRemoved }; + } + const semicolonPosition = scan(nodes, ";", { startIndex: pos }); + if (semicolonPosition != null) { + const argNodes = nodes.splice( + origStartPos, + semicolonPosition - origStartPos + 1 + ); + trim(argNodes); + const args = [animationArg, optionalArg, arg(argNodes)]; + return { + args, + nodesRemoved: origStartPos - semicolonPosition + 1 + nodesRemoved + }; + } + return { + args: [animationArg, optionalArg, blankArg()], + nodesRemoved: 0 + }; +}; +function eatAllAnimationSpecs(nodes, startPos) { + const colonPos = scan(nodes, ":", { + startIndex: startPos, + allowSubstringMatches: true, + onlySkipWhitespaceAndComments: true + }); + if (!colonPos) { + return startPos; + } + let lastMatchPos = startPos; + let i = colonPos + 1; + for (; i < nodes.length; i++) { + const node = nodes[i]; + if (match.string(node, "[")) { + break; + } + if (match.string(node, "=")) { + i++; + while (match.whitespace(nodes[i]) || match.comment(nodes[i])) { + i++; + } + if (!match.group(nodes[i])) { + break; + } + lastMatchPos = i + 1; + const colonPos2 = scan(nodes, ":", { + startIndex: lastMatchPos, + allowSubstringMatches: true, + onlySkipWhitespaceAndComments: true + }); + if (colonPos2 == null) { + break; + } + i = colonPos2 + 1; + } + } + return lastMatchPos; +} +const macros = { + pgfkeys: { + signature: "m", + renderInfo: { breakAround: true, pgfkeysArgs: true } + }, + tikzoption: { + signature: "m", + renderInfo: { breakAround: true, pgfkeysArgs: true } + }, + tikzstyle: { + signature: "m", + renderInfo: { breakAround: true, pgfkeysArgs: true } + }, + usetikzlibrary: { + signature: "m", + renderInfo: { breakAround: true, pgfkeysArgs: true } + }, + usepgfmodule: { signature: "m", renderInfo: { pgfkeysArgs: true } }, + usepgflibrary: { signature: "m", renderInfo: { pgfkeysArgs: true } }, + pgfplotsset: { + signature: "m", + renderInfo: { breakAround: true, pgfkeysArgs: true } + }, + pgfplotstabletypeset: { + signature: "o m", + renderInfo: { breakAround: true, pgfkeysArgs: true } + }, + tikz: { + signature: "o o m", + argumentParser: tikzCommandArgumentParser, + renderInfo: { namedArguments: ["animation", "options", "command"] } + } +}; +const environments = { + tikzpicture: { + signature: "o", + renderInfo: { pgfkeysArgs: true, tikzEnvironment: true }, + processContent: processTikzEnvironmentContent + }, + axis: { + signature: "o", + renderInfo: { pgfkeysArgs: true, tikzEnvironment: true }, + processContent: processTikzEnvironmentContent + }, + scope: { + signature: "o", + renderInfo: { pgfkeysArgs: true, tikzEnvironment: true }, + processContent: processTikzEnvironmentContent + }, + pgfonlayer: { + signature: "m", + renderInfo: { tikzEnvironment: true }, + processContent: processTikzEnvironmentContent + }, + pgflowlevelscope: { + signature: "m", + renderInfo: { tikzEnvironment: true }, + processContent: processTikzEnvironmentContent + }, + pgfviewboxscope: { + signature: "m m m m m", + renderInfo: { tikzEnvironment: true }, + processContent: processTikzEnvironmentContent + }, + pgftransparencygroup: { + signature: "o", + renderInfo: { pgfkeysArgs: true, tikzEnvironment: true }, + processContent: processTikzEnvironmentContent + }, + behindforegroundpath: { + signature: "m", + processContent: processTikzEnvironmentContent + }, + pgfmetadecoration: { + signature: "m", + processContent: processTikzEnvironmentContent + }, + colormixin: { signature: "m", renderInfo: { pgfkeysArgs: true } } +}; +function processTikzEnvironmentContent(nodes) { + attachMacroArgsInArray(nodes, conditionalMacros); + return nodes; +} +const conditionalMacros = { + pgfextra: { signature: "m" }, + beginpgfgraphicnamed: { signature: "m" }, + pgfrealjobname: { signature: "m" }, + pgfplotstreampoint: { signature: "m" }, + pgfplotstreampointoutlier: { signature: "m" }, + pgfplotstreamspecial: { signature: "m" }, + pgfplotxyfile: { signature: "m" }, + pgfplotxyzfile: { signature: "m" }, + pgfplotfunction: { signature: "mmm" }, + pgfplotgnuplot: { signature: "o m" }, + pgfplothandlerrecord: { signature: "m" }, + pgfdeclareplothandler: { signature: "m m m" }, + pgfdeclarelayer: { signature: "m" }, + pgfsetlayers: { signature: "m", renderInfo: { pgfkeysArgs: true } }, + pgfonlayer: { signature: "m" }, + startpgfonlayer: { signature: "m" }, + pgfdeclarehorizontalshading: { signature: "o m m m " }, + pgfdeclareradialshading: { signature: "o m m m" }, + pgfdeclarefunctionalshading: { signature: "o m m m m m" }, + pgfshadecolortorgb: { signature: "m m" }, + pgfshadecolortocmyk: { signature: "m m" }, + pgfshadecolortogray: { signature: "m m" }, + pgfuseshading: { signature: "m" }, + pgfshadepath: { signature: "m m" }, + pgfsetadditionalshadetransform: { signature: "m" }, + pgfsetstrokeopacity: { signature: "m" }, + pgfsetfillopacity: { signature: "m" }, + pgfsetblendmode: { signature: "m" }, + pgfdeclarefading: { signature: "m m" }, + pgfsetfading: { signature: "m m" }, + pgfsetfadingforcurrentpath: { signature: "m m" }, + pgfsetfadingforcurrentpathstroked: { signature: "m m" }, + pgfanimateattribute: { signature: "m m" }, + pgfsnapshot: { signature: "m" }, + pgfqpoint: { signature: "m m" }, + pgfqpointxy: { signature: "m m" }, + pgfqpointxyz: { signature: "m m m" }, + pgfqpointscale: { signature: "m m" }, + pgfpathqmoveto: { signature: "m m" }, + pgfpathqlineto: { signature: "m m" }, + pgfpathqcurveto: { signature: "m m m m m m" }, + pgfpathqcircle: { signature: "m" }, + pgfqbox: { signature: "m" }, + pgfqboxsynced: { signature: "m" }, + pgfaliasimage: { signature: "m m" }, + pgfuseimage: { signature: "m" }, + pgfimage: { signature: "o m", renderInfo: { pgfkeysArgs: true } }, + pgfdeclaremask: { signature: "o m m", renderInfo: { pgfkeysArgs: true } }, + pgfdeclarepatternformonly: { signature: "o m m m m m" }, + pgfdeclarepatterninherentlycolored: { signature: "o m m m m m" }, + pgfsetfillpattern: { signature: "m m" }, + // Coordinate canvas and nonlinear transformations + pgftransformshift: { signature: "m" }, + pgftransformxshift: { signature: "m" }, + pgftransformyshift: { signature: "m" }, + pgftransformscale: { signature: "m" }, + pgftransformxscale: { signature: "m" }, + pgftransformyscale: { signature: "m" }, + pgftransformxslant: { signature: "m" }, + pgftransformyslant: { signature: "m" }, + pgftransformrotate: { signature: "m" }, + pgftransformtriangle: { signature: "m m m" }, + pgftransformcm: { signature: "m m m m m" }, + pgftransformarrow: { signature: "m m" }, + pgftransformlineattime: { signature: "m m m" }, + pgftransformcurveattime: { signature: "m m m m m" }, + pgftransformarcaxesattime: { signature: "m m m m m m" }, + pgfgettransform: { signature: "m" }, + pgfsettransform: { signature: "m" }, + pgfgettransformentries: { signature: "m m m m m m" }, + pgfsettransformentries: { signature: "m m m m m m" }, + pgfpointtransformed: { signature: "m" }, + pgflowlevel: { signature: "m" }, + pgflowlevelobj: { signature: "m m" }, + pgflowlevelscope: { signature: "m" }, + startpgflowlevelscope: { signature: "m" }, + pgfviewboxscope: { signature: "m m m m m" }, + startpgfviewboxscope: { signature: "m m m m m" }, + pgftransformnonlinear: { signature: "m" }, + pgfpointtransformednonlinear: { signature: "m" }, + pgfsetcurvilinearbeziercurve: { signature: "m m m m" }, + pgfcurvilineardistancetotime: { signature: "m" }, + pgfpointcurvilinearbezierorthogonal: { signature: "m m" }, + pgfpointcurvilinearbezierpolar: { signature: "m m" }, + // Matrices + pgfmatrix: { signature: "m m m m m m m" }, + pgfsetmatrixcolumnsep: { signature: "m" }, + pgfmatrixnextcell: { signature: "o" }, + pgfsetmatrixrowsep: { signature: "m" }, + pgfmatrixendrow: { signature: "o" }, + // Nodes and shapes + pgfnode: { signature: "m m m m m" }, + pgfmultipartnode: { signature: "m m m m" }, + pgfcoordinate: { signature: "m m" }, + pgfnodealias: { signature: "m m" }, + pgfnoderename: { signature: "m m" }, + pgfpositionnodelater: { signature: "m" }, + pgfpositionnodenow: { signature: "m" }, + pgfnodepostsetupcode: { signature: "m m" }, + pgfpointanchor: { signature: "m m" }, + pgfpointshapeborder: { signature: "m m" }, + pgfdeclareshape: { signature: "m m" }, + saveddimen: { signature: "m m" }, + savedmacro: { signature: " m" }, + anchor: { signature: "m m" }, + deferredanchor: { signature: "m m" }, + anchorborder: { signature: "m" }, + backgroundpath: { signature: "m" }, + foregroundpath: { signature: "m" }, + behindbackgroundpath: { signature: "m" }, + beforebackgroundpath: { signature: "m" }, + beforeforegroundpath: { signature: "m" }, + behindforegroundpath: { signature: "m" }, + // Arrows + pgfdeclarearrow: { signature: "m" }, + pgfarrowssettipend: { signature: "m" }, + pgfarrowssetbackend: { signature: "m" }, + pgfarrowssetlineend: { signature: "m" }, + pgfarrowssetvisualbackend: { signature: "m" }, + pgfarrowssetvisualtipend: { signature: "m" }, + pgfarrowshullpoint: { signature: "m m" }, + pgfarrowsupperhullpoint: { signature: "m m" }, + pgfarrowssave: { signature: "m" }, + pgfarrowssavethe: { signature: "m" }, + pgfarrowsaddtooptions: { signature: "m" }, + pgfarrowsaddtolateoptions: { signature: "m" }, + pgfarrowsaddtolengthscalelist: { signature: "m" }, + pgfarrowsaddtowidthscalelist: { signature: "m" }, + pgfarrowsthreeparameters: { signature: "m" }, + pgfarrowslinewidthdependent: { signature: "m m m" }, + pgfarrowslengthdependent: { signature: "m" }, + // Path + pgfusepath: { signature: "m" }, + pgfsetlinewidth: { signature: "m" }, + pgfsetmiterlimit: { signature: "m" }, + pgfsetdash: { signature: "m m" }, + pgfsetstrokecolor: { signature: "m" }, + pgfsetcolor: { signature: "m" }, + pgfsetinnerlinewidth: { signature: "m" }, + pgfsetinnerstrokecolor: { signature: "m" }, + pgfsetarrowsstart: { signature: "m" }, + pgfsetarrowsend: { signature: "m" }, + pgfsetarrows: { signature: "m" }, + pgfsetshortenstart: { signature: "m" }, + pgfsetshortenend: { signature: "m" }, + pgfsetfillcolor: { signature: "m" }, + // Decorations + pgfdeclaredecoration: { signature: "m m m" }, + state: { signature: "m o m" }, + pgfdecoratepath: { signature: "m m" }, + startpgfdecoration: { signature: "m" }, + pgfdecoration: { signature: "m" }, + pgfdecoratecurrentpath: { signature: "m" }, + pgfsetdecorationsegmenttransformation: { signature: "m" }, + pgfdeclaremetadecorate: { signature: "m m m" }, + pgfmetadecoration: { signature: "m" }, + startpgfmetadecoration: { signature: "m" }, + // Constructing paths + pgfpathmoveto: { signature: "m" }, + pgfpathlineto: { signature: "m" }, + pgfpathcurveto: { signature: "m m m" }, + pgfpathquadraticcurveto: { signature: "m m" }, + pgfpathcurvebetweentime: { signature: "m m m m m m" }, + pgfpathcurvebetweentimecontinue: { signature: "m m m m m m" }, + pgfpatharc: { signature: "m m m" }, + pgfpatharcaxes: { signature: "m m m m" }, + pgfpatharcto: { signature: "m m m m m m" }, + pgfpatharctoprecomputed: { signature: "m m m m m m m m" }, + pgfpathellipse: { signature: "m m m" }, + pgfpathcircle: { signature: "m m" }, + pgfpathrectangle: { signature: "m m" }, + pgfpathrectanglecorners: { signature: "m m" }, + pgfpathgrid: { signature: " o m m" }, + pgfpathparabola: { signature: "m m" }, + pgfpathsine: { signature: "m" }, + pgfpathcosine: { signature: "m" }, + pgfsetcornersarced: { signature: "m" }, + "pgf@protocolsizes": { signature: "m m" }, + // Specifying coordinates + pgfpoint: { signature: "m m" }, + pgfpointpolar: { signature: "m m m" }, + pgfpointxy: { signature: "m m" }, + pgfsetxvec: { signature: "m" }, + pgfsetyvec: { signature: "m" }, + pgfpointpolarxy: { signature: "m m" }, + pgfpointxyz: { signature: "m m m" }, + pgfsetzvec: { signature: "m" }, + pgfpointcylindrical: { signature: "m m m" }, + pgfpointspherical: { signature: "m m m" }, + pgfpointadd: { signature: "m m" }, + pgfpointscale: { signature: "m m" }, + pgfpointdiff: { signature: "m m" }, + pgfpointnormalised: { signature: "m" }, + pgfpointlineattime: { signature: "m m m" }, + pgfpointlineatdistance: { signature: "m m m" }, + pgfpointarcaxesattime: { signature: "m m m m m m" }, + pgfpointcurveattime: { signature: "m m m m m" }, + pgfpointborderrectangle: { signature: "m m" }, + pgfpointborderellipse: { signature: "m m" }, + pgfpointintersectionoflines: { signature: "m m m m" }, + pgfpointintersectionofcircles: { signature: "m m m m m" }, + pgfintersectionofpaths: { signature: "m m" }, + pgfpointintersectionsolution: { signature: "m" }, + pgfextractx: { signature: "m m" }, + pgfextracty: { signature: "m m" }, + pgfgetlastxy: { signature: "m m" }, + "pgf@process": { signature: "m" }, + // Heirarchical structres ... + pgfsetbaseline: { signature: "m" }, + pgfsetbaselinepointnow: { signature: "m" }, + pgfsetbaselinepointlater: { signature: "m" }, + pgftext: { signature: "o m", renderInfo: { pgfkeysArgs: true } }, + pgfuseid: { signature: "m" }, + pgfusetype: { signature: "m" }, + pgfidrefnextuse: { signature: "m m" }, + pgfidrefprevuse: { signature: "m m" }, + pgfaliasid: { signature: "m m" }, + pgfgaliasid: { signature: "m m" }, + pgfifidreferenced: { signature: "m m m" }, + pgfrdfabout: { signature: "m" }, + pgfrdfcontent: { signature: "m" }, + pgfrdfdatatype: { signature: "m" }, + pgfrdfhref: { signature: "m" }, + pgfrdfprefix: { signature: "m" }, + pgfrdfproperty: { signature: "m" }, + pgfrdfrel: { signature: "m" }, + pgfrdfresource: { signature: "m" }, + pgfrdfrev: { signature: "m" }, + pgfrdfsrc: { signature: "m" }, + pgfrdftypeof: { signature: "m" }, + pgfrdfvocab: { signature: "m" }, + pgferror: { signature: "m" }, + pgfwarning: { signature: "m" }, + path: { + signature: "u;", + renderInfo: { breakAround: true, tikzPathCommand: true } + }, + draw: { + signature: "u;", + renderInfo: { breakAround: true, tikzPathCommand: true } + }, + fill: { + signature: "u;", + renderInfo: { breakAround: true, tikzPathCommand: true } + }, + filldraw: { + signature: "u;", + renderInfo: { breakAround: true, tikzPathCommand: true } + }, + pattern: { + signature: "u;", + renderInfo: { breakAround: true, tikzPathCommand: true } + }, + shade: { + signature: "u;", + renderInfo: { breakAround: true, tikzPathCommand: true } + }, + clip: { + signature: "u;", + renderInfo: { breakAround: true, tikzPathCommand: true } + }, + useasboundingbox: { + signature: "u;", + renderInfo: { breakAround: true, tikzPathCommand: true } + }, + node: { + signature: "u;", + renderInfo: { breakAround: true, tikzPathCommand: true } + }, + coordinate: { + signature: "u;", + renderInfo: { breakAround: true, tikzPathCommand: true } + }, + graph: { + signature: "u;", + renderInfo: { breakAround: true, tikzPathCommand: true } + }, + scoped: { + signature: "o o m", + argumentParser: tikzCommandArgumentParser, + renderInfo: { + namedArguments: ["animation", "options", "command"], + breakAround: true + } + } +}; +function createMatchers() { + return { + isChar: match.string, + isTerminal: (node) => match.string(node, ";"), + isOperation: (node) => match.anyString(node) && node.content.match(/[a-zA-Z]/), + isWhitespace: (node) => match.whitespace(node) || match.parbreak(node), + isComment: match.comment, + isGroup: match.group, + isMacro: match.macro, + isAnyMacro: match.anyMacro + }; +} +const matchers = createMatchers(); +function parse(ast, options) { + const { startRule = "path_spec" } = options || {}; + if (!Array.isArray(ast)) { + throw new Error("You must pass an array of nodes"); + } + ast = decorateArrayForPegjs([...ast]); + return TikzPegParser.parse(ast, { + ...matchers, + startRule + }); +} +export { + conditionalMacros as c, + environments as e, + macros as m, + parse as p +}; +//# sourceMappingURL=parser-BBXMi7mQ.js.map diff --git a/node_modules/@unified-latex/unified-latex-ctan/parser-BBXMi7mQ.js.map b/node_modules/@unified-latex/unified-latex-ctan/parser-BBXMi7mQ.js.map new file mode 100644 index 0000000..d418a6c --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-ctan/parser-BBXMi7mQ.js.map @@ -0,0 +1 @@ +{"version":3,"file":"parser-BBXMi7mQ.js","sources":["../package/tikz/libs/tikz-command-argument-parser.ts","../package/tikz/provides.ts","../package/tikz/libs/parser.ts"],"sourcesContent":["import { arg } from \"@unified-latex/unified-latex-builder\";\nimport * as Ast from \"@unified-latex/unified-latex-types\";\nimport {\n ArgSpecAst as ArgSpec,\n parse as parseArgspec,\n} from \"@unified-latex/unified-latex-util-argspec\";\nimport { Argument, ArgumentParser } from \"@unified-latex/unified-latex-types\";\nimport { gobbleSingleArgument } from \"@unified-latex/unified-latex-util-arguments\";\nimport { match } from \"@unified-latex/unified-latex-util-match\";\nimport { scan } from \"@unified-latex/unified-latex-util-scan\";\nimport { trim } from \"@unified-latex/unified-latex-util-trim\";\nimport { printRaw } from \"@unified-latex/unified-latex-util-print-raw\";\n\nconst OPTIONAL_ARGUMENT_ARG_SPEC = parseArgspec(\"o\")[0];\n\nfunction blankArg() {\n return arg([], { openMark: \"\", closeMark: \"\" });\n}\n\n/**\n * Find the arguments of a tikz command. Many tikz commands accept either\n * the a group as their only argument, or they scan their arguments until the first\n * `;` is found.\n *\n * This behavior cannot be achieved via a standard xparse spec.\n */\nexport const tikzCommandArgumentParser: ArgumentParser = (nodes, startPos) => {\n const origStartPos = startPos;\n let pos = startPos;\n let nodesRemoved = 0;\n\n const cursorPosAfterAnimations = eatAllAnimationSpecs(nodes, pos);\n let animationArg = blankArg();\n if (cursorPosAfterAnimations !== pos) {\n const argContent = nodes.splice(pos, cursorPosAfterAnimations - pos);\n trim(argContent);\n animationArg = arg(argContent, {\n openMark: \" \",\n closeMark: \" \",\n });\n }\n nodesRemoved += cursorPosAfterAnimations - pos;\n\n const {\n argument: _optionalArgument,\n nodesRemoved: optionalArgumentNodesRemoved,\n } = gobbleSingleArgument(nodes, OPTIONAL_ARGUMENT_ARG_SPEC, pos) as {\n argument: Argument;\n nodesRemoved: number;\n };\n nodesRemoved += optionalArgumentNodesRemoved;\n const optionalArg = _optionalArgument || blankArg();\n\n // Eat whitespace\n while (match.whitespace(nodes[pos])) {\n pos++;\n }\n const firstNode = nodes[pos];\n\n // If we're past the end of the array, give up.\n if (!firstNode) {\n return {\n args: [animationArg, optionalArg, blankArg()],\n nodesRemoved: 0,\n };\n }\n\n // If we're a group, grab the contents and call it good.\n if (match.group(firstNode)) {\n const args = [animationArg, optionalArg, arg(firstNode.content)];\n nodes.splice(origStartPos, pos - origStartPos + 1);\n return { args, nodesRemoved: pos - origStartPos + 1 + nodesRemoved };\n }\n\n // No group, so scan for a semicolon.\n const semicolonPosition = scan(nodes, \";\", { startIndex: pos });\n if (semicolonPosition != null) {\n const argNodes = nodes.splice(\n origStartPos,\n semicolonPosition - origStartPos + 1\n );\n trim(argNodes);\n const args = [animationArg, optionalArg, arg(argNodes)];\n return {\n args,\n nodesRemoved: origStartPos - semicolonPosition + 1 + nodesRemoved,\n };\n }\n\n // If there was no semicolon, give up.\n return {\n args: [animationArg, optionalArg, blankArg()],\n nodesRemoved: 0,\n };\n};\n\n/**\n * Find the next index after all animation specs. If no animation specs are present,\n * return `startPos`.\n *\n * An animation spec looks like\n * ```\n * :rotate = { 0s=\"0\", 2s=\"90\", begin on=click }\n * ```\n * Any number can be listed. They start with a colon and have an equals sign followed by a group.\n */\nfunction eatAllAnimationSpecs(nodes: Ast.Node[], startPos: number): number {\n const colonPos = scan(nodes, \":\", {\n startIndex: startPos,\n allowSubstringMatches: true,\n onlySkipWhitespaceAndComments: true,\n });\n\n if (!colonPos) {\n return startPos;\n }\n\n let lastMatchPos = startPos;\n let i = colonPos + 1;\n for (; i < nodes.length; i++) {\n const node = nodes[i];\n if (match.string(node, \"[\")) {\n // XXX As per the tikz manual, we stop scanning if we find an open square brace.\n break;\n }\n if (match.string(node, \"=\")) {\n i++;\n // Look for a group next\n while (match.whitespace(nodes[i]) || match.comment(nodes[i])) {\n i++;\n }\n if (!match.group(nodes[i])) {\n break;\n }\n // We have a match!\n lastMatchPos = i + 1;\n\n // Start the process again\n const colonPos = scan(nodes, \":\", {\n startIndex: lastMatchPos,\n allowSubstringMatches: true,\n onlySkipWhitespaceAndComments: true,\n });\n if (colonPos == null) {\n break;\n }\n i = colonPos + 1;\n }\n }\n\n return lastMatchPos;\n}\n","import {\n MacroInfoRecord,\n EnvInfoRecord,\n} from \"@unified-latex/unified-latex-types\";\nimport * as Ast from \"@unified-latex/unified-latex-types\";\nimport { attachMacroArgsInArray } from \"@unified-latex/unified-latex-util-arguments\";\nimport { tikzCommandArgumentParser } from \"./libs/tikz-command-argument-parser\";\n\nexport const macros: MacroInfoRecord = {\n pgfkeys: {\n signature: \"m\",\n renderInfo: { breakAround: true, pgfkeysArgs: true },\n },\n tikzoption: {\n signature: \"m\",\n renderInfo: { breakAround: true, pgfkeysArgs: true },\n },\n tikzstyle: {\n signature: \"m\",\n renderInfo: { breakAround: true, pgfkeysArgs: true },\n },\n usetikzlibrary: {\n signature: \"m\",\n renderInfo: { breakAround: true, pgfkeysArgs: true },\n },\n usepgfmodule: { signature: \"m\", renderInfo: { pgfkeysArgs: true } },\n usepgflibrary: { signature: \"m\", renderInfo: { pgfkeysArgs: true } },\n pgfplotsset: {\n signature: \"m\",\n renderInfo: { breakAround: true, pgfkeysArgs: true },\n },\n pgfplotstabletypeset: {\n signature: \"o m\",\n renderInfo: { breakAround: true, pgfkeysArgs: true },\n },\n tikz: {\n signature: \"o o m\",\n argumentParser: tikzCommandArgumentParser,\n renderInfo: { namedArguments: [\"animation\", \"options\", \"command\"] },\n },\n};\n\nexport const environments: EnvInfoRecord = {\n tikzpicture: {\n signature: \"o\",\n renderInfo: { pgfkeysArgs: true, tikzEnvironment: true },\n processContent: processTikzEnvironmentContent,\n },\n axis: {\n signature: \"o\",\n renderInfo: { pgfkeysArgs: true, tikzEnvironment: true },\n processContent: processTikzEnvironmentContent,\n },\n scope: {\n signature: \"o\",\n renderInfo: { pgfkeysArgs: true, tikzEnvironment: true },\n processContent: processTikzEnvironmentContent,\n },\n pgfonlayer: {\n signature: \"m\",\n renderInfo: { tikzEnvironment: true },\n processContent: processTikzEnvironmentContent,\n },\n pgflowlevelscope: {\n signature: \"m\",\n renderInfo: { tikzEnvironment: true },\n processContent: processTikzEnvironmentContent,\n },\n pgfviewboxscope: {\n signature: \"m m m m m\",\n renderInfo: { tikzEnvironment: true },\n processContent: processTikzEnvironmentContent,\n },\n pgftransparencygroup: {\n signature: \"o\",\n renderInfo: { pgfkeysArgs: true, tikzEnvironment: true },\n processContent: processTikzEnvironmentContent,\n },\n behindforegroundpath: {\n signature: \"m\",\n processContent: processTikzEnvironmentContent,\n },\n pgfmetadecoration: {\n signature: \"m\",\n processContent: processTikzEnvironmentContent,\n },\n colormixin: { signature: \"m\", renderInfo: { pgfkeysArgs: true } },\n};\n\n/**\n * Attach macro arguments for all macros that are only available within a tikz environment.\n */\nfunction processTikzEnvironmentContent(nodes: Ast.Node[]): Ast.Node[] {\n attachMacroArgsInArray(nodes, conditionalMacros);\n return nodes;\n}\n\n/**\n * Macros that are only parsed inside a tikz environment.\n */\nexport const conditionalMacros: MacroInfoRecord = {\n pgfextra: { signature: \"m\" },\n beginpgfgraphicnamed: { signature: \"m\" },\n pgfrealjobname: { signature: \"m\" },\n pgfplotstreampoint: { signature: \"m\" },\n pgfplotstreampointoutlier: { signature: \"m\" },\n pgfplotstreamspecial: { signature: \"m\" },\n pgfplotxyfile: { signature: \"m\" },\n pgfplotxyzfile: { signature: \"m\" },\n pgfplotfunction: { signature: \"mmm\" },\n pgfplotgnuplot: { signature: \"o m\" },\n pgfplothandlerrecord: { signature: \"m\" },\n pgfdeclareplothandler: { signature: \"m m m\" },\n pgfdeclarelayer: { signature: \"m\" },\n pgfsetlayers: { signature: \"m\", renderInfo: { pgfkeysArgs: true } },\n pgfonlayer: { signature: \"m\" },\n startpgfonlayer: { signature: \"m\" },\n pgfdeclarehorizontalshading: { signature: \"o m m m \" },\n pgfdeclareradialshading: { signature: \"o m m m\" },\n pgfdeclarefunctionalshading: { signature: \"o m m m m m\" },\n pgfshadecolortorgb: { signature: \"m m\" },\n pgfshadecolortocmyk: { signature: \"m m\" },\n pgfshadecolortogray: { signature: \"m m\" },\n pgfuseshading: { signature: \"m\" },\n pgfshadepath: { signature: \"m m\" },\n pgfsetadditionalshadetransform: { signature: \"m\" },\n pgfsetstrokeopacity: { signature: \"m\" },\n pgfsetfillopacity: { signature: \"m\" },\n pgfsetblendmode: { signature: \"m\" },\n pgfdeclarefading: { signature: \"m m\" },\n pgfsetfading: { signature: \"m m\" },\n pgfsetfadingforcurrentpath: { signature: \"m m\" },\n pgfsetfadingforcurrentpathstroked: { signature: \"m m\" },\n pgfanimateattribute: { signature: \"m m\" },\n pgfsnapshot: { signature: \"m\" },\n pgfqpoint: { signature: \"m m\" },\n pgfqpointxy: { signature: \"m m\" },\n pgfqpointxyz: { signature: \"m m m\" },\n pgfqpointscale: { signature: \"m m\" },\n pgfpathqmoveto: { signature: \"m m\" },\n pgfpathqlineto: { signature: \"m m\" },\n pgfpathqcurveto: { signature: \"m m m m m m\" },\n pgfpathqcircle: { signature: \"m\" },\n pgfqbox: { signature: \"m\" },\n pgfqboxsynced: { signature: \"m\" },\n pgfaliasimage: { signature: \"m m\" },\n pgfuseimage: { signature: \"m\" },\n pgfimage: { signature: \"o m\", renderInfo: { pgfkeysArgs: true } },\n pgfdeclaremask: { signature: \"o m m\", renderInfo: { pgfkeysArgs: true } },\n pgfdeclarepatternformonly: { signature: \"o m m m m m\" },\n pgfdeclarepatterninherentlycolored: { signature: \"o m m m m m\" },\n pgfsetfillpattern: { signature: \"m m\" },\n // Coordinate canvas and nonlinear transformations\n pgftransformshift: { signature: \"m\" },\n pgftransformxshift: { signature: \"m\" },\n pgftransformyshift: { signature: \"m\" },\n pgftransformscale: { signature: \"m\" },\n pgftransformxscale: { signature: \"m\" },\n pgftransformyscale: { signature: \"m\" },\n pgftransformxslant: { signature: \"m\" },\n pgftransformyslant: { signature: \"m\" },\n pgftransformrotate: { signature: \"m\" },\n pgftransformtriangle: { signature: \"m m m\" },\n pgftransformcm: { signature: \"m m m m m\" },\n pgftransformarrow: { signature: \"m m\" },\n pgftransformlineattime: { signature: \"m m m\" },\n pgftransformcurveattime: { signature: \"m m m m m\" },\n pgftransformarcaxesattime: { signature: \"m m m m m m\" },\n pgfgettransform: { signature: \"m\" },\n pgfsettransform: { signature: \"m\" },\n pgfgettransformentries: { signature: \"m m m m m m\" },\n pgfsettransformentries: { signature: \"m m m m m m\" },\n pgfpointtransformed: { signature: \"m\" },\n pgflowlevel: { signature: \"m\" },\n pgflowlevelobj: { signature: \"m m\" },\n pgflowlevelscope: { signature: \"m\" },\n startpgflowlevelscope: { signature: \"m\" },\n pgfviewboxscope: { signature: \"m m m m m\" },\n startpgfviewboxscope: { signature: \"m m m m m\" },\n pgftransformnonlinear: { signature: \"m\" },\n pgfpointtransformednonlinear: { signature: \"m\" },\n pgfsetcurvilinearbeziercurve: { signature: \"m m m m\" },\n pgfcurvilineardistancetotime: { signature: \"m\" },\n pgfpointcurvilinearbezierorthogonal: { signature: \"m m\" },\n pgfpointcurvilinearbezierpolar: { signature: \"m m\" },\n // Matrices\n pgfmatrix: { signature: \"m m m m m m m\" },\n pgfsetmatrixcolumnsep: { signature: \"m\" },\n pgfmatrixnextcell: { signature: \"o\" },\n pgfsetmatrixrowsep: { signature: \"m\" },\n pgfmatrixendrow: { signature: \"o\" },\n // Nodes and shapes\n pgfnode: { signature: \"m m m m m\" },\n pgfmultipartnode: { signature: \"m m m m\" },\n pgfcoordinate: { signature: \"m m\" },\n pgfnodealias: { signature: \"m m\" },\n pgfnoderename: { signature: \"m m\" },\n pgfpositionnodelater: { signature: \"m\" },\n pgfpositionnodenow: { signature: \"m\" },\n pgfnodepostsetupcode: { signature: \"m m\" },\n pgfpointanchor: { signature: \"m m\" },\n pgfpointshapeborder: { signature: \"m m\" },\n pgfdeclareshape: { signature: \"m m\" },\n saveddimen: { signature: \"m m\" },\n savedmacro: { signature: \" m\" },\n anchor: { signature: \"m m\" },\n deferredanchor: { signature: \"m m\" },\n anchorborder: { signature: \"m\" },\n backgroundpath: { signature: \"m\" },\n foregroundpath: { signature: \"m\" },\n behindbackgroundpath: { signature: \"m\" },\n beforebackgroundpath: { signature: \"m\" },\n beforeforegroundpath: { signature: \"m\" },\n behindforegroundpath: { signature: \"m\" },\n // Arrows\n pgfdeclarearrow: { signature: \"m\" },\n pgfarrowssettipend: { signature: \"m\" },\n pgfarrowssetbackend: { signature: \"m\" },\n pgfarrowssetlineend: { signature: \"m\" },\n pgfarrowssetvisualbackend: { signature: \"m\" },\n pgfarrowssetvisualtipend: { signature: \"m\" },\n pgfarrowshullpoint: { signature: \"m m\" },\n pgfarrowsupperhullpoint: { signature: \"m m\" },\n pgfarrowssave: { signature: \"m\" },\n pgfarrowssavethe: { signature: \"m\" },\n pgfarrowsaddtooptions: { signature: \"m\" },\n pgfarrowsaddtolateoptions: { signature: \"m\" },\n pgfarrowsaddtolengthscalelist: { signature: \"m\" },\n pgfarrowsaddtowidthscalelist: { signature: \"m\" },\n pgfarrowsthreeparameters: { signature: \"m\" },\n pgfarrowslinewidthdependent: { signature: \"m m m\" },\n pgfarrowslengthdependent: { signature: \"m\" },\n // Path\n pgfusepath: { signature: \"m\" },\n pgfsetlinewidth: { signature: \"m\" },\n pgfsetmiterlimit: { signature: \"m\" },\n pgfsetdash: { signature: \"m m\" },\n pgfsetstrokecolor: { signature: \"m\" },\n pgfsetcolor: { signature: \"m\" },\n pgfsetinnerlinewidth: { signature: \"m\" },\n pgfsetinnerstrokecolor: { signature: \"m\" },\n pgfsetarrowsstart: { signature: \"m\" },\n pgfsetarrowsend: { signature: \"m\" },\n pgfsetarrows: { signature: \"m\" },\n pgfsetshortenstart: { signature: \"m\" },\n pgfsetshortenend: { signature: \"m\" },\n pgfsetfillcolor: { signature: \"m\" },\n // Decorations\n pgfdeclaredecoration: { signature: \"m m m\" },\n state: { signature: \"m o m\" },\n pgfdecoratepath: { signature: \"m m\" },\n startpgfdecoration: { signature: \"m\" },\n pgfdecoration: { signature: \"m\" },\n pgfdecoratecurrentpath: { signature: \"m\" },\n pgfsetdecorationsegmenttransformation: { signature: \"m\" },\n pgfdeclaremetadecorate: { signature: \"m m m\" },\n pgfmetadecoration: { signature: \"m\" },\n startpgfmetadecoration: { signature: \"m\" },\n // Constructing paths\n pgfpathmoveto: { signature: \"m\" },\n pgfpathlineto: { signature: \"m\" },\n pgfpathcurveto: { signature: \"m m m\" },\n pgfpathquadraticcurveto: { signature: \"m m\" },\n pgfpathcurvebetweentime: { signature: \"m m m m m m\" },\n pgfpathcurvebetweentimecontinue: { signature: \"m m m m m m\" },\n pgfpatharc: { signature: \"m m m\" },\n pgfpatharcaxes: { signature: \"m m m m\" },\n pgfpatharcto: { signature: \"m m m m m m\" },\n pgfpatharctoprecomputed: { signature: \"m m m m m m m m\" },\n pgfpathellipse: { signature: \"m m m\" },\n pgfpathcircle: { signature: \"m m\" },\n pgfpathrectangle: { signature: \"m m\" },\n pgfpathrectanglecorners: { signature: \"m m\" },\n pgfpathgrid: { signature: \" o m m\" },\n pgfpathparabola: { signature: \"m m\" },\n pgfpathsine: { signature: \"m\" },\n pgfpathcosine: { signature: \"m\" },\n pgfsetcornersarced: { signature: \"m\" },\n \"pgf@protocolsizes\": { signature: \"m m\" },\n // Specifying coordinates\n pgfpoint: { signature: \"m m\" },\n pgfpointpolar: { signature: \"m m m\" },\n pgfpointxy: { signature: \"m m\" },\n pgfsetxvec: { signature: \"m\" },\n pgfsetyvec: { signature: \"m\" },\n pgfpointpolarxy: { signature: \"m m\" },\n pgfpointxyz: { signature: \"m m m\" },\n pgfsetzvec: { signature: \"m\" },\n pgfpointcylindrical: { signature: \"m m m\" },\n pgfpointspherical: { signature: \"m m m\" },\n pgfpointadd: { signature: \"m m\" },\n pgfpointscale: { signature: \"m m\" },\n pgfpointdiff: { signature: \"m m\" },\n pgfpointnormalised: { signature: \"m\" },\n pgfpointlineattime: { signature: \"m m m\" },\n pgfpointlineatdistance: { signature: \"m m m\" },\n pgfpointarcaxesattime: { signature: \"m m m m m m\" },\n pgfpointcurveattime: { signature: \"m m m m m\" },\n pgfpointborderrectangle: { signature: \"m m\" },\n pgfpointborderellipse: { signature: \"m m\" },\n pgfpointintersectionoflines: { signature: \"m m m m\" },\n pgfpointintersectionofcircles: { signature: \"m m m m m\" },\n pgfintersectionofpaths: { signature: \"m m\" },\n pgfpointintersectionsolution: { signature: \"m\" },\n pgfextractx: { signature: \"m m\" },\n pgfextracty: { signature: \"m m\" },\n pgfgetlastxy: { signature: \"m m\" },\n \"pgf@process\": { signature: \"m\" },\n // Heirarchical structres ...\n pgfsetbaseline: { signature: \"m\" },\n pgfsetbaselinepointnow: { signature: \"m\" },\n pgfsetbaselinepointlater: { signature: \"m\" },\n pgftext: { signature: \"o m\", renderInfo: { pgfkeysArgs: true } },\n pgfuseid: { signature: \"m\" },\n pgfusetype: { signature: \"m\" },\n pgfidrefnextuse: { signature: \"m m\" },\n pgfidrefprevuse: { signature: \"m m\" },\n pgfaliasid: { signature: \"m m\" },\n pgfgaliasid: { signature: \"m m\" },\n pgfifidreferenced: { signature: \"m m m\" },\n pgfrdfabout: { signature: \"m\" },\n pgfrdfcontent: { signature: \"m\" },\n pgfrdfdatatype: { signature: \"m\" },\n pgfrdfhref: { signature: \"m\" },\n pgfrdfprefix: { signature: \"m\" },\n pgfrdfproperty: { signature: \"m\" },\n pgfrdfrel: { signature: \"m\" },\n pgfrdfresource: { signature: \"m\" },\n pgfrdfrev: { signature: \"m\" },\n pgfrdfsrc: { signature: \"m\" },\n pgfrdftypeof: { signature: \"m\" },\n pgfrdfvocab: { signature: \"m\" },\n pgferror: { signature: \"m\" },\n pgfwarning: { signature: \"m\" },\n path: {\n signature: \"u;\",\n renderInfo: { breakAround: true, tikzPathCommand: true },\n },\n draw: {\n signature: \"u;\",\n renderInfo: { breakAround: true, tikzPathCommand: true },\n },\n fill: {\n signature: \"u;\",\n renderInfo: { breakAround: true, tikzPathCommand: true },\n },\n filldraw: {\n signature: \"u;\",\n renderInfo: { breakAround: true, tikzPathCommand: true },\n },\n pattern: {\n signature: \"u;\",\n renderInfo: { breakAround: true, tikzPathCommand: true },\n },\n shade: {\n signature: \"u;\",\n renderInfo: { breakAround: true, tikzPathCommand: true },\n },\n clip: {\n signature: \"u;\",\n renderInfo: { breakAround: true, tikzPathCommand: true },\n },\n useasboundingbox: {\n signature: \"u;\",\n renderInfo: { breakAround: true, tikzPathCommand: true },\n },\n node: {\n signature: \"u;\",\n renderInfo: { breakAround: true, tikzPathCommand: true },\n },\n coordinate: {\n signature: \"u;\",\n renderInfo: { breakAround: true, tikzPathCommand: true },\n },\n graph: {\n signature: \"u;\",\n renderInfo: { breakAround: true, tikzPathCommand: true },\n },\n scoped: {\n signature: \"o o m\",\n argumentParser: tikzCommandArgumentParser,\n renderInfo: {\n namedArguments: [\"animation\", \"options\", \"command\"],\n breakAround: true,\n },\n },\n};\n","import * as Ast from \"@unified-latex/unified-latex-types\";\nimport * as TikzSpec from \"./types\";\nimport { match } from \"@unified-latex/unified-latex-util-match\";\nimport { decorateArrayForPegjs } from \"@unified-latex/unified-latex-util-pegjs\";\nimport { TikzPegParser } from \"@unified-latex/unified-latex-util-pegjs\";\n\ntype TikzParseOptions = {\n startRule?: \"path_spec\" | \"foreach_body\";\n};\n\nfunction createMatchers() {\n return {\n isChar: match.string,\n isTerminal: (node: any) => match.string(node, \";\"),\n isOperation: (node: any) =>\n match.anyString(node) && node.content.match(/[a-zA-Z]/),\n isWhitespace: (node: any) =>\n match.whitespace(node) || match.parbreak(node),\n isComment: match.comment,\n isGroup: match.group,\n isMacro: match.macro,\n isAnyMacro: match.anyMacro,\n };\n}\n\nconst matchers = createMatchers();\n\n/**\n * Parse the contents of the `\\systeme{...}` macro\n */\nexport function parse(\n ast: Ast.Node[],\n options?: Options\n): Options extends { startRule: infer R }\n ? R extends \"path_spec\"\n ? TikzSpec.PathSpec\n : TikzSpec.ForeachBody\n : TikzSpec.PathSpec {\n const { startRule = \"path_spec\" } = options || {};\n if (!Array.isArray(ast)) {\n throw new Error(\"You must pass an array of nodes\");\n }\n // We need to at functions to `nodes` so that it imitates\n // a Javascript string. Because we're mutating, make a copy first\n ast = decorateArrayForPegjs([...ast]);\n // matchers are passed in via the second argument (the `options` argument)\n // so they are available from within the Pegjs grammar.\n return TikzPegParser.parse(ast, {\n ...matchers,\n startRule,\n });\n}\n"],"names":["parseArgspec","colonPos"],"mappings":"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"} \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-ctan/provides-B-HiB8uu.js b/node_modules/@unified-latex/unified-latex-ctan/provides-B-HiB8uu.js new file mode 100644 index 0000000..d2333b1 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-ctan/provides-B-HiB8uu.js @@ -0,0 +1,67 @@ +import { c as cleanEnumerateBody } from "./enumerate-wQeKG6-C.js"; +const macros = { + answerline: { signature: "o" }, + fillin: { signature: "o o" }, + fullwidth: { signature: "m" }, + fillwidthlines: { signature: "m" }, + fillwidthdottedlines: { signature: "m" }, + fillwidthgrid: { signature: "m" }, + makeemptybox: { signature: "m" }, + CorrectChoiceEmphasis: { + signature: "m", + renderInfo: { breakAround: true } + }, + SolutionEmphasis: { signature: "m", renderInfo: { breakAround: true } }, + uplevel: { signature: "m", renderInfo: { breakAround: true } }, + checkboxchar: { signature: "m", renderInfo: { breakAround: true } }, + checkedchar: { signature: "m", renderInfo: { breakAround: true } }, + pointname: { signature: "m", renderInfo: { breakAround: true } }, + marginpointname: { signature: "m", renderInfo: { breakAround: true } }, + extrawidth: { signature: "m", renderInfo: { breakAround: true } }, + pointformat: { signature: "m", renderInfo: { breakAround: true } }, + bonuspointformat: { signature: "m", renderInfo: { breakAround: true } }, + totalformat: { signature: "m", renderInfo: { breakAround: true } }, + qformat: { signature: "m", renderInfo: { breakAround: true } }, + titledquestion: { signature: "m o", renderInfo: { breakAround: true } }, + pointpoints: { signature: "m m", renderInfo: { breakAround: true } }, + bonuspointpoints: { signature: "m m", renderInfo: { breakAround: true } } +}; +const environments = { + choices: { + signature: "o", + processContent: (nodes) => cleanEnumerateBody(nodes, "choice") + }, + checkboxes: { + signature: "o", + processContent: (nodes) => cleanEnumerateBody(nodes, "choice") + }, + oneparchoices: { + signature: "o", + processContent: (nodes) => cleanEnumerateBody(nodes, "choice") + }, + oneparcheckboxes: { + signature: "o", + processContent: (nodes) => cleanEnumerateBody(nodes, "choice") + }, + parts: { + signature: "o", + processContent: (nodes) => cleanEnumerateBody(nodes, "part") + }, + subparts: { + signature: "o", + processContent: (nodes) => cleanEnumerateBody(nodes, "subpart") + }, + subsubparts: { + signature: "o", + processContent: (nodes) => cleanEnumerateBody(nodes, "subsubpart") + }, + questions: { + signature: "o", + processContent: (nodes) => cleanEnumerateBody(nodes, "question") + } +}; +export { + environments as e, + macros as m +}; +//# sourceMappingURL=provides-B-HiB8uu.js.map diff --git a/node_modules/@unified-latex/unified-latex-ctan/provides-B-HiB8uu.js.map b/node_modules/@unified-latex/unified-latex-ctan/provides-B-HiB8uu.js.map new file mode 100644 index 0000000..1ce7fe8 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-ctan/provides-B-HiB8uu.js.map @@ -0,0 +1 @@ +{"version":3,"file":"provides-B-HiB8uu.js","sources":["../package/exam/provides.ts"],"sourcesContent":["import {\n MacroInfoRecord,\n EnvInfoRecord,\n} from \"@unified-latex/unified-latex-types\";\nimport { cleanEnumerateBody } from \"../../utils/enumerate\";\n\nexport const macros: MacroInfoRecord = {\n answerline: { signature: \"o\" },\n fillin: { signature: \"o o\" },\n fullwidth: { signature: \"m\" },\n fillwidthlines: { signature: \"m\" },\n fillwidthdottedlines: { signature: \"m\" },\n fillwidthgrid: { signature: \"m\" },\n makeemptybox: { signature: \"m\" },\n CorrectChoiceEmphasis: {\n signature: \"m\",\n renderInfo: { breakAround: true },\n },\n SolutionEmphasis: { signature: \"m\", renderInfo: { breakAround: true } },\n uplevel: { signature: \"m\", renderInfo: { breakAround: true } },\n checkboxchar: { signature: \"m\", renderInfo: { breakAround: true } },\n checkedchar: { signature: \"m\", renderInfo: { breakAround: true } },\n pointname: { signature: \"m\", renderInfo: { breakAround: true } },\n marginpointname: { signature: \"m\", renderInfo: { breakAround: true } },\n extrawidth: { signature: \"m\", renderInfo: { breakAround: true } },\n pointformat: { signature: \"m\", renderInfo: { breakAround: true } },\n bonuspointformat: { signature: \"m\", renderInfo: { breakAround: true } },\n totalformat: { signature: \"m\", renderInfo: { breakAround: true } },\n qformat: { signature: \"m\", renderInfo: { breakAround: true } },\n titledquestion: { signature: \"m o\", renderInfo: { breakAround: true } },\n pointpoints: { signature: \"m m\", renderInfo: { breakAround: true } },\n bonuspointpoints: { signature: \"m m\", renderInfo: { breakAround: true } },\n};\n\nexport const environments: EnvInfoRecord = {\n choices: {\n signature: \"o\",\n processContent: (nodes) => cleanEnumerateBody(nodes, \"choice\"),\n },\n checkboxes: {\n signature: \"o\",\n processContent: (nodes) => cleanEnumerateBody(nodes, \"choice\"),\n },\n oneparchoices: {\n signature: \"o\",\n processContent: (nodes) => cleanEnumerateBody(nodes, \"choice\"),\n },\n oneparcheckboxes: {\n signature: \"o\",\n processContent: (nodes) => cleanEnumerateBody(nodes, \"choice\"),\n },\n parts: {\n signature: \"o\",\n processContent: (nodes) => cleanEnumerateBody(nodes, \"part\"),\n },\n subparts: {\n signature: \"o\",\n processContent: (nodes) => cleanEnumerateBody(nodes, \"subpart\"),\n },\n subsubparts: {\n signature: \"o\",\n processContent: (nodes) => cleanEnumerateBody(nodes, \"subsubpart\"),\n },\n questions: {\n signature: \"o\",\n processContent: (nodes) => cleanEnumerateBody(nodes, \"question\"),\n },\n};\n"],"names":[],"mappings":";AAMO,MAAM,SAA0B;AAAA,EACnC,YAAY,EAAE,WAAW,IAAI;AAAA,EAC7B,QAAQ,EAAE,WAAW,MAAM;AAAA,EAC3B,WAAW,EAAE,WAAW,IAAI;AAAA,EAC5B,gBAAgB,EAAE,WAAW,IAAI;AAAA,EACjC,sBAAsB,EAAE,WAAW,IAAI;AAAA,EACvC,eAAe,EAAE,WAAW,IAAI;AAAA,EAChC,cAAc,EAAE,WAAW,IAAI;AAAA,EAC/B,uBAAuB;AAAA,IACnB,WAAW;AAAA,IACX,YAAY,EAAE,aAAa,KAAK;AAAA,EACpC;AAAA,EACA,kBAAkB,EAAE,WAAW,KAAK,YAAY,EAAE,aAAa,OAAO;AAAA,EACtE,SAAS,EAAE,WAAW,KAAK,YAAY,EAAE,aAAa,OAAO;AAAA,EAC7D,cAAc,EAAE,WAAW,KAAK,YAAY,EAAE,aAAa,OAAO;AAAA,EAClE,aAAa,EAAE,WAAW,KAAK,YAAY,EAAE,aAAa,OAAO;AAAA,EACjE,WAAW,EAAE,WAAW,KAAK,YAAY,EAAE,aAAa,OAAO;AAAA,EAC/D,iBAAiB,EAAE,WAAW,KAAK,YAAY,EAAE,aAAa,OAAO;AAAA,EACrE,YAAY,EAAE,WAAW,KAAK,YAAY,EAAE,aAAa,OAAO;AAAA,EAChE,aAAa,EAAE,WAAW,KAAK,YAAY,EAAE,aAAa,OAAO;AAAA,EACjE,kBAAkB,EAAE,WAAW,KAAK,YAAY,EAAE,aAAa,OAAO;AAAA,EACtE,aAAa,EAAE,WAAW,KAAK,YAAY,EAAE,aAAa,OAAO;AAAA,EACjE,SAAS,EAAE,WAAW,KAAK,YAAY,EAAE,aAAa,OAAO;AAAA,EAC7D,gBAAgB,EAAE,WAAW,OAAO,YAAY,EAAE,aAAa,OAAO;AAAA,EACtE,aAAa,EAAE,WAAW,OAAO,YAAY,EAAE,aAAa,OAAO;AAAA,EACnE,kBAAkB,EAAE,WAAW,OAAO,YAAY,EAAE,aAAa,KAAO,EAAA;AAC5E;AAEO,MAAM,eAA8B;AAAA,EACvC,SAAS;AAAA,IACL,WAAW;AAAA,IACX,gBAAgB,CAAC,UAAU,mBAAmB,OAAO,QAAQ;AAAA,EACjE;AAAA,EACA,YAAY;AAAA,IACR,WAAW;AAAA,IACX,gBAAgB,CAAC,UAAU,mBAAmB,OAAO,QAAQ;AAAA,EACjE;AAAA,EACA,eAAe;AAAA,IACX,WAAW;AAAA,IACX,gBAAgB,CAAC,UAAU,mBAAmB,OAAO,QAAQ;AAAA,EACjE;AAAA,EACA,kBAAkB;AAAA,IACd,WAAW;AAAA,IACX,gBAAgB,CAAC,UAAU,mBAAmB,OAAO,QAAQ;AAAA,EACjE;AAAA,EACA,OAAO;AAAA,IACH,WAAW;AAAA,IACX,gBAAgB,CAAC,UAAU,mBAAmB,OAAO,MAAM;AAAA,EAC/D;AAAA,EACA,UAAU;AAAA,IACN,WAAW;AAAA,IACX,gBAAgB,CAAC,UAAU,mBAAmB,OAAO,SAAS;AAAA,EAClE;AAAA,EACA,aAAa;AAAA,IACT,WAAW;AAAA,IACX,gBAAgB,CAAC,UAAU,mBAAmB,OAAO,YAAY;AAAA,EACrE;AAAA,EACA,WAAW;AAAA,IACP,WAAW;AAAA,IACX,gBAAgB,CAAC,UAAU,mBAAmB,OAAO,UAAU;AAAA,EAAA;AAEvE;"} \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-ctan/provides-BUHzyq9A.js b/node_modules/@unified-latex/unified-latex-ctan/provides-BUHzyq9A.js new file mode 100644 index 0000000..2671845 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-ctan/provides-BUHzyq9A.js @@ -0,0 +1,346 @@ +import { trim } from "@unified-latex/unified-latex-util-trim"; +import { c as cleanEnumerateBody } from "./enumerate-wQeKG6-C.js"; +const macros = { + // Special + "\\": { signature: "!s !o", renderInfo: { breakAfter: true } }, + _: { signature: "m", escapeToken: "" }, + "^": { signature: "m", escapeToken: "" }, + // \newcommand arg signature from https://www.texdev.net/2020/08/19/the-good-the-bad-and-the-ugly-creating-document-commands + // List can be found in latex2e.pdf "An unofficial reference manual" + newcommand: { + signature: "s +m o +o +m", + renderInfo: { + breakAround: true, + namedArguments: ["starred", "name", "numArgs", "default", "body"] + } + }, + renewcommand: { + signature: "s +m o +o +m", + renderInfo: { + breakAround: true, + namedArguments: ["starred", "name", "numArgs", "default", "body"] + } + }, + providecommand: { + signature: "s +m o +o +m", + renderInfo: { breakAround: true } + }, + // Counters + newcounter: { + signature: "m o", + renderInfo: { breakAround: true } + }, + usecounter: { + signature: "m" + }, + setcounter: { + signature: "m m", + renderInfo: { breakAround: true } + }, + addtocounter: { + signature: "m m", + renderInfo: { breakAround: true } + }, + stepcounter: { + signature: "m", + renderInfo: { breakAround: true } + }, + refstepcounter: { + signature: "m", + renderInfo: { breakAround: true } + }, + // Lengths + newlength: { + signature: "m", + renderInfo: { breakAround: true } + }, + addtolength: { + signature: "m m", + renderInfo: { breakAround: true } + }, + settodepth: { + signature: "m m", + renderInfo: { breakAround: true } + }, + settoheight: { + signature: "m m", + renderInfo: { breakAround: true } + }, + settowidth: { + signature: "m m", + renderInfo: { breakAround: true } + }, + // Spaces + stretch: { signature: "m" }, + hspace: { signature: "s m" }, + vspace: { signature: "s m", renderInfo: { breakAround: true } }, + vfill: { renderInfo: { breakAround: true } }, + indent: { renderInfo: { breakAround: true } }, + phantom: { signature: "m" }, + vphantom: { signature: "m" }, + hphantom: { signature: "m" }, + noindent: { renderInfo: { breakAround: true } }, + smallskip: { renderInfo: { breakAround: true } }, + medskip: { renderInfo: { breakAround: true } }, + bigskip: { renderInfo: { breakAround: true } }, + smallbreak: { renderInfo: { breakAround: true } }, + medbreak: { renderInfo: { breakAround: true } }, + bigbreak: { renderInfo: { breakAround: true } }, + newline: { renderInfo: { breakAround: true } }, + linebreak: { signature: "o", renderInfo: { breakAround: true } }, + nolinebreak: { signature: "o", renderInfo: { breakAround: true } }, + clearpage: { renderInfo: { breakAround: true } }, + cleardoublepage: { renderInfo: { breakAround: true } }, + newpage: { renderInfo: { breakAround: true } }, + enlargethispage: { signature: "s", renderInfo: { breakAround: true } }, + pagebreak: { signature: "o", renderInfo: { breakAround: true } }, + nopagebreak: { signature: "o", renderInfo: { breakAround: true } }, + // Boxes + newsavebox: { + signature: "m", + renderInfo: { breakAround: true } + }, + sbox: { + signature: "m m", + renderInfo: { breakAround: true } + }, + savebox: { + signature: "m o o m", + renderInfo: { breakAround: true } + }, + mbox: { signature: "m" }, + makebox: { signature: "d() o o m", renderInfo: { breakAround: true } }, + fbox: { signature: "m" }, + framebox: { signature: "o o m", renderInfo: { breakAround: true } }, + frame: { signature: "m", renderInfo: { breakAround: true } }, + parbox: { signature: "o o o m m", renderInfo: { breakAround: true } }, + raisebox: { signature: "m o o m" }, + marginpar: { signature: "o m", renderInfo: { breakAround: true } }, + colorbox: { signature: "o m m", renderInfo: { breakAround: true } }, + fcolorbox: { signature: "o m m", renderInfo: { breakAround: true } }, + rotatebox: { signature: "o m m" }, + scalebox: { signature: "m o m" }, + reflectbox: { signature: "m" }, + resizebox: { signature: "s m m m" }, + // Define environments + newenvironment: { + signature: "s m o o m m", + renderInfo: { breakAround: true } + }, + renewenvironment: { + signature: "s m o o m m", + renderInfo: { breakAround: true } + }, + newtheorem: { + signature: "s m o m o", + renderInfo: { breakAround: true } + }, + newfont: { + signature: "m m", + renderInfo: { breakAround: true } + }, + // Counters + alph: { signature: "m" }, + Alph: { signature: "m" }, + arabic: { signature: "m" }, + roman: { signature: "m" }, + Roman: { signature: "m" }, + fnsymbol: { signature: "m" }, + // Other + documentclass: { + signature: "o m", + renderInfo: { breakAround: true, pgfkeysArgs: true } + }, + usepackage: { + signature: "o m", + renderInfo: { breakAround: true, pgfkeysArgs: true } + }, + item: { + signature: "o", + renderInfo: { hangingIndent: true, namedArguments: ["label"] } + }, + value: { signature: "m" }, + centering: { renderInfo: { breakAround: true } }, + input: { signature: "m", renderInfo: { breakAround: true } }, + include: { signature: "m", renderInfo: { breakAround: true } }, + includeonly: { + signature: "m", + renderInfo: { breakAround: true, pgfkeysArgs: true } + }, + discretionary: { signature: "m m m" }, + hyphenation: { signature: "m" }, + footnote: { signature: "o m", renderInfo: { inParMode: true } }, + footnotemark: { signature: "o" }, + footnotetext: { signature: "o m", renderInfo: { inParMode: true } }, + caption: { + signature: "o m", + renderInfo: { inParMode: true, breakAround: true } + }, + // Math Commands + sqrt: { signature: "o m", renderInfo: { inMathMode: true } }, + frac: { signature: "m m", renderInfo: { inMathMode: true } }, + stackrel: { signature: "m m" }, + ensuremath: { signature: "m", renderInfo: { inMathMode: true } }, + // Layout commands + abstract: { + signature: "m", + renderInfo: { breakAround: true, inParMode: true } + }, + maketitle: { renderInfo: { breakAround: true } }, + doublespacing: { renderInfo: { breakAround: true } }, + singlespacing: { renderInfo: { breakAround: true } }, + date: { signature: "o m", renderInfo: { breakAround: true } }, + thanks: { + signature: "m", + renderInfo: { breakAround: true, inParMode: true } + }, + pagenumbering: { signature: "m", renderInfo: { breakAround: true } }, + pagestyle: { signature: "m", renderInfo: { breakAround: true } }, + thispagestyle: { signature: "m", renderInfo: { breakAround: true } }, + // Colors + definecolor: { signature: "m m m", renderInfo: { breakAround: true } }, + pagecolor: { signature: "o m", renderInfo: { breakAround: true } }, + nopagecolor: { renderInfo: { breakAround: true } }, + multicolumn: { signature: "m m m" }, + // Graphics + includegraphics: { + signature: "s o o m", + renderInfo: { breakAround: true, pgfkeysArgs: true } + }, + rule: { signature: "o m m" }, + // Sectioning + part: { + signature: "s o m", + renderInfo: { + breakAround: true, + inParMode: true, + namedArguments: ["starred", "tocTitle", "title"] + } + }, + chapter: { + signature: "s o m", + renderInfo: { + breakAround: true, + inParMode: true, + namedArguments: ["starred", "tocTitle", "title"] + } + }, + section: { + signature: "s o m", + renderInfo: { + breakAround: true, + inParMode: true, + namedArguments: ["starred", "tocTitle", "title"] + } + }, + subsection: { + signature: "s o m", + renderInfo: { + breakAround: true, + inParMode: true, + namedArguments: ["starred", "tocTitle", "title"] + } + }, + subsubsection: { + signature: "s o m", + renderInfo: { + breakAround: true, + inParMode: true, + namedArguments: ["starred", "tocTitle", "title"] + } + }, + paragraph: { + signature: "s o m", + renderInfo: { + breakAround: true, + inParMode: true, + namedArguments: ["starred", "tocTitle", "title"] + } + }, + subparagraph: { + signature: "s o m", + renderInfo: { + breakAround: true, + inParMode: true, + namedArguments: ["starred", "tocTitle", "title"] + } + }, + appendix: { renderInfo: { breakAround: true, inParMode: true } }, + frontmatter: { renderInfo: { breakAround: true, inParMode: true } }, + mainmatter: { renderInfo: { breakAround: true, inParMode: true } }, + backmatter: { renderInfo: { breakAround: true, inParMode: true } }, + // Citing and references + bibitem: { signature: "o m", renderInfo: { hangingIndent: true } }, + cite: { signature: "o m" }, + // Fonts + textrm: { signature: "m", renderInfo: { inParMode: true } }, + textit: { signature: "m", renderInfo: { inParMode: true } }, + textmd: { signature: "m", renderInfo: { inParMode: true } }, + textbf: { signature: "m", renderInfo: { inParMode: true } }, + textup: { signature: "m", renderInfo: { inParMode: true } }, + textsl: { signature: "m", renderInfo: { inParMode: true } }, + textsf: { signature: "m", renderInfo: { inParMode: true } }, + textsc: { signature: "m", renderInfo: { inParMode: true } }, + texttt: { signature: "m", renderInfo: { inParMode: true } }, + underline: { signature: "m", renderInfo: { inParMode: true } }, + emph: { signature: "m", renderInfo: { inParMode: true } }, + textnormal: { signature: "m", renderInfo: { inParMode: true } }, + uppercase: { signature: "m", renderInfo: { inParMode: true } }, + mathbf: { signature: "m" }, + mathsf: { signature: "m" }, + mathtt: { signature: "m" }, + mathit: { signature: "m" }, + mathnormal: { signature: "m" }, + mathcal: { signature: "m" }, + mathrm: { signature: "m" }, + // Other + setlength: { signature: "m m", renderInfo: { breakAround: true } }, + ref: { signature: "s m" }, + label: { signature: "o m" }, + // cleveref changes \label to have this signature + printbibliography: { renderInfo: { breakAround: true } }, + addtocontents: { signature: "m m", renderInfo: { breakAround: true } }, + addcontentsline: { signature: "m m m", renderInfo: { breakAround: true } }, + contentsline: { signature: "m m m", renderInfo: { breakAround: true } }, + bibliography: { signature: "m", renderInfo: { breakAround: true } }, + bibliographystyle: { signature: "m", renderInfo: { breakAround: true } } +}; +const environments = { + document: { + processContent: (nodes) => { + trim(nodes); + return nodes; + } + }, + array: { signature: "o m", renderInfo: { alignContent: true } }, + description: { signature: "o", processContent: cleanEnumerateBody }, + enumerate: { + signature: "o", + processContent: cleanEnumerateBody, + renderInfo: { pgfkeysArgs: true } + }, + itemize: { signature: "o", processContent: cleanEnumerateBody }, + trivlist: { signature: "o", processContent: cleanEnumerateBody }, + list: { signature: "m m", processContent: cleanEnumerateBody }, + figure: { signature: "o" }, + "figure*": { signature: "o" }, + filecontents: { signature: "o m" }, + "filecontents*": { signature: "o m" }, + minipage: { signature: "o o o m" }, + picture: { signature: "r() d()" }, + tabbing: { renderInfo: { alignContent: true } }, + table: { signature: "o" }, + tabular: { signature: "o m", renderInfo: { alignContent: true } }, + "tabular*": { signature: "m o m", renderInfo: { alignContent: true } }, + thebibliography: { + signature: "m", + processContent: (nodes) => cleanEnumerateBody(nodes, "bibitem") + }, + // Math + math: { renderInfo: { inMathMode: true } } +}; +export { + environments as e, + macros as m +}; +//# sourceMappingURL=provides-BUHzyq9A.js.map diff --git a/node_modules/@unified-latex/unified-latex-ctan/provides-BUHzyq9A.js.map b/node_modules/@unified-latex/unified-latex-ctan/provides-BUHzyq9A.js.map new file mode 100644 index 0000000..ca134de --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-ctan/provides-BUHzyq9A.js.map @@ -0,0 +1 @@ +{"version":3,"file":"provides-BUHzyq9A.js","sources":["../package/latex2e/provides.ts"],"sourcesContent":["import {\n MacroInfoRecord,\n EnvInfoRecord,\n} from \"@unified-latex/unified-latex-types\";\nimport { trim } from \"@unified-latex/unified-latex-util-trim\";\nimport { cleanEnumerateBody } from \"../../utils/enumerate\";\n\nexport const macros: MacroInfoRecord = {\n // Special\n \"\\\\\": { signature: \"!s !o\", renderInfo: { breakAfter: true } },\n _: { signature: \"m\", escapeToken: \"\" },\n \"^\": { signature: \"m\", escapeToken: \"\" },\n // \\newcommand arg signature from https://www.texdev.net/2020/08/19/the-good-the-bad-and-the-ugly-creating-document-commands\n // List can be found in latex2e.pdf \"An unofficial reference manual\"\n newcommand: {\n signature: \"s +m o +o +m\",\n renderInfo: {\n breakAround: true,\n namedArguments: [\"starred\", \"name\", \"numArgs\", \"default\", \"body\"],\n },\n },\n renewcommand: {\n signature: \"s +m o +o +m\",\n renderInfo: {\n breakAround: true,\n namedArguments: [\"starred\", \"name\", \"numArgs\", \"default\", \"body\"],\n },\n },\n providecommand: {\n signature: \"s +m o +o +m\",\n renderInfo: { breakAround: true },\n },\n // Counters\n newcounter: {\n signature: \"m o\",\n renderInfo: { breakAround: true },\n },\n usecounter: {\n signature: \"m\",\n },\n setcounter: {\n signature: \"m m\",\n renderInfo: { breakAround: true },\n },\n addtocounter: {\n signature: \"m m\",\n renderInfo: { breakAround: true },\n },\n stepcounter: {\n signature: \"m\",\n renderInfo: { breakAround: true },\n },\n refstepcounter: {\n signature: \"m\",\n renderInfo: { breakAround: true },\n },\n // Lengths\n newlength: {\n signature: \"m\",\n renderInfo: { breakAround: true },\n },\n addtolength: {\n signature: \"m m\",\n renderInfo: { breakAround: true },\n },\n settodepth: {\n signature: \"m m\",\n renderInfo: { breakAround: true },\n },\n settoheight: {\n signature: \"m m\",\n renderInfo: { breakAround: true },\n },\n settowidth: {\n signature: \"m m\",\n renderInfo: { breakAround: true },\n },\n // Spaces\n stretch: { signature: \"m\" },\n hspace: { signature: \"s m\" },\n vspace: { signature: \"s m\", renderInfo: { breakAround: true } },\n vfill: { renderInfo: { breakAround: true } },\n indent: { renderInfo: { breakAround: true } },\n phantom: { signature: \"m\" },\n vphantom: { signature: \"m\" },\n hphantom: { signature: \"m\" },\n noindent: { renderInfo: { breakAround: true } },\n smallskip: { renderInfo: { breakAround: true } },\n medskip: { renderInfo: { breakAround: true } },\n bigskip: { renderInfo: { breakAround: true } },\n smallbreak: { renderInfo: { breakAround: true } },\n medbreak: { renderInfo: { breakAround: true } },\n bigbreak: { renderInfo: { breakAround: true } },\n newline: { renderInfo: { breakAround: true } },\n linebreak: { signature: \"o\", renderInfo: { breakAround: true } },\n nolinebreak: { signature: \"o\", renderInfo: { breakAround: true } },\n clearpage: { renderInfo: { breakAround: true } },\n cleardoublepage: { renderInfo: { breakAround: true } },\n newpage: { renderInfo: { breakAround: true } },\n enlargethispage: { signature: \"s\", renderInfo: { breakAround: true } },\n pagebreak: { signature: \"o\", renderInfo: { breakAround: true } },\n nopagebreak: { signature: \"o\", renderInfo: { breakAround: true } },\n // Boxes\n newsavebox: {\n signature: \"m\",\n renderInfo: { breakAround: true },\n },\n sbox: {\n signature: \"m m\",\n renderInfo: { breakAround: true },\n },\n savebox: {\n signature: \"m o o m\",\n renderInfo: { breakAround: true },\n },\n mbox: { signature: \"m\" },\n makebox: { signature: \"d() o o m\", renderInfo: { breakAround: true } },\n fbox: { signature: \"m\" },\n framebox: { signature: \"o o m\", renderInfo: { breakAround: true } },\n frame: { signature: \"m\", renderInfo: { breakAround: true } },\n parbox: { signature: \"o o o m m\", renderInfo: { breakAround: true } },\n raisebox: { signature: \"m o o m\" },\n marginpar: { signature: \"o m\", renderInfo: { breakAround: true } },\n colorbox: { signature: \"o m m\", renderInfo: { breakAround: true } },\n fcolorbox: { signature: \"o m m\", renderInfo: { breakAround: true } },\n rotatebox: { signature: \"o m m\" },\n scalebox: { signature: \"m o m\" },\n reflectbox: { signature: \"m\" },\n resizebox: { signature: \"s m m m\" },\n // Define environments\n newenvironment: {\n signature: \"s m o o m m\",\n renderInfo: { breakAround: true },\n },\n renewenvironment: {\n signature: \"s m o o m m\",\n renderInfo: { breakAround: true },\n },\n newtheorem: {\n signature: \"s m o m o\",\n renderInfo: { breakAround: true },\n },\n newfont: {\n signature: \"m m\",\n renderInfo: { breakAround: true },\n },\n // Counters\n alph: { signature: \"m\" },\n Alph: { signature: \"m\" },\n arabic: { signature: \"m\" },\n roman: { signature: \"m\" },\n Roman: { signature: \"m\" },\n fnsymbol: { signature: \"m\" },\n // Other\n documentclass: {\n signature: \"o m\",\n renderInfo: { breakAround: true, pgfkeysArgs: true },\n },\n usepackage: {\n signature: \"o m\",\n renderInfo: { breakAround: true, pgfkeysArgs: true },\n },\n item: {\n signature: \"o\",\n renderInfo: { hangingIndent: true, namedArguments: [\"label\"] },\n },\n value: { signature: \"m\" },\n centering: { renderInfo: { breakAround: true } },\n input: { signature: \"m\", renderInfo: { breakAround: true } },\n include: { signature: \"m\", renderInfo: { breakAround: true } },\n includeonly: {\n signature: \"m\",\n renderInfo: { breakAround: true, pgfkeysArgs: true },\n },\n discretionary: { signature: \"m m m\" },\n hyphenation: { signature: \"m\" },\n footnote: { signature: \"o m\", renderInfo: { inParMode: true } },\n footnotemark: { signature: \"o\" },\n footnotetext: { signature: \"o m\", renderInfo: { inParMode: true } },\n caption: {\n signature: \"o m\",\n renderInfo: { inParMode: true, breakAround: true },\n },\n // Math Commands\n sqrt: { signature: \"o m\", renderInfo: { inMathMode: true } },\n frac: { signature: \"m m\", renderInfo: { inMathMode: true } },\n stackrel: { signature: \"m m\" },\n ensuremath: { signature: \"m\", renderInfo: { inMathMode: true } },\n // Layout commands\n abstract: {\n signature: \"m\",\n renderInfo: { breakAround: true, inParMode: true },\n },\n maketitle: { renderInfo: { breakAround: true } },\n doublespacing: { renderInfo: { breakAround: true } },\n singlespacing: { renderInfo: { breakAround: true } },\n date: { signature: \"o m\", renderInfo: { breakAround: true } },\n thanks: {\n signature: \"m\",\n renderInfo: { breakAround: true, inParMode: true },\n },\n pagenumbering: { signature: \"m\", renderInfo: { breakAround: true } },\n pagestyle: { signature: \"m\", renderInfo: { breakAround: true } },\n thispagestyle: { signature: \"m\", renderInfo: { breakAround: true } },\n // Colors\n definecolor: { signature: \"m m m\", renderInfo: { breakAround: true } },\n pagecolor: { signature: \"o m\", renderInfo: { breakAround: true } },\n nopagecolor: { renderInfo: { breakAround: true } },\n multicolumn: { signature: \"m m m\" },\n // Graphics\n includegraphics: {\n signature: \"s o o m\",\n renderInfo: { breakAround: true, pgfkeysArgs: true },\n },\n rule: { signature: \"o m m\" },\n // Sectioning\n part: {\n signature: \"s o m\",\n renderInfo: {\n breakAround: true,\n inParMode: true,\n namedArguments: [\"starred\", \"tocTitle\", \"title\"],\n },\n },\n chapter: {\n signature: \"s o m\",\n renderInfo: {\n breakAround: true,\n inParMode: true,\n namedArguments: [\"starred\", \"tocTitle\", \"title\"],\n },\n },\n section: {\n signature: \"s o m\",\n renderInfo: {\n breakAround: true,\n inParMode: true,\n namedArguments: [\"starred\", \"tocTitle\", \"title\"],\n },\n },\n subsection: {\n signature: \"s o m\",\n renderInfo: {\n breakAround: true,\n inParMode: true,\n namedArguments: [\"starred\", \"tocTitle\", \"title\"],\n },\n },\n subsubsection: {\n signature: \"s o m\",\n renderInfo: {\n breakAround: true,\n inParMode: true,\n namedArguments: [\"starred\", \"tocTitle\", \"title\"],\n },\n },\n paragraph: {\n signature: \"s o m\",\n renderInfo: {\n breakAround: true,\n inParMode: true,\n namedArguments: [\"starred\", \"tocTitle\", \"title\"],\n },\n },\n subparagraph: {\n signature: \"s o m\",\n renderInfo: {\n breakAround: true,\n inParMode: true,\n namedArguments: [\"starred\", \"tocTitle\", \"title\"],\n },\n },\n appendix: { renderInfo: { breakAround: true, inParMode: true } },\n frontmatter: { renderInfo: { breakAround: true, inParMode: true } },\n mainmatter: { renderInfo: { breakAround: true, inParMode: true } },\n backmatter: { renderInfo: { breakAround: true, inParMode: true } },\n // Citing and references\n bibitem: { signature: \"o m\", renderInfo: { hangingIndent: true } },\n cite: { signature: \"o m\" },\n // Fonts\n textrm: { signature: \"m\", renderInfo: { inParMode: true } },\n textit: { signature: \"m\", renderInfo: { inParMode: true } },\n textmd: { signature: \"m\", renderInfo: { inParMode: true } },\n textbf: { signature: \"m\", renderInfo: { inParMode: true } },\n textup: { signature: \"m\", renderInfo: { inParMode: true } },\n textsl: { signature: \"m\", renderInfo: { inParMode: true } },\n textsf: { signature: \"m\", renderInfo: { inParMode: true } },\n textsc: { signature: \"m\", renderInfo: { inParMode: true } },\n texttt: { signature: \"m\", renderInfo: { inParMode: true } },\n underline: { signature: \"m\", renderInfo: { inParMode: true } },\n emph: { signature: \"m\", renderInfo: { inParMode: true } },\n textnormal: { signature: \"m\", renderInfo: { inParMode: true } },\n uppercase: { signature: \"m\", renderInfo: { inParMode: true } },\n mathbf: { signature: \"m\" },\n mathsf: { signature: \"m\" },\n mathtt: { signature: \"m\" },\n mathit: { signature: \"m\" },\n mathnormal: { signature: \"m\" },\n mathcal: { signature: \"m\" },\n mathrm: { signature: \"m\" },\n // Other\n setlength: { signature: \"m m\", renderInfo: { breakAround: true } },\n ref: { signature: \"s m\" },\n label: { signature: \"o m\" }, // cleveref changes \\label to have this signature\n printbibliography: { renderInfo: { breakAround: true } },\n addtocontents: { signature: \"m m\", renderInfo: { breakAround: true } },\n addcontentsline: { signature: \"m m m\", renderInfo: { breakAround: true } },\n contentsline: { signature: \"m m m\", renderInfo: { breakAround: true } },\n bibliography: { signature: \"m\", renderInfo: { breakAround: true } },\n bibliographystyle: { signature: \"m\", renderInfo: { breakAround: true } },\n};\n\nexport const environments: EnvInfoRecord = {\n document: {\n processContent: (nodes) => {\n trim(nodes);\n return nodes;\n },\n },\n array: { signature: \"o m\", renderInfo: { alignContent: true } },\n description: { signature: \"o\", processContent: cleanEnumerateBody },\n enumerate: {\n signature: \"o\",\n processContent: cleanEnumerateBody,\n renderInfo: { pgfkeysArgs: true },\n },\n itemize: { signature: \"o\", processContent: cleanEnumerateBody },\n trivlist: { signature: \"o\", processContent: cleanEnumerateBody },\n list: { signature: \"m m\", processContent: cleanEnumerateBody },\n figure: { signature: \"o\" },\n \"figure*\": { signature: \"o\" },\n filecontents: { signature: \"o m\" },\n \"filecontents*\": { signature: \"o m\" },\n minipage: { signature: \"o o o m\" },\n picture: { signature: \"r() d()\" },\n tabbing: { renderInfo: { alignContent: true } },\n table: { signature: \"o\" },\n tabular: { signature: \"o m\", renderInfo: { alignContent: true } },\n \"tabular*\": { signature: \"m o m\", renderInfo: { alignContent: true } },\n thebibliography: {\n signature: \"m\",\n processContent: (nodes) => cleanEnumerateBody(nodes, \"bibitem\"),\n },\n // Math\n math: { renderInfo: { inMathMode: true } },\n};\n"],"names":[],"mappings":"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"} \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-ctan/provides-Bdw2Aj_V.cjs b/node_modules/@unified-latex/unified-latex-ctan/provides-Bdw2Aj_V.cjs new file mode 100644 index 0000000..a23e6cc --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-ctan/provides-Bdw2Aj_V.cjs @@ -0,0 +1,56 @@ +"use strict"; +const unifiedLatexBuilder = require("@unified-latex/unified-latex-builder"); +const unifiedLatexUtilArgspec = require("@unified-latex/unified-latex-util-argspec"); +const unifiedLatexUtilArguments = require("@unified-latex/unified-latex-util-arguments"); +const unifiedLatexUtilMatch = require("@unified-latex/unified-latex-util-match"); +const argSpecM = unifiedLatexUtilArgspec.parse("m")[0]; +const argSpecO = unifiedLatexUtilArgspec.parse("o")[0]; +const argSpecRDelim = {}; +const argumentParser = (nodes, startPos) => { + const { argument: optionalArg, nodesRemoved: optionalArgNodesRemoved } = unifiedLatexUtilArguments.gobbleSingleArgument(nodes, argSpecO, startPos); + const { argument: languageArg, nodesRemoved: languageArgNodesRemoved } = unifiedLatexUtilArguments.gobbleSingleArgument(nodes, argSpecM, startPos); + let codeArg = null; + let codeArgNodesRemoved = 0; + const nextNode = nodes[startPos]; + if (unifiedLatexUtilMatch.match.group(nextNode)) { + const mandatoryArg = unifiedLatexUtilArguments.gobbleSingleArgument(nodes, argSpecM, startPos); + codeArg = mandatoryArg.argument; + codeArgNodesRemoved = mandatoryArg.nodesRemoved; + } else if (unifiedLatexUtilMatch.match.string(nextNode) && nextNode.content.length === 1) { + const delim = nextNode.content; + argSpecRDelim[delim] = argSpecRDelim[delim] || unifiedLatexUtilArgspec.parse(`r${delim}${delim}`)[0]; + const delimArg = unifiedLatexUtilArguments.gobbleSingleArgument( + nodes, + argSpecRDelim[delim], + startPos + ); + codeArg = delimArg.argument; + codeArgNodesRemoved = delimArg.nodesRemoved; + } + return { + args: [ + optionalArg || unifiedLatexBuilder.arg(null), + languageArg || unifiedLatexBuilder.arg(null), + codeArg || unifiedLatexBuilder.arg(null) + ], + nodesRemoved: optionalArgNodesRemoved + languageArgNodesRemoved + codeArgNodesRemoved + }; +}; +const macros = { + mint: { argumentParser }, + mintinline: { argumentParser }, + inputminted: { argumentParser }, + usemintedstyle: { signature: "m" }, + setminted: { signature: "o m" }, + setmintedinline: { signature: "o m" }, + newmint: { signature: "o m m" }, + newminted: { signature: "o m m" }, + newmintinline: { signature: "o m m" }, + newmintedfile: { signature: "o m m" } +}; +const environments = { + minted: { signature: "o m" } +}; +exports.environments = environments; +exports.macros = macros; +//# sourceMappingURL=provides-Bdw2Aj_V.cjs.map diff --git a/node_modules/@unified-latex/unified-latex-ctan/provides-Bdw2Aj_V.cjs.map b/node_modules/@unified-latex/unified-latex-ctan/provides-Bdw2Aj_V.cjs.map new file mode 100644 index 0000000..671717a --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-ctan/provides-Bdw2Aj_V.cjs.map @@ -0,0 +1 @@ +{"version":3,"file":"provides-Bdw2Aj_V.cjs","sources":["../package/minted/libs/argument-parser.ts","../package/minted/provides.ts"],"sourcesContent":["import { arg } from \"@unified-latex/unified-latex-builder\";\nimport { Argument, ArgumentParser } from \"@unified-latex/unified-latex-types\";\nimport { parse as parseArgspec } from \"@unified-latex/unified-latex-util-argspec\";\nimport { Node } from \"@unified-latex/unified-latex-util-argspec/libs/argspec-types\";\nimport { gobbleSingleArgument } from \"@unified-latex/unified-latex-util-arguments\";\nimport { match } from \"@unified-latex/unified-latex-util-match\";\n\nconst argSpecM = parseArgspec(\"m\")[0];\nconst argSpecO = parseArgspec(\"o\")[0];\nconst argSpecRDelim: { [delim: string]: Node } = {};\n\n/**\n * This argument parser parses arguments in the form of\n * - [⟨options⟩]{⟨language⟩}⟨delim⟩⟨code⟩⟨delim⟩\n * - [⟨options⟩]{⟨language⟩}{⟨code⟩}\n */\nexport const argumentParser: ArgumentParser = (nodes, startPos) => {\n const { argument: optionalArg, nodesRemoved: optionalArgNodesRemoved } =\n gobbleSingleArgument(nodes, argSpecO, startPos);\n\n const { argument: languageArg, nodesRemoved: languageArgNodesRemoved } =\n gobbleSingleArgument(nodes, argSpecM, startPos);\n\n let codeArg: Argument | Argument[] | null = null;\n let codeArgNodesRemoved: number = 0;\n const nextNode = nodes[startPos];\n if (match.group(nextNode)) {\n const mandatoryArg = gobbleSingleArgument(nodes, argSpecM, startPos);\n codeArg = mandatoryArg.argument;\n codeArgNodesRemoved = mandatoryArg.nodesRemoved;\n } else if (match.string(nextNode) && nextNode.content.length === 1) {\n const delim = nextNode.content;\n argSpecRDelim[delim] =\n argSpecRDelim[delim] || parseArgspec(`r${delim}${delim}`)[0];\n const delimArg = gobbleSingleArgument(\n nodes,\n argSpecRDelim[delim],\n startPos\n );\n codeArg = delimArg.argument;\n codeArgNodesRemoved = delimArg.nodesRemoved;\n }\n\n return {\n args: [\n optionalArg || arg(null),\n languageArg || arg(null),\n codeArg || arg(null),\n ],\n nodesRemoved:\n optionalArgNodesRemoved +\n languageArgNodesRemoved +\n codeArgNodesRemoved,\n };\n};\n","import {\n MacroInfoRecord,\n EnvInfoRecord,\n} from \"@unified-latex/unified-latex-types\";\nimport { argumentParser } from \"./libs/argument-parser\";\n\nexport const macros: MacroInfoRecord = {\n mint: { argumentParser: argumentParser },\n mintinline: { argumentParser: argumentParser },\n inputminted: { argumentParser: argumentParser },\n usemintedstyle: { signature: \"m\" },\n setminted: { signature: \"o m\" },\n setmintedinline: { signature: \"o m\" },\n newmint: { signature: \"o m m\" },\n newminted: { signature: \"o m m\" },\n newmintinline: { signature: \"o m m\" },\n newmintedfile: { signature: \"o m m\" },\n};\n\nexport const environments: EnvInfoRecord = {\n minted: { signature: \"o m\" },\n};\n"],"names":["parseArgspec","gobbleSingleArgument","match","arg"],"mappings":";;;;;AAOA,MAAM,WAAWA,wBAAA,MAAa,GAAG,EAAE,CAAC;AACpC,MAAM,WAAWA,wBAAA,MAAa,GAAG,EAAE,CAAC;AACpC,MAAM,gBAA2C,CAAC;AAOrC,MAAA,iBAAiC,CAAC,OAAO,aAAa;AACzD,QAAA,EAAE,UAAU,aAAa,cAAc,wBACzC,IAAAC,+CAAqB,OAAO,UAAU,QAAQ;AAE5C,QAAA,EAAE,UAAU,aAAa,cAAc,wBACzC,IAAAA,+CAAqB,OAAO,UAAU,QAAQ;AAElD,MAAI,UAAwC;AAC5C,MAAI,sBAA8B;AAC5B,QAAA,WAAW,MAAM,QAAQ;AAC3B,MAAAC,sBAAA,MAAM,MAAM,QAAQ,GAAG;AACvB,UAAM,eAAeD,0BAAA,qBAAqB,OAAO,UAAU,QAAQ;AACnE,cAAU,aAAa;AACvB,0BAAsB,aAAa;AAAA,EAAA,WAC5BC,sBAAAA,MAAM,OAAO,QAAQ,KAAK,SAAS,QAAQ,WAAW,GAAG;AAChE,UAAM,QAAQ,SAAS;AACvB,kBAAc,KAAK,IACf,cAAc,KAAK,KAAKF,wBAAA,MAAa,IAAI,KAAK,GAAG,KAAK,EAAE,EAAE,CAAC;AAC/D,UAAM,WAAWC,0BAAA;AAAA,MACb;AAAA,MACA,cAAc,KAAK;AAAA,MACnB;AAAA,IACJ;AACA,cAAU,SAAS;AACnB,0BAAsB,SAAS;AAAA,EAAA;AAG5B,SAAA;AAAA,IACH,MAAM;AAAA,MACF,eAAeE,wBAAI,IAAI;AAAA,MACvB,eAAeA,wBAAI,IAAI;AAAA,MACvB,WAAWA,wBAAI,IAAI;AAAA,IACvB;AAAA,IACA,cACI,0BACA,0BACA;AAAA,EACR;AACJ;AChDO,MAAM,SAA0B;AAAA,EACnC,MAAM,EAAE,eAA+B;AAAA,EACvC,YAAY,EAAE,eAA+B;AAAA,EAC7C,aAAa,EAAE,eAA+B;AAAA,EAC9C,gBAAgB,EAAE,WAAW,IAAI;AAAA,EACjC,WAAW,EAAE,WAAW,MAAM;AAAA,EAC9B,iBAAiB,EAAE,WAAW,MAAM;AAAA,EACpC,SAAS,EAAE,WAAW,QAAQ;AAAA,EAC9B,WAAW,EAAE,WAAW,QAAQ;AAAA,EAChC,eAAe,EAAE,WAAW,QAAQ;AAAA,EACpC,eAAe,EAAE,WAAW,QAAQ;AACxC;AAEO,MAAM,eAA8B;AAAA,EACvC,QAAQ,EAAE,WAAW,MAAM;AAC/B;;;"} \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-ctan/provides-BjJALsf_.cjs b/node_modules/@unified-latex/unified-latex-ctan/provides-BjJALsf_.cjs new file mode 100644 index 0000000..e4713f5 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-ctan/provides-BjJALsf_.cjs @@ -0,0 +1,50 @@ +"use strict"; +const unifiedLatexBuilder = require("@unified-latex/unified-latex-builder"); +const unifiedLatexUtilArgspec = require("@unified-latex/unified-latex-util-argspec"); +const unifiedLatexUtilArguments = require("@unified-latex/unified-latex-util-arguments"); +const unifiedLatexUtilMatch = require("@unified-latex/unified-latex-util-match"); +const argSpecM = unifiedLatexUtilArgspec.parse("m")[0]; +const argSpecO = unifiedLatexUtilArgspec.parse("o")[0]; +const argSpecRDelim = {}; +const argumentParser = (nodes, startPos) => { + const { argument: optionalArg, nodesRemoved: optionalArgNodesRemoved } = unifiedLatexUtilArguments.gobbleSingleArgument(nodes, argSpecO, startPos); + let codeArg = null; + let codeArgNodesRemoved = 0; + const nextNode = nodes[startPos]; + if (unifiedLatexUtilMatch.match.group(nextNode)) { + const mandatoryArg = unifiedLatexUtilArguments.gobbleSingleArgument(nodes, argSpecM, startPos); + codeArg = mandatoryArg.argument; + codeArgNodesRemoved = mandatoryArg.nodesRemoved; + } else if (unifiedLatexUtilMatch.match.string(nextNode) && nextNode.content.length === 1) { + const delim = nextNode.content; + argSpecRDelim[delim] = argSpecRDelim[delim] || unifiedLatexUtilArgspec.parse(`r${delim}${delim}`)[0]; + const delimArg = unifiedLatexUtilArguments.gobbleSingleArgument( + nodes, + argSpecRDelim[delim], + startPos + ); + codeArg = delimArg.argument; + codeArgNodesRemoved = delimArg.nodesRemoved; + } + return { + args: [optionalArg || unifiedLatexBuilder.arg(null), codeArg || unifiedLatexBuilder.arg(null)], + nodesRemoved: optionalArgNodesRemoved + codeArgNodesRemoved + }; +}; +const macros = { + lstset: { signature: "m" }, + lstinline: { argumentParser }, + lstinputlisting: { signature: "o m" }, + lstdefinestyle: { signature: "m m" }, + lstnewenvironment: { signature: "m o o m m" }, + lstMakeShortInline: { signature: "o m" }, + lstDeleteShortInline: { signature: "m" }, + lstdefineformat: { signature: "m m" }, + lstdefinelanguage: { signature: "o m o m o" }, + lstalias: { signature: "o m o m" }, + lstloadlanguages: { signature: "m" } +}; +const environments = {}; +exports.environments = environments; +exports.macros = macros; +//# sourceMappingURL=provides-BjJALsf_.cjs.map diff --git a/node_modules/@unified-latex/unified-latex-ctan/provides-BjJALsf_.cjs.map b/node_modules/@unified-latex/unified-latex-ctan/provides-BjJALsf_.cjs.map new file mode 100644 index 0000000..4920337 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-ctan/provides-BjJALsf_.cjs.map @@ -0,0 +1 @@ +{"version":3,"file":"provides-BjJALsf_.cjs","sources":["../package/listings/libs/argument-parser.ts","../package/listings/provides.ts"],"sourcesContent":["import { arg } from \"@unified-latex/unified-latex-builder\";\nimport { Argument, ArgumentParser } from \"@unified-latex/unified-latex-types\";\nimport { parse as parseArgspec } from \"@unified-latex/unified-latex-util-argspec\";\nimport { Node } from \"@unified-latex/unified-latex-util-argspec/libs/argspec-types\";\nimport { gobbleSingleArgument } from \"@unified-latex/unified-latex-util-arguments\";\nimport { match } from \"@unified-latex/unified-latex-util-match\";\n\nconst argSpecM = parseArgspec(\"m\")[0];\nconst argSpecO = parseArgspec(\"o\")[0];\nconst argSpecRDelim: { [delim: string]: Node } = {};\n\n/**\n * This argument parser parses arguments in the form of\n * - [⟨key=value list⟩]⟨character⟩⟨source code⟩⟨same character⟩\n * - [⟨key=value list⟩]{⟨source code⟩}\n */\nexport const argumentParser: ArgumentParser = (nodes, startPos) => {\n const { argument: optionalArg, nodesRemoved: optionalArgNodesRemoved } =\n gobbleSingleArgument(nodes, argSpecO, startPos);\n\n let codeArg: Argument | Argument[] | null = null;\n let codeArgNodesRemoved: number = 0;\n const nextNode = nodes[startPos];\n if (match.group(nextNode)) {\n const mandatoryArg = gobbleSingleArgument(nodes, argSpecM, startPos);\n codeArg = mandatoryArg.argument;\n codeArgNodesRemoved = mandatoryArg.nodesRemoved;\n } else if (match.string(nextNode) && nextNode.content.length === 1) {\n const delim = nextNode.content;\n argSpecRDelim[delim] =\n argSpecRDelim[delim] || parseArgspec(`r${delim}${delim}`)[0];\n const delimArg = gobbleSingleArgument(\n nodes,\n argSpecRDelim[delim],\n startPos\n );\n codeArg = delimArg.argument;\n codeArgNodesRemoved = delimArg.nodesRemoved;\n }\n\n return {\n args: [optionalArg || arg(null), codeArg || arg(null)],\n nodesRemoved: optionalArgNodesRemoved + codeArgNodesRemoved,\n };\n};\n","import {\n MacroInfoRecord,\n EnvInfoRecord,\n} from \"@unified-latex/unified-latex-types\";\nimport { argumentParser } from \"./libs/argument-parser\";\n\nexport const macros: MacroInfoRecord = {\n lstset: { signature: \"m\" },\n lstinline: { argumentParser: argumentParser },\n lstinputlisting: { signature: \"o m\" },\n lstdefinestyle: { signature: \"m m\" },\n lstnewenvironment: { signature: \"m o o m m\" },\n lstMakeShortInline: { signature: \"o m\" },\n lstDeleteShortInline: { signature: \"m\" },\n lstdefineformat: { signature: \"m m\" },\n lstdefinelanguage: { signature: \"o m o m o\" },\n lstalias: { signature: \"o m o m\" },\n lstloadlanguages: { signature: \"m\" },\n};\n\nexport const environments: EnvInfoRecord = {};\n"],"names":["parseArgspec","gobbleSingleArgument","match","arg"],"mappings":";;;;;AAOA,MAAM,WAAWA,wBAAA,MAAa,GAAG,EAAE,CAAC;AACpC,MAAM,WAAWA,wBAAA,MAAa,GAAG,EAAE,CAAC;AACpC,MAAM,gBAA2C,CAAC;AAOrC,MAAA,iBAAiC,CAAC,OAAO,aAAa;AACzD,QAAA,EAAE,UAAU,aAAa,cAAc,wBACzC,IAAAC,+CAAqB,OAAO,UAAU,QAAQ;AAElD,MAAI,UAAwC;AAC5C,MAAI,sBAA8B;AAC5B,QAAA,WAAW,MAAM,QAAQ;AAC3B,MAAAC,sBAAA,MAAM,MAAM,QAAQ,GAAG;AACvB,UAAM,eAAeD,0BAAA,qBAAqB,OAAO,UAAU,QAAQ;AACnE,cAAU,aAAa;AACvB,0BAAsB,aAAa;AAAA,EAAA,WAC5BC,sBAAAA,MAAM,OAAO,QAAQ,KAAK,SAAS,QAAQ,WAAW,GAAG;AAChE,UAAM,QAAQ,SAAS;AACvB,kBAAc,KAAK,IACf,cAAc,KAAK,KAAKF,wBAAA,MAAa,IAAI,KAAK,GAAG,KAAK,EAAE,EAAE,CAAC;AAC/D,UAAM,WAAWC,0BAAA;AAAA,MACb;AAAA,MACA,cAAc,KAAK;AAAA,MACnB;AAAA,IACJ;AACA,cAAU,SAAS;AACnB,0BAAsB,SAAS;AAAA,EAAA;AAG5B,SAAA;AAAA,IACH,MAAM,CAAC,eAAeE,wBAAI,IAAI,GAAG,WAAWA,oBAAAA,IAAI,IAAI,CAAC;AAAA,IACrD,cAAc,0BAA0B;AAAA,EAC5C;AACJ;ACtCO,MAAM,SAA0B;AAAA,EACnC,QAAQ,EAAE,WAAW,IAAI;AAAA,EACzB,WAAW,EAAE,eAA+B;AAAA,EAC5C,iBAAiB,EAAE,WAAW,MAAM;AAAA,EACpC,gBAAgB,EAAE,WAAW,MAAM;AAAA,EACnC,mBAAmB,EAAE,WAAW,YAAY;AAAA,EAC5C,oBAAoB,EAAE,WAAW,MAAM;AAAA,EACvC,sBAAsB,EAAE,WAAW,IAAI;AAAA,EACvC,iBAAiB,EAAE,WAAW,MAAM;AAAA,EACpC,mBAAmB,EAAE,WAAW,YAAY;AAAA,EAC5C,UAAU,EAAE,WAAW,UAAU;AAAA,EACjC,kBAAkB,EAAE,WAAW,IAAI;AACvC;AAEO,MAAM,eAA8B,CAAA;;;"} \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-ctan/provides-Ch0mvkO_.js b/node_modules/@unified-latex/unified-latex-ctan/provides-Ch0mvkO_.js new file mode 100644 index 0000000..2da9d9a --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-ctan/provides-Ch0mvkO_.js @@ -0,0 +1,51 @@ +import { arg } from "@unified-latex/unified-latex-builder"; +import { parse } from "@unified-latex/unified-latex-util-argspec"; +import { gobbleSingleArgument } from "@unified-latex/unified-latex-util-arguments"; +import { match } from "@unified-latex/unified-latex-util-match"; +const argSpecM = parse("m")[0]; +const argSpecO = parse("o")[0]; +const argSpecRDelim = {}; +const argumentParser = (nodes, startPos) => { + const { argument: optionalArg, nodesRemoved: optionalArgNodesRemoved } = gobbleSingleArgument(nodes, argSpecO, startPos); + let codeArg = null; + let codeArgNodesRemoved = 0; + const nextNode = nodes[startPos]; + if (match.group(nextNode)) { + const mandatoryArg = gobbleSingleArgument(nodes, argSpecM, startPos); + codeArg = mandatoryArg.argument; + codeArgNodesRemoved = mandatoryArg.nodesRemoved; + } else if (match.string(nextNode) && nextNode.content.length === 1) { + const delim = nextNode.content; + argSpecRDelim[delim] = argSpecRDelim[delim] || parse(`r${delim}${delim}`)[0]; + const delimArg = gobbleSingleArgument( + nodes, + argSpecRDelim[delim], + startPos + ); + codeArg = delimArg.argument; + codeArgNodesRemoved = delimArg.nodesRemoved; + } + return { + args: [optionalArg || arg(null), codeArg || arg(null)], + nodesRemoved: optionalArgNodesRemoved + codeArgNodesRemoved + }; +}; +const macros = { + lstset: { signature: "m" }, + lstinline: { argumentParser }, + lstinputlisting: { signature: "o m" }, + lstdefinestyle: { signature: "m m" }, + lstnewenvironment: { signature: "m o o m m" }, + lstMakeShortInline: { signature: "o m" }, + lstDeleteShortInline: { signature: "m" }, + lstdefineformat: { signature: "m m" }, + lstdefinelanguage: { signature: "o m o m o" }, + lstalias: { signature: "o m o m" }, + lstloadlanguages: { signature: "m" } +}; +const environments = {}; +export { + environments as e, + macros as m +}; +//# sourceMappingURL=provides-Ch0mvkO_.js.map diff --git a/node_modules/@unified-latex/unified-latex-ctan/provides-Ch0mvkO_.js.map b/node_modules/@unified-latex/unified-latex-ctan/provides-Ch0mvkO_.js.map new file mode 100644 index 0000000..0368d19 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-ctan/provides-Ch0mvkO_.js.map @@ -0,0 +1 @@ +{"version":3,"file":"provides-Ch0mvkO_.js","sources":["../package/listings/libs/argument-parser.ts","../package/listings/provides.ts"],"sourcesContent":["import { arg } from \"@unified-latex/unified-latex-builder\";\nimport { Argument, ArgumentParser } from \"@unified-latex/unified-latex-types\";\nimport { parse as parseArgspec } from \"@unified-latex/unified-latex-util-argspec\";\nimport { Node } from \"@unified-latex/unified-latex-util-argspec/libs/argspec-types\";\nimport { gobbleSingleArgument } from \"@unified-latex/unified-latex-util-arguments\";\nimport { match } from \"@unified-latex/unified-latex-util-match\";\n\nconst argSpecM = parseArgspec(\"m\")[0];\nconst argSpecO = parseArgspec(\"o\")[0];\nconst argSpecRDelim: { [delim: string]: Node } = {};\n\n/**\n * This argument parser parses arguments in the form of\n * - [⟨key=value list⟩]⟨character⟩⟨source code⟩⟨same character⟩\n * - [⟨key=value list⟩]{⟨source code⟩}\n */\nexport const argumentParser: ArgumentParser = (nodes, startPos) => {\n const { argument: optionalArg, nodesRemoved: optionalArgNodesRemoved } =\n gobbleSingleArgument(nodes, argSpecO, startPos);\n\n let codeArg: Argument | Argument[] | null = null;\n let codeArgNodesRemoved: number = 0;\n const nextNode = nodes[startPos];\n if (match.group(nextNode)) {\n const mandatoryArg = gobbleSingleArgument(nodes, argSpecM, startPos);\n codeArg = mandatoryArg.argument;\n codeArgNodesRemoved = mandatoryArg.nodesRemoved;\n } else if (match.string(nextNode) && nextNode.content.length === 1) {\n const delim = nextNode.content;\n argSpecRDelim[delim] =\n argSpecRDelim[delim] || parseArgspec(`r${delim}${delim}`)[0];\n const delimArg = gobbleSingleArgument(\n nodes,\n argSpecRDelim[delim],\n startPos\n );\n codeArg = delimArg.argument;\n codeArgNodesRemoved = delimArg.nodesRemoved;\n }\n\n return {\n args: [optionalArg || arg(null), codeArg || arg(null)],\n nodesRemoved: optionalArgNodesRemoved + codeArgNodesRemoved,\n };\n};\n","import {\n MacroInfoRecord,\n EnvInfoRecord,\n} from \"@unified-latex/unified-latex-types\";\nimport { argumentParser } from \"./libs/argument-parser\";\n\nexport const macros: MacroInfoRecord = {\n lstset: { signature: \"m\" },\n lstinline: { argumentParser: argumentParser },\n lstinputlisting: { signature: \"o m\" },\n lstdefinestyle: { signature: \"m m\" },\n lstnewenvironment: { signature: \"m o o m m\" },\n lstMakeShortInline: { signature: \"o m\" },\n lstDeleteShortInline: { signature: \"m\" },\n lstdefineformat: { signature: \"m m\" },\n lstdefinelanguage: { signature: \"o m o m o\" },\n lstalias: { signature: \"o m o m\" },\n lstloadlanguages: { signature: \"m\" },\n};\n\nexport const environments: EnvInfoRecord = {};\n"],"names":["parseArgspec"],"mappings":";;;;AAOA,MAAM,WAAWA,MAAa,GAAG,EAAE,CAAC;AACpC,MAAM,WAAWA,MAAa,GAAG,EAAE,CAAC;AACpC,MAAM,gBAA2C,CAAC;AAOrC,MAAA,iBAAiC,CAAC,OAAO,aAAa;AACzD,QAAA,EAAE,UAAU,aAAa,cAAc,wBACzC,IAAA,qBAAqB,OAAO,UAAU,QAAQ;AAElD,MAAI,UAAwC;AAC5C,MAAI,sBAA8B;AAC5B,QAAA,WAAW,MAAM,QAAQ;AAC3B,MAAA,MAAM,MAAM,QAAQ,GAAG;AACvB,UAAM,eAAe,qBAAqB,OAAO,UAAU,QAAQ;AACnE,cAAU,aAAa;AACvB,0BAAsB,aAAa;AAAA,EAAA,WAC5B,MAAM,OAAO,QAAQ,KAAK,SAAS,QAAQ,WAAW,GAAG;AAChE,UAAM,QAAQ,SAAS;AACvB,kBAAc,KAAK,IACf,cAAc,KAAK,KAAKA,MAAa,IAAI,KAAK,GAAG,KAAK,EAAE,EAAE,CAAC;AAC/D,UAAM,WAAW;AAAA,MACb;AAAA,MACA,cAAc,KAAK;AAAA,MACnB;AAAA,IACJ;AACA,cAAU,SAAS;AACnB,0BAAsB,SAAS;AAAA,EAAA;AAG5B,SAAA;AAAA,IACH,MAAM,CAAC,eAAe,IAAI,IAAI,GAAG,WAAW,IAAI,IAAI,CAAC;AAAA,IACrD,cAAc,0BAA0B;AAAA,EAC5C;AACJ;ACtCO,MAAM,SAA0B;AAAA,EACnC,QAAQ,EAAE,WAAW,IAAI;AAAA,EACzB,WAAW,EAAE,eAA+B;AAAA,EAC5C,iBAAiB,EAAE,WAAW,MAAM;AAAA,EACpC,gBAAgB,EAAE,WAAW,MAAM;AAAA,EACnC,mBAAmB,EAAE,WAAW,YAAY;AAAA,EAC5C,oBAAoB,EAAE,WAAW,MAAM;AAAA,EACvC,sBAAsB,EAAE,WAAW,IAAI;AAAA,EACvC,iBAAiB,EAAE,WAAW,MAAM;AAAA,EACpC,mBAAmB,EAAE,WAAW,YAAY;AAAA,EAC5C,UAAU,EAAE,WAAW,UAAU;AAAA,EACjC,kBAAkB,EAAE,WAAW,IAAI;AACvC;AAEO,MAAM,eAA8B,CAAA;"} \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-ctan/provides-CwtnTL9q.cjs b/node_modules/@unified-latex/unified-latex-ctan/provides-CwtnTL9q.cjs new file mode 100644 index 0000000..466e261 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-ctan/provides-CwtnTL9q.cjs @@ -0,0 +1,26 @@ +"use strict"; +const macros = { + systeme: { + signature: "s o o m", + renderInfo: { inMathMode: true } + }, + sysdelim: { + signature: "m m" + }, + syseqsep: { signature: "m" }, + sysalign: { signature: "m" }, + syssignspace: { signature: "m" }, + syseqspace: { signature: "m" }, + syslineskipcoeff: { signature: "m" }, + syseqivsign: { signature: "m" }, + sysaddeqsign: { signature: "m" }, + sysremoveeqsign: { signature: "m" }, + sysextracolonsign: { signature: "m" }, + syscodeextracol: { signature: "m" }, + sysautonum: { signature: "m" }, + syssubstitute: { signature: "m" } +}; +const environments = {}; +exports.environments = environments; +exports.macros = macros; +//# sourceMappingURL=provides-CwtnTL9q.cjs.map diff --git a/node_modules/@unified-latex/unified-latex-ctan/provides-CwtnTL9q.cjs.map b/node_modules/@unified-latex/unified-latex-ctan/provides-CwtnTL9q.cjs.map new file mode 100644 index 0000000..877fcb1 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-ctan/provides-CwtnTL9q.cjs.map @@ -0,0 +1 @@ +{"version":3,"file":"provides-CwtnTL9q.cjs","sources":["../package/systeme/provides.ts"],"sourcesContent":["import {\n MacroInfoRecord,\n EnvInfoRecord,\n} from \"@unified-latex/unified-latex-types\";\n\nexport const macros: MacroInfoRecord = {\n systeme: {\n signature: \"s o o m\",\n renderInfo: { inMathMode: true },\n },\n sysdelim: {\n signature: \"m m\",\n },\n syseqsep: { signature: \"m\" },\n sysalign: { signature: \"m\" },\n syssignspace: { signature: \"m\" },\n syseqspace: { signature: \"m\" },\n syslineskipcoeff: { signature: \"m\" },\n syseqivsign: { signature: \"m\" },\n sysaddeqsign: { signature: \"m\" },\n sysremoveeqsign: { signature: \"m\" },\n sysextracolonsign: { signature: \"m\" },\n syscodeextracol: { signature: \"m\" },\n sysautonum: { signature: \"m\" },\n syssubstitute: { signature: \"m\" },\n};\n\nexport const environments: EnvInfoRecord = {};\n"],"names":[],"mappings":";AAKO,MAAM,SAA0B;AAAA,EACnC,SAAS;AAAA,IACL,WAAW;AAAA,IACX,YAAY,EAAE,YAAY,KAAK;AAAA,EACnC;AAAA,EACA,UAAU;AAAA,IACN,WAAW;AAAA,EACf;AAAA,EACA,UAAU,EAAE,WAAW,IAAI;AAAA,EAC3B,UAAU,EAAE,WAAW,IAAI;AAAA,EAC3B,cAAc,EAAE,WAAW,IAAI;AAAA,EAC/B,YAAY,EAAE,WAAW,IAAI;AAAA,EAC7B,kBAAkB,EAAE,WAAW,IAAI;AAAA,EACnC,aAAa,EAAE,WAAW,IAAI;AAAA,EAC9B,cAAc,EAAE,WAAW,IAAI;AAAA,EAC/B,iBAAiB,EAAE,WAAW,IAAI;AAAA,EAClC,mBAAmB,EAAE,WAAW,IAAI;AAAA,EACpC,iBAAiB,EAAE,WAAW,IAAI;AAAA,EAClC,YAAY,EAAE,WAAW,IAAI;AAAA,EAC7B,eAAe,EAAE,WAAW,IAAI;AACpC;AAEO,MAAM,eAA8B,CAAA;;;"} \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-ctan/provides-DdQzqlsT.cjs b/node_modules/@unified-latex/unified-latex-ctan/provides-DdQzqlsT.cjs new file mode 100644 index 0000000..ec95142 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-ctan/provides-DdQzqlsT.cjs @@ -0,0 +1,345 @@ +"use strict"; +const unifiedLatexUtilTrim = require("@unified-latex/unified-latex-util-trim"); +const enumerate = require("./enumerate-DSh8p1uS.cjs"); +const macros = { + // Special + "\\": { signature: "!s !o", renderInfo: { breakAfter: true } }, + _: { signature: "m", escapeToken: "" }, + "^": { signature: "m", escapeToken: "" }, + // \newcommand arg signature from https://www.texdev.net/2020/08/19/the-good-the-bad-and-the-ugly-creating-document-commands + // List can be found in latex2e.pdf "An unofficial reference manual" + newcommand: { + signature: "s +m o +o +m", + renderInfo: { + breakAround: true, + namedArguments: ["starred", "name", "numArgs", "default", "body"] + } + }, + renewcommand: { + signature: "s +m o +o +m", + renderInfo: { + breakAround: true, + namedArguments: ["starred", "name", "numArgs", "default", "body"] + } + }, + providecommand: { + signature: "s +m o +o +m", + renderInfo: { breakAround: true } + }, + // Counters + newcounter: { + signature: "m o", + renderInfo: { breakAround: true } + }, + usecounter: { + signature: "m" + }, + setcounter: { + signature: "m m", + renderInfo: { breakAround: true } + }, + addtocounter: { + signature: "m m", + renderInfo: { breakAround: true } + }, + stepcounter: { + signature: "m", + renderInfo: { breakAround: true } + }, + refstepcounter: { + signature: "m", + renderInfo: { breakAround: true } + }, + // Lengths + newlength: { + signature: "m", + renderInfo: { breakAround: true } + }, + addtolength: { + signature: "m m", + renderInfo: { breakAround: true } + }, + settodepth: { + signature: "m m", + renderInfo: { breakAround: true } + }, + settoheight: { + signature: "m m", + renderInfo: { breakAround: true } + }, + settowidth: { + signature: "m m", + renderInfo: { breakAround: true } + }, + // Spaces + stretch: { signature: "m" }, + hspace: { signature: "s m" }, + vspace: { signature: "s m", renderInfo: { breakAround: true } }, + vfill: { renderInfo: { breakAround: true } }, + indent: { renderInfo: { breakAround: true } }, + phantom: { signature: "m" }, + vphantom: { signature: "m" }, + hphantom: { signature: "m" }, + noindent: { renderInfo: { breakAround: true } }, + smallskip: { renderInfo: { breakAround: true } }, + medskip: { renderInfo: { breakAround: true } }, + bigskip: { renderInfo: { breakAround: true } }, + smallbreak: { renderInfo: { breakAround: true } }, + medbreak: { renderInfo: { breakAround: true } }, + bigbreak: { renderInfo: { breakAround: true } }, + newline: { renderInfo: { breakAround: true } }, + linebreak: { signature: "o", renderInfo: { breakAround: true } }, + nolinebreak: { signature: "o", renderInfo: { breakAround: true } }, + clearpage: { renderInfo: { breakAround: true } }, + cleardoublepage: { renderInfo: { breakAround: true } }, + newpage: { renderInfo: { breakAround: true } }, + enlargethispage: { signature: "s", renderInfo: { breakAround: true } }, + pagebreak: { signature: "o", renderInfo: { breakAround: true } }, + nopagebreak: { signature: "o", renderInfo: { breakAround: true } }, + // Boxes + newsavebox: { + signature: "m", + renderInfo: { breakAround: true } + }, + sbox: { + signature: "m m", + renderInfo: { breakAround: true } + }, + savebox: { + signature: "m o o m", + renderInfo: { breakAround: true } + }, + mbox: { signature: "m" }, + makebox: { signature: "d() o o m", renderInfo: { breakAround: true } }, + fbox: { signature: "m" }, + framebox: { signature: "o o m", renderInfo: { breakAround: true } }, + frame: { signature: "m", renderInfo: { breakAround: true } }, + parbox: { signature: "o o o m m", renderInfo: { breakAround: true } }, + raisebox: { signature: "m o o m" }, + marginpar: { signature: "o m", renderInfo: { breakAround: true } }, + colorbox: { signature: "o m m", renderInfo: { breakAround: true } }, + fcolorbox: { signature: "o m m", renderInfo: { breakAround: true } }, + rotatebox: { signature: "o m m" }, + scalebox: { signature: "m o m" }, + reflectbox: { signature: "m" }, + resizebox: { signature: "s m m m" }, + // Define environments + newenvironment: { + signature: "s m o o m m", + renderInfo: { breakAround: true } + }, + renewenvironment: { + signature: "s m o o m m", + renderInfo: { breakAround: true } + }, + newtheorem: { + signature: "s m o m o", + renderInfo: { breakAround: true } + }, + newfont: { + signature: "m m", + renderInfo: { breakAround: true } + }, + // Counters + alph: { signature: "m" }, + Alph: { signature: "m" }, + arabic: { signature: "m" }, + roman: { signature: "m" }, + Roman: { signature: "m" }, + fnsymbol: { signature: "m" }, + // Other + documentclass: { + signature: "o m", + renderInfo: { breakAround: true, pgfkeysArgs: true } + }, + usepackage: { + signature: "o m", + renderInfo: { breakAround: true, pgfkeysArgs: true } + }, + item: { + signature: "o", + renderInfo: { hangingIndent: true, namedArguments: ["label"] } + }, + value: { signature: "m" }, + centering: { renderInfo: { breakAround: true } }, + input: { signature: "m", renderInfo: { breakAround: true } }, + include: { signature: "m", renderInfo: { breakAround: true } }, + includeonly: { + signature: "m", + renderInfo: { breakAround: true, pgfkeysArgs: true } + }, + discretionary: { signature: "m m m" }, + hyphenation: { signature: "m" }, + footnote: { signature: "o m", renderInfo: { inParMode: true } }, + footnotemark: { signature: "o" }, + footnotetext: { signature: "o m", renderInfo: { inParMode: true } }, + caption: { + signature: "o m", + renderInfo: { inParMode: true, breakAround: true } + }, + // Math Commands + sqrt: { signature: "o m", renderInfo: { inMathMode: true } }, + frac: { signature: "m m", renderInfo: { inMathMode: true } }, + stackrel: { signature: "m m" }, + ensuremath: { signature: "m", renderInfo: { inMathMode: true } }, + // Layout commands + abstract: { + signature: "m", + renderInfo: { breakAround: true, inParMode: true } + }, + maketitle: { renderInfo: { breakAround: true } }, + doublespacing: { renderInfo: { breakAround: true } }, + singlespacing: { renderInfo: { breakAround: true } }, + date: { signature: "o m", renderInfo: { breakAround: true } }, + thanks: { + signature: "m", + renderInfo: { breakAround: true, inParMode: true } + }, + pagenumbering: { signature: "m", renderInfo: { breakAround: true } }, + pagestyle: { signature: "m", renderInfo: { breakAround: true } }, + thispagestyle: { signature: "m", renderInfo: { breakAround: true } }, + // Colors + definecolor: { signature: "m m m", renderInfo: { breakAround: true } }, + pagecolor: { signature: "o m", renderInfo: { breakAround: true } }, + nopagecolor: { renderInfo: { breakAround: true } }, + multicolumn: { signature: "m m m" }, + // Graphics + includegraphics: { + signature: "s o o m", + renderInfo: { breakAround: true, pgfkeysArgs: true } + }, + rule: { signature: "o m m" }, + // Sectioning + part: { + signature: "s o m", + renderInfo: { + breakAround: true, + inParMode: true, + namedArguments: ["starred", "tocTitle", "title"] + } + }, + chapter: { + signature: "s o m", + renderInfo: { + breakAround: true, + inParMode: true, + namedArguments: ["starred", "tocTitle", "title"] + } + }, + section: { + signature: "s o m", + renderInfo: { + breakAround: true, + inParMode: true, + namedArguments: ["starred", "tocTitle", "title"] + } + }, + subsection: { + signature: "s o m", + renderInfo: { + breakAround: true, + inParMode: true, + namedArguments: ["starred", "tocTitle", "title"] + } + }, + subsubsection: { + signature: "s o m", + renderInfo: { + breakAround: true, + inParMode: true, + namedArguments: ["starred", "tocTitle", "title"] + } + }, + paragraph: { + signature: "s o m", + renderInfo: { + breakAround: true, + inParMode: true, + namedArguments: ["starred", "tocTitle", "title"] + } + }, + subparagraph: { + signature: "s o m", + renderInfo: { + breakAround: true, + inParMode: true, + namedArguments: ["starred", "tocTitle", "title"] + } + }, + appendix: { renderInfo: { breakAround: true, inParMode: true } }, + frontmatter: { renderInfo: { breakAround: true, inParMode: true } }, + mainmatter: { renderInfo: { breakAround: true, inParMode: true } }, + backmatter: { renderInfo: { breakAround: true, inParMode: true } }, + // Citing and references + bibitem: { signature: "o m", renderInfo: { hangingIndent: true } }, + cite: { signature: "o m" }, + // Fonts + textrm: { signature: "m", renderInfo: { inParMode: true } }, + textit: { signature: "m", renderInfo: { inParMode: true } }, + textmd: { signature: "m", renderInfo: { inParMode: true } }, + textbf: { signature: "m", renderInfo: { inParMode: true } }, + textup: { signature: "m", renderInfo: { inParMode: true } }, + textsl: { signature: "m", renderInfo: { inParMode: true } }, + textsf: { signature: "m", renderInfo: { inParMode: true } }, + textsc: { signature: "m", renderInfo: { inParMode: true } }, + texttt: { signature: "m", renderInfo: { inParMode: true } }, + underline: { signature: "m", renderInfo: { inParMode: true } }, + emph: { signature: "m", renderInfo: { inParMode: true } }, + textnormal: { signature: "m", renderInfo: { inParMode: true } }, + uppercase: { signature: "m", renderInfo: { inParMode: true } }, + mathbf: { signature: "m" }, + mathsf: { signature: "m" }, + mathtt: { signature: "m" }, + mathit: { signature: "m" }, + mathnormal: { signature: "m" }, + mathcal: { signature: "m" }, + mathrm: { signature: "m" }, + // Other + setlength: { signature: "m m", renderInfo: { breakAround: true } }, + ref: { signature: "s m" }, + label: { signature: "o m" }, + // cleveref changes \label to have this signature + printbibliography: { renderInfo: { breakAround: true } }, + addtocontents: { signature: "m m", renderInfo: { breakAround: true } }, + addcontentsline: { signature: "m m m", renderInfo: { breakAround: true } }, + contentsline: { signature: "m m m", renderInfo: { breakAround: true } }, + bibliography: { signature: "m", renderInfo: { breakAround: true } }, + bibliographystyle: { signature: "m", renderInfo: { breakAround: true } } +}; +const environments = { + document: { + processContent: (nodes) => { + unifiedLatexUtilTrim.trim(nodes); + return nodes; + } + }, + array: { signature: "o m", renderInfo: { alignContent: true } }, + description: { signature: "o", processContent: enumerate.cleanEnumerateBody }, + enumerate: { + signature: "o", + processContent: enumerate.cleanEnumerateBody, + renderInfo: { pgfkeysArgs: true } + }, + itemize: { signature: "o", processContent: enumerate.cleanEnumerateBody }, + trivlist: { signature: "o", processContent: enumerate.cleanEnumerateBody }, + list: { signature: "m m", processContent: enumerate.cleanEnumerateBody }, + figure: { signature: "o" }, + "figure*": { signature: "o" }, + filecontents: { signature: "o m" }, + "filecontents*": { signature: "o m" }, + minipage: { signature: "o o o m" }, + picture: { signature: "r() d()" }, + tabbing: { renderInfo: { alignContent: true } }, + table: { signature: "o" }, + tabular: { signature: "o m", renderInfo: { alignContent: true } }, + "tabular*": { signature: "m o m", renderInfo: { alignContent: true } }, + thebibliography: { + signature: "m", + processContent: (nodes) => enumerate.cleanEnumerateBody(nodes, "bibitem") + }, + // Math + math: { renderInfo: { inMathMode: true } } +}; +exports.environments = environments; +exports.macros = macros; +//# sourceMappingURL=provides-DdQzqlsT.cjs.map diff --git a/node_modules/@unified-latex/unified-latex-ctan/provides-DdQzqlsT.cjs.map b/node_modules/@unified-latex/unified-latex-ctan/provides-DdQzqlsT.cjs.map new file mode 100644 index 0000000..128d975 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-ctan/provides-DdQzqlsT.cjs.map @@ -0,0 +1 @@ +{"version":3,"file":"provides-DdQzqlsT.cjs","sources":["../package/latex2e/provides.ts"],"sourcesContent":["import {\n MacroInfoRecord,\n EnvInfoRecord,\n} from \"@unified-latex/unified-latex-types\";\nimport { trim } from \"@unified-latex/unified-latex-util-trim\";\nimport { cleanEnumerateBody } from \"../../utils/enumerate\";\n\nexport const macros: MacroInfoRecord = {\n // Special\n \"\\\\\": { signature: \"!s !o\", renderInfo: { breakAfter: true } },\n _: { signature: \"m\", escapeToken: \"\" },\n \"^\": { signature: \"m\", escapeToken: \"\" },\n // \\newcommand arg signature from https://www.texdev.net/2020/08/19/the-good-the-bad-and-the-ugly-creating-document-commands\n // List can be found in latex2e.pdf \"An unofficial reference manual\"\n newcommand: {\n signature: \"s +m o +o +m\",\n renderInfo: {\n breakAround: true,\n namedArguments: [\"starred\", \"name\", \"numArgs\", \"default\", \"body\"],\n },\n },\n renewcommand: {\n signature: \"s +m o +o +m\",\n renderInfo: {\n breakAround: true,\n namedArguments: [\"starred\", \"name\", \"numArgs\", \"default\", \"body\"],\n },\n },\n providecommand: {\n signature: \"s +m o +o +m\",\n renderInfo: { breakAround: true },\n },\n // Counters\n newcounter: {\n signature: \"m o\",\n renderInfo: { breakAround: true },\n },\n usecounter: {\n signature: \"m\",\n },\n setcounter: {\n signature: \"m m\",\n renderInfo: { breakAround: true },\n },\n addtocounter: {\n signature: \"m m\",\n renderInfo: { breakAround: true },\n },\n stepcounter: {\n signature: \"m\",\n renderInfo: { breakAround: true },\n },\n refstepcounter: {\n signature: \"m\",\n renderInfo: { breakAround: true },\n },\n // Lengths\n newlength: {\n signature: \"m\",\n renderInfo: { breakAround: true },\n },\n addtolength: {\n signature: \"m m\",\n renderInfo: { breakAround: true },\n },\n settodepth: {\n signature: \"m m\",\n renderInfo: { breakAround: true },\n },\n settoheight: {\n signature: \"m m\",\n renderInfo: { breakAround: true },\n },\n settowidth: {\n signature: \"m m\",\n renderInfo: { breakAround: true },\n },\n // Spaces\n stretch: { signature: \"m\" },\n hspace: { signature: \"s m\" },\n vspace: { signature: \"s m\", renderInfo: { breakAround: true } },\n vfill: { renderInfo: { breakAround: true } },\n indent: { renderInfo: { breakAround: true } },\n phantom: { signature: \"m\" },\n vphantom: { signature: \"m\" },\n hphantom: { signature: \"m\" },\n noindent: { renderInfo: { breakAround: true } },\n smallskip: { renderInfo: { breakAround: true } },\n medskip: { renderInfo: { breakAround: true } },\n bigskip: { renderInfo: { breakAround: true } },\n smallbreak: { renderInfo: { breakAround: true } },\n medbreak: { renderInfo: { breakAround: true } },\n bigbreak: { renderInfo: { breakAround: true } },\n newline: { renderInfo: { breakAround: true } },\n linebreak: { signature: \"o\", renderInfo: { breakAround: true } },\n nolinebreak: { signature: \"o\", renderInfo: { breakAround: true } },\n clearpage: { renderInfo: { breakAround: true } },\n cleardoublepage: { renderInfo: { breakAround: true } },\n newpage: { renderInfo: { breakAround: true } },\n enlargethispage: { signature: \"s\", renderInfo: { breakAround: true } },\n pagebreak: { signature: \"o\", renderInfo: { breakAround: true } },\n nopagebreak: { signature: \"o\", renderInfo: { breakAround: true } },\n // Boxes\n newsavebox: {\n signature: \"m\",\n renderInfo: { breakAround: true },\n },\n sbox: {\n signature: \"m m\",\n renderInfo: { breakAround: true },\n },\n savebox: {\n signature: \"m o o m\",\n renderInfo: { breakAround: true },\n },\n mbox: { signature: \"m\" },\n makebox: { signature: \"d() o o m\", renderInfo: { breakAround: true } },\n fbox: { signature: \"m\" },\n framebox: { signature: \"o o m\", renderInfo: { breakAround: true } },\n frame: { signature: \"m\", renderInfo: { breakAround: true } },\n parbox: { signature: \"o o o m m\", renderInfo: { breakAround: true } },\n raisebox: { signature: \"m o o m\" },\n marginpar: { signature: \"o m\", renderInfo: { breakAround: true } },\n colorbox: { signature: \"o m m\", renderInfo: { breakAround: true } },\n fcolorbox: { signature: \"o m m\", renderInfo: { breakAround: true } },\n rotatebox: { signature: \"o m m\" },\n scalebox: { signature: \"m o m\" },\n reflectbox: { signature: \"m\" },\n resizebox: { signature: \"s m m m\" },\n // Define environments\n newenvironment: {\n signature: \"s m o o m m\",\n renderInfo: { breakAround: true },\n },\n renewenvironment: {\n signature: \"s m o o m m\",\n renderInfo: { breakAround: true },\n },\n newtheorem: {\n signature: \"s m o m o\",\n renderInfo: { breakAround: true },\n },\n newfont: {\n signature: \"m m\",\n renderInfo: { breakAround: true },\n },\n // Counters\n alph: { signature: \"m\" },\n Alph: { signature: \"m\" },\n arabic: { signature: \"m\" },\n roman: { signature: \"m\" },\n Roman: { signature: \"m\" },\n fnsymbol: { signature: \"m\" },\n // Other\n documentclass: {\n signature: \"o m\",\n renderInfo: { breakAround: true, pgfkeysArgs: true },\n },\n usepackage: {\n signature: \"o m\",\n renderInfo: { breakAround: true, pgfkeysArgs: true },\n },\n item: {\n signature: \"o\",\n renderInfo: { hangingIndent: true, namedArguments: [\"label\"] },\n },\n value: { signature: \"m\" },\n centering: { renderInfo: { breakAround: true } },\n input: { signature: \"m\", renderInfo: { breakAround: true } },\n include: { signature: \"m\", renderInfo: { breakAround: true } },\n includeonly: {\n signature: \"m\",\n renderInfo: { breakAround: true, pgfkeysArgs: true },\n },\n discretionary: { signature: \"m m m\" },\n hyphenation: { signature: \"m\" },\n footnote: { signature: \"o m\", renderInfo: { inParMode: true } },\n footnotemark: { signature: \"o\" },\n footnotetext: { signature: \"o m\", renderInfo: { inParMode: true } },\n caption: {\n signature: \"o m\",\n renderInfo: { inParMode: true, breakAround: true },\n },\n // Math Commands\n sqrt: { signature: \"o m\", renderInfo: { inMathMode: true } },\n frac: { signature: \"m m\", renderInfo: { inMathMode: true } },\n stackrel: { signature: \"m m\" },\n ensuremath: { signature: \"m\", renderInfo: { inMathMode: true } },\n // Layout commands\n abstract: {\n signature: \"m\",\n renderInfo: { breakAround: true, inParMode: true },\n },\n maketitle: { renderInfo: { breakAround: true } },\n doublespacing: { renderInfo: { breakAround: true } },\n singlespacing: { renderInfo: { breakAround: true } },\n date: { signature: \"o m\", renderInfo: { breakAround: true } },\n thanks: {\n signature: \"m\",\n renderInfo: { breakAround: true, inParMode: true },\n },\n pagenumbering: { signature: \"m\", renderInfo: { breakAround: true } },\n pagestyle: { signature: \"m\", renderInfo: { breakAround: true } },\n thispagestyle: { signature: \"m\", renderInfo: { breakAround: true } },\n // Colors\n definecolor: { signature: \"m m m\", renderInfo: { breakAround: true } },\n pagecolor: { signature: \"o m\", renderInfo: { breakAround: true } },\n nopagecolor: { renderInfo: { breakAround: true } },\n multicolumn: { signature: \"m m m\" },\n // Graphics\n includegraphics: {\n signature: \"s o o m\",\n renderInfo: { breakAround: true, pgfkeysArgs: true },\n },\n rule: { signature: \"o m m\" },\n // Sectioning\n part: {\n signature: \"s o m\",\n renderInfo: {\n breakAround: true,\n inParMode: true,\n namedArguments: [\"starred\", \"tocTitle\", \"title\"],\n },\n },\n chapter: {\n signature: \"s o m\",\n renderInfo: {\n breakAround: true,\n inParMode: true,\n namedArguments: [\"starred\", \"tocTitle\", \"title\"],\n },\n },\n section: {\n signature: \"s o m\",\n renderInfo: {\n breakAround: true,\n inParMode: true,\n namedArguments: [\"starred\", \"tocTitle\", \"title\"],\n },\n },\n subsection: {\n signature: \"s o m\",\n renderInfo: {\n breakAround: true,\n inParMode: true,\n namedArguments: [\"starred\", \"tocTitle\", \"title\"],\n },\n },\n subsubsection: {\n signature: \"s o m\",\n renderInfo: {\n breakAround: true,\n inParMode: true,\n namedArguments: [\"starred\", \"tocTitle\", \"title\"],\n },\n },\n paragraph: {\n signature: \"s o m\",\n renderInfo: {\n breakAround: true,\n inParMode: true,\n namedArguments: [\"starred\", \"tocTitle\", \"title\"],\n },\n },\n subparagraph: {\n signature: \"s o m\",\n renderInfo: {\n breakAround: true,\n inParMode: true,\n namedArguments: [\"starred\", \"tocTitle\", \"title\"],\n },\n },\n appendix: { renderInfo: { breakAround: true, inParMode: true } },\n frontmatter: { renderInfo: { breakAround: true, inParMode: true } },\n mainmatter: { renderInfo: { breakAround: true, inParMode: true } },\n backmatter: { renderInfo: { breakAround: true, inParMode: true } },\n // Citing and references\n bibitem: { signature: \"o m\", renderInfo: { hangingIndent: true } },\n cite: { signature: \"o m\" },\n // Fonts\n textrm: { signature: \"m\", renderInfo: { inParMode: true } },\n textit: { signature: \"m\", renderInfo: { inParMode: true } },\n textmd: { signature: \"m\", renderInfo: { inParMode: true } },\n textbf: { signature: \"m\", renderInfo: { inParMode: true } },\n textup: { signature: \"m\", renderInfo: { inParMode: true } },\n textsl: { signature: \"m\", renderInfo: { inParMode: true } },\n textsf: { signature: \"m\", renderInfo: { inParMode: true } },\n textsc: { signature: \"m\", renderInfo: { inParMode: true } },\n texttt: { signature: \"m\", renderInfo: { inParMode: true } },\n underline: { signature: \"m\", renderInfo: { inParMode: true } },\n emph: { signature: \"m\", renderInfo: { inParMode: true } },\n textnormal: { signature: \"m\", renderInfo: { inParMode: true } },\n uppercase: { signature: \"m\", renderInfo: { inParMode: true } },\n mathbf: { signature: \"m\" },\n mathsf: { signature: \"m\" },\n mathtt: { signature: \"m\" },\n mathit: { signature: \"m\" },\n mathnormal: { signature: \"m\" },\n mathcal: { signature: \"m\" },\n mathrm: { signature: \"m\" },\n // Other\n setlength: { signature: \"m m\", renderInfo: { breakAround: true } },\n ref: { signature: \"s m\" },\n label: { signature: \"o m\" }, // cleveref changes \\label to have this signature\n printbibliography: { renderInfo: { breakAround: true } },\n addtocontents: { signature: \"m m\", renderInfo: { breakAround: true } },\n addcontentsline: { signature: \"m m m\", renderInfo: { breakAround: true } },\n contentsline: { signature: \"m m m\", renderInfo: { breakAround: true } },\n bibliography: { signature: \"m\", renderInfo: { breakAround: true } },\n bibliographystyle: { signature: \"m\", renderInfo: { breakAround: true } },\n};\n\nexport const environments: EnvInfoRecord = {\n document: {\n processContent: (nodes) => {\n trim(nodes);\n return nodes;\n },\n },\n array: { signature: \"o m\", renderInfo: { alignContent: true } },\n description: { signature: \"o\", processContent: cleanEnumerateBody },\n enumerate: {\n signature: \"o\",\n processContent: cleanEnumerateBody,\n renderInfo: { pgfkeysArgs: true },\n },\n itemize: { signature: \"o\", processContent: cleanEnumerateBody },\n trivlist: { signature: \"o\", processContent: cleanEnumerateBody },\n list: { signature: \"m m\", processContent: cleanEnumerateBody },\n figure: { signature: \"o\" },\n \"figure*\": { signature: \"o\" },\n filecontents: { signature: \"o m\" },\n \"filecontents*\": { signature: \"o m\" },\n minipage: { signature: \"o o o m\" },\n picture: { signature: \"r() d()\" },\n tabbing: { renderInfo: { alignContent: true } },\n table: { signature: \"o\" },\n tabular: { signature: \"o m\", renderInfo: { alignContent: true } },\n \"tabular*\": { signature: \"m o m\", renderInfo: { alignContent: true } },\n thebibliography: {\n signature: \"m\",\n processContent: (nodes) => cleanEnumerateBody(nodes, \"bibitem\"),\n },\n // Math\n math: { renderInfo: { inMathMode: true } },\n};\n"],"names":["trim","cleanEnumerateBody"],"mappings":"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"} \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-ctan/provides-gOjhEUvC.cjs b/node_modules/@unified-latex/unified-latex-ctan/provides-gOjhEUvC.cjs new file mode 100644 index 0000000..d3083f0 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-ctan/provides-gOjhEUvC.cjs @@ -0,0 +1,66 @@ +"use strict"; +const enumerate = require("./enumerate-DSh8p1uS.cjs"); +const macros = { + answerline: { signature: "o" }, + fillin: { signature: "o o" }, + fullwidth: { signature: "m" }, + fillwidthlines: { signature: "m" }, + fillwidthdottedlines: { signature: "m" }, + fillwidthgrid: { signature: "m" }, + makeemptybox: { signature: "m" }, + CorrectChoiceEmphasis: { + signature: "m", + renderInfo: { breakAround: true } + }, + SolutionEmphasis: { signature: "m", renderInfo: { breakAround: true } }, + uplevel: { signature: "m", renderInfo: { breakAround: true } }, + checkboxchar: { signature: "m", renderInfo: { breakAround: true } }, + checkedchar: { signature: "m", renderInfo: { breakAround: true } }, + pointname: { signature: "m", renderInfo: { breakAround: true } }, + marginpointname: { signature: "m", renderInfo: { breakAround: true } }, + extrawidth: { signature: "m", renderInfo: { breakAround: true } }, + pointformat: { signature: "m", renderInfo: { breakAround: true } }, + bonuspointformat: { signature: "m", renderInfo: { breakAround: true } }, + totalformat: { signature: "m", renderInfo: { breakAround: true } }, + qformat: { signature: "m", renderInfo: { breakAround: true } }, + titledquestion: { signature: "m o", renderInfo: { breakAround: true } }, + pointpoints: { signature: "m m", renderInfo: { breakAround: true } }, + bonuspointpoints: { signature: "m m", renderInfo: { breakAround: true } } +}; +const environments = { + choices: { + signature: "o", + processContent: (nodes) => enumerate.cleanEnumerateBody(nodes, "choice") + }, + checkboxes: { + signature: "o", + processContent: (nodes) => enumerate.cleanEnumerateBody(nodes, "choice") + }, + oneparchoices: { + signature: "o", + processContent: (nodes) => enumerate.cleanEnumerateBody(nodes, "choice") + }, + oneparcheckboxes: { + signature: "o", + processContent: (nodes) => enumerate.cleanEnumerateBody(nodes, "choice") + }, + parts: { + signature: "o", + processContent: (nodes) => enumerate.cleanEnumerateBody(nodes, "part") + }, + subparts: { + signature: "o", + processContent: (nodes) => enumerate.cleanEnumerateBody(nodes, "subpart") + }, + subsubparts: { + signature: "o", + processContent: (nodes) => enumerate.cleanEnumerateBody(nodes, "subsubpart") + }, + questions: { + signature: "o", + processContent: (nodes) => enumerate.cleanEnumerateBody(nodes, "question") + } +}; +exports.environments = environments; +exports.macros = macros; +//# sourceMappingURL=provides-gOjhEUvC.cjs.map diff --git a/node_modules/@unified-latex/unified-latex-ctan/provides-gOjhEUvC.cjs.map b/node_modules/@unified-latex/unified-latex-ctan/provides-gOjhEUvC.cjs.map new file mode 100644 index 0000000..65bf180 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-ctan/provides-gOjhEUvC.cjs.map @@ -0,0 +1 @@ +{"version":3,"file":"provides-gOjhEUvC.cjs","sources":["../package/exam/provides.ts"],"sourcesContent":["import {\n MacroInfoRecord,\n EnvInfoRecord,\n} from \"@unified-latex/unified-latex-types\";\nimport { cleanEnumerateBody } from \"../../utils/enumerate\";\n\nexport const macros: MacroInfoRecord = {\n answerline: { signature: \"o\" },\n fillin: { signature: \"o o\" },\n fullwidth: { signature: \"m\" },\n fillwidthlines: { signature: \"m\" },\n fillwidthdottedlines: { signature: \"m\" },\n fillwidthgrid: { signature: \"m\" },\n makeemptybox: { signature: \"m\" },\n CorrectChoiceEmphasis: {\n signature: \"m\",\n renderInfo: { breakAround: true },\n },\n SolutionEmphasis: { signature: \"m\", renderInfo: { breakAround: true } },\n uplevel: { signature: \"m\", renderInfo: { breakAround: true } },\n checkboxchar: { signature: \"m\", renderInfo: { breakAround: true } },\n checkedchar: { signature: \"m\", renderInfo: { breakAround: true } },\n pointname: { signature: \"m\", renderInfo: { breakAround: true } },\n marginpointname: { signature: \"m\", renderInfo: { breakAround: true } },\n extrawidth: { signature: \"m\", renderInfo: { breakAround: true } },\n pointformat: { signature: \"m\", renderInfo: { breakAround: true } },\n bonuspointformat: { signature: \"m\", renderInfo: { breakAround: true } },\n totalformat: { signature: \"m\", renderInfo: { breakAround: true } },\n qformat: { signature: \"m\", renderInfo: { breakAround: true } },\n titledquestion: { signature: \"m o\", renderInfo: { breakAround: true } },\n pointpoints: { signature: \"m m\", renderInfo: { breakAround: true } },\n bonuspointpoints: { signature: \"m m\", renderInfo: { breakAround: true } },\n};\n\nexport const environments: EnvInfoRecord = {\n choices: {\n signature: \"o\",\n processContent: (nodes) => cleanEnumerateBody(nodes, \"choice\"),\n },\n checkboxes: {\n signature: \"o\",\n processContent: (nodes) => cleanEnumerateBody(nodes, \"choice\"),\n },\n oneparchoices: {\n signature: \"o\",\n processContent: (nodes) => cleanEnumerateBody(nodes, \"choice\"),\n },\n oneparcheckboxes: {\n signature: \"o\",\n processContent: (nodes) => cleanEnumerateBody(nodes, \"choice\"),\n },\n parts: {\n signature: \"o\",\n processContent: (nodes) => cleanEnumerateBody(nodes, \"part\"),\n },\n subparts: {\n signature: \"o\",\n processContent: (nodes) => cleanEnumerateBody(nodes, \"subpart\"),\n },\n subsubparts: {\n signature: \"o\",\n processContent: (nodes) => cleanEnumerateBody(nodes, \"subsubpart\"),\n },\n questions: {\n signature: \"o\",\n processContent: (nodes) => cleanEnumerateBody(nodes, \"question\"),\n },\n};\n"],"names":["cleanEnumerateBody"],"mappings":";;AAMO,MAAM,SAA0B;AAAA,EACnC,YAAY,EAAE,WAAW,IAAI;AAAA,EAC7B,QAAQ,EAAE,WAAW,MAAM;AAAA,EAC3B,WAAW,EAAE,WAAW,IAAI;AAAA,EAC5B,gBAAgB,EAAE,WAAW,IAAI;AAAA,EACjC,sBAAsB,EAAE,WAAW,IAAI;AAAA,EACvC,eAAe,EAAE,WAAW,IAAI;AAAA,EAChC,cAAc,EAAE,WAAW,IAAI;AAAA,EAC/B,uBAAuB;AAAA,IACnB,WAAW;AAAA,IACX,YAAY,EAAE,aAAa,KAAK;AAAA,EACpC;AAAA,EACA,kBAAkB,EAAE,WAAW,KAAK,YAAY,EAAE,aAAa,OAAO;AAAA,EACtE,SAAS,EAAE,WAAW,KAAK,YAAY,EAAE,aAAa,OAAO;AAAA,EAC7D,cAAc,EAAE,WAAW,KAAK,YAAY,EAAE,aAAa,OAAO;AAAA,EAClE,aAAa,EAAE,WAAW,KAAK,YAAY,EAAE,aAAa,OAAO;AAAA,EACjE,WAAW,EAAE,WAAW,KAAK,YAAY,EAAE,aAAa,OAAO;AAAA,EAC/D,iBAAiB,EAAE,WAAW,KAAK,YAAY,EAAE,aAAa,OAAO;AAAA,EACrE,YAAY,EAAE,WAAW,KAAK,YAAY,EAAE,aAAa,OAAO;AAAA,EAChE,aAAa,EAAE,WAAW,KAAK,YAAY,EAAE,aAAa,OAAO;AAAA,EACjE,kBAAkB,EAAE,WAAW,KAAK,YAAY,EAAE,aAAa,OAAO;AAAA,EACtE,aAAa,EAAE,WAAW,KAAK,YAAY,EAAE,aAAa,OAAO;AAAA,EACjE,SAAS,EAAE,WAAW,KAAK,YAAY,EAAE,aAAa,OAAO;AAAA,EAC7D,gBAAgB,EAAE,WAAW,OAAO,YAAY,EAAE,aAAa,OAAO;AAAA,EACtE,aAAa,EAAE,WAAW,OAAO,YAAY,EAAE,aAAa,OAAO;AAAA,EACnE,kBAAkB,EAAE,WAAW,OAAO,YAAY,EAAE,aAAa,KAAO,EAAA;AAC5E;AAEO,MAAM,eAA8B;AAAA,EACvC,SAAS;AAAA,IACL,WAAW;AAAA,IACX,gBAAgB,CAAC,UAAUA,UAAA,mBAAmB,OAAO,QAAQ;AAAA,EACjE;AAAA,EACA,YAAY;AAAA,IACR,WAAW;AAAA,IACX,gBAAgB,CAAC,UAAUA,UAAA,mBAAmB,OAAO,QAAQ;AAAA,EACjE;AAAA,EACA,eAAe;AAAA,IACX,WAAW;AAAA,IACX,gBAAgB,CAAC,UAAUA,UAAA,mBAAmB,OAAO,QAAQ;AAAA,EACjE;AAAA,EACA,kBAAkB;AAAA,IACd,WAAW;AAAA,IACX,gBAAgB,CAAC,UAAUA,UAAA,mBAAmB,OAAO,QAAQ;AAAA,EACjE;AAAA,EACA,OAAO;AAAA,IACH,WAAW;AAAA,IACX,gBAAgB,CAAC,UAAUA,UAAA,mBAAmB,OAAO,MAAM;AAAA,EAC/D;AAAA,EACA,UAAU;AAAA,IACN,WAAW;AAAA,IACX,gBAAgB,CAAC,UAAUA,UAAA,mBAAmB,OAAO,SAAS;AAAA,EAClE;AAAA,EACA,aAAa;AAAA,IACT,WAAW;AAAA,IACX,gBAAgB,CAAC,UAAUA,UAAA,mBAAmB,OAAO,YAAY;AAAA,EACrE;AAAA,EACA,WAAW;AAAA,IACP,WAAW;AAAA,IACX,gBAAgB,CAAC,UAAUA,UAAA,mBAAmB,OAAO,UAAU;AAAA,EAAA;AAEvE;;;"} \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-ctan/provides-sdqk_ZBm.js b/node_modules/@unified-latex/unified-latex-ctan/provides-sdqk_ZBm.js new file mode 100644 index 0000000..2076762 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-ctan/provides-sdqk_ZBm.js @@ -0,0 +1,57 @@ +import { arg } from "@unified-latex/unified-latex-builder"; +import { parse } from "@unified-latex/unified-latex-util-argspec"; +import { gobbleSingleArgument } from "@unified-latex/unified-latex-util-arguments"; +import { match } from "@unified-latex/unified-latex-util-match"; +const argSpecM = parse("m")[0]; +const argSpecO = parse("o")[0]; +const argSpecRDelim = {}; +const argumentParser = (nodes, startPos) => { + const { argument: optionalArg, nodesRemoved: optionalArgNodesRemoved } = gobbleSingleArgument(nodes, argSpecO, startPos); + const { argument: languageArg, nodesRemoved: languageArgNodesRemoved } = gobbleSingleArgument(nodes, argSpecM, startPos); + let codeArg = null; + let codeArgNodesRemoved = 0; + const nextNode = nodes[startPos]; + if (match.group(nextNode)) { + const mandatoryArg = gobbleSingleArgument(nodes, argSpecM, startPos); + codeArg = mandatoryArg.argument; + codeArgNodesRemoved = mandatoryArg.nodesRemoved; + } else if (match.string(nextNode) && nextNode.content.length === 1) { + const delim = nextNode.content; + argSpecRDelim[delim] = argSpecRDelim[delim] || parse(`r${delim}${delim}`)[0]; + const delimArg = gobbleSingleArgument( + nodes, + argSpecRDelim[delim], + startPos + ); + codeArg = delimArg.argument; + codeArgNodesRemoved = delimArg.nodesRemoved; + } + return { + args: [ + optionalArg || arg(null), + languageArg || arg(null), + codeArg || arg(null) + ], + nodesRemoved: optionalArgNodesRemoved + languageArgNodesRemoved + codeArgNodesRemoved + }; +}; +const macros = { + mint: { argumentParser }, + mintinline: { argumentParser }, + inputminted: { argumentParser }, + usemintedstyle: { signature: "m" }, + setminted: { signature: "o m" }, + setmintedinline: { signature: "o m" }, + newmint: { signature: "o m m" }, + newminted: { signature: "o m m" }, + newmintinline: { signature: "o m m" }, + newmintedfile: { signature: "o m m" } +}; +const environments = { + minted: { signature: "o m" } +}; +export { + environments as e, + macros as m +}; +//# sourceMappingURL=provides-sdqk_ZBm.js.map diff --git a/node_modules/@unified-latex/unified-latex-ctan/provides-sdqk_ZBm.js.map b/node_modules/@unified-latex/unified-latex-ctan/provides-sdqk_ZBm.js.map new file mode 100644 index 0000000..87f2bbf --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-ctan/provides-sdqk_ZBm.js.map @@ -0,0 +1 @@ +{"version":3,"file":"provides-sdqk_ZBm.js","sources":["../package/minted/libs/argument-parser.ts","../package/minted/provides.ts"],"sourcesContent":["import { arg } from \"@unified-latex/unified-latex-builder\";\nimport { Argument, ArgumentParser } from \"@unified-latex/unified-latex-types\";\nimport { parse as parseArgspec } from \"@unified-latex/unified-latex-util-argspec\";\nimport { Node } from \"@unified-latex/unified-latex-util-argspec/libs/argspec-types\";\nimport { gobbleSingleArgument } from \"@unified-latex/unified-latex-util-arguments\";\nimport { match } from \"@unified-latex/unified-latex-util-match\";\n\nconst argSpecM = parseArgspec(\"m\")[0];\nconst argSpecO = parseArgspec(\"o\")[0];\nconst argSpecRDelim: { [delim: string]: Node } = {};\n\n/**\n * This argument parser parses arguments in the form of\n * - [⟨options⟩]{⟨language⟩}⟨delim⟩⟨code⟩⟨delim⟩\n * - [⟨options⟩]{⟨language⟩}{⟨code⟩}\n */\nexport const argumentParser: ArgumentParser = (nodes, startPos) => {\n const { argument: optionalArg, nodesRemoved: optionalArgNodesRemoved } =\n gobbleSingleArgument(nodes, argSpecO, startPos);\n\n const { argument: languageArg, nodesRemoved: languageArgNodesRemoved } =\n gobbleSingleArgument(nodes, argSpecM, startPos);\n\n let codeArg: Argument | Argument[] | null = null;\n let codeArgNodesRemoved: number = 0;\n const nextNode = nodes[startPos];\n if (match.group(nextNode)) {\n const mandatoryArg = gobbleSingleArgument(nodes, argSpecM, startPos);\n codeArg = mandatoryArg.argument;\n codeArgNodesRemoved = mandatoryArg.nodesRemoved;\n } else if (match.string(nextNode) && nextNode.content.length === 1) {\n const delim = nextNode.content;\n argSpecRDelim[delim] =\n argSpecRDelim[delim] || parseArgspec(`r${delim}${delim}`)[0];\n const delimArg = gobbleSingleArgument(\n nodes,\n argSpecRDelim[delim],\n startPos\n );\n codeArg = delimArg.argument;\n codeArgNodesRemoved = delimArg.nodesRemoved;\n }\n\n return {\n args: [\n optionalArg || arg(null),\n languageArg || arg(null),\n codeArg || arg(null),\n ],\n nodesRemoved:\n optionalArgNodesRemoved +\n languageArgNodesRemoved +\n codeArgNodesRemoved,\n };\n};\n","import {\n MacroInfoRecord,\n EnvInfoRecord,\n} from \"@unified-latex/unified-latex-types\";\nimport { argumentParser } from \"./libs/argument-parser\";\n\nexport const macros: MacroInfoRecord = {\n mint: { argumentParser: argumentParser },\n mintinline: { argumentParser: argumentParser },\n inputminted: { argumentParser: argumentParser },\n usemintedstyle: { signature: \"m\" },\n setminted: { signature: \"o m\" },\n setmintedinline: { signature: \"o m\" },\n newmint: { signature: \"o m m\" },\n newminted: { signature: \"o m m\" },\n newmintinline: { signature: \"o m m\" },\n newmintedfile: { signature: \"o m m\" },\n};\n\nexport const environments: EnvInfoRecord = {\n minted: { signature: \"o m\" },\n};\n"],"names":["parseArgspec"],"mappings":";;;;AAOA,MAAM,WAAWA,MAAa,GAAG,EAAE,CAAC;AACpC,MAAM,WAAWA,MAAa,GAAG,EAAE,CAAC;AACpC,MAAM,gBAA2C,CAAC;AAOrC,MAAA,iBAAiC,CAAC,OAAO,aAAa;AACzD,QAAA,EAAE,UAAU,aAAa,cAAc,wBACzC,IAAA,qBAAqB,OAAO,UAAU,QAAQ;AAE5C,QAAA,EAAE,UAAU,aAAa,cAAc,wBACzC,IAAA,qBAAqB,OAAO,UAAU,QAAQ;AAElD,MAAI,UAAwC;AAC5C,MAAI,sBAA8B;AAC5B,QAAA,WAAW,MAAM,QAAQ;AAC3B,MAAA,MAAM,MAAM,QAAQ,GAAG;AACvB,UAAM,eAAe,qBAAqB,OAAO,UAAU,QAAQ;AACnE,cAAU,aAAa;AACvB,0BAAsB,aAAa;AAAA,EAAA,WAC5B,MAAM,OAAO,QAAQ,KAAK,SAAS,QAAQ,WAAW,GAAG;AAChE,UAAM,QAAQ,SAAS;AACvB,kBAAc,KAAK,IACf,cAAc,KAAK,KAAKA,MAAa,IAAI,KAAK,GAAG,KAAK,EAAE,EAAE,CAAC;AAC/D,UAAM,WAAW;AAAA,MACb;AAAA,MACA,cAAc,KAAK;AAAA,MACnB;AAAA,IACJ;AACA,cAAU,SAAS;AACnB,0BAAsB,SAAS;AAAA,EAAA;AAG5B,SAAA;AAAA,IACH,MAAM;AAAA,MACF,eAAe,IAAI,IAAI;AAAA,MACvB,eAAe,IAAI,IAAI;AAAA,MACvB,WAAW,IAAI,IAAI;AAAA,IACvB;AAAA,IACA,cACI,0BACA,0BACA;AAAA,EACR;AACJ;AChDO,MAAM,SAA0B;AAAA,EACnC,MAAM,EAAE,eAA+B;AAAA,EACvC,YAAY,EAAE,eAA+B;AAAA,EAC7C,aAAa,EAAE,eAA+B;AAAA,EAC9C,gBAAgB,EAAE,WAAW,IAAI;AAAA,EACjC,WAAW,EAAE,WAAW,MAAM;AAAA,EAC9B,iBAAiB,EAAE,WAAW,MAAM;AAAA,EACpC,SAAS,EAAE,WAAW,QAAQ;AAAA,EAC9B,WAAW,EAAE,WAAW,QAAQ;AAAA,EAChC,eAAe,EAAE,WAAW,QAAQ;AAAA,EACpC,eAAe,EAAE,WAAW,QAAQ;AACxC;AAEO,MAAM,eAA8B;AAAA,EACvC,QAAQ,EAAE,WAAW,MAAM;AAC/B;"} \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-ctan/provides-yGf6-zdY.js b/node_modules/@unified-latex/unified-latex-ctan/provides-yGf6-zdY.js new file mode 100644 index 0000000..2ff9125 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-ctan/provides-yGf6-zdY.js @@ -0,0 +1,27 @@ +const macros = { + systeme: { + signature: "s o o m", + renderInfo: { inMathMode: true } + }, + sysdelim: { + signature: "m m" + }, + syseqsep: { signature: "m" }, + sysalign: { signature: "m" }, + syssignspace: { signature: "m" }, + syseqspace: { signature: "m" }, + syslineskipcoeff: { signature: "m" }, + syseqivsign: { signature: "m" }, + sysaddeqsign: { signature: "m" }, + sysremoveeqsign: { signature: "m" }, + sysextracolonsign: { signature: "m" }, + syscodeextracol: { signature: "m" }, + sysautonum: { signature: "m" }, + syssubstitute: { signature: "m" } +}; +const environments = {}; +export { + environments as e, + macros as m +}; +//# sourceMappingURL=provides-yGf6-zdY.js.map diff --git a/node_modules/@unified-latex/unified-latex-ctan/provides-yGf6-zdY.js.map b/node_modules/@unified-latex/unified-latex-ctan/provides-yGf6-zdY.js.map new file mode 100644 index 0000000..5966b1f --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-ctan/provides-yGf6-zdY.js.map @@ -0,0 +1 @@ +{"version":3,"file":"provides-yGf6-zdY.js","sources":["../package/systeme/provides.ts"],"sourcesContent":["import {\n MacroInfoRecord,\n EnvInfoRecord,\n} from \"@unified-latex/unified-latex-types\";\n\nexport const macros: MacroInfoRecord = {\n systeme: {\n signature: \"s o o m\",\n renderInfo: { inMathMode: true },\n },\n sysdelim: {\n signature: \"m m\",\n },\n syseqsep: { signature: \"m\" },\n sysalign: { signature: \"m\" },\n syssignspace: { signature: \"m\" },\n syseqspace: { signature: \"m\" },\n syslineskipcoeff: { signature: \"m\" },\n syseqivsign: { signature: \"m\" },\n sysaddeqsign: { signature: \"m\" },\n sysremoveeqsign: { signature: \"m\" },\n sysextracolonsign: { signature: \"m\" },\n syscodeextracol: { signature: \"m\" },\n sysautonum: { signature: \"m\" },\n syssubstitute: { signature: \"m\" },\n};\n\nexport const environments: EnvInfoRecord = {};\n"],"names":[],"mappings":"AAKO,MAAM,SAA0B;AAAA,EACnC,SAAS;AAAA,IACL,WAAW;AAAA,IACX,YAAY,EAAE,YAAY,KAAK;AAAA,EACnC;AAAA,EACA,UAAU;AAAA,IACN,WAAW;AAAA,EACf;AAAA,EACA,UAAU,EAAE,WAAW,IAAI;AAAA,EAC3B,UAAU,EAAE,WAAW,IAAI;AAAA,EAC3B,cAAc,EAAE,WAAW,IAAI;AAAA,EAC/B,YAAY,EAAE,WAAW,IAAI;AAAA,EAC7B,kBAAkB,EAAE,WAAW,IAAI;AAAA,EACnC,aAAa,EAAE,WAAW,IAAI;AAAA,EAC9B,cAAc,EAAE,WAAW,IAAI;AAAA,EAC/B,iBAAiB,EAAE,WAAW,IAAI;AAAA,EAClC,mBAAmB,EAAE,WAAW,IAAI;AAAA,EACpC,iBAAiB,EAAE,WAAW,IAAI;AAAA,EAClC,YAAY,EAAE,WAAW,IAAI;AAAA,EAC7B,eAAe,EAAE,WAAW,IAAI;AACpC;AAEO,MAAM,eAA8B,CAAA;"} \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-ctan/utils/enumerate.d.ts b/node_modules/@unified-latex/unified-latex-ctan/utils/enumerate.d.ts new file mode 100644 index 0000000..0077e71 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-ctan/utils/enumerate.d.ts @@ -0,0 +1,13 @@ +import * as Ast from "@unified-latex/unified-latex-types"; +/** + * Clean up any whitespace issues in an enumerate environment. In particular, + * * Remove any leading or ending whitespace + * * Ensure there is a par between occurrences of `\item` + * * Ensure there is whitespace after each occurrence of `\item` provided there is content there + * `itemName` can be used to set what the "item" macro is called. + * + * This function attaches content following a `\item` to the `\item` macro with + * `openMark` and `closeMark` set to empty. This allows hanging-indents to be rendered. + */ +export declare function cleanEnumerateBody(ast: Ast.Node[], itemName?: string): Ast.Node[]; +//# sourceMappingURL=enumerate.d.ts.map \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-ctan/xcolor-BEfsW_1K.cjs b/node_modules/@unified-latex/unified-latex-ctan/xcolor-BEfsW_1K.cjs new file mode 100644 index 0000000..b3ec092 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-ctan/xcolor-BEfsW_1K.cjs @@ -0,0 +1,850 @@ +"use strict"; +const Color = require("color"); +const unifiedLatexUtilPegjs = require("@unified-latex/unified-latex-util-pegjs"); +const macros = { + substitutecolormodel: { + signature: "m m", + renderInfo: { breakAround: true } + }, + selectcolormodel: { + signature: "m", + renderInfo: { breakAround: true } + }, + definecolor: { + signature: "o m m m", + renderInfo: { breakAround: true } + }, + providecolor: { + signature: "o m m m", + renderInfo: { breakAround: true } + }, + colorlet: { + signature: "o m o m", + renderInfo: { breakAround: true } + }, + definecolorset: { + signature: "o m m m", + renderInfo: { breakAround: true } + }, + providecolorset: { + signature: "o m m m m", + renderInfo: { breakAround: true } + }, + preparecolor: { + signature: "o m m m", + renderInfo: { breakAround: true } + }, + preparecolorset: { + signature: "o m m m m", + renderInfo: { breakAround: true } + }, + DefineNamedColor: { + signature: "m m m m", + renderInfo: { breakAround: true } + }, + definecolors: { + signature: "m", + renderInfo: { breakAround: true } + }, + providecolors: { + signature: "m", + renderInfo: { breakAround: true } + }, + color: { signature: "o m", renderInfo: { breakAround: true } }, + textcolor: { signature: "o m m", renderInfo: { inParMode: true } }, + pagecolor: { signature: "o m" }, + colorbox: { signature: "o m m" }, + fcolorbox: { signature: "o m o m m" }, + boxframe: { signature: "o m" }, + testcolor: { signature: "o m" }, + blendcolors: { signature: "s m" }, + maskcolors: { signature: "o m" }, + definecolorseries: { + signature: "m m m o m o m", + renderInfo: { breakAround: true } + }, + resetcolorseries: { + signature: "o m", + renderInfo: { breakAround: true } + }, + rowcolors: { signature: "s o m m m" }, + extractcolorspec: { signature: "m m" }, + extractcolorspecs: { signature: "m m m" }, + convertcolorspec: { signature: "m m m m" } +}; +const environments = { + testcolors: { signature: "o", renderInfo: { pgfkeysArgs: true } } +}; +const fromRgb = ([r, g, b]) => Color([r * 255, g * 255, b * 255], "rgb"); +const DVI_PS_NAMES = { + Apricot: Color("#FBB982"), + Aquamarine: Color("#00B5BE"), + Bittersweet: Color("#C04F17"), + Black: Color("#221E1F"), + Blue: Color("#2D2F92"), + BlueGreen: Color("#00B3B8"), + BlueViolet: Color("#473992"), + BrickRed: Color("#B6321C"), + Brown: Color("#792500"), + BurntOrange: Color("#F7921D"), + CadetBlue: Color("#74729A"), + CarnationPink: Color("#F282B4"), + Cerulean: Color("#00A2E3"), + CornflowerBlue: Color("#41B0E4"), + Cyan: Color("#00AEEF"), + Dandelion: Color("#FDBC42"), + DarkOrchid: Color("#A4538A"), + Emerald: Color("#00A99D"), + ForestGreen: Color("#009B55"), + Fuchsia: Color("#8C368C"), + Goldenrod: Color("#FFDF42"), + Gray: Color("#949698"), + Green: Color("#00A64F"), + GreenYellow: Color("#DFE674"), + JungleGreen: Color("#00A99A"), + Lavender: Color("#F49EC4"), + LimeGreen: Color("#8DC73E"), + Magenta: Color("#EC008C"), + Mahogany: Color("#A9341F"), + Maroon: Color("#AF3235"), + Melon: Color("#F89E7B"), + MidnightBlue: Color("#006795"), + Mulberry: Color("#A93C93"), + NavyBlue: Color("#006EB8"), + OliveGreen: Color("#3C8031"), + Orange: Color("#F58137"), + OrangeRed: Color("#ED135A"), + Orchid: Color("#AF72B0"), + Peach: Color("#F7965A"), + Periwinkle: Color("#7977B8"), + PineGreen: Color("#008B72"), + Plum: Color("#92268F"), + ProcessBlue: Color("#00B0F0"), + Purple: Color("#99479B"), + RawSienna: Color("#974006"), + Red: Color("#ED1B23"), + RedOrange: Color("#F26035"), + RedViolet: Color("#A1246B"), + Rhodamine: Color("#EF559F"), + RoyalBlue: Color("#0071BC"), + RoyalPurple: Color("#613F99"), + RubineRed: Color("#ED017D"), + Salmon: Color("#F69289"), + SeaGreen: Color("#3FBC9D"), + Sepia: Color("#671800"), + SkyBlue: Color("#46C5DD"), + SpringGreen: Color("#C6DC67"), + Tan: Color("#DA9D76"), + TealBlue: Color("#00AEB3"), + Thistle: Color("#D883B7"), + Turquoise: Color("#00B4CE"), + Violet: Color("#58429B"), + VioletRed: Color("#EF58A0"), + White: Color("#FFFFFF"), + WildStrawberry: Color("#EE2967"), + Yellow: Color("#FFF200"), + YellowGreen: Color("#98CC70"), + YellowOrange: Color("#FAA21A") +}; +const SVG_NAMES = { + AliceBlue: fromRgb([0.94, 0.972, 1]), + AntiqueWhite: fromRgb([0.98, 0.92, 0.844]), + Aqua: fromRgb([0, 1, 1]), + Aquamarine: fromRgb([0.498, 1, 0.83]), + Azure: fromRgb([0.94, 1, 1]), + Beige: fromRgb([0.96, 0.96, 0.864]), + Bisque: fromRgb([1, 0.894, 0.77]), + Black: fromRgb([0, 0, 0]), + BlanchedAlmond: fromRgb([1, 0.92, 0.804]), + Blue: fromRgb([0, 0, 1]), + BlueViolet: fromRgb([0.54, 0.17, 0.888]), + Brown: fromRgb([0.648, 0.165, 0.165]), + BurlyWood: fromRgb([0.87, 0.72, 0.53]), + CadetBlue: fromRgb([0.372, 0.62, 0.628]), + Chartreuse: fromRgb([0.498, 1, 0]), + Chocolate: fromRgb([0.824, 0.41, 0.116]), + Coral: fromRgb([1, 0.498, 0.312]), + CornflowerBlue: fromRgb([0.392, 0.585, 0.93]), + Cornsilk: fromRgb([1, 0.972, 0.864]), + Crimson: fromRgb([0.864, 0.08, 0.235]), + Cyan: fromRgb([0, 1, 1]), + DarkBlue: fromRgb([0, 0, 0.545]), + DarkCyan: fromRgb([0, 0.545, 0.545]), + DarkGoldenrod: fromRgb([0.72, 0.525, 0.044]), + DarkGray: fromRgb([0.664, 0.664, 0.664]), + DarkGreen: fromRgb([0, 0.392, 0]), + DarkGrey: fromRgb([0.664, 0.664, 0.664]), + DarkKhaki: fromRgb([0.74, 0.716, 0.42]), + DarkMagenta: fromRgb([0.545, 0, 0.545]), + DarkOliveGreen: fromRgb([0.332, 0.42, 0.185]), + DarkOrange: fromRgb([1, 0.55, 0]), + DarkOrchid: fromRgb([0.6, 0.196, 0.8]), + DarkRed: fromRgb([0.545, 0, 0]), + DarkSalmon: fromRgb([0.912, 0.59, 0.48]), + DarkSeaGreen: fromRgb([0.56, 0.736, 0.56]), + DarkSlateBlue: fromRgb([0.284, 0.24, 0.545]), + DarkSlateGray: fromRgb([0.185, 0.31, 0.31]), + DarkSlateGrey: fromRgb([0.185, 0.31, 0.31]), + DarkTurquoise: fromRgb([0, 0.808, 0.82]), + DarkViolet: fromRgb([0.58, 0, 0.828]), + DeepPink: fromRgb([1, 0.08, 0.576]), + DeepSkyBlue: fromRgb([0, 0.75, 1]), + DimGray: fromRgb([0.41, 0.41, 0.41]), + DimGrey: fromRgb([0.41, 0.41, 0.41]), + DodgerBlue: fromRgb([0.116, 0.565, 1]), + FireBrick: fromRgb([0.698, 0.132, 0.132]), + FloralWhite: fromRgb([1, 0.98, 0.94]), + ForestGreen: fromRgb([0.132, 0.545, 0.132]), + Fuchsia: fromRgb([1, 0, 1]), + Gainsboro: fromRgb([0.864, 0.864, 0.864]), + GhostWhite: fromRgb([0.972, 0.972, 1]), + Gold: fromRgb([1, 0.844, 0]), + Goldenrod: fromRgb([0.855, 0.648, 0.125]), + Gray: fromRgb([0.5, 0.5, 0.5]), + Green: fromRgb([0, 0.5, 0]), + GreenYellow: fromRgb([0.68, 1, 0.185]), + Grey: fromRgb([0.5, 0.5, 0.5]), + Honeydew: fromRgb([0.94, 1, 0.94]), + HotPink: fromRgb([1, 0.41, 0.705]), + IndianRed: fromRgb([0.804, 0.36, 0.36]), + Indigo: fromRgb([0.294, 0, 0.51]), + Ivory: fromRgb([1, 1, 0.94]), + Khaki: fromRgb([0.94, 0.9, 0.55]), + Lavender: fromRgb([0.9, 0.9, 0.98]), + LavenderBlush: fromRgb([1, 0.94, 0.96]), + LawnGreen: fromRgb([0.488, 0.99, 0]), + LemonChiffon: fromRgb([1, 0.98, 0.804]), + LightBlue: fromRgb([0.68, 0.848, 0.9]), + LightCoral: fromRgb([0.94, 0.5, 0.5]), + LightCyan: fromRgb([0.88, 1, 1]), + LightGoldenrod: fromRgb([0.933, 0.867, 0.51]), + LightGoldenrodYellow: fromRgb([0.98, 0.98, 0.824]), + LightGray: fromRgb([0.828, 0.828, 0.828]), + LightGreen: fromRgb([0.565, 0.932, 0.565]), + LightGrey: fromRgb([0.828, 0.828, 0.828]), + LightPink: fromRgb([1, 0.712, 0.756]), + LightSalmon: fromRgb([1, 0.628, 0.48]), + LightSeaGreen: fromRgb([0.125, 0.698, 0.668]), + LightSkyBlue: fromRgb([0.53, 0.808, 0.98]), + LightSlateBlue: fromRgb([0.518, 0.44, 1]), + LightSlateGray: fromRgb([0.468, 0.532, 0.6]), + LightSlateGrey: fromRgb([0.468, 0.532, 0.6]), + LightSteelBlue: fromRgb([0.69, 0.77, 0.87]), + LightYellow: fromRgb([1, 1, 0.88]), + Lime: fromRgb([0, 1, 0]), + LimeGreen: fromRgb([0.196, 0.804, 0.196]), + Linen: fromRgb([0.98, 0.94, 0.9]), + Magenta: fromRgb([1, 0, 1]), + Maroon: fromRgb([0.5, 0, 0]), + MediumAquamarine: fromRgb([0.4, 0.804, 0.668]), + MediumBlue: fromRgb([0, 0, 0.804]), + MediumOrchid: fromRgb([0.73, 0.332, 0.828]), + MediumPurple: fromRgb([0.576, 0.44, 0.86]), + MediumSeaGreen: fromRgb([0.235, 0.7, 0.444]), + MediumSlateBlue: fromRgb([0.484, 0.408, 0.932]), + MediumSpringGreen: fromRgb([0, 0.98, 0.604]), + MediumTurquoise: fromRgb([0.284, 0.82, 0.8]), + MediumVioletRed: fromRgb([0.78, 0.084, 0.52]), + MidnightBlue: fromRgb([0.098, 0.098, 0.44]), + MintCream: fromRgb([0.96, 1, 0.98]), + MistyRose: fromRgb([1, 0.894, 0.884]), + Moccasin: fromRgb([1, 0.894, 0.71]), + NavajoWhite: fromRgb([1, 0.87, 0.68]), + Navy: fromRgb([0, 0, 0.5]), + NavyBlue: fromRgb([0, 0, 0.5]), + OldLace: fromRgb([0.992, 0.96, 0.9]), + Olive: fromRgb([0.5, 0.5, 0]), + OliveDrab: fromRgb([0.42, 0.556, 0.136]), + Orange: fromRgb([1, 0.648, 0]), + OrangeRed: fromRgb([1, 0.27, 0]), + Orchid: fromRgb([0.855, 0.44, 0.84]), + PaleGoldenrod: fromRgb([0.932, 0.91, 0.668]), + PaleGreen: fromRgb([0.596, 0.985, 0.596]), + PaleTurquoise: fromRgb([0.688, 0.932, 0.932]), + PaleVioletRed: fromRgb([0.86, 0.44, 0.576]), + PapayaWhip: fromRgb([1, 0.936, 0.835]), + PeachPuff: fromRgb([1, 0.855, 0.725]), + Peru: fromRgb([0.804, 0.52, 0.248]), + Pink: fromRgb([1, 0.752, 0.796]), + Plum: fromRgb([0.868, 0.628, 0.868]), + PowderBlue: fromRgb([0.69, 0.88, 0.9]), + Purple: fromRgb([0.5, 0, 0.5]), + Red: fromRgb([1, 0, 0]), + RosyBrown: fromRgb([0.736, 0.56, 0.56]), + RoyalBlue: fromRgb([0.255, 0.41, 0.884]), + SaddleBrown: fromRgb([0.545, 0.27, 0.075]), + Salmon: fromRgb([0.98, 0.5, 0.448]), + SandyBrown: fromRgb([0.956, 0.644, 0.376]), + SeaGreen: fromRgb([0.18, 0.545, 0.34]), + Seashell: fromRgb([1, 0.96, 0.932]), + Sienna: fromRgb([0.628, 0.32, 0.176]), + Silver: fromRgb([0.752, 0.752, 0.752]), + SkyBlue: fromRgb([0.53, 0.808, 0.92]), + SlateBlue: fromRgb([0.415, 0.352, 0.804]), + SlateGray: fromRgb([0.44, 0.5, 0.565]), + SlateGrey: fromRgb([0.44, 0.5, 0.565]), + Snow: fromRgb([1, 0.98, 0.98]), + SpringGreen: fromRgb([0, 1, 0.498]), + SteelBlue: fromRgb([0.275, 0.51, 0.705]), + Tan: fromRgb([0.824, 0.705, 0.55]), + Teal: fromRgb([0, 0.5, 0.5]), + Thistle: fromRgb([0.848, 0.75, 0.848]), + Tomato: fromRgb([1, 0.39, 0.28]), + Turquoise: fromRgb([0.25, 0.88, 0.815]), + Violet: fromRgb([0.932, 0.51, 0.932]), + VioletRed: fromRgb([0.816, 0.125, 0.565]), + Wheat: fromRgb([0.96, 0.87, 0.7]), + White: fromRgb([1, 1, 1]), + WhiteSmoke: fromRgb([0.96, 0.96, 0.96]), + Yellow: fromRgb([1, 1, 0]), + YellowGreen: fromRgb([0.604, 0.804, 0.196]) +}; +const X11_NAMES = { + AntiqueWhite1: fromRgb([1, 0.936, 0.86]), + AntiqueWhite2: fromRgb([0.932, 0.875, 0.8]), + AntiqueWhite3: fromRgb([0.804, 0.752, 0.69]), + AntiqueWhite4: fromRgb([0.545, 0.512, 0.47]), + Aquamarine1: fromRgb([0.498, 1, 0.83]), + Aquamarine2: fromRgb([0.464, 0.932, 0.776]), + Aquamarine3: fromRgb([0.4, 0.804, 0.668]), + Aquamarine4: fromRgb([0.27, 0.545, 0.455]), + Azure1: fromRgb([0.94, 1, 1]), + Azure2: fromRgb([0.88, 0.932, 0.932]), + Azure3: fromRgb([0.756, 0.804, 0.804]), + Azure4: fromRgb([0.512, 0.545, 0.545]), + Bisque1: fromRgb([1, 0.894, 0.77]), + Bisque2: fromRgb([0.932, 0.835, 0.716]), + Bisque3: fromRgb([0.804, 0.716, 0.62]), + Bisque4: fromRgb([0.545, 0.49, 0.42]), + Blue1: fromRgb([0, 0, 1]), + Blue2: fromRgb([0, 0, 0.932]), + Blue3: fromRgb([0, 0, 0.804]), + Blue4: fromRgb([0, 0, 0.545]), + Brown1: fromRgb([1, 0.25, 0.25]), + Brown2: fromRgb([0.932, 0.23, 0.23]), + Brown3: fromRgb([0.804, 0.2, 0.2]), + Brown4: fromRgb([0.545, 0.136, 0.136]), + Burlywood1: fromRgb([1, 0.828, 0.608]), + Burlywood2: fromRgb([0.932, 0.772, 0.57]), + Burlywood3: fromRgb([0.804, 0.668, 0.49]), + Burlywood4: fromRgb([0.545, 0.45, 0.332]), + CadetBlue1: fromRgb([0.596, 0.96, 1]), + CadetBlue2: fromRgb([0.556, 0.898, 0.932]), + CadetBlue3: fromRgb([0.48, 0.772, 0.804]), + CadetBlue4: fromRgb([0.325, 0.525, 0.545]), + Chartreuse1: fromRgb([0.498, 1, 0]), + Chartreuse2: fromRgb([0.464, 0.932, 0]), + Chartreuse3: fromRgb([0.4, 0.804, 0]), + Chartreuse4: fromRgb([0.27, 0.545, 0]), + Chocolate1: fromRgb([1, 0.498, 0.14]), + Chocolate2: fromRgb([0.932, 0.464, 0.13]), + Chocolate3: fromRgb([0.804, 0.4, 0.112]), + Chocolate4: fromRgb([0.545, 0.27, 0.075]), + Coral1: fromRgb([1, 0.448, 0.336]), + Coral2: fromRgb([0.932, 0.415, 0.312]), + Coral3: fromRgb([0.804, 0.356, 0.27]), + Coral4: fromRgb([0.545, 0.244, 0.185]), + Cornsilk1: fromRgb([1, 0.972, 0.864]), + Cornsilk2: fromRgb([0.932, 0.91, 0.804]), + Cornsilk3: fromRgb([0.804, 0.785, 0.694]), + Cornsilk4: fromRgb([0.545, 0.532, 0.47]), + Cyan1: fromRgb([0, 1, 1]), + Cyan2: fromRgb([0, 0.932, 0.932]), + Cyan3: fromRgb([0, 0.804, 0.804]), + Cyan4: fromRgb([0, 0.545, 0.545]), + DarkGoldenrod1: fromRgb([1, 0.725, 0.06]), + DarkGoldenrod2: fromRgb([0.932, 0.68, 0.055]), + DarkGoldenrod3: fromRgb([0.804, 0.585, 0.048]), + DarkGoldenrod4: fromRgb([0.545, 0.396, 0.03]), + DarkOliveGreen1: fromRgb([0.792, 1, 0.44]), + DarkOliveGreen2: fromRgb([0.736, 0.932, 0.408]), + DarkOliveGreen3: fromRgb([0.635, 0.804, 0.352]), + DarkOliveGreen4: fromRgb([0.43, 0.545, 0.24]), + DarkOrange1: fromRgb([1, 0.498, 0]), + DarkOrange2: fromRgb([0.932, 0.464, 0]), + DarkOrange3: fromRgb([0.804, 0.4, 0]), + DarkOrange4: fromRgb([0.545, 0.27, 0]), + DarkOrchid1: fromRgb([0.75, 0.244, 1]), + DarkOrchid2: fromRgb([0.698, 0.228, 0.932]), + DarkOrchid3: fromRgb([0.604, 0.196, 0.804]), + DarkOrchid4: fromRgb([0.408, 0.132, 0.545]), + DarkSeaGreen1: fromRgb([0.756, 1, 0.756]), + DarkSeaGreen2: fromRgb([0.705, 0.932, 0.705]), + DarkSeaGreen3: fromRgb([0.608, 0.804, 0.608]), + DarkSeaGreen4: fromRgb([0.41, 0.545, 0.41]), + DarkSlateGray1: fromRgb([0.592, 1, 1]), + DarkSlateGray2: fromRgb([0.552, 0.932, 0.932]), + DarkSlateGray3: fromRgb([0.475, 0.804, 0.804]), + DarkSlateGray4: fromRgb([0.32, 0.545, 0.545]), + DeepPink1: fromRgb([1, 0.08, 0.576]), + DeepPink2: fromRgb([0.932, 0.07, 0.536]), + DeepPink3: fromRgb([0.804, 0.064, 0.464]), + DeepPink4: fromRgb([0.545, 0.04, 0.312]), + DeepSkyBlue1: fromRgb([0, 0.75, 1]), + DeepSkyBlue2: fromRgb([0, 0.698, 0.932]), + DeepSkyBlue3: fromRgb([0, 0.604, 0.804]), + DeepSkyBlue4: fromRgb([0, 0.408, 0.545]), + DodgerBlue1: fromRgb([0.116, 0.565, 1]), + DodgerBlue2: fromRgb([0.11, 0.525, 0.932]), + DodgerBlue3: fromRgb([0.094, 0.455, 0.804]), + DodgerBlue4: fromRgb([0.064, 0.305, 0.545]), + Firebrick1: fromRgb([1, 0.19, 0.19]), + Firebrick2: fromRgb([0.932, 0.172, 0.172]), + Firebrick3: fromRgb([0.804, 0.15, 0.15]), + Firebrick4: fromRgb([0.545, 0.1, 0.1]), + Gold1: fromRgb([1, 0.844, 0]), + Gold2: fromRgb([0.932, 0.79, 0]), + Gold3: fromRgb([0.804, 0.68, 0]), + Gold4: fromRgb([0.545, 0.46, 0]), + Goldenrod1: fromRgb([1, 0.756, 0.145]), + Goldenrod2: fromRgb([0.932, 0.705, 0.132]), + Goldenrod3: fromRgb([0.804, 0.608, 0.112]), + Goldenrod4: fromRgb([0.545, 0.41, 0.08]), + Green1: fromRgb([0, 1, 0]), + Green2: fromRgb([0, 0.932, 0]), + Green3: fromRgb([0, 0.804, 0]), + Green4: fromRgb([0, 0.545, 0]), + Honeydew1: fromRgb([0.94, 1, 0.94]), + Honeydew2: fromRgb([0.88, 0.932, 0.88]), + Honeydew3: fromRgb([0.756, 0.804, 0.756]), + Honeydew4: fromRgb([0.512, 0.545, 0.512]), + HotPink1: fromRgb([1, 0.43, 0.705]), + HotPink2: fromRgb([0.932, 0.415, 0.655]), + HotPink3: fromRgb([0.804, 0.376, 0.565]), + HotPink4: fromRgb([0.545, 0.228, 0.385]), + IndianRed1: fromRgb([1, 0.415, 0.415]), + IndianRed2: fromRgb([0.932, 0.39, 0.39]), + IndianRed3: fromRgb([0.804, 0.332, 0.332]), + IndianRed4: fromRgb([0.545, 0.228, 0.228]), + Ivory1: fromRgb([1, 1, 0.94]), + Ivory2: fromRgb([0.932, 0.932, 0.88]), + Ivory3: fromRgb([0.804, 0.804, 0.756]), + Ivory4: fromRgb([0.545, 0.545, 0.512]), + Khaki1: fromRgb([1, 0.965, 0.56]), + Khaki2: fromRgb([0.932, 0.9, 0.52]), + Khaki3: fromRgb([0.804, 0.776, 0.45]), + Khaki4: fromRgb([0.545, 0.525, 0.305]), + LavenderBlush1: fromRgb([1, 0.94, 0.96]), + LavenderBlush2: fromRgb([0.932, 0.88, 0.898]), + LavenderBlush3: fromRgb([0.804, 0.756, 0.772]), + LavenderBlush4: fromRgb([0.545, 0.512, 0.525]), + LemonChiffon1: fromRgb([1, 0.98, 0.804]), + LemonChiffon2: fromRgb([0.932, 0.912, 0.75]), + LemonChiffon3: fromRgb([0.804, 0.79, 0.648]), + LemonChiffon4: fromRgb([0.545, 0.536, 0.44]), + LightBlue1: fromRgb([0.75, 0.936, 1]), + LightBlue2: fromRgb([0.698, 0.875, 0.932]), + LightBlue3: fromRgb([0.604, 0.752, 0.804]), + LightBlue4: fromRgb([0.408, 0.512, 0.545]), + LightCyan1: fromRgb([0.88, 1, 1]), + LightCyan2: fromRgb([0.82, 0.932, 0.932]), + LightCyan3: fromRgb([0.705, 0.804, 0.804]), + LightCyan4: fromRgb([0.48, 0.545, 0.545]), + LightGoldenrod1: fromRgb([1, 0.925, 0.545]), + LightGoldenrod2: fromRgb([0.932, 0.864, 0.51]), + LightGoldenrod3: fromRgb([0.804, 0.745, 0.44]), + LightGoldenrod4: fromRgb([0.545, 0.505, 0.298]), + LightPink1: fromRgb([1, 0.684, 0.725]), + LightPink2: fromRgb([0.932, 0.635, 0.68]), + LightPink3: fromRgb([0.804, 0.55, 0.585]), + LightPink4: fromRgb([0.545, 0.372, 0.396]), + LightSalmon1: fromRgb([1, 0.628, 0.48]), + LightSalmon2: fromRgb([0.932, 0.585, 0.448]), + LightSalmon3: fromRgb([0.804, 0.505, 0.385]), + LightSalmon4: fromRgb([0.545, 0.34, 0.26]), + LightSkyBlue1: fromRgb([0.69, 0.888, 1]), + LightSkyBlue2: fromRgb([0.644, 0.828, 0.932]), + LightSkyBlue3: fromRgb([0.552, 0.712, 0.804]), + LightSkyBlue4: fromRgb([0.376, 0.484, 0.545]), + LightSteelBlue1: fromRgb([0.792, 0.884, 1]), + LightSteelBlue2: fromRgb([0.736, 0.824, 0.932]), + LightSteelBlue3: fromRgb([0.635, 0.71, 0.804]), + LightSteelBlue4: fromRgb([0.43, 0.484, 0.545]), + LightYellow1: fromRgb([1, 1, 0.88]), + LightYellow2: fromRgb([0.932, 0.932, 0.82]), + LightYellow3: fromRgb([0.804, 0.804, 0.705]), + LightYellow4: fromRgb([0.545, 0.545, 0.48]), + Magenta1: fromRgb([1, 0, 1]), + Magenta2: fromRgb([0.932, 0, 0.932]), + Magenta3: fromRgb([0.804, 0, 0.804]), + Magenta4: fromRgb([0.545, 0, 0.545]), + Maroon1: fromRgb([1, 0.204, 0.7]), + Maroon2: fromRgb([0.932, 0.19, 0.655]), + Maroon3: fromRgb([0.804, 0.16, 0.565]), + Maroon4: fromRgb([0.545, 0.11, 0.385]), + MediumOrchid1: fromRgb([0.88, 0.4, 1]), + MediumOrchid2: fromRgb([0.82, 0.372, 0.932]), + MediumOrchid3: fromRgb([0.705, 0.32, 0.804]), + MediumOrchid4: fromRgb([0.48, 0.215, 0.545]), + MediumPurple1: fromRgb([0.67, 0.51, 1]), + MediumPurple2: fromRgb([0.624, 0.475, 0.932]), + MediumPurple3: fromRgb([0.536, 0.408, 0.804]), + MediumPurple4: fromRgb([0.365, 0.28, 0.545]), + MistyRose1: fromRgb([1, 0.894, 0.884]), + MistyRose2: fromRgb([0.932, 0.835, 0.824]), + MistyRose3: fromRgb([0.804, 0.716, 0.71]), + MistyRose4: fromRgb([0.545, 0.49, 0.484]), + NavajoWhite1: fromRgb([1, 0.87, 0.68]), + NavajoWhite2: fromRgb([0.932, 0.81, 0.63]), + NavajoWhite3: fromRgb([0.804, 0.7, 0.545]), + NavajoWhite4: fromRgb([0.545, 0.475, 0.37]), + OliveDrab1: fromRgb([0.752, 1, 0.244]), + OliveDrab2: fromRgb([0.7, 0.932, 0.228]), + OliveDrab3: fromRgb([0.604, 0.804, 0.196]), + OliveDrab4: fromRgb([0.41, 0.545, 0.132]), + Orange1: fromRgb([1, 0.648, 0]), + Orange2: fromRgb([0.932, 0.604, 0]), + Orange3: fromRgb([0.804, 0.52, 0]), + Orange4: fromRgb([0.545, 0.352, 0]), + OrangeRed1: fromRgb([1, 0.27, 0]), + OrangeRed2: fromRgb([0.932, 0.25, 0]), + OrangeRed3: fromRgb([0.804, 0.215, 0]), + OrangeRed4: fromRgb([0.545, 0.145, 0]), + Orchid1: fromRgb([1, 0.512, 0.98]), + Orchid2: fromRgb([0.932, 0.48, 0.912]), + Orchid3: fromRgb([0.804, 0.41, 0.79]), + Orchid4: fromRgb([0.545, 0.28, 0.536]), + PaleGreen1: fromRgb([0.604, 1, 0.604]), + PaleGreen2: fromRgb([0.565, 0.932, 0.565]), + PaleGreen3: fromRgb([0.488, 0.804, 0.488]), + PaleGreen4: fromRgb([0.33, 0.545, 0.33]), + PaleTurquoise1: fromRgb([0.732, 1, 1]), + PaleTurquoise2: fromRgb([0.684, 0.932, 0.932]), + PaleTurquoise3: fromRgb([0.59, 0.804, 0.804]), + PaleTurquoise4: fromRgb([0.4, 0.545, 0.545]), + PaleVioletRed1: fromRgb([1, 0.51, 0.67]), + PaleVioletRed2: fromRgb([0.932, 0.475, 0.624]), + PaleVioletRed3: fromRgb([0.804, 0.408, 0.536]), + PaleVioletRed4: fromRgb([0.545, 0.28, 0.365]), + PeachPuff1: fromRgb([1, 0.855, 0.725]), + PeachPuff2: fromRgb([0.932, 0.796, 0.68]), + PeachPuff3: fromRgb([0.804, 0.688, 0.585]), + PeachPuff4: fromRgb([0.545, 0.468, 0.396]), + Pink1: fromRgb([1, 0.71, 0.772]), + Pink2: fromRgb([0.932, 0.664, 0.72]), + Pink3: fromRgb([0.804, 0.57, 0.62]), + Pink4: fromRgb([0.545, 0.39, 0.424]), + Plum1: fromRgb([1, 0.732, 1]), + Plum2: fromRgb([0.932, 0.684, 0.932]), + Plum3: fromRgb([0.804, 0.59, 0.804]), + Plum4: fromRgb([0.545, 0.4, 0.545]), + Purple1: fromRgb([0.608, 0.19, 1]), + Purple2: fromRgb([0.57, 0.172, 0.932]), + Purple3: fromRgb([0.49, 0.15, 0.804]), + Purple4: fromRgb([0.332, 0.1, 0.545]), + Red1: fromRgb([1, 0, 0]), + Red2: fromRgb([0.932, 0, 0]), + Red3: fromRgb([0.804, 0, 0]), + Red4: fromRgb([0.545, 0, 0]), + RosyBrown1: fromRgb([1, 0.756, 0.756]), + RosyBrown2: fromRgb([0.932, 0.705, 0.705]), + RosyBrown3: fromRgb([0.804, 0.608, 0.608]), + RosyBrown4: fromRgb([0.545, 0.41, 0.41]), + RoyalBlue1: fromRgb([0.284, 0.464, 1]), + RoyalBlue2: fromRgb([0.264, 0.43, 0.932]), + RoyalBlue3: fromRgb([0.228, 0.372, 0.804]), + RoyalBlue4: fromRgb([0.152, 0.25, 0.545]), + Salmon1: fromRgb([1, 0.55, 0.41]), + Salmon2: fromRgb([0.932, 0.51, 0.385]), + Salmon3: fromRgb([0.804, 0.44, 0.33]), + Salmon4: fromRgb([0.545, 0.298, 0.224]), + SeaGreen1: fromRgb([0.33, 1, 0.624]), + SeaGreen2: fromRgb([0.305, 0.932, 0.58]), + SeaGreen3: fromRgb([0.264, 0.804, 0.5]), + SeaGreen4: fromRgb([0.18, 0.545, 0.34]), + Seashell1: fromRgb([1, 0.96, 0.932]), + Seashell2: fromRgb([0.932, 0.898, 0.87]), + Seashell3: fromRgb([0.804, 0.772, 0.75]), + Seashell4: fromRgb([0.545, 0.525, 0.51]), + Sienna1: fromRgb([1, 0.51, 0.28]), + Sienna2: fromRgb([0.932, 0.475, 0.26]), + Sienna3: fromRgb([0.804, 0.408, 0.224]), + Sienna4: fromRgb([0.545, 0.28, 0.15]), + SkyBlue1: fromRgb([0.53, 0.808, 1]), + SkyBlue2: fromRgb([0.494, 0.752, 0.932]), + SkyBlue3: fromRgb([0.424, 0.65, 0.804]), + SkyBlue4: fromRgb([0.29, 0.44, 0.545]), + SlateBlue1: fromRgb([0.512, 0.435, 1]), + SlateBlue2: fromRgb([0.48, 0.404, 0.932]), + SlateBlue3: fromRgb([0.41, 0.35, 0.804]), + SlateBlue4: fromRgb([0.28, 0.235, 0.545]), + SlateGray1: fromRgb([0.776, 0.888, 1]), + SlateGray2: fromRgb([0.725, 0.828, 0.932]), + SlateGray3: fromRgb([0.624, 0.712, 0.804]), + SlateGray4: fromRgb([0.424, 0.484, 0.545]), + Snow1: fromRgb([1, 0.98, 0.98]), + Snow2: fromRgb([0.932, 0.912, 0.912]), + Snow3: fromRgb([0.804, 0.79, 0.79]), + Snow4: fromRgb([0.545, 0.536, 0.536]), + SpringGreen1: fromRgb([0, 1, 0.498]), + SpringGreen2: fromRgb([0, 0.932, 0.464]), + SpringGreen3: fromRgb([0, 0.804, 0.4]), + SpringGreen4: fromRgb([0, 0.545, 0.27]), + SteelBlue1: fromRgb([0.39, 0.72, 1]), + SteelBlue2: fromRgb([0.36, 0.675, 0.932]), + SteelBlue3: fromRgb([0.31, 0.58, 0.804]), + SteelBlue4: fromRgb([0.21, 0.392, 0.545]), + Tan1: fromRgb([1, 0.648, 0.31]), + Tan2: fromRgb([0.932, 0.604, 0.288]), + Tan3: fromRgb([0.804, 0.52, 0.248]), + Tan4: fromRgb([0.545, 0.352, 0.17]), + Thistle1: fromRgb([1, 0.884, 1]), + Thistle2: fromRgb([0.932, 0.824, 0.932]), + Thistle3: fromRgb([0.804, 0.71, 0.804]), + Thistle4: fromRgb([0.545, 0.484, 0.545]), + Tomato1: fromRgb([1, 0.39, 0.28]), + Tomato2: fromRgb([0.932, 0.36, 0.26]), + Tomato3: fromRgb([0.804, 0.31, 0.224]), + Tomato4: fromRgb([0.545, 0.21, 0.15]), + Turquoise1: fromRgb([0, 0.96, 1]), + Turquoise2: fromRgb([0, 0.898, 0.932]), + Turquoise3: fromRgb([0, 0.772, 0.804]), + Turquoise4: fromRgb([0, 0.525, 0.545]), + VioletRed1: fromRgb([1, 0.244, 0.59]), + VioletRed2: fromRgb([0.932, 0.228, 0.55]), + VioletRed3: fromRgb([0.804, 0.196, 0.47]), + VioletRed4: fromRgb([0.545, 0.132, 0.32]), + Wheat1: fromRgb([1, 0.905, 0.73]), + Wheat2: fromRgb([0.932, 0.848, 0.684]), + Wheat3: fromRgb([0.804, 0.73, 0.59]), + Wheat4: fromRgb([0.545, 0.494, 0.4]), + Yellow1: fromRgb([1, 1, 0]), + Yellow2: fromRgb([0.932, 0.932, 0]), + Yellow3: fromRgb([0.804, 0.804, 0]), + Yellow4: fromRgb([0.545, 0.545, 0]), + Gray0: fromRgb([0.745, 0.745, 0.745]), + Green0: fromRgb([0, 1, 0]), + Grey0: fromRgb([0.745, 0.745, 0.745]), + Maroon0: fromRgb([0.69, 0.19, 0.376]), + Purple0: fromRgb([0.628, 0.125, 0.94]) +}; +const parseCache = {}; +function parse(str = "") { + parseCache[str] = parseCache[str] || unifiedLatexUtilPegjs.XColorPegParser.parse(str); + return parseCache[str]; +} +const CORE_MODELS = /* @__PURE__ */ new Set(["rgb", "cmy", "cmyk", "hsb", "gray"]); +const XColorCoreModelToColor = { + rgb: ([r, g, b]) => Color([r * 255, g * 255, b * 255], "rgb"), + cmy: ([c, m, y]) => XColorCoreModelToColor.rgb([1 - c, 1 - m, 1 - y]), + cmyk: ([c, m, y, k]) => Color([c * 255, m * 255, y * 255, k * 100], "cmyk"), + hsb: ([h, s, b]) => Color([h * 360, s * 100, b * 100], "hsv"), + gray: ([v]) => Color([v * 255, v * 255, v * 255], "rgb") +}; +const XColorModelToColor = { + wave: ([lambda]) => { + const gamma = 0.8; + let baseRgb = [0, 0, 0]; + if (380 <= lambda && lambda < 440) { + baseRgb = [(440 - lambda) / (440 - 380), 0, 1]; + } + if (440 <= lambda && lambda < 490) { + baseRgb = [0, (lambda - 440) / (490 - 440), 1]; + } + if (490 <= lambda && lambda < 510) { + baseRgb = [0, 1, (510 - lambda) / (510 - 490)]; + } + if (510 <= lambda && lambda < 580) { + baseRgb = [(lambda - 510) / (580 - 510), 1, 0]; + } + if (580 <= lambda && lambda < 6450) { + baseRgb = [1, (645 - lambda) / (645 - 580), 0]; + } + if (645 <= lambda && lambda <= 780) { + baseRgb = [1, 0, 0]; + } + let f = 1; + if (380 <= lambda && 420 < lambda) { + f = 0.3 + 0.7 * (lambda - 380) / (420 - 380); + } + if (700 < lambda && lambda <= 780) { + f = 0.3 + 0.7 * (780 - lambda) / (780 - 700); + } + const rgb = [ + Math.pow(baseRgb[0] * f, gamma), + Math.pow(baseRgb[1] * f, gamma), + Math.pow(baseRgb[2] * f, gamma) + ]; + return Color([rgb[0] * 255, rgb[1] * 255, rgb[2] * 255], "rgb"); + }, + Hsb: ([h, s, b]) => XColorCoreModelToColor.hsb([h / 360, s, b]), + HSB: ([h, s, b]) => XColorCoreModelToColor.hsb([h / 240, s / 240, b / 240]), + HTML: ([v]) => v.startsWith("#") ? Color(v) : Color(`#${v}`), + RGB: ([r, g, b]) => Color([r, g, b], "rgb"), + Gray: ([v]) => XColorCoreModelToColor.gray([v / 15]), + ...XColorCoreModelToColor +}; +const ColorToXColorModel = { + rgb: (color) => color.rgb().array().map((v) => v / 255), + cmy: (color) => [255 - color.red(), 255 - color.green(), 255 - color.blue()].map( + (v) => v / 255 + ), + cmyk: (color) => color.cmyk().array().map((v, i) => i === 3 ? v / 100 : v / 255), + hsb: (color) => [ + color.hue() / 360, + color.saturationv() / 100, + color.value() / 100 + ], + gray: (color) => [color.gray() / 100] +}; +const PREDEFINED_XCOLOR_COLORS = { + // Core colors + red: XColorCoreModelToColor.rgb([1, 0, 0]), + green: XColorCoreModelToColor.rgb([0, 1, 0]), + blue: XColorCoreModelToColor.rgb([0, 0, 1]), + brown: XColorCoreModelToColor.rgb([0.75, 0.5, 0.25]), + lime: XColorCoreModelToColor.rgb([0.75, 1, 0]), + orange: XColorCoreModelToColor.rgb([1, 0.5, 0]), + pink: XColorCoreModelToColor.rgb([1, 0.75, 0.75]), + purple: XColorCoreModelToColor.rgb([0.75, 0, 0.25]), + teal: XColorCoreModelToColor.rgb([0, 0.5, 0.5]), + violet: XColorCoreModelToColor.rgb([0.5, 0, 0.5]), + cyan: XColorCoreModelToColor.rgb([0, 1, 1]), + magenta: XColorCoreModelToColor.rgb([1, 0, 1]), + yellow: XColorCoreModelToColor.rgb([1, 1, 0]), + olive: XColorCoreModelToColor.rgb([0.5, 0.5, 0]), + black: XColorCoreModelToColor.rgb([0, 0, 0]), + darkgray: XColorCoreModelToColor.rgb([0.25, 0.25, 0.25]), + gray: XColorCoreModelToColor.rgb([0.5, 0.5, 0.5]), + lightgray: XColorCoreModelToColor.rgb([0.75, 0.75, 0.75]), + white: XColorCoreModelToColor.rgb([1, 1, 1]), + ...DVI_PS_NAMES, + ...SVG_NAMES, + ...X11_NAMES +}; +function scalarMul(scalar, vec) { + return vec.map((v) => scalar * v); +} +function addVectors(...vecs) { + return vecs.reduce((prev, current) => prev.map((v, i) => v + current[i])); +} +function mixInModel(model, colorsAndCoefficients) { + if (!CORE_MODELS.has(model)) { + throw new Error( + `Cannot mix colors in model "${model}"; only core modes ${Array.from( + CORE_MODELS + ).join(", ")} are supported` + ); + } + const toModel = ColorToXColorModel[model]; + const fromModel = XColorCoreModelToColor[model]; + const mixed = addVectors( + ...colorsAndCoefficients.map(([v, color]) => { + const colorInModel = toModel(color); + return scalarMul(v, colorInModel); + }) + ); + return fromModel(mixed); +} +function computeColor(expr, predefinedColors = {}) { + if (expr.type !== "color") { + throw new Error( + `Can only compute the color of a "color" expression, not one of type ${expr.type}` + ); + } + const knownColors = { ...PREDEFINED_XCOLOR_COLORS, ...predefinedColors }; + function getColor(name) { + if (!knownColors[name]) { + throw new Error(`Unknown color "${name}"`); + } + return knownColors[name]; + } + const color = expr.color; + let computedColor = Color("#000000"); + if (color.type === "expr") { + let base = getColor(color.name); + for (const mix of color.mix_expr) { + if (mix.type === "complete_mix") { + const mixColor = getColor(mix.name); + base = base.mix(mixColor, 1 - mix.mix_percent / 100); + } else if (mix.type === "partial_mix") { + base = base.mix(Color("#FFFFFF"), 1 - mix.mix_percent / 100); + } + } + if (color.prefix && color.prefix.length % 2 === 1) { + base = base.rotate(180); + } + computedColor = base; + } + if (color.type === "extended_expr") { + const model = color.core_model; + const div = color.div || color.expressions.reduce((a, expr2) => a + expr2.weight, 0); + if (div <= 0) { + throw new Error( + `Cannot mix color with ratios that have a denominator of ${div}` + ); + } + const colorsToMix = color.expressions.map( + (expr2) => [ + expr2.weight / div, + computeColor({ + type: "color", + color: expr2.color, + functions: [] + }) + ] + ); + computedColor = mixInModel(model, colorsToMix); + } + for (const func of expr.functions) { + if (func.name === "wheel") { + const angle = func.args[0]; + const circ = func.args[1] || 360; + computedColor = computedColor.rotate(angle / circ * 360); + } + if (func.name === "twheel") { + const angle = func.args[0]; + const circ = func.args[1] || 360; + computedColor = computedColor.rotate(angle / circ * 360 + 60); + } + } + return computedColor; +} +function xcolorColorToHex(color, model, options = { predefinedColors: {} }) { + const { predefinedColors = {} } = options; + const parsed = parse(color); + if (model && model !== "default" && parsed.type !== "color") { + if (!(model in XColorModelToColor)) { + throw new Error( + `Unknown color model "${model}"; known models are ${Object.keys( + XColorModelToColor + ).join(", ")}` + ); + } + if (parsed.type !== "hex_spec" && parsed.type !== "num_spec") { + throw new Error( + `Cannot use model ${model} to compute the color "${color}"` + ); + } + if (model === "HTML" && parsed.type === "hex_spec") { + return XColorModelToColor.HTML(parsed.content).hex(); + } else if (parsed.type === "num_spec") { + return XColorModelToColor[model](parsed.content).hex(); + } + throw new Error( + `Don't know how to process color "${color}" in model "${model}"` + ); + } + if (Array.isArray(parsed) || parsed.type !== "color") { + throw new Error( + `Cannot the color "${color}" is not a valid color string` + ); + } + let computed = null; + try { + computed = computeColor(parsed, predefinedColors); + } catch (e) { + } + return computed && computed.hex(); +} +exports.DVI_PS_NAMES = DVI_PS_NAMES; +exports.PREDEFINED_XCOLOR_COLORS = PREDEFINED_XCOLOR_COLORS; +exports.SVG_NAMES = SVG_NAMES; +exports.X11_NAMES = X11_NAMES; +exports.XColorCoreModelToColor = XColorCoreModelToColor; +exports.computeColor = computeColor; +exports.environments = environments; +exports.macros = macros; +exports.parse = parse; +exports.xcolorColorToHex = xcolorColorToHex; +//# sourceMappingURL=xcolor-BEfsW_1K.cjs.map diff --git a/node_modules/@unified-latex/unified-latex-ctan/xcolor-BEfsW_1K.cjs.map b/node_modules/@unified-latex/unified-latex-ctan/xcolor-BEfsW_1K.cjs.map new file mode 100644 index 0000000..d9054ab --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-ctan/xcolor-BEfsW_1K.cjs.map @@ -0,0 +1 @@ +{"version":3,"file":"xcolor-BEfsW_1K.cjs","sources":["../package/xcolor/provides.ts","../package/xcolor/libs/predefined-colors.ts","../package/xcolor/libs/parser.ts","../package/xcolor/libs/xcolor.ts"],"sourcesContent":["import {\n MacroInfoRecord,\n EnvInfoRecord,\n} from \"@unified-latex/unified-latex-types\";\n\nexport const macros: MacroInfoRecord = {\n substitutecolormodel: {\n signature: \"m m\",\n renderInfo: { breakAround: true },\n },\n selectcolormodel: {\n signature: \"m\",\n renderInfo: { breakAround: true },\n },\n definecolor: {\n signature: \"o m m m\",\n renderInfo: { breakAround: true },\n },\n providecolor: {\n signature: \"o m m m\",\n renderInfo: { breakAround: true },\n },\n colorlet: {\n signature: \"o m o m\",\n renderInfo: { breakAround: true },\n },\n definecolorset: {\n signature: \"o m m m\",\n renderInfo: { breakAround: true },\n },\n providecolorset: {\n signature: \"o m m m m\",\n renderInfo: { breakAround: true },\n },\n preparecolor: {\n signature: \"o m m m\",\n renderInfo: { breakAround: true },\n },\n preparecolorset: {\n signature: \"o m m m m\",\n renderInfo: { breakAround: true },\n },\n DefineNamedColor: {\n signature: \"m m m m\",\n renderInfo: { breakAround: true },\n },\n definecolors: {\n signature: \"m\",\n renderInfo: { breakAround: true },\n },\n providecolors: {\n signature: \"m\",\n renderInfo: { breakAround: true },\n },\n color: { signature: \"o m\", renderInfo: { breakAround: true } },\n textcolor: { signature: \"o m m\", renderInfo: { inParMode: true } },\n pagecolor: { signature: \"o m\" },\n colorbox: { signature: \"o m m\" },\n fcolorbox: { signature: \"o m o m m\" },\n boxframe: { signature: \"o m\" },\n testcolor: { signature: \"o m\" },\n blendcolors: { signature: \"s m\" },\n maskcolors: { signature: \"o m\" },\n definecolorseries: {\n signature: \"m m m o m o m\",\n renderInfo: { breakAround: true },\n },\n resetcolorseries: {\n signature: \"o m\",\n renderInfo: { breakAround: true },\n },\n rowcolors: { signature: \"s o m m m\" },\n extractcolorspec: { signature: \"m m\" },\n extractcolorspecs: { signature: \"m m m\" },\n convertcolorspec: { signature: \"m m m m\" },\n};\n\nexport const environments: EnvInfoRecord = {\n testcolors: { signature: \"o\", renderInfo: { pgfkeysArgs: true } },\n};\n","import Color from \"color\";\n\nconst fromRgb = ([r, g, b]: number[]) =>\n Color([r * 255, g * 255, b * 255], \"rgb\");\n\nexport const DVI_PS_NAMES = {\n Apricot: Color(\"#FBB982\"),\n Aquamarine: Color(\"#00B5BE\"),\n Bittersweet: Color(\"#C04F17\"),\n Black: Color(\"#221E1F\"),\n Blue: Color(\"#2D2F92\"),\n BlueGreen: Color(\"#00B3B8\"),\n BlueViolet: Color(\"#473992\"),\n BrickRed: Color(\"#B6321C\"),\n Brown: Color(\"#792500\"),\n BurntOrange: Color(\"#F7921D\"),\n CadetBlue: Color(\"#74729A\"),\n CarnationPink: Color(\"#F282B4\"),\n Cerulean: Color(\"#00A2E3\"),\n CornflowerBlue: Color(\"#41B0E4\"),\n Cyan: Color(\"#00AEEF\"),\n Dandelion: Color(\"#FDBC42\"),\n DarkOrchid: Color(\"#A4538A\"),\n Emerald: Color(\"#00A99D\"),\n ForestGreen: Color(\"#009B55\"),\n Fuchsia: Color(\"#8C368C\"),\n Goldenrod: Color(\"#FFDF42\"),\n Gray: Color(\"#949698\"),\n Green: Color(\"#00A64F\"),\n GreenYellow: Color(\"#DFE674\"),\n JungleGreen: Color(\"#00A99A\"),\n Lavender: Color(\"#F49EC4\"),\n LimeGreen: Color(\"#8DC73E\"),\n Magenta: Color(\"#EC008C\"),\n Mahogany: Color(\"#A9341F\"),\n Maroon: Color(\"#AF3235\"),\n Melon: Color(\"#F89E7B\"),\n MidnightBlue: Color(\"#006795\"),\n Mulberry: Color(\"#A93C93\"),\n NavyBlue: Color(\"#006EB8\"),\n OliveGreen: Color(\"#3C8031\"),\n Orange: Color(\"#F58137\"),\n OrangeRed: Color(\"#ED135A\"),\n Orchid: Color(\"#AF72B0\"),\n Peach: Color(\"#F7965A\"),\n Periwinkle: Color(\"#7977B8\"),\n PineGreen: Color(\"#008B72\"),\n Plum: Color(\"#92268F\"),\n ProcessBlue: Color(\"#00B0F0\"),\n Purple: Color(\"#99479B\"),\n RawSienna: Color(\"#974006\"),\n Red: Color(\"#ED1B23\"),\n RedOrange: Color(\"#F26035\"),\n RedViolet: Color(\"#A1246B\"),\n Rhodamine: Color(\"#EF559F\"),\n RoyalBlue: Color(\"#0071BC\"),\n RoyalPurple: Color(\"#613F99\"),\n RubineRed: Color(\"#ED017D\"),\n Salmon: Color(\"#F69289\"),\n SeaGreen: Color(\"#3FBC9D\"),\n Sepia: Color(\"#671800\"),\n SkyBlue: Color(\"#46C5DD\"),\n SpringGreen: Color(\"#C6DC67\"),\n Tan: Color(\"#DA9D76\"),\n TealBlue: Color(\"#00AEB3\"),\n Thistle: Color(\"#D883B7\"),\n Turquoise: Color(\"#00B4CE\"),\n Violet: Color(\"#58429B\"),\n VioletRed: Color(\"#EF58A0\"),\n White: Color(\"#FFFFFF\"),\n WildStrawberry: Color(\"#EE2967\"),\n Yellow: Color(\"#FFF200\"),\n YellowGreen: Color(\"#98CC70\"),\n YellowOrange: Color(\"#FAA21A\"),\n};\n\nexport const SVG_NAMES = {\n AliceBlue: fromRgb([0.94, 0.972, 1]),\n AntiqueWhite: fromRgb([0.98, 0.92, 0.844]),\n Aqua: fromRgb([0, 1, 1]),\n Aquamarine: fromRgb([0.498, 1, 0.83]),\n Azure: fromRgb([0.94, 1, 1]),\n Beige: fromRgb([0.96, 0.96, 0.864]),\n Bisque: fromRgb([1, 0.894, 0.77]),\n Black: fromRgb([0, 0, 0]),\n BlanchedAlmond: fromRgb([1, 0.92, 0.804]),\n Blue: fromRgb([0, 0, 1]),\n BlueViolet: fromRgb([0.54, 0.17, 0.888]),\n Brown: fromRgb([0.648, 0.165, 0.165]),\n BurlyWood: fromRgb([0.87, 0.72, 0.53]),\n CadetBlue: fromRgb([0.372, 0.62, 0.628]),\n Chartreuse: fromRgb([0.498, 1, 0]),\n Chocolate: fromRgb([0.824, 0.41, 0.116]),\n Coral: fromRgb([1, 0.498, 0.312]),\n CornflowerBlue: fromRgb([0.392, 0.585, 0.93]),\n Cornsilk: fromRgb([1, 0.972, 0.864]),\n Crimson: fromRgb([0.864, 0.08, 0.235]),\n Cyan: fromRgb([0, 1, 1]),\n DarkBlue: fromRgb([0, 0, 0.545]),\n DarkCyan: fromRgb([0, 0.545, 0.545]),\n DarkGoldenrod: fromRgb([0.72, 0.525, 0.044]),\n DarkGray: fromRgb([0.664, 0.664, 0.664]),\n DarkGreen: fromRgb([0, 0.392, 0]),\n DarkGrey: fromRgb([0.664, 0.664, 0.664]),\n DarkKhaki: fromRgb([0.74, 0.716, 0.42]),\n DarkMagenta: fromRgb([0.545, 0, 0.545]),\n DarkOliveGreen: fromRgb([0.332, 0.42, 0.185]),\n DarkOrange: fromRgb([1, 0.55, 0]),\n DarkOrchid: fromRgb([0.6, 0.196, 0.8]),\n DarkRed: fromRgb([0.545, 0, 0]),\n DarkSalmon: fromRgb([0.912, 0.59, 0.48]),\n DarkSeaGreen: fromRgb([0.56, 0.736, 0.56]),\n DarkSlateBlue: fromRgb([0.284, 0.24, 0.545]),\n DarkSlateGray: fromRgb([0.185, 0.31, 0.31]),\n DarkSlateGrey: fromRgb([0.185, 0.31, 0.31]),\n DarkTurquoise: fromRgb([0, 0.808, 0.82]),\n DarkViolet: fromRgb([0.58, 0, 0.828]),\n DeepPink: fromRgb([1, 0.08, 0.576]),\n DeepSkyBlue: fromRgb([0, 0.75, 1]),\n DimGray: fromRgb([0.41, 0.41, 0.41]),\n DimGrey: fromRgb([0.41, 0.41, 0.41]),\n DodgerBlue: fromRgb([0.116, 0.565, 1]),\n FireBrick: fromRgb([0.698, 0.132, 0.132]),\n FloralWhite: fromRgb([1, 0.98, 0.94]),\n ForestGreen: fromRgb([0.132, 0.545, 0.132]),\n Fuchsia: fromRgb([1, 0, 1]),\n Gainsboro: fromRgb([0.864, 0.864, 0.864]),\n GhostWhite: fromRgb([0.972, 0.972, 1]),\n Gold: fromRgb([1, 0.844, 0]),\n Goldenrod: fromRgb([0.855, 0.648, 0.125]),\n Gray: fromRgb([0.5, 0.5, 0.5]),\n Green: fromRgb([0, 0.5, 0]),\n GreenYellow: fromRgb([0.68, 1, 0.185]),\n Grey: fromRgb([0.5, 0.5, 0.5]),\n Honeydew: fromRgb([0.94, 1, 0.94]),\n HotPink: fromRgb([1, 0.41, 0.705]),\n IndianRed: fromRgb([0.804, 0.36, 0.36]),\n Indigo: fromRgb([0.294, 0, 0.51]),\n Ivory: fromRgb([1, 1, 0.94]),\n Khaki: fromRgb([0.94, 0.9, 0.55]),\n Lavender: fromRgb([0.9, 0.9, 0.98]),\n LavenderBlush: fromRgb([1, 0.94, 0.96]),\n LawnGreen: fromRgb([0.488, 0.99, 0]),\n LemonChiffon: fromRgb([1, 0.98, 0.804]),\n LightBlue: fromRgb([0.68, 0.848, 0.9]),\n LightCoral: fromRgb([0.94, 0.5, 0.5]),\n LightCyan: fromRgb([0.88, 1, 1]),\n LightGoldenrod: fromRgb([0.933, 0.867, 0.51]),\n LightGoldenrodYellow: fromRgb([0.98, 0.98, 0.824]),\n LightGray: fromRgb([0.828, 0.828, 0.828]),\n LightGreen: fromRgb([0.565, 0.932, 0.565]),\n LightGrey: fromRgb([0.828, 0.828, 0.828]),\n LightPink: fromRgb([1, 0.712, 0.756]),\n LightSalmon: fromRgb([1, 0.628, 0.48]),\n LightSeaGreen: fromRgb([0.125, 0.698, 0.668]),\n LightSkyBlue: fromRgb([0.53, 0.808, 0.98]),\n LightSlateBlue: fromRgb([0.518, 0.44, 1]),\n LightSlateGray: fromRgb([0.468, 0.532, 0.6]),\n LightSlateGrey: fromRgb([0.468, 0.532, 0.6]),\n LightSteelBlue: fromRgb([0.69, 0.77, 0.87]),\n LightYellow: fromRgb([1, 1, 0.88]),\n Lime: fromRgb([0, 1, 0]),\n LimeGreen: fromRgb([0.196, 0.804, 0.196]),\n Linen: fromRgb([0.98, 0.94, 0.9]),\n Magenta: fromRgb([1, 0, 1]),\n Maroon: fromRgb([0.5, 0, 0]),\n MediumAquamarine: fromRgb([0.4, 0.804, 0.668]),\n MediumBlue: fromRgb([0, 0, 0.804]),\n MediumOrchid: fromRgb([0.73, 0.332, 0.828]),\n MediumPurple: fromRgb([0.576, 0.44, 0.86]),\n MediumSeaGreen: fromRgb([0.235, 0.7, 0.444]),\n MediumSlateBlue: fromRgb([0.484, 0.408, 0.932]),\n MediumSpringGreen: fromRgb([0, 0.98, 0.604]),\n MediumTurquoise: fromRgb([0.284, 0.82, 0.8]),\n MediumVioletRed: fromRgb([0.78, 0.084, 0.52]),\n MidnightBlue: fromRgb([0.098, 0.098, 0.44]),\n MintCream: fromRgb([0.96, 1, 0.98]),\n MistyRose: fromRgb([1, 0.894, 0.884]),\n Moccasin: fromRgb([1, 0.894, 0.71]),\n NavajoWhite: fromRgb([1, 0.87, 0.68]),\n Navy: fromRgb([0, 0, 0.5]),\n NavyBlue: fromRgb([0, 0, 0.5]),\n OldLace: fromRgb([0.992, 0.96, 0.9]),\n Olive: fromRgb([0.5, 0.5, 0]),\n OliveDrab: fromRgb([0.42, 0.556, 0.136]),\n Orange: fromRgb([1, 0.648, 0]),\n OrangeRed: fromRgb([1, 0.27, 0]),\n Orchid: fromRgb([0.855, 0.44, 0.84]),\n PaleGoldenrod: fromRgb([0.932, 0.91, 0.668]),\n PaleGreen: fromRgb([0.596, 0.985, 0.596]),\n PaleTurquoise: fromRgb([0.688, 0.932, 0.932]),\n PaleVioletRed: fromRgb([0.86, 0.44, 0.576]),\n PapayaWhip: fromRgb([1, 0.936, 0.835]),\n PeachPuff: fromRgb([1, 0.855, 0.725]),\n Peru: fromRgb([0.804, 0.52, 0.248]),\n Pink: fromRgb([1, 0.752, 0.796]),\n Plum: fromRgb([0.868, 0.628, 0.868]),\n PowderBlue: fromRgb([0.69, 0.88, 0.9]),\n Purple: fromRgb([0.5, 0, 0.5]),\n Red: fromRgb([1, 0, 0]),\n RosyBrown: fromRgb([0.736, 0.56, 0.56]),\n RoyalBlue: fromRgb([0.255, 0.41, 0.884]),\n SaddleBrown: fromRgb([0.545, 0.27, 0.075]),\n Salmon: fromRgb([0.98, 0.5, 0.448]),\n SandyBrown: fromRgb([0.956, 0.644, 0.376]),\n SeaGreen: fromRgb([0.18, 0.545, 0.34]),\n Seashell: fromRgb([1, 0.96, 0.932]),\n Sienna: fromRgb([0.628, 0.32, 0.176]),\n Silver: fromRgb([0.752, 0.752, 0.752]),\n SkyBlue: fromRgb([0.53, 0.808, 0.92]),\n SlateBlue: fromRgb([0.415, 0.352, 0.804]),\n SlateGray: fromRgb([0.44, 0.5, 0.565]),\n SlateGrey: fromRgb([0.44, 0.5, 0.565]),\n Snow: fromRgb([1, 0.98, 0.98]),\n SpringGreen: fromRgb([0, 1, 0.498]),\n SteelBlue: fromRgb([0.275, 0.51, 0.705]),\n Tan: fromRgb([0.824, 0.705, 0.55]),\n Teal: fromRgb([0, 0.5, 0.5]),\n Thistle: fromRgb([0.848, 0.75, 0.848]),\n Tomato: fromRgb([1, 0.39, 0.28]),\n Turquoise: fromRgb([0.25, 0.88, 0.815]),\n Violet: fromRgb([0.932, 0.51, 0.932]),\n VioletRed: fromRgb([0.816, 0.125, 0.565]),\n Wheat: fromRgb([0.96, 0.87, 0.7]),\n White: fromRgb([1, 1, 1]),\n WhiteSmoke: fromRgb([0.96, 0.96, 0.96]),\n Yellow: fromRgb([1, 1, 0]),\n YellowGreen: fromRgb([0.604, 0.804, 0.196]),\n};\n\nexport const X11_NAMES = {\n AntiqueWhite1: fromRgb([1, 0.936, 0.86]),\n AntiqueWhite2: fromRgb([0.932, 0.875, 0.8]),\n AntiqueWhite3: fromRgb([0.804, 0.752, 0.69]),\n AntiqueWhite4: fromRgb([0.545, 0.512, 0.47]),\n Aquamarine1: fromRgb([0.498, 1, 0.83]),\n Aquamarine2: fromRgb([0.464, 0.932, 0.776]),\n Aquamarine3: fromRgb([0.4, 0.804, 0.668]),\n Aquamarine4: fromRgb([0.27, 0.545, 0.455]),\n Azure1: fromRgb([0.94, 1, 1]),\n Azure2: fromRgb([0.88, 0.932, 0.932]),\n Azure3: fromRgb([0.756, 0.804, 0.804]),\n Azure4: fromRgb([0.512, 0.545, 0.545]),\n Bisque1: fromRgb([1, 0.894, 0.77]),\n Bisque2: fromRgb([0.932, 0.835, 0.716]),\n Bisque3: fromRgb([0.804, 0.716, 0.62]),\n Bisque4: fromRgb([0.545, 0.49, 0.42]),\n Blue1: fromRgb([0, 0, 1]),\n Blue2: fromRgb([0, 0, 0.932]),\n Blue3: fromRgb([0, 0, 0.804]),\n Blue4: fromRgb([0, 0, 0.545]),\n Brown1: fromRgb([1, 0.25, 0.25]),\n Brown2: fromRgb([0.932, 0.23, 0.23]),\n Brown3: fromRgb([0.804, 0.2, 0.2]),\n Brown4: fromRgb([0.545, 0.136, 0.136]),\n Burlywood1: fromRgb([1, 0.828, 0.608]),\n Burlywood2: fromRgb([0.932, 0.772, 0.57]),\n Burlywood3: fromRgb([0.804, 0.668, 0.49]),\n Burlywood4: fromRgb([0.545, 0.45, 0.332]),\n CadetBlue1: fromRgb([0.596, 0.96, 1]),\n CadetBlue2: fromRgb([0.556, 0.898, 0.932]),\n CadetBlue3: fromRgb([0.48, 0.772, 0.804]),\n CadetBlue4: fromRgb([0.325, 0.525, 0.545]),\n Chartreuse1: fromRgb([0.498, 1, 0]),\n Chartreuse2: fromRgb([0.464, 0.932, 0]),\n Chartreuse3: fromRgb([0.4, 0.804, 0]),\n Chartreuse4: fromRgb([0.27, 0.545, 0]),\n Chocolate1: fromRgb([1, 0.498, 0.14]),\n Chocolate2: fromRgb([0.932, 0.464, 0.13]),\n Chocolate3: fromRgb([0.804, 0.4, 0.112]),\n Chocolate4: fromRgb([0.545, 0.27, 0.075]),\n Coral1: fromRgb([1, 0.448, 0.336]),\n Coral2: fromRgb([0.932, 0.415, 0.312]),\n Coral3: fromRgb([0.804, 0.356, 0.27]),\n Coral4: fromRgb([0.545, 0.244, 0.185]),\n Cornsilk1: fromRgb([1, 0.972, 0.864]),\n Cornsilk2: fromRgb([0.932, 0.91, 0.804]),\n Cornsilk3: fromRgb([0.804, 0.785, 0.694]),\n Cornsilk4: fromRgb([0.545, 0.532, 0.47]),\n Cyan1: fromRgb([0, 1, 1]),\n Cyan2: fromRgb([0, 0.932, 0.932]),\n Cyan3: fromRgb([0, 0.804, 0.804]),\n Cyan4: fromRgb([0, 0.545, 0.545]),\n DarkGoldenrod1: fromRgb([1, 0.725, 0.06]),\n DarkGoldenrod2: fromRgb([0.932, 0.68, 0.055]),\n DarkGoldenrod3: fromRgb([0.804, 0.585, 0.048]),\n DarkGoldenrod4: fromRgb([0.545, 0.396, 0.03]),\n DarkOliveGreen1: fromRgb([0.792, 1, 0.44]),\n DarkOliveGreen2: fromRgb([0.736, 0.932, 0.408]),\n DarkOliveGreen3: fromRgb([0.635, 0.804, 0.352]),\n DarkOliveGreen4: fromRgb([0.43, 0.545, 0.24]),\n DarkOrange1: fromRgb([1, 0.498, 0]),\n DarkOrange2: fromRgb([0.932, 0.464, 0]),\n DarkOrange3: fromRgb([0.804, 0.4, 0]),\n DarkOrange4: fromRgb([0.545, 0.27, 0]),\n DarkOrchid1: fromRgb([0.75, 0.244, 1]),\n DarkOrchid2: fromRgb([0.698, 0.228, 0.932]),\n DarkOrchid3: fromRgb([0.604, 0.196, 0.804]),\n DarkOrchid4: fromRgb([0.408, 0.132, 0.545]),\n DarkSeaGreen1: fromRgb([0.756, 1, 0.756]),\n DarkSeaGreen2: fromRgb([0.705, 0.932, 0.705]),\n DarkSeaGreen3: fromRgb([0.608, 0.804, 0.608]),\n DarkSeaGreen4: fromRgb([0.41, 0.545, 0.41]),\n DarkSlateGray1: fromRgb([0.592, 1, 1]),\n DarkSlateGray2: fromRgb([0.552, 0.932, 0.932]),\n DarkSlateGray3: fromRgb([0.475, 0.804, 0.804]),\n DarkSlateGray4: fromRgb([0.32, 0.545, 0.545]),\n DeepPink1: fromRgb([1, 0.08, 0.576]),\n DeepPink2: fromRgb([0.932, 0.07, 0.536]),\n DeepPink3: fromRgb([0.804, 0.064, 0.464]),\n DeepPink4: fromRgb([0.545, 0.04, 0.312]),\n DeepSkyBlue1: fromRgb([0, 0.75, 1]),\n DeepSkyBlue2: fromRgb([0, 0.698, 0.932]),\n DeepSkyBlue3: fromRgb([0, 0.604, 0.804]),\n DeepSkyBlue4: fromRgb([0, 0.408, 0.545]),\n DodgerBlue1: fromRgb([0.116, 0.565, 1]),\n DodgerBlue2: fromRgb([0.11, 0.525, 0.932]),\n DodgerBlue3: fromRgb([0.094, 0.455, 0.804]),\n DodgerBlue4: fromRgb([0.064, 0.305, 0.545]),\n Firebrick1: fromRgb([1, 0.19, 0.19]),\n Firebrick2: fromRgb([0.932, 0.172, 0.172]),\n Firebrick3: fromRgb([0.804, 0.15, 0.15]),\n Firebrick4: fromRgb([0.545, 0.1, 0.1]),\n Gold1: fromRgb([1, 0.844, 0]),\n Gold2: fromRgb([0.932, 0.79, 0]),\n Gold3: fromRgb([0.804, 0.68, 0]),\n Gold4: fromRgb([0.545, 0.46, 0]),\n Goldenrod1: fromRgb([1, 0.756, 0.145]),\n Goldenrod2: fromRgb([0.932, 0.705, 0.132]),\n Goldenrod3: fromRgb([0.804, 0.608, 0.112]),\n Goldenrod4: fromRgb([0.545, 0.41, 0.08]),\n Green1: fromRgb([0, 1, 0]),\n Green2: fromRgb([0, 0.932, 0]),\n Green3: fromRgb([0, 0.804, 0]),\n Green4: fromRgb([0, 0.545, 0]),\n Honeydew1: fromRgb([0.94, 1, 0.94]),\n Honeydew2: fromRgb([0.88, 0.932, 0.88]),\n Honeydew3: fromRgb([0.756, 0.804, 0.756]),\n Honeydew4: fromRgb([0.512, 0.545, 0.512]),\n HotPink1: fromRgb([1, 0.43, 0.705]),\n HotPink2: fromRgb([0.932, 0.415, 0.655]),\n HotPink3: fromRgb([0.804, 0.376, 0.565]),\n HotPink4: fromRgb([0.545, 0.228, 0.385]),\n IndianRed1: fromRgb([1, 0.415, 0.415]),\n IndianRed2: fromRgb([0.932, 0.39, 0.39]),\n IndianRed3: fromRgb([0.804, 0.332, 0.332]),\n IndianRed4: fromRgb([0.545, 0.228, 0.228]),\n Ivory1: fromRgb([1, 1, 0.94]),\n Ivory2: fromRgb([0.932, 0.932, 0.88]),\n Ivory3: fromRgb([0.804, 0.804, 0.756]),\n Ivory4: fromRgb([0.545, 0.545, 0.512]),\n Khaki1: fromRgb([1, 0.965, 0.56]),\n Khaki2: fromRgb([0.932, 0.9, 0.52]),\n Khaki3: fromRgb([0.804, 0.776, 0.45]),\n Khaki4: fromRgb([0.545, 0.525, 0.305]),\n LavenderBlush1: fromRgb([1, 0.94, 0.96]),\n LavenderBlush2: fromRgb([0.932, 0.88, 0.898]),\n LavenderBlush3: fromRgb([0.804, 0.756, 0.772]),\n LavenderBlush4: fromRgb([0.545, 0.512, 0.525]),\n LemonChiffon1: fromRgb([1, 0.98, 0.804]),\n LemonChiffon2: fromRgb([0.932, 0.912, 0.75]),\n LemonChiffon3: fromRgb([0.804, 0.79, 0.648]),\n LemonChiffon4: fromRgb([0.545, 0.536, 0.44]),\n LightBlue1: fromRgb([0.75, 0.936, 1]),\n LightBlue2: fromRgb([0.698, 0.875, 0.932]),\n LightBlue3: fromRgb([0.604, 0.752, 0.804]),\n LightBlue4: fromRgb([0.408, 0.512, 0.545]),\n LightCyan1: fromRgb([0.88, 1, 1]),\n LightCyan2: fromRgb([0.82, 0.932, 0.932]),\n LightCyan3: fromRgb([0.705, 0.804, 0.804]),\n LightCyan4: fromRgb([0.48, 0.545, 0.545]),\n LightGoldenrod1: fromRgb([1, 0.925, 0.545]),\n LightGoldenrod2: fromRgb([0.932, 0.864, 0.51]),\n LightGoldenrod3: fromRgb([0.804, 0.745, 0.44]),\n LightGoldenrod4: fromRgb([0.545, 0.505, 0.298]),\n LightPink1: fromRgb([1, 0.684, 0.725]),\n LightPink2: fromRgb([0.932, 0.635, 0.68]),\n LightPink3: fromRgb([0.804, 0.55, 0.585]),\n LightPink4: fromRgb([0.545, 0.372, 0.396]),\n LightSalmon1: fromRgb([1, 0.628, 0.48]),\n LightSalmon2: fromRgb([0.932, 0.585, 0.448]),\n LightSalmon3: fromRgb([0.804, 0.505, 0.385]),\n LightSalmon4: fromRgb([0.545, 0.34, 0.26]),\n LightSkyBlue1: fromRgb([0.69, 0.888, 1]),\n LightSkyBlue2: fromRgb([0.644, 0.828, 0.932]),\n LightSkyBlue3: fromRgb([0.552, 0.712, 0.804]),\n LightSkyBlue4: fromRgb([0.376, 0.484, 0.545]),\n LightSteelBlue1: fromRgb([0.792, 0.884, 1]),\n LightSteelBlue2: fromRgb([0.736, 0.824, 0.932]),\n LightSteelBlue3: fromRgb([0.635, 0.71, 0.804]),\n LightSteelBlue4: fromRgb([0.43, 0.484, 0.545]),\n LightYellow1: fromRgb([1, 1, 0.88]),\n LightYellow2: fromRgb([0.932, 0.932, 0.82]),\n LightYellow3: fromRgb([0.804, 0.804, 0.705]),\n LightYellow4: fromRgb([0.545, 0.545, 0.48]),\n Magenta1: fromRgb([1, 0, 1]),\n Magenta2: fromRgb([0.932, 0, 0.932]),\n Magenta3: fromRgb([0.804, 0, 0.804]),\n Magenta4: fromRgb([0.545, 0, 0.545]),\n Maroon1: fromRgb([1, 0.204, 0.7]),\n Maroon2: fromRgb([0.932, 0.19, 0.655]),\n Maroon3: fromRgb([0.804, 0.16, 0.565]),\n Maroon4: fromRgb([0.545, 0.11, 0.385]),\n MediumOrchid1: fromRgb([0.88, 0.4, 1]),\n MediumOrchid2: fromRgb([0.82, 0.372, 0.932]),\n MediumOrchid3: fromRgb([0.705, 0.32, 0.804]),\n MediumOrchid4: fromRgb([0.48, 0.215, 0.545]),\n MediumPurple1: fromRgb([0.67, 0.51, 1]),\n MediumPurple2: fromRgb([0.624, 0.475, 0.932]),\n MediumPurple3: fromRgb([0.536, 0.408, 0.804]),\n MediumPurple4: fromRgb([0.365, 0.28, 0.545]),\n MistyRose1: fromRgb([1, 0.894, 0.884]),\n MistyRose2: fromRgb([0.932, 0.835, 0.824]),\n MistyRose3: fromRgb([0.804, 0.716, 0.71]),\n MistyRose4: fromRgb([0.545, 0.49, 0.484]),\n NavajoWhite1: fromRgb([1, 0.87, 0.68]),\n NavajoWhite2: fromRgb([0.932, 0.81, 0.63]),\n NavajoWhite3: fromRgb([0.804, 0.7, 0.545]),\n NavajoWhite4: fromRgb([0.545, 0.475, 0.37]),\n OliveDrab1: fromRgb([0.752, 1, 0.244]),\n OliveDrab2: fromRgb([0.7, 0.932, 0.228]),\n OliveDrab3: fromRgb([0.604, 0.804, 0.196]),\n OliveDrab4: fromRgb([0.41, 0.545, 0.132]),\n Orange1: fromRgb([1, 0.648, 0]),\n Orange2: fromRgb([0.932, 0.604, 0]),\n Orange3: fromRgb([0.804, 0.52, 0]),\n Orange4: fromRgb([0.545, 0.352, 0]),\n OrangeRed1: fromRgb([1, 0.27, 0]),\n OrangeRed2: fromRgb([0.932, 0.25, 0]),\n OrangeRed3: fromRgb([0.804, 0.215, 0]),\n OrangeRed4: fromRgb([0.545, 0.145, 0]),\n Orchid1: fromRgb([1, 0.512, 0.98]),\n Orchid2: fromRgb([0.932, 0.48, 0.912]),\n Orchid3: fromRgb([0.804, 0.41, 0.79]),\n Orchid4: fromRgb([0.545, 0.28, 0.536]),\n PaleGreen1: fromRgb([0.604, 1, 0.604]),\n PaleGreen2: fromRgb([0.565, 0.932, 0.565]),\n PaleGreen3: fromRgb([0.488, 0.804, 0.488]),\n PaleGreen4: fromRgb([0.33, 0.545, 0.33]),\n PaleTurquoise1: fromRgb([0.732, 1, 1]),\n PaleTurquoise2: fromRgb([0.684, 0.932, 0.932]),\n PaleTurquoise3: fromRgb([0.59, 0.804, 0.804]),\n PaleTurquoise4: fromRgb([0.4, 0.545, 0.545]),\n PaleVioletRed1: fromRgb([1, 0.51, 0.67]),\n PaleVioletRed2: fromRgb([0.932, 0.475, 0.624]),\n PaleVioletRed3: fromRgb([0.804, 0.408, 0.536]),\n PaleVioletRed4: fromRgb([0.545, 0.28, 0.365]),\n PeachPuff1: fromRgb([1, 0.855, 0.725]),\n PeachPuff2: fromRgb([0.932, 0.796, 0.68]),\n PeachPuff3: fromRgb([0.804, 0.688, 0.585]),\n PeachPuff4: fromRgb([0.545, 0.468, 0.396]),\n Pink1: fromRgb([1, 0.71, 0.772]),\n Pink2: fromRgb([0.932, 0.664, 0.72]),\n Pink3: fromRgb([0.804, 0.57, 0.62]),\n Pink4: fromRgb([0.545, 0.39, 0.424]),\n Plum1: fromRgb([1, 0.732, 1]),\n Plum2: fromRgb([0.932, 0.684, 0.932]),\n Plum3: fromRgb([0.804, 0.59, 0.804]),\n Plum4: fromRgb([0.545, 0.4, 0.545]),\n Purple1: fromRgb([0.608, 0.19, 1]),\n Purple2: fromRgb([0.57, 0.172, 0.932]),\n Purple3: fromRgb([0.49, 0.15, 0.804]),\n Purple4: fromRgb([0.332, 0.1, 0.545]),\n Red1: fromRgb([1, 0, 0]),\n Red2: fromRgb([0.932, 0, 0]),\n Red3: fromRgb([0.804, 0, 0]),\n Red4: fromRgb([0.545, 0, 0]),\n RosyBrown1: fromRgb([1, 0.756, 0.756]),\n RosyBrown2: fromRgb([0.932, 0.705, 0.705]),\n RosyBrown3: fromRgb([0.804, 0.608, 0.608]),\n RosyBrown4: fromRgb([0.545, 0.41, 0.41]),\n RoyalBlue1: fromRgb([0.284, 0.464, 1]),\n RoyalBlue2: fromRgb([0.264, 0.43, 0.932]),\n RoyalBlue3: fromRgb([0.228, 0.372, 0.804]),\n RoyalBlue4: fromRgb([0.152, 0.25, 0.545]),\n Salmon1: fromRgb([1, 0.55, 0.41]),\n Salmon2: fromRgb([0.932, 0.51, 0.385]),\n Salmon3: fromRgb([0.804, 0.44, 0.33]),\n Salmon4: fromRgb([0.545, 0.298, 0.224]),\n SeaGreen1: fromRgb([0.33, 1, 0.624]),\n SeaGreen2: fromRgb([0.305, 0.932, 0.58]),\n SeaGreen3: fromRgb([0.264, 0.804, 0.5]),\n SeaGreen4: fromRgb([0.18, 0.545, 0.34]),\n Seashell1: fromRgb([1, 0.96, 0.932]),\n Seashell2: fromRgb([0.932, 0.898, 0.87]),\n Seashell3: fromRgb([0.804, 0.772, 0.75]),\n Seashell4: fromRgb([0.545, 0.525, 0.51]),\n Sienna1: fromRgb([1, 0.51, 0.28]),\n Sienna2: fromRgb([0.932, 0.475, 0.26]),\n Sienna3: fromRgb([0.804, 0.408, 0.224]),\n Sienna4: fromRgb([0.545, 0.28, 0.15]),\n SkyBlue1: fromRgb([0.53, 0.808, 1]),\n SkyBlue2: fromRgb([0.494, 0.752, 0.932]),\n SkyBlue3: fromRgb([0.424, 0.65, 0.804]),\n SkyBlue4: fromRgb([0.29, 0.44, 0.545]),\n SlateBlue1: fromRgb([0.512, 0.435, 1]),\n SlateBlue2: fromRgb([0.48, 0.404, 0.932]),\n SlateBlue3: fromRgb([0.41, 0.35, 0.804]),\n SlateBlue4: fromRgb([0.28, 0.235, 0.545]),\n SlateGray1: fromRgb([0.776, 0.888, 1]),\n SlateGray2: fromRgb([0.725, 0.828, 0.932]),\n SlateGray3: fromRgb([0.624, 0.712, 0.804]),\n SlateGray4: fromRgb([0.424, 0.484, 0.545]),\n Snow1: fromRgb([1, 0.98, 0.98]),\n Snow2: fromRgb([0.932, 0.912, 0.912]),\n Snow3: fromRgb([0.804, 0.79, 0.79]),\n Snow4: fromRgb([0.545, 0.536, 0.536]),\n SpringGreen1: fromRgb([0, 1, 0.498]),\n SpringGreen2: fromRgb([0, 0.932, 0.464]),\n SpringGreen3: fromRgb([0, 0.804, 0.4]),\n SpringGreen4: fromRgb([0, 0.545, 0.27]),\n SteelBlue1: fromRgb([0.39, 0.72, 1]),\n SteelBlue2: fromRgb([0.36, 0.675, 0.932]),\n SteelBlue3: fromRgb([0.31, 0.58, 0.804]),\n SteelBlue4: fromRgb([0.21, 0.392, 0.545]),\n Tan1: fromRgb([1, 0.648, 0.31]),\n Tan2: fromRgb([0.932, 0.604, 0.288]),\n Tan3: fromRgb([0.804, 0.52, 0.248]),\n Tan4: fromRgb([0.545, 0.352, 0.17]),\n Thistle1: fromRgb([1, 0.884, 1]),\n Thistle2: fromRgb([0.932, 0.824, 0.932]),\n Thistle3: fromRgb([0.804, 0.71, 0.804]),\n Thistle4: fromRgb([0.545, 0.484, 0.545]),\n Tomato1: fromRgb([1, 0.39, 0.28]),\n Tomato2: fromRgb([0.932, 0.36, 0.26]),\n Tomato3: fromRgb([0.804, 0.31, 0.224]),\n Tomato4: fromRgb([0.545, 0.21, 0.15]),\n Turquoise1: fromRgb([0, 0.96, 1]),\n Turquoise2: fromRgb([0, 0.898, 0.932]),\n Turquoise3: fromRgb([0, 0.772, 0.804]),\n Turquoise4: fromRgb([0, 0.525, 0.545]),\n VioletRed1: fromRgb([1, 0.244, 0.59]),\n VioletRed2: fromRgb([0.932, 0.228, 0.55]),\n VioletRed3: fromRgb([0.804, 0.196, 0.47]),\n VioletRed4: fromRgb([0.545, 0.132, 0.32]),\n Wheat1: fromRgb([1, 0.905, 0.73]),\n Wheat2: fromRgb([0.932, 0.848, 0.684]),\n Wheat3: fromRgb([0.804, 0.73, 0.59]),\n Wheat4: fromRgb([0.545, 0.494, 0.4]),\n Yellow1: fromRgb([1, 1, 0]),\n Yellow2: fromRgb([0.932, 0.932, 0]),\n Yellow3: fromRgb([0.804, 0.804, 0]),\n Yellow4: fromRgb([0.545, 0.545, 0]),\n Gray0: fromRgb([0.745, 0.745, 0.745]),\n Green0: fromRgb([0, 1, 0]),\n Grey0: fromRgb([0.745, 0.745, 0.745]),\n Maroon0: fromRgb([0.69, 0.19, 0.376]),\n Purple0: fromRgb([0.628, 0.125, 0.94]),\n};\n","import { XColorPegParser } from \"@unified-latex/unified-latex-util-pegjs\";\nimport * as XColorSpec from \"./types\";\n\nconst parseCache: Record = {};\n\n/**\n * Parse an `xparse` argument specification string to an AST.\n * This function caches results. Don't mutate the returned AST!\n *\n * @param {string} [str=\"\"] - LaTeX string input\n * @returns - AST for LaTeX string\n */\nexport function parse(str = \"\"): XColorSpec.Ast {\n parseCache[str] =\n parseCache[str] || (XColorPegParser.parse(str) as XColorSpec.Ast);\n return parseCache[str];\n}\n","import Color from \"color\";\nimport { DVI_PS_NAMES, SVG_NAMES, X11_NAMES } from \"./predefined-colors\";\nimport { XColor } from \"./types\";\nimport { parse as xcolorParser } from \"./parser\";\n\nconst CORE_MODELS = new Set([\"rgb\", \"cmy\", \"cmyk\", \"hsb\", \"gray\"]);\n\nexport const XColorCoreModelToColor = {\n rgb: ([r, g, b]: number[]) => Color([r * 255, g * 255, b * 255], \"rgb\"),\n cmy: ([c, m, y]: number[]) =>\n XColorCoreModelToColor.rgb([1 - c, 1 - m, 1 - y]),\n cmyk: ([c, m, y, k]: number[]) =>\n Color([c * 255, m * 255, y * 255, k * 100], \"cmyk\"),\n hsb: ([h, s, b]: number[]) => Color([h * 360, s * 100, b * 100], \"hsv\"),\n gray: ([v]: number[]) => Color([v * 255, v * 255, v * 255], \"rgb\"),\n};\nconst XColorModelToColor = {\n wave: ([lambda]: number[]) => {\n // Constants according to the xcolor readme\n const gamma = 0.8;\n let baseRgb = [0, 0, 0];\n if (380 <= lambda && lambda < 440) {\n baseRgb = [(440 - lambda) / (440 - 380), 0, 1];\n }\n if (440 <= lambda && lambda < 490) {\n baseRgb = [0, (lambda - 440) / (490 - 440), 1];\n }\n if (490 <= lambda && lambda < 510) {\n baseRgb = [0, 1, (510 - lambda) / (510 - 490)];\n }\n if (510 <= lambda && lambda < 580) {\n baseRgb = [(lambda - 510) / (580 - 510), 1, 0];\n }\n if (580 <= lambda && lambda < 6450) {\n baseRgb = [1, (645 - lambda) / (645 - 580), 0];\n }\n if (645 <= lambda && lambda <= 780) {\n baseRgb = [1, 0, 0];\n }\n let f = 1.0;\n if (380 <= lambda && 420 < lambda) {\n f = 0.3 + (0.7 * (lambda - 380)) / (420 - 380);\n }\n if (700 < lambda && lambda <= 780) {\n f = 0.3 + (0.7 * (780 - lambda)) / (780 - 700);\n }\n\n const rgb = [\n Math.pow(baseRgb[0] * f, gamma),\n Math.pow(baseRgb[1] * f, gamma),\n Math.pow(baseRgb[2] * f, gamma),\n ];\n\n return Color([rgb[0] * 255, rgb[1] * 255, rgb[2] * 255], \"rgb\");\n },\n Hsb: ([h, s, b]: number[]) => XColorCoreModelToColor.hsb([h / 360, s, b]),\n HSB: ([h, s, b]: number[]) =>\n XColorCoreModelToColor.hsb([h / 240, s / 240, b / 240]),\n HTML: ([v]: [string]) => (v.startsWith(\"#\") ? Color(v) : Color(`#${v}`)),\n RGB: ([r, g, b]: number[]) => Color([r, g, b], \"rgb\"),\n Gray: ([v]: number[]) => XColorCoreModelToColor.gray([v / 15]),\n ...XColorCoreModelToColor,\n};\n\nconst ColorToXColorModel = {\n rgb: (color: Color) =>\n color\n .rgb()\n .array()\n .map((v) => v / 255),\n cmy: (color: Color) =>\n [255 - color.red(), 255 - color.green(), 255 - color.blue()].map(\n (v) => v / 255\n ),\n cmyk: (color: Color) =>\n color\n .cmyk()\n .array()\n // The k component goes from 0-100\n .map((v, i) => (i === 3 ? v / 100 : v / 255)),\n hsb: (color: Color) => [\n color.hue() / 360,\n color.saturationv() / 100,\n color.value() / 100,\n ],\n gray: (color: Color) => [color.gray() / 100],\n};\n\nexport const PREDEFINED_XCOLOR_COLORS: Record> = {\n // Core colors\n red: XColorCoreModelToColor.rgb([1, 0, 0]),\n green: XColorCoreModelToColor.rgb([0, 1, 0]),\n blue: XColorCoreModelToColor.rgb([0, 0, 1]),\n brown: XColorCoreModelToColor.rgb([0.75, 0.5, 0.25]),\n lime: XColorCoreModelToColor.rgb([0.75, 1, 0]),\n orange: XColorCoreModelToColor.rgb([1, 0.5, 0]),\n pink: XColorCoreModelToColor.rgb([1, 0.75, 0.75]),\n purple: XColorCoreModelToColor.rgb([0.75, 0, 0.25]),\n teal: XColorCoreModelToColor.rgb([0, 0.5, 0.5]),\n violet: XColorCoreModelToColor.rgb([0.5, 0, 0.5]),\n cyan: XColorCoreModelToColor.rgb([0, 1, 1]),\n magenta: XColorCoreModelToColor.rgb([1, 0, 1]),\n yellow: XColorCoreModelToColor.rgb([1, 1, 0]),\n olive: XColorCoreModelToColor.rgb([0.5, 0.5, 0]),\n black: XColorCoreModelToColor.rgb([0, 0, 0]),\n darkgray: XColorCoreModelToColor.rgb([0.25, 0.25, 0.25]),\n gray: XColorCoreModelToColor.rgb([0.5, 0.5, 0.5]),\n lightgray: XColorCoreModelToColor.rgb([0.75, 0.75, 0.75]),\n white: XColorCoreModelToColor.rgb([1, 1, 1]),\n ...DVI_PS_NAMES,\n ...SVG_NAMES,\n ...X11_NAMES,\n};\n\nfunction scalarMul(scalar: number, vec: number[]) {\n return vec.map((v) => scalar * v);\n}\nfunction addVectors(...vecs: number[][]) {\n return vecs.reduce((prev, current) => prev.map((v, i) => v + current[i]));\n}\n\n/**\n * Mix a color in color model `model` as per the algorithm in 2.3.3 of the xcolor manual.\n */\nfunction mixInModel(\n model: string,\n colorsAndCoefficients: [number, Color][]\n): Color {\n if (!CORE_MODELS.has(model)) {\n throw new Error(\n `Cannot mix colors in model \"${model}\"; only core modes ${Array.from(\n CORE_MODELS\n ).join(\", \")} are supported`\n );\n }\n const toModel =\n ColorToXColorModel[model as keyof typeof ColorToXColorModel];\n const fromModel =\n XColorCoreModelToColor[model as keyof typeof XColorCoreModelToColor];\n\n const mixed = addVectors(\n ...colorsAndCoefficients.map(([v, color]) => {\n const colorInModel = toModel(color);\n return scalarMul(v, colorInModel);\n })\n );\n return fromModel(mixed);\n}\n\n/**\n * Given a parsed `XColor`, compute the color and return a `Color` object\n * (that can be used in CSS, for example).\n */\nexport function computeColor(\n expr: XColor,\n predefinedColors: Record> = {}\n): Color {\n if (expr.type !== \"color\") {\n throw new Error(\n `Can only compute the color of a \"color\" expression, not one of type ${expr.type}`\n );\n }\n\n const knownColors = { ...PREDEFINED_XCOLOR_COLORS, ...predefinedColors };\n function getColor(name: string) {\n if (!knownColors[name]) {\n throw new Error(`Unknown color \"${name}\"`);\n }\n return knownColors[name];\n }\n\n const color = expr.color;\n let computedColor = Color(\"#000000\");\n if (color.type === \"expr\") {\n // From the algorithm in 2.3.2 of the xcolor manual\n\n // TODO: the suffix `!![num]` is not yet implemented.\n let base = getColor(color.name);\n for (const mix of color.mix_expr) {\n if (mix.type === \"complete_mix\") {\n const mixColor = getColor(mix.name);\n base = base.mix(mixColor, 1 - mix.mix_percent / 100);\n } else if (mix.type === \"partial_mix\") {\n base = base.mix(Color(\"#FFFFFF\"), 1 - mix.mix_percent / 100);\n }\n }\n if (color.prefix && color.prefix.length % 2 === 1) {\n base = base.rotate(180);\n }\n computedColor = base;\n }\n if (color.type === \"extended_expr\") {\n const model = color.core_model;\n const div =\n color.div ||\n color.expressions.reduce((a, expr) => a + expr.weight, 0);\n if (div <= 0) {\n throw new Error(\n `Cannot mix color with ratios that have a denominator of ${div}`\n );\n }\n const colorsToMix: [number, Color][] = color.expressions.map(\n (expr) => [\n expr.weight / div,\n computeColor({\n type: \"color\",\n color: expr.color,\n functions: [],\n }),\n ]\n );\n computedColor = mixInModel(model, colorsToMix);\n }\n\n // Now we apply any color functions\n for (const func of expr.functions) {\n if (func.name === \"wheel\") {\n const angle = func.args[0];\n const circ = func.args[1] || 360;\n computedColor = computedColor.rotate((angle / circ) * 360);\n }\n if (func.name === \"twheel\") {\n // This function depends on the definition of \\rangetHsb, which we\n // don't actually know, so we just use it's default, which is to\n // add a 60 deg. angle to everything. I think...\n const angle = func.args[0];\n const circ = func.args[1] || 360;\n computedColor = computedColor.rotate((angle / circ) * 360 + 60);\n }\n }\n\n return computedColor;\n}\n\n/**\n * Convert the xcolor defined color to RGB Hex representation.\n * If the color is unknown or cannot be computed, `null` is returned.\n *\n * If `model` is supplied,\n *\n * The most likely reason a color will be `null` is if the color is defined\n * using a pre-defined color that wasn't supplied as an argument.\n */\nexport function xcolorColorToHex(\n color: string,\n model?: string | null,\n options: {\n predefinedColors?: Record>;\n } = { predefinedColors: {} }\n): string | null {\n const { predefinedColors = {} } = options;\n const parsed = xcolorParser(color);\n // If a model was entered, the corresponding color was directly entered without\n // mixing, unless the parsed type was \"color\". This would through an error in `xcolor`,\n // but we won't error.\n if (model && model !== \"default\" && parsed.type !== \"color\") {\n if (!(model in XColorModelToColor)) {\n throw new Error(\n `Unknown color model \"${model}\"; known models are ${Object.keys(\n XColorModelToColor\n ).join(\", \")}`\n );\n }\n if (parsed.type !== \"hex_spec\" && parsed.type !== \"num_spec\") {\n throw new Error(\n `Cannot use model ${model} to compute the color \"${color}\"`\n );\n }\n\n if (model === \"HTML\" && parsed.type === \"hex_spec\") {\n return XColorModelToColor.HTML(parsed.content).hex();\n } else if (parsed.type === \"num_spec\") {\n type x = keyof Omit;\n return XColorModelToColor[\n model as keyof Omit\n ](parsed.content).hex();\n }\n\n throw new Error(\n `Don't know how to process color \"${color}\" in model \"${model}\"`\n );\n }\n\n if (Array.isArray(parsed) || parsed.type !== \"color\") {\n throw new Error(\n `Cannot the color \"${color}\" is not a valid color string`\n );\n }\n let computed: Color | null = null;\n try {\n computed = computeColor(parsed, predefinedColors);\n } catch (e) {}\n\n return computed && computed.hex();\n}\n"],"names":["XColorPegParser","expr","xcolorParser"],"mappings":"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"} \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-ctan/xcolor-CIejE3rZ.js b/node_modules/@unified-latex/unified-latex-ctan/xcolor-CIejE3rZ.js new file mode 100644 index 0000000..0c0fcf7 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-ctan/xcolor-CIejE3rZ.js @@ -0,0 +1,851 @@ +import Color from "color"; +import { XColorPegParser } from "@unified-latex/unified-latex-util-pegjs"; +const macros = { + substitutecolormodel: { + signature: "m m", + renderInfo: { breakAround: true } + }, + selectcolormodel: { + signature: "m", + renderInfo: { breakAround: true } + }, + definecolor: { + signature: "o m m m", + renderInfo: { breakAround: true } + }, + providecolor: { + signature: "o m m m", + renderInfo: { breakAround: true } + }, + colorlet: { + signature: "o m o m", + renderInfo: { breakAround: true } + }, + definecolorset: { + signature: "o m m m", + renderInfo: { breakAround: true } + }, + providecolorset: { + signature: "o m m m m", + renderInfo: { breakAround: true } + }, + preparecolor: { + signature: "o m m m", + renderInfo: { breakAround: true } + }, + preparecolorset: { + signature: "o m m m m", + renderInfo: { breakAround: true } + }, + DefineNamedColor: { + signature: "m m m m", + renderInfo: { breakAround: true } + }, + definecolors: { + signature: "m", + renderInfo: { breakAround: true } + }, + providecolors: { + signature: "m", + renderInfo: { breakAround: true } + }, + color: { signature: "o m", renderInfo: { breakAround: true } }, + textcolor: { signature: "o m m", renderInfo: { inParMode: true } }, + pagecolor: { signature: "o m" }, + colorbox: { signature: "o m m" }, + fcolorbox: { signature: "o m o m m" }, + boxframe: { signature: "o m" }, + testcolor: { signature: "o m" }, + blendcolors: { signature: "s m" }, + maskcolors: { signature: "o m" }, + definecolorseries: { + signature: "m m m o m o m", + renderInfo: { breakAround: true } + }, + resetcolorseries: { + signature: "o m", + renderInfo: { breakAround: true } + }, + rowcolors: { signature: "s o m m m" }, + extractcolorspec: { signature: "m m" }, + extractcolorspecs: { signature: "m m m" }, + convertcolorspec: { signature: "m m m m" } +}; +const environments = { + testcolors: { signature: "o", renderInfo: { pgfkeysArgs: true } } +}; +const fromRgb = ([r, g, b]) => Color([r * 255, g * 255, b * 255], "rgb"); +const DVI_PS_NAMES = { + Apricot: Color("#FBB982"), + Aquamarine: Color("#00B5BE"), + Bittersweet: Color("#C04F17"), + Black: Color("#221E1F"), + Blue: Color("#2D2F92"), + BlueGreen: Color("#00B3B8"), + BlueViolet: Color("#473992"), + BrickRed: Color("#B6321C"), + Brown: Color("#792500"), + BurntOrange: Color("#F7921D"), + CadetBlue: Color("#74729A"), + CarnationPink: Color("#F282B4"), + Cerulean: Color("#00A2E3"), + CornflowerBlue: Color("#41B0E4"), + Cyan: Color("#00AEEF"), + Dandelion: Color("#FDBC42"), + DarkOrchid: Color("#A4538A"), + Emerald: Color("#00A99D"), + ForestGreen: Color("#009B55"), + Fuchsia: Color("#8C368C"), + Goldenrod: Color("#FFDF42"), + Gray: Color("#949698"), + Green: Color("#00A64F"), + GreenYellow: Color("#DFE674"), + JungleGreen: Color("#00A99A"), + Lavender: Color("#F49EC4"), + LimeGreen: Color("#8DC73E"), + Magenta: Color("#EC008C"), + Mahogany: Color("#A9341F"), + Maroon: Color("#AF3235"), + Melon: Color("#F89E7B"), + MidnightBlue: Color("#006795"), + Mulberry: Color("#A93C93"), + NavyBlue: Color("#006EB8"), + OliveGreen: Color("#3C8031"), + Orange: Color("#F58137"), + OrangeRed: Color("#ED135A"), + Orchid: Color("#AF72B0"), + Peach: Color("#F7965A"), + Periwinkle: Color("#7977B8"), + PineGreen: Color("#008B72"), + Plum: Color("#92268F"), + ProcessBlue: Color("#00B0F0"), + Purple: Color("#99479B"), + RawSienna: Color("#974006"), + Red: Color("#ED1B23"), + RedOrange: Color("#F26035"), + RedViolet: Color("#A1246B"), + Rhodamine: Color("#EF559F"), + RoyalBlue: Color("#0071BC"), + RoyalPurple: Color("#613F99"), + RubineRed: Color("#ED017D"), + Salmon: Color("#F69289"), + SeaGreen: Color("#3FBC9D"), + Sepia: Color("#671800"), + SkyBlue: Color("#46C5DD"), + SpringGreen: Color("#C6DC67"), + Tan: Color("#DA9D76"), + TealBlue: Color("#00AEB3"), + Thistle: Color("#D883B7"), + Turquoise: Color("#00B4CE"), + Violet: Color("#58429B"), + VioletRed: Color("#EF58A0"), + White: Color("#FFFFFF"), + WildStrawberry: Color("#EE2967"), + Yellow: Color("#FFF200"), + YellowGreen: Color("#98CC70"), + YellowOrange: Color("#FAA21A") +}; +const SVG_NAMES = { + AliceBlue: fromRgb([0.94, 0.972, 1]), + AntiqueWhite: fromRgb([0.98, 0.92, 0.844]), + Aqua: fromRgb([0, 1, 1]), + Aquamarine: fromRgb([0.498, 1, 0.83]), + Azure: fromRgb([0.94, 1, 1]), + Beige: fromRgb([0.96, 0.96, 0.864]), + Bisque: fromRgb([1, 0.894, 0.77]), + Black: fromRgb([0, 0, 0]), + BlanchedAlmond: fromRgb([1, 0.92, 0.804]), + Blue: fromRgb([0, 0, 1]), + BlueViolet: fromRgb([0.54, 0.17, 0.888]), + Brown: fromRgb([0.648, 0.165, 0.165]), + BurlyWood: fromRgb([0.87, 0.72, 0.53]), + CadetBlue: fromRgb([0.372, 0.62, 0.628]), + Chartreuse: fromRgb([0.498, 1, 0]), + Chocolate: fromRgb([0.824, 0.41, 0.116]), + Coral: fromRgb([1, 0.498, 0.312]), + CornflowerBlue: fromRgb([0.392, 0.585, 0.93]), + Cornsilk: fromRgb([1, 0.972, 0.864]), + Crimson: fromRgb([0.864, 0.08, 0.235]), + Cyan: fromRgb([0, 1, 1]), + DarkBlue: fromRgb([0, 0, 0.545]), + DarkCyan: fromRgb([0, 0.545, 0.545]), + DarkGoldenrod: fromRgb([0.72, 0.525, 0.044]), + DarkGray: fromRgb([0.664, 0.664, 0.664]), + DarkGreen: fromRgb([0, 0.392, 0]), + DarkGrey: fromRgb([0.664, 0.664, 0.664]), + DarkKhaki: fromRgb([0.74, 0.716, 0.42]), + DarkMagenta: fromRgb([0.545, 0, 0.545]), + DarkOliveGreen: fromRgb([0.332, 0.42, 0.185]), + DarkOrange: fromRgb([1, 0.55, 0]), + DarkOrchid: fromRgb([0.6, 0.196, 0.8]), + DarkRed: fromRgb([0.545, 0, 0]), + DarkSalmon: fromRgb([0.912, 0.59, 0.48]), + DarkSeaGreen: fromRgb([0.56, 0.736, 0.56]), + DarkSlateBlue: fromRgb([0.284, 0.24, 0.545]), + DarkSlateGray: fromRgb([0.185, 0.31, 0.31]), + DarkSlateGrey: fromRgb([0.185, 0.31, 0.31]), + DarkTurquoise: fromRgb([0, 0.808, 0.82]), + DarkViolet: fromRgb([0.58, 0, 0.828]), + DeepPink: fromRgb([1, 0.08, 0.576]), + DeepSkyBlue: fromRgb([0, 0.75, 1]), + DimGray: fromRgb([0.41, 0.41, 0.41]), + DimGrey: fromRgb([0.41, 0.41, 0.41]), + DodgerBlue: fromRgb([0.116, 0.565, 1]), + FireBrick: fromRgb([0.698, 0.132, 0.132]), + FloralWhite: fromRgb([1, 0.98, 0.94]), + ForestGreen: fromRgb([0.132, 0.545, 0.132]), + Fuchsia: fromRgb([1, 0, 1]), + Gainsboro: fromRgb([0.864, 0.864, 0.864]), + GhostWhite: fromRgb([0.972, 0.972, 1]), + Gold: fromRgb([1, 0.844, 0]), + Goldenrod: fromRgb([0.855, 0.648, 0.125]), + Gray: fromRgb([0.5, 0.5, 0.5]), + Green: fromRgb([0, 0.5, 0]), + GreenYellow: fromRgb([0.68, 1, 0.185]), + Grey: fromRgb([0.5, 0.5, 0.5]), + Honeydew: fromRgb([0.94, 1, 0.94]), + HotPink: fromRgb([1, 0.41, 0.705]), + IndianRed: fromRgb([0.804, 0.36, 0.36]), + Indigo: fromRgb([0.294, 0, 0.51]), + Ivory: fromRgb([1, 1, 0.94]), + Khaki: fromRgb([0.94, 0.9, 0.55]), + Lavender: fromRgb([0.9, 0.9, 0.98]), + LavenderBlush: fromRgb([1, 0.94, 0.96]), + LawnGreen: fromRgb([0.488, 0.99, 0]), + LemonChiffon: fromRgb([1, 0.98, 0.804]), + LightBlue: fromRgb([0.68, 0.848, 0.9]), + LightCoral: fromRgb([0.94, 0.5, 0.5]), + LightCyan: fromRgb([0.88, 1, 1]), + LightGoldenrod: fromRgb([0.933, 0.867, 0.51]), + LightGoldenrodYellow: fromRgb([0.98, 0.98, 0.824]), + LightGray: fromRgb([0.828, 0.828, 0.828]), + LightGreen: fromRgb([0.565, 0.932, 0.565]), + LightGrey: fromRgb([0.828, 0.828, 0.828]), + LightPink: fromRgb([1, 0.712, 0.756]), + LightSalmon: fromRgb([1, 0.628, 0.48]), + LightSeaGreen: fromRgb([0.125, 0.698, 0.668]), + LightSkyBlue: fromRgb([0.53, 0.808, 0.98]), + LightSlateBlue: fromRgb([0.518, 0.44, 1]), + LightSlateGray: fromRgb([0.468, 0.532, 0.6]), + LightSlateGrey: fromRgb([0.468, 0.532, 0.6]), + LightSteelBlue: fromRgb([0.69, 0.77, 0.87]), + LightYellow: fromRgb([1, 1, 0.88]), + Lime: fromRgb([0, 1, 0]), + LimeGreen: fromRgb([0.196, 0.804, 0.196]), + Linen: fromRgb([0.98, 0.94, 0.9]), + Magenta: fromRgb([1, 0, 1]), + Maroon: fromRgb([0.5, 0, 0]), + MediumAquamarine: fromRgb([0.4, 0.804, 0.668]), + MediumBlue: fromRgb([0, 0, 0.804]), + MediumOrchid: fromRgb([0.73, 0.332, 0.828]), + MediumPurple: fromRgb([0.576, 0.44, 0.86]), + MediumSeaGreen: fromRgb([0.235, 0.7, 0.444]), + MediumSlateBlue: fromRgb([0.484, 0.408, 0.932]), + MediumSpringGreen: fromRgb([0, 0.98, 0.604]), + MediumTurquoise: fromRgb([0.284, 0.82, 0.8]), + MediumVioletRed: fromRgb([0.78, 0.084, 0.52]), + MidnightBlue: fromRgb([0.098, 0.098, 0.44]), + MintCream: fromRgb([0.96, 1, 0.98]), + MistyRose: fromRgb([1, 0.894, 0.884]), + Moccasin: fromRgb([1, 0.894, 0.71]), + NavajoWhite: fromRgb([1, 0.87, 0.68]), + Navy: fromRgb([0, 0, 0.5]), + NavyBlue: fromRgb([0, 0, 0.5]), + OldLace: fromRgb([0.992, 0.96, 0.9]), + Olive: fromRgb([0.5, 0.5, 0]), + OliveDrab: fromRgb([0.42, 0.556, 0.136]), + Orange: fromRgb([1, 0.648, 0]), + OrangeRed: fromRgb([1, 0.27, 0]), + Orchid: fromRgb([0.855, 0.44, 0.84]), + PaleGoldenrod: fromRgb([0.932, 0.91, 0.668]), + PaleGreen: fromRgb([0.596, 0.985, 0.596]), + PaleTurquoise: fromRgb([0.688, 0.932, 0.932]), + PaleVioletRed: fromRgb([0.86, 0.44, 0.576]), + PapayaWhip: fromRgb([1, 0.936, 0.835]), + PeachPuff: fromRgb([1, 0.855, 0.725]), + Peru: fromRgb([0.804, 0.52, 0.248]), + Pink: fromRgb([1, 0.752, 0.796]), + Plum: fromRgb([0.868, 0.628, 0.868]), + PowderBlue: fromRgb([0.69, 0.88, 0.9]), + Purple: fromRgb([0.5, 0, 0.5]), + Red: fromRgb([1, 0, 0]), + RosyBrown: fromRgb([0.736, 0.56, 0.56]), + RoyalBlue: fromRgb([0.255, 0.41, 0.884]), + SaddleBrown: fromRgb([0.545, 0.27, 0.075]), + Salmon: fromRgb([0.98, 0.5, 0.448]), + SandyBrown: fromRgb([0.956, 0.644, 0.376]), + SeaGreen: fromRgb([0.18, 0.545, 0.34]), + Seashell: fromRgb([1, 0.96, 0.932]), + Sienna: fromRgb([0.628, 0.32, 0.176]), + Silver: fromRgb([0.752, 0.752, 0.752]), + SkyBlue: fromRgb([0.53, 0.808, 0.92]), + SlateBlue: fromRgb([0.415, 0.352, 0.804]), + SlateGray: fromRgb([0.44, 0.5, 0.565]), + SlateGrey: fromRgb([0.44, 0.5, 0.565]), + Snow: fromRgb([1, 0.98, 0.98]), + SpringGreen: fromRgb([0, 1, 0.498]), + SteelBlue: fromRgb([0.275, 0.51, 0.705]), + Tan: fromRgb([0.824, 0.705, 0.55]), + Teal: fromRgb([0, 0.5, 0.5]), + Thistle: fromRgb([0.848, 0.75, 0.848]), + Tomato: fromRgb([1, 0.39, 0.28]), + Turquoise: fromRgb([0.25, 0.88, 0.815]), + Violet: fromRgb([0.932, 0.51, 0.932]), + VioletRed: fromRgb([0.816, 0.125, 0.565]), + Wheat: fromRgb([0.96, 0.87, 0.7]), + White: fromRgb([1, 1, 1]), + WhiteSmoke: fromRgb([0.96, 0.96, 0.96]), + Yellow: fromRgb([1, 1, 0]), + YellowGreen: fromRgb([0.604, 0.804, 0.196]) +}; +const X11_NAMES = { + AntiqueWhite1: fromRgb([1, 0.936, 0.86]), + AntiqueWhite2: fromRgb([0.932, 0.875, 0.8]), + AntiqueWhite3: fromRgb([0.804, 0.752, 0.69]), + AntiqueWhite4: fromRgb([0.545, 0.512, 0.47]), + Aquamarine1: fromRgb([0.498, 1, 0.83]), + Aquamarine2: fromRgb([0.464, 0.932, 0.776]), + Aquamarine3: fromRgb([0.4, 0.804, 0.668]), + Aquamarine4: fromRgb([0.27, 0.545, 0.455]), + Azure1: fromRgb([0.94, 1, 1]), + Azure2: fromRgb([0.88, 0.932, 0.932]), + Azure3: fromRgb([0.756, 0.804, 0.804]), + Azure4: fromRgb([0.512, 0.545, 0.545]), + Bisque1: fromRgb([1, 0.894, 0.77]), + Bisque2: fromRgb([0.932, 0.835, 0.716]), + Bisque3: fromRgb([0.804, 0.716, 0.62]), + Bisque4: fromRgb([0.545, 0.49, 0.42]), + Blue1: fromRgb([0, 0, 1]), + Blue2: fromRgb([0, 0, 0.932]), + Blue3: fromRgb([0, 0, 0.804]), + Blue4: fromRgb([0, 0, 0.545]), + Brown1: fromRgb([1, 0.25, 0.25]), + Brown2: fromRgb([0.932, 0.23, 0.23]), + Brown3: fromRgb([0.804, 0.2, 0.2]), + Brown4: fromRgb([0.545, 0.136, 0.136]), + Burlywood1: fromRgb([1, 0.828, 0.608]), + Burlywood2: fromRgb([0.932, 0.772, 0.57]), + Burlywood3: fromRgb([0.804, 0.668, 0.49]), + Burlywood4: fromRgb([0.545, 0.45, 0.332]), + CadetBlue1: fromRgb([0.596, 0.96, 1]), + CadetBlue2: fromRgb([0.556, 0.898, 0.932]), + CadetBlue3: fromRgb([0.48, 0.772, 0.804]), + CadetBlue4: fromRgb([0.325, 0.525, 0.545]), + Chartreuse1: fromRgb([0.498, 1, 0]), + Chartreuse2: fromRgb([0.464, 0.932, 0]), + Chartreuse3: fromRgb([0.4, 0.804, 0]), + Chartreuse4: fromRgb([0.27, 0.545, 0]), + Chocolate1: fromRgb([1, 0.498, 0.14]), + Chocolate2: fromRgb([0.932, 0.464, 0.13]), + Chocolate3: fromRgb([0.804, 0.4, 0.112]), + Chocolate4: fromRgb([0.545, 0.27, 0.075]), + Coral1: fromRgb([1, 0.448, 0.336]), + Coral2: fromRgb([0.932, 0.415, 0.312]), + Coral3: fromRgb([0.804, 0.356, 0.27]), + Coral4: fromRgb([0.545, 0.244, 0.185]), + Cornsilk1: fromRgb([1, 0.972, 0.864]), + Cornsilk2: fromRgb([0.932, 0.91, 0.804]), + Cornsilk3: fromRgb([0.804, 0.785, 0.694]), + Cornsilk4: fromRgb([0.545, 0.532, 0.47]), + Cyan1: fromRgb([0, 1, 1]), + Cyan2: fromRgb([0, 0.932, 0.932]), + Cyan3: fromRgb([0, 0.804, 0.804]), + Cyan4: fromRgb([0, 0.545, 0.545]), + DarkGoldenrod1: fromRgb([1, 0.725, 0.06]), + DarkGoldenrod2: fromRgb([0.932, 0.68, 0.055]), + DarkGoldenrod3: fromRgb([0.804, 0.585, 0.048]), + DarkGoldenrod4: fromRgb([0.545, 0.396, 0.03]), + DarkOliveGreen1: fromRgb([0.792, 1, 0.44]), + DarkOliveGreen2: fromRgb([0.736, 0.932, 0.408]), + DarkOliveGreen3: fromRgb([0.635, 0.804, 0.352]), + DarkOliveGreen4: fromRgb([0.43, 0.545, 0.24]), + DarkOrange1: fromRgb([1, 0.498, 0]), + DarkOrange2: fromRgb([0.932, 0.464, 0]), + DarkOrange3: fromRgb([0.804, 0.4, 0]), + DarkOrange4: fromRgb([0.545, 0.27, 0]), + DarkOrchid1: fromRgb([0.75, 0.244, 1]), + DarkOrchid2: fromRgb([0.698, 0.228, 0.932]), + DarkOrchid3: fromRgb([0.604, 0.196, 0.804]), + DarkOrchid4: fromRgb([0.408, 0.132, 0.545]), + DarkSeaGreen1: fromRgb([0.756, 1, 0.756]), + DarkSeaGreen2: fromRgb([0.705, 0.932, 0.705]), + DarkSeaGreen3: fromRgb([0.608, 0.804, 0.608]), + DarkSeaGreen4: fromRgb([0.41, 0.545, 0.41]), + DarkSlateGray1: fromRgb([0.592, 1, 1]), + DarkSlateGray2: fromRgb([0.552, 0.932, 0.932]), + DarkSlateGray3: fromRgb([0.475, 0.804, 0.804]), + DarkSlateGray4: fromRgb([0.32, 0.545, 0.545]), + DeepPink1: fromRgb([1, 0.08, 0.576]), + DeepPink2: fromRgb([0.932, 0.07, 0.536]), + DeepPink3: fromRgb([0.804, 0.064, 0.464]), + DeepPink4: fromRgb([0.545, 0.04, 0.312]), + DeepSkyBlue1: fromRgb([0, 0.75, 1]), + DeepSkyBlue2: fromRgb([0, 0.698, 0.932]), + DeepSkyBlue3: fromRgb([0, 0.604, 0.804]), + DeepSkyBlue4: fromRgb([0, 0.408, 0.545]), + DodgerBlue1: fromRgb([0.116, 0.565, 1]), + DodgerBlue2: fromRgb([0.11, 0.525, 0.932]), + DodgerBlue3: fromRgb([0.094, 0.455, 0.804]), + DodgerBlue4: fromRgb([0.064, 0.305, 0.545]), + Firebrick1: fromRgb([1, 0.19, 0.19]), + Firebrick2: fromRgb([0.932, 0.172, 0.172]), + Firebrick3: fromRgb([0.804, 0.15, 0.15]), + Firebrick4: fromRgb([0.545, 0.1, 0.1]), + Gold1: fromRgb([1, 0.844, 0]), + Gold2: fromRgb([0.932, 0.79, 0]), + Gold3: fromRgb([0.804, 0.68, 0]), + Gold4: fromRgb([0.545, 0.46, 0]), + Goldenrod1: fromRgb([1, 0.756, 0.145]), + Goldenrod2: fromRgb([0.932, 0.705, 0.132]), + Goldenrod3: fromRgb([0.804, 0.608, 0.112]), + Goldenrod4: fromRgb([0.545, 0.41, 0.08]), + Green1: fromRgb([0, 1, 0]), + Green2: fromRgb([0, 0.932, 0]), + Green3: fromRgb([0, 0.804, 0]), + Green4: fromRgb([0, 0.545, 0]), + Honeydew1: fromRgb([0.94, 1, 0.94]), + Honeydew2: fromRgb([0.88, 0.932, 0.88]), + Honeydew3: fromRgb([0.756, 0.804, 0.756]), + Honeydew4: fromRgb([0.512, 0.545, 0.512]), + HotPink1: fromRgb([1, 0.43, 0.705]), + HotPink2: fromRgb([0.932, 0.415, 0.655]), + HotPink3: fromRgb([0.804, 0.376, 0.565]), + HotPink4: fromRgb([0.545, 0.228, 0.385]), + IndianRed1: fromRgb([1, 0.415, 0.415]), + IndianRed2: fromRgb([0.932, 0.39, 0.39]), + IndianRed3: fromRgb([0.804, 0.332, 0.332]), + IndianRed4: fromRgb([0.545, 0.228, 0.228]), + Ivory1: fromRgb([1, 1, 0.94]), + Ivory2: fromRgb([0.932, 0.932, 0.88]), + Ivory3: fromRgb([0.804, 0.804, 0.756]), + Ivory4: fromRgb([0.545, 0.545, 0.512]), + Khaki1: fromRgb([1, 0.965, 0.56]), + Khaki2: fromRgb([0.932, 0.9, 0.52]), + Khaki3: fromRgb([0.804, 0.776, 0.45]), + Khaki4: fromRgb([0.545, 0.525, 0.305]), + LavenderBlush1: fromRgb([1, 0.94, 0.96]), + LavenderBlush2: fromRgb([0.932, 0.88, 0.898]), + LavenderBlush3: fromRgb([0.804, 0.756, 0.772]), + LavenderBlush4: fromRgb([0.545, 0.512, 0.525]), + LemonChiffon1: fromRgb([1, 0.98, 0.804]), + LemonChiffon2: fromRgb([0.932, 0.912, 0.75]), + LemonChiffon3: fromRgb([0.804, 0.79, 0.648]), + LemonChiffon4: fromRgb([0.545, 0.536, 0.44]), + LightBlue1: fromRgb([0.75, 0.936, 1]), + LightBlue2: fromRgb([0.698, 0.875, 0.932]), + LightBlue3: fromRgb([0.604, 0.752, 0.804]), + LightBlue4: fromRgb([0.408, 0.512, 0.545]), + LightCyan1: fromRgb([0.88, 1, 1]), + LightCyan2: fromRgb([0.82, 0.932, 0.932]), + LightCyan3: fromRgb([0.705, 0.804, 0.804]), + LightCyan4: fromRgb([0.48, 0.545, 0.545]), + LightGoldenrod1: fromRgb([1, 0.925, 0.545]), + LightGoldenrod2: fromRgb([0.932, 0.864, 0.51]), + LightGoldenrod3: fromRgb([0.804, 0.745, 0.44]), + LightGoldenrod4: fromRgb([0.545, 0.505, 0.298]), + LightPink1: fromRgb([1, 0.684, 0.725]), + LightPink2: fromRgb([0.932, 0.635, 0.68]), + LightPink3: fromRgb([0.804, 0.55, 0.585]), + LightPink4: fromRgb([0.545, 0.372, 0.396]), + LightSalmon1: fromRgb([1, 0.628, 0.48]), + LightSalmon2: fromRgb([0.932, 0.585, 0.448]), + LightSalmon3: fromRgb([0.804, 0.505, 0.385]), + LightSalmon4: fromRgb([0.545, 0.34, 0.26]), + LightSkyBlue1: fromRgb([0.69, 0.888, 1]), + LightSkyBlue2: fromRgb([0.644, 0.828, 0.932]), + LightSkyBlue3: fromRgb([0.552, 0.712, 0.804]), + LightSkyBlue4: fromRgb([0.376, 0.484, 0.545]), + LightSteelBlue1: fromRgb([0.792, 0.884, 1]), + LightSteelBlue2: fromRgb([0.736, 0.824, 0.932]), + LightSteelBlue3: fromRgb([0.635, 0.71, 0.804]), + LightSteelBlue4: fromRgb([0.43, 0.484, 0.545]), + LightYellow1: fromRgb([1, 1, 0.88]), + LightYellow2: fromRgb([0.932, 0.932, 0.82]), + LightYellow3: fromRgb([0.804, 0.804, 0.705]), + LightYellow4: fromRgb([0.545, 0.545, 0.48]), + Magenta1: fromRgb([1, 0, 1]), + Magenta2: fromRgb([0.932, 0, 0.932]), + Magenta3: fromRgb([0.804, 0, 0.804]), + Magenta4: fromRgb([0.545, 0, 0.545]), + Maroon1: fromRgb([1, 0.204, 0.7]), + Maroon2: fromRgb([0.932, 0.19, 0.655]), + Maroon3: fromRgb([0.804, 0.16, 0.565]), + Maroon4: fromRgb([0.545, 0.11, 0.385]), + MediumOrchid1: fromRgb([0.88, 0.4, 1]), + MediumOrchid2: fromRgb([0.82, 0.372, 0.932]), + MediumOrchid3: fromRgb([0.705, 0.32, 0.804]), + MediumOrchid4: fromRgb([0.48, 0.215, 0.545]), + MediumPurple1: fromRgb([0.67, 0.51, 1]), + MediumPurple2: fromRgb([0.624, 0.475, 0.932]), + MediumPurple3: fromRgb([0.536, 0.408, 0.804]), + MediumPurple4: fromRgb([0.365, 0.28, 0.545]), + MistyRose1: fromRgb([1, 0.894, 0.884]), + MistyRose2: fromRgb([0.932, 0.835, 0.824]), + MistyRose3: fromRgb([0.804, 0.716, 0.71]), + MistyRose4: fromRgb([0.545, 0.49, 0.484]), + NavajoWhite1: fromRgb([1, 0.87, 0.68]), + NavajoWhite2: fromRgb([0.932, 0.81, 0.63]), + NavajoWhite3: fromRgb([0.804, 0.7, 0.545]), + NavajoWhite4: fromRgb([0.545, 0.475, 0.37]), + OliveDrab1: fromRgb([0.752, 1, 0.244]), + OliveDrab2: fromRgb([0.7, 0.932, 0.228]), + OliveDrab3: fromRgb([0.604, 0.804, 0.196]), + OliveDrab4: fromRgb([0.41, 0.545, 0.132]), + Orange1: fromRgb([1, 0.648, 0]), + Orange2: fromRgb([0.932, 0.604, 0]), + Orange3: fromRgb([0.804, 0.52, 0]), + Orange4: fromRgb([0.545, 0.352, 0]), + OrangeRed1: fromRgb([1, 0.27, 0]), + OrangeRed2: fromRgb([0.932, 0.25, 0]), + OrangeRed3: fromRgb([0.804, 0.215, 0]), + OrangeRed4: fromRgb([0.545, 0.145, 0]), + Orchid1: fromRgb([1, 0.512, 0.98]), + Orchid2: fromRgb([0.932, 0.48, 0.912]), + Orchid3: fromRgb([0.804, 0.41, 0.79]), + Orchid4: fromRgb([0.545, 0.28, 0.536]), + PaleGreen1: fromRgb([0.604, 1, 0.604]), + PaleGreen2: fromRgb([0.565, 0.932, 0.565]), + PaleGreen3: fromRgb([0.488, 0.804, 0.488]), + PaleGreen4: fromRgb([0.33, 0.545, 0.33]), + PaleTurquoise1: fromRgb([0.732, 1, 1]), + PaleTurquoise2: fromRgb([0.684, 0.932, 0.932]), + PaleTurquoise3: fromRgb([0.59, 0.804, 0.804]), + PaleTurquoise4: fromRgb([0.4, 0.545, 0.545]), + PaleVioletRed1: fromRgb([1, 0.51, 0.67]), + PaleVioletRed2: fromRgb([0.932, 0.475, 0.624]), + PaleVioletRed3: fromRgb([0.804, 0.408, 0.536]), + PaleVioletRed4: fromRgb([0.545, 0.28, 0.365]), + PeachPuff1: fromRgb([1, 0.855, 0.725]), + PeachPuff2: fromRgb([0.932, 0.796, 0.68]), + PeachPuff3: fromRgb([0.804, 0.688, 0.585]), + PeachPuff4: fromRgb([0.545, 0.468, 0.396]), + Pink1: fromRgb([1, 0.71, 0.772]), + Pink2: fromRgb([0.932, 0.664, 0.72]), + Pink3: fromRgb([0.804, 0.57, 0.62]), + Pink4: fromRgb([0.545, 0.39, 0.424]), + Plum1: fromRgb([1, 0.732, 1]), + Plum2: fromRgb([0.932, 0.684, 0.932]), + Plum3: fromRgb([0.804, 0.59, 0.804]), + Plum4: fromRgb([0.545, 0.4, 0.545]), + Purple1: fromRgb([0.608, 0.19, 1]), + Purple2: fromRgb([0.57, 0.172, 0.932]), + Purple3: fromRgb([0.49, 0.15, 0.804]), + Purple4: fromRgb([0.332, 0.1, 0.545]), + Red1: fromRgb([1, 0, 0]), + Red2: fromRgb([0.932, 0, 0]), + Red3: fromRgb([0.804, 0, 0]), + Red4: fromRgb([0.545, 0, 0]), + RosyBrown1: fromRgb([1, 0.756, 0.756]), + RosyBrown2: fromRgb([0.932, 0.705, 0.705]), + RosyBrown3: fromRgb([0.804, 0.608, 0.608]), + RosyBrown4: fromRgb([0.545, 0.41, 0.41]), + RoyalBlue1: fromRgb([0.284, 0.464, 1]), + RoyalBlue2: fromRgb([0.264, 0.43, 0.932]), + RoyalBlue3: fromRgb([0.228, 0.372, 0.804]), + RoyalBlue4: fromRgb([0.152, 0.25, 0.545]), + Salmon1: fromRgb([1, 0.55, 0.41]), + Salmon2: fromRgb([0.932, 0.51, 0.385]), + Salmon3: fromRgb([0.804, 0.44, 0.33]), + Salmon4: fromRgb([0.545, 0.298, 0.224]), + SeaGreen1: fromRgb([0.33, 1, 0.624]), + SeaGreen2: fromRgb([0.305, 0.932, 0.58]), + SeaGreen3: fromRgb([0.264, 0.804, 0.5]), + SeaGreen4: fromRgb([0.18, 0.545, 0.34]), + Seashell1: fromRgb([1, 0.96, 0.932]), + Seashell2: fromRgb([0.932, 0.898, 0.87]), + Seashell3: fromRgb([0.804, 0.772, 0.75]), + Seashell4: fromRgb([0.545, 0.525, 0.51]), + Sienna1: fromRgb([1, 0.51, 0.28]), + Sienna2: fromRgb([0.932, 0.475, 0.26]), + Sienna3: fromRgb([0.804, 0.408, 0.224]), + Sienna4: fromRgb([0.545, 0.28, 0.15]), + SkyBlue1: fromRgb([0.53, 0.808, 1]), + SkyBlue2: fromRgb([0.494, 0.752, 0.932]), + SkyBlue3: fromRgb([0.424, 0.65, 0.804]), + SkyBlue4: fromRgb([0.29, 0.44, 0.545]), + SlateBlue1: fromRgb([0.512, 0.435, 1]), + SlateBlue2: fromRgb([0.48, 0.404, 0.932]), + SlateBlue3: fromRgb([0.41, 0.35, 0.804]), + SlateBlue4: fromRgb([0.28, 0.235, 0.545]), + SlateGray1: fromRgb([0.776, 0.888, 1]), + SlateGray2: fromRgb([0.725, 0.828, 0.932]), + SlateGray3: fromRgb([0.624, 0.712, 0.804]), + SlateGray4: fromRgb([0.424, 0.484, 0.545]), + Snow1: fromRgb([1, 0.98, 0.98]), + Snow2: fromRgb([0.932, 0.912, 0.912]), + Snow3: fromRgb([0.804, 0.79, 0.79]), + Snow4: fromRgb([0.545, 0.536, 0.536]), + SpringGreen1: fromRgb([0, 1, 0.498]), + SpringGreen2: fromRgb([0, 0.932, 0.464]), + SpringGreen3: fromRgb([0, 0.804, 0.4]), + SpringGreen4: fromRgb([0, 0.545, 0.27]), + SteelBlue1: fromRgb([0.39, 0.72, 1]), + SteelBlue2: fromRgb([0.36, 0.675, 0.932]), + SteelBlue3: fromRgb([0.31, 0.58, 0.804]), + SteelBlue4: fromRgb([0.21, 0.392, 0.545]), + Tan1: fromRgb([1, 0.648, 0.31]), + Tan2: fromRgb([0.932, 0.604, 0.288]), + Tan3: fromRgb([0.804, 0.52, 0.248]), + Tan4: fromRgb([0.545, 0.352, 0.17]), + Thistle1: fromRgb([1, 0.884, 1]), + Thistle2: fromRgb([0.932, 0.824, 0.932]), + Thistle3: fromRgb([0.804, 0.71, 0.804]), + Thistle4: fromRgb([0.545, 0.484, 0.545]), + Tomato1: fromRgb([1, 0.39, 0.28]), + Tomato2: fromRgb([0.932, 0.36, 0.26]), + Tomato3: fromRgb([0.804, 0.31, 0.224]), + Tomato4: fromRgb([0.545, 0.21, 0.15]), + Turquoise1: fromRgb([0, 0.96, 1]), + Turquoise2: fromRgb([0, 0.898, 0.932]), + Turquoise3: fromRgb([0, 0.772, 0.804]), + Turquoise4: fromRgb([0, 0.525, 0.545]), + VioletRed1: fromRgb([1, 0.244, 0.59]), + VioletRed2: fromRgb([0.932, 0.228, 0.55]), + VioletRed3: fromRgb([0.804, 0.196, 0.47]), + VioletRed4: fromRgb([0.545, 0.132, 0.32]), + Wheat1: fromRgb([1, 0.905, 0.73]), + Wheat2: fromRgb([0.932, 0.848, 0.684]), + Wheat3: fromRgb([0.804, 0.73, 0.59]), + Wheat4: fromRgb([0.545, 0.494, 0.4]), + Yellow1: fromRgb([1, 1, 0]), + Yellow2: fromRgb([0.932, 0.932, 0]), + Yellow3: fromRgb([0.804, 0.804, 0]), + Yellow4: fromRgb([0.545, 0.545, 0]), + Gray0: fromRgb([0.745, 0.745, 0.745]), + Green0: fromRgb([0, 1, 0]), + Grey0: fromRgb([0.745, 0.745, 0.745]), + Maroon0: fromRgb([0.69, 0.19, 0.376]), + Purple0: fromRgb([0.628, 0.125, 0.94]) +}; +const parseCache = {}; +function parse(str = "") { + parseCache[str] = parseCache[str] || XColorPegParser.parse(str); + return parseCache[str]; +} +const CORE_MODELS = /* @__PURE__ */ new Set(["rgb", "cmy", "cmyk", "hsb", "gray"]); +const XColorCoreModelToColor = { + rgb: ([r, g, b]) => Color([r * 255, g * 255, b * 255], "rgb"), + cmy: ([c, m, y]) => XColorCoreModelToColor.rgb([1 - c, 1 - m, 1 - y]), + cmyk: ([c, m, y, k]) => Color([c * 255, m * 255, y * 255, k * 100], "cmyk"), + hsb: ([h, s, b]) => Color([h * 360, s * 100, b * 100], "hsv"), + gray: ([v]) => Color([v * 255, v * 255, v * 255], "rgb") +}; +const XColorModelToColor = { + wave: ([lambda]) => { + const gamma = 0.8; + let baseRgb = [0, 0, 0]; + if (380 <= lambda && lambda < 440) { + baseRgb = [(440 - lambda) / (440 - 380), 0, 1]; + } + if (440 <= lambda && lambda < 490) { + baseRgb = [0, (lambda - 440) / (490 - 440), 1]; + } + if (490 <= lambda && lambda < 510) { + baseRgb = [0, 1, (510 - lambda) / (510 - 490)]; + } + if (510 <= lambda && lambda < 580) { + baseRgb = [(lambda - 510) / (580 - 510), 1, 0]; + } + if (580 <= lambda && lambda < 6450) { + baseRgb = [1, (645 - lambda) / (645 - 580), 0]; + } + if (645 <= lambda && lambda <= 780) { + baseRgb = [1, 0, 0]; + } + let f = 1; + if (380 <= lambda && 420 < lambda) { + f = 0.3 + 0.7 * (lambda - 380) / (420 - 380); + } + if (700 < lambda && lambda <= 780) { + f = 0.3 + 0.7 * (780 - lambda) / (780 - 700); + } + const rgb = [ + Math.pow(baseRgb[0] * f, gamma), + Math.pow(baseRgb[1] * f, gamma), + Math.pow(baseRgb[2] * f, gamma) + ]; + return Color([rgb[0] * 255, rgb[1] * 255, rgb[2] * 255], "rgb"); + }, + Hsb: ([h, s, b]) => XColorCoreModelToColor.hsb([h / 360, s, b]), + HSB: ([h, s, b]) => XColorCoreModelToColor.hsb([h / 240, s / 240, b / 240]), + HTML: ([v]) => v.startsWith("#") ? Color(v) : Color(`#${v}`), + RGB: ([r, g, b]) => Color([r, g, b], "rgb"), + Gray: ([v]) => XColorCoreModelToColor.gray([v / 15]), + ...XColorCoreModelToColor +}; +const ColorToXColorModel = { + rgb: (color) => color.rgb().array().map((v) => v / 255), + cmy: (color) => [255 - color.red(), 255 - color.green(), 255 - color.blue()].map( + (v) => v / 255 + ), + cmyk: (color) => color.cmyk().array().map((v, i) => i === 3 ? v / 100 : v / 255), + hsb: (color) => [ + color.hue() / 360, + color.saturationv() / 100, + color.value() / 100 + ], + gray: (color) => [color.gray() / 100] +}; +const PREDEFINED_XCOLOR_COLORS = { + // Core colors + red: XColorCoreModelToColor.rgb([1, 0, 0]), + green: XColorCoreModelToColor.rgb([0, 1, 0]), + blue: XColorCoreModelToColor.rgb([0, 0, 1]), + brown: XColorCoreModelToColor.rgb([0.75, 0.5, 0.25]), + lime: XColorCoreModelToColor.rgb([0.75, 1, 0]), + orange: XColorCoreModelToColor.rgb([1, 0.5, 0]), + pink: XColorCoreModelToColor.rgb([1, 0.75, 0.75]), + purple: XColorCoreModelToColor.rgb([0.75, 0, 0.25]), + teal: XColorCoreModelToColor.rgb([0, 0.5, 0.5]), + violet: XColorCoreModelToColor.rgb([0.5, 0, 0.5]), + cyan: XColorCoreModelToColor.rgb([0, 1, 1]), + magenta: XColorCoreModelToColor.rgb([1, 0, 1]), + yellow: XColorCoreModelToColor.rgb([1, 1, 0]), + olive: XColorCoreModelToColor.rgb([0.5, 0.5, 0]), + black: XColorCoreModelToColor.rgb([0, 0, 0]), + darkgray: XColorCoreModelToColor.rgb([0.25, 0.25, 0.25]), + gray: XColorCoreModelToColor.rgb([0.5, 0.5, 0.5]), + lightgray: XColorCoreModelToColor.rgb([0.75, 0.75, 0.75]), + white: XColorCoreModelToColor.rgb([1, 1, 1]), + ...DVI_PS_NAMES, + ...SVG_NAMES, + ...X11_NAMES +}; +function scalarMul(scalar, vec) { + return vec.map((v) => scalar * v); +} +function addVectors(...vecs) { + return vecs.reduce((prev, current) => prev.map((v, i) => v + current[i])); +} +function mixInModel(model, colorsAndCoefficients) { + if (!CORE_MODELS.has(model)) { + throw new Error( + `Cannot mix colors in model "${model}"; only core modes ${Array.from( + CORE_MODELS + ).join(", ")} are supported` + ); + } + const toModel = ColorToXColorModel[model]; + const fromModel = XColorCoreModelToColor[model]; + const mixed = addVectors( + ...colorsAndCoefficients.map(([v, color]) => { + const colorInModel = toModel(color); + return scalarMul(v, colorInModel); + }) + ); + return fromModel(mixed); +} +function computeColor(expr, predefinedColors = {}) { + if (expr.type !== "color") { + throw new Error( + `Can only compute the color of a "color" expression, not one of type ${expr.type}` + ); + } + const knownColors = { ...PREDEFINED_XCOLOR_COLORS, ...predefinedColors }; + function getColor(name) { + if (!knownColors[name]) { + throw new Error(`Unknown color "${name}"`); + } + return knownColors[name]; + } + const color = expr.color; + let computedColor = Color("#000000"); + if (color.type === "expr") { + let base = getColor(color.name); + for (const mix of color.mix_expr) { + if (mix.type === "complete_mix") { + const mixColor = getColor(mix.name); + base = base.mix(mixColor, 1 - mix.mix_percent / 100); + } else if (mix.type === "partial_mix") { + base = base.mix(Color("#FFFFFF"), 1 - mix.mix_percent / 100); + } + } + if (color.prefix && color.prefix.length % 2 === 1) { + base = base.rotate(180); + } + computedColor = base; + } + if (color.type === "extended_expr") { + const model = color.core_model; + const div = color.div || color.expressions.reduce((a, expr2) => a + expr2.weight, 0); + if (div <= 0) { + throw new Error( + `Cannot mix color with ratios that have a denominator of ${div}` + ); + } + const colorsToMix = color.expressions.map( + (expr2) => [ + expr2.weight / div, + computeColor({ + type: "color", + color: expr2.color, + functions: [] + }) + ] + ); + computedColor = mixInModel(model, colorsToMix); + } + for (const func of expr.functions) { + if (func.name === "wheel") { + const angle = func.args[0]; + const circ = func.args[1] || 360; + computedColor = computedColor.rotate(angle / circ * 360); + } + if (func.name === "twheel") { + const angle = func.args[0]; + const circ = func.args[1] || 360; + computedColor = computedColor.rotate(angle / circ * 360 + 60); + } + } + return computedColor; +} +function xcolorColorToHex(color, model, options = { predefinedColors: {} }) { + const { predefinedColors = {} } = options; + const parsed = parse(color); + if (model && model !== "default" && parsed.type !== "color") { + if (!(model in XColorModelToColor)) { + throw new Error( + `Unknown color model "${model}"; known models are ${Object.keys( + XColorModelToColor + ).join(", ")}` + ); + } + if (parsed.type !== "hex_spec" && parsed.type !== "num_spec") { + throw new Error( + `Cannot use model ${model} to compute the color "${color}"` + ); + } + if (model === "HTML" && parsed.type === "hex_spec") { + return XColorModelToColor.HTML(parsed.content).hex(); + } else if (parsed.type === "num_spec") { + return XColorModelToColor[model](parsed.content).hex(); + } + throw new Error( + `Don't know how to process color "${color}" in model "${model}"` + ); + } + if (Array.isArray(parsed) || parsed.type !== "color") { + throw new Error( + `Cannot the color "${color}" is not a valid color string` + ); + } + let computed = null; + try { + computed = computeColor(parsed, predefinedColors); + } catch (e) { + } + return computed && computed.hex(); +} +export { + DVI_PS_NAMES as D, + PREDEFINED_XCOLOR_COLORS as P, + SVG_NAMES as S, + XColorCoreModelToColor as X, + X11_NAMES as a, + computeColor as c, + environments as e, + macros as m, + parse as p, + xcolorColorToHex as x +}; +//# sourceMappingURL=xcolor-CIejE3rZ.js.map diff --git a/node_modules/@unified-latex/unified-latex-ctan/xcolor-CIejE3rZ.js.map b/node_modules/@unified-latex/unified-latex-ctan/xcolor-CIejE3rZ.js.map new file mode 100644 index 0000000..50b6287 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-ctan/xcolor-CIejE3rZ.js.map @@ -0,0 +1 @@ +{"version":3,"file":"xcolor-CIejE3rZ.js","sources":["../package/xcolor/provides.ts","../package/xcolor/libs/predefined-colors.ts","../package/xcolor/libs/parser.ts","../package/xcolor/libs/xcolor.ts"],"sourcesContent":["import {\n MacroInfoRecord,\n EnvInfoRecord,\n} from \"@unified-latex/unified-latex-types\";\n\nexport const macros: MacroInfoRecord = {\n substitutecolormodel: {\n signature: \"m m\",\n renderInfo: { breakAround: true },\n },\n selectcolormodel: {\n signature: \"m\",\n renderInfo: { breakAround: true },\n },\n definecolor: {\n signature: \"o m m m\",\n renderInfo: { breakAround: true },\n },\n providecolor: {\n signature: \"o m m m\",\n renderInfo: { breakAround: true },\n },\n colorlet: {\n signature: \"o m o m\",\n renderInfo: { breakAround: true },\n },\n definecolorset: {\n signature: \"o m m m\",\n renderInfo: { breakAround: true },\n },\n providecolorset: {\n signature: \"o m m m m\",\n renderInfo: { breakAround: true },\n },\n preparecolor: {\n signature: \"o m m m\",\n renderInfo: { breakAround: true },\n },\n preparecolorset: {\n signature: \"o m m m m\",\n renderInfo: { breakAround: true },\n },\n DefineNamedColor: {\n signature: \"m m m m\",\n renderInfo: { breakAround: true },\n },\n definecolors: {\n signature: \"m\",\n renderInfo: { breakAround: true },\n },\n providecolors: {\n signature: \"m\",\n renderInfo: { breakAround: true },\n },\n color: { signature: \"o m\", renderInfo: { breakAround: true } },\n textcolor: { signature: \"o m m\", renderInfo: { inParMode: true } },\n pagecolor: { signature: \"o m\" },\n colorbox: { signature: \"o m m\" },\n fcolorbox: { signature: \"o m o m m\" },\n boxframe: { signature: \"o m\" },\n testcolor: { signature: \"o m\" },\n blendcolors: { signature: \"s m\" },\n maskcolors: { signature: \"o m\" },\n definecolorseries: {\n signature: \"m m m o m o m\",\n renderInfo: { breakAround: true },\n },\n resetcolorseries: {\n signature: \"o m\",\n renderInfo: { breakAround: true },\n },\n rowcolors: { signature: \"s o m m m\" },\n extractcolorspec: { signature: \"m m\" },\n extractcolorspecs: { signature: \"m m m\" },\n convertcolorspec: { signature: \"m m m m\" },\n};\n\nexport const environments: EnvInfoRecord = {\n testcolors: { signature: \"o\", renderInfo: { pgfkeysArgs: true } },\n};\n","import Color from \"color\";\n\nconst fromRgb = ([r, g, b]: number[]) =>\n Color([r * 255, g * 255, b * 255], \"rgb\");\n\nexport const DVI_PS_NAMES = {\n Apricot: Color(\"#FBB982\"),\n Aquamarine: Color(\"#00B5BE\"),\n Bittersweet: Color(\"#C04F17\"),\n Black: Color(\"#221E1F\"),\n Blue: Color(\"#2D2F92\"),\n BlueGreen: Color(\"#00B3B8\"),\n BlueViolet: Color(\"#473992\"),\n BrickRed: Color(\"#B6321C\"),\n Brown: Color(\"#792500\"),\n BurntOrange: Color(\"#F7921D\"),\n CadetBlue: Color(\"#74729A\"),\n CarnationPink: Color(\"#F282B4\"),\n Cerulean: Color(\"#00A2E3\"),\n CornflowerBlue: Color(\"#41B0E4\"),\n Cyan: Color(\"#00AEEF\"),\n Dandelion: Color(\"#FDBC42\"),\n DarkOrchid: Color(\"#A4538A\"),\n Emerald: Color(\"#00A99D\"),\n ForestGreen: Color(\"#009B55\"),\n Fuchsia: Color(\"#8C368C\"),\n Goldenrod: Color(\"#FFDF42\"),\n Gray: Color(\"#949698\"),\n Green: Color(\"#00A64F\"),\n GreenYellow: Color(\"#DFE674\"),\n JungleGreen: Color(\"#00A99A\"),\n Lavender: Color(\"#F49EC4\"),\n LimeGreen: Color(\"#8DC73E\"),\n Magenta: Color(\"#EC008C\"),\n Mahogany: Color(\"#A9341F\"),\n Maroon: Color(\"#AF3235\"),\n Melon: Color(\"#F89E7B\"),\n MidnightBlue: Color(\"#006795\"),\n Mulberry: Color(\"#A93C93\"),\n NavyBlue: Color(\"#006EB8\"),\n OliveGreen: Color(\"#3C8031\"),\n Orange: Color(\"#F58137\"),\n OrangeRed: Color(\"#ED135A\"),\n Orchid: Color(\"#AF72B0\"),\n Peach: Color(\"#F7965A\"),\n Periwinkle: Color(\"#7977B8\"),\n PineGreen: Color(\"#008B72\"),\n Plum: Color(\"#92268F\"),\n ProcessBlue: Color(\"#00B0F0\"),\n Purple: Color(\"#99479B\"),\n RawSienna: Color(\"#974006\"),\n Red: Color(\"#ED1B23\"),\n RedOrange: Color(\"#F26035\"),\n RedViolet: Color(\"#A1246B\"),\n Rhodamine: Color(\"#EF559F\"),\n RoyalBlue: Color(\"#0071BC\"),\n RoyalPurple: Color(\"#613F99\"),\n RubineRed: Color(\"#ED017D\"),\n Salmon: Color(\"#F69289\"),\n SeaGreen: Color(\"#3FBC9D\"),\n Sepia: Color(\"#671800\"),\n SkyBlue: Color(\"#46C5DD\"),\n SpringGreen: Color(\"#C6DC67\"),\n Tan: Color(\"#DA9D76\"),\n TealBlue: Color(\"#00AEB3\"),\n Thistle: Color(\"#D883B7\"),\n Turquoise: Color(\"#00B4CE\"),\n Violet: Color(\"#58429B\"),\n VioletRed: Color(\"#EF58A0\"),\n White: Color(\"#FFFFFF\"),\n WildStrawberry: Color(\"#EE2967\"),\n Yellow: Color(\"#FFF200\"),\n YellowGreen: Color(\"#98CC70\"),\n YellowOrange: Color(\"#FAA21A\"),\n};\n\nexport const SVG_NAMES = {\n AliceBlue: fromRgb([0.94, 0.972, 1]),\n AntiqueWhite: fromRgb([0.98, 0.92, 0.844]),\n Aqua: fromRgb([0, 1, 1]),\n Aquamarine: fromRgb([0.498, 1, 0.83]),\n Azure: fromRgb([0.94, 1, 1]),\n Beige: fromRgb([0.96, 0.96, 0.864]),\n Bisque: fromRgb([1, 0.894, 0.77]),\n Black: fromRgb([0, 0, 0]),\n BlanchedAlmond: fromRgb([1, 0.92, 0.804]),\n Blue: fromRgb([0, 0, 1]),\n BlueViolet: fromRgb([0.54, 0.17, 0.888]),\n Brown: fromRgb([0.648, 0.165, 0.165]),\n BurlyWood: fromRgb([0.87, 0.72, 0.53]),\n CadetBlue: fromRgb([0.372, 0.62, 0.628]),\n Chartreuse: fromRgb([0.498, 1, 0]),\n Chocolate: fromRgb([0.824, 0.41, 0.116]),\n Coral: fromRgb([1, 0.498, 0.312]),\n CornflowerBlue: fromRgb([0.392, 0.585, 0.93]),\n Cornsilk: fromRgb([1, 0.972, 0.864]),\n Crimson: fromRgb([0.864, 0.08, 0.235]),\n Cyan: fromRgb([0, 1, 1]),\n DarkBlue: fromRgb([0, 0, 0.545]),\n DarkCyan: fromRgb([0, 0.545, 0.545]),\n DarkGoldenrod: fromRgb([0.72, 0.525, 0.044]),\n DarkGray: fromRgb([0.664, 0.664, 0.664]),\n DarkGreen: fromRgb([0, 0.392, 0]),\n DarkGrey: fromRgb([0.664, 0.664, 0.664]),\n DarkKhaki: fromRgb([0.74, 0.716, 0.42]),\n DarkMagenta: fromRgb([0.545, 0, 0.545]),\n DarkOliveGreen: fromRgb([0.332, 0.42, 0.185]),\n DarkOrange: fromRgb([1, 0.55, 0]),\n DarkOrchid: fromRgb([0.6, 0.196, 0.8]),\n DarkRed: fromRgb([0.545, 0, 0]),\n DarkSalmon: fromRgb([0.912, 0.59, 0.48]),\n DarkSeaGreen: fromRgb([0.56, 0.736, 0.56]),\n DarkSlateBlue: fromRgb([0.284, 0.24, 0.545]),\n DarkSlateGray: fromRgb([0.185, 0.31, 0.31]),\n DarkSlateGrey: fromRgb([0.185, 0.31, 0.31]),\n DarkTurquoise: fromRgb([0, 0.808, 0.82]),\n DarkViolet: fromRgb([0.58, 0, 0.828]),\n DeepPink: fromRgb([1, 0.08, 0.576]),\n DeepSkyBlue: fromRgb([0, 0.75, 1]),\n DimGray: fromRgb([0.41, 0.41, 0.41]),\n DimGrey: fromRgb([0.41, 0.41, 0.41]),\n DodgerBlue: fromRgb([0.116, 0.565, 1]),\n FireBrick: fromRgb([0.698, 0.132, 0.132]),\n FloralWhite: fromRgb([1, 0.98, 0.94]),\n ForestGreen: fromRgb([0.132, 0.545, 0.132]),\n Fuchsia: fromRgb([1, 0, 1]),\n Gainsboro: fromRgb([0.864, 0.864, 0.864]),\n GhostWhite: fromRgb([0.972, 0.972, 1]),\n Gold: fromRgb([1, 0.844, 0]),\n Goldenrod: fromRgb([0.855, 0.648, 0.125]),\n Gray: fromRgb([0.5, 0.5, 0.5]),\n Green: fromRgb([0, 0.5, 0]),\n GreenYellow: fromRgb([0.68, 1, 0.185]),\n Grey: fromRgb([0.5, 0.5, 0.5]),\n Honeydew: fromRgb([0.94, 1, 0.94]),\n HotPink: fromRgb([1, 0.41, 0.705]),\n IndianRed: fromRgb([0.804, 0.36, 0.36]),\n Indigo: fromRgb([0.294, 0, 0.51]),\n Ivory: fromRgb([1, 1, 0.94]),\n Khaki: fromRgb([0.94, 0.9, 0.55]),\n Lavender: fromRgb([0.9, 0.9, 0.98]),\n LavenderBlush: fromRgb([1, 0.94, 0.96]),\n LawnGreen: fromRgb([0.488, 0.99, 0]),\n LemonChiffon: fromRgb([1, 0.98, 0.804]),\n LightBlue: fromRgb([0.68, 0.848, 0.9]),\n LightCoral: fromRgb([0.94, 0.5, 0.5]),\n LightCyan: fromRgb([0.88, 1, 1]),\n LightGoldenrod: fromRgb([0.933, 0.867, 0.51]),\n LightGoldenrodYellow: fromRgb([0.98, 0.98, 0.824]),\n LightGray: fromRgb([0.828, 0.828, 0.828]),\n LightGreen: fromRgb([0.565, 0.932, 0.565]),\n LightGrey: fromRgb([0.828, 0.828, 0.828]),\n LightPink: fromRgb([1, 0.712, 0.756]),\n LightSalmon: fromRgb([1, 0.628, 0.48]),\n LightSeaGreen: fromRgb([0.125, 0.698, 0.668]),\n LightSkyBlue: fromRgb([0.53, 0.808, 0.98]),\n LightSlateBlue: fromRgb([0.518, 0.44, 1]),\n LightSlateGray: fromRgb([0.468, 0.532, 0.6]),\n LightSlateGrey: fromRgb([0.468, 0.532, 0.6]),\n LightSteelBlue: fromRgb([0.69, 0.77, 0.87]),\n LightYellow: fromRgb([1, 1, 0.88]),\n Lime: fromRgb([0, 1, 0]),\n LimeGreen: fromRgb([0.196, 0.804, 0.196]),\n Linen: fromRgb([0.98, 0.94, 0.9]),\n Magenta: fromRgb([1, 0, 1]),\n Maroon: fromRgb([0.5, 0, 0]),\n MediumAquamarine: fromRgb([0.4, 0.804, 0.668]),\n MediumBlue: fromRgb([0, 0, 0.804]),\n MediumOrchid: fromRgb([0.73, 0.332, 0.828]),\n MediumPurple: fromRgb([0.576, 0.44, 0.86]),\n MediumSeaGreen: fromRgb([0.235, 0.7, 0.444]),\n MediumSlateBlue: fromRgb([0.484, 0.408, 0.932]),\n MediumSpringGreen: fromRgb([0, 0.98, 0.604]),\n MediumTurquoise: fromRgb([0.284, 0.82, 0.8]),\n MediumVioletRed: fromRgb([0.78, 0.084, 0.52]),\n MidnightBlue: fromRgb([0.098, 0.098, 0.44]),\n MintCream: fromRgb([0.96, 1, 0.98]),\n MistyRose: fromRgb([1, 0.894, 0.884]),\n Moccasin: fromRgb([1, 0.894, 0.71]),\n NavajoWhite: fromRgb([1, 0.87, 0.68]),\n Navy: fromRgb([0, 0, 0.5]),\n NavyBlue: fromRgb([0, 0, 0.5]),\n OldLace: fromRgb([0.992, 0.96, 0.9]),\n Olive: fromRgb([0.5, 0.5, 0]),\n OliveDrab: fromRgb([0.42, 0.556, 0.136]),\n Orange: fromRgb([1, 0.648, 0]),\n OrangeRed: fromRgb([1, 0.27, 0]),\n Orchid: fromRgb([0.855, 0.44, 0.84]),\n PaleGoldenrod: fromRgb([0.932, 0.91, 0.668]),\n PaleGreen: fromRgb([0.596, 0.985, 0.596]),\n PaleTurquoise: fromRgb([0.688, 0.932, 0.932]),\n PaleVioletRed: fromRgb([0.86, 0.44, 0.576]),\n PapayaWhip: fromRgb([1, 0.936, 0.835]),\n PeachPuff: fromRgb([1, 0.855, 0.725]),\n Peru: fromRgb([0.804, 0.52, 0.248]),\n Pink: fromRgb([1, 0.752, 0.796]),\n Plum: fromRgb([0.868, 0.628, 0.868]),\n PowderBlue: fromRgb([0.69, 0.88, 0.9]),\n Purple: fromRgb([0.5, 0, 0.5]),\n Red: fromRgb([1, 0, 0]),\n RosyBrown: fromRgb([0.736, 0.56, 0.56]),\n RoyalBlue: fromRgb([0.255, 0.41, 0.884]),\n SaddleBrown: fromRgb([0.545, 0.27, 0.075]),\n Salmon: fromRgb([0.98, 0.5, 0.448]),\n SandyBrown: fromRgb([0.956, 0.644, 0.376]),\n SeaGreen: fromRgb([0.18, 0.545, 0.34]),\n Seashell: fromRgb([1, 0.96, 0.932]),\n Sienna: fromRgb([0.628, 0.32, 0.176]),\n Silver: fromRgb([0.752, 0.752, 0.752]),\n SkyBlue: fromRgb([0.53, 0.808, 0.92]),\n SlateBlue: fromRgb([0.415, 0.352, 0.804]),\n SlateGray: fromRgb([0.44, 0.5, 0.565]),\n SlateGrey: fromRgb([0.44, 0.5, 0.565]),\n Snow: fromRgb([1, 0.98, 0.98]),\n SpringGreen: fromRgb([0, 1, 0.498]),\n SteelBlue: fromRgb([0.275, 0.51, 0.705]),\n Tan: fromRgb([0.824, 0.705, 0.55]),\n Teal: fromRgb([0, 0.5, 0.5]),\n Thistle: fromRgb([0.848, 0.75, 0.848]),\n Tomato: fromRgb([1, 0.39, 0.28]),\n Turquoise: fromRgb([0.25, 0.88, 0.815]),\n Violet: fromRgb([0.932, 0.51, 0.932]),\n VioletRed: fromRgb([0.816, 0.125, 0.565]),\n Wheat: fromRgb([0.96, 0.87, 0.7]),\n White: fromRgb([1, 1, 1]),\n WhiteSmoke: fromRgb([0.96, 0.96, 0.96]),\n Yellow: fromRgb([1, 1, 0]),\n YellowGreen: fromRgb([0.604, 0.804, 0.196]),\n};\n\nexport const X11_NAMES = {\n AntiqueWhite1: fromRgb([1, 0.936, 0.86]),\n AntiqueWhite2: fromRgb([0.932, 0.875, 0.8]),\n AntiqueWhite3: fromRgb([0.804, 0.752, 0.69]),\n AntiqueWhite4: fromRgb([0.545, 0.512, 0.47]),\n Aquamarine1: fromRgb([0.498, 1, 0.83]),\n Aquamarine2: fromRgb([0.464, 0.932, 0.776]),\n Aquamarine3: fromRgb([0.4, 0.804, 0.668]),\n Aquamarine4: fromRgb([0.27, 0.545, 0.455]),\n Azure1: fromRgb([0.94, 1, 1]),\n Azure2: fromRgb([0.88, 0.932, 0.932]),\n Azure3: fromRgb([0.756, 0.804, 0.804]),\n Azure4: fromRgb([0.512, 0.545, 0.545]),\n Bisque1: fromRgb([1, 0.894, 0.77]),\n Bisque2: fromRgb([0.932, 0.835, 0.716]),\n Bisque3: fromRgb([0.804, 0.716, 0.62]),\n Bisque4: fromRgb([0.545, 0.49, 0.42]),\n Blue1: fromRgb([0, 0, 1]),\n Blue2: fromRgb([0, 0, 0.932]),\n Blue3: fromRgb([0, 0, 0.804]),\n Blue4: fromRgb([0, 0, 0.545]),\n Brown1: fromRgb([1, 0.25, 0.25]),\n Brown2: fromRgb([0.932, 0.23, 0.23]),\n Brown3: fromRgb([0.804, 0.2, 0.2]),\n Brown4: fromRgb([0.545, 0.136, 0.136]),\n Burlywood1: fromRgb([1, 0.828, 0.608]),\n Burlywood2: fromRgb([0.932, 0.772, 0.57]),\n Burlywood3: fromRgb([0.804, 0.668, 0.49]),\n Burlywood4: fromRgb([0.545, 0.45, 0.332]),\n CadetBlue1: fromRgb([0.596, 0.96, 1]),\n CadetBlue2: fromRgb([0.556, 0.898, 0.932]),\n CadetBlue3: fromRgb([0.48, 0.772, 0.804]),\n CadetBlue4: fromRgb([0.325, 0.525, 0.545]),\n Chartreuse1: fromRgb([0.498, 1, 0]),\n Chartreuse2: fromRgb([0.464, 0.932, 0]),\n Chartreuse3: fromRgb([0.4, 0.804, 0]),\n Chartreuse4: fromRgb([0.27, 0.545, 0]),\n Chocolate1: fromRgb([1, 0.498, 0.14]),\n Chocolate2: fromRgb([0.932, 0.464, 0.13]),\n Chocolate3: fromRgb([0.804, 0.4, 0.112]),\n Chocolate4: fromRgb([0.545, 0.27, 0.075]),\n Coral1: fromRgb([1, 0.448, 0.336]),\n Coral2: fromRgb([0.932, 0.415, 0.312]),\n Coral3: fromRgb([0.804, 0.356, 0.27]),\n Coral4: fromRgb([0.545, 0.244, 0.185]),\n Cornsilk1: fromRgb([1, 0.972, 0.864]),\n Cornsilk2: fromRgb([0.932, 0.91, 0.804]),\n Cornsilk3: fromRgb([0.804, 0.785, 0.694]),\n Cornsilk4: fromRgb([0.545, 0.532, 0.47]),\n Cyan1: fromRgb([0, 1, 1]),\n Cyan2: fromRgb([0, 0.932, 0.932]),\n Cyan3: fromRgb([0, 0.804, 0.804]),\n Cyan4: fromRgb([0, 0.545, 0.545]),\n DarkGoldenrod1: fromRgb([1, 0.725, 0.06]),\n DarkGoldenrod2: fromRgb([0.932, 0.68, 0.055]),\n DarkGoldenrod3: fromRgb([0.804, 0.585, 0.048]),\n DarkGoldenrod4: fromRgb([0.545, 0.396, 0.03]),\n DarkOliveGreen1: fromRgb([0.792, 1, 0.44]),\n DarkOliveGreen2: fromRgb([0.736, 0.932, 0.408]),\n DarkOliveGreen3: fromRgb([0.635, 0.804, 0.352]),\n DarkOliveGreen4: fromRgb([0.43, 0.545, 0.24]),\n DarkOrange1: fromRgb([1, 0.498, 0]),\n DarkOrange2: fromRgb([0.932, 0.464, 0]),\n DarkOrange3: fromRgb([0.804, 0.4, 0]),\n DarkOrange4: fromRgb([0.545, 0.27, 0]),\n DarkOrchid1: fromRgb([0.75, 0.244, 1]),\n DarkOrchid2: fromRgb([0.698, 0.228, 0.932]),\n DarkOrchid3: fromRgb([0.604, 0.196, 0.804]),\n DarkOrchid4: fromRgb([0.408, 0.132, 0.545]),\n DarkSeaGreen1: fromRgb([0.756, 1, 0.756]),\n DarkSeaGreen2: fromRgb([0.705, 0.932, 0.705]),\n DarkSeaGreen3: fromRgb([0.608, 0.804, 0.608]),\n DarkSeaGreen4: fromRgb([0.41, 0.545, 0.41]),\n DarkSlateGray1: fromRgb([0.592, 1, 1]),\n DarkSlateGray2: fromRgb([0.552, 0.932, 0.932]),\n DarkSlateGray3: fromRgb([0.475, 0.804, 0.804]),\n DarkSlateGray4: fromRgb([0.32, 0.545, 0.545]),\n DeepPink1: fromRgb([1, 0.08, 0.576]),\n DeepPink2: fromRgb([0.932, 0.07, 0.536]),\n DeepPink3: fromRgb([0.804, 0.064, 0.464]),\n DeepPink4: fromRgb([0.545, 0.04, 0.312]),\n DeepSkyBlue1: fromRgb([0, 0.75, 1]),\n DeepSkyBlue2: fromRgb([0, 0.698, 0.932]),\n DeepSkyBlue3: fromRgb([0, 0.604, 0.804]),\n DeepSkyBlue4: fromRgb([0, 0.408, 0.545]),\n DodgerBlue1: fromRgb([0.116, 0.565, 1]),\n DodgerBlue2: fromRgb([0.11, 0.525, 0.932]),\n DodgerBlue3: fromRgb([0.094, 0.455, 0.804]),\n DodgerBlue4: fromRgb([0.064, 0.305, 0.545]),\n Firebrick1: fromRgb([1, 0.19, 0.19]),\n Firebrick2: fromRgb([0.932, 0.172, 0.172]),\n Firebrick3: fromRgb([0.804, 0.15, 0.15]),\n Firebrick4: fromRgb([0.545, 0.1, 0.1]),\n Gold1: fromRgb([1, 0.844, 0]),\n Gold2: fromRgb([0.932, 0.79, 0]),\n Gold3: fromRgb([0.804, 0.68, 0]),\n Gold4: fromRgb([0.545, 0.46, 0]),\n Goldenrod1: fromRgb([1, 0.756, 0.145]),\n Goldenrod2: fromRgb([0.932, 0.705, 0.132]),\n Goldenrod3: fromRgb([0.804, 0.608, 0.112]),\n Goldenrod4: fromRgb([0.545, 0.41, 0.08]),\n Green1: fromRgb([0, 1, 0]),\n Green2: fromRgb([0, 0.932, 0]),\n Green3: fromRgb([0, 0.804, 0]),\n Green4: fromRgb([0, 0.545, 0]),\n Honeydew1: fromRgb([0.94, 1, 0.94]),\n Honeydew2: fromRgb([0.88, 0.932, 0.88]),\n Honeydew3: fromRgb([0.756, 0.804, 0.756]),\n Honeydew4: fromRgb([0.512, 0.545, 0.512]),\n HotPink1: fromRgb([1, 0.43, 0.705]),\n HotPink2: fromRgb([0.932, 0.415, 0.655]),\n HotPink3: fromRgb([0.804, 0.376, 0.565]),\n HotPink4: fromRgb([0.545, 0.228, 0.385]),\n IndianRed1: fromRgb([1, 0.415, 0.415]),\n IndianRed2: fromRgb([0.932, 0.39, 0.39]),\n IndianRed3: fromRgb([0.804, 0.332, 0.332]),\n IndianRed4: fromRgb([0.545, 0.228, 0.228]),\n Ivory1: fromRgb([1, 1, 0.94]),\n Ivory2: fromRgb([0.932, 0.932, 0.88]),\n Ivory3: fromRgb([0.804, 0.804, 0.756]),\n Ivory4: fromRgb([0.545, 0.545, 0.512]),\n Khaki1: fromRgb([1, 0.965, 0.56]),\n Khaki2: fromRgb([0.932, 0.9, 0.52]),\n Khaki3: fromRgb([0.804, 0.776, 0.45]),\n Khaki4: fromRgb([0.545, 0.525, 0.305]),\n LavenderBlush1: fromRgb([1, 0.94, 0.96]),\n LavenderBlush2: fromRgb([0.932, 0.88, 0.898]),\n LavenderBlush3: fromRgb([0.804, 0.756, 0.772]),\n LavenderBlush4: fromRgb([0.545, 0.512, 0.525]),\n LemonChiffon1: fromRgb([1, 0.98, 0.804]),\n LemonChiffon2: fromRgb([0.932, 0.912, 0.75]),\n LemonChiffon3: fromRgb([0.804, 0.79, 0.648]),\n LemonChiffon4: fromRgb([0.545, 0.536, 0.44]),\n LightBlue1: fromRgb([0.75, 0.936, 1]),\n LightBlue2: fromRgb([0.698, 0.875, 0.932]),\n LightBlue3: fromRgb([0.604, 0.752, 0.804]),\n LightBlue4: fromRgb([0.408, 0.512, 0.545]),\n LightCyan1: fromRgb([0.88, 1, 1]),\n LightCyan2: fromRgb([0.82, 0.932, 0.932]),\n LightCyan3: fromRgb([0.705, 0.804, 0.804]),\n LightCyan4: fromRgb([0.48, 0.545, 0.545]),\n LightGoldenrod1: fromRgb([1, 0.925, 0.545]),\n LightGoldenrod2: fromRgb([0.932, 0.864, 0.51]),\n LightGoldenrod3: fromRgb([0.804, 0.745, 0.44]),\n LightGoldenrod4: fromRgb([0.545, 0.505, 0.298]),\n LightPink1: fromRgb([1, 0.684, 0.725]),\n LightPink2: fromRgb([0.932, 0.635, 0.68]),\n LightPink3: fromRgb([0.804, 0.55, 0.585]),\n LightPink4: fromRgb([0.545, 0.372, 0.396]),\n LightSalmon1: fromRgb([1, 0.628, 0.48]),\n LightSalmon2: fromRgb([0.932, 0.585, 0.448]),\n LightSalmon3: fromRgb([0.804, 0.505, 0.385]),\n LightSalmon4: fromRgb([0.545, 0.34, 0.26]),\n LightSkyBlue1: fromRgb([0.69, 0.888, 1]),\n LightSkyBlue2: fromRgb([0.644, 0.828, 0.932]),\n LightSkyBlue3: fromRgb([0.552, 0.712, 0.804]),\n LightSkyBlue4: fromRgb([0.376, 0.484, 0.545]),\n LightSteelBlue1: fromRgb([0.792, 0.884, 1]),\n LightSteelBlue2: fromRgb([0.736, 0.824, 0.932]),\n LightSteelBlue3: fromRgb([0.635, 0.71, 0.804]),\n LightSteelBlue4: fromRgb([0.43, 0.484, 0.545]),\n LightYellow1: fromRgb([1, 1, 0.88]),\n LightYellow2: fromRgb([0.932, 0.932, 0.82]),\n LightYellow3: fromRgb([0.804, 0.804, 0.705]),\n LightYellow4: fromRgb([0.545, 0.545, 0.48]),\n Magenta1: fromRgb([1, 0, 1]),\n Magenta2: fromRgb([0.932, 0, 0.932]),\n Magenta3: fromRgb([0.804, 0, 0.804]),\n Magenta4: fromRgb([0.545, 0, 0.545]),\n Maroon1: fromRgb([1, 0.204, 0.7]),\n Maroon2: fromRgb([0.932, 0.19, 0.655]),\n Maroon3: fromRgb([0.804, 0.16, 0.565]),\n Maroon4: fromRgb([0.545, 0.11, 0.385]),\n MediumOrchid1: fromRgb([0.88, 0.4, 1]),\n MediumOrchid2: fromRgb([0.82, 0.372, 0.932]),\n MediumOrchid3: fromRgb([0.705, 0.32, 0.804]),\n MediumOrchid4: fromRgb([0.48, 0.215, 0.545]),\n MediumPurple1: fromRgb([0.67, 0.51, 1]),\n MediumPurple2: fromRgb([0.624, 0.475, 0.932]),\n MediumPurple3: fromRgb([0.536, 0.408, 0.804]),\n MediumPurple4: fromRgb([0.365, 0.28, 0.545]),\n MistyRose1: fromRgb([1, 0.894, 0.884]),\n MistyRose2: fromRgb([0.932, 0.835, 0.824]),\n MistyRose3: fromRgb([0.804, 0.716, 0.71]),\n MistyRose4: fromRgb([0.545, 0.49, 0.484]),\n NavajoWhite1: fromRgb([1, 0.87, 0.68]),\n NavajoWhite2: fromRgb([0.932, 0.81, 0.63]),\n NavajoWhite3: fromRgb([0.804, 0.7, 0.545]),\n NavajoWhite4: fromRgb([0.545, 0.475, 0.37]),\n OliveDrab1: fromRgb([0.752, 1, 0.244]),\n OliveDrab2: fromRgb([0.7, 0.932, 0.228]),\n OliveDrab3: fromRgb([0.604, 0.804, 0.196]),\n OliveDrab4: fromRgb([0.41, 0.545, 0.132]),\n Orange1: fromRgb([1, 0.648, 0]),\n Orange2: fromRgb([0.932, 0.604, 0]),\n Orange3: fromRgb([0.804, 0.52, 0]),\n Orange4: fromRgb([0.545, 0.352, 0]),\n OrangeRed1: fromRgb([1, 0.27, 0]),\n OrangeRed2: fromRgb([0.932, 0.25, 0]),\n OrangeRed3: fromRgb([0.804, 0.215, 0]),\n OrangeRed4: fromRgb([0.545, 0.145, 0]),\n Orchid1: fromRgb([1, 0.512, 0.98]),\n Orchid2: fromRgb([0.932, 0.48, 0.912]),\n Orchid3: fromRgb([0.804, 0.41, 0.79]),\n Orchid4: fromRgb([0.545, 0.28, 0.536]),\n PaleGreen1: fromRgb([0.604, 1, 0.604]),\n PaleGreen2: fromRgb([0.565, 0.932, 0.565]),\n PaleGreen3: fromRgb([0.488, 0.804, 0.488]),\n PaleGreen4: fromRgb([0.33, 0.545, 0.33]),\n PaleTurquoise1: fromRgb([0.732, 1, 1]),\n PaleTurquoise2: fromRgb([0.684, 0.932, 0.932]),\n PaleTurquoise3: fromRgb([0.59, 0.804, 0.804]),\n PaleTurquoise4: fromRgb([0.4, 0.545, 0.545]),\n PaleVioletRed1: fromRgb([1, 0.51, 0.67]),\n PaleVioletRed2: fromRgb([0.932, 0.475, 0.624]),\n PaleVioletRed3: fromRgb([0.804, 0.408, 0.536]),\n PaleVioletRed4: fromRgb([0.545, 0.28, 0.365]),\n PeachPuff1: fromRgb([1, 0.855, 0.725]),\n PeachPuff2: fromRgb([0.932, 0.796, 0.68]),\n PeachPuff3: fromRgb([0.804, 0.688, 0.585]),\n PeachPuff4: fromRgb([0.545, 0.468, 0.396]),\n Pink1: fromRgb([1, 0.71, 0.772]),\n Pink2: fromRgb([0.932, 0.664, 0.72]),\n Pink3: fromRgb([0.804, 0.57, 0.62]),\n Pink4: fromRgb([0.545, 0.39, 0.424]),\n Plum1: fromRgb([1, 0.732, 1]),\n Plum2: fromRgb([0.932, 0.684, 0.932]),\n Plum3: fromRgb([0.804, 0.59, 0.804]),\n Plum4: fromRgb([0.545, 0.4, 0.545]),\n Purple1: fromRgb([0.608, 0.19, 1]),\n Purple2: fromRgb([0.57, 0.172, 0.932]),\n Purple3: fromRgb([0.49, 0.15, 0.804]),\n Purple4: fromRgb([0.332, 0.1, 0.545]),\n Red1: fromRgb([1, 0, 0]),\n Red2: fromRgb([0.932, 0, 0]),\n Red3: fromRgb([0.804, 0, 0]),\n Red4: fromRgb([0.545, 0, 0]),\n RosyBrown1: fromRgb([1, 0.756, 0.756]),\n RosyBrown2: fromRgb([0.932, 0.705, 0.705]),\n RosyBrown3: fromRgb([0.804, 0.608, 0.608]),\n RosyBrown4: fromRgb([0.545, 0.41, 0.41]),\n RoyalBlue1: fromRgb([0.284, 0.464, 1]),\n RoyalBlue2: fromRgb([0.264, 0.43, 0.932]),\n RoyalBlue3: fromRgb([0.228, 0.372, 0.804]),\n RoyalBlue4: fromRgb([0.152, 0.25, 0.545]),\n Salmon1: fromRgb([1, 0.55, 0.41]),\n Salmon2: fromRgb([0.932, 0.51, 0.385]),\n Salmon3: fromRgb([0.804, 0.44, 0.33]),\n Salmon4: fromRgb([0.545, 0.298, 0.224]),\n SeaGreen1: fromRgb([0.33, 1, 0.624]),\n SeaGreen2: fromRgb([0.305, 0.932, 0.58]),\n SeaGreen3: fromRgb([0.264, 0.804, 0.5]),\n SeaGreen4: fromRgb([0.18, 0.545, 0.34]),\n Seashell1: fromRgb([1, 0.96, 0.932]),\n Seashell2: fromRgb([0.932, 0.898, 0.87]),\n Seashell3: fromRgb([0.804, 0.772, 0.75]),\n Seashell4: fromRgb([0.545, 0.525, 0.51]),\n Sienna1: fromRgb([1, 0.51, 0.28]),\n Sienna2: fromRgb([0.932, 0.475, 0.26]),\n Sienna3: fromRgb([0.804, 0.408, 0.224]),\n Sienna4: fromRgb([0.545, 0.28, 0.15]),\n SkyBlue1: fromRgb([0.53, 0.808, 1]),\n SkyBlue2: fromRgb([0.494, 0.752, 0.932]),\n SkyBlue3: fromRgb([0.424, 0.65, 0.804]),\n SkyBlue4: fromRgb([0.29, 0.44, 0.545]),\n SlateBlue1: fromRgb([0.512, 0.435, 1]),\n SlateBlue2: fromRgb([0.48, 0.404, 0.932]),\n SlateBlue3: fromRgb([0.41, 0.35, 0.804]),\n SlateBlue4: fromRgb([0.28, 0.235, 0.545]),\n SlateGray1: fromRgb([0.776, 0.888, 1]),\n SlateGray2: fromRgb([0.725, 0.828, 0.932]),\n SlateGray3: fromRgb([0.624, 0.712, 0.804]),\n SlateGray4: fromRgb([0.424, 0.484, 0.545]),\n Snow1: fromRgb([1, 0.98, 0.98]),\n Snow2: fromRgb([0.932, 0.912, 0.912]),\n Snow3: fromRgb([0.804, 0.79, 0.79]),\n Snow4: fromRgb([0.545, 0.536, 0.536]),\n SpringGreen1: fromRgb([0, 1, 0.498]),\n SpringGreen2: fromRgb([0, 0.932, 0.464]),\n SpringGreen3: fromRgb([0, 0.804, 0.4]),\n SpringGreen4: fromRgb([0, 0.545, 0.27]),\n SteelBlue1: fromRgb([0.39, 0.72, 1]),\n SteelBlue2: fromRgb([0.36, 0.675, 0.932]),\n SteelBlue3: fromRgb([0.31, 0.58, 0.804]),\n SteelBlue4: fromRgb([0.21, 0.392, 0.545]),\n Tan1: fromRgb([1, 0.648, 0.31]),\n Tan2: fromRgb([0.932, 0.604, 0.288]),\n Tan3: fromRgb([0.804, 0.52, 0.248]),\n Tan4: fromRgb([0.545, 0.352, 0.17]),\n Thistle1: fromRgb([1, 0.884, 1]),\n Thistle2: fromRgb([0.932, 0.824, 0.932]),\n Thistle3: fromRgb([0.804, 0.71, 0.804]),\n Thistle4: fromRgb([0.545, 0.484, 0.545]),\n Tomato1: fromRgb([1, 0.39, 0.28]),\n Tomato2: fromRgb([0.932, 0.36, 0.26]),\n Tomato3: fromRgb([0.804, 0.31, 0.224]),\n Tomato4: fromRgb([0.545, 0.21, 0.15]),\n Turquoise1: fromRgb([0, 0.96, 1]),\n Turquoise2: fromRgb([0, 0.898, 0.932]),\n Turquoise3: fromRgb([0, 0.772, 0.804]),\n Turquoise4: fromRgb([0, 0.525, 0.545]),\n VioletRed1: fromRgb([1, 0.244, 0.59]),\n VioletRed2: fromRgb([0.932, 0.228, 0.55]),\n VioletRed3: fromRgb([0.804, 0.196, 0.47]),\n VioletRed4: fromRgb([0.545, 0.132, 0.32]),\n Wheat1: fromRgb([1, 0.905, 0.73]),\n Wheat2: fromRgb([0.932, 0.848, 0.684]),\n Wheat3: fromRgb([0.804, 0.73, 0.59]),\n Wheat4: fromRgb([0.545, 0.494, 0.4]),\n Yellow1: fromRgb([1, 1, 0]),\n Yellow2: fromRgb([0.932, 0.932, 0]),\n Yellow3: fromRgb([0.804, 0.804, 0]),\n Yellow4: fromRgb([0.545, 0.545, 0]),\n Gray0: fromRgb([0.745, 0.745, 0.745]),\n Green0: fromRgb([0, 1, 0]),\n Grey0: fromRgb([0.745, 0.745, 0.745]),\n Maroon0: fromRgb([0.69, 0.19, 0.376]),\n Purple0: fromRgb([0.628, 0.125, 0.94]),\n};\n","import { XColorPegParser } from \"@unified-latex/unified-latex-util-pegjs\";\nimport * as XColorSpec from \"./types\";\n\nconst parseCache: Record = {};\n\n/**\n * Parse an `xparse` argument specification string to an AST.\n * This function caches results. Don't mutate the returned AST!\n *\n * @param {string} [str=\"\"] - LaTeX string input\n * @returns - AST for LaTeX string\n */\nexport function parse(str = \"\"): XColorSpec.Ast {\n parseCache[str] =\n parseCache[str] || (XColorPegParser.parse(str) as XColorSpec.Ast);\n return parseCache[str];\n}\n","import Color from \"color\";\nimport { DVI_PS_NAMES, SVG_NAMES, X11_NAMES } from \"./predefined-colors\";\nimport { XColor } from \"./types\";\nimport { parse as xcolorParser } from \"./parser\";\n\nconst CORE_MODELS = new Set([\"rgb\", \"cmy\", \"cmyk\", \"hsb\", \"gray\"]);\n\nexport const XColorCoreModelToColor = {\n rgb: ([r, g, b]: number[]) => Color([r * 255, g * 255, b * 255], \"rgb\"),\n cmy: ([c, m, y]: number[]) =>\n XColorCoreModelToColor.rgb([1 - c, 1 - m, 1 - y]),\n cmyk: ([c, m, y, k]: number[]) =>\n Color([c * 255, m * 255, y * 255, k * 100], \"cmyk\"),\n hsb: ([h, s, b]: number[]) => Color([h * 360, s * 100, b * 100], \"hsv\"),\n gray: ([v]: number[]) => Color([v * 255, v * 255, v * 255], \"rgb\"),\n};\nconst XColorModelToColor = {\n wave: ([lambda]: number[]) => {\n // Constants according to the xcolor readme\n const gamma = 0.8;\n let baseRgb = [0, 0, 0];\n if (380 <= lambda && lambda < 440) {\n baseRgb = [(440 - lambda) / (440 - 380), 0, 1];\n }\n if (440 <= lambda && lambda < 490) {\n baseRgb = [0, (lambda - 440) / (490 - 440), 1];\n }\n if (490 <= lambda && lambda < 510) {\n baseRgb = [0, 1, (510 - lambda) / (510 - 490)];\n }\n if (510 <= lambda && lambda < 580) {\n baseRgb = [(lambda - 510) / (580 - 510), 1, 0];\n }\n if (580 <= lambda && lambda < 6450) {\n baseRgb = [1, (645 - lambda) / (645 - 580), 0];\n }\n if (645 <= lambda && lambda <= 780) {\n baseRgb = [1, 0, 0];\n }\n let f = 1.0;\n if (380 <= lambda && 420 < lambda) {\n f = 0.3 + (0.7 * (lambda - 380)) / (420 - 380);\n }\n if (700 < lambda && lambda <= 780) {\n f = 0.3 + (0.7 * (780 - lambda)) / (780 - 700);\n }\n\n const rgb = [\n Math.pow(baseRgb[0] * f, gamma),\n Math.pow(baseRgb[1] * f, gamma),\n Math.pow(baseRgb[2] * f, gamma),\n ];\n\n return Color([rgb[0] * 255, rgb[1] * 255, rgb[2] * 255], \"rgb\");\n },\n Hsb: ([h, s, b]: number[]) => XColorCoreModelToColor.hsb([h / 360, s, b]),\n HSB: ([h, s, b]: number[]) =>\n XColorCoreModelToColor.hsb([h / 240, s / 240, b / 240]),\n HTML: ([v]: [string]) => (v.startsWith(\"#\") ? Color(v) : Color(`#${v}`)),\n RGB: ([r, g, b]: number[]) => Color([r, g, b], \"rgb\"),\n Gray: ([v]: number[]) => XColorCoreModelToColor.gray([v / 15]),\n ...XColorCoreModelToColor,\n};\n\nconst ColorToXColorModel = {\n rgb: (color: Color) =>\n color\n .rgb()\n .array()\n .map((v) => v / 255),\n cmy: (color: Color) =>\n [255 - color.red(), 255 - color.green(), 255 - color.blue()].map(\n (v) => v / 255\n ),\n cmyk: (color: Color) =>\n color\n .cmyk()\n .array()\n // The k component goes from 0-100\n .map((v, i) => (i === 3 ? v / 100 : v / 255)),\n hsb: (color: Color) => [\n color.hue() / 360,\n color.saturationv() / 100,\n color.value() / 100,\n ],\n gray: (color: Color) => [color.gray() / 100],\n};\n\nexport const PREDEFINED_XCOLOR_COLORS: Record> = {\n // Core colors\n red: XColorCoreModelToColor.rgb([1, 0, 0]),\n green: XColorCoreModelToColor.rgb([0, 1, 0]),\n blue: XColorCoreModelToColor.rgb([0, 0, 1]),\n brown: XColorCoreModelToColor.rgb([0.75, 0.5, 0.25]),\n lime: XColorCoreModelToColor.rgb([0.75, 1, 0]),\n orange: XColorCoreModelToColor.rgb([1, 0.5, 0]),\n pink: XColorCoreModelToColor.rgb([1, 0.75, 0.75]),\n purple: XColorCoreModelToColor.rgb([0.75, 0, 0.25]),\n teal: XColorCoreModelToColor.rgb([0, 0.5, 0.5]),\n violet: XColorCoreModelToColor.rgb([0.5, 0, 0.5]),\n cyan: XColorCoreModelToColor.rgb([0, 1, 1]),\n magenta: XColorCoreModelToColor.rgb([1, 0, 1]),\n yellow: XColorCoreModelToColor.rgb([1, 1, 0]),\n olive: XColorCoreModelToColor.rgb([0.5, 0.5, 0]),\n black: XColorCoreModelToColor.rgb([0, 0, 0]),\n darkgray: XColorCoreModelToColor.rgb([0.25, 0.25, 0.25]),\n gray: XColorCoreModelToColor.rgb([0.5, 0.5, 0.5]),\n lightgray: XColorCoreModelToColor.rgb([0.75, 0.75, 0.75]),\n white: XColorCoreModelToColor.rgb([1, 1, 1]),\n ...DVI_PS_NAMES,\n ...SVG_NAMES,\n ...X11_NAMES,\n};\n\nfunction scalarMul(scalar: number, vec: number[]) {\n return vec.map((v) => scalar * v);\n}\nfunction addVectors(...vecs: number[][]) {\n return vecs.reduce((prev, current) => prev.map((v, i) => v + current[i]));\n}\n\n/**\n * Mix a color in color model `model` as per the algorithm in 2.3.3 of the xcolor manual.\n */\nfunction mixInModel(\n model: string,\n colorsAndCoefficients: [number, Color][]\n): Color {\n if (!CORE_MODELS.has(model)) {\n throw new Error(\n `Cannot mix colors in model \"${model}\"; only core modes ${Array.from(\n CORE_MODELS\n ).join(\", \")} are supported`\n );\n }\n const toModel =\n ColorToXColorModel[model as keyof typeof ColorToXColorModel];\n const fromModel =\n XColorCoreModelToColor[model as keyof typeof XColorCoreModelToColor];\n\n const mixed = addVectors(\n ...colorsAndCoefficients.map(([v, color]) => {\n const colorInModel = toModel(color);\n return scalarMul(v, colorInModel);\n })\n );\n return fromModel(mixed);\n}\n\n/**\n * Given a parsed `XColor`, compute the color and return a `Color` object\n * (that can be used in CSS, for example).\n */\nexport function computeColor(\n expr: XColor,\n predefinedColors: Record> = {}\n): Color {\n if (expr.type !== \"color\") {\n throw new Error(\n `Can only compute the color of a \"color\" expression, not one of type ${expr.type}`\n );\n }\n\n const knownColors = { ...PREDEFINED_XCOLOR_COLORS, ...predefinedColors };\n function getColor(name: string) {\n if (!knownColors[name]) {\n throw new Error(`Unknown color \"${name}\"`);\n }\n return knownColors[name];\n }\n\n const color = expr.color;\n let computedColor = Color(\"#000000\");\n if (color.type === \"expr\") {\n // From the algorithm in 2.3.2 of the xcolor manual\n\n // TODO: the suffix `!![num]` is not yet implemented.\n let base = getColor(color.name);\n for (const mix of color.mix_expr) {\n if (mix.type === \"complete_mix\") {\n const mixColor = getColor(mix.name);\n base = base.mix(mixColor, 1 - mix.mix_percent / 100);\n } else if (mix.type === \"partial_mix\") {\n base = base.mix(Color(\"#FFFFFF\"), 1 - mix.mix_percent / 100);\n }\n }\n if (color.prefix && color.prefix.length % 2 === 1) {\n base = base.rotate(180);\n }\n computedColor = base;\n }\n if (color.type === \"extended_expr\") {\n const model = color.core_model;\n const div =\n color.div ||\n color.expressions.reduce((a, expr) => a + expr.weight, 0);\n if (div <= 0) {\n throw new Error(\n `Cannot mix color with ratios that have a denominator of ${div}`\n );\n }\n const colorsToMix: [number, Color][] = color.expressions.map(\n (expr) => [\n expr.weight / div,\n computeColor({\n type: \"color\",\n color: expr.color,\n functions: [],\n }),\n ]\n );\n computedColor = mixInModel(model, colorsToMix);\n }\n\n // Now we apply any color functions\n for (const func of expr.functions) {\n if (func.name === \"wheel\") {\n const angle = func.args[0];\n const circ = func.args[1] || 360;\n computedColor = computedColor.rotate((angle / circ) * 360);\n }\n if (func.name === \"twheel\") {\n // This function depends on the definition of \\rangetHsb, which we\n // don't actually know, so we just use it's default, which is to\n // add a 60 deg. angle to everything. I think...\n const angle = func.args[0];\n const circ = func.args[1] || 360;\n computedColor = computedColor.rotate((angle / circ) * 360 + 60);\n }\n }\n\n return computedColor;\n}\n\n/**\n * Convert the xcolor defined color to RGB Hex representation.\n * If the color is unknown or cannot be computed, `null` is returned.\n *\n * If `model` is supplied,\n *\n * The most likely reason a color will be `null` is if the color is defined\n * using a pre-defined color that wasn't supplied as an argument.\n */\nexport function xcolorColorToHex(\n color: string,\n model?: string | null,\n options: {\n predefinedColors?: Record>;\n } = { predefinedColors: {} }\n): string | null {\n const { predefinedColors = {} } = options;\n const parsed = xcolorParser(color);\n // If a model was entered, the corresponding color was directly entered without\n // mixing, unless the parsed type was \"color\". This would through an error in `xcolor`,\n // but we won't error.\n if (model && model !== \"default\" && parsed.type !== \"color\") {\n if (!(model in XColorModelToColor)) {\n throw new Error(\n `Unknown color model \"${model}\"; known models are ${Object.keys(\n XColorModelToColor\n ).join(\", \")}`\n );\n }\n if (parsed.type !== \"hex_spec\" && parsed.type !== \"num_spec\") {\n throw new Error(\n `Cannot use model ${model} to compute the color \"${color}\"`\n );\n }\n\n if (model === \"HTML\" && parsed.type === \"hex_spec\") {\n return XColorModelToColor.HTML(parsed.content).hex();\n } else if (parsed.type === \"num_spec\") {\n type x = keyof Omit;\n return XColorModelToColor[\n model as keyof Omit\n ](parsed.content).hex();\n }\n\n throw new Error(\n `Don't know how to process color \"${color}\" in model \"${model}\"`\n );\n }\n\n if (Array.isArray(parsed) || parsed.type !== \"color\") {\n throw new Error(\n `Cannot the color \"${color}\" is not a valid color string`\n );\n }\n let computed: Color | null = null;\n try {\n computed = computeColor(parsed, predefinedColors);\n } catch (e) {}\n\n return computed && computed.hex();\n}\n"],"names":["expr","xcolorParser"],"mappings":"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"} \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-prettier/README.md b/node_modules/@unified-latex/unified-latex-prettier/README.md new file mode 100644 index 0000000..983c8ea --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-prettier/README.md @@ -0,0 +1,24 @@ + + + + +# unified-latex-prettier + +## What is this? + +A [Prettier](https://prettier.io/) plugin for formatting and pretty-printing LaTeX source code. + +## When should I use this? + +If you want to construct a `Prettier` instance that has LaTeX parsing abilities. + +You should probably use the `prettier-plugin-latex` package instead of directly accessing this package. + +## Install + +```bash +npm install @unified-latex/unified-latex-prettier +``` + +This package contains both esm and commonjs exports. To explicitly access the esm export, +import the `.js` file. To explicitly access the commonjs export, import the `.cjs` file. diff --git a/node_modules/@unified-latex/unified-latex-prettier/index.cjs b/node_modules/@unified-latex/unified-latex-prettier/index.cjs new file mode 100644 index 0000000..4db1e6b --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-prettier/index.cjs @@ -0,0 +1,26424 @@ +"use strict"; +var __create = Object.create; +var __defProp = Object.defineProperty; +var __getOwnPropDesc = Object.getOwnPropertyDescriptor; +var __getOwnPropNames = Object.getOwnPropertyNames; +var __getProtoOf = Object.getPrototypeOf; +var __hasOwnProp = Object.prototype.hasOwnProperty; +var __commonJS = (cb, mod) => function __require() { + return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports; +}; +var __export = (target, all) => { + for (var name in all) + __defProp(target, name, { get: all[name], enumerable: true }); +}; +var __copyProps = (to, from, except, desc) => { + if (from && typeof from === "object" || typeof from === "function") { + for (let key of __getOwnPropNames(from)) + if (!__hasOwnProp.call(to, key) && key !== except) + __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable }); + } + return to; +}; +var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps( + // If the importer is in node compatibility mode or this is not an ESM + // file that has been converted to a CommonJS file using a Babel- + // compatible transform (i.e. "__esModule" has not been set), then set + // "default" to the CommonJS "module.exports" for node compatibility. + isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target, + mod +)); +var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod); +var __accessCheck = (obj, member, msg) => { + if (!member.has(obj)) + throw TypeError("Cannot " + msg); +}; +var __privateGet = (obj, member, getter) => { + __accessCheck(obj, member, "read from private field"); + return getter ? getter.call(obj) : member.get(obj); +}; +var __privateAdd = (obj, member, value) => { + if (member.has(obj)) + throw TypeError("Cannot add the same private member more than once"); + member instanceof WeakSet ? member.add(obj) : member.set(obj, value); +}; +var __privateSet = (obj, member, value, setter) => { + __accessCheck(obj, member, "write to private field"); + setter ? setter.call(obj, value) : member.set(obj, value); + return value; +}; + +// ../../node_modules/trie-prefix-tree/dist/config.js +var require_config = __commonJS({ + "../../node_modules/trie-prefix-tree/dist/config.js"(exports, module2) { + "use strict"; + Object.defineProperty(exports, "__esModule", { + value: true + }); + exports.default = { + END_WORD: "$", + END_WORD_REPLACER: "9a219a89-91cd-42e2-abd5-eb113af08ca8", + PERMS_MIN_LEN: 2 + }; + module2.exports = exports["default"]; + } +}); + +// ../../node_modules/trie-prefix-tree/dist/append.js +var require_append = __commonJS({ + "../../node_modules/trie-prefix-tree/dist/append.js"(exports, module2) { + "use strict"; + Object.defineProperty(exports, "__esModule", { + value: true + }); + exports.default = append; + var _config = require_config(); + var _config2 = _interopRequireDefault(_config); + function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : { default: obj }; + } + function append(trie, letter, index2, array) { + var isEndWordLetter = letter === _config2.default.END_WORD; + var isLastLetter = index2 === array.length - 1; + if (isEndWordLetter && !isLastLetter) { + trie[_config2.default.END_WORD] = 1; + trie[_config2.default.END_WORD_REPLACER] = {}; + trie = trie[_config2.default.END_WORD_REPLACER]; + } else { + trie[letter] = trie[letter] || {}; + trie = trie[letter]; + } + if (isLastLetter) { + trie[_config2.default.END_WORD] = 1; + } + return trie; + } + module2.exports = exports["default"]; + } +}); + +// ../../node_modules/trie-prefix-tree/dist/create.js +var require_create = __commonJS({ + "../../node_modules/trie-prefix-tree/dist/create.js"(exports, module2) { + "use strict"; + Object.defineProperty(exports, "__esModule", { + value: true + }); + var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function(obj) { + return typeof obj; + } : function(obj) { + return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; + }; + exports.default = create; + var _append = require_append(); + var _append2 = _interopRequireDefault(_append); + function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : { default: obj }; + } + function create(input) { + if (!Array.isArray(input)) { + throw "Expected parameter Array, received " + (typeof input === "undefined" ? "undefined" : _typeof(input)); + } + var trie = input.reduce(function(accumulator, item) { + item.toLowerCase().split("").reduce(_append2.default, accumulator); + return accumulator; + }, {}); + return trie; + } + module2.exports = exports["default"]; + } +}); + +// ../../node_modules/trie-prefix-tree/dist/utils.js +var require_utils = __commonJS({ + "../../node_modules/trie-prefix-tree/dist/utils.js"(exports, module2) { + "use strict"; + Object.defineProperty(exports, "__esModule", { + value: true + }); + exports.default = { + objectCopy: function objectCopy(obj) { + if (typeof obj === "undefined") { + return {}; + } + return JSON.parse(JSON.stringify(obj)); + }, + stringify: function stringify(obj) { + var spacer = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : 2; + if (typeof obj === "undefined") { + return ""; + } + return JSON.stringify(obj, null, spacer); + } + }; + module2.exports = exports["default"]; + } +}); + +// ../../node_modules/trie-prefix-tree/dist/checkPrefix.js +var require_checkPrefix = __commonJS({ + "../../node_modules/trie-prefix-tree/dist/checkPrefix.js"(exports, module2) { + "use strict"; + Object.defineProperty(exports, "__esModule", { + value: true + }); + exports.default = checkPrefix; + var _utils = require_utils(); + var _utils2 = _interopRequireDefault(_utils); + function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : { default: obj }; + } + function checkPrefix(prefixNode, prefix) { + var input = prefix.toLowerCase().split(""); + var prefixFound = input.every(function(letter, index2) { + if (!prefixNode[letter]) { + return false; + } + return prefixNode = prefixNode[letter]; + }); + return { + prefixFound, + prefixNode + }; + } + module2.exports = exports["default"]; + } +}); + +// ../../node_modules/trie-prefix-tree/dist/recursePrefix.js +var require_recursePrefix = __commonJS({ + "../../node_modules/trie-prefix-tree/dist/recursePrefix.js"(exports, module2) { + "use strict"; + Object.defineProperty(exports, "__esModule", { + value: true + }); + exports.default = recursePrefix; + var _config = require_config(); + var _config2 = _interopRequireDefault(_config); + function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : { default: obj }; + } + var pushInOrder = function pushInOrder2(word, prefixes) { + var i = 0; + while (i < prefixes.length) { + if (word < prefixes[i]) { + break; + } + i += 1; + } + prefixes.splice(i, 0, word); + return prefixes; + }; + function recursePrefix(node, prefix, sorted) { + var prefixes = arguments.length > 3 && arguments[3] !== void 0 ? arguments[3] : []; + var word = prefix; + for (var branch in node) { + var currentLetter = branch; + if (branch === _config2.default.END_WORD && typeof node[branch] === "number") { + if (sorted) { + pushInOrder(word, prefixes); + } else { + prefixes.push(word); + } + word = ""; + } else if (branch === _config2.default.END_WORD_REPLACER) { + currentLetter = _config2.default.END_WORD; + } + recursePrefix(node[branch], prefix + currentLetter, sorted, prefixes); + } + return prefixes; + } + module2.exports = exports["default"]; + } +}); + +// ../../node_modules/trie-prefix-tree/dist/recurseRandomWord.js +var require_recurseRandomWord = __commonJS({ + "../../node_modules/trie-prefix-tree/dist/recurseRandomWord.js"(exports, module2) { + "use strict"; + Object.defineProperty(exports, "__esModule", { + value: true + }); + exports.default = recurseRandomWord; + var _config = require_config(); + var _config2 = _interopRequireDefault(_config); + function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : { default: obj }; + } + function recurseRandomWord(node, prefix) { + var word = prefix; + var branches = Object.keys(node); + var branch = branches[Math.floor(Math.random() * branches.length)]; + if (branch === _config2.default.END_WORD) { + return word; + } + return recurseRandomWord(node[branch], prefix + branch); + } + module2.exports = exports["default"]; + } +}); + +// ../../node_modules/trie-prefix-tree/dist/permutations.js +var require_permutations = __commonJS({ + "../../node_modules/trie-prefix-tree/dist/permutations.js"(exports, module2) { + "use strict"; + Object.defineProperty(exports, "__esModule", { + value: true + }); + var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function(obj) { + return typeof obj; + } : function(obj) { + return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; + }; + exports.default = permutations; + var _config = require_config(); + var _config2 = _interopRequireDefault(_config); + function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : { default: obj }; + } + function permutations(letters, trie) { + var opts = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : { + type: "anagram" + }; + if (typeof letters !== "string") { + throw "Permutations expects string letters, received " + (typeof letters === "undefined" ? "undefined" : _typeof(letters)); + } + var words = []; + var permute = function permute2(word, node) { + var prefix = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : ""; + var wordIsEmpty = word.length === 0; + var wordFound = words.indexOf(prefix) !== -1; + var endWordFound = node[_config2.default.END_WORD] === 1; + if (wordIsEmpty && endWordFound && !wordFound) { + words.push(prefix); + } + for (var i = 0, len = word.length; i < len; i++) { + var letter = word[i]; + if (opts.type === "sub-anagram") { + if (endWordFound && !(words.indexOf(prefix) !== -1)) { + words.push(prefix); + } + } + if (node[letter]) { + var remaining = word.substring(0, i) + word.substring(i + 1, len); + permute2(remaining, node[letter], prefix + letter, words); + } + } + return words.sort(); + }; + return permute(letters, trie); + } + module2.exports = exports["default"]; + } +}); + +// ../../node_modules/trie-prefix-tree/dist/index.js +var require_dist = __commonJS({ + "../../node_modules/trie-prefix-tree/dist/index.js"(exports, module2) { + "use strict"; + Object.defineProperty(exports, "__esModule", { + value: true + }); + var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function(obj) { + return typeof obj; + } : function(obj) { + return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; + }; + exports.default = function(input) { + if (!Array.isArray(input)) { + throw "Expected parameter Array, received " + (typeof input === "undefined" ? "undefined" : _typeof(input)); + } + var trie = (0, _create2.default)([].concat(_toConsumableArray(input))); + return { + /** + * Get the generated raw trie object + */ + tree: function tree() { + return trie; + }, + /** + * Get a string representation of the trie + */ + dump: function dump() { + var spacer = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : 0; + return _utils2.default.stringify(trie, spacer); + }, + /** + * Add a new word to the trie + */ + addWord: function addWord(word) { + if (typeof word !== "string" || word === "") { + throw "Expected parameter string, received " + (typeof word === "undefined" ? "undefined" : _typeof(word)); + } + var reducer = function reducer2() { + return _append2.default.apply(void 0, arguments); + }; + var input2 = word.toLowerCase().split(""); + input2.reduce(reducer, trie); + return this; + }, + /** + * Remove an existing word from the trie + */ + removeWord: function removeWord(word) { + if (typeof word !== "string" || word === "") { + throw "Expected parameter string, received " + (typeof word === "undefined" ? "undefined" : _typeof(word)); + } + var _checkPrefix = (0, _checkPrefix6.default)(trie, word), prefixFound = _checkPrefix.prefixFound, prefixNode = _checkPrefix.prefixNode; + if (prefixFound) { + delete prefixNode[_config2.default.END_WORD]; + } + return this; + }, + /** + * Check a prefix is valid + * @returns Boolean + */ + isPrefix: function isPrefix(prefix) { + if (typeof prefix !== "string") { + throw "Expected string prefix, received " + (typeof prefix === "undefined" ? "undefined" : _typeof(prefix)); + } + var _checkPrefix2 = (0, _checkPrefix6.default)(trie, prefix), prefixFound = _checkPrefix2.prefixFound; + return prefixFound; + }, + /** + * Get a list of all words in the trie with the given prefix + * @returns Array + */ + getPrefix: function getPrefix(strPrefix) { + var sorted = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : true; + if (typeof strPrefix !== "string") { + throw "Expected string prefix, received " + (typeof strPrefix === "undefined" ? "undefined" : _typeof(strPrefix)); + } + if (typeof sorted !== "boolean") { + throw "Expected sort parameter as boolean, received " + (typeof sorted === "undefined" ? "undefined" : _typeof(sorted)); + } + if (!this.isPrefix(strPrefix)) { + return []; + } + var prefixNode = strPrefix.length ? (0, _checkPrefix6.default)(trie, strPrefix).prefixNode : trie; + return (0, _recursePrefix2.default)(prefixNode, strPrefix, sorted); + }, + /** + * Get a random word in the trie with the given prefix + * @returns Array + */ + getRandomWordWithPrefix: function getRandomWordWithPrefix(strPrefix) { + if (typeof strPrefix !== "string") { + throw "Expected string prefix, received " + (typeof strPrefix === "undefined" ? "undefined" : _typeof(strPrefix)); + } + if (!this.isPrefix(strPrefix)) { + return ""; + } + var _checkPrefix3 = (0, _checkPrefix6.default)(trie, strPrefix), prefixNode = _checkPrefix3.prefixNode; + return (0, _recurseRandomWord2.default)(prefixNode, strPrefix); + }, + /** + * Count the number of words with the given prefixSearch + * @returns Number + */ + countPrefix: function countPrefix(strPrefix) { + var prefixes = this.getPrefix(strPrefix); + return prefixes.length; + }, + /** + * Get all words in the trie + * @returns Array + */ + getWords: function getWords() { + var sorted = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : true; + return this.getPrefix("", sorted); + }, + /** + * Check the existence of a word in the trie + * @returns Boolean + */ + hasWord: function hasWord(word) { + if (typeof word !== "string") { + throw "Expected string word, received " + (typeof word === "undefined" ? "undefined" : _typeof(word)); + } + var _checkPrefix4 = (0, _checkPrefix6.default)(trie, word), prefixFound = _checkPrefix4.prefixFound, prefixNode = _checkPrefix4.prefixNode; + if (prefixFound) { + return prefixNode[_config2.default.END_WORD] === 1; + } + return false; + }, + /** + * Get a list of valid anagrams that can be made from the given letters + * @returns Array + */ + getAnagrams: function getAnagrams(letters) { + if (typeof letters !== "string") { + throw "Anagrams expected string letters, received " + (typeof letters === "undefined" ? "undefined" : _typeof(letters)); + } + if (letters.length < PERMS_MIN_LEN) { + throw "getAnagrams expects at least " + PERMS_MIN_LEN + " letters"; + } + return (0, _permutations2.default)(letters, trie, { + type: "anagram" + }); + }, + /** + * Get a list of all sub-anagrams that can be made from the given letters + * @returns Array + */ + getSubAnagrams: function getSubAnagrams(letters) { + if (typeof letters !== "string") { + throw "Expected string letters, received " + (typeof letters === "undefined" ? "undefined" : _typeof(letters)); + } + if (letters.length < PERMS_MIN_LEN) { + throw "getSubAnagrams expects at least " + PERMS_MIN_LEN + " letters"; + } + return (0, _permutations2.default)(letters, trie, { + type: "sub-anagram" + }); + } + }; + }; + var _create = require_create(); + var _create2 = _interopRequireDefault(_create); + var _append = require_append(); + var _append2 = _interopRequireDefault(_append); + var _checkPrefix5 = require_checkPrefix(); + var _checkPrefix6 = _interopRequireDefault(_checkPrefix5); + var _recursePrefix = require_recursePrefix(); + var _recursePrefix2 = _interopRequireDefault(_recursePrefix); + var _recurseRandomWord = require_recurseRandomWord(); + var _recurseRandomWord2 = _interopRequireDefault(_recurseRandomWord); + var _utils = require_utils(); + var _utils2 = _interopRequireDefault(_utils); + var _config = require_config(); + var _config2 = _interopRequireDefault(_config); + var _permutations = require_permutations(); + var _permutations2 = _interopRequireDefault(_permutations); + function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : { default: obj }; + } + function _toConsumableArray(arr) { + if (Array.isArray(arr)) { + for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { + arr2[i] = arr[i]; + } + return arr2; + } else { + return Array.from(arr); + } + } + var PERMS_MIN_LEN = _config2.default.PERMS_MIN_LEN; + module2.exports = exports["default"]; + } +}); + +// ../../node_modules/is-buffer/index.js +var require_is_buffer = __commonJS({ + "../../node_modules/is-buffer/index.js"(exports, module2) { + module2.exports = function isBuffer2(obj) { + return obj != null && obj.constructor != null && typeof obj.constructor.isBuffer === "function" && obj.constructor.isBuffer(obj); + }; + } +}); + +// ../../node_modules/extend/index.js +var require_extend = __commonJS({ + "../../node_modules/extend/index.js"(exports, module2) { + "use strict"; + var hasOwn = Object.prototype.hasOwnProperty; + var toStr = Object.prototype.toString; + var defineProperty = Object.defineProperty; + var gOPD = Object.getOwnPropertyDescriptor; + var isArray = function isArray2(arr) { + if (typeof Array.isArray === "function") { + return Array.isArray(arr); + } + return toStr.call(arr) === "[object Array]"; + }; + var isPlainObject2 = function isPlainObject3(obj) { + if (!obj || toStr.call(obj) !== "[object Object]") { + return false; + } + var hasOwnConstructor = hasOwn.call(obj, "constructor"); + var hasIsPrototypeOf = obj.constructor && obj.constructor.prototype && hasOwn.call(obj.constructor.prototype, "isPrototypeOf"); + if (obj.constructor && !hasOwnConstructor && !hasIsPrototypeOf) { + return false; + } + var key; + for (key in obj) { + } + return typeof key === "undefined" || hasOwn.call(obj, key); + }; + var setProperty = function setProperty2(target, options) { + if (defineProperty && options.name === "__proto__") { + defineProperty(target, options.name, { + enumerable: true, + configurable: true, + value: options.newValue, + writable: true + }); + } else { + target[options.name] = options.newValue; + } + }; + var getProperty = function getProperty2(obj, name) { + if (name === "__proto__") { + if (!hasOwn.call(obj, name)) { + return void 0; + } else if (gOPD) { + return gOPD(obj, name).value; + } + } + return obj[name]; + }; + module2.exports = function extend2() { + var options, name, src, copy, copyIsArray, clone2; + var target = arguments[0]; + var i = 1; + var length = arguments.length; + var deep = false; + if (typeof target === "boolean") { + deep = target; + target = arguments[1] || {}; + i = 2; + } + if (target == null || typeof target !== "object" && typeof target !== "function") { + target = {}; + } + for (; i < length; ++i) { + options = arguments[i]; + if (options != null) { + for (name in options) { + src = getProperty(target, name); + copy = getProperty(options, name); + if (target !== copy) { + if (deep && copy && (isPlainObject2(copy) || (copyIsArray = isArray(copy)))) { + if (copyIsArray) { + copyIsArray = false; + clone2 = src && isArray(src) ? src : []; + } else { + clone2 = src && isPlainObject2(src) ? src : {}; + } + setProperty(target, { name, newValue: extend2(deep, clone2, copy) }); + } else if (typeof copy !== "undefined") { + setProperty(target, { name, newValue: copy }); + } + } + } + } + } + return target; + }; + } +}); + +// ../../node_modules/color-name/index.js +var require_color_name = __commonJS({ + "../../node_modules/color-name/index.js"(exports, module2) { + "use strict"; + module2.exports = { + "aliceblue": [240, 248, 255], + "antiquewhite": [250, 235, 215], + "aqua": [0, 255, 255], + "aquamarine": [127, 255, 212], + "azure": [240, 255, 255], + "beige": [245, 245, 220], + "bisque": [255, 228, 196], + "black": [0, 0, 0], + "blanchedalmond": [255, 235, 205], + "blue": [0, 0, 255], + "blueviolet": [138, 43, 226], + "brown": [165, 42, 42], + "burlywood": [222, 184, 135], + "cadetblue": [95, 158, 160], + "chartreuse": [127, 255, 0], + "chocolate": [210, 105, 30], + "coral": [255, 127, 80], + "cornflowerblue": [100, 149, 237], + "cornsilk": [255, 248, 220], + "crimson": [220, 20, 60], + "cyan": [0, 255, 255], + "darkblue": [0, 0, 139], + "darkcyan": [0, 139, 139], + "darkgoldenrod": [184, 134, 11], + "darkgray": [169, 169, 169], + "darkgreen": [0, 100, 0], + "darkgrey": [169, 169, 169], + "darkkhaki": [189, 183, 107], + "darkmagenta": [139, 0, 139], + "darkolivegreen": [85, 107, 47], + "darkorange": [255, 140, 0], + "darkorchid": [153, 50, 204], + "darkred": [139, 0, 0], + "darksalmon": [233, 150, 122], + "darkseagreen": [143, 188, 143], + "darkslateblue": [72, 61, 139], + "darkslategray": [47, 79, 79], + "darkslategrey": [47, 79, 79], + "darkturquoise": [0, 206, 209], + "darkviolet": [148, 0, 211], + "deeppink": [255, 20, 147], + "deepskyblue": [0, 191, 255], + "dimgray": [105, 105, 105], + "dimgrey": [105, 105, 105], + "dodgerblue": [30, 144, 255], + "firebrick": [178, 34, 34], + "floralwhite": [255, 250, 240], + "forestgreen": [34, 139, 34], + "fuchsia": [255, 0, 255], + "gainsboro": [220, 220, 220], + "ghostwhite": [248, 248, 255], + "gold": [255, 215, 0], + "goldenrod": [218, 165, 32], + "gray": [128, 128, 128], + "green": [0, 128, 0], + "greenyellow": [173, 255, 47], + "grey": [128, 128, 128], + "honeydew": [240, 255, 240], + "hotpink": [255, 105, 180], + "indianred": [205, 92, 92], + "indigo": [75, 0, 130], + "ivory": [255, 255, 240], + "khaki": [240, 230, 140], + "lavender": [230, 230, 250], + "lavenderblush": [255, 240, 245], + "lawngreen": [124, 252, 0], + "lemonchiffon": [255, 250, 205], + "lightblue": [173, 216, 230], + "lightcoral": [240, 128, 128], + "lightcyan": [224, 255, 255], + "lightgoldenrodyellow": [250, 250, 210], + "lightgray": [211, 211, 211], + "lightgreen": [144, 238, 144], + "lightgrey": [211, 211, 211], + "lightpink": [255, 182, 193], + "lightsalmon": [255, 160, 122], + "lightseagreen": [32, 178, 170], + "lightskyblue": [135, 206, 250], + "lightslategray": [119, 136, 153], + "lightslategrey": [119, 136, 153], + "lightsteelblue": [176, 196, 222], + "lightyellow": [255, 255, 224], + "lime": [0, 255, 0], + "limegreen": [50, 205, 50], + "linen": [250, 240, 230], + "magenta": [255, 0, 255], + "maroon": [128, 0, 0], + "mediumaquamarine": [102, 205, 170], + "mediumblue": [0, 0, 205], + "mediumorchid": [186, 85, 211], + "mediumpurple": [147, 112, 219], + "mediumseagreen": [60, 179, 113], + "mediumslateblue": [123, 104, 238], + "mediumspringgreen": [0, 250, 154], + "mediumturquoise": [72, 209, 204], + "mediumvioletred": [199, 21, 133], + "midnightblue": [25, 25, 112], + "mintcream": [245, 255, 250], + "mistyrose": [255, 228, 225], + "moccasin": [255, 228, 181], + "navajowhite": [255, 222, 173], + "navy": [0, 0, 128], + "oldlace": [253, 245, 230], + "olive": [128, 128, 0], + "olivedrab": [107, 142, 35], + "orange": [255, 165, 0], + "orangered": [255, 69, 0], + "orchid": [218, 112, 214], + "palegoldenrod": [238, 232, 170], + "palegreen": [152, 251, 152], + "paleturquoise": [175, 238, 238], + "palevioletred": [219, 112, 147], + "papayawhip": [255, 239, 213], + "peachpuff": [255, 218, 185], + "peru": [205, 133, 63], + "pink": [255, 192, 203], + "plum": [221, 160, 221], + "powderblue": [176, 224, 230], + "purple": [128, 0, 128], + "rebeccapurple": [102, 51, 153], + "red": [255, 0, 0], + "rosybrown": [188, 143, 143], + "royalblue": [65, 105, 225], + "saddlebrown": [139, 69, 19], + "salmon": [250, 128, 114], + "sandybrown": [244, 164, 96], + "seagreen": [46, 139, 87], + "seashell": [255, 245, 238], + "sienna": [160, 82, 45], + "silver": [192, 192, 192], + "skyblue": [135, 206, 235], + "slateblue": [106, 90, 205], + "slategray": [112, 128, 144], + "slategrey": [112, 128, 144], + "snow": [255, 250, 250], + "springgreen": [0, 255, 127], + "steelblue": [70, 130, 180], + "tan": [210, 180, 140], + "teal": [0, 128, 128], + "thistle": [216, 191, 216], + "tomato": [255, 99, 71], + "turquoise": [64, 224, 208], + "violet": [238, 130, 238], + "wheat": [245, 222, 179], + "white": [255, 255, 255], + "whitesmoke": [245, 245, 245], + "yellow": [255, 255, 0], + "yellowgreen": [154, 205, 50] + }; + } +}); + +// ../../node_modules/simple-swizzle/node_modules/is-arrayish/index.js +var require_is_arrayish = __commonJS({ + "../../node_modules/simple-swizzle/node_modules/is-arrayish/index.js"(exports, module2) { + module2.exports = function isArrayish(obj) { + if (!obj || typeof obj === "string") { + return false; + } + return obj instanceof Array || Array.isArray(obj) || obj.length >= 0 && (obj.splice instanceof Function || Object.getOwnPropertyDescriptor(obj, obj.length - 1) && obj.constructor.name !== "String"); + }; + } +}); + +// ../../node_modules/simple-swizzle/index.js +var require_simple_swizzle = __commonJS({ + "../../node_modules/simple-swizzle/index.js"(exports, module2) { + "use strict"; + var isArrayish = require_is_arrayish(); + var concat = Array.prototype.concat; + var slice = Array.prototype.slice; + var swizzle = module2.exports = function swizzle2(args) { + var results = []; + for (var i = 0, len = args.length; i < len; i++) { + var arg2 = args[i]; + if (isArrayish(arg2)) { + results = concat.call(results, slice.call(arg2)); + } else { + results.push(arg2); + } + } + return results; + }; + swizzle.wrap = function(fn) { + return function() { + return fn(swizzle(arguments)); + }; + }; + } +}); + +// ../../node_modules/color-string/index.js +var require_color_string = __commonJS({ + "../../node_modules/color-string/index.js"(exports, module2) { + var colorNames = require_color_name(); + var swizzle = require_simple_swizzle(); + var hasOwnProperty = Object.hasOwnProperty; + var reverseNames = /* @__PURE__ */ Object.create(null); + for (name in colorNames) { + if (hasOwnProperty.call(colorNames, name)) { + reverseNames[colorNames[name]] = name; + } + } + var name; + var cs = module2.exports = { + to: {}, + get: {} + }; + cs.get = function(string2) { + var prefix = string2.substring(0, 3).toLowerCase(); + var val; + var model; + switch (prefix) { + case "hsl": + val = cs.get.hsl(string2); + model = "hsl"; + break; + case "hwb": + val = cs.get.hwb(string2); + model = "hwb"; + break; + default: + val = cs.get.rgb(string2); + model = "rgb"; + break; + } + if (!val) { + return null; + } + return { model, value: val }; + }; + cs.get.rgb = function(string2) { + if (!string2) { + return null; + } + var abbr = /^#([a-f0-9]{3,4})$/i; + var hex = /^#([a-f0-9]{6})([a-f0-9]{2})?$/i; + var rgba = /^rgba?\(\s*([+-]?\d+)(?=[\s,])\s*(?:,\s*)?([+-]?\d+)(?=[\s,])\s*(?:,\s*)?([+-]?\d+)\s*(?:[,|\/]\s*([+-]?[\d\.]+)(%?)\s*)?\)$/; + var per = /^rgba?\(\s*([+-]?[\d\.]+)\%\s*,?\s*([+-]?[\d\.]+)\%\s*,?\s*([+-]?[\d\.]+)\%\s*(?:[,|\/]\s*([+-]?[\d\.]+)(%?)\s*)?\)$/; + var keyword = /^(\w+)$/; + var rgb = [0, 0, 0, 1]; + var match2; + var i; + var hexAlpha; + if (match2 = string2.match(hex)) { + hexAlpha = match2[2]; + match2 = match2[1]; + for (i = 0; i < 3; i++) { + var i2 = i * 2; + rgb[i] = parseInt(match2.slice(i2, i2 + 2), 16); + } + if (hexAlpha) { + rgb[3] = parseInt(hexAlpha, 16) / 255; + } + } else if (match2 = string2.match(abbr)) { + match2 = match2[1]; + hexAlpha = match2[3]; + for (i = 0; i < 3; i++) { + rgb[i] = parseInt(match2[i] + match2[i], 16); + } + if (hexAlpha) { + rgb[3] = parseInt(hexAlpha + hexAlpha, 16) / 255; + } + } else if (match2 = string2.match(rgba)) { + for (i = 0; i < 3; i++) { + rgb[i] = parseInt(match2[i + 1], 0); + } + if (match2[4]) { + if (match2[5]) { + rgb[3] = parseFloat(match2[4]) * 0.01; + } else { + rgb[3] = parseFloat(match2[4]); + } + } + } else if (match2 = string2.match(per)) { + for (i = 0; i < 3; i++) { + rgb[i] = Math.round(parseFloat(match2[i + 1]) * 2.55); + } + if (match2[4]) { + if (match2[5]) { + rgb[3] = parseFloat(match2[4]) * 0.01; + } else { + rgb[3] = parseFloat(match2[4]); + } + } + } else if (match2 = string2.match(keyword)) { + if (match2[1] === "transparent") { + return [0, 0, 0, 0]; + } + if (!hasOwnProperty.call(colorNames, match2[1])) { + return null; + } + rgb = colorNames[match2[1]]; + rgb[3] = 1; + return rgb; + } else { + return null; + } + for (i = 0; i < 3; i++) { + rgb[i] = clamp(rgb[i], 0, 255); + } + rgb[3] = clamp(rgb[3], 0, 1); + return rgb; + }; + cs.get.hsl = function(string2) { + if (!string2) { + return null; + } + var hsl = /^hsla?\(\s*([+-]?(?:\d{0,3}\.)?\d+)(?:deg)?\s*,?\s*([+-]?[\d\.]+)%\s*,?\s*([+-]?[\d\.]+)%\s*(?:[,|\/]\s*([+-]?(?=\.\d|\d)(?:0|[1-9]\d*)?(?:\.\d*)?(?:[eE][+-]?\d+)?)\s*)?\)$/; + var match2 = string2.match(hsl); + if (match2) { + var alpha = parseFloat(match2[4]); + var h = (parseFloat(match2[1]) % 360 + 360) % 360; + var s2 = clamp(parseFloat(match2[2]), 0, 100); + var l = clamp(parseFloat(match2[3]), 0, 100); + var a = clamp(isNaN(alpha) ? 1 : alpha, 0, 1); + return [h, s2, l, a]; + } + return null; + }; + cs.get.hwb = function(string2) { + if (!string2) { + return null; + } + var hwb = /^hwb\(\s*([+-]?\d{0,3}(?:\.\d+)?)(?:deg)?\s*,\s*([+-]?[\d\.]+)%\s*,\s*([+-]?[\d\.]+)%\s*(?:,\s*([+-]?(?=\.\d|\d)(?:0|[1-9]\d*)?(?:\.\d*)?(?:[eE][+-]?\d+)?)\s*)?\)$/; + var match2 = string2.match(hwb); + if (match2) { + var alpha = parseFloat(match2[4]); + var h = (parseFloat(match2[1]) % 360 + 360) % 360; + var w = clamp(parseFloat(match2[2]), 0, 100); + var b = clamp(parseFloat(match2[3]), 0, 100); + var a = clamp(isNaN(alpha) ? 1 : alpha, 0, 1); + return [h, w, b, a]; + } + return null; + }; + cs.to.hex = function() { + var rgba = swizzle(arguments); + return "#" + hexDouble(rgba[0]) + hexDouble(rgba[1]) + hexDouble(rgba[2]) + (rgba[3] < 1 ? hexDouble(Math.round(rgba[3] * 255)) : ""); + }; + cs.to.rgb = function() { + var rgba = swizzle(arguments); + return rgba.length < 4 || rgba[3] === 1 ? "rgb(" + Math.round(rgba[0]) + ", " + Math.round(rgba[1]) + ", " + Math.round(rgba[2]) + ")" : "rgba(" + Math.round(rgba[0]) + ", " + Math.round(rgba[1]) + ", " + Math.round(rgba[2]) + ", " + rgba[3] + ")"; + }; + cs.to.rgb.percent = function() { + var rgba = swizzle(arguments); + var r = Math.round(rgba[0] / 255 * 100); + var g = Math.round(rgba[1] / 255 * 100); + var b = Math.round(rgba[2] / 255 * 100); + return rgba.length < 4 || rgba[3] === 1 ? "rgb(" + r + "%, " + g + "%, " + b + "%)" : "rgba(" + r + "%, " + g + "%, " + b + "%, " + rgba[3] + ")"; + }; + cs.to.hsl = function() { + var hsla = swizzle(arguments); + return hsla.length < 4 || hsla[3] === 1 ? "hsl(" + hsla[0] + ", " + hsla[1] + "%, " + hsla[2] + "%)" : "hsla(" + hsla[0] + ", " + hsla[1] + "%, " + hsla[2] + "%, " + hsla[3] + ")"; + }; + cs.to.hwb = function() { + var hwba = swizzle(arguments); + var a = ""; + if (hwba.length >= 4 && hwba[3] !== 1) { + a = ", " + hwba[3]; + } + return "hwb(" + hwba[0] + ", " + hwba[1] + "%, " + hwba[2] + "%" + a + ")"; + }; + cs.to.keyword = function(rgb) { + return reverseNames[rgb.slice(0, 3)]; + }; + function clamp(num, min, max) { + return Math.min(Math.max(min, num), max); + } + function hexDouble(num) { + var str = Math.round(num).toString(16).toUpperCase(); + return str.length < 2 ? "0" + str : str; + } + } +}); + +// ../../node_modules/color-convert/conversions.js +var require_conversions = __commonJS({ + "../../node_modules/color-convert/conversions.js"(exports, module2) { + var cssKeywords = require_color_name(); + var reverseKeywords = {}; + for (const key of Object.keys(cssKeywords)) { + reverseKeywords[cssKeywords[key]] = key; + } + var convert = { + rgb: { channels: 3, labels: "rgb" }, + hsl: { channels: 3, labels: "hsl" }, + hsv: { channels: 3, labels: "hsv" }, + hwb: { channels: 3, labels: "hwb" }, + cmyk: { channels: 4, labels: "cmyk" }, + xyz: { channels: 3, labels: "xyz" }, + lab: { channels: 3, labels: "lab" }, + lch: { channels: 3, labels: "lch" }, + hex: { channels: 1, labels: ["hex"] }, + keyword: { channels: 1, labels: ["keyword"] }, + ansi16: { channels: 1, labels: ["ansi16"] }, + ansi256: { channels: 1, labels: ["ansi256"] }, + hcg: { channels: 3, labels: ["h", "c", "g"] }, + apple: { channels: 3, labels: ["r16", "g16", "b16"] }, + gray: { channels: 1, labels: ["gray"] } + }; + module2.exports = convert; + for (const model of Object.keys(convert)) { + if (!("channels" in convert[model])) { + throw new Error("missing channels property: " + model); + } + if (!("labels" in convert[model])) { + throw new Error("missing channel labels property: " + model); + } + if (convert[model].labels.length !== convert[model].channels) { + throw new Error("channel and label counts mismatch: " + model); + } + const { channels, labels } = convert[model]; + delete convert[model].channels; + delete convert[model].labels; + Object.defineProperty(convert[model], "channels", { value: channels }); + Object.defineProperty(convert[model], "labels", { value: labels }); + } + convert.rgb.hsl = function(rgb) { + const r = rgb[0] / 255; + const g = rgb[1] / 255; + const b = rgb[2] / 255; + const min = Math.min(r, g, b); + const max = Math.max(r, g, b); + const delta = max - min; + let h; + let s2; + if (max === min) { + h = 0; + } else if (r === max) { + h = (g - b) / delta; + } else if (g === max) { + h = 2 + (b - r) / delta; + } else if (b === max) { + h = 4 + (r - g) / delta; + } + h = Math.min(h * 60, 360); + if (h < 0) { + h += 360; + } + const l = (min + max) / 2; + if (max === min) { + s2 = 0; + } else if (l <= 0.5) { + s2 = delta / (max + min); + } else { + s2 = delta / (2 - max - min); + } + return [h, s2 * 100, l * 100]; + }; + convert.rgb.hsv = function(rgb) { + let rdif; + let gdif; + let bdif; + let h; + let s2; + const r = rgb[0] / 255; + const g = rgb[1] / 255; + const b = rgb[2] / 255; + const v = Math.max(r, g, b); + const diff = v - Math.min(r, g, b); + const diffc = function(c) { + return (v - c) / 6 / diff + 1 / 2; + }; + if (diff === 0) { + h = 0; + s2 = 0; + } else { + s2 = diff / v; + rdif = diffc(r); + gdif = diffc(g); + bdif = diffc(b); + if (r === v) { + h = bdif - gdif; + } else if (g === v) { + h = 1 / 3 + rdif - bdif; + } else if (b === v) { + h = 2 / 3 + gdif - rdif; + } + if (h < 0) { + h += 1; + } else if (h > 1) { + h -= 1; + } + } + return [ + h * 360, + s2 * 100, + v * 100 + ]; + }; + convert.rgb.hwb = function(rgb) { + const r = rgb[0]; + const g = rgb[1]; + let b = rgb[2]; + const h = convert.rgb.hsl(rgb)[0]; + const w = 1 / 255 * Math.min(r, Math.min(g, b)); + b = 1 - 1 / 255 * Math.max(r, Math.max(g, b)); + return [h, w * 100, b * 100]; + }; + convert.rgb.cmyk = function(rgb) { + const r = rgb[0] / 255; + const g = rgb[1] / 255; + const b = rgb[2] / 255; + const k = Math.min(1 - r, 1 - g, 1 - b); + const c = (1 - r - k) / (1 - k) || 0; + const m = (1 - g - k) / (1 - k) || 0; + const y = (1 - b - k) / (1 - k) || 0; + return [c * 100, m * 100, y * 100, k * 100]; + }; + function comparativeDistance(x, y) { + return (x[0] - y[0]) ** 2 + (x[1] - y[1]) ** 2 + (x[2] - y[2]) ** 2; + } + convert.rgb.keyword = function(rgb) { + const reversed = reverseKeywords[rgb]; + if (reversed) { + return reversed; + } + let currentClosestDistance = Infinity; + let currentClosestKeyword; + for (const keyword of Object.keys(cssKeywords)) { + const value = cssKeywords[keyword]; + const distance = comparativeDistance(rgb, value); + if (distance < currentClosestDistance) { + currentClosestDistance = distance; + currentClosestKeyword = keyword; + } + } + return currentClosestKeyword; + }; + convert.keyword.rgb = function(keyword) { + return cssKeywords[keyword]; + }; + convert.rgb.xyz = function(rgb) { + let r = rgb[0] / 255; + let g = rgb[1] / 255; + let b = rgb[2] / 255; + r = r > 0.04045 ? ((r + 0.055) / 1.055) ** 2.4 : r / 12.92; + g = g > 0.04045 ? ((g + 0.055) / 1.055) ** 2.4 : g / 12.92; + b = b > 0.04045 ? ((b + 0.055) / 1.055) ** 2.4 : b / 12.92; + const x = r * 0.4124 + g * 0.3576 + b * 0.1805; + const y = r * 0.2126 + g * 0.7152 + b * 0.0722; + const z = r * 0.0193 + g * 0.1192 + b * 0.9505; + return [x * 100, y * 100, z * 100]; + }; + convert.rgb.lab = function(rgb) { + const xyz = convert.rgb.xyz(rgb); + let x = xyz[0]; + let y = xyz[1]; + let z = xyz[2]; + x /= 95.047; + y /= 100; + z /= 108.883; + x = x > 8856e-6 ? x ** (1 / 3) : 7.787 * x + 16 / 116; + y = y > 8856e-6 ? y ** (1 / 3) : 7.787 * y + 16 / 116; + z = z > 8856e-6 ? z ** (1 / 3) : 7.787 * z + 16 / 116; + const l = 116 * y - 16; + const a = 500 * (x - y); + const b = 200 * (y - z); + return [l, a, b]; + }; + convert.hsl.rgb = function(hsl) { + const h = hsl[0] / 360; + const s2 = hsl[1] / 100; + const l = hsl[2] / 100; + let t2; + let t3; + let val; + if (s2 === 0) { + val = l * 255; + return [val, val, val]; + } + if (l < 0.5) { + t2 = l * (1 + s2); + } else { + t2 = l + s2 - l * s2; + } + const t1 = 2 * l - t2; + const rgb = [0, 0, 0]; + for (let i = 0; i < 3; i++) { + t3 = h + 1 / 3 * -(i - 1); + if (t3 < 0) { + t3++; + } + if (t3 > 1) { + t3--; + } + if (6 * t3 < 1) { + val = t1 + (t2 - t1) * 6 * t3; + } else if (2 * t3 < 1) { + val = t2; + } else if (3 * t3 < 2) { + val = t1 + (t2 - t1) * (2 / 3 - t3) * 6; + } else { + val = t1; + } + rgb[i] = val * 255; + } + return rgb; + }; + convert.hsl.hsv = function(hsl) { + const h = hsl[0]; + let s2 = hsl[1] / 100; + let l = hsl[2] / 100; + let smin = s2; + const lmin = Math.max(l, 0.01); + l *= 2; + s2 *= l <= 1 ? l : 2 - l; + smin *= lmin <= 1 ? lmin : 2 - lmin; + const v = (l + s2) / 2; + const sv = l === 0 ? 2 * smin / (lmin + smin) : 2 * s2 / (l + s2); + return [h, sv * 100, v * 100]; + }; + convert.hsv.rgb = function(hsv) { + const h = hsv[0] / 60; + const s2 = hsv[1] / 100; + let v = hsv[2] / 100; + const hi = Math.floor(h) % 6; + const f = h - Math.floor(h); + const p = 255 * v * (1 - s2); + const q = 255 * v * (1 - s2 * f); + const t = 255 * v * (1 - s2 * (1 - f)); + v *= 255; + switch (hi) { + case 0: + return [v, t, p]; + case 1: + return [q, v, p]; + case 2: + return [p, v, t]; + case 3: + return [p, q, v]; + case 4: + return [t, p, v]; + case 5: + return [v, p, q]; + } + }; + convert.hsv.hsl = function(hsv) { + const h = hsv[0]; + const s2 = hsv[1] / 100; + const v = hsv[2] / 100; + const vmin = Math.max(v, 0.01); + let sl; + let l; + l = (2 - s2) * v; + const lmin = (2 - s2) * vmin; + sl = s2 * vmin; + sl /= lmin <= 1 ? lmin : 2 - lmin; + sl = sl || 0; + l /= 2; + return [h, sl * 100, l * 100]; + }; + convert.hwb.rgb = function(hwb) { + const h = hwb[0] / 360; + let wh = hwb[1] / 100; + let bl = hwb[2] / 100; + const ratio = wh + bl; + let f; + if (ratio > 1) { + wh /= ratio; + bl /= ratio; + } + const i = Math.floor(6 * h); + const v = 1 - bl; + f = 6 * h - i; + if ((i & 1) !== 0) { + f = 1 - f; + } + const n = wh + f * (v - wh); + let r; + let g; + let b; + switch (i) { + default: + case 6: + case 0: + r = v; + g = n; + b = wh; + break; + case 1: + r = n; + g = v; + b = wh; + break; + case 2: + r = wh; + g = v; + b = n; + break; + case 3: + r = wh; + g = n; + b = v; + break; + case 4: + r = n; + g = wh; + b = v; + break; + case 5: + r = v; + g = wh; + b = n; + break; + } + return [r * 255, g * 255, b * 255]; + }; + convert.cmyk.rgb = function(cmyk) { + const c = cmyk[0] / 100; + const m = cmyk[1] / 100; + const y = cmyk[2] / 100; + const k = cmyk[3] / 100; + const r = 1 - Math.min(1, c * (1 - k) + k); + const g = 1 - Math.min(1, m * (1 - k) + k); + const b = 1 - Math.min(1, y * (1 - k) + k); + return [r * 255, g * 255, b * 255]; + }; + convert.xyz.rgb = function(xyz) { + const x = xyz[0] / 100; + const y = xyz[1] / 100; + const z = xyz[2] / 100; + let r; + let g; + let b; + r = x * 3.2406 + y * -1.5372 + z * -0.4986; + g = x * -0.9689 + y * 1.8758 + z * 0.0415; + b = x * 0.0557 + y * -0.204 + z * 1.057; + r = r > 31308e-7 ? 1.055 * r ** (1 / 2.4) - 0.055 : r * 12.92; + g = g > 31308e-7 ? 1.055 * g ** (1 / 2.4) - 0.055 : g * 12.92; + b = b > 31308e-7 ? 1.055 * b ** (1 / 2.4) - 0.055 : b * 12.92; + r = Math.min(Math.max(0, r), 1); + g = Math.min(Math.max(0, g), 1); + b = Math.min(Math.max(0, b), 1); + return [r * 255, g * 255, b * 255]; + }; + convert.xyz.lab = function(xyz) { + let x = xyz[0]; + let y = xyz[1]; + let z = xyz[2]; + x /= 95.047; + y /= 100; + z /= 108.883; + x = x > 8856e-6 ? x ** (1 / 3) : 7.787 * x + 16 / 116; + y = y > 8856e-6 ? y ** (1 / 3) : 7.787 * y + 16 / 116; + z = z > 8856e-6 ? z ** (1 / 3) : 7.787 * z + 16 / 116; + const l = 116 * y - 16; + const a = 500 * (x - y); + const b = 200 * (y - z); + return [l, a, b]; + }; + convert.lab.xyz = function(lab) { + const l = lab[0]; + const a = lab[1]; + const b = lab[2]; + let x; + let y; + let z; + y = (l + 16) / 116; + x = a / 500 + y; + z = y - b / 200; + const y2 = y ** 3; + const x2 = x ** 3; + const z2 = z ** 3; + y = y2 > 8856e-6 ? y2 : (y - 16 / 116) / 7.787; + x = x2 > 8856e-6 ? x2 : (x - 16 / 116) / 7.787; + z = z2 > 8856e-6 ? z2 : (z - 16 / 116) / 7.787; + x *= 95.047; + y *= 100; + z *= 108.883; + return [x, y, z]; + }; + convert.lab.lch = function(lab) { + const l = lab[0]; + const a = lab[1]; + const b = lab[2]; + let h; + const hr = Math.atan2(b, a); + h = hr * 360 / 2 / Math.PI; + if (h < 0) { + h += 360; + } + const c = Math.sqrt(a * a + b * b); + return [l, c, h]; + }; + convert.lch.lab = function(lch) { + const l = lch[0]; + const c = lch[1]; + const h = lch[2]; + const hr = h / 360 * 2 * Math.PI; + const a = c * Math.cos(hr); + const b = c * Math.sin(hr); + return [l, a, b]; + }; + convert.rgb.ansi16 = function(args, saturation = null) { + const [r, g, b] = args; + let value = saturation === null ? convert.rgb.hsv(args)[2] : saturation; + value = Math.round(value / 50); + if (value === 0) { + return 30; + } + let ansi = 30 + (Math.round(b / 255) << 2 | Math.round(g / 255) << 1 | Math.round(r / 255)); + if (value === 2) { + ansi += 60; + } + return ansi; + }; + convert.hsv.ansi16 = function(args) { + return convert.rgb.ansi16(convert.hsv.rgb(args), args[2]); + }; + convert.rgb.ansi256 = function(args) { + const r = args[0]; + const g = args[1]; + const b = args[2]; + if (r === g && g === b) { + if (r < 8) { + return 16; + } + if (r > 248) { + return 231; + } + return Math.round((r - 8) / 247 * 24) + 232; + } + const ansi = 16 + 36 * Math.round(r / 255 * 5) + 6 * Math.round(g / 255 * 5) + Math.round(b / 255 * 5); + return ansi; + }; + convert.ansi16.rgb = function(args) { + let color = args % 10; + if (color === 0 || color === 7) { + if (args > 50) { + color += 3.5; + } + color = color / 10.5 * 255; + return [color, color, color]; + } + const mult = (~~(args > 50) + 1) * 0.5; + const r = (color & 1) * mult * 255; + const g = (color >> 1 & 1) * mult * 255; + const b = (color >> 2 & 1) * mult * 255; + return [r, g, b]; + }; + convert.ansi256.rgb = function(args) { + if (args >= 232) { + const c = (args - 232) * 10 + 8; + return [c, c, c]; + } + args -= 16; + let rem; + const r = Math.floor(args / 36) / 5 * 255; + const g = Math.floor((rem = args % 36) / 6) / 5 * 255; + const b = rem % 6 / 5 * 255; + return [r, g, b]; + }; + convert.rgb.hex = function(args) { + const integer = ((Math.round(args[0]) & 255) << 16) + ((Math.round(args[1]) & 255) << 8) + (Math.round(args[2]) & 255); + const string2 = integer.toString(16).toUpperCase(); + return "000000".substring(string2.length) + string2; + }; + convert.hex.rgb = function(args) { + const match2 = args.toString(16).match(/[a-f0-9]{6}|[a-f0-9]{3}/i); + if (!match2) { + return [0, 0, 0]; + } + let colorString = match2[0]; + if (match2[0].length === 3) { + colorString = colorString.split("").map((char) => { + return char + char; + }).join(""); + } + const integer = parseInt(colorString, 16); + const r = integer >> 16 & 255; + const g = integer >> 8 & 255; + const b = integer & 255; + return [r, g, b]; + }; + convert.rgb.hcg = function(rgb) { + const r = rgb[0] / 255; + const g = rgb[1] / 255; + const b = rgb[2] / 255; + const max = Math.max(Math.max(r, g), b); + const min = Math.min(Math.min(r, g), b); + const chroma = max - min; + let grayscale; + let hue; + if (chroma < 1) { + grayscale = min / (1 - chroma); + } else { + grayscale = 0; + } + if (chroma <= 0) { + hue = 0; + } else if (max === r) { + hue = (g - b) / chroma % 6; + } else if (max === g) { + hue = 2 + (b - r) / chroma; + } else { + hue = 4 + (r - g) / chroma; + } + hue /= 6; + hue %= 1; + return [hue * 360, chroma * 100, grayscale * 100]; + }; + convert.hsl.hcg = function(hsl) { + const s2 = hsl[1] / 100; + const l = hsl[2] / 100; + const c = l < 0.5 ? 2 * s2 * l : 2 * s2 * (1 - l); + let f = 0; + if (c < 1) { + f = (l - 0.5 * c) / (1 - c); + } + return [hsl[0], c * 100, f * 100]; + }; + convert.hsv.hcg = function(hsv) { + const s2 = hsv[1] / 100; + const v = hsv[2] / 100; + const c = s2 * v; + let f = 0; + if (c < 1) { + f = (v - c) / (1 - c); + } + return [hsv[0], c * 100, f * 100]; + }; + convert.hcg.rgb = function(hcg) { + const h = hcg[0] / 360; + const c = hcg[1] / 100; + const g = hcg[2] / 100; + if (c === 0) { + return [g * 255, g * 255, g * 255]; + } + const pure = [0, 0, 0]; + const hi = h % 1 * 6; + const v = hi % 1; + const w = 1 - v; + let mg = 0; + switch (Math.floor(hi)) { + case 0: + pure[0] = 1; + pure[1] = v; + pure[2] = 0; + break; + case 1: + pure[0] = w; + pure[1] = 1; + pure[2] = 0; + break; + case 2: + pure[0] = 0; + pure[1] = 1; + pure[2] = v; + break; + case 3: + pure[0] = 0; + pure[1] = w; + pure[2] = 1; + break; + case 4: + pure[0] = v; + pure[1] = 0; + pure[2] = 1; + break; + default: + pure[0] = 1; + pure[1] = 0; + pure[2] = w; + } + mg = (1 - c) * g; + return [ + (c * pure[0] + mg) * 255, + (c * pure[1] + mg) * 255, + (c * pure[2] + mg) * 255 + ]; + }; + convert.hcg.hsv = function(hcg) { + const c = hcg[1] / 100; + const g = hcg[2] / 100; + const v = c + g * (1 - c); + let f = 0; + if (v > 0) { + f = c / v; + } + return [hcg[0], f * 100, v * 100]; + }; + convert.hcg.hsl = function(hcg) { + const c = hcg[1] / 100; + const g = hcg[2] / 100; + const l = g * (1 - c) + 0.5 * c; + let s2 = 0; + if (l > 0 && l < 0.5) { + s2 = c / (2 * l); + } else if (l >= 0.5 && l < 1) { + s2 = c / (2 * (1 - l)); + } + return [hcg[0], s2 * 100, l * 100]; + }; + convert.hcg.hwb = function(hcg) { + const c = hcg[1] / 100; + const g = hcg[2] / 100; + const v = c + g * (1 - c); + return [hcg[0], (v - c) * 100, (1 - v) * 100]; + }; + convert.hwb.hcg = function(hwb) { + const w = hwb[1] / 100; + const b = hwb[2] / 100; + const v = 1 - b; + const c = v - w; + let g = 0; + if (c < 1) { + g = (v - c) / (1 - c); + } + return [hwb[0], c * 100, g * 100]; + }; + convert.apple.rgb = function(apple) { + return [apple[0] / 65535 * 255, apple[1] / 65535 * 255, apple[2] / 65535 * 255]; + }; + convert.rgb.apple = function(rgb) { + return [rgb[0] / 255 * 65535, rgb[1] / 255 * 65535, rgb[2] / 255 * 65535]; + }; + convert.gray.rgb = function(args) { + return [args[0] / 100 * 255, args[0] / 100 * 255, args[0] / 100 * 255]; + }; + convert.gray.hsl = function(args) { + return [0, 0, args[0]]; + }; + convert.gray.hsv = convert.gray.hsl; + convert.gray.hwb = function(gray) { + return [0, 100, gray[0]]; + }; + convert.gray.cmyk = function(gray) { + return [0, 0, 0, gray[0]]; + }; + convert.gray.lab = function(gray) { + return [gray[0], 0, 0]; + }; + convert.gray.hex = function(gray) { + const val = Math.round(gray[0] / 100 * 255) & 255; + const integer = (val << 16) + (val << 8) + val; + const string2 = integer.toString(16).toUpperCase(); + return "000000".substring(string2.length) + string2; + }; + convert.rgb.gray = function(rgb) { + const val = (rgb[0] + rgb[1] + rgb[2]) / 3; + return [val / 255 * 100]; + }; + } +}); + +// ../../node_modules/color-convert/route.js +var require_route = __commonJS({ + "../../node_modules/color-convert/route.js"(exports, module2) { + var conversions = require_conversions(); + function buildGraph() { + const graph = {}; + const models = Object.keys(conversions); + for (let len = models.length, i = 0; i < len; i++) { + graph[models[i]] = { + // http://jsperf.com/1-vs-infinity + // micro-opt, but this is simple. + distance: -1, + parent: null + }; + } + return graph; + } + function deriveBFS(fromModel) { + const graph = buildGraph(); + const queue = [fromModel]; + graph[fromModel].distance = 0; + while (queue.length) { + const current = queue.pop(); + const adjacents = Object.keys(conversions[current]); + for (let len = adjacents.length, i = 0; i < len; i++) { + const adjacent = adjacents[i]; + const node = graph[adjacent]; + if (node.distance === -1) { + node.distance = graph[current].distance + 1; + node.parent = current; + queue.unshift(adjacent); + } + } + } + return graph; + } + function link(from, to) { + return function(args) { + return to(from(args)); + }; + } + function wrapConversion(toModel, graph) { + const path2 = [graph[toModel].parent, toModel]; + let fn = conversions[graph[toModel].parent][toModel]; + let cur = graph[toModel].parent; + while (graph[cur].parent) { + path2.unshift(graph[cur].parent); + fn = link(conversions[graph[cur].parent][cur], fn); + cur = graph[cur].parent; + } + fn.conversion = path2; + return fn; + } + module2.exports = function(fromModel) { + const graph = deriveBFS(fromModel); + const conversion = {}; + const models = Object.keys(graph); + for (let len = models.length, i = 0; i < len; i++) { + const toModel = models[i]; + const node = graph[toModel]; + if (node.parent === null) { + continue; + } + conversion[toModel] = wrapConversion(toModel, graph); + } + return conversion; + }; + } +}); + +// ../../node_modules/color-convert/index.js +var require_color_convert = __commonJS({ + "../../node_modules/color-convert/index.js"(exports, module2) { + var conversions = require_conversions(); + var route = require_route(); + var convert = {}; + var models = Object.keys(conversions); + function wrapRaw(fn) { + const wrappedFn = function(...args) { + const arg0 = args[0]; + if (arg0 === void 0 || arg0 === null) { + return arg0; + } + if (arg0.length > 1) { + args = arg0; + } + return fn(args); + }; + if ("conversion" in fn) { + wrappedFn.conversion = fn.conversion; + } + return wrappedFn; + } + function wrapRounded(fn) { + const wrappedFn = function(...args) { + const arg0 = args[0]; + if (arg0 === void 0 || arg0 === null) { + return arg0; + } + if (arg0.length > 1) { + args = arg0; + } + const result = fn(args); + if (typeof result === "object") { + for (let len = result.length, i = 0; i < len; i++) { + result[i] = Math.round(result[i]); + } + } + return result; + }; + if ("conversion" in fn) { + wrappedFn.conversion = fn.conversion; + } + return wrappedFn; + } + models.forEach((fromModel) => { + convert[fromModel] = {}; + Object.defineProperty(convert[fromModel], "channels", { value: conversions[fromModel].channels }); + Object.defineProperty(convert[fromModel], "labels", { value: conversions[fromModel].labels }); + const routes = route(fromModel); + const routeModels = Object.keys(routes); + routeModels.forEach((toModel) => { + const fn = routes[toModel]; + convert[fromModel][toModel] = wrapRounded(fn); + convert[fromModel][toModel].raw = wrapRaw(fn); + }); + }); + module2.exports = convert; + } +}); + +// ../../node_modules/color/index.js +var require_color = __commonJS({ + "../../node_modules/color/index.js"(exports, module2) { + var colorString = require_color_string(); + var convert = require_color_convert(); + var skippedModels = [ + // To be honest, I don't really feel like keyword belongs in color convert, but eh. + "keyword", + // Gray conflicts with some method names, and has its own method defined. + "gray", + // Shouldn't really be in color-convert either... + "hex" + ]; + var hashedModelKeys = {}; + for (const model of Object.keys(convert)) { + hashedModelKeys[[...convert[model].labels].sort().join("")] = model; + } + var limiters = {}; + function Color3(object, model) { + if (!(this instanceof Color3)) { + return new Color3(object, model); + } + if (model && model in skippedModels) { + model = null; + } + if (model && !(model in convert)) { + throw new Error("Unknown model: " + model); + } + let i; + let channels; + if (object == null) { + this.model = "rgb"; + this.color = [0, 0, 0]; + this.valpha = 1; + } else if (object instanceof Color3) { + this.model = object.model; + this.color = [...object.color]; + this.valpha = object.valpha; + } else if (typeof object === "string") { + const result = colorString.get(object); + if (result === null) { + throw new Error("Unable to parse color from string: " + object); + } + this.model = result.model; + channels = convert[this.model].channels; + this.color = result.value.slice(0, channels); + this.valpha = typeof result.value[channels] === "number" ? result.value[channels] : 1; + } else if (object.length > 0) { + this.model = model || "rgb"; + channels = convert[this.model].channels; + const newArray = Array.prototype.slice.call(object, 0, channels); + this.color = zeroArray(newArray, channels); + this.valpha = typeof object[channels] === "number" ? object[channels] : 1; + } else if (typeof object === "number") { + this.model = "rgb"; + this.color = [ + object >> 16 & 255, + object >> 8 & 255, + object & 255 + ]; + this.valpha = 1; + } else { + this.valpha = 1; + const keys2 = Object.keys(object); + if ("alpha" in object) { + keys2.splice(keys2.indexOf("alpha"), 1); + this.valpha = typeof object.alpha === "number" ? object.alpha : 0; + } + const hashedKeys = keys2.sort().join(""); + if (!(hashedKeys in hashedModelKeys)) { + throw new Error("Unable to parse color from object: " + JSON.stringify(object)); + } + this.model = hashedModelKeys[hashedKeys]; + const { labels } = convert[this.model]; + const color = []; + for (i = 0; i < labels.length; i++) { + color.push(object[labels[i]]); + } + this.color = zeroArray(color); + } + if (limiters[this.model]) { + channels = convert[this.model].channels; + for (i = 0; i < channels; i++) { + const limit = limiters[this.model][i]; + if (limit) { + this.color[i] = limit(this.color[i]); + } + } + } + this.valpha = Math.max(0, Math.min(1, this.valpha)); + if (Object.freeze) { + Object.freeze(this); + } + } + Color3.prototype = { + toString() { + return this.string(); + }, + toJSON() { + return this[this.model](); + }, + string(places) { + let self = this.model in colorString.to ? this : this.rgb(); + self = self.round(typeof places === "number" ? places : 1); + const args = self.valpha === 1 ? self.color : [...self.color, this.valpha]; + return colorString.to[self.model](args); + }, + percentString(places) { + const self = this.rgb().round(typeof places === "number" ? places : 1); + const args = self.valpha === 1 ? self.color : [...self.color, this.valpha]; + return colorString.to.rgb.percent(args); + }, + array() { + return this.valpha === 1 ? [...this.color] : [...this.color, this.valpha]; + }, + object() { + const result = {}; + const { channels } = convert[this.model]; + const { labels } = convert[this.model]; + for (let i = 0; i < channels; i++) { + result[labels[i]] = this.color[i]; + } + if (this.valpha !== 1) { + result.alpha = this.valpha; + } + return result; + }, + unitArray() { + const rgb = this.rgb().color; + rgb[0] /= 255; + rgb[1] /= 255; + rgb[2] /= 255; + if (this.valpha !== 1) { + rgb.push(this.valpha); + } + return rgb; + }, + unitObject() { + const rgb = this.rgb().object(); + rgb.r /= 255; + rgb.g /= 255; + rgb.b /= 255; + if (this.valpha !== 1) { + rgb.alpha = this.valpha; + } + return rgb; + }, + round(places) { + places = Math.max(places || 0, 0); + return new Color3([...this.color.map(roundToPlace(places)), this.valpha], this.model); + }, + alpha(value) { + if (value !== void 0) { + return new Color3([...this.color, Math.max(0, Math.min(1, value))], this.model); + } + return this.valpha; + }, + // Rgb + red: getset("rgb", 0, maxfn(255)), + green: getset("rgb", 1, maxfn(255)), + blue: getset("rgb", 2, maxfn(255)), + hue: getset(["hsl", "hsv", "hsl", "hwb", "hcg"], 0, (value) => (value % 360 + 360) % 360), + saturationl: getset("hsl", 1, maxfn(100)), + lightness: getset("hsl", 2, maxfn(100)), + saturationv: getset("hsv", 1, maxfn(100)), + value: getset("hsv", 2, maxfn(100)), + chroma: getset("hcg", 1, maxfn(100)), + gray: getset("hcg", 2, maxfn(100)), + white: getset("hwb", 1, maxfn(100)), + wblack: getset("hwb", 2, maxfn(100)), + cyan: getset("cmyk", 0, maxfn(100)), + magenta: getset("cmyk", 1, maxfn(100)), + yellow: getset("cmyk", 2, maxfn(100)), + black: getset("cmyk", 3, maxfn(100)), + x: getset("xyz", 0, maxfn(95.047)), + y: getset("xyz", 1, maxfn(100)), + z: getset("xyz", 2, maxfn(108.833)), + l: getset("lab", 0, maxfn(100)), + a: getset("lab", 1), + b: getset("lab", 2), + keyword(value) { + if (value !== void 0) { + return new Color3(value); + } + return convert[this.model].keyword(this.color); + }, + hex(value) { + if (value !== void 0) { + return new Color3(value); + } + return colorString.to.hex(this.rgb().round().color); + }, + hexa(value) { + if (value !== void 0) { + return new Color3(value); + } + const rgbArray = this.rgb().round().color; + let alphaHex = Math.round(this.valpha * 255).toString(16).toUpperCase(); + if (alphaHex.length === 1) { + alphaHex = "0" + alphaHex; + } + return colorString.to.hex(rgbArray) + alphaHex; + }, + rgbNumber() { + const rgb = this.rgb().color; + return (rgb[0] & 255) << 16 | (rgb[1] & 255) << 8 | rgb[2] & 255; + }, + luminosity() { + const rgb = this.rgb().color; + const lum = []; + for (const [i, element] of rgb.entries()) { + const chan = element / 255; + lum[i] = chan <= 0.04045 ? chan / 12.92 : ((chan + 0.055) / 1.055) ** 2.4; + } + return 0.2126 * lum[0] + 0.7152 * lum[1] + 0.0722 * lum[2]; + }, + contrast(color2) { + const lum1 = this.luminosity(); + const lum2 = color2.luminosity(); + if (lum1 > lum2) { + return (lum1 + 0.05) / (lum2 + 0.05); + } + return (lum2 + 0.05) / (lum1 + 0.05); + }, + level(color2) { + const contrastRatio = this.contrast(color2); + if (contrastRatio >= 7) { + return "AAA"; + } + return contrastRatio >= 4.5 ? "AA" : ""; + }, + isDark() { + const rgb = this.rgb().color; + const yiq = (rgb[0] * 2126 + rgb[1] * 7152 + rgb[2] * 722) / 1e4; + return yiq < 128; + }, + isLight() { + return !this.isDark(); + }, + negate() { + const rgb = this.rgb(); + for (let i = 0; i < 3; i++) { + rgb.color[i] = 255 - rgb.color[i]; + } + return rgb; + }, + lighten(ratio) { + const hsl = this.hsl(); + hsl.color[2] += hsl.color[2] * ratio; + return hsl; + }, + darken(ratio) { + const hsl = this.hsl(); + hsl.color[2] -= hsl.color[2] * ratio; + return hsl; + }, + saturate(ratio) { + const hsl = this.hsl(); + hsl.color[1] += hsl.color[1] * ratio; + return hsl; + }, + desaturate(ratio) { + const hsl = this.hsl(); + hsl.color[1] -= hsl.color[1] * ratio; + return hsl; + }, + whiten(ratio) { + const hwb = this.hwb(); + hwb.color[1] += hwb.color[1] * ratio; + return hwb; + }, + blacken(ratio) { + const hwb = this.hwb(); + hwb.color[2] += hwb.color[2] * ratio; + return hwb; + }, + grayscale() { + const rgb = this.rgb().color; + const value = rgb[0] * 0.3 + rgb[1] * 0.59 + rgb[2] * 0.11; + return Color3.rgb(value, value, value); + }, + fade(ratio) { + return this.alpha(this.valpha - this.valpha * ratio); + }, + opaquer(ratio) { + return this.alpha(this.valpha + this.valpha * ratio); + }, + rotate(degrees) { + const hsl = this.hsl(); + let hue = hsl.color[0]; + hue = (hue + degrees) % 360; + hue = hue < 0 ? 360 + hue : hue; + hsl.color[0] = hue; + return hsl; + }, + mix(mixinColor, weight) { + if (!mixinColor || !mixinColor.rgb) { + throw new Error('Argument to "mix" was not a Color instance, but rather an instance of ' + typeof mixinColor); + } + const color1 = mixinColor.rgb(); + const color2 = this.rgb(); + const p = weight === void 0 ? 0.5 : weight; + const w = 2 * p - 1; + const a = color1.alpha() - color2.alpha(); + const w1 = ((w * a === -1 ? w : (w + a) / (1 + w * a)) + 1) / 2; + const w2 = 1 - w1; + return Color3.rgb( + w1 * color1.red() + w2 * color2.red(), + w1 * color1.green() + w2 * color2.green(), + w1 * color1.blue() + w2 * color2.blue(), + color1.alpha() * p + color2.alpha() * (1 - p) + ); + } + }; + for (const model of Object.keys(convert)) { + if (skippedModels.includes(model)) { + continue; + } + const { channels } = convert[model]; + Color3.prototype[model] = function(...args) { + if (this.model === model) { + return new Color3(this); + } + if (args.length > 0) { + return new Color3(args, model); + } + return new Color3([...assertArray(convert[this.model][model].raw(this.color)), this.valpha], model); + }; + Color3[model] = function(...args) { + let color = args[0]; + if (typeof color === "number") { + color = zeroArray(args, channels); + } + return new Color3(color, model); + }; + } + function roundTo(number, places) { + return Number(number.toFixed(places)); + } + function roundToPlace(places) { + return function(number) { + return roundTo(number, places); + }; + } + function getset(model, channel, modifier) { + model = Array.isArray(model) ? model : [model]; + for (const m of model) { + (limiters[m] || (limiters[m] = []))[channel] = modifier; + } + model = model[0]; + return function(value) { + let result; + if (value !== void 0) { + if (modifier) { + value = modifier(value); + } + result = this[model](); + result.color[channel] = value; + return result; + } + result = this[model]().color[channel]; + if (modifier) { + result = modifier(result); + } + return result; + }; + } + function maxfn(max) { + return function(v) { + return Math.max(0, Math.min(max, v)); + }; + } + function assertArray(value) { + return Array.isArray(value) ? value : [value]; + } + function zeroArray(array, length) { + for (let i = 0; i < length; i++) { + if (typeof array[i] !== "number") { + array[i] = 0; + } + } + return array; + } + module2.exports = Color3; + } +}); + +// index.ts +var unified_latex_prettier_exports = {}; +__export(unified_latex_prettier_exports, { + prettierPluginLatex: () => prettierPluginLatex, + printLatexAst: () => printLatexAst, + printer: () => printLatexAst +}); +module.exports = __toCommonJS(unified_latex_prettier_exports); + +// node_modules/prettier/doc.mjs +var __defProp2 = Object.defineProperty; +var __export2 = (target, all) => { + for (var name in all) + __defProp2(target, name, { get: all[name], enumerable: true }); +}; +var public_exports = {}; +__export2(public_exports, { + builders: () => builders, + printer: () => printer, + utils: () => utils +}); +var DOC_TYPE_STRING = "string"; +var DOC_TYPE_ARRAY = "array"; +var DOC_TYPE_CURSOR = "cursor"; +var DOC_TYPE_INDENT = "indent"; +var DOC_TYPE_ALIGN = "align"; +var DOC_TYPE_TRIM = "trim"; +var DOC_TYPE_GROUP = "group"; +var DOC_TYPE_FILL = "fill"; +var DOC_TYPE_IF_BREAK = "if-break"; +var DOC_TYPE_INDENT_IF_BREAK = "indent-if-break"; +var DOC_TYPE_LINE_SUFFIX = "line-suffix"; +var DOC_TYPE_LINE_SUFFIX_BOUNDARY = "line-suffix-boundary"; +var DOC_TYPE_LINE = "line"; +var DOC_TYPE_LABEL = "label"; +var DOC_TYPE_BREAK_PARENT = "break-parent"; +var VALID_OBJECT_DOC_TYPES = /* @__PURE__ */ new Set([ + DOC_TYPE_CURSOR, + DOC_TYPE_INDENT, + DOC_TYPE_ALIGN, + DOC_TYPE_TRIM, + DOC_TYPE_GROUP, + DOC_TYPE_FILL, + DOC_TYPE_IF_BREAK, + DOC_TYPE_INDENT_IF_BREAK, + DOC_TYPE_LINE_SUFFIX, + DOC_TYPE_LINE_SUFFIX_BOUNDARY, + DOC_TYPE_LINE, + DOC_TYPE_LABEL, + DOC_TYPE_BREAK_PARENT +]); +function getDocType(doc) { + if (typeof doc === "string") { + return DOC_TYPE_STRING; + } + if (Array.isArray(doc)) { + return DOC_TYPE_ARRAY; + } + if (!doc) { + return; + } + const { type } = doc; + if (VALID_OBJECT_DOC_TYPES.has(type)) { + return type; + } +} +var get_doc_type_default = getDocType; +var disjunctionListFormat = (list) => new Intl.ListFormat("en-US", { type: "disjunction" }).format(list); +function getDocErrorMessage(doc) { + const type = doc === null ? "null" : typeof doc; + if (type !== "string" && type !== "object") { + return `Unexpected doc '${type}', +Expected it to be 'string' or 'object'.`; + } + if (get_doc_type_default(doc)) { + throw new Error("doc is valid."); + } + const objectType = Object.prototype.toString.call(doc); + if (objectType !== "[object Object]") { + return `Unexpected doc '${objectType}'.`; + } + const EXPECTED_TYPE_VALUES = disjunctionListFormat( + [...VALID_OBJECT_DOC_TYPES].map((type2) => `'${type2}'`) + ); + return `Unexpected doc.type '${doc.type}'. +Expected it to be ${EXPECTED_TYPE_VALUES}.`; +} +var InvalidDocError = class extends Error { + name = "InvalidDocError"; + constructor(doc) { + super(getDocErrorMessage(doc)); + this.doc = doc; + } +}; +var invalid_doc_error_default = InvalidDocError; +var traverseDocOnExitStackMarker = {}; +function traverseDoc(doc, onEnter, onExit, shouldTraverseConditionalGroups) { + const docsStack = [doc]; + while (docsStack.length > 0) { + const doc2 = docsStack.pop(); + if (doc2 === traverseDocOnExitStackMarker) { + onExit(docsStack.pop()); + continue; + } + if (onExit) { + docsStack.push(doc2, traverseDocOnExitStackMarker); + } + const docType = get_doc_type_default(doc2); + if (!docType) { + throw new invalid_doc_error_default(doc2); + } + if ((onEnter == null ? void 0 : onEnter(doc2)) === false) { + continue; + } + switch (docType) { + case DOC_TYPE_ARRAY: + case DOC_TYPE_FILL: { + const parts = docType === DOC_TYPE_ARRAY ? doc2 : doc2.parts; + for (let ic = parts.length, i = ic - 1; i >= 0; --i) { + docsStack.push(parts[i]); + } + break; + } + case DOC_TYPE_IF_BREAK: + docsStack.push(doc2.flatContents, doc2.breakContents); + break; + case DOC_TYPE_GROUP: + if (shouldTraverseConditionalGroups && doc2.expandedStates) { + for (let ic = doc2.expandedStates.length, i = ic - 1; i >= 0; --i) { + docsStack.push(doc2.expandedStates[i]); + } + } else { + docsStack.push(doc2.contents); + } + break; + case DOC_TYPE_ALIGN: + case DOC_TYPE_INDENT: + case DOC_TYPE_INDENT_IF_BREAK: + case DOC_TYPE_LABEL: + case DOC_TYPE_LINE_SUFFIX: + docsStack.push(doc2.contents); + break; + case DOC_TYPE_STRING: + case DOC_TYPE_CURSOR: + case DOC_TYPE_TRIM: + case DOC_TYPE_LINE_SUFFIX_BOUNDARY: + case DOC_TYPE_LINE: + case DOC_TYPE_BREAK_PARENT: + break; + default: + throw new invalid_doc_error_default(doc2); + } + } +} +var traverse_doc_default = traverseDoc; +var noop = () => { +}; +var assertDoc = true ? noop : function(doc) { + traverse_doc_default(doc, (doc2) => { + if (checked.has(doc2)) { + return false; + } + if (typeof doc2 !== "string") { + checked.add(doc2); + } + }); +}; +var assertDocArray = true ? noop : function(docs, optional = false) { + if (optional && !docs) { + return; + } + if (!Array.isArray(docs)) { + throw new TypeError("Unexpected doc array."); + } + for (const doc of docs) { + assertDoc(doc); + } +}; +function indent(contents) { + assertDoc(contents); + return { type: DOC_TYPE_INDENT, contents }; +} +function align(widthOrString, contents) { + assertDoc(contents); + return { type: DOC_TYPE_ALIGN, contents, n: widthOrString }; +} +function group(contents, opts = {}) { + assertDoc(contents); + assertDocArray( + opts.expandedStates, + /* optional */ + true + ); + return { + type: DOC_TYPE_GROUP, + id: opts.id, + contents, + break: Boolean(opts.shouldBreak), + expandedStates: opts.expandedStates + }; +} +function dedentToRoot(contents) { + return align(Number.NEGATIVE_INFINITY, contents); +} +function markAsRoot(contents) { + return align({ type: "root" }, contents); +} +function dedent(contents) { + return align(-1, contents); +} +function conditionalGroup(states, opts) { + return group(states[0], { ...opts, expandedStates: states }); +} +function fill(parts) { + assertDocArray(parts); + return { type: DOC_TYPE_FILL, parts }; +} +function ifBreak(breakContents, flatContents = "", opts = {}) { + assertDoc(breakContents); + if (flatContents !== "") { + assertDoc(flatContents); + } + return { + type: DOC_TYPE_IF_BREAK, + breakContents, + flatContents, + groupId: opts.groupId + }; +} +function indentIfBreak(contents, opts) { + assertDoc(contents); + return { + type: DOC_TYPE_INDENT_IF_BREAK, + contents, + groupId: opts.groupId, + negate: opts.negate + }; +} +function lineSuffix(contents) { + assertDoc(contents); + return { type: DOC_TYPE_LINE_SUFFIX, contents }; +} +var lineSuffixBoundary = { type: DOC_TYPE_LINE_SUFFIX_BOUNDARY }; +var breakParent = { type: DOC_TYPE_BREAK_PARENT }; +var trim = { type: DOC_TYPE_TRIM }; +var hardlineWithoutBreakParent = { type: DOC_TYPE_LINE, hard: true }; +var literallineWithoutBreakParent = { + type: DOC_TYPE_LINE, + hard: true, + literal: true +}; +var line = { type: DOC_TYPE_LINE }; +var softline = { type: DOC_TYPE_LINE, soft: true }; +var hardline = [hardlineWithoutBreakParent, breakParent]; +var literalline = [literallineWithoutBreakParent, breakParent]; +var cursor = { type: DOC_TYPE_CURSOR }; +function join(separator, docs) { + assertDoc(separator); + assertDocArray(docs); + const parts = []; + for (let i = 0; i < docs.length; i++) { + if (i !== 0) { + parts.push(separator); + } + parts.push(docs[i]); + } + return parts; +} +function addAlignmentToDoc(doc, size, tabWidth) { + assertDoc(doc); + let aligned = doc; + if (size > 0) { + for (let i = 0; i < Math.floor(size / tabWidth); ++i) { + aligned = indent(aligned); + } + aligned = align(size % tabWidth, aligned); + aligned = align(Number.NEGATIVE_INFINITY, aligned); + } + return aligned; +} +function label(label2, contents) { + assertDoc(contents); + return label2 ? { type: DOC_TYPE_LABEL, label: label2, contents } : contents; +} +var at = (isOptionalObject, object, index2) => { + if (isOptionalObject && (object === void 0 || object === null)) { + return; + } + if (Array.isArray(object) || typeof object === "string") { + return object[index2 < 0 ? object.length + index2 : index2]; + } + return object.at(index2); +}; +var at_default = at; +var stringReplaceAll = (isOptionalObject, original, pattern, replacement) => { + if (isOptionalObject && (original === void 0 || original === null)) { + return; + } + if (original.replaceAll) { + return original.replaceAll(pattern, replacement); + } + if (pattern.global) { + return original.replace(pattern, replacement); + } + return original.split(pattern).join(replacement); +}; +var string_replace_all_default = stringReplaceAll; +function convertEndOfLineToChars(value) { + switch (value) { + case "cr": + return "\r"; + case "crlf": + return "\r\n"; + default: + return "\n"; + } +} +var emoji_regex_default = () => { + return /[#*0-9]\uFE0F?\u20E3|[\xA9\xAE\u203C\u2049\u2122\u2139\u2194-\u2199\u21A9\u21AA\u231A\u231B\u2328\u23CF\u23ED-\u23EF\u23F1\u23F2\u23F8-\u23FA\u24C2\u25AA\u25AB\u25B6\u25C0\u25FB\u25FC\u25FE\u2600-\u2604\u260E\u2611\u2614\u2615\u2618\u2620\u2622\u2623\u2626\u262A\u262E\u262F\u2638-\u263A\u2640\u2642\u2648-\u2653\u265F\u2660\u2663\u2665\u2666\u2668\u267B\u267E\u267F\u2692\u2694-\u2697\u2699\u269B\u269C\u26A0\u26A7\u26AA\u26B0\u26B1\u26BD\u26BE\u26C4\u26C8\u26CF\u26D1\u26D3\u26E9\u26F0-\u26F5\u26F7\u26F8\u26FA\u2702\u2708\u2709\u270F\u2712\u2714\u2716\u271D\u2721\u2733\u2734\u2744\u2747\u2757\u2763\u27A1\u2934\u2935\u2B05-\u2B07\u2B1B\u2B1C\u2B55\u3030\u303D\u3297\u3299]\uFE0F?|[\u261D\u270C\u270D](?:\uFE0F|\uD83C[\uDFFB-\uDFFF])?|[\u270A\u270B](?:\uD83C[\uDFFB-\uDFFF])?|[\u23E9-\u23EC\u23F0\u23F3\u25FD\u2693\u26A1\u26AB\u26C5\u26CE\u26D4\u26EA\u26FD\u2705\u2728\u274C\u274E\u2753-\u2755\u2795-\u2797\u27B0\u27BF\u2B50]|\u26F9(?:\uFE0F|\uD83C[\uDFFB-\uDFFF])?(?:\u200D[\u2640\u2642]\uFE0F?)?|\u2764\uFE0F?(?:\u200D(?:\uD83D\uDD25|\uD83E\uDE79))?|\uD83C(?:[\uDC04\uDD70\uDD71\uDD7E\uDD7F\uDE02\uDE37\uDF21\uDF24-\uDF2C\uDF36\uDF7D\uDF96\uDF97\uDF99-\uDF9B\uDF9E\uDF9F\uDFCD\uDFCE\uDFD4-\uDFDF\uDFF5\uDFF7]\uFE0F?|[\uDF85\uDFC2\uDFC7](?:\uD83C[\uDFFB-\uDFFF])?|[\uDFC3\uDFC4\uDFCA](?:\uD83C[\uDFFB-\uDFFF])?(?:\u200D[\u2640\u2642]\uFE0F?)?|[\uDFCB\uDFCC](?:\uFE0F|\uD83C[\uDFFB-\uDFFF])?(?:\u200D[\u2640\u2642]\uFE0F?)?|[\uDCCF\uDD8E\uDD91-\uDD9A\uDE01\uDE1A\uDE2F\uDE32-\uDE36\uDE38-\uDE3A\uDE50\uDE51\uDF00-\uDF20\uDF2D-\uDF35\uDF37-\uDF7C\uDF7E-\uDF84\uDF86-\uDF93\uDFA0-\uDFC1\uDFC5\uDFC6\uDFC8\uDFC9\uDFCF-\uDFD3\uDFE0-\uDFF0\uDFF8-\uDFFF]|\uDDE6\uD83C[\uDDE8-\uDDEC\uDDEE\uDDF1\uDDF2\uDDF4\uDDF6-\uDDFA\uDDFC\uDDFD\uDDFF]|\uDDE7\uD83C[\uDDE6\uDDE7\uDDE9-\uDDEF\uDDF1-\uDDF4\uDDF6-\uDDF9\uDDFB\uDDFC\uDDFE\uDDFF]|\uDDE8\uD83C[\uDDE6\uDDE8\uDDE9\uDDEB-\uDDEE\uDDF0-\uDDF5\uDDF7\uDDFA-\uDDFF]|\uDDE9\uD83C[\uDDEA\uDDEC\uDDEF\uDDF0\uDDF2\uDDF4\uDDFF]|\uDDEA\uD83C[\uDDE6\uDDE8\uDDEA\uDDEC\uDDED\uDDF7-\uDDFA]|\uDDEB\uD83C[\uDDEE-\uDDF0\uDDF2\uDDF4\uDDF7]|\uDDEC\uD83C[\uDDE6\uDDE7\uDDE9-\uDDEE\uDDF1-\uDDF3\uDDF5-\uDDFA\uDDFC\uDDFE]|\uDDED\uD83C[\uDDF0\uDDF2\uDDF3\uDDF7\uDDF9\uDDFA]|\uDDEE\uD83C[\uDDE8-\uDDEA\uDDF1-\uDDF4\uDDF6-\uDDF9]|\uDDEF\uD83C[\uDDEA\uDDF2\uDDF4\uDDF5]|\uDDF0\uD83C[\uDDEA\uDDEC-\uDDEE\uDDF2\uDDF3\uDDF5\uDDF7\uDDFC\uDDFE\uDDFF]|\uDDF1\uD83C[\uDDE6-\uDDE8\uDDEE\uDDF0\uDDF7-\uDDFB\uDDFE]|\uDDF2\uD83C[\uDDE6\uDDE8-\uDDED\uDDF0-\uDDFF]|\uDDF3\uD83C[\uDDE6\uDDE8\uDDEA-\uDDEC\uDDEE\uDDF1\uDDF4\uDDF5\uDDF7\uDDFA\uDDFF]|\uDDF4\uD83C\uDDF2|\uDDF5\uD83C[\uDDE6\uDDEA-\uDDED\uDDF0-\uDDF3\uDDF7-\uDDF9\uDDFC\uDDFE]|\uDDF6\uD83C\uDDE6|\uDDF7\uD83C[\uDDEA\uDDF4\uDDF8\uDDFA\uDDFC]|\uDDF8\uD83C[\uDDE6-\uDDEA\uDDEC-\uDDF4\uDDF7-\uDDF9\uDDFB\uDDFD-\uDDFF]|\uDDF9\uD83C[\uDDE6\uDDE8\uDDE9\uDDEB-\uDDED\uDDEF-\uDDF4\uDDF7\uDDF9\uDDFB\uDDFC\uDDFF]|\uDDFA\uD83C[\uDDE6\uDDEC\uDDF2\uDDF3\uDDF8\uDDFE\uDDFF]|\uDDFB\uD83C[\uDDE6\uDDE8\uDDEA\uDDEC\uDDEE\uDDF3\uDDFA]|\uDDFC\uD83C[\uDDEB\uDDF8]|\uDDFD\uD83C\uDDF0|\uDDFE\uD83C[\uDDEA\uDDF9]|\uDDFF\uD83C[\uDDE6\uDDF2\uDDFC]|\uDFF3\uFE0F?(?:\u200D(?:\u26A7\uFE0F?|\uD83C\uDF08))?|\uDFF4(?:\u200D\u2620\uFE0F?|\uDB40\uDC67\uDB40\uDC62\uDB40(?:\uDC65\uDB40\uDC6E\uDB40\uDC67|\uDC73\uDB40\uDC63\uDB40\uDC74|\uDC77\uDB40\uDC6C\uDB40\uDC73)\uDB40\uDC7F)?)|\uD83D(?:[\uDC08\uDC26](?:\u200D\u2B1B)?|[\uDC3F\uDCFD\uDD49\uDD4A\uDD6F\uDD70\uDD73\uDD76-\uDD79\uDD87\uDD8A-\uDD8D\uDDA5\uDDA8\uDDB1\uDDB2\uDDBC\uDDC2-\uDDC4\uDDD1-\uDDD3\uDDDC-\uDDDE\uDDE1\uDDE3\uDDE8\uDDEF\uDDF3\uDDFA\uDECB\uDECD-\uDECF\uDEE0-\uDEE5\uDEE9\uDEF0\uDEF3]\uFE0F?|[\uDC42\uDC43\uDC46-\uDC50\uDC66\uDC67\uDC6B-\uDC6D\uDC72\uDC74-\uDC76\uDC78\uDC7C\uDC83\uDC85\uDC8F\uDC91\uDCAA\uDD7A\uDD95\uDD96\uDE4C\uDE4F\uDEC0\uDECC](?:\uD83C[\uDFFB-\uDFFF])?|[\uDC6E\uDC70\uDC71\uDC73\uDC77\uDC81\uDC82\uDC86\uDC87\uDE45-\uDE47\uDE4B\uDE4D\uDE4E\uDEA3\uDEB4-\uDEB6](?:\uD83C[\uDFFB-\uDFFF])?(?:\u200D[\u2640\u2642]\uFE0F?)?|[\uDD74\uDD90](?:\uFE0F|\uD83C[\uDFFB-\uDFFF])?|[\uDC00-\uDC07\uDC09-\uDC14\uDC16-\uDC25\uDC27-\uDC3A\uDC3C-\uDC3E\uDC40\uDC44\uDC45\uDC51-\uDC65\uDC6A\uDC79-\uDC7B\uDC7D-\uDC80\uDC84\uDC88-\uDC8E\uDC90\uDC92-\uDCA9\uDCAB-\uDCFC\uDCFF-\uDD3D\uDD4B-\uDD4E\uDD50-\uDD67\uDDA4\uDDFB-\uDE2D\uDE2F-\uDE34\uDE37-\uDE44\uDE48-\uDE4A\uDE80-\uDEA2\uDEA4-\uDEB3\uDEB7-\uDEBF\uDEC1-\uDEC5\uDED0-\uDED2\uDED5-\uDED7\uDEDC-\uDEDF\uDEEB\uDEEC\uDEF4-\uDEFC\uDFE0-\uDFEB\uDFF0]|\uDC15(?:\u200D\uD83E\uDDBA)?|\uDC3B(?:\u200D\u2744\uFE0F?)?|\uDC41\uFE0F?(?:\u200D\uD83D\uDDE8\uFE0F?)?|\uDC68(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:\uDC8B\u200D\uD83D)?\uDC68|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D(?:[\uDC68\uDC69]\u200D\uD83D(?:\uDC66(?:\u200D\uD83D\uDC66)?|\uDC67(?:\u200D\uD83D[\uDC66\uDC67])?)|[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uDC66(?:\u200D\uD83D\uDC66)?|\uDC67(?:\u200D\uD83D[\uDC66\uDC67])?)|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\uD83C(?:\uDFFB(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:\uDC8B\u200D\uD83D)?\uDC68\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF-\uDDB3\uDDBC\uDDBD]|\uDD1D\u200D\uD83D\uDC68\uD83C[\uDFFC-\uDFFF])))?|\uDFFC(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:\uDC8B\u200D\uD83D)?\uDC68\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF-\uDDB3\uDDBC\uDDBD]|\uDD1D\u200D\uD83D\uDC68\uD83C[\uDFFB\uDFFD-\uDFFF])))?|\uDFFD(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:\uDC8B\u200D\uD83D)?\uDC68\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF-\uDDB3\uDDBC\uDDBD]|\uDD1D\u200D\uD83D\uDC68\uD83C[\uDFFB\uDFFC\uDFFE\uDFFF])))?|\uDFFE(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:\uDC8B\u200D\uD83D)?\uDC68\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF-\uDDB3\uDDBC\uDDBD]|\uDD1D\u200D\uD83D\uDC68\uD83C[\uDFFB-\uDFFD\uDFFF])))?|\uDFFF(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:\uDC8B\u200D\uD83D)?\uDC68\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF-\uDDB3\uDDBC\uDDBD]|\uDD1D\u200D\uD83D\uDC68\uD83C[\uDFFB-\uDFFE])))?))?|\uDC69(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:\uDC8B\u200D\uD83D)?[\uDC68\uDC69]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D(?:[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uDC66(?:\u200D\uD83D\uDC66)?|\uDC67(?:\u200D\uD83D[\uDC66\uDC67])?|\uDC69\u200D\uD83D(?:\uDC66(?:\u200D\uD83D\uDC66)?|\uDC67(?:\u200D\uD83D[\uDC66\uDC67])?))|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\uD83C(?:\uDFFB(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:[\uDC68\uDC69]|\uDC8B\u200D\uD83D[\uDC68\uDC69])\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF-\uDDB3\uDDBC\uDDBD]|\uDD1D\u200D\uD83D[\uDC68\uDC69]\uD83C[\uDFFC-\uDFFF])))?|\uDFFC(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:[\uDC68\uDC69]|\uDC8B\u200D\uD83D[\uDC68\uDC69])\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF-\uDDB3\uDDBC\uDDBD]|\uDD1D\u200D\uD83D[\uDC68\uDC69]\uD83C[\uDFFB\uDFFD-\uDFFF])))?|\uDFFD(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:[\uDC68\uDC69]|\uDC8B\u200D\uD83D[\uDC68\uDC69])\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF-\uDDB3\uDDBC\uDDBD]|\uDD1D\u200D\uD83D[\uDC68\uDC69]\uD83C[\uDFFB\uDFFC\uDFFE\uDFFF])))?|\uDFFE(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:[\uDC68\uDC69]|\uDC8B\u200D\uD83D[\uDC68\uDC69])\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF-\uDDB3\uDDBC\uDDBD]|\uDD1D\u200D\uD83D[\uDC68\uDC69]\uD83C[\uDFFB-\uDFFD\uDFFF])))?|\uDFFF(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:[\uDC68\uDC69]|\uDC8B\u200D\uD83D[\uDC68\uDC69])\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF-\uDDB3\uDDBC\uDDBD]|\uDD1D\u200D\uD83D[\uDC68\uDC69]\uD83C[\uDFFB-\uDFFE])))?))?|\uDC6F(?:\u200D[\u2640\u2642]\uFE0F?)?|\uDD75(?:\uFE0F|\uD83C[\uDFFB-\uDFFF])?(?:\u200D[\u2640\u2642]\uFE0F?)?|\uDE2E(?:\u200D\uD83D\uDCA8)?|\uDE35(?:\u200D\uD83D\uDCAB)?|\uDE36(?:\u200D\uD83C\uDF2B\uFE0F?)?)|\uD83E(?:[\uDD0C\uDD0F\uDD18-\uDD1F\uDD30-\uDD34\uDD36\uDD77\uDDB5\uDDB6\uDDBB\uDDD2\uDDD3\uDDD5\uDEC3-\uDEC5\uDEF0\uDEF2-\uDEF8](?:\uD83C[\uDFFB-\uDFFF])?|[\uDD26\uDD35\uDD37-\uDD39\uDD3D\uDD3E\uDDB8\uDDB9\uDDCD-\uDDCF\uDDD4\uDDD6-\uDDDD](?:\uD83C[\uDFFB-\uDFFF])?(?:\u200D[\u2640\u2642]\uFE0F?)?|[\uDDDE\uDDDF](?:\u200D[\u2640\u2642]\uFE0F?)?|[\uDD0D\uDD0E\uDD10-\uDD17\uDD20-\uDD25\uDD27-\uDD2F\uDD3A\uDD3F-\uDD45\uDD47-\uDD76\uDD78-\uDDB4\uDDB7\uDDBA\uDDBC-\uDDCC\uDDD0\uDDE0-\uDDFF\uDE70-\uDE7C\uDE80-\uDE88\uDE90-\uDEBD\uDEBF-\uDEC2\uDECE-\uDEDB\uDEE0-\uDEE8]|\uDD3C(?:\u200D[\u2640\u2642]\uFE0F?|\uD83C[\uDFFB-\uDFFF])?|\uDDD1(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\uD83C[\uDF3E\uDF73\uDF7C\uDF84\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF-\uDDB3\uDDBC\uDDBD]|\uDD1D\u200D\uD83E\uDDD1))|\uD83C(?:\uDFFB(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D(?:\uD83D\uDC8B\u200D)?\uD83E\uDDD1\uD83C[\uDFFC-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF84\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF-\uDDB3\uDDBC\uDDBD]|\uDD1D\u200D\uD83E\uDDD1\uD83C[\uDFFB-\uDFFF])))?|\uDFFC(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D(?:\uD83D\uDC8B\u200D)?\uD83E\uDDD1\uD83C[\uDFFB\uDFFD-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF84\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF-\uDDB3\uDDBC\uDDBD]|\uDD1D\u200D\uD83E\uDDD1\uD83C[\uDFFB-\uDFFF])))?|\uDFFD(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D(?:\uD83D\uDC8B\u200D)?\uD83E\uDDD1\uD83C[\uDFFB\uDFFC\uDFFE\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF84\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF-\uDDB3\uDDBC\uDDBD]|\uDD1D\u200D\uD83E\uDDD1\uD83C[\uDFFB-\uDFFF])))?|\uDFFE(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D(?:\uD83D\uDC8B\u200D)?\uD83E\uDDD1\uD83C[\uDFFB-\uDFFD\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF84\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF-\uDDB3\uDDBC\uDDBD]|\uDD1D\u200D\uD83E\uDDD1\uD83C[\uDFFB-\uDFFF])))?|\uDFFF(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D(?:\uD83D\uDC8B\u200D)?\uD83E\uDDD1\uD83C[\uDFFB-\uDFFE]|\uD83C[\uDF3E\uDF73\uDF7C\uDF84\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF-\uDDB3\uDDBC\uDDBD]|\uDD1D\u200D\uD83E\uDDD1\uD83C[\uDFFB-\uDFFF])))?))?|\uDEF1(?:\uD83C(?:\uDFFB(?:\u200D\uD83E\uDEF2\uD83C[\uDFFC-\uDFFF])?|\uDFFC(?:\u200D\uD83E\uDEF2\uD83C[\uDFFB\uDFFD-\uDFFF])?|\uDFFD(?:\u200D\uD83E\uDEF2\uD83C[\uDFFB\uDFFC\uDFFE\uDFFF])?|\uDFFE(?:\u200D\uD83E\uDEF2\uD83C[\uDFFB-\uDFFD\uDFFF])?|\uDFFF(?:\u200D\uD83E\uDEF2\uD83C[\uDFFB-\uDFFE])?))?)/g; +}; +var eastasianwidth_default = { + eastAsianWidth(character) { + var x = character.charCodeAt(0); + var y = character.length == 2 ? character.charCodeAt(1) : 0; + var codePoint = x; + if (55296 <= x && x <= 56319 && 56320 <= y && y <= 57343) { + x &= 1023; + y &= 1023; + codePoint = x << 10 | y; + codePoint += 65536; + } + if (12288 == codePoint || 65281 <= codePoint && codePoint <= 65376 || 65504 <= codePoint && codePoint <= 65510) { + return "F"; + } + if (4352 <= codePoint && codePoint <= 4447 || 4515 <= codePoint && codePoint <= 4519 || 4602 <= codePoint && codePoint <= 4607 || 9001 <= codePoint && codePoint <= 9002 || 11904 <= codePoint && codePoint <= 11929 || 11931 <= codePoint && codePoint <= 12019 || 12032 <= codePoint && codePoint <= 12245 || 12272 <= codePoint && codePoint <= 12283 || 12289 <= codePoint && codePoint <= 12350 || 12353 <= codePoint && codePoint <= 12438 || 12441 <= codePoint && codePoint <= 12543 || 12549 <= codePoint && codePoint <= 12589 || 12593 <= codePoint && codePoint <= 12686 || 12688 <= codePoint && codePoint <= 12730 || 12736 <= codePoint && codePoint <= 12771 || 12784 <= codePoint && codePoint <= 12830 || 12832 <= codePoint && codePoint <= 12871 || 12880 <= codePoint && codePoint <= 13054 || 13056 <= codePoint && codePoint <= 19903 || 19968 <= codePoint && codePoint <= 42124 || 42128 <= codePoint && codePoint <= 42182 || 43360 <= codePoint && codePoint <= 43388 || 44032 <= codePoint && codePoint <= 55203 || 55216 <= codePoint && codePoint <= 55238 || 55243 <= codePoint && codePoint <= 55291 || 63744 <= codePoint && codePoint <= 64255 || 65040 <= codePoint && codePoint <= 65049 || 65072 <= codePoint && codePoint <= 65106 || 65108 <= codePoint && codePoint <= 65126 || 65128 <= codePoint && codePoint <= 65131 || 110592 <= codePoint && codePoint <= 110593 || 127488 <= codePoint && codePoint <= 127490 || 127504 <= codePoint && codePoint <= 127546 || 127552 <= codePoint && codePoint <= 127560 || 127568 <= codePoint && codePoint <= 127569 || 131072 <= codePoint && codePoint <= 194367 || 177984 <= codePoint && codePoint <= 196605 || 196608 <= codePoint && codePoint <= 262141) { + return "W"; + } + return "N"; + } +}; +var notAsciiRegex = /[^\x20-\x7F]/; +function getStringWidth(text) { + if (!text) { + return 0; + } + if (!notAsciiRegex.test(text)) { + return text.length; + } + text = text.replace(emoji_regex_default(), " "); + let width = 0; + for (const character of text) { + const codePoint = character.codePointAt(0); + if (codePoint <= 31 || codePoint >= 127 && codePoint <= 159) { + continue; + } + if (codePoint >= 768 && codePoint <= 879) { + continue; + } + const code = eastasianwidth_default.eastAsianWidth(character); + width += code === "F" || code === "W" ? 2 : 1; + } + return width; +} +var get_string_width_default = getStringWidth; +var getDocParts = (doc) => { + if (Array.isArray(doc)) { + return doc; + } + if (doc.type !== DOC_TYPE_FILL) { + throw new Error(`Expect doc to be 'array' or '${DOC_TYPE_FILL}'.`); + } + return doc.parts; +}; +function mapDoc(doc, cb) { + if (typeof doc === "string") { + return cb(doc); + } + const mapped = /* @__PURE__ */ new Map(); + return rec(doc); + function rec(doc2) { + if (mapped.has(doc2)) { + return mapped.get(doc2); + } + const result = process2(doc2); + mapped.set(doc2, result); + return result; + } + function process2(doc2) { + switch (get_doc_type_default(doc2)) { + case DOC_TYPE_ARRAY: + return cb(doc2.map(rec)); + case DOC_TYPE_FILL: + return cb({ + ...doc2, + parts: doc2.parts.map(rec) + }); + case DOC_TYPE_IF_BREAK: + return cb({ + ...doc2, + breakContents: rec(doc2.breakContents), + flatContents: rec(doc2.flatContents) + }); + case DOC_TYPE_GROUP: { + let { + expandedStates, + contents + } = doc2; + if (expandedStates) { + expandedStates = expandedStates.map(rec); + contents = expandedStates[0]; + } else { + contents = rec(contents); + } + return cb({ + ...doc2, + contents, + expandedStates + }); + } + case DOC_TYPE_ALIGN: + case DOC_TYPE_INDENT: + case DOC_TYPE_INDENT_IF_BREAK: + case DOC_TYPE_LABEL: + case DOC_TYPE_LINE_SUFFIX: + return cb({ + ...doc2, + contents: rec(doc2.contents) + }); + case DOC_TYPE_STRING: + case DOC_TYPE_CURSOR: + case DOC_TYPE_TRIM: + case DOC_TYPE_LINE_SUFFIX_BOUNDARY: + case DOC_TYPE_LINE: + case DOC_TYPE_BREAK_PARENT: + return cb(doc2); + default: + throw new invalid_doc_error_default(doc2); + } + } +} +function findInDoc(doc, fn, defaultValue) { + let result = defaultValue; + let shouldSkipFurtherProcessing = false; + function findInDocOnEnterFn(doc2) { + if (shouldSkipFurtherProcessing) { + return false; + } + const maybeResult = fn(doc2); + if (maybeResult !== void 0) { + shouldSkipFurtherProcessing = true; + result = maybeResult; + } + } + traverse_doc_default(doc, findInDocOnEnterFn); + return result; +} +function willBreakFn(doc) { + if (doc.type === DOC_TYPE_GROUP && doc.break) { + return true; + } + if (doc.type === DOC_TYPE_LINE && doc.hard) { + return true; + } + if (doc.type === DOC_TYPE_BREAK_PARENT) { + return true; + } +} +function willBreak(doc) { + return findInDoc(doc, willBreakFn, false); +} +function breakParentGroup(groupStack) { + if (groupStack.length > 0) { + const parentGroup = at_default( + /* isOptionalObject*/ + false, + groupStack, + -1 + ); + if (!parentGroup.expandedStates && !parentGroup.break) { + parentGroup.break = "propagated"; + } + } + return null; +} +function propagateBreaks(doc) { + const alreadyVisitedSet = /* @__PURE__ */ new Set(); + const groupStack = []; + function propagateBreaksOnEnterFn(doc2) { + if (doc2.type === DOC_TYPE_BREAK_PARENT) { + breakParentGroup(groupStack); + } + if (doc2.type === DOC_TYPE_GROUP) { + groupStack.push(doc2); + if (alreadyVisitedSet.has(doc2)) { + return false; + } + alreadyVisitedSet.add(doc2); + } + } + function propagateBreaksOnExitFn(doc2) { + if (doc2.type === DOC_TYPE_GROUP) { + const group22 = groupStack.pop(); + if (group22.break) { + breakParentGroup(groupStack); + } + } + } + traverse_doc_default( + doc, + propagateBreaksOnEnterFn, + propagateBreaksOnExitFn, + /* shouldTraverseConditionalGroups */ + true + ); +} +function removeLinesFn(doc) { + if (doc.type === DOC_TYPE_LINE && !doc.hard) { + return doc.soft ? "" : " "; + } + if (doc.type === DOC_TYPE_IF_BREAK) { + return doc.flatContents; + } + return doc; +} +function removeLines(doc) { + return mapDoc(doc, removeLinesFn); +} +function stripTrailingHardlineFromParts(parts) { + parts = [...parts]; + while (parts.length >= 2 && at_default( + /* isOptionalObject*/ + false, + parts, + -2 + ).type === DOC_TYPE_LINE && at_default( + /* isOptionalObject*/ + false, + parts, + -1 + ).type === DOC_TYPE_BREAK_PARENT) { + parts.length -= 2; + } + if (parts.length > 0) { + const lastPart = stripTrailingHardlineFromDoc(at_default( + /* isOptionalObject*/ + false, + parts, + -1 + )); + parts[parts.length - 1] = lastPart; + } + return parts; +} +function stripTrailingHardlineFromDoc(doc) { + switch (get_doc_type_default(doc)) { + case DOC_TYPE_ALIGN: + case DOC_TYPE_INDENT: + case DOC_TYPE_INDENT_IF_BREAK: + case DOC_TYPE_GROUP: + case DOC_TYPE_LINE_SUFFIX: + case DOC_TYPE_LABEL: { + const contents = stripTrailingHardlineFromDoc(doc.contents); + return { + ...doc, + contents + }; + } + case DOC_TYPE_IF_BREAK: + return { + ...doc, + breakContents: stripTrailingHardlineFromDoc(doc.breakContents), + flatContents: stripTrailingHardlineFromDoc(doc.flatContents) + }; + case DOC_TYPE_FILL: + return { + ...doc, + parts: stripTrailingHardlineFromParts(doc.parts) + }; + case DOC_TYPE_ARRAY: + return stripTrailingHardlineFromParts(doc); + case DOC_TYPE_STRING: + return doc.replace(/[\n\r]*$/, ""); + case DOC_TYPE_CURSOR: + case DOC_TYPE_TRIM: + case DOC_TYPE_LINE_SUFFIX_BOUNDARY: + case DOC_TYPE_LINE: + case DOC_TYPE_BREAK_PARENT: + break; + default: + throw new invalid_doc_error_default(doc); + } + return doc; +} +function stripTrailingHardline(doc) { + return stripTrailingHardlineFromDoc(cleanDoc(doc)); +} +function cleanDocFn(doc) { + switch (get_doc_type_default(doc)) { + case DOC_TYPE_FILL: + if (doc.parts.every((part) => part === "")) { + return ""; + } + break; + case DOC_TYPE_GROUP: + if (!doc.contents && !doc.id && !doc.break && !doc.expandedStates) { + return ""; + } + if (doc.contents.type === DOC_TYPE_GROUP && doc.contents.id === doc.id && doc.contents.break === doc.break && doc.contents.expandedStates === doc.expandedStates) { + return doc.contents; + } + break; + case DOC_TYPE_ALIGN: + case DOC_TYPE_INDENT: + case DOC_TYPE_INDENT_IF_BREAK: + case DOC_TYPE_LINE_SUFFIX: + if (!doc.contents) { + return ""; + } + break; + case DOC_TYPE_IF_BREAK: + if (!doc.flatContents && !doc.breakContents) { + return ""; + } + break; + case DOC_TYPE_ARRAY: { + const parts = []; + for (const part of doc) { + if (!part) { + continue; + } + const [currentPart, ...restParts] = Array.isArray(part) ? part : [part]; + if (typeof currentPart === "string" && typeof at_default( + /* isOptionalObject*/ + false, + parts, + -1 + ) === "string") { + parts[parts.length - 1] += currentPart; + } else { + parts.push(currentPart); + } + parts.push(...restParts); + } + if (parts.length === 0) { + return ""; + } + if (parts.length === 1) { + return parts[0]; + } + return parts; + } + case DOC_TYPE_STRING: + case DOC_TYPE_CURSOR: + case DOC_TYPE_TRIM: + case DOC_TYPE_LINE_SUFFIX_BOUNDARY: + case DOC_TYPE_LINE: + case DOC_TYPE_LABEL: + case DOC_TYPE_BREAK_PARENT: + break; + default: + throw new invalid_doc_error_default(doc); + } + return doc; +} +function cleanDoc(doc) { + return mapDoc(doc, (currentDoc) => cleanDocFn(currentDoc)); +} +function replaceEndOfLine(doc, replacement = literalline) { + return mapDoc(doc, (currentDoc) => typeof currentDoc === "string" ? join(replacement, currentDoc.split("\n")) : currentDoc); +} +function canBreakFn(doc) { + if (doc.type === DOC_TYPE_LINE) { + return true; + } +} +function canBreak(doc) { + return findInDoc(doc, canBreakFn, false); +} +var MODE_BREAK = Symbol("MODE_BREAK"); +var MODE_FLAT = Symbol("MODE_FLAT"); +var CURSOR_PLACEHOLDER = Symbol("cursor"); +function rootIndent() { + return { + value: "", + length: 0, + queue: [] + }; +} +function makeIndent(ind, options) { + return generateInd(ind, { + type: "indent" + }, options); +} +function makeAlign(indent22, widthOrDoc, options) { + if (widthOrDoc === Number.NEGATIVE_INFINITY) { + return indent22.root || rootIndent(); + } + if (widthOrDoc < 0) { + return generateInd(indent22, { + type: "dedent" + }, options); + } + if (!widthOrDoc) { + return indent22; + } + if (widthOrDoc.type === "root") { + return { + ...indent22, + root: indent22 + }; + } + const alignType = typeof widthOrDoc === "string" ? "stringAlign" : "numberAlign"; + return generateInd(indent22, { + type: alignType, + n: widthOrDoc + }, options); +} +function generateInd(ind, newPart, options) { + const queue = newPart.type === "dedent" ? ind.queue.slice(0, -1) : [...ind.queue, newPart]; + let value = ""; + let length = 0; + let lastTabs = 0; + let lastSpaces = 0; + for (const part of queue) { + switch (part.type) { + case "indent": + flush(); + if (options.useTabs) { + addTabs(1); + } else { + addSpaces(options.tabWidth); + } + break; + case "stringAlign": + flush(); + value += part.n; + length += part.n.length; + break; + case "numberAlign": + lastTabs += 1; + lastSpaces += part.n; + break; + default: + throw new Error(`Unexpected type '${part.type}'`); + } + } + flushSpaces(); + return { + ...ind, + value, + length, + queue + }; + function addTabs(count) { + value += " ".repeat(count); + length += options.tabWidth * count; + } + function addSpaces(count) { + value += " ".repeat(count); + length += count; + } + function flush() { + if (options.useTabs) { + flushTabs(); + } else { + flushSpaces(); + } + } + function flushTabs() { + if (lastTabs > 0) { + addTabs(lastTabs); + } + resetLast(); + } + function flushSpaces() { + if (lastSpaces > 0) { + addSpaces(lastSpaces); + } + resetLast(); + } + function resetLast() { + lastTabs = 0; + lastSpaces = 0; + } +} +function trim2(out) { + let trimCount = 0; + let cursorCount = 0; + let outIndex = out.length; + outer: + while (outIndex--) { + const last = out[outIndex]; + if (last === CURSOR_PLACEHOLDER) { + cursorCount++; + continue; + } + if (false) { + throw new Error(`Unexpected value in trim: '${typeof last}'`); + } + for (let charIndex = last.length - 1; charIndex >= 0; charIndex--) { + const char = last[charIndex]; + if (char === " " || char === " ") { + trimCount++; + } else { + out[outIndex] = last.slice(0, charIndex + 1); + break outer; + } + } + } + if (trimCount > 0 || cursorCount > 0) { + out.length = outIndex + 1; + while (cursorCount-- > 0) { + out.push(CURSOR_PLACEHOLDER); + } + } + return trimCount; +} +function fits(next, restCommands, width, hasLineSuffix, groupModeMap, mustBeFlat) { + if (width === Number.POSITIVE_INFINITY) { + return true; + } + let restIdx = restCommands.length; + const cmds = [next]; + const out = []; + while (width >= 0) { + if (cmds.length === 0) { + if (restIdx === 0) { + return true; + } + cmds.push(restCommands[--restIdx]); + continue; + } + const { + mode, + doc + } = cmds.pop(); + switch (get_doc_type_default(doc)) { + case DOC_TYPE_STRING: + out.push(doc); + width -= get_string_width_default(doc); + break; + case DOC_TYPE_ARRAY: + case DOC_TYPE_FILL: { + const parts = getDocParts(doc); + for (let i = parts.length - 1; i >= 0; i--) { + cmds.push({ + mode, + doc: parts[i] + }); + } + break; + } + case DOC_TYPE_INDENT: + case DOC_TYPE_ALIGN: + case DOC_TYPE_INDENT_IF_BREAK: + case DOC_TYPE_LABEL: + cmds.push({ + mode, + doc: doc.contents + }); + break; + case DOC_TYPE_TRIM: + width += trim2(out); + break; + case DOC_TYPE_GROUP: { + if (mustBeFlat && doc.break) { + return false; + } + const groupMode = doc.break ? MODE_BREAK : mode; + const contents = doc.expandedStates && groupMode === MODE_BREAK ? at_default( + /* isOptionalObject*/ + false, + doc.expandedStates, + -1 + ) : doc.contents; + cmds.push({ + mode: groupMode, + doc: contents + }); + break; + } + case DOC_TYPE_IF_BREAK: { + const groupMode = doc.groupId ? groupModeMap[doc.groupId] || MODE_FLAT : mode; + const contents = groupMode === MODE_BREAK ? doc.breakContents : doc.flatContents; + if (contents) { + cmds.push({ + mode, + doc: contents + }); + } + break; + } + case DOC_TYPE_LINE: + if (mode === MODE_BREAK || doc.hard) { + return true; + } + if (!doc.soft) { + out.push(" "); + width--; + } + break; + case DOC_TYPE_LINE_SUFFIX: + hasLineSuffix = true; + break; + case DOC_TYPE_LINE_SUFFIX_BOUNDARY: + if (hasLineSuffix) { + return false; + } + break; + } + } + return false; +} +function printDocToString(doc, options) { + const groupModeMap = {}; + const width = options.printWidth; + const newLine = convertEndOfLineToChars(options.endOfLine); + let pos = 0; + const cmds = [{ + ind: rootIndent(), + mode: MODE_BREAK, + doc + }]; + const out = []; + let shouldRemeasure = false; + const lineSuffix22 = []; + let printedCursorCount = 0; + propagateBreaks(doc); + while (cmds.length > 0) { + const { + ind, + mode, + doc: doc2 + } = cmds.pop(); + switch (get_doc_type_default(doc2)) { + case DOC_TYPE_STRING: { + const formatted = newLine !== "\n" ? string_replace_all_default( + /* isOptionalObject*/ + false, + doc2, + "\n", + newLine + ) : doc2; + out.push(formatted); + if (cmds.length > 0) { + pos += get_string_width_default(formatted); + } + break; + } + case DOC_TYPE_ARRAY: + for (let i = doc2.length - 1; i >= 0; i--) { + cmds.push({ + ind, + mode, + doc: doc2[i] + }); + } + break; + case DOC_TYPE_CURSOR: + if (printedCursorCount >= 2) { + throw new Error("There are too many 'cursor' in doc."); + } + out.push(CURSOR_PLACEHOLDER); + printedCursorCount++; + break; + case DOC_TYPE_INDENT: + cmds.push({ + ind: makeIndent(ind, options), + mode, + doc: doc2.contents + }); + break; + case DOC_TYPE_ALIGN: + cmds.push({ + ind: makeAlign(ind, doc2.n, options), + mode, + doc: doc2.contents + }); + break; + case DOC_TYPE_TRIM: + pos -= trim2(out); + break; + case DOC_TYPE_GROUP: + switch (mode) { + case MODE_FLAT: + if (!shouldRemeasure) { + cmds.push({ + ind, + mode: doc2.break ? MODE_BREAK : MODE_FLAT, + doc: doc2.contents + }); + break; + } + case MODE_BREAK: { + shouldRemeasure = false; + const next = { + ind, + mode: MODE_FLAT, + doc: doc2.contents + }; + const rem = width - pos; + const hasLineSuffix = lineSuffix22.length > 0; + if (!doc2.break && fits(next, cmds, rem, hasLineSuffix, groupModeMap)) { + cmds.push(next); + } else { + if (doc2.expandedStates) { + const mostExpanded = at_default( + /* isOptionalObject*/ + false, + doc2.expandedStates, + -1 + ); + if (doc2.break) { + cmds.push({ + ind, + mode: MODE_BREAK, + doc: mostExpanded + }); + break; + } else { + for (let i = 1; i < doc2.expandedStates.length + 1; i++) { + if (i >= doc2.expandedStates.length) { + cmds.push({ + ind, + mode: MODE_BREAK, + doc: mostExpanded + }); + break; + } else { + const state = doc2.expandedStates[i]; + const cmd = { + ind, + mode: MODE_FLAT, + doc: state + }; + if (fits(cmd, cmds, rem, hasLineSuffix, groupModeMap)) { + cmds.push(cmd); + break; + } + } + } + } + } else { + cmds.push({ + ind, + mode: MODE_BREAK, + doc: doc2.contents + }); + } + } + break; + } + } + if (doc2.id) { + groupModeMap[doc2.id] = at_default( + /* isOptionalObject*/ + false, + cmds, + -1 + ).mode; + } + break; + case DOC_TYPE_FILL: { + const rem = width - pos; + const { + parts + } = doc2; + if (parts.length === 0) { + break; + } + const [content, whitespace2] = parts; + const contentFlatCmd = { + ind, + mode: MODE_FLAT, + doc: content + }; + const contentBreakCmd = { + ind, + mode: MODE_BREAK, + doc: content + }; + const contentFits = fits(contentFlatCmd, [], rem, lineSuffix22.length > 0, groupModeMap, true); + if (parts.length === 1) { + if (contentFits) { + cmds.push(contentFlatCmd); + } else { + cmds.push(contentBreakCmd); + } + break; + } + const whitespaceFlatCmd = { + ind, + mode: MODE_FLAT, + doc: whitespace2 + }; + const whitespaceBreakCmd = { + ind, + mode: MODE_BREAK, + doc: whitespace2 + }; + if (parts.length === 2) { + if (contentFits) { + cmds.push(whitespaceFlatCmd, contentFlatCmd); + } else { + cmds.push(whitespaceBreakCmd, contentBreakCmd); + } + break; + } + parts.splice(0, 2); + const remainingCmd = { + ind, + mode, + doc: fill(parts) + }; + const secondContent = parts[0]; + const firstAndSecondContentFlatCmd = { + ind, + mode: MODE_FLAT, + doc: [content, whitespace2, secondContent] + }; + const firstAndSecondContentFits = fits(firstAndSecondContentFlatCmd, [], rem, lineSuffix22.length > 0, groupModeMap, true); + if (firstAndSecondContentFits) { + cmds.push(remainingCmd, whitespaceFlatCmd, contentFlatCmd); + } else if (contentFits) { + cmds.push(remainingCmd, whitespaceBreakCmd, contentFlatCmd); + } else { + cmds.push(remainingCmd, whitespaceBreakCmd, contentBreakCmd); + } + break; + } + case DOC_TYPE_IF_BREAK: + case DOC_TYPE_INDENT_IF_BREAK: { + const groupMode = doc2.groupId ? groupModeMap[doc2.groupId] : mode; + if (groupMode === MODE_BREAK) { + const breakContents = doc2.type === DOC_TYPE_IF_BREAK ? doc2.breakContents : doc2.negate ? doc2.contents : indent(doc2.contents); + if (breakContents) { + cmds.push({ + ind, + mode, + doc: breakContents + }); + } + } + if (groupMode === MODE_FLAT) { + const flatContents = doc2.type === DOC_TYPE_IF_BREAK ? doc2.flatContents : doc2.negate ? indent(doc2.contents) : doc2.contents; + if (flatContents) { + cmds.push({ + ind, + mode, + doc: flatContents + }); + } + } + break; + } + case DOC_TYPE_LINE_SUFFIX: + lineSuffix22.push({ + ind, + mode, + doc: doc2.contents + }); + break; + case DOC_TYPE_LINE_SUFFIX_BOUNDARY: + if (lineSuffix22.length > 0) { + cmds.push({ + ind, + mode, + doc: hardlineWithoutBreakParent + }); + } + break; + case DOC_TYPE_LINE: + switch (mode) { + case MODE_FLAT: + if (!doc2.hard) { + if (!doc2.soft) { + out.push(" "); + pos += 1; + } + break; + } else { + shouldRemeasure = true; + } + case MODE_BREAK: + if (lineSuffix22.length > 0) { + cmds.push({ + ind, + mode, + doc: doc2 + }, ...lineSuffix22.reverse()); + lineSuffix22.length = 0; + break; + } + if (doc2.literal) { + if (ind.root) { + out.push(newLine, ind.root.value); + pos = ind.root.length; + } else { + out.push(newLine); + pos = 0; + } + } else { + pos -= trim2(out); + out.push(newLine + ind.value); + pos = ind.length; + } + break; + } + break; + case DOC_TYPE_LABEL: + cmds.push({ + ind, + mode, + doc: doc2.contents + }); + break; + case DOC_TYPE_BREAK_PARENT: + break; + default: + throw new invalid_doc_error_default(doc2); + } + if (cmds.length === 0 && lineSuffix22.length > 0) { + cmds.push(...lineSuffix22.reverse()); + lineSuffix22.length = 0; + } + } + const cursorPlaceholderIndex = out.indexOf(CURSOR_PLACEHOLDER); + if (cursorPlaceholderIndex !== -1) { + const otherCursorPlaceholderIndex = out.indexOf(CURSOR_PLACEHOLDER, cursorPlaceholderIndex + 1); + const beforeCursor = out.slice(0, cursorPlaceholderIndex).join(""); + const aroundCursor = out.slice(cursorPlaceholderIndex + 1, otherCursorPlaceholderIndex).join(""); + const afterCursor = out.slice(otherCursorPlaceholderIndex + 1).join(""); + return { + formatted: beforeCursor + aroundCursor + afterCursor, + cursorNodeStart: beforeCursor.length, + cursorNodeText: aroundCursor + }; + } + return { + formatted: out.join("") + }; +} +var builders = { + join, + line, + softline, + hardline, + literalline, + group, + conditionalGroup, + fill, + lineSuffix, + lineSuffixBoundary, + cursor, + breakParent, + ifBreak, + trim, + indent, + indentIfBreak, + align, + addAlignmentToDoc, + markAsRoot, + dedentToRoot, + dedent, + hardlineWithoutBreakParent, + literallineWithoutBreakParent, + label, + // TODO: Remove this in v4 + concat: (parts) => parts +}; +var printer = { printDocToString }; +var utils = { + willBreak, + traverseDoc: traverse_doc_default, + findInDoc, + mapDoc, + removeLines, + stripTrailingHardline, + replaceEndOfLine, + canBreak +}; + +// ../unified-latex-util-print-raw/dist/index.js +var linebreak = Symbol("linebreak"); +var ESCAPE = "\\"; +function _printRaw(node) { + if (typeof node === "string") { + return [node]; + } + if (Array.isArray(node)) { + return [].concat( + ...node.map((n) => _printRaw(n)) + ); + } + let argsString, escape; + switch (node.type) { + case "root": + return _printRaw(node.content); + case "argument": + return [node.openMark, ..._printRaw(node.content), node.closeMark]; + case "comment": + var suffix = node.suffixParbreak ? "" : linebreak; + var leadingWhitespace = ""; + if (node.sameline && node.leadingWhitespace) { + leadingWhitespace = " "; + } + if (node.sameline) { + return [ + leadingWhitespace, + "%", + ..._printRaw(node.content), + suffix + ]; + } + return [linebreak, "%", ..._printRaw(node.content), suffix]; + case "environment": + case "mathenv": + case "verbatim": + var env = _printRaw(node.env); + var envStart = [ESCAPE + "begin{", ...env, "}"]; + var envEnd = [ESCAPE + "end{", ...env, "}"]; + argsString = node.args == null ? [] : _printRaw(node.args); + return [ + ...envStart, + ...argsString, + ..._printRaw(node.content), + ...envEnd + ]; + case "displaymath": + return [ESCAPE + "[", ..._printRaw(node.content), ESCAPE + "]"]; + case "group": + return ["{", ..._printRaw(node.content), "}"]; + case "inlinemath": + return ["$", ..._printRaw(node.content), "$"]; + case "macro": + argsString = node.args == null ? [] : _printRaw(node.args); + escape = node.escapeToken == null ? ESCAPE : node.escapeToken; + return [escape, ..._printRaw(node.content), ...argsString]; + case "parbreak": + return [linebreak, linebreak]; + case "string": + return [node.content]; + case "verb": + return [ + ESCAPE, + node.env, + node.escape, + ..._printRaw(node.content), + node.escape + ]; + case "whitespace": + return [" "]; + default: + console.warn( + "Cannot find render for node ", + node, + `(of type ${typeof node})` + ); + return ["" + node]; + } +} +function printRaw(node, options) { + const asArray = options != null ? options.asArray : false; + const printedTokens = _printRaw(node); + if (asArray) { + return printedTokens; + } + return printedTokens.map((x) => x === linebreak ? "\n" : x).join(""); +} + +// ../unified-latex-util-match/dist/index.js +function createMacroMatcher(macros17) { + const macrosHash = Array.isArray(macros17) ? macros17.length > 0 ? typeof macros17[0] === "string" ? Object.fromEntries( + macros17.map((macro2) => { + if (typeof macro2 !== "string") { + throw new Error("Wrong branch of map function"); + } + return [macro2, {}]; + }) + ) : Object.fromEntries( + macros17.map((macro2) => { + if (typeof macro2 === "string") { + throw new Error("Wrong branch of map function"); + } + if (macro2.escapeToken != null) { + return [ + macro2.content, + { escapeToken: macro2.escapeToken } + ]; + } + return [macro2.content, {}]; + }) + ) : {} : macros17; + return function matchAgainstMacros(node) { + if (node == null || node.type !== "macro") { + return false; + } + const spec = macrosHash[node.content]; + if (!spec) { + return false; + } + if (typeof spec === "object" && "escapeToken" in spec) { + return spec.escapeToken == null || spec.escapeToken === node.escapeToken; + } + return true; + }; +} +function createEnvironmentMatcher(macros17) { + const environmentsHash = Array.isArray(macros17) ? Object.fromEntries( + macros17.map((str) => { + return [str, {}]; + }) + ) : macros17; + return function matchAgainstEnvironments(node) { + if (!match.anyEnvironment(node)) { + return false; + } + const envName = printRaw(node.env); + const spec = environmentsHash[envName]; + if (!spec) { + return false; + } + return true; + }; +} +var match = { + macro(node, macroName) { + if (node == null) { + return false; + } + return node.type === "macro" && (macroName == null || node.content === macroName); + }, + anyMacro(node) { + return match.macro(node); + }, + environment(node, envName) { + if (node == null) { + return false; + } + return (node.type === "environment" || node.type === "mathenv") && (envName == null || printRaw(node.env) === envName); + }, + anyEnvironment(node) { + return match.environment(node); + }, + comment(node) { + if (node == null) { + return false; + } + return node.type === "comment"; + }, + parbreak(node) { + if (node == null) { + return false; + } + return node.type === "parbreak"; + }, + whitespace(node) { + if (node == null) { + return false; + } + return node.type === "whitespace"; + }, + /** + * Matches whitespace or a comment with leading whitespace. + */ + whitespaceLike(node) { + if (node == null) { + return false; + } + return node.type === "whitespace" || node.type === "whitespace" && node.leadingWhitespace === true; + }, + string(node, value) { + if (node == null) { + return false; + } + return node.type === "string" && (value == null || node.content === value); + }, + anyString(node) { + return match.string(node); + }, + group(node) { + if (node == null) { + return false; + } + return node.type === "group"; + }, + argument(node) { + if (node == null) { + return false; + } + return node.type === "argument"; + }, + blankArgument(node) { + if (!match.argument(node)) { + return false; + } + return node.openMark === "" && node.closeMark === "" && node.content.length === 0; + }, + math(node) { + if (node == null) { + return false; + } + return node.type === "displaymath" || node.type === "inlinemath"; + }, + createMacroMatcher, + createEnvironmentMatcher +}; +var { + anyEnvironment, + anyMacro, + anyString, + argument, + blankArgument, + comment, + environment, + group: group2, + macro, + math, + parbreak, + string, + whitespace +} = match; + +// libs/printer/common.ts +function formatEnvSurround(node) { + const env = printRaw(node.env); + return { + envName: env, + start: ESCAPE2 + "begin{" + env + "}", + end: ESCAPE2 + "end{" + env + "}" + }; +} +function isLineType(elm) { + if (elm == null || typeof elm === "string") { + return false; + } + if (Array.isArray(elm)) { + return isLineType(elm[0]); + } + if (elm.type === "concat") { + return isLineType(elm.parts); + } + return elm.type === "line"; +} +function joinWithSoftline(arr) { + if (arr.length === 0 || arr.length === 1) { + return arr; + } + const ret = [arr[0]]; + for (let i = 1; i < arr.length; i++) { + const prevNode = arr[i - 1]; + const nextNode = arr[i]; + if (!isLineType(prevNode) && !isLineType(nextNode)) { + ret.push(softline2); + } + ret.push(nextNode); + } + return ret; +} +function getNodeInfo(node, options) { + if (!node) { + return { renderInfo: {} }; + } + const renderInfo = node._renderInfo || {}; + const previousNode = options.referenceMap && options.referenceMap.getPreviousNode(node); + const nextNode = options.referenceMap && options.referenceMap.getNextNode(node); + const renderCache = options.referenceMap && options.referenceMap.getRenderCache(node); + return { + renderInfo, + renderCache, + previousNode, + nextNode, + referenceMap: options.referenceMap + }; +} +var ESCAPE2 = "\\"; +var { + group: group3, + fill: fill2, + ifBreak: ifBreak2, + line: line2, + softline: softline2, + hardline: hardline2, + lineSuffix: lineSuffix2, + lineSuffixBoundary: lineSuffixBoundary2, + breakParent: breakParent2, + indent: indent2, + markAsRoot: markAsRoot2, + join: join2 +} = builders; +function formatDocArray(nodes, docArray, options) { + const ret = []; + for (let i = 0; i < nodes.length; i++) { + const rawNode = nodes[i]; + const printedNode = docArray[i]; + const { renderInfo, referenceMap, previousNode, nextNode } = getNodeInfo(rawNode, options); + const renderCache = referenceMap && referenceMap.getRenderCache(rawNode); + switch (rawNode.type) { + case "comment": + if (!rawNode.sameline && previousNode && !match.comment(previousNode) && !match.parbreak(previousNode)) { + ret.push(hardline2); + } + ret.push(printedNode); + if (nextNode && !rawNode.suffixParbreak) { + ret.push(hardline2); + } + break; + case "environment": + case "displaymath": + case "mathenv": + if (previousNode && (previousNode == null ? void 0 : previousNode.type) !== "parbreak") { + if (ret[ret.length - 1] === line2) { + ret.pop(); + } + if (ret[ret.length - 1] !== hardline2) { + ret.push(hardline2); + } + } + ret.push(printedNode); + if ((nextNode == null ? void 0 : nextNode.type) === "whitespace") { + ret.push(hardline2); + i++; + } + break; + case "macro": + if (renderInfo.breakBefore || renderInfo.breakAround) { + if (previousNode) { + if (ret[ret.length - 1] === line2 || ret[ret.length - 1] === hardline2) { + ret.pop(); + ret.push(hardline2); + } else if (!match.comment(previousNode) && !match.parbreak(previousNode)) { + ret.push(hardline2); + } + } + } + if (renderInfo.inParMode && !renderInfo.hangingIndent && renderCache) { + ret.push( + renderCache.content, + ...renderCache.rawArgs || [] + ); + } else { + ret.push(printedNode); + } + if (renderInfo.breakAfter || renderInfo.breakAround) { + if (nextNode) { + if (match.whitespace(nextNode)) { + ret.push(hardline2); + i++; + } else if (match.parbreak(nextNode)) { + } else if (!match.comment(nextNode)) { + ret.push(hardline2); + } + } + } + break; + case "parbreak": + ret.push(hardline2, hardline2); + break; + default: + ret.push(printedNode); + break; + } + } + return ret; +} + +// libs/zip.ts +function zip(array1, array2) { + const ret = []; + const len = Math.min(array1.length, array2.length); + for (let i = 0; i < len; i++) { + ret.push([array1[i], array2[i]]); + } + return ret; +} + +// libs/printer/macro.ts +function printMacro(path2, print, options) { + const node = path2.getNode(); + const { renderInfo, previousNode, nextNode, referenceMap } = getNodeInfo( + node, + options + ); + const content = (node.escapeToken != null ? node.escapeToken : ESCAPE2) + node.content; + const args = node.args ? path2.map(print, "args") : []; + const rawArgs = []; + for (const [arg2, printedArg] of zip(node.args || [], args)) { + const renderCache = referenceMap && referenceMap.getRenderCache(arg2); + if (renderInfo.inParMode && renderCache) { + rawArgs.push(...renderCache); + } else { + rawArgs.push(printedArg); + } + } + if (referenceMap) { + referenceMap.setRenderCache(node, { rawArgs, content }); + } + if (renderInfo.hangingIndent) { + return indent2(fill2([content, ...rawArgs])); + } + return group3([content, ...rawArgs]); +} + +// ../unified-latex-util-visit/dist/index.js +function listMathChildren(node) { + const NULL_RETURN = { enter: [], leave: [] }; + if (Array.isArray(node)) { + return NULL_RETURN; + } + if (match.math(node)) { + return { enter: ["content"], leave: [] }; + } + const renderInfo = node._renderInfo || {}; + if (renderInfo.inMathMode == null) { + return NULL_RETURN; + } + if (match.macro(node)) { + if (renderInfo.inMathMode === true) { + return { enter: ["args"], leave: [] }; + } else if (renderInfo.inMathMode === false) { + return { enter: [], leave: ["args"] }; + } + } + if (match.environment(node)) { + if (renderInfo.inMathMode === true) { + return { enter: ["content"], leave: [] }; + } else { + return { enter: [], leave: ["content"] }; + } + } + return NULL_RETURN; +} +var CONTINUE = Symbol("continue"); +var SKIP = Symbol("skip"); +var EXIT = Symbol("exit"); +var DEFAULT_CONTEXT = { + inMathMode: false, + hasMathModeAncestor: false +}; +function visit(tree, visitor, options) { + const { + startingContext = DEFAULT_CONTEXT, + test = () => true, + includeArrays = false + } = options || {}; + let enter; + let leave; + if (typeof visitor === "function") { + enter = visitor; + } else if (visitor && typeof visitor === "object") { + enter = visitor.enter; + leave = visitor.leave; + } + walk(tree, { + key: void 0, + index: void 0, + parents: [], + containingArray: void 0, + context: { ...startingContext } + }); + function walk(node, { key, index: index2, parents, context, containingArray }) { + const nodePassesTest = includeArrays ? test(node, { key, index: index2, parents, context, containingArray }) : !Array.isArray(node) && test(node, { key, index: index2, parents, context, containingArray }); + const result = enter && nodePassesTest ? toResult( + enter(node, { + key, + index: index2, + parents, + context, + containingArray + }) + ) : [CONTINUE]; + if (result[0] === EXIT) { + return result; + } + if (result[0] === SKIP) { + return leave && nodePassesTest ? toResult( + leave(node, { + key, + index: index2, + parents, + context, + containingArray + }) + ) : result; + } + if (Array.isArray(node)) { + for (let index22 = 0; index22 > -1 && index22 < node.length; index22++) { + const item = node[index22]; + const result2 = walk(item, { + key, + index: index22, + parents, + context, + containingArray: node + }); + if (result2[0] === EXIT) { + return result2; + } + if (typeof result2[1] === "number") { + index22 = result2[1] - 1; + } + } + } else { + let childProps = ["content", "args"]; + switch (node.type) { + case "macro": + childProps = ["args"]; + break; + case "comment": + case "string": + case "verb": + case "verbatim": + childProps = []; + break; + default: + break; + } + const mathModeProps = listMathChildren(node); + for (const key2 of childProps) { + const value = node[key2]; + const grandparents = [node].concat(parents); + if (value == null) { + continue; + } + const newContext = { ...context }; + if (mathModeProps.enter.includes(key2)) { + newContext.inMathMode = true; + newContext.hasMathModeAncestor = true; + } else if (mathModeProps.leave.includes(key2)) { + newContext.inMathMode = false; + } + const result2 = walk(value, { + key: key2, + index: void 0, + parents: grandparents, + context: newContext, + containingArray: void 0 + }); + if (result2[0] === EXIT) { + return result2; + } + } + } + return leave && nodePassesTest ? toResult( + leave(node, { + key, + index: index2, + parents, + context, + containingArray + }) + ) : result; + } +} +function toResult(value) { + if (value == null) { + return [CONTINUE]; + } + if (Array.isArray(value)) { + return value; + } + if (typeof value === "number") { + return [CONTINUE, value]; + } + return [value]; +} + +// ../unified-latex-util-trim/dist/index.js +function trim3(nodes) { + if (!Array.isArray(nodes)) { + console.warn("Trying to trim a non-array ast", nodes); + return nodes; + } + const { trimmedStart } = trimStart(nodes); + const { trimmedEnd } = trimEnd(nodes); + return { trimmedStart, trimmedEnd }; +} +function trimStart(nodes) { + const { start } = amountOfLeadingAndTrailingWhitespace(nodes); + nodes.splice(0, start); + for (const leadingToken of nodes) { + if (!match.comment(leadingToken)) { + break; + } + if (leadingToken.leadingWhitespace || leadingToken.sameline) { + leadingToken.leadingWhitespace = false; + delete leadingToken.position; + } + if (start > 0 && leadingToken.sameline) { + leadingToken.sameline = false; + delete leadingToken.position; + } + } + return { trimmedStart: start }; +} +function trimEnd(nodes) { + const { end } = amountOfLeadingAndTrailingWhitespace(nodes); + nodes.splice(nodes.length - end, end); + for (let i = nodes.length - 1; i >= 0; i--) { + const trailingToken = nodes[i]; + if (!match.comment(trailingToken)) { + break; + } + delete trailingToken.suffixParbreak; + if (match.comment(trailingToken) && trailingToken.leadingWhitespace && !trailingToken.sameline) { + trailingToken.leadingWhitespace = false; + delete trailingToken.position; + } + } + return { trimmedEnd: end }; +} +function amountOfLeadingAndTrailingWhitespace(ast) { + let start = 0; + let end = 0; + for (const node of ast) { + if (match.whitespace(node) || match.parbreak(node)) { + start++; + } else { + break; + } + } + if (start === ast.length) { + return { start, end: 0 }; + } + for (let i = ast.length - 1; i >= 0; i--) { + const node = ast[i]; + if (match.whitespace(node) || match.parbreak(node)) { + end++; + } else { + break; + } + } + return { start, end }; +} +var unifiedLatexTrimEnvironmentContents = function unifiedLatexTrimEnvironmentContents2() { + return (tree) => { + visit(tree, (node) => { + if (!(match.math(node) || match.anyEnvironment(node))) { + return; + } + let firstNode = node.content[0]; + if (match.comment(firstNode) && firstNode.sameline) { + firstNode.suffixParbreak = false; + trimEnd(node.content); + const { trimmedStart } = trimStart(node.content.slice(1)); + node.content.splice(1, trimmedStart); + } else { + trim3(node.content); + } + }); + }; +}; +var unifiedLatexTrimRoot = function unifiedLatexTrimRoot2() { + return (tree) => { + trim3(tree.content); + }; +}; + +// ../unified-latex-util-pegjs/dist/index.js +function decorateArrayForPegjs(array) { + array.charAt = function(i) { + return this[i]; + }; + array.charCodeAt = () => 0; + array.substring = function(i, j) { + return this.slice(i, j); + }; + array.replace = function(a, b) { + const ret = JSON.stringify(this); + return ret.replace(a, b); + }; + return array; +} +var latex_default = ( + // Generated by Peggy 2.0.1. + // + // https://peggyjs.org/ + function() { + "use strict"; + function peg$subclass(child, parent) { + function C() { + this.constructor = child; + } + C.prototype = parent.prototype; + child.prototype = new C(); + } + function peg$SyntaxError(message, expected, found, location) { + var self = Error.call(this, message); + if (Object.setPrototypeOf) { + Object.setPrototypeOf(self, peg$SyntaxError.prototype); + } + self.expected = expected; + self.found = found; + self.location = location; + self.name = "SyntaxError"; + return self; + } + peg$subclass(peg$SyntaxError, Error); + function peg$padEnd(str, targetLength, padString) { + padString = padString || " "; + if (str.length > targetLength) { + return str; + } + targetLength -= str.length; + padString += padString.repeat(targetLength); + return str + padString.slice(0, targetLength); + } + peg$SyntaxError.prototype.format = function(sources) { + var str = "Error: " + this.message; + if (this.location) { + var src = null; + var k; + for (k = 0; k < sources.length; k++) { + if (sources[k].source === this.location.source) { + src = sources[k].text.split(/\r\n|\n|\r/g); + break; + } + } + var s2 = this.location.start; + var loc = this.location.source + ":" + s2.line + ":" + s2.column; + if (src) { + var e = this.location.end; + var filler = peg$padEnd("", s2.line.toString().length, " "); + var line5 = src[s2.line - 1]; + var last = s2.line === e.line ? e.column : line5.length + 1; + var hatLen = last - s2.column || 1; + str += "\n --> " + loc + "\n" + filler + " |\n" + s2.line + " | " + line5 + "\n" + filler + " | " + peg$padEnd("", s2.column - 1, " ") + peg$padEnd("", hatLen, "^"); + } else { + str += "\n at " + loc; + } + } + return str; + }; + peg$SyntaxError.buildMessage = function(expected, found) { + var DESCRIBE_EXPECTATION_FNS = { + literal: function(expectation) { + return '"' + literalEscape(expectation.text) + '"'; + }, + class: function(expectation) { + var escapedParts = expectation.parts.map(function(part) { + return Array.isArray(part) ? classEscape(part[0]) + "-" + classEscape(part[1]) : classEscape(part); + }); + return "[" + (expectation.inverted ? "^" : "") + escapedParts.join("") + "]"; + }, + any: function() { + return "any character"; + }, + end: function() { + return "end of input"; + }, + other: function(expectation) { + return expectation.description; + } + }; + function hex(ch) { + return ch.charCodeAt(0).toString(16).toUpperCase(); + } + function literalEscape(s2) { + return s2.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\0/g, "\\0").replace(/\t/g, "\\t").replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/[\x00-\x0F]/g, function(ch) { + return "\\x0" + hex(ch); + }).replace(/[\x10-\x1F\x7F-\x9F]/g, function(ch) { + return "\\x" + hex(ch); + }); + } + function classEscape(s2) { + return s2.replace(/\\/g, "\\\\").replace(/\]/g, "\\]").replace(/\^/g, "\\^").replace(/-/g, "\\-").replace(/\0/g, "\\0").replace(/\t/g, "\\t").replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/[\x00-\x0F]/g, function(ch) { + return "\\x0" + hex(ch); + }).replace(/[\x10-\x1F\x7F-\x9F]/g, function(ch) { + return "\\x" + hex(ch); + }); + } + function describeExpectation(expectation) { + return DESCRIBE_EXPECTATION_FNS[expectation.type](expectation); + } + function describeExpected(expected2) { + var descriptions = expected2.map(describeExpectation); + var i, j; + descriptions.sort(); + if (descriptions.length > 0) { + for (i = 1, j = 1; i < descriptions.length; i++) { + if (descriptions[i - 1] !== descriptions[i]) { + descriptions[j] = descriptions[i]; + j++; + } + } + descriptions.length = j; + } + switch (descriptions.length) { + case 1: + return descriptions[0]; + case 2: + return descriptions[0] + " or " + descriptions[1]; + default: + return descriptions.slice(0, -1).join(", ") + ", or " + descriptions[descriptions.length - 1]; + } + } + function describeFound(found2) { + return found2 ? '"' + literalEscape(found2) + '"' : "end of input"; + } + return "Expected " + describeExpected(expected) + " but " + describeFound(found) + " found."; + }; + function peg$parse(input, options) { + options = options !== void 0 ? options : {}; + var peg$FAILED = {}; + var peg$source = options.grammarSource; + var peg$startRuleFunctions = { document: peg$parsedocument, math: peg$parsemath }; + var peg$startRuleFunction = peg$parsedocument; + var peg$c0 = "%"; + var peg$c1 = "."; + var peg$c2 = "verb*"; + var peg$c3 = "verb"; + var peg$c4 = "["; + var peg$c5 = "]"; + var peg$c6 = "lstinline"; + var peg$c7 = "mintinline"; + var peg$c8 = "mint"; + var peg$c9 = "minted"; + var peg$c10 = "verbatim*"; + var peg$c11 = "verbatim"; + var peg$c12 = "filecontents*"; + var peg$c13 = "filecontents"; + var peg$c14 = "comment"; + var peg$c15 = "lstlisting"; + var peg$c16 = "("; + var peg$c17 = ")"; + var peg$c18 = "begin"; + var peg$c19 = "end"; + var peg$c20 = "equation*"; + var peg$c21 = "equation"; + var peg$c22 = "align*"; + var peg$c23 = "align"; + var peg$c24 = "alignat*"; + var peg$c25 = "alignat"; + var peg$c26 = "gather*"; + var peg$c27 = "gather"; + var peg$c28 = "multline*"; + var peg$c29 = "multline"; + var peg$c30 = "flalign*"; + var peg$c31 = "flalign"; + var peg$c32 = "split"; + var peg$c33 = "math"; + var peg$c34 = "displaymath"; + var peg$c35 = "\\"; + var peg$c36 = "{"; + var peg$c37 = "}"; + var peg$c38 = "$"; + var peg$c39 = "&"; + var peg$c40 = "\r"; + var peg$c41 = "\n"; + var peg$c42 = "\r\n"; + var peg$c43 = "#"; + var peg$c44 = "^"; + var peg$c45 = "_"; + var peg$c46 = "\0"; + var peg$r0 = /^[^ \t\n\r]/; + var peg$r1 = /^[ \t]/; + var peg$r2 = /^[a-zA-Z]/; + var peg$r3 = /^[0-9]/; + var peg$r4 = /^[.,;:\-*\/()!?=+<>[\]`'"~]/; + var peg$e0 = peg$otherExpectation("document"); + var peg$e1 = peg$otherExpectation("math"); + var peg$e2 = peg$otherExpectation("token"); + var peg$e3 = peg$anyExpectation(); + var peg$e4 = peg$otherExpectation("parbreak"); + var peg$e5 = peg$otherExpectation("math token"); + var peg$e6 = peg$otherExpectation("nonchar token"); + var peg$e7 = peg$literalExpectation("%", false); + var peg$e8 = peg$otherExpectation("whitespace"); + var peg$e9 = peg$otherExpectation("number"); + var peg$e10 = peg$literalExpectation(".", false); + var peg$e11 = peg$otherExpectation("special macro"); + var peg$e12 = peg$literalExpectation("verb*", false); + var peg$e13 = peg$literalExpectation("verb", false); + var peg$e14 = peg$literalExpectation("[", false); + var peg$e15 = peg$literalExpectation("]", false); + var peg$e16 = peg$classExpectation([" ", " ", "\n", "\r"], true, false); + var peg$e17 = peg$otherExpectation("verbatim listings"); + var peg$e18 = peg$literalExpectation("lstinline", false); + var peg$e19 = peg$otherExpectation("verbatim minted"); + var peg$e20 = peg$literalExpectation("mintinline", false); + var peg$e21 = peg$literalExpectation("mint", false); + var peg$e22 = peg$otherExpectation("verbatim minted environment"); + var peg$e23 = peg$literalExpectation("minted", false); + var peg$e24 = peg$otherExpectation("verbatim environment"); + var peg$e25 = peg$literalExpectation("verbatim*", false); + var peg$e26 = peg$literalExpectation("verbatim", false); + var peg$e27 = peg$literalExpectation("filecontents*", false); + var peg$e28 = peg$literalExpectation("filecontents", false); + var peg$e29 = peg$literalExpectation("comment", false); + var peg$e30 = peg$literalExpectation("lstlisting", false); + var peg$e31 = peg$otherExpectation("macro"); + var peg$e32 = peg$otherExpectation("group"); + var peg$e33 = peg$otherExpectation("environment"); + var peg$e34 = peg$otherExpectation("math environment"); + var peg$e35 = peg$otherExpectation("math group"); + var peg$e36 = peg$literalExpectation("(", false); + var peg$e37 = peg$literalExpectation(")", false); + var peg$e38 = peg$literalExpectation("begin", false); + var peg$e39 = peg$literalExpectation("end", false); + var peg$e40 = peg$literalExpectation("equation*", false); + var peg$e41 = peg$literalExpectation("equation", false); + var peg$e42 = peg$literalExpectation("align*", false); + var peg$e43 = peg$literalExpectation("align", false); + var peg$e44 = peg$literalExpectation("alignat*", false); + var peg$e45 = peg$literalExpectation("alignat", false); + var peg$e46 = peg$literalExpectation("gather*", false); + var peg$e47 = peg$literalExpectation("gather", false); + var peg$e48 = peg$literalExpectation("multline*", false); + var peg$e49 = peg$literalExpectation("multline", false); + var peg$e50 = peg$literalExpectation("flalign*", false); + var peg$e51 = peg$literalExpectation("flalign", false); + var peg$e52 = peg$literalExpectation("split", false); + var peg$e53 = peg$literalExpectation("math", false); + var peg$e54 = peg$literalExpectation("displaymath", false); + var peg$e55 = peg$otherExpectation("escape"); + var peg$e56 = peg$literalExpectation("\\", false); + var peg$e57 = peg$literalExpectation("{", false); + var peg$e58 = peg$literalExpectation("}", false); + var peg$e59 = peg$literalExpectation("$", false); + var peg$e60 = peg$literalExpectation("&", false); + var peg$e61 = peg$otherExpectation("newline"); + var peg$e62 = peg$literalExpectation("\r", false); + var peg$e63 = peg$literalExpectation("\n", false); + var peg$e64 = peg$literalExpectation("\r\n", false); + var peg$e65 = peg$literalExpectation("#", false); + var peg$e66 = peg$literalExpectation("^", false); + var peg$e67 = peg$literalExpectation("_", false); + var peg$e68 = peg$literalExpectation("\0", false); + var peg$e69 = peg$classExpectation([" ", " "], false, false); + var peg$e70 = peg$otherExpectation("letter"); + var peg$e71 = peg$classExpectation([["a", "z"], ["A", "Z"]], false, false); + var peg$e72 = peg$otherExpectation("digit"); + var peg$e73 = peg$classExpectation([["0", "9"]], false, false); + var peg$e74 = peg$otherExpectation("punctuation"); + var peg$e75 = peg$classExpectation([".", ",", ";", ":", "-", "*", "/", "(", ")", "!", "?", "=", "+", "<", ">", "[", "]", "`", "'", '"', "~"], false, false); + var peg$e76 = peg$otherExpectation("full comment"); + var peg$e77 = peg$otherExpectation("comment"); + var peg$f0 = function(content) { + return createNode("root", { content: content.flatMap((x) => x) }); + }; + var peg$f1 = function(t) { + return t; + }; + var peg$f2 = function(eq) { + return createNode("inlinemath", { content: eq.flatMap((x) => x) }); + }; + var peg$f3 = function(s2) { + return createNode("string", { content: s2 }); + }; + var peg$f4 = function(s2) { + return createNode("string", { content: s2 }); + }; + var peg$f5 = function() { + return createNode("parbreak"); + }; + var peg$f6 = function(x) { + return x; + }; + var peg$f7 = function(x) { + return x; + }; + var peg$f8 = function() { + return createNode("macro", { content: "^", escapeToken: "" }); + }; + var peg$f9 = function() { + return createNode("macro", { content: "_", escapeToken: "" }); + }; + var peg$f10 = function(s2) { + return createNode("string", { content: s2 }); + }; + var peg$f11 = function() { + return createNode("whitespace"); + }; + var peg$f12 = function(a, b) { + return a.join("") + "." + b.join(""); + }; + var peg$f13 = function(b) { + return "." + b.join(""); + }; + var peg$f14 = function(a) { + return a.join("") + "."; + }; + var peg$f15 = function(s2) { + return createNode("string", { content: s2 }); + }; + var peg$f16 = function(env, e, end) { + return end == e; + }; + var peg$f17 = function(env, e, x) { + return x; + }; + var peg$f18 = function(env, e, x, end) { + return end == e; + }; + var peg$f19 = function(env, e, x) { + return createNode("verb", { + env, + escape: e, + content: x.join("") + }); + }; + var peg$f20 = function(x) { + return x; + }; + var peg$f21 = function(x) { + return createNode("displaymath", { content: x.flatMap((x2) => x2) }); + }; + var peg$f22 = function(x) { + return x; + }; + var peg$f23 = function(x) { + return createNode("inlinemath", { content: x.flatMap((x2) => x2) }); + }; + var peg$f24 = function(x) { + return x; + }; + var peg$f25 = function(x) { + return createNode("displaymath", { content: x.flatMap((x2) => x2) }); + }; + var peg$f26 = function(end) { + return end.type === "string" && end.content === "]"; + }; + var peg$f27 = function(x) { + return x; + }; + var peg$f28 = function(o) { + return [ + createNode("string", { content: "[" }), + ...o, + createNode("string", { content: "]" }) + ]; + }; + var peg$f29 = function(x) { + return x; + }; + var peg$f30 = function(v) { + return createNode("group", { + content: createNode("string", { content: v.join("") }) + }); + }; + var peg$f31 = function(d, end) { + return end == d; + }; + var peg$f32 = function(d, x) { + return x; + }; + var peg$f33 = function(d, v, end) { + return end == d; + }; + var peg$f34 = function(d, v) { + return [ + createNode("string", { content: d }), + createNode("string", { content: v.join("") }), + createNode("string", { content: d }) + ]; + }; + var peg$f35 = function(macro2, option, verbatim) { + return [ + createNode("macro", { content: macro2 }), + ...option || [], + ...[].concat(verbatim) + ]; + }; + var peg$f36 = function(macro2, option, language, verbatim) { + return [ + createNode("macro", { content: macro2 }), + ...option || [], + language, + ...[].concat(verbatim) + ]; + }; + var peg$f37 = function(env, lang, end_env) { + return compare_env({ content: [env] }, end_env); + }; + var peg$f38 = function(env, lang, x) { + return x; + }; + var peg$f39 = function(env, lang, body) { + return createNode("verbatim", { + env: `${env}{${lang.content.content}}`, + content: body.join("") + }); + }; + var peg$f40 = function(env, end_env) { + return compare_env({ content: [env] }, end_env); + }; + var peg$f41 = function(env, x) { + return x; + }; + var peg$f42 = function(env, body) { + return createNode("verbatim", { + env, + content: body.join("") + }); + }; + var peg$f43 = function(n) { + return n.join(""); + }; + var peg$f44 = function(n) { + return n; + }; + var peg$f45 = function(m) { + return createNode("macro", { content: m }); + }; + var peg$f46 = function(c) { + return c; + }; + var peg$f47 = function(x) { + return createNode("group", { content: x.flatMap((x2) => x2) }); + }; + var peg$f48 = function(g) { + return text().slice(1, -1); + }; + var peg$f49 = function(env, env_comment, end_env) { + return compare_env(env, end_env); + }; + var peg$f50 = function(env, env_comment, x) { + return x; + }; + var peg$f51 = function(env, env_comment, body) { + body = body.flatMap((x) => x); + return createNode("environment", { + env, + content: env_comment ? [env_comment, ...body] : body + }); + }; + var peg$f52 = function(env, env_comment, end_env) { + return compare_env({ content: [env] }, end_env); + }; + var peg$f53 = function(env, env_comment, x) { + return x; + }; + var peg$f54 = function(env, env_comment, body) { + body = body.flatMap((x) => x); + return createNode("mathenv", { + env, + content: env_comment ? [env_comment, ...body] : body + }); + }; + var peg$f55 = function(c) { + return c; + }; + var peg$f56 = function(x) { + return createNode("group", { content: x.flatMap((x2) => x2) }); + }; + var peg$f57 = function(e) { + return createNode("string", { content: e }); + }; + var peg$f58 = function() { + return createNode("string", { content: "\\" }); + }; + var peg$f59 = function(s2) { + return createNode("string", { content: s2 }); + }; + var peg$f60 = function(s2) { + return createNode("string", { content: s2 }); + }; + var peg$f61 = function(s2) { + return createNode("string", { content: s2 }); + }; + var peg$f62 = function(s2) { + return createNode("string", { content: s2 }); + }; + var peg$f63 = function(s2) { + return createNode("string", { content: s2 }); + }; + var peg$f64 = function(s2) { + return createNode("string", { content: s2 }); + }; + var peg$f65 = function(s2) { + return createNode("string", { content: s2 }); + }; + var peg$f66 = function() { + return " "; + }; + var peg$f67 = function(p) { + return createNode("string", { content: p }); + }; + var peg$f68 = function(leading_sp, comment2) { + return createNode("comment", { + ...comment2, + sameline: false, + leadingWhitespace: leading_sp.length > 0 + }); + }; + var peg$f69 = function(spaces, x) { + return createNode("comment", { + ...x, + sameline: true, + leadingWhitespace: spaces.length > 0 + }); + }; + var peg$f70 = function(c) { + return c; + }; + var peg$f71 = function(c) { + return { content: c.join(""), suffixParbreak: true }; + }; + var peg$f72 = function(c) { + return c; + }; + var peg$f73 = function(c) { + return { content: c.join("") }; + }; + var peg$f74 = function() { + var loc = location(); + return loc.start.column === 1; + }; + var peg$currPos = 0; + var peg$savedPos = 0; + var peg$posDetailsCache = [{ line: 1, column: 1 }]; + var peg$maxFailPos = 0; + var peg$maxFailExpected = []; + var peg$silentFails = 0; + var peg$result; + if ("startRule" in options) { + if (!(options.startRule in peg$startRuleFunctions)) { + throw new Error(`Can't start parsing from rule "` + options.startRule + '".'); + } + peg$startRuleFunction = peg$startRuleFunctions[options.startRule]; + } + function text() { + return input.substring(peg$savedPos, peg$currPos); + } + function offset() { + return peg$savedPos; + } + function range() { + return { + source: peg$source, + start: peg$savedPos, + end: peg$currPos + }; + } + function location() { + return peg$computeLocation(peg$savedPos, peg$currPos); + } + function expected(description, location2) { + location2 = location2 !== void 0 ? location2 : peg$computeLocation(peg$savedPos, peg$currPos); + throw peg$buildStructuredError( + [peg$otherExpectation(description)], + input.substring(peg$savedPos, peg$currPos), + location2 + ); + } + function error(message, location2) { + location2 = location2 !== void 0 ? location2 : peg$computeLocation(peg$savedPos, peg$currPos); + throw peg$buildSimpleError(message, location2); + } + function peg$literalExpectation(text2, ignoreCase) { + return { type: "literal", text: text2, ignoreCase }; + } + function peg$classExpectation(parts, inverted, ignoreCase) { + return { type: "class", parts, inverted, ignoreCase }; + } + function peg$anyExpectation() { + return { type: "any" }; + } + function peg$endExpectation() { + return { type: "end" }; + } + function peg$otherExpectation(description) { + return { type: "other", description }; + } + function peg$computePosDetails(pos) { + var details = peg$posDetailsCache[pos]; + var p; + if (details) { + return details; + } else { + p = pos - 1; + while (!peg$posDetailsCache[p]) { + p--; + } + details = peg$posDetailsCache[p]; + details = { + line: details.line, + column: details.column + }; + while (p < pos) { + if (input.charCodeAt(p) === 10) { + details.line++; + details.column = 1; + } else { + details.column++; + } + p++; + } + peg$posDetailsCache[pos] = details; + return details; + } + } + function peg$computeLocation(startPos, endPos) { + var startPosDetails = peg$computePosDetails(startPos); + var endPosDetails = peg$computePosDetails(endPos); + return { + source: peg$source, + start: { + offset: startPos, + line: startPosDetails.line, + column: startPosDetails.column + }, + end: { + offset: endPos, + line: endPosDetails.line, + column: endPosDetails.column + } + }; + } + function peg$fail(expected2) { + if (peg$currPos < peg$maxFailPos) { + return; + } + if (peg$currPos > peg$maxFailPos) { + peg$maxFailPos = peg$currPos; + peg$maxFailExpected = []; + } + peg$maxFailExpected.push(expected2); + } + function peg$buildSimpleError(message, location2) { + return new peg$SyntaxError(message, null, null, location2); + } + function peg$buildStructuredError(expected2, found, location2) { + return new peg$SyntaxError( + peg$SyntaxError.buildMessage(expected2, found), + expected2, + found, + location2 + ); + } + function peg$parsedocument() { + var s0, s1, s2; + peg$silentFails++; + s0 = peg$currPos; + s1 = []; + s2 = peg$parsetoken(); + while (s2 !== peg$FAILED) { + s1.push(s2); + s2 = peg$parsetoken(); + } + peg$savedPos = s0; + s1 = peg$f0(s1); + s0 = s1; + peg$silentFails--; + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + return s0; + } + function peg$parsemath() { + var s0, s1; + peg$silentFails++; + s0 = []; + s1 = peg$parsemath_token(); + while (s1 !== peg$FAILED) { + s0.push(s1); + s1 = peg$parsemath_token(); + } + peg$silentFails--; + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e1); + } + return s0; + } + function peg$parsetoken() { + var s0, s1, s2, s3, s4, s5; + peg$silentFails++; + s0 = peg$parsespecial_macro(); + if (s0 === peg$FAILED) { + s0 = peg$parsemacro(); + if (s0 === peg$FAILED) { + s0 = peg$parsefull_comment(); + if (s0 === peg$FAILED) { + s0 = peg$parsegroup(); + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$parsemath_shift(); + if (s1 !== peg$FAILED) { + s2 = []; + s3 = peg$currPos; + s4 = peg$currPos; + peg$silentFails++; + s5 = peg$parsemath_shift(); + peg$silentFails--; + if (s5 === peg$FAILED) { + s4 = void 0; + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + if (s4 !== peg$FAILED) { + s5 = peg$parsemath_token(); + if (s5 !== peg$FAILED) { + peg$savedPos = s3; + s3 = peg$f1(s5); + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + if (s3 !== peg$FAILED) { + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$currPos; + s4 = peg$currPos; + peg$silentFails++; + s5 = peg$parsemath_shift(); + peg$silentFails--; + if (s5 === peg$FAILED) { + s4 = void 0; + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + if (s4 !== peg$FAILED) { + s5 = peg$parsemath_token(); + if (s5 !== peg$FAILED) { + peg$savedPos = s3; + s3 = peg$f1(s5); + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s3 = peg$parsemath_shift(); + if (s3 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f2(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$parsealignment_tab(); + if (s0 === peg$FAILED) { + s0 = peg$parseparbreak(); + if (s0 === peg$FAILED) { + s0 = peg$parsemacro_parameter(); + if (s0 === peg$FAILED) { + s0 = peg$parseignore(); + if (s0 === peg$FAILED) { + s0 = peg$parsenumber(); + if (s0 === peg$FAILED) { + s0 = peg$parsewhitespace(); + if (s0 === peg$FAILED) { + s0 = peg$parsepunctuation(); + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$currPos; + s2 = []; + s3 = peg$currPos; + s4 = peg$currPos; + peg$silentFails++; + s5 = peg$parsenonchar_token(); + peg$silentFails--; + if (s5 === peg$FAILED) { + s4 = void 0; + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + if (s4 !== peg$FAILED) { + if (input.length > peg$currPos) { + s5 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s5 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s5 !== peg$FAILED) { + s4 = [s4, s5]; + s3 = s4; + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + if (s3 !== peg$FAILED) { + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$currPos; + s4 = peg$currPos; + peg$silentFails++; + s5 = peg$parsenonchar_token(); + peg$silentFails--; + if (s5 === peg$FAILED) { + s4 = void 0; + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + if (s4 !== peg$FAILED) { + if (input.length > peg$currPos) { + s5 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s5 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s5 !== peg$FAILED) { + s4 = [s4, s5]; + s3 = s4; + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s1 = input.substring(s1, peg$currPos); + } else { + s1 = s2; + } + if (s1 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$f3(s1); + } + s0 = s1; + if (s0 === peg$FAILED) { + s0 = peg$parsebegin_group(); + if (s0 === peg$FAILED) { + s0 = peg$parseend_group(); + if (s0 === peg$FAILED) { + s0 = peg$parsemath_shift(); + if (s0 === peg$FAILED) { + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s1 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$f4(s1); + } + s0 = s1; + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e2); + } + } + return s0; + } + function peg$parseparbreak() { + var s0, s1, s2, s3, s4, s5, s6, s7; + peg$silentFails++; + s0 = peg$currPos; + s1 = peg$currPos; + s2 = []; + s3 = peg$parsesp(); + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$parsesp(); + } + s3 = peg$parsenl(); + if (s3 !== peg$FAILED) { + s4 = []; + s5 = peg$currPos; + s6 = []; + s7 = peg$parsesp(); + while (s7 !== peg$FAILED) { + s6.push(s7); + s7 = peg$parsesp(); + } + s7 = peg$parsenl(); + if (s7 !== peg$FAILED) { + s6 = [s6, s7]; + s5 = s6; + } else { + peg$currPos = s5; + s5 = peg$FAILED; + } + if (s5 !== peg$FAILED) { + while (s5 !== peg$FAILED) { + s4.push(s5); + s5 = peg$currPos; + s6 = []; + s7 = peg$parsesp(); + while (s7 !== peg$FAILED) { + s6.push(s7); + s7 = peg$parsesp(); + } + s7 = peg$parsenl(); + if (s7 !== peg$FAILED) { + s6 = [s6, s7]; + s5 = s6; + } else { + peg$currPos = s5; + s5 = peg$FAILED; + } + } + } else { + s4 = peg$FAILED; + } + if (s4 !== peg$FAILED) { + s5 = []; + s6 = peg$parsesp(); + while (s6 !== peg$FAILED) { + s5.push(s6); + s6 = peg$parsesp(); + } + s6 = peg$currPos; + peg$silentFails++; + s7 = peg$parsecomment_start(); + peg$silentFails--; + if (s7 === peg$FAILED) { + s6 = void 0; + } else { + peg$currPos = s6; + s6 = peg$FAILED; + } + if (s6 !== peg$FAILED) { + s2 = [s2, s3, s4, s5, s6]; + s1 = s2; + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + if (s1 === peg$FAILED) { + s1 = peg$currPos; + s2 = []; + s3 = peg$parsesp(); + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$parsesp(); + } + s3 = peg$parsenl(); + if (s3 !== peg$FAILED) { + s4 = []; + s5 = peg$currPos; + s6 = []; + s7 = peg$parsesp(); + while (s7 !== peg$FAILED) { + s6.push(s7); + s7 = peg$parsesp(); + } + s7 = peg$parsenl(); + if (s7 !== peg$FAILED) { + s6 = [s6, s7]; + s5 = s6; + } else { + peg$currPos = s5; + s5 = peg$FAILED; + } + if (s5 !== peg$FAILED) { + while (s5 !== peg$FAILED) { + s4.push(s5); + s5 = peg$currPos; + s6 = []; + s7 = peg$parsesp(); + while (s7 !== peg$FAILED) { + s6.push(s7); + s7 = peg$parsesp(); + } + s7 = peg$parsenl(); + if (s7 !== peg$FAILED) { + s6 = [s6, s7]; + s5 = s6; + } else { + peg$currPos = s5; + s5 = peg$FAILED; + } + } + } else { + s4 = peg$FAILED; + } + if (s4 !== peg$FAILED) { + s2 = [s2, s3, s4]; + s1 = s2; + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + } + if (s1 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$f5(); + } + s0 = s1; + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e4); + } + } + return s0; + } + function peg$parsemath_token() { + var s0, s1, s2, s3, s4; + peg$silentFails++; + s0 = peg$parsespecial_macro(); + if (s0 === peg$FAILED) { + s0 = peg$parsemacro(); + if (s0 === peg$FAILED) { + s0 = peg$parsefull_comment(); + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = []; + s2 = peg$parsewhitespace(); + while (s2 !== peg$FAILED) { + s1.push(s2); + s2 = peg$parsewhitespace(); + } + s2 = peg$parsegroup(); + if (s2 !== peg$FAILED) { + s3 = []; + s4 = peg$parsewhitespace(); + while (s4 !== peg$FAILED) { + s3.push(s4); + s4 = peg$parsewhitespace(); + } + peg$savedPos = s0; + s0 = peg$f6(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = []; + s2 = peg$parsewhitespace(); + while (s2 !== peg$FAILED) { + s1.push(s2); + s2 = peg$parsewhitespace(); + } + s2 = peg$parsealignment_tab(); + if (s2 !== peg$FAILED) { + s3 = []; + s4 = peg$parsewhitespace(); + while (s4 !== peg$FAILED) { + s3.push(s4); + s4 = peg$parsewhitespace(); + } + peg$savedPos = s0; + s0 = peg$f7(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$parsemacro_parameter(); + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = []; + s2 = peg$parsewhitespace(); + while (s2 !== peg$FAILED) { + s1.push(s2); + s2 = peg$parsewhitespace(); + } + s2 = peg$parsesuperscript(); + if (s2 !== peg$FAILED) { + s3 = []; + s4 = peg$parsewhitespace(); + while (s4 !== peg$FAILED) { + s3.push(s4); + s4 = peg$parsewhitespace(); + } + peg$savedPos = s0; + s0 = peg$f8(); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = []; + s2 = peg$parsewhitespace(); + while (s2 !== peg$FAILED) { + s1.push(s2); + s2 = peg$parsewhitespace(); + } + s2 = peg$parsesubscript(); + if (s2 !== peg$FAILED) { + s3 = []; + s4 = peg$parsewhitespace(); + while (s4 !== peg$FAILED) { + s3.push(s4); + s4 = peg$parsewhitespace(); + } + peg$savedPos = s0; + s0 = peg$f9(); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$parseignore(); + if (s0 === peg$FAILED) { + s0 = peg$parsewhitespace(); + if (s0 === peg$FAILED) { + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s1 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$f10(s1); + } + s0 = s1; + } + } + } + } + } + } + } + } + } + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e5); + } + } + return s0; + } + function peg$parsenonchar_token() { + var s0, s1; + peg$silentFails++; + s0 = peg$parseescape(); + if (s0 === peg$FAILED) { + if (input.charCodeAt(peg$currPos) === 37) { + s0 = peg$c0; + peg$currPos++; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e7); + } + } + if (s0 === peg$FAILED) { + s0 = peg$parsebegin_group(); + if (s0 === peg$FAILED) { + s0 = peg$parseend_group(); + if (s0 === peg$FAILED) { + s0 = peg$parsemath_shift(); + if (s0 === peg$FAILED) { + s0 = peg$parsealignment_tab(); + if (s0 === peg$FAILED) { + s0 = peg$parsenl(); + if (s0 === peg$FAILED) { + s0 = peg$parsemacro_parameter(); + if (s0 === peg$FAILED) { + s0 = peg$parseignore(); + if (s0 === peg$FAILED) { + s0 = peg$parsesp(); + if (s0 === peg$FAILED) { + s0 = peg$parsepunctuation(); + if (s0 === peg$FAILED) { + s0 = peg$parseEOF(); + } + } + } + } + } + } + } + } + } + } + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e6); + } + } + return s0; + } + function peg$parsewhitespace() { + var s0, s1, s2, s3, s4, s5, s6, s7; + peg$silentFails++; + s0 = peg$currPos; + s1 = peg$currPos; + s2 = peg$parsenl(); + if (s2 !== peg$FAILED) { + s3 = []; + s4 = peg$parsesp(); + while (s4 !== peg$FAILED) { + s3.push(s4); + s4 = peg$parsesp(); + } + s2 = [s2, s3]; + s1 = s2; + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + if (s1 === peg$FAILED) { + s1 = peg$currPos; + s2 = []; + s3 = peg$parsesp(); + if (s3 !== peg$FAILED) { + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$parsesp(); + } + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s3 = peg$parsenl(); + if (s3 !== peg$FAILED) { + s4 = peg$currPos; + peg$silentFails++; + s5 = peg$parsecomment_start(); + peg$silentFails--; + if (s5 === peg$FAILED) { + s4 = void 0; + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + if (s4 !== peg$FAILED) { + s5 = []; + s6 = peg$parsesp(); + while (s6 !== peg$FAILED) { + s5.push(s6); + s6 = peg$parsesp(); + } + s6 = peg$currPos; + peg$silentFails++; + s7 = peg$parsenl(); + peg$silentFails--; + if (s7 === peg$FAILED) { + s6 = void 0; + } else { + peg$currPos = s6; + s6 = peg$FAILED; + } + if (s6 !== peg$FAILED) { + s2 = [s2, s3, s4, s5, s6]; + s1 = s2; + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + if (s1 === peg$FAILED) { + s1 = []; + s2 = peg$parsesp(); + if (s2 !== peg$FAILED) { + while (s2 !== peg$FAILED) { + s1.push(s2); + s2 = peg$parsesp(); + } + } else { + s1 = peg$FAILED; + } + } + } + if (s1 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$f11(); + } + s0 = s1; + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e8); + } + } + return s0; + } + function peg$parsenumber() { + var s0, s1, s2, s3, s4, s5; + peg$silentFails++; + s0 = peg$currPos; + s1 = peg$currPos; + s2 = []; + s3 = peg$parsenum(); + if (s3 !== peg$FAILED) { + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$parsenum(); + } + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + if (input.charCodeAt(peg$currPos) === 46) { + s3 = peg$c1; + peg$currPos++; + } else { + s3 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e10); + } + } + if (s3 !== peg$FAILED) { + s4 = []; + s5 = peg$parsenum(); + if (s5 !== peg$FAILED) { + while (s5 !== peg$FAILED) { + s4.push(s5); + s5 = peg$parsenum(); + } + } else { + s4 = peg$FAILED; + } + if (s4 !== peg$FAILED) { + peg$savedPos = s1; + s1 = peg$f12(s2, s4); + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + if (s1 === peg$FAILED) { + s1 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 46) { + s2 = peg$c1; + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e10); + } + } + if (s2 !== peg$FAILED) { + s3 = []; + s4 = peg$parsenum(); + if (s4 !== peg$FAILED) { + while (s4 !== peg$FAILED) { + s3.push(s4); + s4 = peg$parsenum(); + } + } else { + s3 = peg$FAILED; + } + if (s3 !== peg$FAILED) { + peg$savedPos = s1; + s1 = peg$f13(s3); + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + if (s1 === peg$FAILED) { + s1 = peg$currPos; + s2 = []; + s3 = peg$parsenum(); + if (s3 !== peg$FAILED) { + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$parsenum(); + } + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + if (input.charCodeAt(peg$currPos) === 46) { + s3 = peg$c1; + peg$currPos++; + } else { + s3 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e10); + } + } + if (s3 !== peg$FAILED) { + peg$savedPos = s1; + s1 = peg$f14(s2); + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + } + } + if (s1 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$f15(s1); + } + s0 = s1; + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e9); + } + } + return s0; + } + function peg$parsespecial_macro() { + var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9; + peg$silentFails++; + s0 = peg$currPos; + s1 = peg$parseescape(); + if (s1 !== peg$FAILED) { + if (input.substr(peg$currPos, 5) === peg$c2) { + s2 = peg$c2; + peg$currPos += 5; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e12); + } + } + if (s2 === peg$FAILED) { + if (input.substr(peg$currPos, 4) === peg$c3) { + s2 = peg$c3; + peg$currPos += 4; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e13); + } + } + } + if (s2 !== peg$FAILED) { + if (input.length > peg$currPos) { + s3 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s3 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s3 !== peg$FAILED) { + s4 = []; + s5 = peg$currPos; + s6 = peg$currPos; + peg$silentFails++; + s7 = peg$currPos; + if (input.length > peg$currPos) { + s8 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s8 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s8 !== peg$FAILED) { + peg$savedPos = peg$currPos; + s9 = peg$f16(s2, s3, s8); + if (s9) { + s9 = void 0; + } else { + s9 = peg$FAILED; + } + if (s9 !== peg$FAILED) { + s8 = [s8, s9]; + s7 = s8; + } else { + peg$currPos = s7; + s7 = peg$FAILED; + } + } else { + peg$currPos = s7; + s7 = peg$FAILED; + } + peg$silentFails--; + if (s7 === peg$FAILED) { + s6 = void 0; + } else { + peg$currPos = s6; + s6 = peg$FAILED; + } + if (s6 !== peg$FAILED) { + if (input.length > peg$currPos) { + s7 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s7 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s7 !== peg$FAILED) { + peg$savedPos = s5; + s5 = peg$f17(s2, s3, s7); + } else { + peg$currPos = s5; + s5 = peg$FAILED; + } + } else { + peg$currPos = s5; + s5 = peg$FAILED; + } + while (s5 !== peg$FAILED) { + s4.push(s5); + s5 = peg$currPos; + s6 = peg$currPos; + peg$silentFails++; + s7 = peg$currPos; + if (input.length > peg$currPos) { + s8 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s8 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s8 !== peg$FAILED) { + peg$savedPos = peg$currPos; + s9 = peg$f16(s2, s3, s8); + if (s9) { + s9 = void 0; + } else { + s9 = peg$FAILED; + } + if (s9 !== peg$FAILED) { + s8 = [s8, s9]; + s7 = s8; + } else { + peg$currPos = s7; + s7 = peg$FAILED; + } + } else { + peg$currPos = s7; + s7 = peg$FAILED; + } + peg$silentFails--; + if (s7 === peg$FAILED) { + s6 = void 0; + } else { + peg$currPos = s6; + s6 = peg$FAILED; + } + if (s6 !== peg$FAILED) { + if (input.length > peg$currPos) { + s7 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s7 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s7 !== peg$FAILED) { + peg$savedPos = s5; + s5 = peg$f17(s2, s3, s7); + } else { + peg$currPos = s5; + s5 = peg$FAILED; + } + } else { + peg$currPos = s5; + s5 = peg$FAILED; + } + } + s5 = peg$currPos; + if (input.length > peg$currPos) { + s6 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s6 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s6 !== peg$FAILED) { + peg$savedPos = peg$currPos; + s7 = peg$f18(s2, s3, s4, s6); + if (s7) { + s7 = void 0; + } else { + s7 = peg$FAILED; + } + if (s7 !== peg$FAILED) { + s6 = [s6, s7]; + s5 = s6; + } else { + peg$currPos = s5; + s5 = peg$FAILED; + } + } else { + peg$currPos = s5; + s5 = peg$FAILED; + } + if (s5 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f19(s2, s3, s4); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$parseverbatim_listings(); + if (s0 === peg$FAILED) { + s0 = peg$parseverbatim_minted(); + if (s0 === peg$FAILED) { + s0 = peg$parseverbatim_environment(); + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$parsebegin_display_math(); + if (s1 !== peg$FAILED) { + s2 = []; + s3 = peg$currPos; + s4 = peg$currPos; + peg$silentFails++; + s5 = peg$parseend_display_math(); + peg$silentFails--; + if (s5 === peg$FAILED) { + s4 = void 0; + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + if (s4 !== peg$FAILED) { + s5 = peg$parsemath_token(); + if (s5 !== peg$FAILED) { + peg$savedPos = s3; + s3 = peg$f20(s5); + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$currPos; + s4 = peg$currPos; + peg$silentFails++; + s5 = peg$parseend_display_math(); + peg$silentFails--; + if (s5 === peg$FAILED) { + s4 = void 0; + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + if (s4 !== peg$FAILED) { + s5 = peg$parsemath_token(); + if (s5 !== peg$FAILED) { + peg$savedPos = s3; + s3 = peg$f20(s5); + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } + s3 = peg$parseend_display_math(); + if (s3 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f21(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$parsebegin_inline_math(); + if (s1 !== peg$FAILED) { + s2 = []; + s3 = peg$currPos; + s4 = peg$currPos; + peg$silentFails++; + s5 = peg$parseend_inline_math(); + peg$silentFails--; + if (s5 === peg$FAILED) { + s4 = void 0; + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + if (s4 !== peg$FAILED) { + s5 = peg$parsemath_token(); + if (s5 !== peg$FAILED) { + peg$savedPos = s3; + s3 = peg$f22(s5); + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$currPos; + s4 = peg$currPos; + peg$silentFails++; + s5 = peg$parseend_inline_math(); + peg$silentFails--; + if (s5 === peg$FAILED) { + s4 = void 0; + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + if (s4 !== peg$FAILED) { + s5 = peg$parsemath_token(); + if (s5 !== peg$FAILED) { + peg$savedPos = s3; + s3 = peg$f22(s5); + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } + s3 = peg$parseend_inline_math(); + if (s3 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f23(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$parsemath_shift(); + if (s1 !== peg$FAILED) { + s2 = peg$parsemath_shift(); + if (s2 !== peg$FAILED) { + s3 = []; + s4 = peg$currPos; + s5 = peg$currPos; + peg$silentFails++; + s6 = peg$currPos; + s7 = peg$parsemath_shift(); + if (s7 !== peg$FAILED) { + s8 = peg$parsemath_shift(); + if (s8 !== peg$FAILED) { + s7 = [s7, s8]; + s6 = s7; + } else { + peg$currPos = s6; + s6 = peg$FAILED; + } + } else { + peg$currPos = s6; + s6 = peg$FAILED; + } + peg$silentFails--; + if (s6 === peg$FAILED) { + s5 = void 0; + } else { + peg$currPos = s5; + s5 = peg$FAILED; + } + if (s5 !== peg$FAILED) { + s6 = peg$parsemath_token(); + if (s6 !== peg$FAILED) { + peg$savedPos = s4; + s4 = peg$f24(s6); + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + while (s4 !== peg$FAILED) { + s3.push(s4); + s4 = peg$currPos; + s5 = peg$currPos; + peg$silentFails++; + s6 = peg$currPos; + s7 = peg$parsemath_shift(); + if (s7 !== peg$FAILED) { + s8 = peg$parsemath_shift(); + if (s8 !== peg$FAILED) { + s7 = [s7, s8]; + s6 = s7; + } else { + peg$currPos = s6; + s6 = peg$FAILED; + } + } else { + peg$currPos = s6; + s6 = peg$FAILED; + } + peg$silentFails--; + if (s6 === peg$FAILED) { + s5 = void 0; + } else { + peg$currPos = s5; + s5 = peg$FAILED; + } + if (s5 !== peg$FAILED) { + s6 = peg$parsemath_token(); + if (s6 !== peg$FAILED) { + peg$savedPos = s4; + s4 = peg$f24(s6); + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + } + s4 = peg$parsemath_shift(); + if (s4 !== peg$FAILED) { + s5 = peg$parsemath_shift(); + if (s5 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f25(s3); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$parsemath_environment(); + if (s0 === peg$FAILED) { + s0 = peg$parseenvironment(); + } + } + } + } + } + } + } + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e11); + } + } + return s0; + } + function peg$parsesquare_bracket_argument() { + var s0, s1, s2, s3, s4, s5, s6, s7; + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 91) { + s1 = peg$c4; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e14); + } + } + if (s1 !== peg$FAILED) { + s2 = []; + s3 = peg$currPos; + s4 = peg$currPos; + peg$silentFails++; + s5 = peg$currPos; + s6 = peg$parsetoken(); + if (s6 !== peg$FAILED) { + peg$savedPos = peg$currPos; + s7 = peg$f26(s6); + if (s7) { + s7 = void 0; + } else { + s7 = peg$FAILED; + } + if (s7 !== peg$FAILED) { + s6 = [s6, s7]; + s5 = s6; + } else { + peg$currPos = s5; + s5 = peg$FAILED; + } + } else { + peg$currPos = s5; + s5 = peg$FAILED; + } + peg$silentFails--; + if (s5 === peg$FAILED) { + s4 = void 0; + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + if (s4 !== peg$FAILED) { + s5 = peg$parsetoken(); + if (s5 !== peg$FAILED) { + peg$savedPos = s3; + s3 = peg$f27(s5); + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$currPos; + s4 = peg$currPos; + peg$silentFails++; + s5 = peg$currPos; + s6 = peg$parsetoken(); + if (s6 !== peg$FAILED) { + peg$savedPos = peg$currPos; + s7 = peg$f26(s6); + if (s7) { + s7 = void 0; + } else { + s7 = peg$FAILED; + } + if (s7 !== peg$FAILED) { + s6 = [s6, s7]; + s5 = s6; + } else { + peg$currPos = s5; + s5 = peg$FAILED; + } + } else { + peg$currPos = s5; + s5 = peg$FAILED; + } + peg$silentFails--; + if (s5 === peg$FAILED) { + s4 = void 0; + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + if (s4 !== peg$FAILED) { + s5 = peg$parsetoken(); + if (s5 !== peg$FAILED) { + peg$savedPos = s3; + s3 = peg$f27(s5); + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } + if (input.charCodeAt(peg$currPos) === 93) { + s3 = peg$c5; + peg$currPos++; + } else { + s3 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e15); + } + } + if (s3 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f28(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parseverbatim_group() { + var s0, s1, s2, s3, s4, s5; + s0 = peg$currPos; + s1 = peg$parsebegin_group(); + if (s1 !== peg$FAILED) { + s2 = []; + s3 = peg$currPos; + s4 = peg$currPos; + peg$silentFails++; + s5 = peg$parseend_group(); + peg$silentFails--; + if (s5 === peg$FAILED) { + s4 = void 0; + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + if (s4 !== peg$FAILED) { + if (input.length > peg$currPos) { + s5 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s5 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s5 !== peg$FAILED) { + peg$savedPos = s3; + s3 = peg$f29(s5); + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$currPos; + s4 = peg$currPos; + peg$silentFails++; + s5 = peg$parseend_group(); + peg$silentFails--; + if (s5 === peg$FAILED) { + s4 = void 0; + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + if (s4 !== peg$FAILED) { + if (input.length > peg$currPos) { + s5 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s5 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s5 !== peg$FAILED) { + peg$savedPos = s3; + s3 = peg$f29(s5); + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } + s3 = peg$parseend_group(); + if (s3 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f30(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parseverbatim_delimited_by_char() { + var s0, s1, s2, s3, s4, s5, s6, s7; + s0 = peg$currPos; + if (peg$r0.test(input.charAt(peg$currPos))) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e16); + } + } + if (s1 !== peg$FAILED) { + s2 = []; + s3 = peg$currPos; + s4 = peg$currPos; + peg$silentFails++; + s5 = peg$currPos; + if (input.length > peg$currPos) { + s6 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s6 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s6 !== peg$FAILED) { + peg$savedPos = peg$currPos; + s7 = peg$f31(s1, s6); + if (s7) { + s7 = void 0; + } else { + s7 = peg$FAILED; + } + if (s7 !== peg$FAILED) { + s6 = [s6, s7]; + s5 = s6; + } else { + peg$currPos = s5; + s5 = peg$FAILED; + } + } else { + peg$currPos = s5; + s5 = peg$FAILED; + } + peg$silentFails--; + if (s5 === peg$FAILED) { + s4 = void 0; + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + if (s4 !== peg$FAILED) { + if (input.length > peg$currPos) { + s5 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s5 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s5 !== peg$FAILED) { + peg$savedPos = s3; + s3 = peg$f32(s1, s5); + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$currPos; + s4 = peg$currPos; + peg$silentFails++; + s5 = peg$currPos; + if (input.length > peg$currPos) { + s6 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s6 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s6 !== peg$FAILED) { + peg$savedPos = peg$currPos; + s7 = peg$f31(s1, s6); + if (s7) { + s7 = void 0; + } else { + s7 = peg$FAILED; + } + if (s7 !== peg$FAILED) { + s6 = [s6, s7]; + s5 = s6; + } else { + peg$currPos = s5; + s5 = peg$FAILED; + } + } else { + peg$currPos = s5; + s5 = peg$FAILED; + } + peg$silentFails--; + if (s5 === peg$FAILED) { + s4 = void 0; + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + if (s4 !== peg$FAILED) { + if (input.length > peg$currPos) { + s5 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s5 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s5 !== peg$FAILED) { + peg$savedPos = s3; + s3 = peg$f32(s1, s5); + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } + s3 = peg$currPos; + if (input.length > peg$currPos) { + s4 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s4 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s4 !== peg$FAILED) { + peg$savedPos = peg$currPos; + s5 = peg$f33(s1, s2, s4); + if (s5) { + s5 = void 0; + } else { + s5 = peg$FAILED; + } + if (s5 !== peg$FAILED) { + s4 = [s4, s5]; + s3 = s4; + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + if (s3 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f34(s1, s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parseverbatim_listings() { + var s0, s1, s2, s3, s4; + peg$silentFails++; + s0 = peg$currPos; + s1 = peg$parseescape(); + if (s1 !== peg$FAILED) { + if (input.substr(peg$currPos, 9) === peg$c6) { + s2 = peg$c6; + peg$currPos += 9; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e18); + } + } + if (s2 !== peg$FAILED) { + s3 = peg$parsesquare_bracket_argument(); + if (s3 === peg$FAILED) { + s3 = null; + } + s4 = peg$parseverbatim_group(); + if (s4 === peg$FAILED) { + s4 = peg$parseverbatim_delimited_by_char(); + } + if (s4 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f35(s2, s3, s4); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e17); + } + } + return s0; + } + function peg$parseverbatim_minted() { + var s0, s1, s2, s3, s4, s5; + peg$silentFails++; + s0 = peg$currPos; + s1 = peg$parseescape(); + if (s1 !== peg$FAILED) { + if (input.substr(peg$currPos, 10) === peg$c7) { + s2 = peg$c7; + peg$currPos += 10; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e20); + } + } + if (s2 === peg$FAILED) { + if (input.substr(peg$currPos, 4) === peg$c8) { + s2 = peg$c8; + peg$currPos += 4; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e21); + } + } + } + if (s2 !== peg$FAILED) { + s3 = peg$parsesquare_bracket_argument(); + if (s3 === peg$FAILED) { + s3 = null; + } + s4 = peg$parsegroup(); + if (s4 !== peg$FAILED) { + s5 = peg$parseverbatim_group(); + if (s5 === peg$FAILED) { + s5 = peg$parseverbatim_delimited_by_char(); + } + if (s5 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f36(s2, s3, s4, s5); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e19); + } + } + return s0; + } + function peg$parseverbatim_minted_environment() { + var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12; + peg$silentFails++; + s0 = peg$currPos; + s1 = peg$parsebegin_env(); + if (s1 !== peg$FAILED) { + s2 = peg$parsebegin_group(); + if (s2 !== peg$FAILED) { + if (input.substr(peg$currPos, 6) === peg$c9) { + s3 = peg$c9; + peg$currPos += 6; + } else { + s3 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e23); + } + } + if (s3 !== peg$FAILED) { + s4 = peg$parseend_group(); + if (s4 !== peg$FAILED) { + s5 = peg$parsegroup(); + if (s5 !== peg$FAILED) { + s6 = []; + s7 = peg$currPos; + s8 = peg$currPos; + peg$silentFails++; + s9 = peg$currPos; + s10 = peg$parseend_env(); + if (s10 !== peg$FAILED) { + s11 = peg$parsegroup(); + if (s11 !== peg$FAILED) { + peg$savedPos = peg$currPos; + s12 = peg$f37(s3, s5, s11); + if (s12) { + s12 = void 0; + } else { + s12 = peg$FAILED; + } + if (s12 !== peg$FAILED) { + s10 = [s10, s11, s12]; + s9 = s10; + } else { + peg$currPos = s9; + s9 = peg$FAILED; + } + } else { + peg$currPos = s9; + s9 = peg$FAILED; + } + } else { + peg$currPos = s9; + s9 = peg$FAILED; + } + peg$silentFails--; + if (s9 === peg$FAILED) { + s8 = void 0; + } else { + peg$currPos = s8; + s8 = peg$FAILED; + } + if (s8 !== peg$FAILED) { + if (input.length > peg$currPos) { + s9 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s9 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s9 !== peg$FAILED) { + peg$savedPos = s7; + s7 = peg$f38(s3, s5, s9); + } else { + peg$currPos = s7; + s7 = peg$FAILED; + } + } else { + peg$currPos = s7; + s7 = peg$FAILED; + } + while (s7 !== peg$FAILED) { + s6.push(s7); + s7 = peg$currPos; + s8 = peg$currPos; + peg$silentFails++; + s9 = peg$currPos; + s10 = peg$parseend_env(); + if (s10 !== peg$FAILED) { + s11 = peg$parsegroup(); + if (s11 !== peg$FAILED) { + peg$savedPos = peg$currPos; + s12 = peg$f37(s3, s5, s11); + if (s12) { + s12 = void 0; + } else { + s12 = peg$FAILED; + } + if (s12 !== peg$FAILED) { + s10 = [s10, s11, s12]; + s9 = s10; + } else { + peg$currPos = s9; + s9 = peg$FAILED; + } + } else { + peg$currPos = s9; + s9 = peg$FAILED; + } + } else { + peg$currPos = s9; + s9 = peg$FAILED; + } + peg$silentFails--; + if (s9 === peg$FAILED) { + s8 = void 0; + } else { + peg$currPos = s8; + s8 = peg$FAILED; + } + if (s8 !== peg$FAILED) { + if (input.length > peg$currPos) { + s9 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s9 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s9 !== peg$FAILED) { + peg$savedPos = s7; + s7 = peg$f38(s3, s5, s9); + } else { + peg$currPos = s7; + s7 = peg$FAILED; + } + } else { + peg$currPos = s7; + s7 = peg$FAILED; + } + } + s7 = peg$parseend_env(); + if (s7 !== peg$FAILED) { + s8 = peg$parsebegin_group(); + if (s8 !== peg$FAILED) { + s9 = peg$parseverbatim_env_name(); + if (s9 !== peg$FAILED) { + s10 = peg$parseend_group(); + if (s10 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f39(s3, s5, s6); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e22); + } + } + return s0; + } + function peg$parseverbatim_environment() { + var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11; + peg$silentFails++; + s0 = peg$currPos; + s1 = peg$parsebegin_env(); + if (s1 !== peg$FAILED) { + s2 = peg$parsebegin_group(); + if (s2 !== peg$FAILED) { + s3 = peg$parseverbatim_env_name(); + if (s3 !== peg$FAILED) { + s4 = peg$parseend_group(); + if (s4 !== peg$FAILED) { + s5 = []; + s6 = peg$currPos; + s7 = peg$currPos; + peg$silentFails++; + s8 = peg$currPos; + s9 = peg$parseend_env(); + if (s9 !== peg$FAILED) { + s10 = peg$parsegroup(); + if (s10 !== peg$FAILED) { + peg$savedPos = peg$currPos; + s11 = peg$f40(s3, s10); + if (s11) { + s11 = void 0; + } else { + s11 = peg$FAILED; + } + if (s11 !== peg$FAILED) { + s9 = [s9, s10, s11]; + s8 = s9; + } else { + peg$currPos = s8; + s8 = peg$FAILED; + } + } else { + peg$currPos = s8; + s8 = peg$FAILED; + } + } else { + peg$currPos = s8; + s8 = peg$FAILED; + } + peg$silentFails--; + if (s8 === peg$FAILED) { + s7 = void 0; + } else { + peg$currPos = s7; + s7 = peg$FAILED; + } + if (s7 !== peg$FAILED) { + if (input.length > peg$currPos) { + s8 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s8 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s8 !== peg$FAILED) { + peg$savedPos = s6; + s6 = peg$f41(s3, s8); + } else { + peg$currPos = s6; + s6 = peg$FAILED; + } + } else { + peg$currPos = s6; + s6 = peg$FAILED; + } + while (s6 !== peg$FAILED) { + s5.push(s6); + s6 = peg$currPos; + s7 = peg$currPos; + peg$silentFails++; + s8 = peg$currPos; + s9 = peg$parseend_env(); + if (s9 !== peg$FAILED) { + s10 = peg$parsegroup(); + if (s10 !== peg$FAILED) { + peg$savedPos = peg$currPos; + s11 = peg$f40(s3, s10); + if (s11) { + s11 = void 0; + } else { + s11 = peg$FAILED; + } + if (s11 !== peg$FAILED) { + s9 = [s9, s10, s11]; + s8 = s9; + } else { + peg$currPos = s8; + s8 = peg$FAILED; + } + } else { + peg$currPos = s8; + s8 = peg$FAILED; + } + } else { + peg$currPos = s8; + s8 = peg$FAILED; + } + peg$silentFails--; + if (s8 === peg$FAILED) { + s7 = void 0; + } else { + peg$currPos = s7; + s7 = peg$FAILED; + } + if (s7 !== peg$FAILED) { + if (input.length > peg$currPos) { + s8 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s8 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s8 !== peg$FAILED) { + peg$savedPos = s6; + s6 = peg$f41(s3, s8); + } else { + peg$currPos = s6; + s6 = peg$FAILED; + } + } else { + peg$currPos = s6; + s6 = peg$FAILED; + } + } + s6 = peg$parseend_env(); + if (s6 !== peg$FAILED) { + s7 = peg$parsebegin_group(); + if (s7 !== peg$FAILED) { + s8 = peg$parseverbatim_env_name(); + if (s8 !== peg$FAILED) { + s9 = peg$parseend_group(); + if (s9 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f42(s3, s5); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e24); + } + } + return s0; + } + function peg$parseverbatim_env_name() { + var s0; + if (input.substr(peg$currPos, 9) === peg$c10) { + s0 = peg$c10; + peg$currPos += 9; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e25); + } + } + if (s0 === peg$FAILED) { + if (input.substr(peg$currPos, 8) === peg$c11) { + s0 = peg$c11; + peg$currPos += 8; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e26); + } + } + if (s0 === peg$FAILED) { + if (input.substr(peg$currPos, 13) === peg$c12) { + s0 = peg$c12; + peg$currPos += 13; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e27); + } + } + if (s0 === peg$FAILED) { + if (input.substr(peg$currPos, 12) === peg$c13) { + s0 = peg$c13; + peg$currPos += 12; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e28); + } + } + if (s0 === peg$FAILED) { + if (input.substr(peg$currPos, 7) === peg$c14) { + s0 = peg$c14; + peg$currPos += 7; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e29); + } + } + if (s0 === peg$FAILED) { + if (input.substr(peg$currPos, 10) === peg$c15) { + s0 = peg$c15; + peg$currPos += 10; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e30); + } + } + } + } + } + } + } + return s0; + } + function peg$parsemacro() { + var s0, s1, s2, s3, s4; + peg$silentFails++; + s0 = peg$currPos; + s1 = peg$currPos; + s2 = peg$parseescape(); + if (s2 !== peg$FAILED) { + s3 = []; + s4 = peg$parsechar(); + if (s4 !== peg$FAILED) { + while (s4 !== peg$FAILED) { + s3.push(s4); + s4 = peg$parsechar(); + } + } else { + s3 = peg$FAILED; + } + if (s3 !== peg$FAILED) { + peg$savedPos = s1; + s1 = peg$f43(s3); + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + if (s1 === peg$FAILED) { + s1 = peg$currPos; + s2 = peg$parseescape(); + if (s2 !== peg$FAILED) { + if (input.length > peg$currPos) { + s3 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s3 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s3 !== peg$FAILED) { + peg$savedPos = s1; + s1 = peg$f44(s3); + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + } + if (s1 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$f45(s1); + } + s0 = s1; + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e31); + } + } + return s0; + } + function peg$parsegroup() { + var s0, s1, s2, s3, s4, s5; + peg$silentFails++; + s0 = peg$currPos; + s1 = peg$parsebegin_group(); + if (s1 !== peg$FAILED) { + s2 = []; + s3 = peg$currPos; + s4 = peg$currPos; + peg$silentFails++; + s5 = peg$parseend_group(); + peg$silentFails--; + if (s5 === peg$FAILED) { + s4 = void 0; + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + if (s4 !== peg$FAILED) { + s5 = peg$parsetoken(); + if (s5 !== peg$FAILED) { + peg$savedPos = s3; + s3 = peg$f46(s5); + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$currPos; + s4 = peg$currPos; + peg$silentFails++; + s5 = peg$parseend_group(); + peg$silentFails--; + if (s5 === peg$FAILED) { + s4 = void 0; + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + if (s4 !== peg$FAILED) { + s5 = peg$parsetoken(); + if (s5 !== peg$FAILED) { + peg$savedPos = s3; + s3 = peg$f46(s5); + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } + s3 = peg$parseend_group(); + if (s3 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f47(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e32); + } + } + return s0; + } + function peg$parsegroup_contents_as_string() { + var s0, s1; + s0 = peg$currPos; + s1 = peg$parsegroup(); + if (s1 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$f48(s1); + } + s0 = s1; + return s0; + } + function peg$parseenvironment() { + var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10; + peg$silentFails++; + s0 = peg$currPos; + s1 = peg$parsebegin_env(); + if (s1 !== peg$FAILED) { + s2 = peg$parsegroup_contents_as_string(); + if (s2 !== peg$FAILED) { + s3 = peg$parsesameline_comment(); + if (s3 === peg$FAILED) { + s3 = null; + } + s4 = []; + s5 = peg$currPos; + s6 = peg$currPos; + peg$silentFails++; + s7 = peg$currPos; + s8 = peg$parseend_env(); + if (s8 !== peg$FAILED) { + s9 = peg$parsegroup_contents_as_string(); + if (s9 !== peg$FAILED) { + peg$savedPos = peg$currPos; + s10 = peg$f49(s2, s3, s9); + if (s10) { + s10 = void 0; + } else { + s10 = peg$FAILED; + } + if (s10 !== peg$FAILED) { + s8 = [s8, s9, s10]; + s7 = s8; + } else { + peg$currPos = s7; + s7 = peg$FAILED; + } + } else { + peg$currPos = s7; + s7 = peg$FAILED; + } + } else { + peg$currPos = s7; + s7 = peg$FAILED; + } + peg$silentFails--; + if (s7 === peg$FAILED) { + s6 = void 0; + } else { + peg$currPos = s6; + s6 = peg$FAILED; + } + if (s6 !== peg$FAILED) { + s7 = peg$parsetoken(); + if (s7 !== peg$FAILED) { + peg$savedPos = s5; + s5 = peg$f50(s2, s3, s7); + } else { + peg$currPos = s5; + s5 = peg$FAILED; + } + } else { + peg$currPos = s5; + s5 = peg$FAILED; + } + while (s5 !== peg$FAILED) { + s4.push(s5); + s5 = peg$currPos; + s6 = peg$currPos; + peg$silentFails++; + s7 = peg$currPos; + s8 = peg$parseend_env(); + if (s8 !== peg$FAILED) { + s9 = peg$parsegroup_contents_as_string(); + if (s9 !== peg$FAILED) { + peg$savedPos = peg$currPos; + s10 = peg$f49(s2, s3, s9); + if (s10) { + s10 = void 0; + } else { + s10 = peg$FAILED; + } + if (s10 !== peg$FAILED) { + s8 = [s8, s9, s10]; + s7 = s8; + } else { + peg$currPos = s7; + s7 = peg$FAILED; + } + } else { + peg$currPos = s7; + s7 = peg$FAILED; + } + } else { + peg$currPos = s7; + s7 = peg$FAILED; + } + peg$silentFails--; + if (s7 === peg$FAILED) { + s6 = void 0; + } else { + peg$currPos = s6; + s6 = peg$FAILED; + } + if (s6 !== peg$FAILED) { + s7 = peg$parsetoken(); + if (s7 !== peg$FAILED) { + peg$savedPos = s5; + s5 = peg$f50(s2, s3, s7); + } else { + peg$currPos = s5; + s5 = peg$FAILED; + } + } else { + peg$currPos = s5; + s5 = peg$FAILED; + } + } + s5 = peg$parseend_env(); + if (s5 !== peg$FAILED) { + s6 = peg$parsegroup_contents_as_string(); + if (s6 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f51(s2, s3, s4); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e33); + } + } + return s0; + } + function peg$parsemath_environment() { + var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12; + peg$silentFails++; + s0 = peg$currPos; + s1 = peg$parsebegin_env(); + if (s1 !== peg$FAILED) { + s2 = peg$parsebegin_group(); + if (s2 !== peg$FAILED) { + s3 = peg$parsemath_env_name(); + if (s3 !== peg$FAILED) { + s4 = peg$parseend_group(); + if (s4 !== peg$FAILED) { + s5 = peg$parsesameline_comment(); + if (s5 === peg$FAILED) { + s5 = null; + } + s6 = []; + s7 = peg$currPos; + s8 = peg$currPos; + peg$silentFails++; + s9 = peg$currPos; + s10 = peg$parseend_env(); + if (s10 !== peg$FAILED) { + s11 = peg$parsegroup(); + if (s11 !== peg$FAILED) { + peg$savedPos = peg$currPos; + s12 = peg$f52(s3, s5, s11); + if (s12) { + s12 = void 0; + } else { + s12 = peg$FAILED; + } + if (s12 !== peg$FAILED) { + s10 = [s10, s11, s12]; + s9 = s10; + } else { + peg$currPos = s9; + s9 = peg$FAILED; + } + } else { + peg$currPos = s9; + s9 = peg$FAILED; + } + } else { + peg$currPos = s9; + s9 = peg$FAILED; + } + peg$silentFails--; + if (s9 === peg$FAILED) { + s8 = void 0; + } else { + peg$currPos = s8; + s8 = peg$FAILED; + } + if (s8 !== peg$FAILED) { + s9 = peg$parsemath_token(); + if (s9 !== peg$FAILED) { + peg$savedPos = s7; + s7 = peg$f53(s3, s5, s9); + } else { + peg$currPos = s7; + s7 = peg$FAILED; + } + } else { + peg$currPos = s7; + s7 = peg$FAILED; + } + while (s7 !== peg$FAILED) { + s6.push(s7); + s7 = peg$currPos; + s8 = peg$currPos; + peg$silentFails++; + s9 = peg$currPos; + s10 = peg$parseend_env(); + if (s10 !== peg$FAILED) { + s11 = peg$parsegroup(); + if (s11 !== peg$FAILED) { + peg$savedPos = peg$currPos; + s12 = peg$f52(s3, s5, s11); + if (s12) { + s12 = void 0; + } else { + s12 = peg$FAILED; + } + if (s12 !== peg$FAILED) { + s10 = [s10, s11, s12]; + s9 = s10; + } else { + peg$currPos = s9; + s9 = peg$FAILED; + } + } else { + peg$currPos = s9; + s9 = peg$FAILED; + } + } else { + peg$currPos = s9; + s9 = peg$FAILED; + } + peg$silentFails--; + if (s9 === peg$FAILED) { + s8 = void 0; + } else { + peg$currPos = s8; + s8 = peg$FAILED; + } + if (s8 !== peg$FAILED) { + s9 = peg$parsemath_token(); + if (s9 !== peg$FAILED) { + peg$savedPos = s7; + s7 = peg$f53(s3, s5, s9); + } else { + peg$currPos = s7; + s7 = peg$FAILED; + } + } else { + peg$currPos = s7; + s7 = peg$FAILED; + } + } + s7 = peg$parseend_env(); + if (s7 !== peg$FAILED) { + s8 = peg$parsebegin_group(); + if (s8 !== peg$FAILED) { + s9 = peg$parsemath_env_name(); + if (s9 !== peg$FAILED) { + s10 = peg$parseend_group(); + if (s10 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f54(s3, s5, s6); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e34); + } + } + return s0; + } + function peg$parsemath_group() { + var s0, s1, s2, s3, s4, s5; + peg$silentFails++; + s0 = peg$currPos; + s1 = peg$parsebegin_group(); + if (s1 !== peg$FAILED) { + s2 = []; + s3 = peg$currPos; + s4 = peg$currPos; + peg$silentFails++; + s5 = peg$parseend_group(); + peg$silentFails--; + if (s5 === peg$FAILED) { + s4 = void 0; + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + if (s4 !== peg$FAILED) { + s5 = peg$parsemath_token(); + if (s5 !== peg$FAILED) { + peg$savedPos = s3; + s3 = peg$f55(s5); + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$currPos; + s4 = peg$currPos; + peg$silentFails++; + s5 = peg$parseend_group(); + peg$silentFails--; + if (s5 === peg$FAILED) { + s4 = void 0; + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + if (s4 !== peg$FAILED) { + s5 = peg$parsemath_token(); + if (s5 !== peg$FAILED) { + peg$savedPos = s3; + s3 = peg$f55(s5); + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } + s3 = peg$parseend_group(); + if (s3 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f56(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e35); + } + } + return s0; + } + function peg$parsebegin_display_math() { + var s0, s1, s2; + s0 = peg$currPos; + s1 = peg$parseescape(); + if (s1 !== peg$FAILED) { + if (input.charCodeAt(peg$currPos) === 91) { + s2 = peg$c4; + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e14); + } + } + if (s2 !== peg$FAILED) { + s1 = [s1, s2]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parseend_display_math() { + var s0, s1, s2; + s0 = peg$currPos; + s1 = peg$parseescape(); + if (s1 !== peg$FAILED) { + if (input.charCodeAt(peg$currPos) === 93) { + s2 = peg$c5; + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e15); + } + } + if (s2 !== peg$FAILED) { + s1 = [s1, s2]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsebegin_inline_math() { + var s0, s1, s2; + s0 = peg$currPos; + s1 = peg$parseescape(); + if (s1 !== peg$FAILED) { + if (input.charCodeAt(peg$currPos) === 40) { + s2 = peg$c16; + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e36); + } + } + if (s2 !== peg$FAILED) { + s1 = [s1, s2]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parseend_inline_math() { + var s0, s1, s2; + s0 = peg$currPos; + s1 = peg$parseescape(); + if (s1 !== peg$FAILED) { + if (input.charCodeAt(peg$currPos) === 41) { + s2 = peg$c17; + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e37); + } + } + if (s2 !== peg$FAILED) { + s1 = [s1, s2]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsebegin_env() { + var s0, s1, s2; + s0 = peg$currPos; + s1 = peg$parseescape(); + if (s1 !== peg$FAILED) { + if (input.substr(peg$currPos, 5) === peg$c18) { + s2 = peg$c18; + peg$currPos += 5; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e38); + } + } + if (s2 !== peg$FAILED) { + s1 = [s1, s2]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parseend_env() { + var s0, s1, s2; + s0 = peg$currPos; + s1 = peg$parseescape(); + if (s1 !== peg$FAILED) { + if (input.substr(peg$currPos, 3) === peg$c19) { + s2 = peg$c19; + peg$currPos += 3; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e39); + } + } + if (s2 !== peg$FAILED) { + s1 = [s1, s2]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsemath_env_name() { + var s0, s1; + s0 = peg$currPos; + if (input.substr(peg$currPos, 9) === peg$c20) { + s1 = peg$c20; + peg$currPos += 9; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e40); + } + } + if (s1 === peg$FAILED) { + if (input.substr(peg$currPos, 8) === peg$c21) { + s1 = peg$c21; + peg$currPos += 8; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e41); + } + } + if (s1 === peg$FAILED) { + if (input.substr(peg$currPos, 6) === peg$c22) { + s1 = peg$c22; + peg$currPos += 6; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e42); + } + } + if (s1 === peg$FAILED) { + if (input.substr(peg$currPos, 5) === peg$c23) { + s1 = peg$c23; + peg$currPos += 5; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e43); + } + } + if (s1 === peg$FAILED) { + if (input.substr(peg$currPos, 8) === peg$c24) { + s1 = peg$c24; + peg$currPos += 8; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e44); + } + } + if (s1 === peg$FAILED) { + if (input.substr(peg$currPos, 7) === peg$c25) { + s1 = peg$c25; + peg$currPos += 7; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e45); + } + } + if (s1 === peg$FAILED) { + if (input.substr(peg$currPos, 7) === peg$c26) { + s1 = peg$c26; + peg$currPos += 7; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e46); + } + } + if (s1 === peg$FAILED) { + if (input.substr(peg$currPos, 6) === peg$c27) { + s1 = peg$c27; + peg$currPos += 6; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e47); + } + } + if (s1 === peg$FAILED) { + if (input.substr(peg$currPos, 9) === peg$c28) { + s1 = peg$c28; + peg$currPos += 9; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e48); + } + } + if (s1 === peg$FAILED) { + if (input.substr(peg$currPos, 8) === peg$c29) { + s1 = peg$c29; + peg$currPos += 8; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e49); + } + } + if (s1 === peg$FAILED) { + if (input.substr(peg$currPos, 8) === peg$c30) { + s1 = peg$c30; + peg$currPos += 8; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e50); + } + } + if (s1 === peg$FAILED) { + if (input.substr(peg$currPos, 7) === peg$c31) { + s1 = peg$c31; + peg$currPos += 7; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e51); + } + } + if (s1 === peg$FAILED) { + if (input.substr(peg$currPos, 5) === peg$c32) { + s1 = peg$c32; + peg$currPos += 5; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e52); + } + } + if (s1 === peg$FAILED) { + if (input.substr(peg$currPos, 4) === peg$c33) { + s1 = peg$c33; + peg$currPos += 4; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e53); + } + } + if (s1 === peg$FAILED) { + if (input.substr(peg$currPos, 11) === peg$c34) { + s1 = peg$c34; + peg$currPos += 11; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e54); + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + if (s1 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$f57(s1); + } + s0 = s1; + return s0; + } + function peg$parseescape() { + var s0, s1; + peg$silentFails++; + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 92) { + s1 = peg$c35; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e56); + } + } + if (s1 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$f58(); + } + s0 = s1; + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e55); + } + } + return s0; + } + function peg$parsebegin_group() { + var s0, s1; + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 123) { + s1 = peg$c36; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e57); + } + } + if (s1 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$f59(s1); + } + s0 = s1; + return s0; + } + function peg$parseend_group() { + var s0, s1; + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 125) { + s1 = peg$c37; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e58); + } + } + if (s1 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$f60(s1); + } + s0 = s1; + return s0; + } + function peg$parsemath_shift() { + var s0, s1; + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 36) { + s1 = peg$c38; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e59); + } + } + if (s1 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$f61(s1); + } + s0 = s1; + return s0; + } + function peg$parsealignment_tab() { + var s0, s1; + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 38) { + s1 = peg$c39; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e60); + } + } + if (s1 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$f62(s1); + } + s0 = s1; + return s0; + } + function peg$parsenl() { + var s0, s1, s2; + peg$silentFails++; + s0 = peg$currPos; + s1 = peg$currPos; + peg$silentFails++; + if (input.charCodeAt(peg$currPos) === 13) { + s2 = peg$c40; + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e62); + } + } + peg$silentFails--; + if (s2 === peg$FAILED) { + s1 = void 0; + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + if (s1 !== peg$FAILED) { + if (input.charCodeAt(peg$currPos) === 10) { + s2 = peg$c41; + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e63); + } + } + if (s2 !== peg$FAILED) { + s1 = [s1, s2]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + if (input.charCodeAt(peg$currPos) === 13) { + s0 = peg$c40; + peg$currPos++; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e62); + } + } + if (s0 === peg$FAILED) { + if (input.substr(peg$currPos, 2) === peg$c42) { + s0 = peg$c42; + peg$currPos += 2; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e64); + } + } + } + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e61); + } + } + return s0; + } + function peg$parsemacro_parameter() { + var s0, s1; + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 35) { + s1 = peg$c43; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e65); + } + } + if (s1 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$f63(s1); + } + s0 = s1; + return s0; + } + function peg$parsesuperscript() { + var s0, s1; + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 94) { + s1 = peg$c44; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e66); + } + } + if (s1 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$f64(s1); + } + s0 = s1; + return s0; + } + function peg$parsesubscript() { + var s0, s1; + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 95) { + s1 = peg$c45; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e67); + } + } + if (s1 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$f65(s1); + } + s0 = s1; + return s0; + } + function peg$parseignore() { + var s0; + if (input.charCodeAt(peg$currPos) === 0) { + s0 = peg$c46; + peg$currPos++; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e68); + } + } + return s0; + } + function peg$parsesp() { + var s0, s1, s2; + peg$silentFails++; + s0 = peg$currPos; + s1 = []; + if (peg$r1.test(input.charAt(peg$currPos))) { + s2 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e69); + } + } + if (s2 !== peg$FAILED) { + while (s2 !== peg$FAILED) { + s1.push(s2); + if (peg$r1.test(input.charAt(peg$currPos))) { + s2 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e69); + } + } + } + } else { + s1 = peg$FAILED; + } + if (s1 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$f66(); + } + s0 = s1; + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e8); + } + } + return s0; + } + function peg$parsechar() { + var s0, s1; + peg$silentFails++; + if (peg$r2.test(input.charAt(peg$currPos))) { + s0 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e71); + } + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e70); + } + } + return s0; + } + function peg$parsenum() { + var s0, s1; + peg$silentFails++; + if (peg$r3.test(input.charAt(peg$currPos))) { + s0 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e73); + } + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e72); + } + } + return s0; + } + function peg$parsepunctuation() { + var s0, s1; + peg$silentFails++; + s0 = peg$currPos; + if (peg$r4.test(input.charAt(peg$currPos))) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e75); + } + } + if (s1 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$f67(s1); + } + s0 = s1; + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e74); + } + } + return s0; + } + function peg$parsecomment_start() { + var s0; + if (input.charCodeAt(peg$currPos) === 37) { + s0 = peg$c0; + peg$currPos++; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e7); + } + } + return s0; + } + function peg$parsefull_comment() { + var s0, s1; + peg$silentFails++; + s0 = peg$parseownline_comment(); + if (s0 === peg$FAILED) { + s0 = peg$parsesameline_comment(); + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e76); + } + } + return s0; + } + function peg$parseownline_comment() { + var s0, s1, s2, s3; + s0 = peg$currPos; + s1 = peg$currPos; + s2 = []; + s3 = peg$parsesp(); + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$parsesp(); + } + s3 = peg$parsenl(); + if (s3 !== peg$FAILED) { + s2 = [s2, s3]; + s1 = s2; + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + if (s1 === peg$FAILED) { + s1 = null; + } + s2 = peg$parseleading_sp(); + if (s2 !== peg$FAILED) { + s3 = peg$parsecomment(); + if (s3 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f68(s2, s3); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsesameline_comment() { + var s0, s1, s2; + s0 = peg$currPos; + s1 = []; + s2 = peg$parsesp(); + while (s2 !== peg$FAILED) { + s1.push(s2); + s2 = peg$parsesp(); + } + s2 = peg$parsecomment(); + if (s2 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f69(s1, s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsecomment() { + var s0, s1, s2, s3, s4, s5, s6, s7; + peg$silentFails++; + s0 = peg$currPos; + s1 = peg$parsecomment_start(); + if (s1 !== peg$FAILED) { + s2 = []; + s3 = peg$currPos; + s4 = peg$currPos; + peg$silentFails++; + s5 = peg$parsenl(); + peg$silentFails--; + if (s5 === peg$FAILED) { + s4 = void 0; + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + if (s4 !== peg$FAILED) { + if (input.length > peg$currPos) { + s5 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s5 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s5 !== peg$FAILED) { + peg$savedPos = s3; + s3 = peg$f70(s5); + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$currPos; + s4 = peg$currPos; + peg$silentFails++; + s5 = peg$parsenl(); + peg$silentFails--; + if (s5 === peg$FAILED) { + s4 = void 0; + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + if (s4 !== peg$FAILED) { + if (input.length > peg$currPos) { + s5 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s5 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s5 !== peg$FAILED) { + peg$savedPos = s3; + s3 = peg$f70(s5); + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } + s3 = peg$currPos; + peg$silentFails++; + s4 = peg$parseparbreak(); + peg$silentFails--; + if (s4 !== peg$FAILED) { + peg$currPos = s3; + s3 = void 0; + } else { + s3 = peg$FAILED; + } + if (s3 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f71(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$parsecomment_start(); + if (s1 !== peg$FAILED) { + s2 = []; + s3 = peg$currPos; + s4 = peg$currPos; + peg$silentFails++; + s5 = peg$parsenl(); + peg$silentFails--; + if (s5 === peg$FAILED) { + s4 = void 0; + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + if (s4 !== peg$FAILED) { + if (input.length > peg$currPos) { + s5 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s5 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s5 !== peg$FAILED) { + peg$savedPos = s3; + s3 = peg$f72(s5); + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$currPos; + s4 = peg$currPos; + peg$silentFails++; + s5 = peg$parsenl(); + peg$silentFails--; + if (s5 === peg$FAILED) { + s4 = void 0; + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + if (s4 !== peg$FAILED) { + if (input.length > peg$currPos) { + s5 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s5 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s5 !== peg$FAILED) { + peg$savedPos = s3; + s3 = peg$f72(s5); + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } + s3 = peg$currPos; + s4 = peg$parsenl(); + if (s4 !== peg$FAILED) { + s5 = []; + s6 = peg$parsesp(); + while (s6 !== peg$FAILED) { + s5.push(s6); + s6 = peg$parsesp(); + } + s6 = peg$currPos; + peg$silentFails++; + s7 = peg$parsecomment_start(); + peg$silentFails--; + if (s7 === peg$FAILED) { + s6 = void 0; + } else { + peg$currPos = s6; + s6 = peg$FAILED; + } + if (s6 !== peg$FAILED) { + s4 = [s4, s5, s6]; + s3 = s4; + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + if (s3 === peg$FAILED) { + s3 = peg$parsenl(); + if (s3 === peg$FAILED) { + s3 = peg$parseEOF(); + } + } + if (s3 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f73(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e77); + } + } + return s0; + } + function peg$parseleading_sp() { + var s0, s1, s2, s3, s4; + s0 = peg$currPos; + s1 = peg$currPos; + s2 = peg$parsestart_of_line(); + if (s2 !== peg$FAILED) { + s3 = []; + s4 = peg$parsesp(); + while (s4 !== peg$FAILED) { + s3.push(s4); + s4 = peg$parsesp(); + } + s2 = [s2, s3]; + s1 = s2; + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + if (s1 !== peg$FAILED) { + s0 = input.substring(s0, peg$currPos); + } else { + s0 = s1; + } + return s0; + } + function peg$parsestart_of_line() { + var s0; + peg$savedPos = peg$currPos; + s0 = peg$f74(); + if (s0) { + s0 = void 0; + } else { + s0 = peg$FAILED; + } + return s0; + } + function peg$parseEOF() { + var s0, s1; + s0 = peg$currPos; + peg$silentFails++; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + peg$silentFails--; + if (s1 === peg$FAILED) { + s0 = void 0; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function toString(e) { + if (typeof e === "string") { + return e; + } + if (typeof e.content === "string") { + return e.content; + } + if (e && e.type === "whitespace") { + return " "; + } + return e; + } + function compare_env(g1, g2) { + const g1Name = typeof g1 === "string" ? g1 : g1.content.map(toString).join(""); + const g2Name = typeof g2 === "string" ? g2 : g2.content.map(toString).join(""); + return g1Name === g2Name; + } + function createNode(type, extra = {}) { + return { type, ...extra, position: location() }; + } + peg$result = peg$startRuleFunction(); + if (peg$result !== peg$FAILED && peg$currPos === input.length) { + return peg$result; + } else { + if (peg$result !== peg$FAILED && peg$currPos < input.length) { + peg$fail(peg$endExpectation()); + } + throw peg$buildStructuredError( + peg$maxFailExpected, + peg$maxFailPos < input.length ? input.charAt(peg$maxFailPos) : null, + peg$maxFailPos < input.length ? peg$computeLocation(peg$maxFailPos, peg$maxFailPos + 1) : peg$computeLocation(peg$maxFailPos, peg$maxFailPos) + ); + } + } + return { + SyntaxError: peg$SyntaxError, + parse: peg$parse + }; + }() +); +var align_environment_default = ( + // Generated by Peggy 2.0.1. + // + // https://peggyjs.org/ + function() { + "use strict"; + function peg$subclass(child, parent) { + function C() { + this.constructor = child; + } + C.prototype = parent.prototype; + child.prototype = new C(); + } + function peg$SyntaxError(message, expected, found, location) { + var self = Error.call(this, message); + if (Object.setPrototypeOf) { + Object.setPrototypeOf(self, peg$SyntaxError.prototype); + } + self.expected = expected; + self.found = found; + self.location = location; + self.name = "SyntaxError"; + return self; + } + peg$subclass(peg$SyntaxError, Error); + function peg$padEnd(str, targetLength, padString) { + padString = padString || " "; + if (str.length > targetLength) { + return str; + } + targetLength -= str.length; + padString += padString.repeat(targetLength); + return str + padString.slice(0, targetLength); + } + peg$SyntaxError.prototype.format = function(sources) { + var str = "Error: " + this.message; + if (this.location) { + var src = null; + var k; + for (k = 0; k < sources.length; k++) { + if (sources[k].source === this.location.source) { + src = sources[k].text.split(/\r\n|\n|\r/g); + break; + } + } + var s2 = this.location.start; + var loc = this.location.source + ":" + s2.line + ":" + s2.column; + if (src) { + var e = this.location.end; + var filler = peg$padEnd("", s2.line.toString().length, " "); + var line5 = src[s2.line - 1]; + var last = s2.line === e.line ? e.column : line5.length + 1; + var hatLen = last - s2.column || 1; + str += "\n --> " + loc + "\n" + filler + " |\n" + s2.line + " | " + line5 + "\n" + filler + " | " + peg$padEnd("", s2.column - 1, " ") + peg$padEnd("", hatLen, "^"); + } else { + str += "\n at " + loc; + } + } + return str; + }; + peg$SyntaxError.buildMessage = function(expected, found) { + var DESCRIBE_EXPECTATION_FNS = { + literal: function(expectation) { + return '"' + literalEscape(expectation.text) + '"'; + }, + class: function(expectation) { + var escapedParts = expectation.parts.map(function(part) { + return Array.isArray(part) ? classEscape(part[0]) + "-" + classEscape(part[1]) : classEscape(part); + }); + return "[" + (expectation.inverted ? "^" : "") + escapedParts.join("") + "]"; + }, + any: function() { + return "any character"; + }, + end: function() { + return "end of input"; + }, + other: function(expectation) { + return expectation.description; + } + }; + function hex(ch) { + return ch.charCodeAt(0).toString(16).toUpperCase(); + } + function literalEscape(s2) { + return s2.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\0/g, "\\0").replace(/\t/g, "\\t").replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/[\x00-\x0F]/g, function(ch) { + return "\\x0" + hex(ch); + }).replace(/[\x10-\x1F\x7F-\x9F]/g, function(ch) { + return "\\x" + hex(ch); + }); + } + function classEscape(s2) { + return s2.replace(/\\/g, "\\\\").replace(/\]/g, "\\]").replace(/\^/g, "\\^").replace(/-/g, "\\-").replace(/\0/g, "\\0").replace(/\t/g, "\\t").replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/[\x00-\x0F]/g, function(ch) { + return "\\x0" + hex(ch); + }).replace(/[\x10-\x1F\x7F-\x9F]/g, function(ch) { + return "\\x" + hex(ch); + }); + } + function describeExpectation(expectation) { + return DESCRIBE_EXPECTATION_FNS[expectation.type](expectation); + } + function describeExpected(expected2) { + var descriptions = expected2.map(describeExpectation); + var i, j; + descriptions.sort(); + if (descriptions.length > 0) { + for (i = 1, j = 1; i < descriptions.length; i++) { + if (descriptions[i - 1] !== descriptions[i]) { + descriptions[j] = descriptions[i]; + j++; + } + } + descriptions.length = j; + } + switch (descriptions.length) { + case 1: + return descriptions[0]; + case 2: + return descriptions[0] + " or " + descriptions[1]; + default: + return descriptions.slice(0, -1).join(", ") + ", or " + descriptions[descriptions.length - 1]; + } + } + function describeFound(found2) { + return found2 ? '"' + literalEscape(found2) + '"' : "end of input"; + } + return "Expected " + describeExpected(expected) + " but " + describeFound(found) + " found."; + }; + function peg$parse(input, options) { + options = options !== void 0 ? options : {}; + var peg$FAILED = {}; + var peg$source = options.grammarSource; + var peg$startRuleFunctions = { body: peg$parsebody }; + var peg$startRuleFunction = peg$parsebody; + var peg$e0 = peg$anyExpectation(); + var peg$f0 = function() { + return []; + }; + var peg$f1 = function(x) { + return { cells: [], colSeps: [], ...x }; + }; + var peg$f2 = function(rowItems, rowSep, trailingComment) { + return { ...rowItems, rowSep, trailingComment }; + }; + var peg$f3 = function(rowItems, trailingComment) { + return { ...rowItems, rowSep: null, trailingComment }; + }; + var peg$f4 = function(x) { + return x; + }; + var peg$f5 = function(x) { + return { + cells: [], + colSeps: [], + rowSep: null, + trailingComment: x + }; + }; + var peg$f6 = function(x) { + return x; + }; + var peg$f7 = function(colSep, cell) { + return { colSep, cell }; + }; + var peg$f8 = function(colSep) { + return { colSep }; + }; + var peg$f9 = function(a, b) { + return processRow(a, b); + }; + var peg$f10 = function(b) { + return processRow(null, b); + }; + var peg$f11 = function(tok) { + return options.isSameLineComment(tok); + }; + var peg$f12 = function(tok) { + return tok; + }; + var peg$f13 = function(tok) { + return options.isOwnLineComment(tok); + }; + var peg$f14 = function(tok) { + return tok; + }; + var peg$f15 = function(tok) { + return options.isWhitespace(tok); + }; + var peg$f16 = function(tok) { + return tok; + }; + var peg$f17 = function(tok) { + return options.isRowSep(tok); + }; + var peg$f18 = function(tok) { + return tok; + }; + var peg$f19 = function(tok) { + return options.isColSep(tok); + }; + var peg$f20 = function(tok) { + return tok; + }; + var peg$currPos = 0; + var peg$savedPos = 0; + var peg$posDetailsCache = [{ line: 1, column: 1 }]; + var peg$maxFailPos = 0; + var peg$maxFailExpected = []; + var peg$silentFails = 0; + var peg$result; + if ("startRule" in options) { + if (!(options.startRule in peg$startRuleFunctions)) { + throw new Error(`Can't start parsing from rule "` + options.startRule + '".'); + } + peg$startRuleFunction = peg$startRuleFunctions[options.startRule]; + } + function text() { + return input.substring(peg$savedPos, peg$currPos); + } + function offset() { + return peg$savedPos; + } + function range() { + return { + source: peg$source, + start: peg$savedPos, + end: peg$currPos + }; + } + function location() { + return peg$computeLocation(peg$savedPos, peg$currPos); + } + function expected(description, location2) { + location2 = location2 !== void 0 ? location2 : peg$computeLocation(peg$savedPos, peg$currPos); + throw peg$buildStructuredError( + [peg$otherExpectation(description)], + input.substring(peg$savedPos, peg$currPos), + location2 + ); + } + function error(message, location2) { + location2 = location2 !== void 0 ? location2 : peg$computeLocation(peg$savedPos, peg$currPos); + throw peg$buildSimpleError(message, location2); + } + function peg$literalExpectation(text2, ignoreCase) { + return { type: "literal", text: text2, ignoreCase }; + } + function peg$classExpectation(parts, inverted, ignoreCase) { + return { type: "class", parts, inverted, ignoreCase }; + } + function peg$anyExpectation() { + return { type: "any" }; + } + function peg$endExpectation() { + return { type: "end" }; + } + function peg$otherExpectation(description) { + return { type: "other", description }; + } + function peg$computePosDetails(pos) { + var details = peg$posDetailsCache[pos]; + var p; + if (details) { + return details; + } else { + p = pos - 1; + while (!peg$posDetailsCache[p]) { + p--; + } + details = peg$posDetailsCache[p]; + details = { + line: details.line, + column: details.column + }; + while (p < pos) { + if (input.charCodeAt(p) === 10) { + details.line++; + details.column = 1; + } else { + details.column++; + } + p++; + } + peg$posDetailsCache[pos] = details; + return details; + } + } + function peg$computeLocation(startPos, endPos) { + var startPosDetails = peg$computePosDetails(startPos); + var endPosDetails = peg$computePosDetails(endPos); + return { + source: peg$source, + start: { + offset: startPos, + line: startPosDetails.line, + column: startPosDetails.column + }, + end: { + offset: endPos, + line: endPosDetails.line, + column: endPosDetails.column + } + }; + } + function peg$fail(expected2) { + if (peg$currPos < peg$maxFailPos) { + return; + } + if (peg$currPos > peg$maxFailPos) { + peg$maxFailPos = peg$currPos; + peg$maxFailExpected = []; + } + peg$maxFailExpected.push(expected2); + } + function peg$buildSimpleError(message, location2) { + return new peg$SyntaxError(message, null, null, location2); + } + function peg$buildStructuredError(expected2, found, location2) { + return new peg$SyntaxError( + peg$SyntaxError.buildMessage(expected2, found), + expected2, + found, + location2 + ); + } + function peg$parsebody() { + var s0, s1; + s0 = []; + s1 = peg$parsecomment_only_line(); + if (s1 === peg$FAILED) { + s1 = peg$parserow_with_end(); + if (s1 === peg$FAILED) { + s1 = peg$parserow_without_end(); + } + } + if (s1 !== peg$FAILED) { + while (s1 !== peg$FAILED) { + s0.push(s1); + s1 = peg$parsecomment_only_line(); + if (s1 === peg$FAILED) { + s1 = peg$parserow_with_end(); + if (s1 === peg$FAILED) { + s1 = peg$parserow_without_end(); + } + } + } + } else { + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$parseEOL(); + if (s1 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$f0(); + } + s0 = s1; + } + return s0; + } + function peg$parserow_with_end() { + var s0, s1, s2, s3; + s0 = peg$currPos; + s1 = peg$currPos; + s2 = peg$parserow_items(); + if (s2 === peg$FAILED) { + s2 = null; + } + peg$savedPos = s1; + s2 = peg$f1(s2); + s1 = s2; + s2 = peg$parserow_sep(); + if (s2 !== peg$FAILED) { + s3 = peg$parsetrailing_comment(); + if (s3 === peg$FAILED) { + s3 = null; + } + peg$savedPos = s0; + s0 = peg$f2(s1, s2, s3); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parserow_without_end() { + var s0, s1, s2; + s0 = peg$currPos; + s1 = peg$parserow_items(); + if (s1 !== peg$FAILED) { + s2 = peg$parsetrailing_comment(); + if (s2 === peg$FAILED) { + s2 = null; + } + peg$savedPos = s0; + s0 = peg$f3(s1, s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsetrailing_comment() { + var s0, s1, s2; + s0 = peg$currPos; + s1 = []; + s2 = peg$parsewhitespace(); + while (s2 !== peg$FAILED) { + s1.push(s2); + s2 = peg$parsewhitespace(); + } + s2 = peg$parsesame_line_comment(); + if (s2 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f4(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsecomment_only_line() { + var s0, s1, s2; + s0 = peg$currPos; + s1 = []; + s2 = peg$parsewhitespace(); + while (s2 !== peg$FAILED) { + s1.push(s2); + s2 = peg$parsewhitespace(); + } + s2 = peg$parseown_line_comment(); + if (s2 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f5(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsetoken() { + var s0, s1, s2; + s0 = peg$currPos; + s1 = peg$currPos; + peg$silentFails++; + s2 = peg$parserow_sep(); + if (s2 === peg$FAILED) { + s2 = peg$parsecol_sep(); + if (s2 === peg$FAILED) { + s2 = peg$parsetrailing_comment(); + if (s2 === peg$FAILED) { + s2 = peg$parseown_line_comment(); + } + } + } + peg$silentFails--; + if (s2 === peg$FAILED) { + s1 = void 0; + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + if (s1 !== peg$FAILED) { + if (input.length > peg$currPos) { + s2 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s2 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f6(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsecell() { + var s0, s1, s2; + s0 = peg$currPos; + s1 = []; + s2 = peg$parsetoken(); + if (s2 !== peg$FAILED) { + while (s2 !== peg$FAILED) { + s1.push(s2); + s2 = peg$parsetoken(); + } + } else { + s1 = peg$FAILED; + } + if (s1 !== peg$FAILED) { + s0 = input.substring(s0, peg$currPos); + } else { + s0 = s1; + } + return s0; + } + function peg$parseseparated_cell() { + var s0, s1, s2; + s0 = peg$currPos; + s1 = peg$parsecol_sep(); + if (s1 !== peg$FAILED) { + s2 = peg$parsecell(); + if (s2 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f7(s1, s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$parsecol_sep(); + if (s1 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$f8(s1); + } + s0 = s1; + } + return s0; + } + function peg$parserow_items() { + var s0, s1, s2, s3; + s0 = peg$currPos; + s1 = peg$parsecell(); + if (s1 !== peg$FAILED) { + s2 = []; + s3 = peg$parseseparated_cell(); + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$parseseparated_cell(); + } + peg$savedPos = s0; + s0 = peg$f9(s1, s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = []; + s2 = peg$parseseparated_cell(); + if (s2 !== peg$FAILED) { + while (s2 !== peg$FAILED) { + s1.push(s2); + s2 = peg$parseseparated_cell(); + } + } else { + s1 = peg$FAILED; + } + if (s1 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$f10(s1); + } + s0 = s1; + } + return s0; + } + function peg$parsesame_line_comment() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + peg$savedPos = peg$currPos; + s2 = peg$f11(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f12(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parseown_line_comment() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + peg$savedPos = peg$currPos; + s2 = peg$f13(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f14(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsewhitespace() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + peg$savedPos = peg$currPos; + s2 = peg$f15(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f16(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parserow_sep() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + peg$savedPos = peg$currPos; + s2 = peg$f17(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f18(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsecol_sep() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + peg$savedPos = peg$currPos; + s2 = peg$f19(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f20(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parseEOL() { + var s0, s1; + s0 = peg$currPos; + peg$silentFails++; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + peg$silentFails--; + if (s1 === peg$FAILED) { + s0 = void 0; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function processRow(leadCell, otherCells) { + const cells = [leadCell || []]; + const seps = []; + for (const x of otherCells) { + cells.push(x.cell || []); + seps.push(x.colSep); + } + return { cells, colSeps: seps }; + } + if (!options.isWhitespace) { + try { + Object.assign( + options, + createMatchers(["\\", "hline", "cr"], ["&"]) + ); + } catch (e) { + console.warn("Error when initializing parser", e); + } + } + peg$result = peg$startRuleFunction(); + if (peg$result !== peg$FAILED && peg$currPos === input.length) { + return peg$result; + } else { + if (peg$result !== peg$FAILED && peg$currPos < input.length) { + peg$fail(peg$endExpectation()); + } + throw peg$buildStructuredError( + peg$maxFailExpected, + peg$maxFailPos < input.length ? input.charAt(peg$maxFailPos) : null, + peg$maxFailPos < input.length ? peg$computeLocation(peg$maxFailPos, peg$maxFailPos + 1) : peg$computeLocation(peg$maxFailPos, peg$maxFailPos) + ); + } + } + return { + SyntaxError: peg$SyntaxError, + parse: peg$parse + }; + }() +); +var xparse_argspec_default = ( + // Generated by Peggy 2.0.1. + // + // https://peggyjs.org/ + function() { + "use strict"; + function peg$subclass(child, parent) { + function C() { + this.constructor = child; + } + C.prototype = parent.prototype; + child.prototype = new C(); + } + function peg$SyntaxError(message, expected, found, location) { + var self = Error.call(this, message); + if (Object.setPrototypeOf) { + Object.setPrototypeOf(self, peg$SyntaxError.prototype); + } + self.expected = expected; + self.found = found; + self.location = location; + self.name = "SyntaxError"; + return self; + } + peg$subclass(peg$SyntaxError, Error); + function peg$padEnd(str, targetLength, padString) { + padString = padString || " "; + if (str.length > targetLength) { + return str; + } + targetLength -= str.length; + padString += padString.repeat(targetLength); + return str + padString.slice(0, targetLength); + } + peg$SyntaxError.prototype.format = function(sources) { + var str = "Error: " + this.message; + if (this.location) { + var src = null; + var k; + for (k = 0; k < sources.length; k++) { + if (sources[k].source === this.location.source) { + src = sources[k].text.split(/\r\n|\n|\r/g); + break; + } + } + var s2 = this.location.start; + var loc = this.location.source + ":" + s2.line + ":" + s2.column; + if (src) { + var e = this.location.end; + var filler = peg$padEnd("", s2.line.toString().length, " "); + var line5 = src[s2.line - 1]; + var last = s2.line === e.line ? e.column : line5.length + 1; + var hatLen = last - s2.column || 1; + str += "\n --> " + loc + "\n" + filler + " |\n" + s2.line + " | " + line5 + "\n" + filler + " | " + peg$padEnd("", s2.column - 1, " ") + peg$padEnd("", hatLen, "^"); + } else { + str += "\n at " + loc; + } + } + return str; + }; + peg$SyntaxError.buildMessage = function(expected, found) { + var DESCRIBE_EXPECTATION_FNS = { + literal: function(expectation) { + return '"' + literalEscape(expectation.text) + '"'; + }, + class: function(expectation) { + var escapedParts = expectation.parts.map(function(part) { + return Array.isArray(part) ? classEscape(part[0]) + "-" + classEscape(part[1]) : classEscape(part); + }); + return "[" + (expectation.inverted ? "^" : "") + escapedParts.join("") + "]"; + }, + any: function() { + return "any character"; + }, + end: function() { + return "end of input"; + }, + other: function(expectation) { + return expectation.description; + } + }; + function hex(ch) { + return ch.charCodeAt(0).toString(16).toUpperCase(); + } + function literalEscape(s2) { + return s2.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\0/g, "\\0").replace(/\t/g, "\\t").replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/[\x00-\x0F]/g, function(ch) { + return "\\x0" + hex(ch); + }).replace(/[\x10-\x1F\x7F-\x9F]/g, function(ch) { + return "\\x" + hex(ch); + }); + } + function classEscape(s2) { + return s2.replace(/\\/g, "\\\\").replace(/\]/g, "\\]").replace(/\^/g, "\\^").replace(/-/g, "\\-").replace(/\0/g, "\\0").replace(/\t/g, "\\t").replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/[\x00-\x0F]/g, function(ch) { + return "\\x0" + hex(ch); + }).replace(/[\x10-\x1F\x7F-\x9F]/g, function(ch) { + return "\\x" + hex(ch); + }); + } + function describeExpectation(expectation) { + return DESCRIBE_EXPECTATION_FNS[expectation.type](expectation); + } + function describeExpected(expected2) { + var descriptions = expected2.map(describeExpectation); + var i, j; + descriptions.sort(); + if (descriptions.length > 0) { + for (i = 1, j = 1; i < descriptions.length; i++) { + if (descriptions[i - 1] !== descriptions[i]) { + descriptions[j] = descriptions[i]; + j++; + } + } + descriptions.length = j; + } + switch (descriptions.length) { + case 1: + return descriptions[0]; + case 2: + return descriptions[0] + " or " + descriptions[1]; + default: + return descriptions.slice(0, -1).join(", ") + ", or " + descriptions[descriptions.length - 1]; + } + } + function describeFound(found2) { + return found2 ? '"' + literalEscape(found2) + '"' : "end of input"; + } + return "Expected " + describeExpected(expected) + " but " + describeFound(found) + " found."; + }; + function peg$parse(input, options) { + options = options !== void 0 ? options : {}; + var peg$FAILED = {}; + var peg$source = options.grammarSource; + var peg$startRuleFunctions = { args_spec_list: peg$parseargs_spec_list }; + var peg$startRuleFunction = peg$parseargs_spec_list; + var peg$c0 = "+"; + var peg$c1 = "v"; + var peg$c2 = "b"; + var peg$c3 = "!"; + var peg$c4 = "D"; + var peg$c5 = "d"; + var peg$c6 = "s"; + var peg$c7 = "O"; + var peg$c8 = "o"; + var peg$c9 = "e"; + var peg$c10 = "E"; + var peg$c11 = "t"; + var peg$c12 = "R"; + var peg$c13 = "r"; + var peg$c14 = "u"; + var peg$c15 = "m"; + var peg$c16 = "{"; + var peg$c17 = "}"; + var peg$c18 = " "; + var peg$c19 = "\n"; + var peg$c20 = "\r"; + var peg$r0 = /^[{ ]/; + var peg$e0 = peg$literalExpectation("+", false); + var peg$e1 = peg$literalExpectation("v", false); + var peg$e2 = peg$anyExpectation(); + var peg$e3 = peg$literalExpectation("b", false); + var peg$e4 = peg$literalExpectation("!", false); + var peg$e5 = peg$literalExpectation("D", false); + var peg$e6 = peg$literalExpectation("d", false); + var peg$e7 = peg$literalExpectation("s", false); + var peg$e8 = peg$literalExpectation("O", false); + var peg$e9 = peg$literalExpectation("o", false); + var peg$e10 = peg$literalExpectation("e", false); + var peg$e11 = peg$literalExpectation("E", false); + var peg$e12 = peg$literalExpectation("t", false); + var peg$e13 = peg$literalExpectation("R", false); + var peg$e14 = peg$literalExpectation("r", false); + var peg$e15 = peg$literalExpectation("u", false); + var peg$e16 = peg$classExpectation(["{", " "], false, false); + var peg$e17 = peg$literalExpectation("m", false); + var peg$e18 = peg$literalExpectation("{", false); + var peg$e19 = peg$literalExpectation("}", false); + var peg$e20 = peg$literalExpectation(" ", false); + var peg$e21 = peg$literalExpectation("\n", false); + var peg$e22 = peg$literalExpectation("\r", false); + var peg$f0 = function(x) { + return x; + }; + var peg$f1 = function(spec) { + return spec; + }; + var peg$f2 = function(spec) { + return spec; + }; + var peg$f3 = function(openBrace) { + return createNode("verbatim", { openBrace, closeBrace: openBrace }); + }; + var peg$f4 = function() { + return createNode("body"); + }; + var peg$f5 = function(leading_bang, spec) { + return leading_bang ? { ...spec, noLeadingWhitespace: true } : spec; + }; + var peg$f6 = function(braceSpec, defaultArg) { + return createNode("optional", { ...braceSpec, defaultArg }); + }; + var peg$f7 = function(braceSpec) { + return createNode("optional", braceSpec); + }; + var peg$f8 = function() { + return createNode("optionalStar"); + }; + var peg$f9 = function(g) { + return createNode("optional", { defaultArg: g }); + }; + var peg$f10 = function() { + return createNode("optional"); + }; + var peg$f11 = function(args) { + return createNode("embellishment", { + embellishmentTokens: args.content + }); + }; + var peg$f12 = function(args, g) { + return createNode("embellishment", { + embellishmentTokens: args.content, + defaultArg: g + }); + }; + var peg$f13 = function(tok) { + return createNode("optionalToken", { token: tok }); + }; + var peg$f14 = function(braceSpec, defaultArg) { + return createNode("mandatory", { ...braceSpec, defaultArg }); + }; + var peg$f15 = function(braceSpec) { + return createNode("mandatory", braceSpec); + }; + var peg$f16 = function(stopTokens) { + return createNode("until", { stopTokens }); + }; + var peg$f17 = function(x) { + return [x]; + }; + var peg$f18 = function(g) { + return g.content; + }; + var peg$f19 = function() { + return createNode("mandatory"); + }; + var peg$f20 = function(openBrace, closeBrace) { + return { openBrace, closeBrace }; + }; + var peg$f21 = function(content) { + return { type: "group", content }; + }; + var peg$f22 = function() { + return ""; + }; + var peg$currPos = 0; + var peg$savedPos = 0; + var peg$posDetailsCache = [{ line: 1, column: 1 }]; + var peg$maxFailPos = 0; + var peg$maxFailExpected = []; + var peg$silentFails = 0; + var peg$result; + if ("startRule" in options) { + if (!(options.startRule in peg$startRuleFunctions)) { + throw new Error(`Can't start parsing from rule "` + options.startRule + '".'); + } + peg$startRuleFunction = peg$startRuleFunctions[options.startRule]; + } + function text() { + return input.substring(peg$savedPos, peg$currPos); + } + function offset() { + return peg$savedPos; + } + function range() { + return { + source: peg$source, + start: peg$savedPos, + end: peg$currPos + }; + } + function location() { + return peg$computeLocation(peg$savedPos, peg$currPos); + } + function expected(description, location2) { + location2 = location2 !== void 0 ? location2 : peg$computeLocation(peg$savedPos, peg$currPos); + throw peg$buildStructuredError( + [peg$otherExpectation(description)], + input.substring(peg$savedPos, peg$currPos), + location2 + ); + } + function error(message, location2) { + location2 = location2 !== void 0 ? location2 : peg$computeLocation(peg$savedPos, peg$currPos); + throw peg$buildSimpleError(message, location2); + } + function peg$literalExpectation(text2, ignoreCase) { + return { type: "literal", text: text2, ignoreCase }; + } + function peg$classExpectation(parts, inverted, ignoreCase) { + return { type: "class", parts, inverted, ignoreCase }; + } + function peg$anyExpectation() { + return { type: "any" }; + } + function peg$endExpectation() { + return { type: "end" }; + } + function peg$otherExpectation(description) { + return { type: "other", description }; + } + function peg$computePosDetails(pos) { + var details = peg$posDetailsCache[pos]; + var p; + if (details) { + return details; + } else { + p = pos - 1; + while (!peg$posDetailsCache[p]) { + p--; + } + details = peg$posDetailsCache[p]; + details = { + line: details.line, + column: details.column + }; + while (p < pos) { + if (input.charCodeAt(p) === 10) { + details.line++; + details.column = 1; + } else { + details.column++; + } + p++; + } + peg$posDetailsCache[pos] = details; + return details; + } + } + function peg$computeLocation(startPos, endPos) { + var startPosDetails = peg$computePosDetails(startPos); + var endPosDetails = peg$computePosDetails(endPos); + return { + source: peg$source, + start: { + offset: startPos, + line: startPosDetails.line, + column: startPosDetails.column + }, + end: { + offset: endPos, + line: endPosDetails.line, + column: endPosDetails.column + } + }; + } + function peg$fail(expected2) { + if (peg$currPos < peg$maxFailPos) { + return; + } + if (peg$currPos > peg$maxFailPos) { + peg$maxFailPos = peg$currPos; + peg$maxFailExpected = []; + } + peg$maxFailExpected.push(expected2); + } + function peg$buildSimpleError(message, location2) { + return new peg$SyntaxError(message, null, null, location2); + } + function peg$buildStructuredError(expected2, found, location2) { + return new peg$SyntaxError( + peg$SyntaxError.buildMessage(expected2, found), + expected2, + found, + location2 + ); + } + function peg$parseargs_spec_list() { + var s0, s1, s2, s3, s4; + s0 = peg$currPos; + s1 = []; + s2 = peg$currPos; + s3 = peg$parsewhitespace(); + s4 = peg$parsearg_spec(); + if (s4 !== peg$FAILED) { + peg$savedPos = s2; + s2 = peg$f0(s4); + } else { + peg$currPos = s2; + s2 = peg$FAILED; + } + while (s2 !== peg$FAILED) { + s1.push(s2); + s2 = peg$currPos; + s3 = peg$parsewhitespace(); + s4 = peg$parsearg_spec(); + if (s4 !== peg$FAILED) { + peg$savedPos = s2; + s2 = peg$f0(s4); + } else { + peg$currPos = s2; + s2 = peg$FAILED; + } + } + s2 = peg$parsewhitespace(); + peg$savedPos = s0; + s0 = peg$f1(s1); + return s0; + } + function peg$parsearg_spec() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 43) { + s1 = peg$c0; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 === peg$FAILED) { + s1 = null; + } + s2 = peg$parseoptional(); + if (s2 === peg$FAILED) { + s2 = peg$parsemandatory(); + if (s2 === peg$FAILED) { + s2 = peg$parseverbatim(); + if (s2 === peg$FAILED) { + s2 = peg$parserequired(); + if (s2 === peg$FAILED) { + s2 = peg$parsebody(); + if (s2 === peg$FAILED) { + s2 = peg$parseuntil(); + } + } + } + } + } + if (s2 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f2(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parseverbatim() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 118) { + s1 = peg$c1; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e1); + } + } + if (s1 !== peg$FAILED) { + if (input.length > peg$currPos) { + s2 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e2); + } + } + if (s2 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f3(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsebody() { + var s0, s1; + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 98) { + s1 = peg$c2; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s1 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$f4(); + } + s0 = s1; + return s0; + } + function peg$parseoptional() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 33) { + s1 = peg$c3; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e4); + } + } + if (s1 === peg$FAILED) { + s1 = null; + } + s2 = peg$parseoptional_star(); + if (s2 === peg$FAILED) { + s2 = peg$parseoptional_standard(); + if (s2 === peg$FAILED) { + s2 = peg$parseoptional_delimited(); + if (s2 === peg$FAILED) { + s2 = peg$parseoptional_embellishment(); + if (s2 === peg$FAILED) { + s2 = peg$parseoptional_token(); + } + } + } + } + if (s2 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f5(s1, s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parseoptional_delimited() { + var s0, s1, s2, s3; + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 68) { + s1 = peg$c4; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e5); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$parsebrace_spec(); + s3 = peg$parsebraced_group(); + if (s3 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f6(s2, s3); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 100) { + s1 = peg$c5; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e6); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$parsebrace_spec(); + peg$savedPos = s0; + s0 = peg$f7(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } + return s0; + } + function peg$parseoptional_star() { + var s0, s1; + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 115) { + s1 = peg$c6; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e7); + } + } + if (s1 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$f8(); + } + s0 = s1; + return s0; + } + function peg$parseoptional_standard() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 79) { + s1 = peg$c7; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e8); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$parsebraced_group(); + if (s2 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f9(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 111) { + s1 = peg$c8; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e9); + } + } + if (s1 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$f10(); + } + s0 = s1; + } + return s0; + } + function peg$parseoptional_embellishment() { + var s0, s1, s2, s3; + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 101) { + s1 = peg$c9; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e10); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$parsebraced_group(); + if (s2 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f11(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 69) { + s1 = peg$c10; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e11); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$parsebraced_group(); + if (s2 !== peg$FAILED) { + s3 = peg$parsebraced_group(); + if (s3 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f12(s2, s3); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } + return s0; + } + function peg$parseoptional_token() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 116) { + s1 = peg$c11; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e12); + } + } + if (s1 !== peg$FAILED) { + if (input.length > peg$currPos) { + s2 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e2); + } + } + if (s2 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f13(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parserequired() { + var s0, s1, s2, s3; + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 82) { + s1 = peg$c12; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e13); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$parsebrace_spec(); + s3 = peg$parsebraced_group(); + if (s3 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f14(s2, s3); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 114) { + s1 = peg$c13; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e14); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$parsebrace_spec(); + peg$savedPos = s0; + s0 = peg$f15(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } + return s0; + } + function peg$parseuntil() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 117) { + s1 = peg$c14; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e15); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$parseuntil_stop_token(); + if (s2 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f16(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parseuntil_stop_token() { + var s0, s1, s2; + s0 = peg$currPos; + s1 = peg$currPos; + peg$silentFails++; + if (peg$r0.test(input.charAt(peg$currPos))) { + s2 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e16); + } + } + peg$silentFails--; + if (s2 === peg$FAILED) { + s1 = void 0; + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + if (s1 !== peg$FAILED) { + if (input.length > peg$currPos) { + s2 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e2); + } + } + if (s2 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f17(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$parsebraced_group(); + if (s1 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$f18(s1); + } + s0 = s1; + } + return s0; + } + function peg$parsemandatory() { + var s0, s1; + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 109) { + s1 = peg$c15; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e17); + } + } + if (s1 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$f19(); + } + s0 = s1; + return s0; + } + function peg$parsebrace_spec() { + var s0, s1, s2, s3, s4, s5; + s0 = peg$currPos; + s1 = peg$currPos; + s2 = peg$currPos; + s3 = peg$currPos; + peg$silentFails++; + s4 = peg$parsewhitespace_token(); + peg$silentFails--; + if (s4 === peg$FAILED) { + s3 = void 0; + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + if (s3 !== peg$FAILED) { + if (input.length > peg$currPos) { + s4 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s4 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e2); + } + } + if (s4 !== peg$FAILED) { + s3 = [s3, s4]; + s2 = s3; + } else { + peg$currPos = s2; + s2 = peg$FAILED; + } + } else { + peg$currPos = s2; + s2 = peg$FAILED; + } + if (s2 === peg$FAILED) { + s2 = null; + } + s1 = input.substring(s1, peg$currPos); + s2 = peg$currPos; + s3 = peg$currPos; + s4 = peg$currPos; + peg$silentFails++; + s5 = peg$parsewhitespace_token(); + peg$silentFails--; + if (s5 === peg$FAILED) { + s4 = void 0; + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + if (s4 !== peg$FAILED) { + if (input.length > peg$currPos) { + s5 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s5 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e2); + } + } + if (s5 !== peg$FAILED) { + s4 = [s4, s5]; + s3 = s4; + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + if (s3 === peg$FAILED) { + s3 = null; + } + s2 = input.substring(s2, peg$currPos); + peg$savedPos = s0; + s0 = peg$f20(s1, s2); + return s0; + } + function peg$parsebraced_group() { + var s0, s1, s2, s3, s4, s5, s6, s7; + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 123) { + s1 = peg$c16; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e18); + } + } + if (s1 !== peg$FAILED) { + s2 = []; + s3 = peg$currPos; + s4 = peg$currPos; + s5 = peg$currPos; + peg$silentFails++; + if (input.charCodeAt(peg$currPos) === 125) { + s6 = peg$c17; + peg$currPos++; + } else { + s6 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e19); + } + } + peg$silentFails--; + if (s6 === peg$FAILED) { + s5 = void 0; + } else { + peg$currPos = s5; + s5 = peg$FAILED; + } + if (s5 !== peg$FAILED) { + s6 = peg$currPos; + peg$silentFails++; + s7 = peg$parsebraced_group(); + peg$silentFails--; + if (s7 === peg$FAILED) { + s6 = void 0; + } else { + peg$currPos = s6; + s6 = peg$FAILED; + } + if (s6 !== peg$FAILED) { + if (input.length > peg$currPos) { + s7 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s7 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e2); + } + } + if (s7 !== peg$FAILED) { + s5 = [s5, s6, s7]; + s4 = s5; + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + if (s4 !== peg$FAILED) { + s3 = input.substring(s3, peg$currPos); + } else { + s3 = s4; + } + if (s3 === peg$FAILED) { + s3 = peg$parsebraced_group(); + } + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$currPos; + s4 = peg$currPos; + s5 = peg$currPos; + peg$silentFails++; + if (input.charCodeAt(peg$currPos) === 125) { + s6 = peg$c17; + peg$currPos++; + } else { + s6 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e19); + } + } + peg$silentFails--; + if (s6 === peg$FAILED) { + s5 = void 0; + } else { + peg$currPos = s5; + s5 = peg$FAILED; + } + if (s5 !== peg$FAILED) { + s6 = peg$currPos; + peg$silentFails++; + s7 = peg$parsebraced_group(); + peg$silentFails--; + if (s7 === peg$FAILED) { + s6 = void 0; + } else { + peg$currPos = s6; + s6 = peg$FAILED; + } + if (s6 !== peg$FAILED) { + if (input.length > peg$currPos) { + s7 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s7 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e2); + } + } + if (s7 !== peg$FAILED) { + s5 = [s5, s6, s7]; + s4 = s5; + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + if (s4 !== peg$FAILED) { + s3 = input.substring(s3, peg$currPos); + } else { + s3 = s4; + } + if (s3 === peg$FAILED) { + s3 = peg$parsebraced_group(); + } + } + if (input.charCodeAt(peg$currPos) === 125) { + s3 = peg$c17; + peg$currPos++; + } else { + s3 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e19); + } + } + if (s3 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f21(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsewhitespace() { + var s0, s1, s2; + s0 = peg$currPos; + s1 = []; + s2 = peg$parsewhitespace_token(); + while (s2 !== peg$FAILED) { + s1.push(s2); + s2 = peg$parsewhitespace_token(); + } + peg$savedPos = s0; + s1 = peg$f22(); + s0 = s1; + return s0; + } + function peg$parsewhitespace_token() { + var s0; + if (input.charCodeAt(peg$currPos) === 32) { + s0 = peg$c18; + peg$currPos++; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e20); + } + } + if (s0 === peg$FAILED) { + if (input.charCodeAt(peg$currPos) === 10) { + s0 = peg$c19; + peg$currPos++; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e21); + } + } + if (s0 === peg$FAILED) { + if (input.charCodeAt(peg$currPos) === 13) { + s0 = peg$c20; + peg$currPos++; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e22); + } + } + } + } + return s0; + } + const DEFAULT_OPTIONS = { + optional: { openBrace: "[", closeBrace: "]" }, + mandatory: { openBrace: "{", closeBrace: "}" } + }; + function createNode(type, options2) { + const computedOptions = DEFAULT_OPTIONS[type] || {}; + return { type, ...computedOptions, ...options2 }; + } + peg$result = peg$startRuleFunction(); + if (peg$result !== peg$FAILED && peg$currPos === input.length) { + return peg$result; + } else { + if (peg$result !== peg$FAILED && peg$currPos < input.length) { + peg$fail(peg$endExpectation()); + } + throw peg$buildStructuredError( + peg$maxFailExpected, + peg$maxFailPos < input.length ? input.charAt(peg$maxFailPos) : null, + peg$maxFailPos < input.length ? peg$computeLocation(peg$maxFailPos, peg$maxFailPos + 1) : peg$computeLocation(peg$maxFailPos, peg$maxFailPos) + ); + } + } + return { + SyntaxError: peg$SyntaxError, + parse: peg$parse + }; + }() +); +var pgfkeys_default = ( + // Generated by Peggy 2.0.1. + // + // https://peggyjs.org/ + function() { + "use strict"; + function peg$subclass(child, parent) { + function C() { + this.constructor = child; + } + C.prototype = parent.prototype; + child.prototype = new C(); + } + function peg$SyntaxError(message, expected, found, location) { + var self = Error.call(this, message); + if (Object.setPrototypeOf) { + Object.setPrototypeOf(self, peg$SyntaxError.prototype); + } + self.expected = expected; + self.found = found; + self.location = location; + self.name = "SyntaxError"; + return self; + } + peg$subclass(peg$SyntaxError, Error); + function peg$padEnd(str, targetLength, padString) { + padString = padString || " "; + if (str.length > targetLength) { + return str; + } + targetLength -= str.length; + padString += padString.repeat(targetLength); + return str + padString.slice(0, targetLength); + } + peg$SyntaxError.prototype.format = function(sources) { + var str = "Error: " + this.message; + if (this.location) { + var src = null; + var k; + for (k = 0; k < sources.length; k++) { + if (sources[k].source === this.location.source) { + src = sources[k].text.split(/\r\n|\n|\r/g); + break; + } + } + var s2 = this.location.start; + var loc = this.location.source + ":" + s2.line + ":" + s2.column; + if (src) { + var e = this.location.end; + var filler = peg$padEnd("", s2.line.toString().length, " "); + var line5 = src[s2.line - 1]; + var last = s2.line === e.line ? e.column : line5.length + 1; + var hatLen = last - s2.column || 1; + str += "\n --> " + loc + "\n" + filler + " |\n" + s2.line + " | " + line5 + "\n" + filler + " | " + peg$padEnd("", s2.column - 1, " ") + peg$padEnd("", hatLen, "^"); + } else { + str += "\n at " + loc; + } + } + return str; + }; + peg$SyntaxError.buildMessage = function(expected, found) { + var DESCRIBE_EXPECTATION_FNS = { + literal: function(expectation) { + return '"' + literalEscape(expectation.text) + '"'; + }, + class: function(expectation) { + var escapedParts = expectation.parts.map(function(part) { + return Array.isArray(part) ? classEscape(part[0]) + "-" + classEscape(part[1]) : classEscape(part); + }); + return "[" + (expectation.inverted ? "^" : "") + escapedParts.join("") + "]"; + }, + any: function() { + return "any character"; + }, + end: function() { + return "end of input"; + }, + other: function(expectation) { + return expectation.description; + } + }; + function hex(ch) { + return ch.charCodeAt(0).toString(16).toUpperCase(); + } + function literalEscape(s2) { + return s2.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\0/g, "\\0").replace(/\t/g, "\\t").replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/[\x00-\x0F]/g, function(ch) { + return "\\x0" + hex(ch); + }).replace(/[\x10-\x1F\x7F-\x9F]/g, function(ch) { + return "\\x" + hex(ch); + }); + } + function classEscape(s2) { + return s2.replace(/\\/g, "\\\\").replace(/\]/g, "\\]").replace(/\^/g, "\\^").replace(/-/g, "\\-").replace(/\0/g, "\\0").replace(/\t/g, "\\t").replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/[\x00-\x0F]/g, function(ch) { + return "\\x0" + hex(ch); + }).replace(/[\x10-\x1F\x7F-\x9F]/g, function(ch) { + return "\\x" + hex(ch); + }); + } + function describeExpectation(expectation) { + return DESCRIBE_EXPECTATION_FNS[expectation.type](expectation); + } + function describeExpected(expected2) { + var descriptions = expected2.map(describeExpectation); + var i, j; + descriptions.sort(); + if (descriptions.length > 0) { + for (i = 1, j = 1; i < descriptions.length; i++) { + if (descriptions[i - 1] !== descriptions[i]) { + descriptions[j] = descriptions[i]; + j++; + } + } + descriptions.length = j; + } + switch (descriptions.length) { + case 1: + return descriptions[0]; + case 2: + return descriptions[0] + " or " + descriptions[1]; + default: + return descriptions.slice(0, -1).join(", ") + ", or " + descriptions[descriptions.length - 1]; + } + } + function describeFound(found2) { + return found2 ? '"' + literalEscape(found2) + '"' : "end of input"; + } + return "Expected " + describeExpected(expected) + " but " + describeFound(found) + " found."; + }; + function peg$parse(input, options) { + options = options !== void 0 ? options : {}; + var peg$FAILED = {}; + var peg$source = options.grammarSource; + var peg$startRuleFunctions = { body: peg$parsebody }; + var peg$startRuleFunction = peg$parsebody; + var peg$e0 = peg$anyExpectation(); + var peg$f0 = function() { + return []; + }; + var peg$f1 = function(rowItems, trailingComment) { + return { + itemParts: [], + ...rowItems, + trailingComment, + trailingComma: true + }; + }; + var peg$f2 = function(rowItems, trailingComment) { + return { ...rowItems, trailingComment }; + }; + var peg$f3 = function(a, b) { + return processItem(a, b); + }; + var peg$f4 = function(b) { + return processItem(null, b); + }; + var peg$f5 = function(cell) { + return { cell }; + }; + var peg$f6 = function() { + return {}; + }; + var peg$f7 = function(part) { + return part; + }; + var peg$f8 = function(x) { + return x; + }; + var peg$f9 = function(space, x) { + return { + trailingComment: x, + leadingParbreak: space.parbreak > 0 + }; + }; + var peg$f10 = function(list) { + return { + whitespace: list.filter((x) => options.isWhitespace(x)).length, + parbreak: list.filter((x) => options.isParbreak(x)).length + }; + }; + var peg$f11 = function() { + return !options.allowParenGroups; + }; + var peg$f12 = function(tok) { + return options.isSameLineComment(tok); + }; + var peg$f13 = function(tok) { + return tok; + }; + var peg$f14 = function(tok) { + return options.isOwnLineComment(tok); + }; + var peg$f15 = function(tok) { + return tok; + }; + var peg$f16 = function(tok) { + return options.isWhitespace(tok); + }; + var peg$f17 = function(tok) { + return tok; + }; + var peg$f18 = function(tok) { + return options.isParbreak(tok); + }; + var peg$f19 = function(tok) { + return tok; + }; + var peg$f20 = function(tok) { + return options.isComma(tok); + }; + var peg$f21 = function(tok) { + return tok; + }; + var peg$f22 = function(tok) { + return options.isEquals(tok); + }; + var peg$f23 = function(tok) { + return tok; + }; + var peg$f24 = function(tok) { + return options.isChar(tok, "("); + }; + var peg$f25 = function(tok) { + return tok; + }; + var peg$f26 = function(tok) { + return options.isChar(tok, ")"); + }; + var peg$f27 = function(tok) { + return tok; + }; + var peg$currPos = 0; + var peg$savedPos = 0; + var peg$posDetailsCache = [{ line: 1, column: 1 }]; + var peg$maxFailPos = 0; + var peg$maxFailExpected = []; + var peg$silentFails = 0; + var peg$result; + if ("startRule" in options) { + if (!(options.startRule in peg$startRuleFunctions)) { + throw new Error(`Can't start parsing from rule "` + options.startRule + '".'); + } + peg$startRuleFunction = peg$startRuleFunctions[options.startRule]; + } + function text() { + return input.substring(peg$savedPos, peg$currPos); + } + function offset() { + return peg$savedPos; + } + function range() { + return { + source: peg$source, + start: peg$savedPos, + end: peg$currPos + }; + } + function location() { + return peg$computeLocation(peg$savedPos, peg$currPos); + } + function expected(description, location2) { + location2 = location2 !== void 0 ? location2 : peg$computeLocation(peg$savedPos, peg$currPos); + throw peg$buildStructuredError( + [peg$otherExpectation(description)], + input.substring(peg$savedPos, peg$currPos), + location2 + ); + } + function error(message, location2) { + location2 = location2 !== void 0 ? location2 : peg$computeLocation(peg$savedPos, peg$currPos); + throw peg$buildSimpleError(message, location2); + } + function peg$literalExpectation(text2, ignoreCase) { + return { type: "literal", text: text2, ignoreCase }; + } + function peg$classExpectation(parts, inverted, ignoreCase) { + return { type: "class", parts, inverted, ignoreCase }; + } + function peg$anyExpectation() { + return { type: "any" }; + } + function peg$endExpectation() { + return { type: "end" }; + } + function peg$otherExpectation(description) { + return { type: "other", description }; + } + function peg$computePosDetails(pos) { + var details = peg$posDetailsCache[pos]; + var p; + if (details) { + return details; + } else { + p = pos - 1; + while (!peg$posDetailsCache[p]) { + p--; + } + details = peg$posDetailsCache[p]; + details = { + line: details.line, + column: details.column + }; + while (p < pos) { + if (input.charCodeAt(p) === 10) { + details.line++; + details.column = 1; + } else { + details.column++; + } + p++; + } + peg$posDetailsCache[pos] = details; + return details; + } + } + function peg$computeLocation(startPos, endPos) { + var startPosDetails = peg$computePosDetails(startPos); + var endPosDetails = peg$computePosDetails(endPos); + return { + source: peg$source, + start: { + offset: startPos, + line: startPosDetails.line, + column: startPosDetails.column + }, + end: { + offset: endPos, + line: endPosDetails.line, + column: endPosDetails.column + } + }; + } + function peg$fail(expected2) { + if (peg$currPos < peg$maxFailPos) { + return; + } + if (peg$currPos > peg$maxFailPos) { + peg$maxFailPos = peg$currPos; + peg$maxFailExpected = []; + } + peg$maxFailExpected.push(expected2); + } + function peg$buildSimpleError(message, location2) { + return new peg$SyntaxError(message, null, null, location2); + } + function peg$buildStructuredError(expected2, found, location2) { + return new peg$SyntaxError( + peg$SyntaxError.buildMessage(expected2, found), + expected2, + found, + location2 + ); + } + function peg$parsebody() { + var s0, s1, s2; + s0 = []; + s1 = peg$parsecomment_only_line(); + if (s1 === peg$FAILED) { + s1 = peg$parseitem_with_end(); + if (s1 === peg$FAILED) { + s1 = peg$parseitem_without_end(); + } + } + if (s1 !== peg$FAILED) { + while (s1 !== peg$FAILED) { + s0.push(s1); + s1 = peg$parsecomment_only_line(); + if (s1 === peg$FAILED) { + s1 = peg$parseitem_with_end(); + if (s1 === peg$FAILED) { + s1 = peg$parseitem_without_end(); + } + } + } + } else { + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = []; + s2 = peg$parsewhitespace(); + while (s2 !== peg$FAILED) { + s1.push(s2); + s2 = peg$parsewhitespace(); + } + s2 = peg$parseEOL(); + if (s2 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f0(); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } + return s0; + } + function peg$parseitem_with_end() { + var s0, s1, s2, s3, s4, s5, s6, s7, s8; + s0 = peg$currPos; + s1 = peg$parsewhitespace_or_parbreaks(); + s2 = peg$parserow_items(); + if (s2 === peg$FAILED) { + s2 = null; + } + s3 = peg$parsewhitespace_or_parbreaks(); + s4 = peg$parseitem_sep(); + if (s4 !== peg$FAILED) { + s5 = []; + s6 = peg$parsewhitespace(); + while (s6 !== peg$FAILED) { + s5.push(s6); + s6 = peg$parsewhitespace(); + } + s6 = peg$parsetrailing_comment(); + if (s6 === peg$FAILED) { + s6 = null; + } + s7 = []; + s8 = peg$parsewhitespace(); + while (s8 !== peg$FAILED) { + s7.push(s8); + s8 = peg$parsewhitespace(); + } + peg$savedPos = s0; + s0 = peg$f1(s2, s6); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parseitem_without_end() { + var s0, s1, s2, s3; + s0 = peg$currPos; + s1 = peg$parsewhitespace_or_parbreaks(); + s2 = peg$parserow_items(); + if (s2 !== peg$FAILED) { + s3 = peg$parsetrailing_comment(); + if (s3 === peg$FAILED) { + s3 = null; + } + peg$savedPos = s0; + s0 = peg$f2(s2, s3); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parserow_items() { + var s0, s1, s2, s3; + s0 = peg$currPos; + s1 = peg$parseitem_part(); + if (s1 !== peg$FAILED) { + s2 = []; + s3 = peg$parseseparated_part(); + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$parseseparated_part(); + } + peg$savedPos = s0; + s0 = peg$f3(s1, s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = []; + s2 = peg$parseseparated_part(); + if (s2 !== peg$FAILED) { + while (s2 !== peg$FAILED) { + s1.push(s2); + s2 = peg$parseseparated_part(); + } + } else { + s1 = peg$FAILED; + } + if (s1 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$f4(s1); + } + s0 = s1; + } + return s0; + } + function peg$parseseparated_part() { + var s0, s1, s2, s3, s4; + s0 = peg$currPos; + s1 = []; + s2 = peg$parseparbreak(); + while (s2 !== peg$FAILED) { + s1.push(s2); + s2 = peg$parseparbreak(); + } + s2 = peg$parseequals(); + if (s2 !== peg$FAILED) { + s3 = []; + s4 = peg$parseparbreak(); + while (s4 !== peg$FAILED) { + s3.push(s4); + s4 = peg$parseparbreak(); + } + s4 = peg$parseitem_part(); + if (s4 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f5(s4); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = []; + s2 = peg$parseparbreak(); + while (s2 !== peg$FAILED) { + s1.push(s2); + s2 = peg$parseparbreak(); + } + s2 = peg$parseequals(); + if (s2 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f6(); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } + return s0; + } + function peg$parseitem_part() { + var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9; + s0 = peg$currPos; + s1 = []; + s2 = peg$parsewhitespace(); + while (s2 !== peg$FAILED) { + s1.push(s2); + s2 = peg$parsewhitespace(); + } + s2 = peg$currPos; + s3 = []; + s4 = peg$parsenon_whitespace_non_parbreak_token(); + if (s4 === peg$FAILED) { + s4 = peg$currPos; + s5 = peg$parsewhitespace(); + if (s5 === peg$FAILED) { + s5 = peg$parseparbreak(); + } + if (s5 !== peg$FAILED) { + s6 = peg$currPos; + peg$silentFails++; + s7 = peg$currPos; + s8 = []; + s9 = peg$parsewhitespace(); + if (s9 === peg$FAILED) { + s9 = peg$parseparbreak(); + } + while (s9 !== peg$FAILED) { + s8.push(s9); + s9 = peg$parsewhitespace(); + if (s9 === peg$FAILED) { + s9 = peg$parseparbreak(); + } + } + s9 = peg$parsenon_whitespace_non_parbreak_token(); + if (s9 !== peg$FAILED) { + s8 = [s8, s9]; + s7 = s8; + } else { + peg$currPos = s7; + s7 = peg$FAILED; + } + peg$silentFails--; + if (s7 !== peg$FAILED) { + peg$currPos = s6; + s6 = void 0; + } else { + s6 = peg$FAILED; + } + if (s6 !== peg$FAILED) { + s5 = [s5, s6]; + s4 = s5; + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + } + if (s4 !== peg$FAILED) { + while (s4 !== peg$FAILED) { + s3.push(s4); + s4 = peg$parsenon_whitespace_non_parbreak_token(); + if (s4 === peg$FAILED) { + s4 = peg$currPos; + s5 = peg$parsewhitespace(); + if (s5 === peg$FAILED) { + s5 = peg$parseparbreak(); + } + if (s5 !== peg$FAILED) { + s6 = peg$currPos; + peg$silentFails++; + s7 = peg$currPos; + s8 = []; + s9 = peg$parsewhitespace(); + if (s9 === peg$FAILED) { + s9 = peg$parseparbreak(); + } + while (s9 !== peg$FAILED) { + s8.push(s9); + s9 = peg$parsewhitespace(); + if (s9 === peg$FAILED) { + s9 = peg$parseparbreak(); + } + } + s9 = peg$parsenon_whitespace_non_parbreak_token(); + if (s9 !== peg$FAILED) { + s8 = [s8, s9]; + s7 = s8; + } else { + peg$currPos = s7; + s7 = peg$FAILED; + } + peg$silentFails--; + if (s7 !== peg$FAILED) { + peg$currPos = s6; + s6 = void 0; + } else { + s6 = peg$FAILED; + } + if (s6 !== peg$FAILED) { + s5 = [s5, s6]; + s4 = s5; + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + } + } + } else { + s3 = peg$FAILED; + } + if (s3 !== peg$FAILED) { + s2 = input.substring(s2, peg$currPos); + } else { + s2 = s3; + } + if (s2 !== peg$FAILED) { + s3 = []; + s4 = peg$parsewhitespace(); + while (s4 !== peg$FAILED) { + s3.push(s4); + s4 = peg$parsewhitespace(); + } + peg$savedPos = s0; + s0 = peg$f7(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsetrailing_comment() { + var s0, s1, s2; + s0 = peg$currPos; + s1 = []; + s2 = peg$parsewhitespace(); + while (s2 !== peg$FAILED) { + s1.push(s2); + s2 = peg$parsewhitespace(); + } + s2 = peg$parsesame_line_comment(); + if (s2 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f8(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsecomment_only_line() { + var s0, s1, s2; + s0 = peg$currPos; + s1 = peg$parsewhitespace_or_parbreaks(); + s2 = peg$parseown_line_comment(); + if (s2 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f9(s1, s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsetoken() { + var s0, s1, s2, s3; + s0 = peg$currPos; + s1 = peg$currPos; + s2 = peg$currPos; + peg$silentFails++; + s3 = peg$parsenon_token(); + peg$silentFails--; + if (s3 === peg$FAILED) { + s2 = void 0; + } else { + peg$currPos = s2; + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + if (input.length > peg$currPos) { + s3 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s3 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s3 !== peg$FAILED) { + s2 = [s2, s3]; + s1 = s2; + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + if (s1 !== peg$FAILED) { + s0 = input.substring(s0, peg$currPos); + } else { + s0 = s1; + } + return s0; + } + function peg$parsenon_whitespace_non_parbreak_token() { + var s0, s1, s2, s3; + s0 = peg$currPos; + s1 = peg$currPos; + s2 = peg$currPos; + peg$silentFails++; + s3 = peg$parsewhitespace(); + if (s3 === peg$FAILED) { + s3 = peg$parseparbreak(); + } + peg$silentFails--; + if (s3 === peg$FAILED) { + s2 = void 0; + } else { + peg$currPos = s2; + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s3 = peg$parseparen_block(); + if (s3 === peg$FAILED) { + s3 = peg$parsetoken(); + } + if (s3 !== peg$FAILED) { + s2 = [s2, s3]; + s1 = s2; + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + if (s1 !== peg$FAILED) { + s0 = input.substring(s0, peg$currPos); + } else { + s0 = s1; + } + return s0; + } + function peg$parsenon_token() { + var s0; + s0 = peg$parseitem_sep(); + if (s0 === peg$FAILED) { + s0 = peg$parseequals(); + if (s0 === peg$FAILED) { + s0 = peg$parsetrailing_comment(); + if (s0 === peg$FAILED) { + s0 = peg$parseown_line_comment(); + } + } + } + return s0; + } + function peg$parsewhitespace_or_parbreaks() { + var s0, s1, s2; + s0 = peg$currPos; + s1 = []; + s2 = peg$parsewhitespace(); + if (s2 === peg$FAILED) { + s2 = peg$parseparbreak(); + } + while (s2 !== peg$FAILED) { + s1.push(s2); + s2 = peg$parsewhitespace(); + if (s2 === peg$FAILED) { + s2 = peg$parseparbreak(); + } + } + peg$savedPos = s0; + s1 = peg$f10(s1); + s0 = s1; + return s0; + } + function peg$parseparen_block() { + var s0, s1, s2, s3, s4, s5, s6, s7, s8; + s0 = peg$currPos; + peg$savedPos = peg$currPos; + s1 = peg$f11(); + if (s1) { + s1 = peg$FAILED; + } else { + s1 = void 0; + } + if (s1 !== peg$FAILED) { + s2 = peg$currPos; + s3 = peg$currPos; + s4 = peg$parseopen_paren(); + if (s4 !== peg$FAILED) { + s5 = []; + s6 = peg$currPos; + s7 = peg$currPos; + peg$silentFails++; + s8 = peg$parseclose_paren(); + peg$silentFails--; + if (s8 === peg$FAILED) { + s7 = void 0; + } else { + peg$currPos = s7; + s7 = peg$FAILED; + } + if (s7 !== peg$FAILED) { + if (input.length > peg$currPos) { + s8 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s8 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s8 !== peg$FAILED) { + s7 = [s7, s8]; + s6 = s7; + } else { + peg$currPos = s6; + s6 = peg$FAILED; + } + } else { + peg$currPos = s6; + s6 = peg$FAILED; + } + while (s6 !== peg$FAILED) { + s5.push(s6); + s6 = peg$currPos; + s7 = peg$currPos; + peg$silentFails++; + s8 = peg$parseclose_paren(); + peg$silentFails--; + if (s8 === peg$FAILED) { + s7 = void 0; + } else { + peg$currPos = s7; + s7 = peg$FAILED; + } + if (s7 !== peg$FAILED) { + if (input.length > peg$currPos) { + s8 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s8 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s8 !== peg$FAILED) { + s7 = [s7, s8]; + s6 = s7; + } else { + peg$currPos = s6; + s6 = peg$FAILED; + } + } else { + peg$currPos = s6; + s6 = peg$FAILED; + } + } + s6 = peg$parseclose_paren(); + if (s6 !== peg$FAILED) { + s4 = [s4, s5, s6]; + s3 = s4; + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + if (s3 !== peg$FAILED) { + s2 = input.substring(s2, peg$currPos); + } else { + s2 = s3; + } + if (s2 !== peg$FAILED) { + s1 = [s1, s2]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsesame_line_comment() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + peg$savedPos = peg$currPos; + s2 = peg$f12(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f13(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parseown_line_comment() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + peg$savedPos = peg$currPos; + s2 = peg$f14(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f15(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsewhitespace() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + peg$savedPos = peg$currPos; + s2 = peg$f16(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f17(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parseparbreak() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + peg$savedPos = peg$currPos; + s2 = peg$f18(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f19(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parseitem_sep() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + peg$savedPos = peg$currPos; + s2 = peg$f20(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f21(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parseequals() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + peg$savedPos = peg$currPos; + s2 = peg$f22(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f23(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parseopen_paren() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + peg$savedPos = peg$currPos; + s2 = peg$f24(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f25(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parseclose_paren() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + peg$savedPos = peg$currPos; + s2 = peg$f26(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f27(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parseEOL() { + var s0, s1; + s0 = peg$currPos; + peg$silentFails++; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + peg$silentFails--; + if (s1 === peg$FAILED) { + s0 = void 0; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function processItem(leadCell, otherCells) { + const cells = [leadCell || []]; + for (const x of otherCells) { + cells.push(x.cell || []); + } + return { itemParts: cells }; + } + if (!options.isWhitespace) { + try { + Object.assign(options, { + isChar: (node, char) => node.type === "string" && node.content === char, + isComma(node) { + return node.type === "string" && node.content === ","; + }, + isEquals(node) { + return node.type === "string" && node.content === "="; + }, + isParbreak(node) { + return node.type === "parbreak"; + }, + isWhitespace(node) { + return node.type === "whitespace"; + }, + isSameLineComment: (node) => node.type === "comment" && node.sameline, + isOwnLineComment: (node) => node.type === "comment" && !node.sameline, + isComment: (node) => node.type === "comment", + allowParenGroups: true + }); + } catch (e) { + console.warn("Error when initializing parser", e); + } + } + peg$result = peg$startRuleFunction(); + if (peg$result !== peg$FAILED && peg$currPos === input.length) { + return peg$result; + } else { + if (peg$result !== peg$FAILED && peg$currPos < input.length) { + peg$fail(peg$endExpectation()); + } + throw peg$buildStructuredError( + peg$maxFailExpected, + peg$maxFailPos < input.length ? input.charAt(peg$maxFailPos) : null, + peg$maxFailPos < input.length ? peg$computeLocation(peg$maxFailPos, peg$maxFailPos + 1) : peg$computeLocation(peg$maxFailPos, peg$maxFailPos) + ); + } + } + return { + SyntaxError: peg$SyntaxError, + parse: peg$parse + }; + }() +); +var macro_substitutions_default = ( + // Generated by Peggy 2.0.1. + // + // https://peggyjs.org/ + function() { + "use strict"; + function peg$subclass(child, parent) { + function C() { + this.constructor = child; + } + C.prototype = parent.prototype; + child.prototype = new C(); + } + function peg$SyntaxError(message, expected, found, location) { + var self = Error.call(this, message); + if (Object.setPrototypeOf) { + Object.setPrototypeOf(self, peg$SyntaxError.prototype); + } + self.expected = expected; + self.found = found; + self.location = location; + self.name = "SyntaxError"; + return self; + } + peg$subclass(peg$SyntaxError, Error); + function peg$padEnd(str, targetLength, padString) { + padString = padString || " "; + if (str.length > targetLength) { + return str; + } + targetLength -= str.length; + padString += padString.repeat(targetLength); + return str + padString.slice(0, targetLength); + } + peg$SyntaxError.prototype.format = function(sources) { + var str = "Error: " + this.message; + if (this.location) { + var src = null; + var k; + for (k = 0; k < sources.length; k++) { + if (sources[k].source === this.location.source) { + src = sources[k].text.split(/\r\n|\n|\r/g); + break; + } + } + var s2 = this.location.start; + var loc = this.location.source + ":" + s2.line + ":" + s2.column; + if (src) { + var e = this.location.end; + var filler = peg$padEnd("", s2.line.toString().length, " "); + var line5 = src[s2.line - 1]; + var last = s2.line === e.line ? e.column : line5.length + 1; + var hatLen = last - s2.column || 1; + str += "\n --> " + loc + "\n" + filler + " |\n" + s2.line + " | " + line5 + "\n" + filler + " | " + peg$padEnd("", s2.column - 1, " ") + peg$padEnd("", hatLen, "^"); + } else { + str += "\n at " + loc; + } + } + return str; + }; + peg$SyntaxError.buildMessage = function(expected, found) { + var DESCRIBE_EXPECTATION_FNS = { + literal: function(expectation) { + return '"' + literalEscape(expectation.text) + '"'; + }, + class: function(expectation) { + var escapedParts = expectation.parts.map(function(part) { + return Array.isArray(part) ? classEscape(part[0]) + "-" + classEscape(part[1]) : classEscape(part); + }); + return "[" + (expectation.inverted ? "^" : "") + escapedParts.join("") + "]"; + }, + any: function() { + return "any character"; + }, + end: function() { + return "end of input"; + }, + other: function(expectation) { + return expectation.description; + } + }; + function hex(ch) { + return ch.charCodeAt(0).toString(16).toUpperCase(); + } + function literalEscape(s2) { + return s2.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\0/g, "\\0").replace(/\t/g, "\\t").replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/[\x00-\x0F]/g, function(ch) { + return "\\x0" + hex(ch); + }).replace(/[\x10-\x1F\x7F-\x9F]/g, function(ch) { + return "\\x" + hex(ch); + }); + } + function classEscape(s2) { + return s2.replace(/\\/g, "\\\\").replace(/\]/g, "\\]").replace(/\^/g, "\\^").replace(/-/g, "\\-").replace(/\0/g, "\\0").replace(/\t/g, "\\t").replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/[\x00-\x0F]/g, function(ch) { + return "\\x0" + hex(ch); + }).replace(/[\x10-\x1F\x7F-\x9F]/g, function(ch) { + return "\\x" + hex(ch); + }); + } + function describeExpectation(expectation) { + return DESCRIBE_EXPECTATION_FNS[expectation.type](expectation); + } + function describeExpected(expected2) { + var descriptions = expected2.map(describeExpectation); + var i, j; + descriptions.sort(); + if (descriptions.length > 0) { + for (i = 1, j = 1; i < descriptions.length; i++) { + if (descriptions[i - 1] !== descriptions[i]) { + descriptions[j] = descriptions[i]; + j++; + } + } + descriptions.length = j; + } + switch (descriptions.length) { + case 1: + return descriptions[0]; + case 2: + return descriptions[0] + " or " + descriptions[1]; + default: + return descriptions.slice(0, -1).join(", ") + ", or " + descriptions[descriptions.length - 1]; + } + } + function describeFound(found2) { + return found2 ? '"' + literalEscape(found2) + '"' : "end of input"; + } + return "Expected " + describeExpected(expected) + " but " + describeFound(found) + " found."; + }; + function peg$parse(input, options) { + options = options !== void 0 ? options : {}; + var peg$FAILED = {}; + var peg$source = options.grammarSource; + var peg$startRuleFunctions = { body: peg$parsebody }; + var peg$startRuleFunction = peg$parsebody; + var peg$e0 = peg$anyExpectation(); + var peg$f0 = function(e) { + return [].concat(...e).filter((n) => !!n); + }; + var peg$f1 = function() { + return []; + }; + var peg$f2 = function(tok) { + return options.isHash(tok); + }; + var peg$f3 = function(tok) { + return tok; + }; + var peg$f4 = function(tok) { + return options.isNumber(tok); + }; + var peg$f5 = function(tok) { + return tok; + }; + var peg$f6 = function() { + return { type: "string", content: "#" }; + }; + var peg$f7 = function(num) { + const split = options.splitNumber(num); + return [{ type: "hash_number", number: split.number }, split.rest]; + }; + var peg$currPos = 0; + var peg$savedPos = 0; + var peg$posDetailsCache = [{ line: 1, column: 1 }]; + var peg$maxFailPos = 0; + var peg$maxFailExpected = []; + var peg$silentFails = 0; + var peg$result; + if ("startRule" in options) { + if (!(options.startRule in peg$startRuleFunctions)) { + throw new Error(`Can't start parsing from rule "` + options.startRule + '".'); + } + peg$startRuleFunction = peg$startRuleFunctions[options.startRule]; + } + function text() { + return input.substring(peg$savedPos, peg$currPos); + } + function offset() { + return peg$savedPos; + } + function range() { + return { + source: peg$source, + start: peg$savedPos, + end: peg$currPos + }; + } + function location() { + return peg$computeLocation(peg$savedPos, peg$currPos); + } + function expected(description, location2) { + location2 = location2 !== void 0 ? location2 : peg$computeLocation(peg$savedPos, peg$currPos); + throw peg$buildStructuredError( + [peg$otherExpectation(description)], + input.substring(peg$savedPos, peg$currPos), + location2 + ); + } + function error(message, location2) { + location2 = location2 !== void 0 ? location2 : peg$computeLocation(peg$savedPos, peg$currPos); + throw peg$buildSimpleError(message, location2); + } + function peg$literalExpectation(text2, ignoreCase) { + return { type: "literal", text: text2, ignoreCase }; + } + function peg$classExpectation(parts, inverted, ignoreCase) { + return { type: "class", parts, inverted, ignoreCase }; + } + function peg$anyExpectation() { + return { type: "any" }; + } + function peg$endExpectation() { + return { type: "end" }; + } + function peg$otherExpectation(description) { + return { type: "other", description }; + } + function peg$computePosDetails(pos) { + var details = peg$posDetailsCache[pos]; + var p; + if (details) { + return details; + } else { + p = pos - 1; + while (!peg$posDetailsCache[p]) { + p--; + } + details = peg$posDetailsCache[p]; + details = { + line: details.line, + column: details.column + }; + while (p < pos) { + if (input.charCodeAt(p) === 10) { + details.line++; + details.column = 1; + } else { + details.column++; + } + p++; + } + peg$posDetailsCache[pos] = details; + return details; + } + } + function peg$computeLocation(startPos, endPos) { + var startPosDetails = peg$computePosDetails(startPos); + var endPosDetails = peg$computePosDetails(endPos); + return { + source: peg$source, + start: { + offset: startPos, + line: startPosDetails.line, + column: startPosDetails.column + }, + end: { + offset: endPos, + line: endPosDetails.line, + column: endPosDetails.column + } + }; + } + function peg$fail(expected2) { + if (peg$currPos < peg$maxFailPos) { + return; + } + if (peg$currPos > peg$maxFailPos) { + peg$maxFailPos = peg$currPos; + peg$maxFailExpected = []; + } + peg$maxFailExpected.push(expected2); + } + function peg$buildSimpleError(message, location2) { + return new peg$SyntaxError(message, null, null, location2); + } + function peg$buildStructuredError(expected2, found, location2) { + return new peg$SyntaxError( + peg$SyntaxError.buildMessage(expected2, found), + expected2, + found, + location2 + ); + } + function peg$parsebody() { + var s0, s1, s2; + s0 = peg$currPos; + s1 = []; + s2 = peg$parsedouble_hash(); + if (s2 === peg$FAILED) { + s2 = peg$parsehash_number(); + if (s2 === peg$FAILED) { + if (input.length > peg$currPos) { + s2 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + } + } + if (s2 !== peg$FAILED) { + while (s2 !== peg$FAILED) { + s1.push(s2); + s2 = peg$parsedouble_hash(); + if (s2 === peg$FAILED) { + s2 = peg$parsehash_number(); + if (s2 === peg$FAILED) { + if (input.length > peg$currPos) { + s2 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + } + } + } + } else { + s1 = peg$FAILED; + } + if (s1 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$f0(s1); + } + s0 = s1; + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$parseEOL(); + if (s1 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$f1(); + } + s0 = s1; + } + return s0; + } + function peg$parsehash() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + peg$savedPos = peg$currPos; + s2 = peg$f2(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f3(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsenumber() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + peg$savedPos = peg$currPos; + s2 = peg$f4(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f5(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsedouble_hash() { + var s0, s1, s2; + s0 = peg$currPos; + s1 = peg$parsehash(); + if (s1 !== peg$FAILED) { + s2 = peg$parsehash(); + if (s2 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f6(); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsehash_number() { + var s0, s1, s2; + s0 = peg$currPos; + s1 = peg$parsehash(); + if (s1 !== peg$FAILED) { + s2 = peg$parsenumber(); + if (s2 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f7(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parseEOL() { + var s0, s1; + s0 = peg$currPos; + peg$silentFails++; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + peg$silentFails--; + if (s1 === peg$FAILED) { + s0 = void 0; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + if (!options.isHash) { + try { + Object.assign(options, { + isHash: (node) => node.type === "string" && node.content === "#", + isNumber: (node) => node.type === "string" && 0 < +node.content.charAt(0), + splitNumber: (node) => { + const number = +node.content.charAt(0); + if (node.content.length > 1) { + return { + number, + rest: { + type: "string", + content: node.content.slice(1) + } + }; + } + return { number }; + } + }); + } catch (e) { + console.warn("Error when initializing parser", e); + } + } + peg$result = peg$startRuleFunction(); + if (peg$result !== peg$FAILED && peg$currPos === input.length) { + return peg$result; + } else { + if (peg$result !== peg$FAILED && peg$currPos < input.length) { + peg$fail(peg$endExpectation()); + } + throw peg$buildStructuredError( + peg$maxFailExpected, + peg$maxFailPos < input.length ? input.charAt(peg$maxFailPos) : null, + peg$maxFailPos < input.length ? peg$computeLocation(peg$maxFailPos, peg$maxFailPos + 1) : peg$computeLocation(peg$maxFailPos, peg$maxFailPos) + ); + } + } + return { + SyntaxError: peg$SyntaxError, + parse: peg$parse + }; + }() +); +var ligatures_default = ( + // Generated by Peggy 2.0.1. + // + // https://peggyjs.org/ + function() { + "use strict"; + function peg$subclass(child, parent) { + function C() { + this.constructor = child; + } + C.prototype = parent.prototype; + child.prototype = new C(); + } + function peg$SyntaxError(message, expected, found, location) { + var self = Error.call(this, message); + if (Object.setPrototypeOf) { + Object.setPrototypeOf(self, peg$SyntaxError.prototype); + } + self.expected = expected; + self.found = found; + self.location = location; + self.name = "SyntaxError"; + return self; + } + peg$subclass(peg$SyntaxError, Error); + function peg$padEnd(str, targetLength, padString) { + padString = padString || " "; + if (str.length > targetLength) { + return str; + } + targetLength -= str.length; + padString += padString.repeat(targetLength); + return str + padString.slice(0, targetLength); + } + peg$SyntaxError.prototype.format = function(sources) { + var str = "Error: " + this.message; + if (this.location) { + var src = null; + var k; + for (k = 0; k < sources.length; k++) { + if (sources[k].source === this.location.source) { + src = sources[k].text.split(/\r\n|\n|\r/g); + break; + } + } + var s2 = this.location.start; + var loc = this.location.source + ":" + s2.line + ":" + s2.column; + if (src) { + var e = this.location.end; + var filler = peg$padEnd("", s2.line.toString().length, " "); + var line5 = src[s2.line - 1]; + var last = s2.line === e.line ? e.column : line5.length + 1; + var hatLen = last - s2.column || 1; + str += "\n --> " + loc + "\n" + filler + " |\n" + s2.line + " | " + line5 + "\n" + filler + " | " + peg$padEnd("", s2.column - 1, " ") + peg$padEnd("", hatLen, "^"); + } else { + str += "\n at " + loc; + } + } + return str; + }; + peg$SyntaxError.buildMessage = function(expected, found) { + var DESCRIBE_EXPECTATION_FNS = { + literal: function(expectation) { + return '"' + literalEscape(expectation.text) + '"'; + }, + class: function(expectation) { + var escapedParts = expectation.parts.map(function(part) { + return Array.isArray(part) ? classEscape(part[0]) + "-" + classEscape(part[1]) : classEscape(part); + }); + return "[" + (expectation.inverted ? "^" : "") + escapedParts.join("") + "]"; + }, + any: function() { + return "any character"; + }, + end: function() { + return "end of input"; + }, + other: function(expectation) { + return expectation.description; + } + }; + function hex(ch) { + return ch.charCodeAt(0).toString(16).toUpperCase(); + } + function literalEscape(s2) { + return s2.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\0/g, "\\0").replace(/\t/g, "\\t").replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/[\x00-\x0F]/g, function(ch) { + return "\\x0" + hex(ch); + }).replace(/[\x10-\x1F\x7F-\x9F]/g, function(ch) { + return "\\x" + hex(ch); + }); + } + function classEscape(s2) { + return s2.replace(/\\/g, "\\\\").replace(/\]/g, "\\]").replace(/\^/g, "\\^").replace(/-/g, "\\-").replace(/\0/g, "\\0").replace(/\t/g, "\\t").replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/[\x00-\x0F]/g, function(ch) { + return "\\x0" + hex(ch); + }).replace(/[\x10-\x1F\x7F-\x9F]/g, function(ch) { + return "\\x" + hex(ch); + }); + } + function describeExpectation(expectation) { + return DESCRIBE_EXPECTATION_FNS[expectation.type](expectation); + } + function describeExpected(expected2) { + var descriptions = expected2.map(describeExpectation); + var i, j; + descriptions.sort(); + if (descriptions.length > 0) { + for (i = 1, j = 1; i < descriptions.length; i++) { + if (descriptions[i - 1] !== descriptions[i]) { + descriptions[j] = descriptions[i]; + j++; + } + } + descriptions.length = j; + } + switch (descriptions.length) { + case 1: + return descriptions[0]; + case 2: + return descriptions[0] + " or " + descriptions[1]; + default: + return descriptions.slice(0, -1).join(", ") + ", or " + descriptions[descriptions.length - 1]; + } + } + function describeFound(found2) { + return found2 ? '"' + literalEscape(found2) + '"' : "end of input"; + } + return "Expected " + describeExpected(expected) + " but " + describeFound(found) + " found."; + }; + function peg$parse(input, options) { + options = options !== void 0 ? options : {}; + var peg$FAILED = {}; + var peg$source = options.grammarSource; + var peg$startRuleFunctions = { body: peg$parsebody }; + var peg$startRuleFunction = peg$parsebody; + var peg$e0 = peg$anyExpectation(); + var peg$f0 = function(e) { + return [].concat(...e).filter((n) => !!n); + }; + var peg$f1 = function() { + return []; + }; + var peg$f2 = function(toks) { + return options.isRecognized(toks); + }; + var peg$f3 = function(toks) { + return options.isRecognized(toks); + }; + var peg$f4 = function(tok1, tok2) { + const split = options.split(tok2); + return options.isRecognized([tok1, split[0]]); + }; + var peg$f5 = function(tok1, tok2) { + const split = options.split(tok2); + return [options.isRecognized([tok1, split[0]]), split[1]]; + }; + var peg$f6 = function(tok1, tok2) { + return options.isRecognized([tok1, tok2]); + }; + var peg$f7 = function(tok1, tok2) { + return options.isRecognized([tok1, tok2]); + }; + var peg$f8 = function(toks) { + return options.isRecognized(toks); + }; + var peg$f9 = function(toks) { + return options.isRecognized(toks); + }; + var peg$f10 = function(tok) { + return options.isRecognized([tok]); + }; + var peg$f11 = function(tok) { + return options.isRecognized([tok]); + }; + var peg$f12 = function(tok) { + return options.isMacro(tok); + }; + var peg$f13 = function(tok) { + return tok; + }; + var peg$f14 = function(tok) { + return options.isWhitespace(tok); + }; + var peg$f15 = function(tok) { + return tok; + }; + var peg$f16 = function(tok) { + return options.isSplitable(tok); + }; + var peg$f17 = function(tok) { + return tok; + }; + var peg$currPos = 0; + var peg$savedPos = 0; + var peg$posDetailsCache = [{ line: 1, column: 1 }]; + var peg$maxFailPos = 0; + var peg$maxFailExpected = []; + var peg$silentFails = 0; + var peg$result; + if ("startRule" in options) { + if (!(options.startRule in peg$startRuleFunctions)) { + throw new Error(`Can't start parsing from rule "` + options.startRule + '".'); + } + peg$startRuleFunction = peg$startRuleFunctions[options.startRule]; + } + function text() { + return input.substring(peg$savedPos, peg$currPos); + } + function offset() { + return peg$savedPos; + } + function range() { + return { + source: peg$source, + start: peg$savedPos, + end: peg$currPos + }; + } + function location() { + return peg$computeLocation(peg$savedPos, peg$currPos); + } + function expected(description, location2) { + location2 = location2 !== void 0 ? location2 : peg$computeLocation(peg$savedPos, peg$currPos); + throw peg$buildStructuredError( + [peg$otherExpectation(description)], + input.substring(peg$savedPos, peg$currPos), + location2 + ); + } + function error(message, location2) { + location2 = location2 !== void 0 ? location2 : peg$computeLocation(peg$savedPos, peg$currPos); + throw peg$buildSimpleError(message, location2); + } + function peg$literalExpectation(text2, ignoreCase) { + return { type: "literal", text: text2, ignoreCase }; + } + function peg$classExpectation(parts, inverted, ignoreCase) { + return { type: "class", parts, inverted, ignoreCase }; + } + function peg$anyExpectation() { + return { type: "any" }; + } + function peg$endExpectation() { + return { type: "end" }; + } + function peg$otherExpectation(description) { + return { type: "other", description }; + } + function peg$computePosDetails(pos) { + var details = peg$posDetailsCache[pos]; + var p; + if (details) { + return details; + } else { + p = pos - 1; + while (!peg$posDetailsCache[p]) { + p--; + } + details = peg$posDetailsCache[p]; + details = { + line: details.line, + column: details.column + }; + while (p < pos) { + if (input.charCodeAt(p) === 10) { + details.line++; + details.column = 1; + } else { + details.column++; + } + p++; + } + peg$posDetailsCache[pos] = details; + return details; + } + } + function peg$computeLocation(startPos, endPos) { + var startPosDetails = peg$computePosDetails(startPos); + var endPosDetails = peg$computePosDetails(endPos); + return { + source: peg$source, + start: { + offset: startPos, + line: startPosDetails.line, + column: startPosDetails.column + }, + end: { + offset: endPos, + line: endPosDetails.line, + column: endPosDetails.column + } + }; + } + function peg$fail(expected2) { + if (peg$currPos < peg$maxFailPos) { + return; + } + if (peg$currPos > peg$maxFailPos) { + peg$maxFailPos = peg$currPos; + peg$maxFailExpected = []; + } + peg$maxFailExpected.push(expected2); + } + function peg$buildSimpleError(message, location2) { + return new peg$SyntaxError(message, null, null, location2); + } + function peg$buildStructuredError(expected2, found, location2) { + return new peg$SyntaxError( + peg$SyntaxError.buildMessage(expected2, found), + expected2, + found, + location2 + ); + } + function peg$parsebody() { + var s0, s1, s2; + s0 = peg$currPos; + s1 = []; + s2 = peg$parsetriple_ligature(); + if (s2 === peg$FAILED) { + s2 = peg$parsedouble_ligature(); + if (s2 === peg$FAILED) { + s2 = peg$parsemono_ligature(); + if (s2 === peg$FAILED) { + if (input.length > peg$currPos) { + s2 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + } + } + } + if (s2 !== peg$FAILED) { + while (s2 !== peg$FAILED) { + s1.push(s2); + s2 = peg$parsetriple_ligature(); + if (s2 === peg$FAILED) { + s2 = peg$parsedouble_ligature(); + if (s2 === peg$FAILED) { + s2 = peg$parsemono_ligature(); + if (s2 === peg$FAILED) { + if (input.length > peg$currPos) { + s2 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + } + } + } + } + } else { + s1 = peg$FAILED; + } + if (s1 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$f0(s1); + } + s0 = s1; + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$parseEOL(); + if (s1 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$f1(); + } + s0 = s1; + } + return s0; + } + function peg$parsetriple_ligature() { + var s0, s1, s2, s3, s4; + s0 = peg$currPos; + s1 = peg$currPos; + if (input.length > peg$currPos) { + s2 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s2 !== peg$FAILED) { + if (input.length > peg$currPos) { + s3 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s3 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s3 !== peg$FAILED) { + if (input.length > peg$currPos) { + s4 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s4 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s4 !== peg$FAILED) { + s2 = [s2, s3, s4]; + s1 = s2; + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + if (s1 !== peg$FAILED) { + peg$savedPos = peg$currPos; + s2 = peg$f2(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f3(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsedouble_ligature() { + var s0; + s0 = peg$parsedouble_macro_ligature(); + if (s0 === peg$FAILED) { + s0 = peg$parsedouble_macro_ligature_extracted(); + if (s0 === peg$FAILED) { + s0 = peg$parsedouble_char_ligature(); + } + } + return s0; + } + function peg$parsedouble_macro_ligature_extracted() { + var s0, s1, s2, s3, s4; + s0 = peg$currPos; + s1 = peg$parsemacro(); + if (s1 !== peg$FAILED) { + s2 = []; + s3 = peg$parsewhitespace(); + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$parsewhitespace(); + } + s3 = peg$parsesplitable(); + if (s3 !== peg$FAILED) { + peg$savedPos = peg$currPos; + s4 = peg$f4(s1, s3); + if (s4) { + s4 = void 0; + } else { + s4 = peg$FAILED; + } + if (s4 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f5(s1, s3); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsedouble_macro_ligature() { + var s0, s1, s2, s3, s4; + s0 = peg$currPos; + s1 = peg$parsemacro(); + if (s1 !== peg$FAILED) { + s2 = []; + s3 = peg$parsewhitespace(); + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$parsewhitespace(); + } + if (input.length > peg$currPos) { + s3 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s3 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s3 !== peg$FAILED) { + peg$savedPos = peg$currPos; + s4 = peg$f6(s1, s3); + if (s4) { + s4 = void 0; + } else { + s4 = peg$FAILED; + } + if (s4 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f7(s1, s3); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsedouble_char_ligature() { + var s0, s1, s2, s3; + s0 = peg$currPos; + s1 = peg$currPos; + if (input.length > peg$currPos) { + s2 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s2 !== peg$FAILED) { + if (input.length > peg$currPos) { + s3 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s3 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s3 !== peg$FAILED) { + s2 = [s2, s3]; + s1 = s2; + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + if (s1 !== peg$FAILED) { + peg$savedPos = peg$currPos; + s2 = peg$f8(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f9(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsemono_ligature() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + peg$savedPos = peg$currPos; + s2 = peg$f10(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f11(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsemacro() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + peg$savedPos = peg$currPos; + s2 = peg$f12(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f13(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsewhitespace() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + peg$savedPos = peg$currPos; + s2 = peg$f14(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f15(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsesplitable() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + peg$savedPos = peg$currPos; + s2 = peg$f16(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f17(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parseEOL() { + var s0, s1; + s0 = peg$currPos; + peg$silentFails++; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + peg$silentFails--; + if (s1 === peg$FAILED) { + s0 = void 0; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + if (!options.isWhitespace) { + try { + Object.assign(options, { + isMacro: (node) => node.type === "macro", + isWhitespace: (node) => node.type === "whitespace", + isRecognized: (nodes) => { + if (nodes.length == 2 && nodes[0].content === "^" && nodes[1].content === "o") { + return { type: "string", content: "\xF4" }; + } + return null; + }, + isSplitable: (node) => node.type === "string" && node.content.length > 1, + split: (node) => [ + { type: "string", content: node.content.charAt(0) }, + { type: "string", content: node.content.slice(1) } + ] + }); + } catch (e) { + console.warn("Error when initializing parser", e); + } + } + peg$result = peg$startRuleFunction(); + if (peg$result !== peg$FAILED && peg$currPos === input.length) { + return peg$result; + } else { + if (peg$result !== peg$FAILED && peg$currPos < input.length) { + peg$fail(peg$endExpectation()); + } + throw peg$buildStructuredError( + peg$maxFailExpected, + peg$maxFailPos < input.length ? input.charAt(peg$maxFailPos) : null, + peg$maxFailPos < input.length ? peg$computeLocation(peg$maxFailPos, peg$maxFailPos + 1) : peg$computeLocation(peg$maxFailPos, peg$maxFailPos) + ); + } + } + return { + SyntaxError: peg$SyntaxError, + parse: peg$parse + }; + }() +); +var xcolor_expressions_default = ( + // Generated by Peggy 2.0.1. + // + // https://peggyjs.org/ + function() { + "use strict"; + function peg$subclass(child, parent) { + function C() { + this.constructor = child; + } + C.prototype = parent.prototype; + child.prototype = new C(); + } + function peg$SyntaxError(message, expected, found, location) { + var self = Error.call(this, message); + if (Object.setPrototypeOf) { + Object.setPrototypeOf(self, peg$SyntaxError.prototype); + } + self.expected = expected; + self.found = found; + self.location = location; + self.name = "SyntaxError"; + return self; + } + peg$subclass(peg$SyntaxError, Error); + function peg$padEnd(str, targetLength, padString) { + padString = padString || " "; + if (str.length > targetLength) { + return str; + } + targetLength -= str.length; + padString += padString.repeat(targetLength); + return str + padString.slice(0, targetLength); + } + peg$SyntaxError.prototype.format = function(sources) { + var str = "Error: " + this.message; + if (this.location) { + var src = null; + var k; + for (k = 0; k < sources.length; k++) { + if (sources[k].source === this.location.source) { + src = sources[k].text.split(/\r\n|\n|\r/g); + break; + } + } + var s2 = this.location.start; + var loc = this.location.source + ":" + s2.line + ":" + s2.column; + if (src) { + var e = this.location.end; + var filler = peg$padEnd("", s2.line.toString().length, " "); + var line5 = src[s2.line - 1]; + var last = s2.line === e.line ? e.column : line5.length + 1; + var hatLen = last - s2.column || 1; + str += "\n --> " + loc + "\n" + filler + " |\n" + s2.line + " | " + line5 + "\n" + filler + " | " + peg$padEnd("", s2.column - 1, " ") + peg$padEnd("", hatLen, "^"); + } else { + str += "\n at " + loc; + } + } + return str; + }; + peg$SyntaxError.buildMessage = function(expected, found) { + var DESCRIBE_EXPECTATION_FNS = { + literal: function(expectation) { + return '"' + literalEscape(expectation.text) + '"'; + }, + class: function(expectation) { + var escapedParts = expectation.parts.map(function(part) { + return Array.isArray(part) ? classEscape(part[0]) + "-" + classEscape(part[1]) : classEscape(part); + }); + return "[" + (expectation.inverted ? "^" : "") + escapedParts.join("") + "]"; + }, + any: function() { + return "any character"; + }, + end: function() { + return "end of input"; + }, + other: function(expectation) { + return expectation.description; + } + }; + function hex(ch) { + return ch.charCodeAt(0).toString(16).toUpperCase(); + } + function literalEscape(s2) { + return s2.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\0/g, "\\0").replace(/\t/g, "\\t").replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/[\x00-\x0F]/g, function(ch) { + return "\\x0" + hex(ch); + }).replace(/[\x10-\x1F\x7F-\x9F]/g, function(ch) { + return "\\x" + hex(ch); + }); + } + function classEscape(s2) { + return s2.replace(/\\/g, "\\\\").replace(/\]/g, "\\]").replace(/\^/g, "\\^").replace(/-/g, "\\-").replace(/\0/g, "\\0").replace(/\t/g, "\\t").replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/[\x00-\x0F]/g, function(ch) { + return "\\x0" + hex(ch); + }).replace(/[\x10-\x1F\x7F-\x9F]/g, function(ch) { + return "\\x" + hex(ch); + }); + } + function describeExpectation(expectation) { + return DESCRIBE_EXPECTATION_FNS[expectation.type](expectation); + } + function describeExpected(expected2) { + var descriptions = expected2.map(describeExpectation); + var i, j; + descriptions.sort(); + if (descriptions.length > 0) { + for (i = 1, j = 1; i < descriptions.length; i++) { + if (descriptions[i - 1] !== descriptions[i]) { + descriptions[j] = descriptions[i]; + j++; + } + } + descriptions.length = j; + } + switch (descriptions.length) { + case 1: + return descriptions[0]; + case 2: + return descriptions[0] + " or " + descriptions[1]; + default: + return descriptions.slice(0, -1).join(", ") + ", or " + descriptions[descriptions.length - 1]; + } + } + function describeFound(found2) { + return found2 ? '"' + literalEscape(found2) + '"' : "end of input"; + } + return "Expected " + describeExpected(expected) + " but " + describeFound(found) + " found."; + }; + function peg$parse(input, options) { + options = options !== void 0 ? options : {}; + var peg$FAILED = {}; + var peg$source = options.grammarSource; + var peg$startRuleFunctions = { start: peg$parsestart }; + var peg$startRuleFunction = peg$parsestart; + var peg$c0 = ";"; + var peg$c1 = ","; + var peg$c2 = ":"; + var peg$c3 = "/"; + var peg$c4 = ">"; + var peg$c5 = "!"; + var peg$c6 = "."; + var peg$c7 = "!!["; + var peg$c8 = "]"; + var peg$c9 = "!!"; + var peg$c10 = "+"; + var peg$c11 = "-"; + var peg$r0 = /^[a-zA-Z0-9]/; + var peg$r1 = /^[0-9]/; + var peg$r2 = /^[ \t\n\r]/; + var peg$r3 = /^[0-9a-fA-F]/; + var peg$e0 = peg$anyExpectation(); + var peg$e1 = peg$literalExpectation(";", false); + var peg$e2 = peg$literalExpectation(",", false); + var peg$e3 = peg$otherExpectation("model list"); + var peg$e4 = peg$literalExpectation(":", false); + var peg$e5 = peg$literalExpectation("/", false); + var peg$e6 = peg$otherExpectation("model"); + var peg$e7 = peg$otherExpectation("color spec list"); + var peg$e8 = peg$otherExpectation("color spec"); + var peg$e9 = peg$otherExpectation("color"); + var peg$e10 = peg$otherExpectation("function expression"); + var peg$e11 = peg$literalExpectation(">", false); + var peg$e12 = peg$otherExpectation("function"); + var peg$e13 = peg$otherExpectation("extended expression"); + var peg$e14 = peg$otherExpectation("core model"); + var peg$e15 = peg$otherExpectation("expr"); + var peg$e16 = peg$literalExpectation("!", false); + var peg$e17 = peg$otherExpectation("mix expr"); + var peg$e18 = peg$otherExpectation("name"); + var peg$e19 = peg$literalExpectation(".", false); + var peg$e20 = peg$classExpectation([["a", "z"], ["A", "Z"], ["0", "9"]], false, false); + var peg$e21 = peg$otherExpectation("postfix"); + var peg$e22 = peg$literalExpectation("!![", false); + var peg$e23 = peg$literalExpectation("]", false); + var peg$e24 = peg$literalExpectation("!!", false); + var peg$e25 = peg$otherExpectation("prefix"); + var peg$e26 = peg$otherExpectation("plus"); + var peg$e27 = peg$literalExpectation("+", false); + var peg$e28 = peg$otherExpectation("minus"); + var peg$e29 = peg$literalExpectation("-", false); + var peg$e30 = peg$otherExpectation("num"); + var peg$e31 = peg$classExpectation([["0", "9"]], false, false); + var peg$e32 = peg$otherExpectation("positive float"); + var peg$e33 = peg$otherExpectation("divisor"); + var peg$e34 = peg$otherExpectation("int"); + var peg$e35 = peg$otherExpectation("whitespace"); + var peg$e36 = peg$classExpectation([" ", " ", "\n", "\r"], false, false); + var peg$e37 = peg$classExpectation([["0", "9"], ["a", "f"], ["A", "F"]], false, false); + var peg$f0 = function(m) { + return m; + }; + var peg$f1 = function(m) { + return m; + }; + var peg$f2 = function(m) { + return m; + }; + var peg$f3 = function(m) { + return m; + }; + var peg$f4 = function(m) { + return m; + }; + var peg$f5 = function(a) { + return { type: "invalid_spec", content: a }; + }; + var peg$f6 = function(f, c) { + return c; + }; + var peg$f7 = function(f, r) { + return { type: "color_set", content: [f].concat(r) }; + }; + var peg$f8 = function(n, s2) { + return { type: "color_set_item", name: n, spec_list: s2 }; + }; + var peg$f9 = function(c, m) { + return { type: "model_list", contents: m, core_model: c }; + }; + var peg$f10 = function(m) { + return { type: "model_list", contents: m, core_model: null }; + }; + var peg$f11 = function(m, a) { + return a; + }; + var peg$f12 = function(m, r) { + return [m].concat(r); + }; + var peg$f13 = function(s2, a) { + return a; + }; + var peg$f14 = function(s2, r) { + return { type: "spec_list", content: [s2].concat(r) }; + }; + var peg$f15 = function(c) { + return { type: "hex_spec", content: [c] }; + }; + var peg$f16 = function(c, d) { + return d; + }; + var peg$f17 = function(c, d) { + return d; + }; + var peg$f18 = function(c, r) { + return { type: "num_spec", content: r ? [c].concat(r) : [c] }; + }; + var peg$f19 = function(c, fs) { + return { type: "color", color: c, functions: fs }; + }; + var peg$f20 = function(f, n) { + return n; + }; + var peg$f21 = function(f, args) { + return { type: "function", name: f, args }; + }; + var peg$f22 = function(core, d, e, es) { + return { + type: "extended_expr", + core_model: core, + div: d, + expressions: [e].concat(es) + }; + }; + var peg$f23 = function(core, e, es) { + return { + type: "extended_expr", + core_model: core, + div: null, + expressions: [e].concat(es) + }; + }; + var peg$f24 = function(e, d) { + return { type: "weighted_expr", color: e, weight: d }; + }; + var peg$f25 = function(e) { + return e; + }; + var peg$f26 = function(p, n, e, po) { + return { + type: "expr", + prefix: p, + name: n, + mix_expr: e, + postfix: po + }; + }; + var peg$f27 = function(p, n) { + return { type: "complete_mix", mix_percent: p, name: n }; + }; + var peg$f28 = function(p) { + return { type: "partial_mix", mix_percent: p }; + }; + var peg$f29 = function(c, p) { + return c.concat(p || []); + }; + var peg$f30 = function(n) { + return { type: "postfix", num: n }; + }; + var peg$f31 = function(p) { + return { type: "postfix", plusses: p }; + }; + var peg$f32 = function(n) { + return parseInt(n, 10); + }; + var peg$f33 = function(n) { + return parseFloat(n); + }; + var peg$f34 = function(n) { + return n; + }; + var peg$f35 = function(n) { + return -n; + }; + var peg$f36 = function(m, n) { + return m ? -n : n; + }; + var peg$f37 = function(h) { + return h.toUpperCase(); + }; + var peg$currPos = 0; + var peg$savedPos = 0; + var peg$posDetailsCache = [{ line: 1, column: 1 }]; + var peg$maxFailPos = 0; + var peg$maxFailExpected = []; + var peg$silentFails = 0; + var peg$result; + if ("startRule" in options) { + if (!(options.startRule in peg$startRuleFunctions)) { + throw new Error(`Can't start parsing from rule "` + options.startRule + '".'); + } + peg$startRuleFunction = peg$startRuleFunctions[options.startRule]; + } + function text() { + return input.substring(peg$savedPos, peg$currPos); + } + function offset() { + return peg$savedPos; + } + function range() { + return { + source: peg$source, + start: peg$savedPos, + end: peg$currPos + }; + } + function location() { + return peg$computeLocation(peg$savedPos, peg$currPos); + } + function expected(description, location2) { + location2 = location2 !== void 0 ? location2 : peg$computeLocation(peg$savedPos, peg$currPos); + throw peg$buildStructuredError( + [peg$otherExpectation(description)], + input.substring(peg$savedPos, peg$currPos), + location2 + ); + } + function error(message, location2) { + location2 = location2 !== void 0 ? location2 : peg$computeLocation(peg$savedPos, peg$currPos); + throw peg$buildSimpleError(message, location2); + } + function peg$literalExpectation(text2, ignoreCase) { + return { type: "literal", text: text2, ignoreCase }; + } + function peg$classExpectation(parts, inverted, ignoreCase) { + return { type: "class", parts, inverted, ignoreCase }; + } + function peg$anyExpectation() { + return { type: "any" }; + } + function peg$endExpectation() { + return { type: "end" }; + } + function peg$otherExpectation(description) { + return { type: "other", description }; + } + function peg$computePosDetails(pos) { + var details = peg$posDetailsCache[pos]; + var p; + if (details) { + return details; + } else { + p = pos - 1; + while (!peg$posDetailsCache[p]) { + p--; + } + details = peg$posDetailsCache[p]; + details = { + line: details.line, + column: details.column + }; + while (p < pos) { + if (input.charCodeAt(p) === 10) { + details.line++; + details.column = 1; + } else { + details.column++; + } + p++; + } + peg$posDetailsCache[pos] = details; + return details; + } + } + function peg$computeLocation(startPos, endPos) { + var startPosDetails = peg$computePosDetails(startPos); + var endPosDetails = peg$computePosDetails(endPos); + return { + source: peg$source, + start: { + offset: startPos, + line: startPosDetails.line, + column: startPosDetails.column + }, + end: { + offset: endPos, + line: endPosDetails.line, + column: endPosDetails.column + } + }; + } + function peg$fail(expected2) { + if (peg$currPos < peg$maxFailPos) { + return; + } + if (peg$currPos > peg$maxFailPos) { + peg$maxFailPos = peg$currPos; + peg$maxFailExpected = []; + } + peg$maxFailExpected.push(expected2); + } + function peg$buildSimpleError(message, location2) { + return new peg$SyntaxError(message, null, null, location2); + } + function peg$buildStructuredError(expected2, found, location2) { + return new peg$SyntaxError( + peg$SyntaxError.buildMessage(expected2, found), + expected2, + found, + location2 + ); + } + function peg$parsestart() { + var s0, s1, s2, s3; + s0 = peg$currPos; + s1 = peg$parsespec(); + if (s1 !== peg$FAILED) { + s2 = peg$parseEOL(); + if (s2 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f0(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$parsespec_list(); + if (s1 !== peg$FAILED) { + s2 = peg$parseEOL(); + if (s2 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f1(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$parsecolor(); + if (s1 !== peg$FAILED) { + s2 = peg$parseEOL(); + if (s2 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f2(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$parsemodel_list(); + if (s1 !== peg$FAILED) { + s2 = peg$parseEOL(); + if (s2 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f3(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$parsecolor_set_spec(); + if (s1 !== peg$FAILED) { + s2 = peg$parseEOL(); + if (s2 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f4(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$currPos; + s2 = []; + if (input.length > peg$currPos) { + s3 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s3 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + while (s3 !== peg$FAILED) { + s2.push(s3); + if (input.length > peg$currPos) { + s3 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s3 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + } + s1 = input.substring(s1, peg$currPos); + peg$savedPos = s0; + s1 = peg$f5(s1); + s0 = s1; + } + } + } + } + } + return s0; + } + function peg$parsecolor_set_spec() { + var s0, s1, s2, s3, s4, s5; + s0 = peg$currPos; + s1 = peg$parsecolor_set_item(); + if (s1 !== peg$FAILED) { + s2 = []; + s3 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 59) { + s4 = peg$c0; + peg$currPos++; + } else { + s4 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e1); + } + } + if (s4 !== peg$FAILED) { + s5 = peg$parsecolor_set_item(); + if (s5 !== peg$FAILED) { + peg$savedPos = s3; + s3 = peg$f6(s1, s5); + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 59) { + s4 = peg$c0; + peg$currPos++; + } else { + s4 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e1); + } + } + if (s4 !== peg$FAILED) { + s5 = peg$parsecolor_set_item(); + if (s5 !== peg$FAILED) { + peg$savedPos = s3; + s3 = peg$f6(s1, s5); + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } + peg$savedPos = s0; + s0 = peg$f7(s1, s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsecolor_set_item() { + var s0, s1, s2, s3; + s0 = peg$currPos; + s1 = peg$parsename(); + if (s1 !== peg$FAILED) { + if (input.charCodeAt(peg$currPos) === 44) { + s2 = peg$c1; + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e2); + } + } + if (s2 !== peg$FAILED) { + s3 = peg$parsespec_list(); + if (s3 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f8(s1, s3); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsemodel_list() { + var s0, s1, s2, s3; + peg$silentFails++; + s0 = peg$currPos; + s1 = peg$parsecore_model(); + if (s1 !== peg$FAILED) { + if (input.charCodeAt(peg$currPos) === 58) { + s2 = peg$c2; + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e4); + } + } + if (s2 !== peg$FAILED) { + s3 = peg$parsemodel_list_tail(); + if (s3 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f9(s1, s3); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$parsemodel_list_tail(); + if (s1 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$f10(s1); + } + s0 = s1; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + return s0; + } + function peg$parsemodel_list_tail() { + var s0, s1, s2, s3, s4, s5; + s0 = peg$currPos; + s1 = peg$parsemodel(); + if (s1 !== peg$FAILED) { + s2 = []; + s3 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 47) { + s4 = peg$c3; + peg$currPos++; + } else { + s4 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e5); + } + } + if (s4 !== peg$FAILED) { + s5 = peg$parsemodel(); + if (s5 !== peg$FAILED) { + peg$savedPos = s3; + s3 = peg$f11(s1, s5); + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 47) { + s4 = peg$c3; + peg$currPos++; + } else { + s4 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e5); + } + } + if (s4 !== peg$FAILED) { + s5 = peg$parsemodel(); + if (s5 !== peg$FAILED) { + peg$savedPos = s3; + s3 = peg$f11(s1, s5); + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } + peg$savedPos = s0; + s0 = peg$f12(s1, s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsemodel() { + var s0, s1; + peg$silentFails++; + s0 = peg$parsecore_model(); + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e6); + } + } + return s0; + } + function peg$parsespec_list() { + var s0, s1, s2, s3, s4, s5; + peg$silentFails++; + s0 = peg$currPos; + s1 = peg$parsespec(); + if (s1 !== peg$FAILED) { + s2 = []; + s3 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 47) { + s4 = peg$c3; + peg$currPos++; + } else { + s4 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e5); + } + } + if (s4 !== peg$FAILED) { + s5 = peg$parsespec(); + if (s5 !== peg$FAILED) { + peg$savedPos = s3; + s3 = peg$f13(s1, s5); + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 47) { + s4 = peg$c3; + peg$currPos++; + } else { + s4 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e5); + } + } + if (s4 !== peg$FAILED) { + s5 = peg$parsespec(); + if (s5 !== peg$FAILED) { + peg$savedPos = s3; + s3 = peg$f13(s1, s5); + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } + peg$savedPos = s0; + s0 = peg$f14(s1, s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e7); + } + } + return s0; + } + function peg$parsespec() { + var s0, s1, s2, s3, s4, s5, s6, s7, s8; + peg$silentFails++; + s0 = peg$currPos; + s1 = peg$currPos; + s2 = peg$currPos; + s3 = peg$parsehex(); + if (s3 !== peg$FAILED) { + s4 = peg$parsehex(); + if (s4 !== peg$FAILED) { + s5 = peg$parsehex(); + if (s5 !== peg$FAILED) { + s6 = peg$parsehex(); + if (s6 !== peg$FAILED) { + s7 = peg$parsehex(); + if (s7 !== peg$FAILED) { + s8 = peg$parsehex(); + if (s8 !== peg$FAILED) { + s3 = [s3, s4, s5, s6, s7, s8]; + s2 = s3; + } else { + peg$currPos = s2; + s2 = peg$FAILED; + } + } else { + peg$currPos = s2; + s2 = peg$FAILED; + } + } else { + peg$currPos = s2; + s2 = peg$FAILED; + } + } else { + peg$currPos = s2; + s2 = peg$FAILED; + } + } else { + peg$currPos = s2; + s2 = peg$FAILED; + } + } else { + peg$currPos = s2; + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s1 = input.substring(s1, peg$currPos); + } else { + s1 = s2; + } + if (s1 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$f15(s1); + } + s0 = s1; + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$parsedec(); + if (s1 !== peg$FAILED) { + s2 = []; + s3 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 44) { + s4 = peg$c1; + peg$currPos++; + } else { + s4 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e2); + } + } + if (s4 !== peg$FAILED) { + s5 = peg$parsedec(); + if (s5 !== peg$FAILED) { + peg$savedPos = s3; + s3 = peg$f16(s1, s5); + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + if (s3 !== peg$FAILED) { + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 44) { + s4 = peg$c1; + peg$currPos++; + } else { + s4 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e2); + } + } + if (s4 !== peg$FAILED) { + s5 = peg$parsedec(); + if (s5 !== peg$FAILED) { + peg$savedPos = s3; + s3 = peg$f16(s1, s5); + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } + } else { + s2 = peg$FAILED; + } + if (s2 === peg$FAILED) { + s2 = []; + s3 = peg$currPos; + s4 = peg$parsesp(); + if (s4 !== peg$FAILED) { + s5 = peg$parsedec(); + if (s5 !== peg$FAILED) { + peg$savedPos = s3; + s3 = peg$f17(s1, s5); + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + if (s3 !== peg$FAILED) { + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$currPos; + s4 = peg$parsesp(); + if (s4 !== peg$FAILED) { + s5 = peg$parsedec(); + if (s5 !== peg$FAILED) { + peg$savedPos = s3; + s3 = peg$f17(s1, s5); + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } + } else { + s2 = peg$FAILED; + } + } + if (s2 === peg$FAILED) { + s2 = null; + } + peg$savedPos = s0; + s0 = peg$f18(s1, s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e8); + } + } + return s0; + } + function peg$parsecolor() { + var s0, s1, s2, s3; + peg$silentFails++; + s0 = peg$currPos; + s1 = peg$parsecolor_expr(); + if (s1 !== peg$FAILED) { + s2 = []; + s3 = peg$parsefunc_expr(); + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$parsefunc_expr(); + } + peg$savedPos = s0; + s0 = peg$f19(s1, s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e9); + } + } + return s0; + } + function peg$parsecolor_expr() { + var s0; + s0 = peg$parseext_expr(); + if (s0 === peg$FAILED) { + s0 = peg$parseexpr(); + if (s0 === peg$FAILED) { + s0 = peg$parsename(); + } + } + return s0; + } + function peg$parsefunc_expr() { + var s0, s1, s2, s3, s4, s5, s6; + peg$silentFails++; + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 62) { + s1 = peg$c4; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e11); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$parsefunction(); + if (s2 !== peg$FAILED) { + s3 = []; + s4 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 44) { + s5 = peg$c1; + peg$currPos++; + } else { + s5 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e2); + } + } + if (s5 !== peg$FAILED) { + s6 = peg$parseint(); + if (s6 !== peg$FAILED) { + peg$savedPos = s4; + s4 = peg$f20(s2, s6); + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + while (s4 !== peg$FAILED) { + s3.push(s4); + s4 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 44) { + s5 = peg$c1; + peg$currPos++; + } else { + s5 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e2); + } + } + if (s5 !== peg$FAILED) { + s6 = peg$parseint(); + if (s6 !== peg$FAILED) { + peg$savedPos = s4; + s4 = peg$f20(s2, s6); + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + } + peg$savedPos = s0; + s0 = peg$f21(s2, s3); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e10); + } + } + return s0; + } + function peg$parsefunction() { + var s0, s1; + peg$silentFails++; + s0 = peg$parsename(); + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e12); + } + } + return s0; + } + function peg$parseext_expr() { + var s0, s1, s2, s3, s4, s5, s6, s7; + peg$silentFails++; + s0 = peg$currPos; + s1 = peg$parsecore_model(); + if (s1 !== peg$FAILED) { + if (input.charCodeAt(peg$currPos) === 44) { + s2 = peg$c1; + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e2); + } + } + if (s2 !== peg$FAILED) { + s3 = peg$parsediv(); + if (s3 !== peg$FAILED) { + if (input.charCodeAt(peg$currPos) === 58) { + s4 = peg$c2; + peg$currPos++; + } else { + s4 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e4); + } + } + if (s4 !== peg$FAILED) { + s5 = peg$parseweighted_expr(); + if (s5 !== peg$FAILED) { + s6 = []; + s7 = peg$parseadditional_weighted_expr(); + while (s7 !== peg$FAILED) { + s6.push(s7); + s7 = peg$parseadditional_weighted_expr(); + } + peg$savedPos = s0; + s0 = peg$f22(s1, s3, s5, s6); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$parsecore_model(); + if (s1 !== peg$FAILED) { + if (input.charCodeAt(peg$currPos) === 58) { + s2 = peg$c2; + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e4); + } + } + if (s2 !== peg$FAILED) { + s3 = peg$parseweighted_expr(); + if (s3 !== peg$FAILED) { + s4 = []; + s5 = peg$parseadditional_weighted_expr(); + while (s5 !== peg$FAILED) { + s4.push(s5); + s5 = peg$parseadditional_weighted_expr(); + } + peg$savedPos = s0; + s0 = peg$f23(s1, s3, s4); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e13); + } + } + return s0; + } + function peg$parseweighted_expr() { + var s0, s1, s2, s3; + s0 = peg$currPos; + s1 = peg$parseexpr(); + if (s1 !== peg$FAILED) { + if (input.charCodeAt(peg$currPos) === 44) { + s2 = peg$c1; + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e2); + } + } + if (s2 !== peg$FAILED) { + s3 = peg$parsedec(); + if (s3 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f24(s1, s3); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parseadditional_weighted_expr() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 59) { + s1 = peg$c0; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e1); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$parseweighted_expr(); + if (s2 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f25(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsecore_model() { + var s0, s1; + peg$silentFails++; + s0 = peg$parsename(); + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e14); + } + } + return s0; + } + function peg$parseexpr() { + var s0, s1, s2, s3, s4; + peg$silentFails++; + s0 = peg$currPos; + s1 = peg$parseprefix(); + s2 = peg$parsename(); + if (s2 !== peg$FAILED) { + s3 = peg$parsemix_expr(); + s4 = peg$parsepostfix(); + if (s4 === peg$FAILED) { + s4 = null; + } + peg$savedPos = s0; + s0 = peg$f26(s1, s2, s3, s4); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e15); + } + } + return s0; + } + function peg$parsecomplete_mix() { + var s0, s1, s2, s3, s4; + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 33) { + s1 = peg$c5; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e16); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$parsepct(); + if (s2 !== peg$FAILED) { + if (input.charCodeAt(peg$currPos) === 33) { + s3 = peg$c5; + peg$currPos++; + } else { + s3 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e16); + } + } + if (s3 !== peg$FAILED) { + s4 = peg$parsename(); + if (s4 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f27(s2, s4); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsepartial_mix() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 33) { + s1 = peg$c5; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e16); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$parsepct(); + if (s2 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f28(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsemix_expr() { + var s0, s1, s2; + peg$silentFails++; + s0 = peg$currPos; + s1 = []; + s2 = peg$parsecomplete_mix(); + while (s2 !== peg$FAILED) { + s1.push(s2); + s2 = peg$parsecomplete_mix(); + } + s2 = peg$parsepartial_mix(); + if (s2 === peg$FAILED) { + s2 = null; + } + peg$savedPos = s0; + s0 = peg$f29(s1, s2); + peg$silentFails--; + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e17); + } + return s0; + } + function peg$parsename() { + var s0, s1, s2; + peg$silentFails++; + if (input.charCodeAt(peg$currPos) === 46) { + s0 = peg$c6; + peg$currPos++; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e19); + } + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = []; + if (peg$r0.test(input.charAt(peg$currPos))) { + s2 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e20); + } + } + if (s2 !== peg$FAILED) { + while (s2 !== peg$FAILED) { + s1.push(s2); + if (peg$r0.test(input.charAt(peg$currPos))) { + s2 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e20); + } + } + } + } else { + s1 = peg$FAILED; + } + if (s1 !== peg$FAILED) { + s0 = input.substring(s0, peg$currPos); + } else { + s0 = s1; + } + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e18); + } + } + return s0; + } + function peg$parsepostfix() { + var s0, s1, s2, s3, s4; + peg$silentFails++; + s0 = peg$currPos; + if (input.substr(peg$currPos, 3) === peg$c7) { + s1 = peg$c7; + peg$currPos += 3; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e22); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$parsenum(); + if (s2 !== peg$FAILED) { + if (input.charCodeAt(peg$currPos) === 93) { + s3 = peg$c8; + peg$currPos++; + } else { + s3 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e23); + } + } + if (s3 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f30(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + if (input.substr(peg$currPos, 2) === peg$c9) { + s1 = peg$c9; + peg$currPos += 2; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e24); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$currPos; + s3 = []; + s4 = peg$parseplus(); + if (s4 !== peg$FAILED) { + while (s4 !== peg$FAILED) { + s3.push(s4); + s4 = peg$parseplus(); + } + } else { + s3 = peg$FAILED; + } + if (s3 !== peg$FAILED) { + s2 = input.substring(s2, peg$currPos); + } else { + s2 = s3; + } + if (s2 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f31(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e21); + } + } + return s0; + } + function peg$parseprefix() { + var s0, s1; + peg$silentFails++; + s0 = peg$parseminus(); + if (s0 === peg$FAILED) { + s0 = null; + } + peg$silentFails--; + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e25); + } + return s0; + } + function peg$parseplus() { + var s0, s1, s2; + peg$silentFails++; + s0 = peg$currPos; + s1 = []; + if (input.charCodeAt(peg$currPos) === 43) { + s2 = peg$c10; + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e27); + } + } + if (s2 !== peg$FAILED) { + while (s2 !== peg$FAILED) { + s1.push(s2); + if (input.charCodeAt(peg$currPos) === 43) { + s2 = peg$c10; + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e27); + } + } + } + } else { + s1 = peg$FAILED; + } + if (s1 !== peg$FAILED) { + s0 = input.substring(s0, peg$currPos); + } else { + s0 = s1; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e26); + } + } + return s0; + } + function peg$parseminus() { + var s0, s1, s2; + peg$silentFails++; + s0 = peg$currPos; + s1 = []; + if (input.charCodeAt(peg$currPos) === 45) { + s2 = peg$c11; + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e29); + } + } + if (s2 !== peg$FAILED) { + while (s2 !== peg$FAILED) { + s1.push(s2); + if (input.charCodeAt(peg$currPos) === 45) { + s2 = peg$c11; + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e29); + } + } + } + } else { + s1 = peg$FAILED; + } + if (s1 !== peg$FAILED) { + s0 = input.substring(s0, peg$currPos); + } else { + s0 = s1; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e28); + } + } + return s0; + } + function peg$parsenum() { + var s0, s1, s2, s3; + peg$silentFails++; + s0 = peg$currPos; + s1 = peg$currPos; + s2 = []; + if (peg$r1.test(input.charAt(peg$currPos))) { + s3 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s3 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e31); + } + } + if (s3 !== peg$FAILED) { + while (s3 !== peg$FAILED) { + s2.push(s3); + if (peg$r1.test(input.charAt(peg$currPos))) { + s3 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s3 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e31); + } + } + } + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s1 = input.substring(s1, peg$currPos); + } else { + s1 = s2; + } + if (s1 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$f32(s1); + } + s0 = s1; + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e30); + } + } + return s0; + } + function peg$parsepct() { + var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9; + peg$silentFails++; + s0 = peg$currPos; + s1 = peg$currPos; + s2 = peg$currPos; + s3 = peg$currPos; + s4 = []; + if (peg$r1.test(input.charAt(peg$currPos))) { + s5 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s5 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e31); + } + } + if (s5 !== peg$FAILED) { + while (s5 !== peg$FAILED) { + s4.push(s5); + if (peg$r1.test(input.charAt(peg$currPos))) { + s5 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s5 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e31); + } + } + } + } else { + s4 = peg$FAILED; + } + if (s4 !== peg$FAILED) { + s3 = input.substring(s3, peg$currPos); + } else { + s3 = s4; + } + if (s3 !== peg$FAILED) { + s4 = peg$currPos; + s5 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 46) { + s6 = peg$c6; + peg$currPos++; + } else { + s6 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e19); + } + } + if (s6 !== peg$FAILED) { + s7 = peg$currPos; + s8 = []; + if (peg$r1.test(input.charAt(peg$currPos))) { + s9 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s9 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e31); + } + } + while (s9 !== peg$FAILED) { + s8.push(s9); + if (peg$r1.test(input.charAt(peg$currPos))) { + s9 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s9 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e31); + } + } + } + s7 = input.substring(s7, peg$currPos); + s6 = [s6, s7]; + s5 = s6; + } else { + peg$currPos = s5; + s5 = peg$FAILED; + } + if (s5 === peg$FAILED) { + s5 = null; + } + s4 = input.substring(s4, peg$currPos); + s3 = [s3, s4]; + s2 = s3; + } else { + peg$currPos = s2; + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s1 = input.substring(s1, peg$currPos); + } else { + s1 = s2; + } + if (s1 === peg$FAILED) { + s1 = peg$currPos; + s2 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 46) { + s3 = peg$c6; + peg$currPos++; + } else { + s3 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e19); + } + } + if (s3 !== peg$FAILED) { + s4 = peg$currPos; + s5 = []; + if (peg$r1.test(input.charAt(peg$currPos))) { + s6 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s6 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e31); + } + } + if (s6 !== peg$FAILED) { + while (s6 !== peg$FAILED) { + s5.push(s6); + if (peg$r1.test(input.charAt(peg$currPos))) { + s6 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s6 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e31); + } + } + } + } else { + s5 = peg$FAILED; + } + if (s5 !== peg$FAILED) { + s4 = input.substring(s4, peg$currPos); + } else { + s4 = s5; + } + if (s4 !== peg$FAILED) { + s3 = [s3, s4]; + s2 = s3; + } else { + peg$currPos = s2; + s2 = peg$FAILED; + } + } else { + peg$currPos = s2; + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s1 = input.substring(s1, peg$currPos); + } else { + s1 = s2; + } + } + if (s1 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$f33(s1); + } + s0 = s1; + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e32); + } + } + return s0; + } + function peg$parsediv() { + var s0, s1; + peg$silentFails++; + s0 = peg$parsepct(); + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e33); + } + } + return s0; + } + function peg$parsedec() { + var s0, s1, s2; + s0 = peg$parsepct(); + if (s0 === peg$FAILED) { + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 43) { + s1 = peg$c10; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e27); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$parsepct(); + if (s2 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f34(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 45) { + s1 = peg$c11; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e29); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$parsepct(); + if (s2 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f35(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } + } + return s0; + } + function peg$parseint() { + var s0, s1, s2; + peg$silentFails++; + s0 = peg$currPos; + s1 = peg$parseminus(); + if (s1 === peg$FAILED) { + s1 = null; + } + s2 = peg$parsenum(); + if (s2 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f36(s1, s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e34); + } + } + return s0; + } + function peg$parse_() { + var s0, s1; + peg$silentFails++; + s0 = []; + if (peg$r2.test(input.charAt(peg$currPos))) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e36); + } + } + while (s1 !== peg$FAILED) { + s0.push(s1); + if (peg$r2.test(input.charAt(peg$currPos))) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e36); + } + } + } + peg$silentFails--; + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e35); + } + return s0; + } + function peg$parsesp() { + var s0, s1; + s0 = []; + if (peg$r2.test(input.charAt(peg$currPos))) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e36); + } + } + if (s1 !== peg$FAILED) { + while (s1 !== peg$FAILED) { + s0.push(s1); + if (peg$r2.test(input.charAt(peg$currPos))) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e36); + } + } + } + } else { + s0 = peg$FAILED; + } + return s0; + } + function peg$parsehex() { + var s0, s1; + s0 = peg$currPos; + if (peg$r3.test(input.charAt(peg$currPos))) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e37); + } + } + if (s1 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$f37(s1); + } + s0 = s1; + return s0; + } + function peg$parseEOL() { + var s0, s1; + s0 = peg$currPos; + peg$silentFails++; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + peg$silentFails--; + if (s1 === peg$FAILED) { + s0 = void 0; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + peg$result = peg$startRuleFunction(); + if (peg$result !== peg$FAILED && peg$currPos === input.length) { + return peg$result; + } else { + if (peg$result !== peg$FAILED && peg$currPos < input.length) { + peg$fail(peg$endExpectation()); + } + throw peg$buildStructuredError( + peg$maxFailExpected, + peg$maxFailPos < input.length ? input.charAt(peg$maxFailPos) : null, + peg$maxFailPos < input.length ? peg$computeLocation(peg$maxFailPos, peg$maxFailPos + 1) : peg$computeLocation(peg$maxFailPos, peg$maxFailPos) + ); + } + } + return { + SyntaxError: peg$SyntaxError, + parse: peg$parse + }; + }() +); +var tabular_spec_default = ( + // Generated by Peggy 2.0.1. + // + // https://peggyjs.org/ + function() { + "use strict"; + function peg$subclass(child, parent) { + function C() { + this.constructor = child; + } + C.prototype = parent.prototype; + child.prototype = new C(); + } + function peg$SyntaxError(message, expected, found, location) { + var self = Error.call(this, message); + if (Object.setPrototypeOf) { + Object.setPrototypeOf(self, peg$SyntaxError.prototype); + } + self.expected = expected; + self.found = found; + self.location = location; + self.name = "SyntaxError"; + return self; + } + peg$subclass(peg$SyntaxError, Error); + function peg$padEnd(str, targetLength, padString) { + padString = padString || " "; + if (str.length > targetLength) { + return str; + } + targetLength -= str.length; + padString += padString.repeat(targetLength); + return str + padString.slice(0, targetLength); + } + peg$SyntaxError.prototype.format = function(sources) { + var str = "Error: " + this.message; + if (this.location) { + var src = null; + var k; + for (k = 0; k < sources.length; k++) { + if (sources[k].source === this.location.source) { + src = sources[k].text.split(/\r\n|\n|\r/g); + break; + } + } + var s2 = this.location.start; + var loc = this.location.source + ":" + s2.line + ":" + s2.column; + if (src) { + var e = this.location.end; + var filler = peg$padEnd("", s2.line.toString().length, " "); + var line5 = src[s2.line - 1]; + var last = s2.line === e.line ? e.column : line5.length + 1; + var hatLen = last - s2.column || 1; + str += "\n --> " + loc + "\n" + filler + " |\n" + s2.line + " | " + line5 + "\n" + filler + " | " + peg$padEnd("", s2.column - 1, " ") + peg$padEnd("", hatLen, "^"); + } else { + str += "\n at " + loc; + } + } + return str; + }; + peg$SyntaxError.buildMessage = function(expected, found) { + var DESCRIBE_EXPECTATION_FNS = { + literal: function(expectation) { + return '"' + literalEscape(expectation.text) + '"'; + }, + class: function(expectation) { + var escapedParts = expectation.parts.map(function(part) { + return Array.isArray(part) ? classEscape(part[0]) + "-" + classEscape(part[1]) : classEscape(part); + }); + return "[" + (expectation.inverted ? "^" : "") + escapedParts.join("") + "]"; + }, + any: function() { + return "any character"; + }, + end: function() { + return "end of input"; + }, + other: function(expectation) { + return expectation.description; + } + }; + function hex(ch) { + return ch.charCodeAt(0).toString(16).toUpperCase(); + } + function literalEscape(s2) { + return s2.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\0/g, "\\0").replace(/\t/g, "\\t").replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/[\x00-\x0F]/g, function(ch) { + return "\\x0" + hex(ch); + }).replace(/[\x10-\x1F\x7F-\x9F]/g, function(ch) { + return "\\x" + hex(ch); + }); + } + function classEscape(s2) { + return s2.replace(/\\/g, "\\\\").replace(/\]/g, "\\]").replace(/\^/g, "\\^").replace(/-/g, "\\-").replace(/\0/g, "\\0").replace(/\t/g, "\\t").replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/[\x00-\x0F]/g, function(ch) { + return "\\x0" + hex(ch); + }).replace(/[\x10-\x1F\x7F-\x9F]/g, function(ch) { + return "\\x" + hex(ch); + }); + } + function describeExpectation(expectation) { + return DESCRIBE_EXPECTATION_FNS[expectation.type](expectation); + } + function describeExpected(expected2) { + var descriptions = expected2.map(describeExpectation); + var i, j; + descriptions.sort(); + if (descriptions.length > 0) { + for (i = 1, j = 1; i < descriptions.length; i++) { + if (descriptions[i - 1] !== descriptions[i]) { + descriptions[j] = descriptions[i]; + j++; + } + } + descriptions.length = j; + } + switch (descriptions.length) { + case 1: + return descriptions[0]; + case 2: + return descriptions[0] + " or " + descriptions[1]; + default: + return descriptions.slice(0, -1).join(", ") + ", or " + descriptions[descriptions.length - 1]; + } + } + function describeFound(found2) { + return found2 ? '"' + literalEscape(found2) + '"' : "end of input"; + } + return "Expected " + describeExpected(expected) + " but " + describeFound(found) + " found."; + }; + function peg$parse(input, options) { + options = options !== void 0 ? options : {}; + var peg$FAILED = {}; + var peg$source = options.grammarSource; + var peg$startRuleFunctions = { body: peg$parsebody }; + var peg$startRuleFunction = peg$parsebody; + var peg$e0 = peg$otherExpectation("decl_start"); + var peg$e1 = peg$otherExpectation("decl_end"); + var peg$e2 = peg$otherExpectation("vert"); + var peg$e3 = peg$anyExpectation(); + var peg$e4 = peg$otherExpectation("l"); + var peg$e5 = peg$otherExpectation("r"); + var peg$e6 = peg$otherExpectation("c"); + var peg$e7 = peg$otherExpectation("p"); + var peg$e8 = peg$otherExpectation("m"); + var peg$e9 = peg$otherExpectation("b"); + var peg$e10 = peg$otherExpectation("w"); + var peg$e11 = peg$otherExpectation("W"); + var peg$e12 = peg$otherExpectation("X"); + var peg$e13 = peg$otherExpectation("!"); + var peg$e14 = peg$otherExpectation("@"); + var peg$e15 = peg$otherExpectation("<"); + var peg$e16 = peg$otherExpectation(">"); + var peg$e17 = peg$otherExpectation("group"); + var peg$e18 = peg$otherExpectation("whitespace"); + var peg$f0 = function(c) { + return c; + }; + var peg$f1 = function(cols) { + return cols; + }; + var peg$f2 = function() { + return []; + }; + var peg$f3 = function(divs1, start, a, end, divs2) { + return { + type: "column", + pre_dividers: divs1, + post_dividers: divs2, + before_start_code: start, + before_end_code: end, + alignment: a + }; + }; + var peg$f4 = function() { + return { + type: "vert_divider" + }; + }; + var peg$f5 = function(b, g) { + return { + type: "bang_divider", + content: g[0].content + }; + }; + var peg$f6 = function(g) { + return { + type: "at_divider", + content: g[0].content + }; + }; + var peg$f7 = function(div) { + return div; + }; + var peg$f8 = function(g) { + return { type: "decl_code", code: g[0].content }; + }; + var peg$f9 = function(g) { + return { type: "decl_code", code: g[0].content }; + }; + var peg$f10 = function() { + return { type: "alignment", alignment: "left" }; + }; + var peg$f11 = function() { + return { type: "alignment", alignment: "center" }; + }; + var peg$f12 = function() { + return { type: "alignment", alignment: "right" }; + }; + var peg$f13 = function() { + return { type: "alignment", alignment: "X" }; + }; + var peg$f14 = function() { + return "top"; + }; + var peg$f15 = function() { + return "default"; + }; + var peg$f16 = function() { + return "bottom"; + }; + var peg$f17 = function(a, g) { + return { + type: "alignment", + alignment: "parbox", + baseline: a, + size: g[0].content + }; + }; + var peg$f18 = function(g1, g2) { + return { + type: "alignment", + alignment: "parbox", + baseline: g1[0].content, + size: g2[0].content + }; + }; + var peg$f19 = function(tok) { + return options.matchChar(tok, "|"); + }; + var peg$f20 = function(tok) { + return options.matchChar(tok, "l"); + }; + var peg$f21 = function(tok) { + return options.matchChar(tok, "r"); + }; + var peg$f22 = function(tok) { + return options.matchChar(tok, "c"); + }; + var peg$f23 = function(tok) { + return options.matchChar(tok, "p"); + }; + var peg$f24 = function(tok) { + return options.matchChar(tok, "m"); + }; + var peg$f25 = function(tok) { + return options.matchChar(tok, "b"); + }; + var peg$f26 = function(tok) { + return options.matchChar(tok, "w"); + }; + var peg$f27 = function(tok) { + return options.matchChar(tok, "W"); + }; + var peg$f28 = function(tok) { + return options.matchChar(tok, "X"); + }; + var peg$f29 = function(tok) { + return options.matchChar(tok, "!"); + }; + var peg$f30 = function(tok) { + return options.matchChar(tok, "@"); + }; + var peg$f31 = function(tok) { + return options.matchChar(tok, "<"); + }; + var peg$f32 = function(tok) { + return options.matchChar(tok, ">"); + }; + var peg$f33 = function(tok) { + return options.isGroup(tok); + }; + var peg$f34 = function(tok) { + return options.isWhitespace(tok); + }; + var peg$currPos = 0; + var peg$savedPos = 0; + var peg$posDetailsCache = [{ line: 1, column: 1 }]; + var peg$maxFailPos = 0; + var peg$maxFailExpected = []; + var peg$silentFails = 0; + var peg$result; + if ("startRule" in options) { + if (!(options.startRule in peg$startRuleFunctions)) { + throw new Error(`Can't start parsing from rule "` + options.startRule + '".'); + } + peg$startRuleFunction = peg$startRuleFunctions[options.startRule]; + } + function text() { + return input.substring(peg$savedPos, peg$currPos); + } + function offset() { + return peg$savedPos; + } + function range() { + return { + source: peg$source, + start: peg$savedPos, + end: peg$currPos + }; + } + function location() { + return peg$computeLocation(peg$savedPos, peg$currPos); + } + function expected(description, location2) { + location2 = location2 !== void 0 ? location2 : peg$computeLocation(peg$savedPos, peg$currPos); + throw peg$buildStructuredError( + [peg$otherExpectation(description)], + input.substring(peg$savedPos, peg$currPos), + location2 + ); + } + function error(message, location2) { + location2 = location2 !== void 0 ? location2 : peg$computeLocation(peg$savedPos, peg$currPos); + throw peg$buildSimpleError(message, location2); + } + function peg$literalExpectation(text2, ignoreCase) { + return { type: "literal", text: text2, ignoreCase }; + } + function peg$classExpectation(parts, inverted, ignoreCase) { + return { type: "class", parts, inverted, ignoreCase }; + } + function peg$anyExpectation() { + return { type: "any" }; + } + function peg$endExpectation() { + return { type: "end" }; + } + function peg$otherExpectation(description) { + return { type: "other", description }; + } + function peg$computePosDetails(pos) { + var details = peg$posDetailsCache[pos]; + var p; + if (details) { + return details; + } else { + p = pos - 1; + while (!peg$posDetailsCache[p]) { + p--; + } + details = peg$posDetailsCache[p]; + details = { + line: details.line, + column: details.column + }; + while (p < pos) { + if (input.charCodeAt(p) === 10) { + details.line++; + details.column = 1; + } else { + details.column++; + } + p++; + } + peg$posDetailsCache[pos] = details; + return details; + } + } + function peg$computeLocation(startPos, endPos) { + var startPosDetails = peg$computePosDetails(startPos); + var endPosDetails = peg$computePosDetails(endPos); + return { + source: peg$source, + start: { + offset: startPos, + line: startPosDetails.line, + column: startPosDetails.column + }, + end: { + offset: endPos, + line: endPosDetails.line, + column: endPosDetails.column + } + }; + } + function peg$fail(expected2) { + if (peg$currPos < peg$maxFailPos) { + return; + } + if (peg$currPos > peg$maxFailPos) { + peg$maxFailPos = peg$currPos; + peg$maxFailExpected = []; + } + peg$maxFailExpected.push(expected2); + } + function peg$buildSimpleError(message, location2) { + return new peg$SyntaxError(message, null, null, location2); + } + function peg$buildStructuredError(expected2, found, location2) { + return new peg$SyntaxError( + peg$SyntaxError.buildMessage(expected2, found), + expected2, + found, + location2 + ); + } + function peg$parsebody() { + var s0, s1, s2, s3, s4, s5; + s0 = peg$currPos; + s1 = []; + s2 = peg$currPos; + s3 = peg$parsecolumn(); + if (s3 !== peg$FAILED) { + s4 = []; + s5 = peg$parse_(); + while (s5 !== peg$FAILED) { + s4.push(s5); + s5 = peg$parse_(); + } + peg$savedPos = s2; + s2 = peg$f0(s3); + } else { + peg$currPos = s2; + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + while (s2 !== peg$FAILED) { + s1.push(s2); + s2 = peg$currPos; + s3 = peg$parsecolumn(); + if (s3 !== peg$FAILED) { + s4 = []; + s5 = peg$parse_(); + while (s5 !== peg$FAILED) { + s4.push(s5); + s5 = peg$parse_(); + } + peg$savedPos = s2; + s2 = peg$f0(s3); + } else { + peg$currPos = s2; + s2 = peg$FAILED; + } + } + } else { + s1 = peg$FAILED; + } + if (s1 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$f1(s1); + } + s0 = s1; + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$parseEOL(); + if (s1 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$f2(); + } + s0 = s1; + } + return s0; + } + function peg$parsecolumn() { + var s0, s1, s2, s3, s4, s5, s6; + s0 = peg$currPos; + s1 = []; + s2 = peg$parsecolumn_divider(); + while (s2 !== peg$FAILED) { + s1.push(s2); + s2 = peg$parsecolumn_divider(); + } + s2 = peg$parsedecl_start(); + if (s2 === peg$FAILED) { + s2 = null; + } + s3 = peg$parsealignment(); + if (s3 !== peg$FAILED) { + s4 = peg$parsedecl_end(); + if (s4 === peg$FAILED) { + s4 = null; + } + s5 = []; + s6 = peg$parsecolumn_divider(); + while (s6 !== peg$FAILED) { + s5.push(s6); + s6 = peg$parsecolumn_divider(); + } + peg$savedPos = s0; + s0 = peg$f3(s1, s2, s3, s4, s5); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsecolumn_divider() { + var s0, s1, s2, s3, s4; + s0 = peg$currPos; + s1 = []; + s2 = peg$parse_(); + while (s2 !== peg$FAILED) { + s1.push(s2); + s2 = peg$parse_(); + } + s2 = peg$currPos; + s3 = peg$parsevert(); + if (s3 !== peg$FAILED) { + peg$savedPos = s2; + s3 = peg$f4(); + } + s2 = s3; + if (s2 === peg$FAILED) { + s2 = peg$currPos; + s3 = peg$parsebang(); + if (s3 !== peg$FAILED) { + s4 = peg$parsegroup(); + if (s4 !== peg$FAILED) { + peg$savedPos = s2; + s2 = peg$f5(s3, s4); + } else { + peg$currPos = s2; + s2 = peg$FAILED; + } + } else { + peg$currPos = s2; + s2 = peg$FAILED; + } + if (s2 === peg$FAILED) { + s2 = peg$currPos; + s3 = peg$parseat(); + if (s3 !== peg$FAILED) { + s4 = peg$parsegroup(); + if (s4 !== peg$FAILED) { + peg$savedPos = s2; + s2 = peg$f6(s4); + } else { + peg$currPos = s2; + s2 = peg$FAILED; + } + } else { + peg$currPos = s2; + s2 = peg$FAILED; + } + } + } + if (s2 !== peg$FAILED) { + s3 = []; + s4 = peg$parse_(); + while (s4 !== peg$FAILED) { + s3.push(s4); + s4 = peg$parse_(); + } + peg$savedPos = s0; + s0 = peg$f7(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsedecl_start() { + var s0, s1, s2; + peg$silentFails++; + s0 = peg$currPos; + s1 = peg$parsegreater(); + if (s1 !== peg$FAILED) { + s2 = peg$parsegroup(); + if (s2 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f8(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + return s0; + } + function peg$parsedecl_end() { + var s0, s1, s2; + peg$silentFails++; + s0 = peg$currPos; + s1 = peg$parseless(); + if (s1 !== peg$FAILED) { + s2 = peg$parsegroup(); + if (s2 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f9(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e1); + } + } + return s0; + } + function peg$parsealignment() { + var s0, s1, s2, s3, s4, s5; + s0 = peg$currPos; + s1 = peg$parsel(); + if (s1 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$f10(); + } + s0 = s1; + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$parsec(); + if (s1 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$f11(); + } + s0 = s1; + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$parser(); + if (s1 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$f12(); + } + s0 = s1; + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$parseX(); + if (s1 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$f13(); + } + s0 = s1; + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$currPos; + s2 = peg$parsep(); + if (s2 !== peg$FAILED) { + peg$savedPos = s1; + s2 = peg$f14(); + } + s1 = s2; + if (s1 === peg$FAILED) { + s1 = peg$currPos; + s2 = peg$parsem(); + if (s2 !== peg$FAILED) { + peg$savedPos = s1; + s2 = peg$f15(); + } + s1 = s2; + if (s1 === peg$FAILED) { + s1 = peg$currPos; + s2 = peg$parseb(); + if (s2 !== peg$FAILED) { + peg$savedPos = s1; + s2 = peg$f16(); + } + s1 = s2; + } + } + if (s1 !== peg$FAILED) { + s2 = []; + s3 = peg$parse_(); + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$parse_(); + } + s3 = peg$parsegroup(); + if (s3 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f17(s1, s3); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$parsew(); + if (s1 === peg$FAILED) { + s1 = peg$parseW(); + } + if (s1 !== peg$FAILED) { + s2 = []; + s3 = peg$parse_(); + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$parse_(); + } + s3 = peg$parsegroup(); + if (s3 !== peg$FAILED) { + s4 = []; + s5 = peg$parse_(); + while (s5 !== peg$FAILED) { + s4.push(s5); + s5 = peg$parse_(); + } + s5 = peg$parsegroup(); + if (s5 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f18(s3, s5); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } + } + } + } + } + return s0; + } + function peg$parsevert() { + var s0, s1, s2; + peg$silentFails++; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s1 !== peg$FAILED) { + peg$savedPos = peg$currPos; + s2 = peg$f19(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s1 = [s1, s2]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e2); + } + } + return s0; + } + function peg$parsel() { + var s0, s1, s2; + peg$silentFails++; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s1 !== peg$FAILED) { + peg$savedPos = peg$currPos; + s2 = peg$f20(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s1 = [s1, s2]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e4); + } + } + return s0; + } + function peg$parser() { + var s0, s1, s2; + peg$silentFails++; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s1 !== peg$FAILED) { + peg$savedPos = peg$currPos; + s2 = peg$f21(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s1 = [s1, s2]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e5); + } + } + return s0; + } + function peg$parsec() { + var s0, s1, s2; + peg$silentFails++; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s1 !== peg$FAILED) { + peg$savedPos = peg$currPos; + s2 = peg$f22(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s1 = [s1, s2]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e6); + } + } + return s0; + } + function peg$parsep() { + var s0, s1, s2; + peg$silentFails++; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s1 !== peg$FAILED) { + peg$savedPos = peg$currPos; + s2 = peg$f23(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s1 = [s1, s2]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e7); + } + } + return s0; + } + function peg$parsem() { + var s0, s1, s2; + peg$silentFails++; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s1 !== peg$FAILED) { + peg$savedPos = peg$currPos; + s2 = peg$f24(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s1 = [s1, s2]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e8); + } + } + return s0; + } + function peg$parseb() { + var s0, s1, s2; + peg$silentFails++; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s1 !== peg$FAILED) { + peg$savedPos = peg$currPos; + s2 = peg$f25(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s1 = [s1, s2]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e9); + } + } + return s0; + } + function peg$parsew() { + var s0, s1, s2; + peg$silentFails++; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s1 !== peg$FAILED) { + peg$savedPos = peg$currPos; + s2 = peg$f26(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s1 = [s1, s2]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e10); + } + } + return s0; + } + function peg$parseW() { + var s0, s1, s2; + peg$silentFails++; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s1 !== peg$FAILED) { + peg$savedPos = peg$currPos; + s2 = peg$f27(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s1 = [s1, s2]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e11); + } + } + return s0; + } + function peg$parseX() { + var s0, s1, s2; + peg$silentFails++; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s1 !== peg$FAILED) { + peg$savedPos = peg$currPos; + s2 = peg$f28(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s1 = [s1, s2]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e12); + } + } + return s0; + } + function peg$parsebang() { + var s0, s1, s2; + peg$silentFails++; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s1 !== peg$FAILED) { + peg$savedPos = peg$currPos; + s2 = peg$f29(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s1 = [s1, s2]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e13); + } + } + return s0; + } + function peg$parseat() { + var s0, s1, s2; + peg$silentFails++; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s1 !== peg$FAILED) { + peg$savedPos = peg$currPos; + s2 = peg$f30(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s1 = [s1, s2]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e14); + } + } + return s0; + } + function peg$parseless() { + var s0, s1, s2; + peg$silentFails++; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s1 !== peg$FAILED) { + peg$savedPos = peg$currPos; + s2 = peg$f31(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s1 = [s1, s2]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e15); + } + } + return s0; + } + function peg$parsegreater() { + var s0, s1, s2; + peg$silentFails++; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s1 !== peg$FAILED) { + peg$savedPos = peg$currPos; + s2 = peg$f32(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s1 = [s1, s2]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e16); + } + } + return s0; + } + function peg$parsegroup() { + var s0, s1, s2; + peg$silentFails++; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s1 !== peg$FAILED) { + peg$savedPos = peg$currPos; + s2 = peg$f33(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s1 = [s1, s2]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e17); + } + } + return s0; + } + function peg$parse_() { + var s0, s1, s2; + peg$silentFails++; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s1 !== peg$FAILED) { + peg$savedPos = peg$currPos; + s2 = peg$f34(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s1 = [s1, s2]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e18); + } + } + return s0; + } + function peg$parseEOL() { + var s0, s1; + s0 = peg$currPos; + peg$silentFails++; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + peg$silentFails--; + if (s1 === peg$FAILED) { + s0 = void 0; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + if (!options.isHash) { + try { + Object.assign(options, { + matchChar: (node, char) => node.type === "string" && node.content === char, + isGroup: (node) => node.type === "group", + isWhitespace: (node) => node.type === "whitespace" + }); + } catch (e) { + console.warn("Error when initializing parser", e); + } + } + peg$result = peg$startRuleFunction(); + if (peg$result !== peg$FAILED && peg$currPos === input.length) { + return peg$result; + } else { + if (peg$result !== peg$FAILED && peg$currPos < input.length) { + peg$fail(peg$endExpectation()); + } + throw peg$buildStructuredError( + peg$maxFailExpected, + peg$maxFailPos < input.length ? input.charAt(peg$maxFailPos) : null, + peg$maxFailPos < input.length ? peg$computeLocation(peg$maxFailPos, peg$maxFailPos + 1) : peg$computeLocation(peg$maxFailPos, peg$maxFailPos) + ); + } + } + return { + SyntaxError: peg$SyntaxError, + parse: peg$parse + }; + }() +); +var systeme_environment_default = ( + // Generated by Peggy 2.0.1. + // + // https://peggyjs.org/ + function() { + "use strict"; + function peg$subclass(child, parent) { + function C() { + this.constructor = child; + } + C.prototype = parent.prototype; + child.prototype = new C(); + } + function peg$SyntaxError(message, expected, found, location) { + var self = Error.call(this, message); + if (Object.setPrototypeOf) { + Object.setPrototypeOf(self, peg$SyntaxError.prototype); + } + self.expected = expected; + self.found = found; + self.location = location; + self.name = "SyntaxError"; + return self; + } + peg$subclass(peg$SyntaxError, Error); + function peg$padEnd(str, targetLength, padString) { + padString = padString || " "; + if (str.length > targetLength) { + return str; + } + targetLength -= str.length; + padString += padString.repeat(targetLength); + return str + padString.slice(0, targetLength); + } + peg$SyntaxError.prototype.format = function(sources) { + var str = "Error: " + this.message; + if (this.location) { + var src = null; + var k; + for (k = 0; k < sources.length; k++) { + if (sources[k].source === this.location.source) { + src = sources[k].text.split(/\r\n|\n|\r/g); + break; + } + } + var s2 = this.location.start; + var loc = this.location.source + ":" + s2.line + ":" + s2.column; + if (src) { + var e = this.location.end; + var filler = peg$padEnd("", s2.line.toString().length, " "); + var line5 = src[s2.line - 1]; + var last = s2.line === e.line ? e.column : line5.length + 1; + var hatLen = last - s2.column || 1; + str += "\n --> " + loc + "\n" + filler + " |\n" + s2.line + " | " + line5 + "\n" + filler + " | " + peg$padEnd("", s2.column - 1, " ") + peg$padEnd("", hatLen, "^"); + } else { + str += "\n at " + loc; + } + } + return str; + }; + peg$SyntaxError.buildMessage = function(expected, found) { + var DESCRIBE_EXPECTATION_FNS = { + literal: function(expectation) { + return '"' + literalEscape(expectation.text) + '"'; + }, + class: function(expectation) { + var escapedParts = expectation.parts.map(function(part) { + return Array.isArray(part) ? classEscape(part[0]) + "-" + classEscape(part[1]) : classEscape(part); + }); + return "[" + (expectation.inverted ? "^" : "") + escapedParts.join("") + "]"; + }, + any: function() { + return "any character"; + }, + end: function() { + return "end of input"; + }, + other: function(expectation) { + return expectation.description; + } + }; + function hex(ch) { + return ch.charCodeAt(0).toString(16).toUpperCase(); + } + function literalEscape(s2) { + return s2.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\0/g, "\\0").replace(/\t/g, "\\t").replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/[\x00-\x0F]/g, function(ch) { + return "\\x0" + hex(ch); + }).replace(/[\x10-\x1F\x7F-\x9F]/g, function(ch) { + return "\\x" + hex(ch); + }); + } + function classEscape(s2) { + return s2.replace(/\\/g, "\\\\").replace(/\]/g, "\\]").replace(/\^/g, "\\^").replace(/-/g, "\\-").replace(/\0/g, "\\0").replace(/\t/g, "\\t").replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/[\x00-\x0F]/g, function(ch) { + return "\\x0" + hex(ch); + }).replace(/[\x10-\x1F\x7F-\x9F]/g, function(ch) { + return "\\x" + hex(ch); + }); + } + function describeExpectation(expectation) { + return DESCRIBE_EXPECTATION_FNS[expectation.type](expectation); + } + function describeExpected(expected2) { + var descriptions = expected2.map(describeExpectation); + var i, j; + descriptions.sort(); + if (descriptions.length > 0) { + for (i = 1, j = 1; i < descriptions.length; i++) { + if (descriptions[i - 1] !== descriptions[i]) { + descriptions[j] = descriptions[i]; + j++; + } + } + descriptions.length = j; + } + switch (descriptions.length) { + case 1: + return descriptions[0]; + case 2: + return descriptions[0] + " or " + descriptions[1]; + default: + return descriptions.slice(0, -1).join(", ") + ", or " + descriptions[descriptions.length - 1]; + } + } + function describeFound(found2) { + return found2 ? '"' + literalEscape(found2) + '"' : "end of input"; + } + return "Expected " + describeExpected(expected) + " but " + describeFound(found) + " found."; + }; + function peg$parse(input, options) { + options = options !== void 0 ? options : {}; + var peg$FAILED = {}; + var peg$source = options.grammarSource; + var peg$startRuleFunctions = { body: peg$parsebody }; + var peg$startRuleFunction = peg$parsebody; + var peg$e0 = peg$otherExpectation("partial item"); + var peg$e1 = peg$otherExpectation("item"); + var peg$e2 = peg$anyExpectation(); + var peg$e3 = peg$otherExpectation("equation"); + var peg$e4 = peg$otherExpectation("trailing comment"); + var peg$e5 = peg$otherExpectation("comment only line"); + var peg$e6 = peg$otherExpectation("non-var token"); + var peg$e7 = peg$otherExpectation("token"); + var peg$e8 = peg$otherExpectation("same line comment"); + var peg$e9 = peg$otherExpectation("own line comment"); + var peg$e10 = peg$otherExpectation(","); + var peg$e11 = peg$otherExpectation("@"); + var peg$e12 = peg$otherExpectation("variable token"); + var peg$e13 = peg$otherExpectation("+/-"); + var peg$e14 = peg$otherExpectation("="); + var peg$f0 = function(a, b) { + return a.concat(b ? b : []); + }; + var peg$f1 = function() { + return []; + }; + var peg$f2 = function(a, b, c) { + return a.concat(b, c); + }; + var peg$f3 = function(op, a, b, c) { + return { type: "item", op, variable: b, content: a.concat(b, c) }; + }; + var peg$f4 = function(op, a) { + return { type: "item", op, variable: null, content: a }; + }; + var peg$f5 = function(line5, sep, comment2) { + return { ...line5, sep: [].concat(sep), trailingComment: comment2 }; + }; + var peg$f6 = function(line5, comment2) { + return { ...line5, trailingComment: comment2 }; + }; + var peg$f7 = function(eq, ann) { + return { + type: "line", + equation: eq, + annotation: ann, + sep: null + }; + }; + var peg$f8 = function(at2, ann) { + return at2 ? { type: "annotation", marker: at2, content: ann } : null; + }; + var peg$f9 = function(left, eq, right) { + return { type: "equation", left, right, equals: eq }; + }; + var peg$f10 = function(x) { + return x; + }; + var peg$f11 = function(x) { + return { + type: "line", + trailingComment: x + }; + }; + var peg$f12 = function(v, s2) { + return [v].concat(s2 ? s2 : []); + }; + var peg$f13 = function(t) { + return t; + }; + var peg$f14 = function(x) { + return x; + }; + var peg$f15 = function(x) { + return x; + }; + var peg$f16 = function(tok) { + return options.isSameLineComment(tok); + }; + var peg$f17 = function(tok) { + return tok; + }; + var peg$f18 = function(tok) { + return options.isOwnLineComment(tok); + }; + var peg$f19 = function(tok) { + return tok; + }; + var peg$f20 = function(tok) { + return options.isWhitespace(tok); + }; + var peg$f21 = function(tok) { + return tok; + }; + var peg$f22 = function(tok) { + return options.isSep(tok); + }; + var peg$f23 = function(tok) { + return tok; + }; + var peg$f24 = function(tok) { + return options.isAt(tok); + }; + var peg$f25 = function(tok) { + return tok; + }; + var peg$f26 = function(tok) { + return options.isVar(tok); + }; + var peg$f27 = function(tok) { + return tok; + }; + var peg$f28 = function(tok) { + return options.isOperation(tok); + }; + var peg$f29 = function(tok) { + return tok; + }; + var peg$f30 = function(tok) { + return options.isEquals(tok); + }; + var peg$f31 = function(tok) { + return tok; + }; + var peg$f32 = function(tok) { + return options.isSubscript(tok); + }; + var peg$f33 = function(tok) { + return tok; + }; + var peg$currPos = 0; + var peg$savedPos = 0; + var peg$posDetailsCache = [{ line: 1, column: 1 }]; + var peg$maxFailPos = 0; + var peg$maxFailExpected = []; + var peg$silentFails = 0; + var peg$result; + if ("startRule" in options) { + if (!(options.startRule in peg$startRuleFunctions)) { + throw new Error(`Can't start parsing from rule "` + options.startRule + '".'); + } + peg$startRuleFunction = peg$startRuleFunctions[options.startRule]; + } + function text() { + return input.substring(peg$savedPos, peg$currPos); + } + function offset() { + return peg$savedPos; + } + function range() { + return { + source: peg$source, + start: peg$savedPos, + end: peg$currPos + }; + } + function location() { + return peg$computeLocation(peg$savedPos, peg$currPos); + } + function expected(description, location2) { + location2 = location2 !== void 0 ? location2 : peg$computeLocation(peg$savedPos, peg$currPos); + throw peg$buildStructuredError( + [peg$otherExpectation(description)], + input.substring(peg$savedPos, peg$currPos), + location2 + ); + } + function error(message, location2) { + location2 = location2 !== void 0 ? location2 : peg$computeLocation(peg$savedPos, peg$currPos); + throw peg$buildSimpleError(message, location2); + } + function peg$literalExpectation(text2, ignoreCase) { + return { type: "literal", text: text2, ignoreCase }; + } + function peg$classExpectation(parts, inverted, ignoreCase) { + return { type: "class", parts, inverted, ignoreCase }; + } + function peg$anyExpectation() { + return { type: "any" }; + } + function peg$endExpectation() { + return { type: "end" }; + } + function peg$otherExpectation(description) { + return { type: "other", description }; + } + function peg$computePosDetails(pos) { + var details = peg$posDetailsCache[pos]; + var p; + if (details) { + return details; + } else { + p = pos - 1; + while (!peg$posDetailsCache[p]) { + p--; + } + details = peg$posDetailsCache[p]; + details = { + line: details.line, + column: details.column + }; + while (p < pos) { + if (input.charCodeAt(p) === 10) { + details.line++; + details.column = 1; + } else { + details.column++; + } + p++; + } + peg$posDetailsCache[pos] = details; + return details; + } + } + function peg$computeLocation(startPos, endPos) { + var startPosDetails = peg$computePosDetails(startPos); + var endPosDetails = peg$computePosDetails(endPos); + return { + source: peg$source, + start: { + offset: startPos, + line: startPosDetails.line, + column: startPosDetails.column + }, + end: { + offset: endPos, + line: endPosDetails.line, + column: endPosDetails.column + } + }; + } + function peg$fail(expected2) { + if (peg$currPos < peg$maxFailPos) { + return; + } + if (peg$currPos > peg$maxFailPos) { + peg$maxFailPos = peg$currPos; + peg$maxFailExpected = []; + } + peg$maxFailExpected.push(expected2); + } + function peg$buildSimpleError(message, location2) { + return new peg$SyntaxError(message, null, null, location2); + } + function peg$buildStructuredError(expected2, found, location2) { + return new peg$SyntaxError( + peg$SyntaxError.buildMessage(expected2, found), + expected2, + found, + location2 + ); + } + function peg$parsebody() { + var s0, s1, s2; + s0 = peg$currPos; + s1 = []; + s2 = peg$parsecomment_only_line(); + if (s2 === peg$FAILED) { + s2 = peg$parseline_with_sep(); + if (s2 === peg$FAILED) { + s2 = peg$parsepartial_line_with_comment(); + } + } + while (s2 !== peg$FAILED) { + s1.push(s2); + s2 = peg$parsecomment_only_line(); + if (s2 === peg$FAILED) { + s2 = peg$parseline_with_sep(); + if (s2 === peg$FAILED) { + s2 = peg$parsepartial_line_with_comment(); + } + } + } + s2 = peg$parseline_without_sep(); + if (s2 === peg$FAILED) { + s2 = peg$parseEOL(); + } + if (s2 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f0(s1, s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$parseEOL(); + if (s1 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$f1(); + } + s0 = s1; + } + return s0; + } + function peg$parsepartial_item() { + var s0, s1, s2, s3, s4, s5, s6, s7, s8; + peg$silentFails++; + s0 = peg$currPos; + s1 = []; + s2 = peg$parse_(); + while (s2 !== peg$FAILED) { + s1.push(s2); + s2 = peg$parse_(); + } + s2 = []; + s3 = peg$parsenon_var_token(); + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$parsenon_var_token(); + } + s3 = []; + s4 = peg$parse_(); + while (s4 !== peg$FAILED) { + s3.push(s4); + s4 = peg$parse_(); + } + s4 = peg$parsevar(); + if (s4 !== peg$FAILED) { + s5 = []; + s6 = peg$parse_(); + while (s6 !== peg$FAILED) { + s5.push(s6); + s6 = peg$parse_(); + } + s6 = []; + s7 = peg$parsetoken(); + while (s7 !== peg$FAILED) { + s6.push(s7); + s7 = peg$parsetoken(); + } + s7 = []; + s8 = peg$parse_(); + while (s8 !== peg$FAILED) { + s7.push(s8); + s8 = peg$parse_(); + } + peg$savedPos = s0; + s0 = peg$f2(s2, s4, s6); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + return s0; + } + function peg$parseitem() { + var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9; + peg$silentFails++; + s0 = peg$currPos; + s1 = peg$parseoperation(); + if (s1 === peg$FAILED) { + s1 = null; + } + s2 = []; + s3 = peg$parse_(); + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$parse_(); + } + s3 = []; + s4 = peg$parsenon_var_token(); + while (s4 !== peg$FAILED) { + s3.push(s4); + s4 = peg$parsenon_var_token(); + } + s4 = []; + s5 = peg$parse_(); + while (s5 !== peg$FAILED) { + s4.push(s5); + s5 = peg$parse_(); + } + s5 = peg$parsevar(); + if (s5 !== peg$FAILED) { + s6 = []; + s7 = peg$parse_(); + while (s7 !== peg$FAILED) { + s6.push(s7); + s7 = peg$parse_(); + } + s7 = []; + s8 = peg$parsetoken(); + while (s8 !== peg$FAILED) { + s7.push(s8); + s8 = peg$parsetoken(); + } + s8 = []; + s9 = peg$parse_(); + while (s9 !== peg$FAILED) { + s8.push(s9); + s9 = peg$parse_(); + } + peg$savedPos = s0; + s0 = peg$f3(s1, s3, s5, s7); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$parseoperation(); + if (s1 === peg$FAILED) { + s1 = null; + } + s2 = []; + s3 = peg$parse_(); + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$parse_(); + } + s3 = []; + s4 = peg$parsenon_var_token(); + if (s4 !== peg$FAILED) { + while (s4 !== peg$FAILED) { + s3.push(s4); + s4 = peg$parsenon_var_token(); + } + } else { + s3 = peg$FAILED; + } + if (s3 !== peg$FAILED) { + s4 = []; + s5 = peg$parse_(); + while (s5 !== peg$FAILED) { + s4.push(s5); + s5 = peg$parse_(); + } + peg$savedPos = s0; + s0 = peg$f4(s1, s3); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e1); + } + } + return s0; + } + function peg$parseline_with_sep() { + var s0, s1, s2, s3; + s0 = peg$currPos; + s1 = peg$parseline_without_sep(); + if (s1 !== peg$FAILED) { + s2 = peg$parsesep(); + if (s2 !== peg$FAILED) { + s3 = peg$parsetrailing_comment(); + if (s3 === peg$FAILED) { + s3 = null; + } + peg$savedPos = s0; + s0 = peg$f5(s1, s2, s3); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsepartial_line_with_comment() { + var s0, s1, s2; + s0 = peg$currPos; + s1 = peg$parseline_without_sep(); + if (s1 !== peg$FAILED) { + s2 = peg$parsetrailing_comment(); + if (s2 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f6(s1, s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parseline_without_sep() { + var s0, s1, s2, s3; + s0 = peg$currPos; + s1 = peg$currPos; + peg$silentFails++; + if (input.length > peg$currPos) { + s2 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e2); + } + } + peg$silentFails--; + if (s2 !== peg$FAILED) { + peg$currPos = s1; + s1 = void 0; + } else { + s1 = peg$FAILED; + } + if (s1 !== peg$FAILED) { + s2 = peg$parseequation(); + s3 = peg$parseannotation(); + if (s3 === peg$FAILED) { + s3 = null; + } + peg$savedPos = s0; + s0 = peg$f7(s2, s3); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parseannotation() { + var s0, s1, s2, s3; + s0 = peg$currPos; + s1 = peg$parseat(); + if (s1 !== peg$FAILED) { + s2 = []; + s3 = peg$parsenon_sep_token(); + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$parsenon_sep_token(); + } + peg$savedPos = s0; + s0 = peg$f8(s1, s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parseequation() { + var s0, s1, s2, s3, s4; + peg$silentFails++; + s0 = peg$currPos; + s1 = []; + s2 = peg$parseitem(); + while (s2 !== peg$FAILED) { + s1.push(s2); + s2 = peg$parseitem(); + } + s2 = peg$parseequals(); + if (s2 === peg$FAILED) { + s2 = null; + } + s3 = []; + s4 = peg$parsetoken(); + if (s4 === peg$FAILED) { + s4 = peg$parseoperation(); + } + while (s4 !== peg$FAILED) { + s3.push(s4); + s4 = peg$parsetoken(); + if (s4 === peg$FAILED) { + s4 = peg$parseoperation(); + } + } + peg$savedPos = s0; + s0 = peg$f9(s1, s2, s3); + peg$silentFails--; + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + return s0; + } + function peg$parsetrailing_comment() { + var s0, s1, s2; + peg$silentFails++; + s0 = peg$currPos; + s1 = []; + s2 = peg$parse_(); + while (s2 !== peg$FAILED) { + s1.push(s2); + s2 = peg$parse_(); + } + s2 = peg$parsesame_line_comment(); + if (s2 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f10(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e4); + } + } + return s0; + } + function peg$parsecomment_only_line() { + var s0, s1, s2; + peg$silentFails++; + s0 = peg$currPos; + s1 = []; + s2 = peg$parse_(); + while (s2 !== peg$FAILED) { + s1.push(s2); + s2 = peg$parse_(); + } + s2 = peg$parseown_line_comment(); + if (s2 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f11(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e5); + } + } + return s0; + } + function peg$parsevar() { + var s0, s1, s2, s3; + s0 = peg$currPos; + s1 = peg$parsevar_token(); + if (s1 !== peg$FAILED) { + s2 = []; + s3 = peg$parse_(); + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$parse_(); + } + s3 = peg$parsesubscript(); + if (s3 === peg$FAILED) { + s3 = null; + } + peg$savedPos = s0; + s0 = peg$f12(s1, s3); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsenon_var_token() { + var s0, s1, s2; + peg$silentFails++; + s0 = peg$currPos; + s1 = peg$currPos; + peg$silentFails++; + s2 = peg$parsevar(); + peg$silentFails--; + if (s2 === peg$FAILED) { + s1 = void 0; + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + if (s1 !== peg$FAILED) { + s2 = peg$parsetoken(); + if (s2 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f13(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e6); + } + } + return s0; + } + function peg$parsenon_sep_token() { + var s0, s1, s2; + s0 = peg$currPos; + s1 = peg$currPos; + peg$silentFails++; + s2 = peg$parsesep(); + if (s2 === peg$FAILED) { + s2 = peg$parsetrailing_comment(); + if (s2 === peg$FAILED) { + s2 = peg$parseown_line_comment(); + } + } + peg$silentFails--; + if (s2 === peg$FAILED) { + s1 = void 0; + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + if (s1 !== peg$FAILED) { + if (input.length > peg$currPos) { + s2 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e2); + } + } + if (s2 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f14(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsetoken() { + var s0, s1, s2; + peg$silentFails++; + s0 = peg$currPos; + s1 = peg$currPos; + peg$silentFails++; + s2 = peg$parsesep(); + if (s2 === peg$FAILED) { + s2 = peg$parseat(); + if (s2 === peg$FAILED) { + s2 = peg$parseoperation(); + if (s2 === peg$FAILED) { + s2 = peg$parseequals(); + if (s2 === peg$FAILED) { + s2 = peg$parsetrailing_comment(); + if (s2 === peg$FAILED) { + s2 = peg$parseown_line_comment(); + } + } + } + } + } + peg$silentFails--; + if (s2 === peg$FAILED) { + s1 = void 0; + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + if (s1 !== peg$FAILED) { + if (input.length > peg$currPos) { + s2 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e2); + } + } + if (s2 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f15(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e7); + } + } + return s0; + } + function peg$parsesame_line_comment() { + var s0, s1, s2; + peg$silentFails++; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e2); + } + } + if (s1 !== peg$FAILED) { + peg$savedPos = peg$currPos; + s2 = peg$f16(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f17(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e8); + } + } + return s0; + } + function peg$parseown_line_comment() { + var s0, s1, s2; + peg$silentFails++; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e2); + } + } + if (s1 !== peg$FAILED) { + peg$savedPos = peg$currPos; + s2 = peg$f18(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f19(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e9); + } + } + return s0; + } + function peg$parse_() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e2); + } + } + if (s1 !== peg$FAILED) { + peg$savedPos = peg$currPos; + s2 = peg$f20(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f21(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsesep() { + var s0, s1, s2; + peg$silentFails++; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e2); + } + } + if (s1 !== peg$FAILED) { + peg$savedPos = peg$currPos; + s2 = peg$f22(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f23(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e10); + } + } + return s0; + } + function peg$parseat() { + var s0, s1, s2; + peg$silentFails++; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e2); + } + } + if (s1 !== peg$FAILED) { + peg$savedPos = peg$currPos; + s2 = peg$f24(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f25(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e11); + } + } + return s0; + } + function peg$parsevar_token() { + var s0, s1, s2; + peg$silentFails++; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e2); + } + } + if (s1 !== peg$FAILED) { + peg$savedPos = peg$currPos; + s2 = peg$f26(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f27(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e12); + } + } + return s0; + } + function peg$parseoperation() { + var s0, s1, s2, s3, s4; + peg$silentFails++; + s0 = peg$currPos; + s1 = []; + s2 = peg$parse_(); + while (s2 !== peg$FAILED) { + s1.push(s2); + s2 = peg$parse_(); + } + if (input.length > peg$currPos) { + s2 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e2); + } + } + if (s2 !== peg$FAILED) { + s3 = []; + s4 = peg$parse_(); + while (s4 !== peg$FAILED) { + s3.push(s4); + s4 = peg$parse_(); + } + peg$savedPos = peg$currPos; + s4 = peg$f28(s2); + if (s4) { + s4 = void 0; + } else { + s4 = peg$FAILED; + } + if (s4 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f29(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e13); + } + } + return s0; + } + function peg$parseequals() { + var s0, s1, s2; + peg$silentFails++; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e2); + } + } + if (s1 !== peg$FAILED) { + peg$savedPos = peg$currPos; + s2 = peg$f30(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f31(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e14); + } + } + return s0; + } + function peg$parsesubscript() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e2); + } + } + if (s1 !== peg$FAILED) { + peg$savedPos = peg$currPos; + s2 = peg$f32(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f33(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parseEOL() { + var s0, s1; + s0 = peg$currPos; + peg$silentFails++; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e2); + } + } + peg$silentFails--; + if (s1 === peg$FAILED) { + s0 = void 0; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + if (!options.isWhitespace) { + try { + Object.assign(options, { + isSep: (node) => node.type === "string" && node.content === ",", + isVar: (node) => node.type === "string" && node.content.match(/[a-zA-Z]/), + isOperation: (node) => node.type === "string" && node.content.match(/[+-]/), + isEquals: (node) => node.type === "string" && node.content === "=", + isAt: (node) => node.type === "string" && node.content === "@", + isSubscript: (node) => node.content === "_", + isWhitespace: (node) => node.type === "whitespace", + isSameLineComment: (node) => node.type === "comment" && node.sameline, + isOwnLineComment: (node) => node.type === "comment" && !node.sameline + }); + } catch (e) { + console.warn("Error when initializing parser", e); + } + } + peg$result = peg$startRuleFunction(); + if (peg$result !== peg$FAILED && peg$currPos === input.length) { + return peg$result; + } else { + if (peg$result !== peg$FAILED && peg$currPos < input.length) { + peg$fail(peg$endExpectation()); + } + throw peg$buildStructuredError( + peg$maxFailExpected, + peg$maxFailPos < input.length ? input.charAt(peg$maxFailPos) : null, + peg$maxFailPos < input.length ? peg$computeLocation(peg$maxFailPos, peg$maxFailPos + 1) : peg$computeLocation(peg$maxFailPos, peg$maxFailPos) + ); + } + } + return { + SyntaxError: peg$SyntaxError, + parse: peg$parse + }; + }() +); +var tex_glue_default = ( + // Generated by Peggy 2.0.1. + // + // https://peggyjs.org/ + function() { + "use strict"; + function peg$subclass(child, parent) { + function C() { + this.constructor = child; + } + C.prototype = parent.prototype; + child.prototype = new C(); + } + function peg$SyntaxError(message, expected, found, location) { + var self = Error.call(this, message); + if (Object.setPrototypeOf) { + Object.setPrototypeOf(self, peg$SyntaxError.prototype); + } + self.expected = expected; + self.found = found; + self.location = location; + self.name = "SyntaxError"; + return self; + } + peg$subclass(peg$SyntaxError, Error); + function peg$padEnd(str, targetLength, padString) { + padString = padString || " "; + if (str.length > targetLength) { + return str; + } + targetLength -= str.length; + padString += padString.repeat(targetLength); + return str + padString.slice(0, targetLength); + } + peg$SyntaxError.prototype.format = function(sources) { + var str = "Error: " + this.message; + if (this.location) { + var src = null; + var k; + for (k = 0; k < sources.length; k++) { + if (sources[k].source === this.location.source) { + src = sources[k].text.split(/\r\n|\n|\r/g); + break; + } + } + var s2 = this.location.start; + var loc = this.location.source + ":" + s2.line + ":" + s2.column; + if (src) { + var e = this.location.end; + var filler = peg$padEnd("", s2.line.toString().length, " "); + var line5 = src[s2.line - 1]; + var last = s2.line === e.line ? e.column : line5.length + 1; + var hatLen = last - s2.column || 1; + str += "\n --> " + loc + "\n" + filler + " |\n" + s2.line + " | " + line5 + "\n" + filler + " | " + peg$padEnd("", s2.column - 1, " ") + peg$padEnd("", hatLen, "^"); + } else { + str += "\n at " + loc; + } + } + return str; + }; + peg$SyntaxError.buildMessage = function(expected, found) { + var DESCRIBE_EXPECTATION_FNS = { + literal: function(expectation) { + return '"' + literalEscape(expectation.text) + '"'; + }, + class: function(expectation) { + var escapedParts = expectation.parts.map(function(part) { + return Array.isArray(part) ? classEscape(part[0]) + "-" + classEscape(part[1]) : classEscape(part); + }); + return "[" + (expectation.inverted ? "^" : "") + escapedParts.join("") + "]"; + }, + any: function() { + return "any character"; + }, + end: function() { + return "end of input"; + }, + other: function(expectation) { + return expectation.description; + } + }; + function hex(ch) { + return ch.charCodeAt(0).toString(16).toUpperCase(); + } + function literalEscape(s2) { + return s2.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\0/g, "\\0").replace(/\t/g, "\\t").replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/[\x00-\x0F]/g, function(ch) { + return "\\x0" + hex(ch); + }).replace(/[\x10-\x1F\x7F-\x9F]/g, function(ch) { + return "\\x" + hex(ch); + }); + } + function classEscape(s2) { + return s2.replace(/\\/g, "\\\\").replace(/\]/g, "\\]").replace(/\^/g, "\\^").replace(/-/g, "\\-").replace(/\0/g, "\\0").replace(/\t/g, "\\t").replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/[\x00-\x0F]/g, function(ch) { + return "\\x0" + hex(ch); + }).replace(/[\x10-\x1F\x7F-\x9F]/g, function(ch) { + return "\\x" + hex(ch); + }); + } + function describeExpectation(expectation) { + return DESCRIBE_EXPECTATION_FNS[expectation.type](expectation); + } + function describeExpected(expected2) { + var descriptions = expected2.map(describeExpectation); + var i, j; + descriptions.sort(); + if (descriptions.length > 0) { + for (i = 1, j = 1; i < descriptions.length; i++) { + if (descriptions[i - 1] !== descriptions[i]) { + descriptions[j] = descriptions[i]; + j++; + } + } + descriptions.length = j; + } + switch (descriptions.length) { + case 1: + return descriptions[0]; + case 2: + return descriptions[0] + " or " + descriptions[1]; + default: + return descriptions.slice(0, -1).join(", ") + ", or " + descriptions[descriptions.length - 1]; + } + } + function describeFound(found2) { + return found2 ? '"' + literalEscape(found2) + '"' : "end of input"; + } + return "Expected " + describeExpected(expected) + " but " + describeFound(found) + " found."; + }; + function peg$parse(input, options) { + options = options !== void 0 ? options : {}; + var peg$FAILED = {}; + var peg$source = options.grammarSource; + var peg$startRuleFunctions = { root: peg$parseroot }; + var peg$startRuleFunction = peg$parseroot; + var peg$c0 = "plus"; + var peg$c1 = "minus"; + var peg$c2 = "pt"; + var peg$c3 = "mm"; + var peg$c4 = "cm"; + var peg$c5 = "in"; + var peg$c6 = "ex"; + var peg$c7 = "em"; + var peg$c8 = "bp"; + var peg$c9 = "pc"; + var peg$c10 = "dd"; + var peg$c11 = "cc"; + var peg$c12 = "nd"; + var peg$c13 = "nc"; + var peg$c14 = "sp"; + var peg$c15 = "filll"; + var peg$c16 = "fill"; + var peg$c17 = "fil"; + var peg$c18 = "."; + var peg$c19 = "+"; + var peg$c20 = "-"; + var peg$r0 = /^[0-9]/; + var peg$e0 = peg$anyExpectation(); + var peg$e1 = peg$literalExpectation("plus", false); + var peg$e2 = peg$literalExpectation("minus", false); + var peg$e3 = peg$literalExpectation("pt", false); + var peg$e4 = peg$literalExpectation("mm", false); + var peg$e5 = peg$literalExpectation("cm", false); + var peg$e6 = peg$literalExpectation("in", false); + var peg$e7 = peg$literalExpectation("ex", false); + var peg$e8 = peg$literalExpectation("em", false); + var peg$e9 = peg$literalExpectation("bp", false); + var peg$e10 = peg$literalExpectation("pc", false); + var peg$e11 = peg$literalExpectation("dd", false); + var peg$e12 = peg$literalExpectation("cc", false); + var peg$e13 = peg$literalExpectation("nd", false); + var peg$e14 = peg$literalExpectation("nc", false); + var peg$e15 = peg$literalExpectation("sp", false); + var peg$e16 = peg$literalExpectation("filll", false); + var peg$e17 = peg$literalExpectation("fill", false); + var peg$e18 = peg$literalExpectation("fil", false); + var peg$e19 = peg$otherExpectation("number"); + var peg$e20 = peg$classExpectation([["0", "9"]], false, false); + var peg$e21 = peg$literalExpectation(".", false); + var peg$e22 = peg$literalExpectation("+", false); + var peg$e23 = peg$literalExpectation("-", false); + var peg$f0 = function(b, st, sh) { + return { + type: "glue", + fixed: b, + stretchable: st, + shrinkable: sh, + position: location() + }; + }; + var peg$f1 = function(glue) { + return glue; + }; + var peg$f2 = function(n, u) { + return { type: "dim", value: n, unit: u }; + }; + var peg$f3 = function(n, u) { + return { type: "dim", value: n, unit: u }; + }; + var peg$f4 = function(n, u) { + return { type: "dim", value: n, unit: u }; + }; + var peg$f5 = function(n) { + return parseFloat(n); + }; + var peg$currPos = 0; + var peg$savedPos = 0; + var peg$posDetailsCache = [{ line: 1, column: 1 }]; + var peg$maxFailPos = 0; + var peg$maxFailExpected = []; + var peg$silentFails = 0; + var peg$result; + if ("startRule" in options) { + if (!(options.startRule in peg$startRuleFunctions)) { + throw new Error(`Can't start parsing from rule "` + options.startRule + '".'); + } + peg$startRuleFunction = peg$startRuleFunctions[options.startRule]; + } + function text() { + return input.substring(peg$savedPos, peg$currPos); + } + function offset() { + return peg$savedPos; + } + function range() { + return { + source: peg$source, + start: peg$savedPos, + end: peg$currPos + }; + } + function location() { + return peg$computeLocation(peg$savedPos, peg$currPos); + } + function expected(description, location2) { + location2 = location2 !== void 0 ? location2 : peg$computeLocation(peg$savedPos, peg$currPos); + throw peg$buildStructuredError( + [peg$otherExpectation(description)], + input.substring(peg$savedPos, peg$currPos), + location2 + ); + } + function error(message, location2) { + location2 = location2 !== void 0 ? location2 : peg$computeLocation(peg$savedPos, peg$currPos); + throw peg$buildSimpleError(message, location2); + } + function peg$literalExpectation(text2, ignoreCase) { + return { type: "literal", text: text2, ignoreCase }; + } + function peg$classExpectation(parts, inverted, ignoreCase) { + return { type: "class", parts, inverted, ignoreCase }; + } + function peg$anyExpectation() { + return { type: "any" }; + } + function peg$endExpectation() { + return { type: "end" }; + } + function peg$otherExpectation(description) { + return { type: "other", description }; + } + function peg$computePosDetails(pos) { + var details = peg$posDetailsCache[pos]; + var p; + if (details) { + return details; + } else { + p = pos - 1; + while (!peg$posDetailsCache[p]) { + p--; + } + details = peg$posDetailsCache[p]; + details = { + line: details.line, + column: details.column + }; + while (p < pos) { + if (input.charCodeAt(p) === 10) { + details.line++; + details.column = 1; + } else { + details.column++; + } + p++; + } + peg$posDetailsCache[pos] = details; + return details; + } + } + function peg$computeLocation(startPos, endPos) { + var startPosDetails = peg$computePosDetails(startPos); + var endPosDetails = peg$computePosDetails(endPos); + return { + source: peg$source, + start: { + offset: startPos, + line: startPosDetails.line, + column: startPosDetails.column + }, + end: { + offset: endPos, + line: endPosDetails.line, + column: endPosDetails.column + } + }; + } + function peg$fail(expected2) { + if (peg$currPos < peg$maxFailPos) { + return; + } + if (peg$currPos > peg$maxFailPos) { + peg$maxFailPos = peg$currPos; + peg$maxFailExpected = []; + } + peg$maxFailExpected.push(expected2); + } + function peg$buildSimpleError(message, location2) { + return new peg$SyntaxError(message, null, null, location2); + } + function peg$buildStructuredError(expected2, found, location2) { + return new peg$SyntaxError( + peg$SyntaxError.buildMessage(expected2, found), + expected2, + found, + location2 + ); + } + function peg$parseroot() { + var s0, s1, s2, s3, s4; + s0 = peg$currPos; + s1 = peg$currPos; + s2 = peg$parsebase(); + if (s2 !== peg$FAILED) { + s3 = peg$parsestretchable(); + if (s3 === peg$FAILED) { + s3 = null; + } + s4 = peg$parseshrinkable(); + if (s4 === peg$FAILED) { + s4 = null; + } + peg$savedPos = s1; + s1 = peg$f0(s2, s3, s4); + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + if (s1 !== peg$FAILED) { + s2 = []; + if (input.length > peg$currPos) { + s3 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s3 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + while (s3 !== peg$FAILED) { + s2.push(s3); + if (input.length > peg$currPos) { + s3 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s3 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + } + peg$savedPos = s0; + s0 = peg$f1(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsebase() { + var s0, s1, s2; + s0 = peg$currPos; + s1 = peg$parsenumber(); + if (s1 !== peg$FAILED) { + s2 = peg$parseunit(); + if (s2 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f2(s1, s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsestretchable() { + var s0, s1, s2, s3; + s0 = peg$currPos; + if (input.substr(peg$currPos, 4) === peg$c0) { + s1 = peg$c0; + peg$currPos += 4; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e1); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$parsenumber(); + if (s2 !== peg$FAILED) { + s3 = peg$parserubber_unit(); + if (s3 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f3(s2, s3); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parseshrinkable() { + var s0, s1, s2, s3; + s0 = peg$currPos; + if (input.substr(peg$currPos, 5) === peg$c1) { + s1 = peg$c1; + peg$currPos += 5; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e2); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$parsenumber(); + if (s2 !== peg$FAILED) { + s3 = peg$parserubber_unit(); + if (s3 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f4(s2, s3); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parseunit() { + var s0; + if (input.substr(peg$currPos, 2) === peg$c2) { + s0 = peg$c2; + peg$currPos += 2; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s0 === peg$FAILED) { + if (input.substr(peg$currPos, 2) === peg$c3) { + s0 = peg$c3; + peg$currPos += 2; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e4); + } + } + if (s0 === peg$FAILED) { + if (input.substr(peg$currPos, 2) === peg$c4) { + s0 = peg$c4; + peg$currPos += 2; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e5); + } + } + if (s0 === peg$FAILED) { + if (input.substr(peg$currPos, 2) === peg$c5) { + s0 = peg$c5; + peg$currPos += 2; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e6); + } + } + if (s0 === peg$FAILED) { + if (input.substr(peg$currPos, 2) === peg$c6) { + s0 = peg$c6; + peg$currPos += 2; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e7); + } + } + if (s0 === peg$FAILED) { + if (input.substr(peg$currPos, 2) === peg$c7) { + s0 = peg$c7; + peg$currPos += 2; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e8); + } + } + if (s0 === peg$FAILED) { + if (input.substr(peg$currPos, 2) === peg$c8) { + s0 = peg$c8; + peg$currPos += 2; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e9); + } + } + if (s0 === peg$FAILED) { + if (input.substr(peg$currPos, 2) === peg$c9) { + s0 = peg$c9; + peg$currPos += 2; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e10); + } + } + if (s0 === peg$FAILED) { + if (input.substr(peg$currPos, 2) === peg$c10) { + s0 = peg$c10; + peg$currPos += 2; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e11); + } + } + if (s0 === peg$FAILED) { + if (input.substr(peg$currPos, 2) === peg$c11) { + s0 = peg$c11; + peg$currPos += 2; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e12); + } + } + if (s0 === peg$FAILED) { + if (input.substr(peg$currPos, 2) === peg$c12) { + s0 = peg$c12; + peg$currPos += 2; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e13); + } + } + if (s0 === peg$FAILED) { + if (input.substr(peg$currPos, 2) === peg$c13) { + s0 = peg$c13; + peg$currPos += 2; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e14); + } + } + if (s0 === peg$FAILED) { + if (input.substr(peg$currPos, 2) === peg$c14) { + s0 = peg$c14; + peg$currPos += 2; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e15); + } + } + } + } + } + } + } + } + } + } + } + } + } + } + return s0; + } + function peg$parserubber_unit() { + var s0; + s0 = peg$parseunit(); + if (s0 === peg$FAILED) { + if (input.substr(peg$currPos, 5) === peg$c15) { + s0 = peg$c15; + peg$currPos += 5; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e16); + } + } + if (s0 === peg$FAILED) { + if (input.substr(peg$currPos, 4) === peg$c16) { + s0 = peg$c16; + peg$currPos += 4; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e17); + } + } + if (s0 === peg$FAILED) { + if (input.substr(peg$currPos, 3) === peg$c17) { + s0 = peg$c17; + peg$currPos += 3; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e18); + } + } + } + } + } + return s0; + } + function peg$parsenumber() { + var s0, s1, s2, s3, s4, s5, s6, s7, s8; + peg$silentFails++; + s0 = peg$currPos; + s1 = peg$currPos; + s2 = peg$currPos; + s3 = peg$parsesign(); + if (s3 === peg$FAILED) { + s3 = null; + } + s4 = peg$currPos; + s5 = []; + if (peg$r0.test(input.charAt(peg$currPos))) { + s6 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s6 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e20); + } + } + while (s6 !== peg$FAILED) { + s5.push(s6); + if (peg$r0.test(input.charAt(peg$currPos))) { + s6 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s6 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e20); + } + } + } + if (input.charCodeAt(peg$currPos) === 46) { + s6 = peg$c18; + peg$currPos++; + } else { + s6 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e21); + } + } + if (s6 !== peg$FAILED) { + s7 = []; + if (peg$r0.test(input.charAt(peg$currPos))) { + s8 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s8 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e20); + } + } + if (s8 !== peg$FAILED) { + while (s8 !== peg$FAILED) { + s7.push(s8); + if (peg$r0.test(input.charAt(peg$currPos))) { + s8 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s8 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e20); + } + } + } + } else { + s7 = peg$FAILED; + } + if (s7 !== peg$FAILED) { + s5 = [s5, s6, s7]; + s4 = s5; + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + if (s4 === peg$FAILED) { + s4 = []; + if (peg$r0.test(input.charAt(peg$currPos))) { + s5 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s5 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e20); + } + } + if (s5 !== peg$FAILED) { + while (s5 !== peg$FAILED) { + s4.push(s5); + if (peg$r0.test(input.charAt(peg$currPos))) { + s5 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s5 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e20); + } + } + } + } else { + s4 = peg$FAILED; + } + } + if (s4 !== peg$FAILED) { + s3 = [s3, s4]; + s2 = s3; + } else { + peg$currPos = s2; + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s1 = input.substring(s1, peg$currPos); + } else { + s1 = s2; + } + if (s1 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$f5(s1); + } + s0 = s1; + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e19); + } + } + return s0; + } + function peg$parsesign() { + var s0; + if (input.charCodeAt(peg$currPos) === 43) { + s0 = peg$c19; + peg$currPos++; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e22); + } + } + if (s0 === peg$FAILED) { + if (input.charCodeAt(peg$currPos) === 45) { + s0 = peg$c20; + peg$currPos++; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e23); + } + } + } + return s0; + } + function peg$parseEOL() { + var s0, s1; + s0 = peg$currPos; + peg$silentFails++; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + peg$silentFails--; + if (s1 === peg$FAILED) { + s0 = void 0; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + peg$result = peg$startRuleFunction(); + if (peg$result !== peg$FAILED && peg$currPos === input.length) { + return peg$result; + } else { + if (peg$result !== peg$FAILED && peg$currPos < input.length) { + peg$fail(peg$endExpectation()); + } + throw peg$buildStructuredError( + peg$maxFailExpected, + peg$maxFailPos < input.length ? input.charAt(peg$maxFailPos) : null, + peg$maxFailPos < input.length ? peg$computeLocation(peg$maxFailPos, peg$maxFailPos + 1) : peg$computeLocation(peg$maxFailPos, peg$maxFailPos) + ); + } + } + return { + SyntaxError: peg$SyntaxError, + parse: peg$parse + }; + }() +); +var tikz_default = ( + // Generated by Peggy 2.0.1. + // + // https://peggyjs.org/ + function() { + "use strict"; + function peg$subclass(child, parent) { + function C() { + this.constructor = child; + } + C.prototype = parent.prototype; + child.prototype = new C(); + } + function peg$SyntaxError(message, expected, found, location) { + var self = Error.call(this, message); + if (Object.setPrototypeOf) { + Object.setPrototypeOf(self, peg$SyntaxError.prototype); + } + self.expected = expected; + self.found = found; + self.location = location; + self.name = "SyntaxError"; + return self; + } + peg$subclass(peg$SyntaxError, Error); + function peg$padEnd(str, targetLength, padString) { + padString = padString || " "; + if (str.length > targetLength) { + return str; + } + targetLength -= str.length; + padString += padString.repeat(targetLength); + return str + padString.slice(0, targetLength); + } + peg$SyntaxError.prototype.format = function(sources) { + var str = "Error: " + this.message; + if (this.location) { + var src = null; + var k; + for (k = 0; k < sources.length; k++) { + if (sources[k].source === this.location.source) { + src = sources[k].text.split(/\r\n|\n|\r/g); + break; + } + } + var s2 = this.location.start; + var loc = this.location.source + ":" + s2.line + ":" + s2.column; + if (src) { + var e = this.location.end; + var filler = peg$padEnd("", s2.line.toString().length, " "); + var line5 = src[s2.line - 1]; + var last = s2.line === e.line ? e.column : line5.length + 1; + var hatLen = last - s2.column || 1; + str += "\n --> " + loc + "\n" + filler + " |\n" + s2.line + " | " + line5 + "\n" + filler + " | " + peg$padEnd("", s2.column - 1, " ") + peg$padEnd("", hatLen, "^"); + } else { + str += "\n at " + loc; + } + } + return str; + }; + peg$SyntaxError.buildMessage = function(expected, found) { + var DESCRIBE_EXPECTATION_FNS = { + literal: function(expectation) { + return '"' + literalEscape(expectation.text) + '"'; + }, + class: function(expectation) { + var escapedParts = expectation.parts.map(function(part) { + return Array.isArray(part) ? classEscape(part[0]) + "-" + classEscape(part[1]) : classEscape(part); + }); + return "[" + (expectation.inverted ? "^" : "") + escapedParts.join("") + "]"; + }, + any: function() { + return "any character"; + }, + end: function() { + return "end of input"; + }, + other: function(expectation) { + return expectation.description; + } + }; + function hex(ch) { + return ch.charCodeAt(0).toString(16).toUpperCase(); + } + function literalEscape(s2) { + return s2.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\0/g, "\\0").replace(/\t/g, "\\t").replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/[\x00-\x0F]/g, function(ch) { + return "\\x0" + hex(ch); + }).replace(/[\x10-\x1F\x7F-\x9F]/g, function(ch) { + return "\\x" + hex(ch); + }); + } + function classEscape(s2) { + return s2.replace(/\\/g, "\\\\").replace(/\]/g, "\\]").replace(/\^/g, "\\^").replace(/-/g, "\\-").replace(/\0/g, "\\0").replace(/\t/g, "\\t").replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/[\x00-\x0F]/g, function(ch) { + return "\\x0" + hex(ch); + }).replace(/[\x10-\x1F\x7F-\x9F]/g, function(ch) { + return "\\x" + hex(ch); + }); + } + function describeExpectation(expectation) { + return DESCRIBE_EXPECTATION_FNS[expectation.type](expectation); + } + function describeExpected(expected2) { + var descriptions = expected2.map(describeExpectation); + var i, j; + descriptions.sort(); + if (descriptions.length > 0) { + for (i = 1, j = 1; i < descriptions.length; i++) { + if (descriptions[i - 1] !== descriptions[i]) { + descriptions[j] = descriptions[i]; + j++; + } + } + descriptions.length = j; + } + switch (descriptions.length) { + case 1: + return descriptions[0]; + case 2: + return descriptions[0] + " or " + descriptions[1]; + default: + return descriptions.slice(0, -1).join(", ") + ", or " + descriptions[descriptions.length - 1]; + } + } + function describeFound(found2) { + return found2 ? '"' + literalEscape(found2) + '"' : "end of input"; + } + return "Expected " + describeExpected(expected) + " but " + describeFound(found) + " found."; + }; + function peg$parse(input, options) { + options = options !== void 0 ? options : {}; + var peg$FAILED = {}; + var peg$source = options.grammarSource; + var peg$startRuleFunctions = { path_spec: peg$parsepath_spec, foreach_body: peg$parseforeach_body }; + var peg$startRuleFunction = peg$parsepath_spec; + var peg$e0 = peg$anyExpectation(); + var peg$e1 = peg$otherExpectation("same line comment"); + var peg$e2 = peg$otherExpectation("own line comment"); + var peg$e3 = peg$otherExpectation("comment"); + var peg$e4 = peg$otherExpectation("floating comment"); + var peg$e5 = peg$otherExpectation("operation"); + var peg$e6 = peg$otherExpectation("="); + var peg$f0 = function(v) { + return v; + }; + var peg$f1 = function(ops) { + return { type: "path_spec", content: ops }; + }; + var peg$f2 = function(c1, op, comment2) { + return { op, comment: comment2 }; + }; + var peg$f3 = function(c1, ops, c2, body) { + const comments = [c1, ...ops.map((x) => x.comment), c2].filter( + (x) => x + ); + const attribute = ops.map((x) => x.op.content.content).join(" "); + return { + type: "animation", + comments, + attribute, + content: body.content + }; + }; + var peg$f4 = function(start, b) { + return { ...b, start, type: "foreach" }; + }; + var peg$f5 = function(c1, variables, options2, c2, c3, list, c4, command) { + const comments = [c1, c2, c3, c4].filter((x) => x); + return { + type: "foreach_body", + variables, + options: options2 && options2.content, + list, + command, + comments + }; + }; + var peg$f6 = function(c1, options2, c2, body) { + const comments = [c1, c2].filter((x) => x); + return { + type: "svg_operation", + options: options2 && options2.content, + content: body, + comments + }; + }; + var peg$f7 = function(c1, c2, coord, c3, c4, x) { + return { coord: x, comment: c4 }; + }; + var peg$f8 = function(c1, c2, coord, c3, a, c5) { + const comments = [c1, c2, c3, a && a.comment, c5].filter((x) => x); + return { + type: "curve_to", + controls: a ? [coord, a.coord] : [coord], + comments + }; + }; + var peg$f9 = function() { + return { type: "line_to", command: "|-" }; + }; + var peg$f10 = function() { + return { type: "line_to", command: "-|" }; + }; + var peg$f11 = function() { + return { type: "line_to", command: "--" }; + }; + var peg$f12 = function(prefix, content) { + return { type: "coordinate", content, prefix }; + }; + var peg$f13 = function(content) { + return { type: "square_brace_group", content }; + }; + var peg$f14 = function(v) { + return { type: "unknown", content: v }; + }; + var peg$f15 = function(tok) { + return options.isSameLineComment(tok); + }; + var peg$f16 = function(tok) { + return tok; + }; + var peg$f17 = function(tok) { + return options.isOwnLineComment(tok); + }; + var peg$f18 = function(tok) { + return tok; + }; + var peg$f19 = function(tok) { + return options.isComment(tok); + }; + var peg$f20 = function(tok) { + return tok; + }; + var peg$f21 = function(tok) { + return options.isWhitespace(tok); + }; + var peg$f22 = function(tok) { + return tok; + }; + var peg$f23 = function(c) { + return c; + }; + var peg$f24 = function(tok) { + return options.isOperation(tok); + }; + var peg$f25 = function(tok) { + return { type: "operation", content: tok }; + }; + var peg$f26 = function(tok) { + return options.isChar(tok, "="); + }; + var peg$f27 = function(tok) { + return tok; + }; + var peg$f28 = function(tok) { + return options.isChar(tok, "["); + }; + var peg$f29 = function(tok) { + return tok; + }; + var peg$f30 = function(tok) { + return options.isChar(tok, "]"); + }; + var peg$f31 = function(tok) { + return tok; + }; + var peg$f32 = function(tok) { + return options.isChar(tok, "("); + }; + var peg$f33 = function(tok) { + return tok; + }; + var peg$f34 = function(tok) { + return options.isChar(tok, ")"); + }; + var peg$f35 = function(tok) { + return tok; + }; + var peg$f36 = function(tok) { + return options.isChar(tok, "+"); + }; + var peg$f37 = function(tok) { + return tok; + }; + var peg$f38 = function(tok) { + return options.isChar(tok, "-"); + }; + var peg$f39 = function(tok) { + return tok; + }; + var peg$f40 = function(tok) { + return options.isChar(tok, "|"); + }; + var peg$f41 = function(tok) { + return tok; + }; + var peg$f42 = function(tok) { + return options.isChar(tok, "."); + }; + var peg$f43 = function(tok) { + return tok; + }; + var peg$f44 = function(tok) { + return options.isChar(tok, "controls"); + }; + var peg$f45 = function(tok) { + return tok; + }; + var peg$f46 = function(tok) { + return options.isChar(tok, "and"); + }; + var peg$f47 = function(tok) { + return tok; + }; + var peg$f48 = function(tok) { + return options.isChar(tok, "svg"); + }; + var peg$f49 = function(tok) { + return tok; + }; + var peg$f50 = function(tok) { + return options.isGroup(tok); + }; + var peg$f51 = function(tok) { + return tok; + }; + var peg$f52 = function(tok) { + return options.isAnyMacro(tok); + }; + var peg$f53 = function(tok) { + return tok; + }; + var peg$f54 = function(tok) { + return options.isChar(tok, "foreach"); + }; + var peg$f55 = function(tok) { + return tok; + }; + var peg$f56 = function(tok) { + return options.isMacro(tok, "foreach"); + }; + var peg$f57 = function(tok) { + return tok; + }; + var peg$f58 = function(tok) { + return options.isChar(tok, "in"); + }; + var peg$f59 = function(tok) { + return tok; + }; + var peg$f60 = function(tok) { + return options.isChar(tok, ":"); + }; + var peg$f61 = function(tok) { + return tok; + }; + var peg$currPos = 0; + var peg$savedPos = 0; + var peg$posDetailsCache = [{ line: 1, column: 1 }]; + var peg$maxFailPos = 0; + var peg$maxFailExpected = []; + var peg$silentFails = 0; + var peg$result; + if ("startRule" in options) { + if (!(options.startRule in peg$startRuleFunctions)) { + throw new Error(`Can't start parsing from rule "` + options.startRule + '".'); + } + peg$startRuleFunction = peg$startRuleFunctions[options.startRule]; + } + function text() { + return input.substring(peg$savedPos, peg$currPos); + } + function offset() { + return peg$savedPos; + } + function range() { + return { + source: peg$source, + start: peg$savedPos, + end: peg$currPos + }; + } + function location() { + return peg$computeLocation(peg$savedPos, peg$currPos); + } + function expected(description, location2) { + location2 = location2 !== void 0 ? location2 : peg$computeLocation(peg$savedPos, peg$currPos); + throw peg$buildStructuredError( + [peg$otherExpectation(description)], + input.substring(peg$savedPos, peg$currPos), + location2 + ); + } + function error(message, location2) { + location2 = location2 !== void 0 ? location2 : peg$computeLocation(peg$savedPos, peg$currPos); + throw peg$buildSimpleError(message, location2); + } + function peg$literalExpectation(text2, ignoreCase) { + return { type: "literal", text: text2, ignoreCase }; + } + function peg$classExpectation(parts, inverted, ignoreCase) { + return { type: "class", parts, inverted, ignoreCase }; + } + function peg$anyExpectation() { + return { type: "any" }; + } + function peg$endExpectation() { + return { type: "end" }; + } + function peg$otherExpectation(description) { + return { type: "other", description }; + } + function peg$computePosDetails(pos) { + var details = peg$posDetailsCache[pos]; + var p; + if (details) { + return details; + } else { + p = pos - 1; + while (!peg$posDetailsCache[p]) { + p--; + } + details = peg$posDetailsCache[p]; + details = { + line: details.line, + column: details.column + }; + while (p < pos) { + if (input.charCodeAt(p) === 10) { + details.line++; + details.column = 1; + } else { + details.column++; + } + p++; + } + peg$posDetailsCache[pos] = details; + return details; + } + } + function peg$computeLocation(startPos, endPos) { + var startPosDetails = peg$computePosDetails(startPos); + var endPosDetails = peg$computePosDetails(endPos); + return { + source: peg$source, + start: { + offset: startPos, + line: startPosDetails.line, + column: startPosDetails.column + }, + end: { + offset: endPos, + line: endPosDetails.line, + column: endPosDetails.column + } + }; + } + function peg$fail(expected2) { + if (peg$currPos < peg$maxFailPos) { + return; + } + if (peg$currPos > peg$maxFailPos) { + peg$maxFailPos = peg$currPos; + peg$maxFailExpected = []; + } + peg$maxFailExpected.push(expected2); + } + function peg$buildSimpleError(message, location2) { + return new peg$SyntaxError(message, null, null, location2); + } + function peg$buildStructuredError(expected2, found, location2) { + return new peg$SyntaxError( + peg$SyntaxError.buildMessage(expected2, found), + expected2, + found, + location2 + ); + } + function peg$parsepath_spec() { + var s0, s1, s2, s3, s4, s5; + s0 = peg$currPos; + s1 = []; + s2 = peg$currPos; + s3 = peg$parsesquare_brace_group(); + if (s3 === peg$FAILED) { + s3 = peg$parsecoordinate(); + if (s3 === peg$FAILED) { + s3 = peg$parsecurve_to(); + if (s3 === peg$FAILED) { + s3 = peg$parseline_to(); + if (s3 === peg$FAILED) { + s3 = peg$parsesvg(); + if (s3 === peg$FAILED) { + s3 = peg$parseforeach(); + if (s3 === peg$FAILED) { + s3 = peg$parseoperation(); + if (s3 === peg$FAILED) { + s3 = peg$parsecomment(); + if (s3 === peg$FAILED) { + s3 = peg$parseanimation(); + if (s3 === peg$FAILED) { + s3 = peg$parseunknown(); + } + } + } + } + } + } + } + } + } + if (s3 !== peg$FAILED) { + s4 = []; + s5 = peg$parse_(); + while (s5 !== peg$FAILED) { + s4.push(s5); + s5 = peg$parse_(); + } + peg$savedPos = s2; + s2 = peg$f0(s3); + } else { + peg$currPos = s2; + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + while (s2 !== peg$FAILED) { + s1.push(s2); + s2 = peg$currPos; + s3 = peg$parsesquare_brace_group(); + if (s3 === peg$FAILED) { + s3 = peg$parsecoordinate(); + if (s3 === peg$FAILED) { + s3 = peg$parsecurve_to(); + if (s3 === peg$FAILED) { + s3 = peg$parseline_to(); + if (s3 === peg$FAILED) { + s3 = peg$parsesvg(); + if (s3 === peg$FAILED) { + s3 = peg$parseforeach(); + if (s3 === peg$FAILED) { + s3 = peg$parseoperation(); + if (s3 === peg$FAILED) { + s3 = peg$parsecomment(); + if (s3 === peg$FAILED) { + s3 = peg$parseanimation(); + if (s3 === peg$FAILED) { + s3 = peg$parseunknown(); + } + } + } + } + } + } + } + } + } + if (s3 !== peg$FAILED) { + s4 = []; + s5 = peg$parse_(); + while (s5 !== peg$FAILED) { + s4.push(s5); + s5 = peg$parse_(); + } + peg$savedPos = s2; + s2 = peg$f0(s3); + } else { + peg$currPos = s2; + s2 = peg$FAILED; + } + } + } else { + s1 = peg$FAILED; + } + if (s1 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$f1(s1); + } + s0 = s1; + return s0; + } + function peg$parseanimation() { + var s0, s1, s2, s3, s4, s5, s6; + s0 = peg$currPos; + s1 = peg$parsecolon(); + if (s1 !== peg$FAILED) { + s2 = peg$parse_comment_(); + s3 = []; + s4 = peg$currPos; + s5 = peg$parseoperation(); + if (s5 !== peg$FAILED) { + s6 = peg$parse_comment_(); + peg$savedPos = s4; + s4 = peg$f2(s2, s5, s6); + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + if (s4 !== peg$FAILED) { + while (s4 !== peg$FAILED) { + s3.push(s4); + s4 = peg$currPos; + s5 = peg$parseoperation(); + if (s5 !== peg$FAILED) { + s6 = peg$parse_comment_(); + peg$savedPos = s4; + s4 = peg$f2(s2, s5, s6); + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + } + } else { + s3 = peg$FAILED; + } + if (s3 !== peg$FAILED) { + s4 = peg$parseequals(); + if (s4 !== peg$FAILED) { + s5 = peg$parse_comment_(); + s6 = peg$parsegroup(); + if (s6 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f3(s2, s3, s5, s6); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parseforeach() { + var s0, s1, s2; + s0 = peg$currPos; + s1 = peg$parseforeach_keyword(); + if (s1 === peg$FAILED) { + s1 = peg$parseforeach_macro(); + } + if (s1 !== peg$FAILED) { + s2 = peg$parseforeach_body(); + if (s2 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f4(s1, s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parseforeach_body() { + var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9; + s0 = peg$currPos; + s1 = peg$parse_comment_(); + s2 = peg$currPos; + s3 = []; + s4 = peg$currPos; + s5 = peg$currPos; + peg$silentFails++; + s6 = peg$parsein_keyword(); + if (s6 === peg$FAILED) { + s6 = peg$parsesquare_brace_group(); + } + peg$silentFails--; + if (s6 === peg$FAILED) { + s5 = void 0; + } else { + peg$currPos = s5; + s5 = peg$FAILED; + } + if (s5 !== peg$FAILED) { + if (input.length > peg$currPos) { + s6 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s6 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s6 !== peg$FAILED) { + s5 = [s5, s6]; + s4 = s5; + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + while (s4 !== peg$FAILED) { + s3.push(s4); + s4 = peg$currPos; + s5 = peg$currPos; + peg$silentFails++; + s6 = peg$parsein_keyword(); + if (s6 === peg$FAILED) { + s6 = peg$parsesquare_brace_group(); + } + peg$silentFails--; + if (s6 === peg$FAILED) { + s5 = void 0; + } else { + peg$currPos = s5; + s5 = peg$FAILED; + } + if (s5 !== peg$FAILED) { + if (input.length > peg$currPos) { + s6 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s6 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s6 !== peg$FAILED) { + s5 = [s5, s6]; + s4 = s5; + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + } + s2 = input.substring(s2, peg$currPos); + s3 = peg$parsesquare_brace_group(); + if (s3 === peg$FAILED) { + s3 = null; + } + s4 = peg$parse_comment_(); + s5 = peg$parsein_keyword(); + if (s5 !== peg$FAILED) { + s6 = peg$parse_comment_(); + s7 = peg$parsegroup(); + if (s7 === peg$FAILED) { + s7 = peg$parsemacro(); + } + if (s7 !== peg$FAILED) { + s8 = peg$parse_comment_(); + s9 = peg$parseforeach(); + if (s9 === peg$FAILED) { + s9 = peg$parsegroup(); + if (s9 === peg$FAILED) { + s9 = peg$parsemacro(); + } + } + if (s9 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f5(s1, s2, s3, s4, s6, s7, s8, s9); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsesvg() { + var s0, s1, s2, s3, s4, s5; + s0 = peg$currPos; + s1 = peg$parsesvg_keyword(); + if (s1 !== peg$FAILED) { + s2 = peg$parse_comment_(); + s3 = peg$parsesquare_brace_group(); + if (s3 === peg$FAILED) { + s3 = null; + } + s4 = peg$parse_comment_(); + s5 = peg$parsegroup(); + if (s5 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f6(s2, s3, s4, s5); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsecurve_to() { + var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10; + s0 = peg$currPos; + s1 = peg$parsedotdot(); + if (s1 !== peg$FAILED) { + s2 = peg$parse_comment_(); + s3 = peg$parsecontrols_keyword(); + if (s3 !== peg$FAILED) { + s4 = peg$parse_comment_(); + s5 = peg$parsecoordinate(); + if (s5 !== peg$FAILED) { + s6 = peg$parse_comment_(); + s7 = peg$currPos; + s8 = peg$parseand_keyword(); + if (s8 !== peg$FAILED) { + s9 = peg$parse_comment_(); + s10 = peg$parsecoordinate(); + if (s10 !== peg$FAILED) { + peg$savedPos = s7; + s7 = peg$f7(s2, s4, s5, s6, s9, s10); + } else { + peg$currPos = s7; + s7 = peg$FAILED; + } + } else { + peg$currPos = s7; + s7 = peg$FAILED; + } + if (s7 === peg$FAILED) { + s7 = null; + } + s8 = peg$parse_comment_(); + s9 = peg$parsedotdot(); + if (s9 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f8(s2, s4, s5, s6, s7, s8); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parseline_to() { + var s0, s1, s2; + s0 = peg$currPos; + s1 = peg$parsepipe(); + if (s1 !== peg$FAILED) { + s2 = peg$parseminus(); + if (s2 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f9(); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$parseminus(); + if (s1 !== peg$FAILED) { + s2 = peg$parsepipe(); + if (s2 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f10(); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$parseminus(); + if (s1 !== peg$FAILED) { + s2 = peg$parseminus(); + if (s2 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f11(); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } + } + return s0; + } + function peg$parsecoordinate() { + var s0, s1, s2, s3, s4, s5, s6, s7; + s0 = peg$currPos; + s1 = peg$currPos; + s2 = peg$currPos; + s3 = peg$parseplus(); + if (s3 !== peg$FAILED) { + s4 = peg$parseplus(); + if (s4 === peg$FAILED) { + s4 = null; + } + s3 = [s3, s4]; + s2 = s3; + } else { + peg$currPos = s2; + s2 = peg$FAILED; + } + if (s2 === peg$FAILED) { + s2 = null; + } + s1 = input.substring(s1, peg$currPos); + s2 = peg$parseopen_paren(); + if (s2 !== peg$FAILED) { + s3 = peg$currPos; + s4 = []; + s5 = peg$currPos; + s6 = peg$currPos; + peg$silentFails++; + s7 = peg$parseclose_paren(); + peg$silentFails--; + if (s7 === peg$FAILED) { + s6 = void 0; + } else { + peg$currPos = s6; + s6 = peg$FAILED; + } + if (s6 !== peg$FAILED) { + if (input.length > peg$currPos) { + s7 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s7 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s7 !== peg$FAILED) { + s6 = [s6, s7]; + s5 = s6; + } else { + peg$currPos = s5; + s5 = peg$FAILED; + } + } else { + peg$currPos = s5; + s5 = peg$FAILED; + } + while (s5 !== peg$FAILED) { + s4.push(s5); + s5 = peg$currPos; + s6 = peg$currPos; + peg$silentFails++; + s7 = peg$parseclose_paren(); + peg$silentFails--; + if (s7 === peg$FAILED) { + s6 = void 0; + } else { + peg$currPos = s6; + s6 = peg$FAILED; + } + if (s6 !== peg$FAILED) { + if (input.length > peg$currPos) { + s7 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s7 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s7 !== peg$FAILED) { + s6 = [s6, s7]; + s5 = s6; + } else { + peg$currPos = s5; + s5 = peg$FAILED; + } + } else { + peg$currPos = s5; + s5 = peg$FAILED; + } + } + s3 = input.substring(s3, peg$currPos); + s4 = peg$parseclose_paren(); + if (s4 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f12(s1, s3); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsesquare_brace_group() { + var s0, s1, s2, s3, s4, s5, s6; + s0 = peg$currPos; + s1 = peg$parseopen_square_brace(); + if (s1 !== peg$FAILED) { + s2 = peg$currPos; + s3 = []; + s4 = peg$currPos; + s5 = peg$currPos; + peg$silentFails++; + s6 = peg$parseclose_square_brace(); + peg$silentFails--; + if (s6 === peg$FAILED) { + s5 = void 0; + } else { + peg$currPos = s5; + s5 = peg$FAILED; + } + if (s5 !== peg$FAILED) { + if (input.length > peg$currPos) { + s6 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s6 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s6 !== peg$FAILED) { + s5 = [s5, s6]; + s4 = s5; + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + while (s4 !== peg$FAILED) { + s3.push(s4); + s4 = peg$currPos; + s5 = peg$currPos; + peg$silentFails++; + s6 = peg$parseclose_square_brace(); + peg$silentFails--; + if (s6 === peg$FAILED) { + s5 = void 0; + } else { + peg$currPos = s5; + s5 = peg$FAILED; + } + if (s5 !== peg$FAILED) { + if (input.length > peg$currPos) { + s6 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s6 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s6 !== peg$FAILED) { + s5 = [s5, s6]; + s4 = s5; + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + } + s2 = input.substring(s2, peg$currPos); + s3 = peg$parseclose_square_brace(); + if (s3 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f13(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsedotdot() { + var s0, s1, s2; + s0 = peg$currPos; + s1 = peg$parsedot(); + if (s1 !== peg$FAILED) { + s2 = peg$parsedot(); + if (s2 !== peg$FAILED) { + s1 = [s1, s2]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parseunknown() { + var s0, s1; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$f14(s1); + } + s0 = s1; + return s0; + } + function peg$parsesame_line_comment() { + var s0, s1, s2; + peg$silentFails++; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + peg$savedPos = peg$currPos; + s2 = peg$f15(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f16(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e1); + } + } + return s0; + } + function peg$parseown_line_comment() { + var s0, s1, s2; + peg$silentFails++; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + peg$savedPos = peg$currPos; + s2 = peg$f17(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f18(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e2); + } + } + return s0; + } + function peg$parsecomment() { + var s0, s1, s2; + peg$silentFails++; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + peg$savedPos = peg$currPos; + s2 = peg$f19(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f20(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + return s0; + } + function peg$parse_() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + peg$savedPos = peg$currPos; + s2 = peg$f21(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f22(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parse_comment_() { + var s0, s1, s2, s3, s4; + peg$silentFails++; + s0 = peg$currPos; + s1 = []; + s2 = peg$parse_(); + while (s2 !== peg$FAILED) { + s1.push(s2); + s2 = peg$parse_(); + } + s2 = peg$parsecomment(); + if (s2 === peg$FAILED) { + s2 = null; + } + s3 = []; + s4 = peg$parse_(); + while (s4 !== peg$FAILED) { + s3.push(s4); + s4 = peg$parse_(); + } + peg$savedPos = s0; + s0 = peg$f23(s2); + peg$silentFails--; + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e4); + } + return s0; + } + function peg$parseoperation() { + var s0, s1, s2; + peg$silentFails++; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + peg$savedPos = peg$currPos; + s2 = peg$f24(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f25(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e5); + } + } + return s0; + } + function peg$parseequals() { + var s0, s1, s2; + peg$silentFails++; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + peg$savedPos = peg$currPos; + s2 = peg$f26(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f27(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e6); + } + } + return s0; + } + function peg$parseopen_square_brace() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + peg$savedPos = peg$currPos; + s2 = peg$f28(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f29(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parseclose_square_brace() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + peg$savedPos = peg$currPos; + s2 = peg$f30(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f31(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parseopen_paren() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + peg$savedPos = peg$currPos; + s2 = peg$f32(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f33(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parseclose_paren() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + peg$savedPos = peg$currPos; + s2 = peg$f34(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f35(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parseplus() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + peg$savedPos = peg$currPos; + s2 = peg$f36(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f37(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parseminus() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + peg$savedPos = peg$currPos; + s2 = peg$f38(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f39(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsepipe() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + peg$savedPos = peg$currPos; + s2 = peg$f40(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f41(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsedot() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + peg$savedPos = peg$currPos; + s2 = peg$f42(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f43(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsecontrols_keyword() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + peg$savedPos = peg$currPos; + s2 = peg$f44(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f45(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parseand_keyword() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + peg$savedPos = peg$currPos; + s2 = peg$f46(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f47(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsesvg_keyword() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + peg$savedPos = peg$currPos; + s2 = peg$f48(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f49(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsegroup() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + peg$savedPos = peg$currPos; + s2 = peg$f50(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f51(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsemacro() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + peg$savedPos = peg$currPos; + s2 = peg$f52(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f53(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parseforeach_keyword() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + peg$savedPos = peg$currPos; + s2 = peg$f54(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f55(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parseforeach_macro() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + peg$savedPos = peg$currPos; + s2 = peg$f56(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f57(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsein_keyword() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + peg$savedPos = peg$currPos; + s2 = peg$f58(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f59(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsecolon() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + peg$savedPos = peg$currPos; + s2 = peg$f60(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f61(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parseEOL() { + var s0, s1; + s0 = peg$currPos; + peg$silentFails++; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + peg$silentFails--; + if (s1 === peg$FAILED) { + s0 = void 0; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + if (!options.isWhitespace) { + try { + Object.assign(options, { + isChar: (node, char) => node.type === "string" && node.content === char, + isOperation: (node) => node.type === "string" && node.content.match(/[a-zA-Z]/), + isWhitespace: (node) => node.type === "whitespace" || node.type === "parbreak", + isSameLineComment: (node) => node.type === "comment" && node.sameline, + isOwnLineComment: (node) => node.type === "comment" && !node.sameline, + isComment: (node) => node.type === "comment", + isGroup: (node) => node.type === "group", + isMacro: (node, name) => node.type === "macro" && node.content === name, + isAnyMacro: (node) => node.type === "macro" + }); + } catch (e) { + console.warn("Error when initializing parser", e); + } + } + peg$result = peg$startRuleFunction(); + if (peg$result !== peg$FAILED && peg$currPos === input.length) { + return peg$result; + } else { + if (peg$result !== peg$FAILED && peg$currPos < input.length) { + peg$fail(peg$endExpectation()); + } + throw peg$buildStructuredError( + peg$maxFailExpected, + peg$maxFailPos < input.length ? input.charAt(peg$maxFailPos) : null, + peg$maxFailPos < input.length ? peg$computeLocation(peg$maxFailPos, peg$maxFailPos + 1) : peg$computeLocation(peg$maxFailPos, peg$maxFailPos) + ); + } + } + return { + SyntaxError: peg$SyntaxError, + parse: peg$parse + }; + }() +); +var LatexPegParser = latex_default; +var AlignEnvironmentPegParser = align_environment_default; +var ArgSpecPegParser = xparse_argspec_default; +var PgfkeysPegParser = pgfkeys_default; +var TikzPegParser = tikz_default; + +// ../unified-latex-util-argspec/dist/index.js +var parseCache = {}; +function parse(str = "") { + parseCache[str] = parseCache[str] || ArgSpecPegParser.parse(str); + return parseCache[str]; +} + +// ../unified-latex-builder/dist/index.js +var BRACES_MAP = { + "*": { openMark: "", closeMark: "" }, + "{": { openMark: "{", closeMark: "}" }, + "[": { openMark: "[", closeMark: "]" }, + "(": { openMark: "(", closeMark: ")" }, + "<": { openMark: "<", closeMark: ">" } +}; +var CLOSE_BRACES = new Set( + Object.values(BRACES_MAP).map((x) => x.closeMark).filter((x) => x) +); +function bracesToOpenAndCloseMarks(braces) { + const ret = []; + for (const char of braces.split("")) { + if (CLOSE_BRACES.has(char)) { + continue; + } + const braces2 = BRACES_MAP[char]; + if (braces2 == null) { + throw new Error(`Unknown open/close mark type "${char}"`); + } + braces2; + ret.push(braces2); + } + return ret; +} +function arg(args2, special) { + if (args2 == null) { + return { type: "argument", content: [], openMark: "", closeMark: "" }; + } + if (typeof args2 === "string") { + args2 = s(args2); + } + if (!Array.isArray(args2) && args2.type === "argument") { + return args2; + } + let openMark = (special == null ? void 0 : special.openMark) ?? "{"; + let closeMark = (special == null ? void 0 : special.closeMark) ?? "}"; + if (special == null ? void 0 : special.braces) { + const braces = bracesToOpenAndCloseMarks(special.braces); + if (braces[0]) { + openMark = braces[0].openMark; + closeMark = braces[0].closeMark; + } + } + if (!Array.isArray(args2)) { + args2 = [args2]; + } + return { type: "argument", content: args2, openMark, closeMark }; +} +function s(value) { + if (typeof value === "string") { + return { type: "string", content: value }; + } + return value; +} + +// ../unified-latex-util-scan/dist/index.js +var import_trie_prefix_tree = __toESM(require_dist(), 1); +function scan(nodes, token, options) { + const { startIndex, onlySkipWhitespaceAndComments, allowSubstringMatches } = options || {}; + if (typeof token === "string") { + token = { type: "string", content: token }; + } + for (let i = startIndex || 0; i < nodes.length; i++) { + const node = nodes[i]; + if (node.type === token.type) { + switch (node.type) { + case "comment": + case "displaymath": + case "inlinemath": + case "root": + case "parbreak": + case "whitespace": + case "verb": + case "verbatim": + case "group": + return i; + case "macro": + if (node.content === token.content) { + return i; + } + break; + case "environment": + case "mathenv": + if (printRaw(node.env) === printRaw(token.env)) { + return i; + } + break; + case "string": + if (node.content === token.content) { + return i; + } + if (allowSubstringMatches && node.content.indexOf(token.content) >= 0) { + return i; + } + break; + } + } + if (onlySkipWhitespaceAndComments && !match.whitespace(node) && !match.comment(node)) { + return null; + } + } + return null; +} + +// ../unified-latex-util-render-info/dist/index.js +function updateRenderInfo(node, renderInfo) { + if (renderInfo != null) { + node._renderInfo = { ...node._renderInfo || {}, ...renderInfo }; + } + return node; +} + +// ../unified-latex-util-arguments/dist/index.js +function gobbleSingleArgument(nodes, argSpec, startPos = 0) { + if (typeof argSpec === "string" || !argSpec.type) { + throw new Error( + `argSpec must be an already-parsed argument specification, not "${JSON.stringify( + argSpec + )}"` + ); + } + let argument2 = null; + let currPos = startPos; + const gobbleWhitespace = argSpec.noLeadingWhitespace ? () => { + } : () => { + while (currPos < nodes.length) { + if (!match.whitespace(nodes[currPos])) { + break; + } + currPos++; + } + }; + const openMark = argSpec.openBrace || ""; + const closeMark = argSpec.closeBrace || ""; + const acceptGroup = (argSpec.type === "mandatory" || argSpec.type === "optional") && openMark === "{" && closeMark === "}"; + function findBracePositions() { + let openMarkPos = null; + if (openMark) { + openMarkPos = nodes.findIndex( + (node, i) => i >= currPos && match.string(node, openMark) + ); + if (openMarkPos < currPos) { + openMarkPos = null; + } + } + let closeMarkPos = null; + if (openMarkPos != null) { + closeMarkPos = nodes.findIndex( + (node, i) => i >= openMarkPos + 1 && match.string(node, closeMark) + ); + if (closeMarkPos < openMarkPos + 1) { + closeMarkPos = null; + } + } + return [openMarkPos, closeMarkPos]; + } + gobbleWhitespace(); + const currNode = nodes[currPos]; + if (currNode == null || match.comment(currNode) || match.parbreak(currNode)) { + return { argument: argument2, nodesRemoved: 0 }; + } + switch (argSpec.type) { + case "mandatory": + if (acceptGroup) { + let content = [currNode]; + if (match.group(currNode)) { + content = currNode.content; + } + argument2 = arg(content, { + openMark, + closeMark + }); + currPos++; + break; + } + case "optional": + if (acceptGroup && match.group(currNode)) { + argument2 = arg(currNode.content, { + openMark, + closeMark + }); + currPos++; + break; + } + if (match.string(currNode, openMark)) { + const [openMarkPos, closeMarkPos] = findBracePositions(); + if (openMarkPos != null && closeMarkPos != null) { + argument2 = arg(nodes.slice(openMarkPos + 1, closeMarkPos), { + openMark, + closeMark + }); + currPos = closeMarkPos + 1; + break; + } + } + break; + case "optionalStar": + case "optionalToken": + if (match.string( + currNode, + argSpec.type === "optionalStar" ? "*" : argSpec.token + )) { + argument2 = arg([currNode], { openMark: "", closeMark: "" }); + currPos++; + break; + } + break; + case "until": { + if (argSpec.stopTokens.length > 1) { + console.warn( + `"until" matches with multi-token stop conditions are not yet implemented` + ); + break; + } + const rawToken = argSpec.stopTokens[0]; + const stopToken = rawToken === " " ? { type: "whitespace" } : { type: "string", content: argSpec.stopTokens[0] }; + let matchPos = scan(nodes, stopToken, { + startIndex: startPos, + allowSubstringMatches: true + }); + if (matchPos != null && partialStringMatch(nodes[matchPos], stopToken)) { + console.warn( + `"until" arguments that stop at non-punctuation symbols is not yet implemented` + ); + break; + } + if (matchPos == null) { + break; + } + argument2 = arg(nodes.slice(startPos, matchPos), { + openMark: "", + closeMark: rawToken + }); + currPos = matchPos; + if (currPos < nodes.length) { + currPos++; + } + break; + } + default: + console.warn( + `Don't know how to find an argument of argspec type "${argSpec.type}"` + ); + } + const nodesRemoved = argument2 ? currPos - startPos : 0; + nodes.splice(startPos, nodesRemoved); + return { argument: argument2, nodesRemoved }; +} +function partialStringMatch(node, token) { + return match.anyString(node) && match.anyString(token) && node.content.length > token.content.length; +} +function gobbleArguments(nodes, argSpec, startPos = 0) { + if (typeof argSpec === "function") { + return argSpec(nodes, startPos); + } + if (typeof argSpec === "string") { + argSpec = parse(argSpec); + } + const args = []; + let nodesRemoved = 0; + for (const spec of argSpec) { + const { argument: argument2, nodesRemoved: removed } = gobbleSingleArgument( + nodes, + spec, + startPos + ); + if (argument2) { + args.push(argument2); + nodesRemoved += removed; + } else { + args.push(arg([], { openMark: "", closeMark: "" })); + } + } + return { args, nodesRemoved }; +} +function attachMacroArgsInArray(nodes, macros17) { + let currIndex; + const isRelevantMacro = match.createMacroMatcher(macros17); + function gobbleUntilMacro() { + while (currIndex >= 0 && !isRelevantMacro(nodes[currIndex])) { + currIndex--; + } + } + currIndex = nodes.length - 1; + while (currIndex >= 0) { + gobbleUntilMacro(); + if (currIndex < 0) { + return; + } + const macroIndex = currIndex; + const macro2 = nodes[macroIndex]; + const macroName = macro2.content; + const macroInfo2 = macros17[macroName]; + updateRenderInfo(macro2, macroInfo2.renderInfo); + const signatureOrParser = macroInfo2.argumentParser || macroInfo2.signature; + if (signatureOrParser == null) { + currIndex--; + continue; + } + if (macro2.args != null) { + currIndex = macroIndex - 1; + continue; + } + currIndex++; + const { args } = gobbleArguments(nodes, signatureOrParser, currIndex); + macro2.args = args; + currIndex = macroIndex - 1; + } +} + +// ../unified-latex-ctan/package/tikz/libs/tikz-command-argument-parser.ts +var OPTIONAL_ARGUMENT_ARG_SPEC = parse("o")[0]; + +// ../unified-latex-ctan/package/tikz/libs/parser.ts +function createMatchers2() { + return { + isChar: match.string, + isTerminal: (node) => match.string(node, ";"), + isOperation: (node) => match.anyString(node) && node.content.match(/[a-zA-Z]/), + isWhitespace: (node) => match.whitespace(node) || match.parbreak(node), + isComment: match.comment, + isGroup: match.group, + isMacro: match.macro, + isAnyMacro: match.anyMacro + }; +} +var matchers = createMatchers2(); +function parse2(ast, options) { + const { startRule = "path_spec" } = options || {}; + if (!Array.isArray(ast)) { + throw new Error("You must pass an array of nodes"); + } + ast = decorateArrayForPegjs([...ast]); + return TikzPegParser.parse(ast, { + ...matchers, + startRule + }); +} + +// ../unified-latex-util-pgfkeys/dist/index.js +function createMatchers3() { + return { + isChar: (node, char) => match.string(node, char), + isComma: (node) => match.string(node, ","), + isEquals: (node) => match.string(node, "="), + isWhitespace: (node) => match.whitespace(node), + isParbreak: (node) => match.parbreak(node), + isSameLineComment: (node) => match.comment(node) && node.sameline, + isOwnLineComment: (node) => match.comment(node) && !node.sameline + }; +} +function parsePgfkeys(ast, options) { + if (!Array.isArray(ast)) { + throw new Error("You must pass an array of nodes"); + } + const { allowParenGroups = false } = options || {}; + ast = decorateArrayForPegjs([...ast]); + return PgfkeysPegParser.parse(ast, { + ...createMatchers3(), + allowParenGroups + }); +} + +// libs/printer/print-argument-pgfkeys.ts +function printArgumentPgfkeys(nodes, options) { + const { allowParenGroups = false } = options; + const parsed = parsePgfkeys(nodes, { allowParenGroups }); + const content = []; + for (const part of parsed) { + const isLastItem = part === parsed[parsed.length - 1]; + if (part.itemParts) { + const parts = part.itemParts.map( + (node) => printRaw(node, { asArray: true }).map( + (token) => token === linebreak ? hardline2 : token + ) + ); + const row = join2("=", parts); + content.push(row); + if (part.trailingComma) { + content.push(","); + } + } + if (part.trailingComment) { + const leadingContent = part.itemParts ? [" "] : []; + if (part.leadingParbreak) { + leadingContent.push(hardline2); + } + content.push( + ...leadingContent, + // We're carefully and manually controlling the newlines, + // so print the comment directly without any newlines + "%", + part.trailingComment.content, + breakParent2 + ); + } + if (!isLastItem) { + content.push(line2); + } + } + let leadingComment = [""]; + if (options.leadingComment) { + if (options.leadingComment.leadingWhitespace) { + leadingComment.push(" "); + } + leadingComment.push("%" + options.leadingComment.content, breakParent2); + } + return group3([ + options.openMark, + ...leadingComment, + // If there is no content, we don't want to push an extra `softline`. + // This matters because the braces group could still be broken by `leadingComment` + content.length > 0 ? indent2([softline2, ...content]) : "", + softline2, + options.closeMark + ]); +} + +// libs/printer/tikz.ts +function printTikzArgument(path2, print, options) { + const node = path2.getNode(); + const { renderInfo, previousNode, nextNode, referenceMap } = getNodeInfo( + node, + options + ); + const content = []; + const nodes = [...node.content]; + trim3(nodes); + try { + const tikzAst = parse2(nodes); + if (tikzAst.content.length === 0) { + content.push(";"); + return content; + } + const printer2 = new TikzArgumentPrinter(tikzAst, path2, print); + return printer2.toDoc(); + } catch (e) { + console.warn("Encountered error when trying to parse tikz argument", e); + } + content.push(";"); + return content; +} +function printFragment(fragment, path2, print) { + const tmpKey = Symbol(); + const currNode = path2.getNode(); + if (!currNode) { + throw new Error( + "tried to print a fragment, but the current node is `null`" + ); + } + currNode[tmpKey] = fragment; + const ret = print(tmpKey); + delete currNode[tmpKey]; + return ret; +} +function printTikzPathSpecNode(node, path2, print) { + switch (node.type) { + case "comment": + return printFragment(node, path2, print); + case "unknown": + return printFragment(node.content, path2, print); + case "coordinate": + return [printRaw(node.prefix), "(", printRaw(node.content), ")"]; + case "line_to": + return node.command; + case "square_brace_group": + return printOptionalArgs(node.content); + case "operation": + return node.content.content; + case "svg_operation": { + const comments = node.comments.map( + (n) => printTikzPathSpecNode(n, path2, print) + ); + const options = node.options ? printOptionalArgs(node.options) : []; + const rest = node.options ? [group3(indent2([line2, printRaw(node.content)]))] : [" ", printRaw(node.content)]; + return [...comments, "svg", options, ...rest]; + } + case "curve_to": { + const comments = node.comments.map( + (n) => printTikzPathSpecNode(n, path2, print) + ); + const printedControls = node.controls.length > 1 ? [ + printTikzPathSpecNode(node.controls[0], path2, print), + " ", + "and", + line2, + printTikzPathSpecNode(node.controls[1], path2, print) + ] : [printTikzPathSpecNode(node.controls[0], path2, print)]; + return [ + ...comments, + "..", + " ", + group3( + indent2(["controls", line2, ...printedControls, " ", ".."]) + ) + ]; + } + case "animation": { + const comments = node.comments.map( + (n) => printTikzPathSpecNode(n, path2, print) + ); + return [ + ...comments, + ":", + node.attribute, + " ", + "=", + " ", + group3( + indent2([ + printArgumentPgfkeys(node.content, { + openMark: "{", + closeMark: "}" + }) + ]) + ) + ]; + } + case "foreach": { + const comments = node.comments.map( + (n) => printTikzPathSpecNode(n, path2, print) + ); + const variables = [...node.variables]; + trim3(variables); + const list = node.list.type === "macro" ? printFragment(node.list, path2, print) : printArgumentPgfkeys(node.list.content, { + openMark: "{", + closeMark: "}", + allowParenGroups: true + }); + const doc = [ + ...comments, + printRaw(node.start), + " ", + printRaw(variables) + ]; + if (node.options) { + doc.push(" ", indent2(printOptionalArgs(node.options))); + } + doc.push(" ", "in", " ", group3(indent2(list))); + const commandType = node.command.type; + switch (commandType) { + case "foreach": + doc.push( + indent2([ + line2, + printTikzPathSpecNode(node.command, path2, print) + ]) + ); + break; + case "macro": + doc.push( + indent2([line2, printFragment(node.command, path2, print)]) + ); + break; + case "group": { + const groupContent = [...node.command.content]; + trim3(groupContent); + doc.push( + " ", + indent2( + group3([ + "{", + indent2([ + softline2, + ...groupContent.map( + (n) => printFragment(n, path2, print) + ) + ]), + softline2, + "}" + ]) + ) + ); + break; + } + default: + const invalidType = commandType; + console.warn( + `Unhandled command type when printing "foreach": ${invalidType}` + ); + } + return indent2(doc); + } + } + console.warn( + `Encountered unknown type when trying to print tikz PathSpec: "${node.type}"` + ); + return []; +} +function printOptionalArgs(nodes) { + return printArgumentPgfkeys(nodes, { + openMark: "[", + closeMark: "]" + }); +} +var _path, _print; +var TikzArgumentPrinter = class { + constructor(spec, path2, print) { + __privateAdd(this, _path, void 0); + __privateAdd(this, _print, void 0); + __privateSet(this, _path, path2); + __privateSet(this, _print, print); + this.nodes = [...spec.content]; + } + nodeToDoc(node) { + return printTikzPathSpecNode(node, __privateGet(this, _path), __privateGet(this, _print)); + } + toDoc() { + const doc = []; + const startArg = this.eatOptionalArg(); + if (startArg.optionalArg) { + doc.push( + ...startArg.comments.map( + (c) => printFragment(c, __privateGet(this, _path), __privateGet(this, _print)) + ) + ); + doc.push(printOptionalArgs(startArg.optionalArg.content)); + } + const innerDoc = []; + doc.push(group3([indent2(innerDoc), ";"])); + let cycle = -1; + while (this.nodes.length > 0) { + cycle++; + const firstSep = cycle === 0 && !startArg.optionalArg ? " " : line2; + const comingUp = this.peek(); + switch (comingUp) { + case "short_path": { + const [n0, n1, n2] = this.nodes.splice(0, 3); + innerDoc.push( + firstSep, + this.nodeToDoc(n0), + " ", + this.nodeToDoc(n1), + " ", + this.nodeToDoc(n2) + ); + continue; + } + case "long_path": { + const [n0, n1] = this.nodes.splice(0, 2); + if (n1.type === "operation") { + this.nodes.unshift(n1); + innerDoc.push( + firstSep, + this.nodeToDoc(n0), + " ", + this.eatOperation() + ); + } else { + innerDoc.push( + firstSep, + this.nodeToDoc(n0), + " ", + this.nodeToDoc(n1) + ); + } + continue; + } + case "node": + { + const eatenNode = this.eatNode(); + if (eatenNode) { + innerDoc.push(line2, ...eatenNode); + continue; + } + console.warn( + "Expected to print a tikz `node` PathSpec but couldn't find the text `node`" + ); + } + continue; + case "operation": + innerDoc.push(firstSep, this.eatOperation()); + continue; + case "unknown": { + const node = this.nodes.shift(); + innerDoc.push(firstSep, this.nodeToDoc(node)); + continue; + } + } + this.nodes.shift(); + } + return doc; + } + /** + * Look at the current node and the nodes that follow. Return what + * "type" is recognized. + */ + peek() { + const [n0, n1, n2, n3] = [ + this.nodes[0], + this.nodes[1], + this.nodes[2], + this.nodes[3] + ]; + if ((n0 == null ? void 0 : n0.type) === "coordinate" && isPathJoinOperation(n1)) { + if ((n2 == null ? void 0 : n2.type) === "coordinate" && !((n3 == null ? void 0 : n3.type) === "coordinate" || isPathJoinOperation(n3))) { + return "short_path"; + } + return "long_path"; + } + if ((n0 == null ? void 0 : n0.type) === "operation") { + if (n0.content.content === "node") { + return "node"; + } + return "operation"; + } + return "unknown"; + } + /** + * Eat comments and an optional arg if present. If no optional + * arg is present, do nothing. + */ + eatOptionalArg() { + let i = 0; + const comments = []; + let optionalArg = null; + for (; i < this.nodes.length; i++) { + const node = this.nodes[i]; + if (node.type === "square_brace_group") { + optionalArg = node; + i++; + break; + } + if (node.type === "comment") { + comments.push(node); + continue; + } + break; + } + if (optionalArg) { + this.nodes.splice(0, i); + } + return { optionalArg, comments }; + } + /** + * Eat a `type === "operation"` node whose contents is `"node"`. I.e., + * the type of thing that shows up in `\path node at (1,1) {foo};` + */ + eatNode() { + const firstNode = this.nodes[0]; + if ((firstNode == null ? void 0 : firstNode.type) === "operation" && firstNode.content.content === "node") { + this.nodes.shift(); + } else { + return null; + } + const innerDoc = []; + const commentBlock = []; + const doc = [commentBlock, "node", group3(indent2(innerDoc))]; + let hasNodeArgument = false; + let shouldBail = false; + let i = 0; + const comments = []; + const options = []; + const name = []; + const atLocations = []; + const animations = []; + let content = []; + for (; i < this.nodes.length && !shouldBail; i++) { + const node = this.nodes[i]; + switch (node.type) { + case "animation": + animations.push(this.nodeToDoc(node)); + continue; + case "comment": { + const comment2 = { + ...node, + leadingWhitespace: false + }; + comments.push(this.nodeToDoc(comment2)); + continue; + } + case "square_brace_group": + options.push(printOptionalArgs(node.content)); + continue; + case "coordinate": + name.push(this.nodeToDoc(node)); + continue; + case "operation": { + if (node.content.content === "at") { + const nextNode = this.nodes[i + 1]; + if (!nextNode || !(nextNode.type === "coordinate" || nextNode.type === "unknown" && match.anyMacro(nextNode.content))) { + shouldBail = true; + continue; + } + atLocations.push(["at", " ", this.nodeToDoc(nextNode)]); + i++; + continue; + } + shouldBail = true; + continue; + } + case "unknown": { + if (match.group(node.content)) { + hasNodeArgument = true; + content = this.nodeToDoc(node); + } + } + } + break; + } + if (!hasNodeArgument) { + return innerDoc; + } + this.nodes.splice(0, i + 1); + let isFirstElement = true; + let isNamed = !(Array.isArray(name) && name.length === 0); + for (const comment2 of comments) { + commentBlock.push(comment2, hardline2); + } + if (options.length > 0) { + innerDoc.push(join2(" ", options)); + isFirstElement = false; + } + if (animations.length > 0) { + innerDoc.push(isFirstElement ? " " : line2); + innerDoc.push(join2(line2, animations)); + isFirstElement = false; + } + if (isNamed) { + innerDoc.push(isFirstElement ? " " : line2); + innerDoc.push(name); + isFirstElement = false; + } + if (atLocations.length > 0) { + innerDoc.push(isFirstElement || isNamed ? " " : line2); + innerDoc.push(join2(line2, atLocations)); + isFirstElement = false; + } + innerDoc.push(line2, content); + return doc; + } + /** + * Eat a `type === "operation"` node, including its optional arguments. + */ + eatOperation() { + const node = this.nodes[0]; + if ((node == null ? void 0 : node.type) === "operation") { + this.nodes.shift(); + } else { + return []; + } + const doc = []; + if ((node == null ? void 0 : node.type) !== "operation") { + throw new Error("Expecting `operation` node."); + } + const options = this.eatOptionalArg(); + doc.push( + ...options.comments.map( + (c) => printFragment(c, __privateGet(this, _path), __privateGet(this, _print)) + ), + node.content.content + ); + if (options.optionalArg) { + doc.push(indent2(printOptionalArgs(options.optionalArg.content))); + } + return doc; + } +}; +_path = new WeakMap(); +_print = new WeakMap(); +var PATH_JOIN_OPERATIONS = /* @__PURE__ */ new Set(["rectangle", "grid", "sin", "cos", "to"]); +function isPathJoinOperation(node) { + if (!node) { + return false; + } + switch (node.type) { + case "line_to": + case "curve_to": + return true; + case "operation": + return PATH_JOIN_OPERATIONS.has(node.content.content); + } + return false; +} + +// libs/printer/argument.ts +function printArgument(path2, print, options) { + const node = path2.getNode(); + const { renderInfo, previousNode, nextNode, referenceMap } = getNodeInfo( + node, + options + ); + if (node.openMark === "" && node.closeMark === "" && node.content.length === 0) { + return []; + } + const parentNode = path2.getParentNode(); + const { renderInfo: parentRenderInfo } = getNodeInfo(parentNode, options); + if (parentRenderInfo.pgfkeysArgs) { + const leadingComment = node.content.length > 0 && match.comment(node.content[0]) && node.content[0].sameline ? node.content[0] : null; + const content2 = leadingComment ? node.content.slice(1) : node.content; + trim3(content2); + return printArgumentPgfkeys(content2, { + openMark: node.openMark, + closeMark: node.closeMark, + leadingComment + }); + } + if (parentRenderInfo.tikzPathCommand) { + return printTikzArgument(path2, print, options); + } + const openMark = node.openMark; + const closeMark = node.closeMark; + let content = path2.map(print, "content"); + content = formatDocArray(node.content, content, options); + if (match.comment(node.content[node.content.length - 1])) { + content.push(hardline2); + } + let rawRet = [openMark, fill2(content), closeMark]; + if (renderInfo.inParMode) { + rawRet = [openMark, ...content, closeMark]; + } + if (referenceMap) { + referenceMap.setRenderCache(node, rawRet); + } + return rawRet; +} + +// libs/printer/root.ts +function hasPreambleCode(nodes) { + return nodes.some((node) => match.macro(node, "documentclass")); +} +function printRoot(path2, print, options) { + const node = path2.getNode(); + const { renderInfo, previousNode, nextNode, referenceMap } = getNodeInfo( + node, + options + ); + const content = path2.map(print, "content"); + const rawContent = formatDocArray(node.content, content, options); + const concatFunction = hasPreambleCode(node.content) ? (x) => x : fill2; + return concatFunction(rawContent); +} + +// libs/printer/comment.ts +function printComment(path2, _print2, _options) { + const node = path2.getNode(); + let leadingWhitespace = ""; + if (node.leadingWhitespace && node.sameline) { + leadingWhitespace = " "; + } + const content = [leadingWhitespace, "%" + printRaw(node.content)]; + return content; +} + +// libs/printer/math.ts +function printInlineMath(path2, print, options) { + const node = path2.getNode(); + if (node.content.length === 0) { + return ["$", " ", "$"]; + } + let content = path2.map(print, "content"); + content = formatDocArray(node.content, content, options); + content = joinWithSoftline(content); + if (node.content[node.content.length - 1].type === "comment") { + content.push(hardline2); + } + return fill2(["$", ...content, "$"]); +} +function printDisplayMath(path2, print, options) { + const node = path2.getNode(); + let content = path2.map(print, "content"); + content = formatDocArray(node.content, content, options); + content = joinWithSoftline(content); + const bodyStartToken = [hardline2]; + if (node.content.length === 0 || node.content[0].type === "comment" && node.content[0].sameline) { + bodyStartToken.pop(); + } + return [ + ESCAPE2 + "[", + indent2(fill2(bodyStartToken.concat(content))), + hardline2, + ESCAPE2 + "]" + ]; +} + +// ../unified-latex-util-align/dist/index.js +function createMatchers4(rowSepMacros, colSep) { + const isRowSep = match.createMacroMatcher(rowSepMacros); + return { + isRowSep, + isColSep: (node) => colSep.some((sep) => match.string(node, sep)), + isWhitespace: (node) => match.whitespace(node), + isSameLineComment: (node) => match.comment(node) && node.sameline, + isOwnLineComment: (node) => match.comment(node) && !node.sameline + }; +} +function parseAlignEnvironment(ast, colSep = ["&"], rowSepMacros = ["\\", "hline", "cr"]) { + if (!Array.isArray(ast)) { + throw new Error("You must pass an array of nodes"); + } + ast = decorateArrayForPegjs([...ast]); + return AlignEnvironmentPegParser.parse( + ast, + createMatchers4(rowSepMacros, colSep) + ); +} + +// libs/printer/environment.ts +function printVerbatimEnvironment(path2, print, options) { + const node = path2.getNode(); + const env = formatEnvSurround(node); + return [env.start, node.content, env.end]; +} +function printEnvironment(path2, print, options) { + const node = path2.getNode(); + const { renderInfo, previousNode, nextNode, referenceMap } = getNodeInfo( + node, + options + ); + const args = node.args ? path2.map(print, "args") : []; + const env = formatEnvSurround(node); + let content = path2.map(print, "content"); + content = formatDocArray(node.content, content, options); + if (renderInfo.inMathMode) { + content = joinWithSoftline(content); + } + let bodyStartToken = [hardline2]; + if (node.content.length === 0 || node.content[0].type === "comment" && node.content[0].sameline) { + bodyStartToken.pop(); + } + return [ + env.start, + ...args, + indent2(fill2(bodyStartToken.concat(content))), + hardline2, + env.end + ]; +} +function printAlignedEnvironment(path2, print, options) { + const node = path2.getNode(); + const { renderInfo, previousNode, nextNode, referenceMap } = getNodeInfo( + node, + options + ); + const args = node.args ? path2.map(print, "args") : []; + const env = formatEnvSurround(node); + const leadingComment = node.content[0] && node.content[0].type === "comment" && node.content[0].sameline ? node.content[0] : null; + const { rows, rowSeps, trailingComments } = formatAlignedContent( + leadingComment ? node.content.slice(1) : node.content + ); + const content = []; + for (let i = 0; i < rows.length; i++) { + const row = rows[i]; + const rowSep = rowSeps[i]; + const trailingComment = trailingComments[i]; + content.push(row); + if (rowSep) { + content.push(printRaw(rowSep)); + } + if (rowSep && trailingComment) { + content.push(" "); + } + if (trailingComment) { + content.push(["%", printRaw(trailingComment.content)]); + } + if (rowSep || trailingComment) { + content.push(hardline2); + } + } + if (content[content.length - 1] === hardline2) { + content.pop(); + } + if (leadingComment) { + content.unshift( + leadingComment.leadingWhitespace ? " " : "", + "%" + printRaw(leadingComment.content), + hardline2 + ); + return [env.start, ...args, indent2(content), hardline2, env.end]; + } + return [ + env.start, + ...args, + indent2([hardline2, ...content]), + hardline2, + env.end + ]; +} +function formatAlignedContent(nodes) { + function getSpace(len = 1) { + return " ".repeat(len); + } + const rows = parseAlignEnvironment(nodes); + const numCols = Math.max(...rows.map((r) => r.cells.length)); + const rowSeps = rows.map(({ rowSep }) => printRaw(rowSep || [])); + const trailingComments = rows.map(({ trailingComment }) => trailingComment); + const renderedRows = rows.map(({ cells, colSeps }) => ({ + cells: cells.map((nodes2) => { + trim3(nodes2); + return printRaw(nodes2); + }), + seps: colSeps.map((nodes2) => printRaw(nodes2)) + })); + const colWidths = []; + for (let i = 0; i < numCols; i++) { + colWidths.push( + Math.max( + ...renderedRows.map( + ({ cells, seps }) => ((cells[i] || "") + (seps[i] || "")).length + ) + ) + ); + } + const joinedRows = renderedRows.map(({ cells, seps }) => { + if (cells.length === 1 && cells[0] === "") { + return ""; + } + let ret = ""; + for (let i = 0; i < cells.length; i++) { + const width = colWidths[i] - (seps[i] || "").length; + ret += (i === 0 ? "" : " ") + cells[i] + getSpace(width - cells[i].length + 1) + (seps[i] || ""); + } + return ret; + }); + return { rows: joinedRows, rowSeps, trailingComments }; +} + +// libs/reference-map.ts +var ReferenceMap = class { + constructor(ast) { + this.ast = ast; + this.map = /* @__PURE__ */ new Map(); + visit( + this.ast, + (nodeList) => { + for (let i = 0; i < nodeList.length; i++) { + this.map.set(nodeList[i], { + previous: nodeList[i - 1], + next: nodeList[i + 1] + }); + } + }, + { includeArrays: true, test: Array.isArray } + ); + } + /** + * Associate render-specific data with this node. This data + * will be overwritten if `setRenderCache` is called twice. + * + * @param {Ast.Ast} node + * @param {*} data + * @memberof ReferenceMap + */ + setRenderCache(node, data) { + const currData = this.map.get(node) || {}; + this.map.set(node, { ...currData, renderCache: data }); + } + /** + * Retrieve data associated with `node` via `setRenderCache` + * + * @param {Ast.Ast} node + * @returns {(object | undefined)} + * @memberof ReferenceMap + */ + getRenderCache(node) { + var _a; + return (_a = this.map.get(node)) == null ? void 0 : _a.renderCache; + } + getPreviousNode(node) { + return (this.map.get(node) || {}).previous; + } + getNextNode(node) { + return (this.map.get(node) || {}).next; + } +}; + +// libs/printer/printer.ts +function printLatexAst(path2, options, print) { + const node = path2.getValue(); + const { renderInfo } = getNodeInfo(node, options); + if (node == null) { + return node; + } + if (typeof node === "string") { + return node; + } + switch (node.type) { + case "root": + if (options.referenceMap) { + console.warn( + "Processing root node, but ReferenceMap already exists. Are there multiple nodes of type 'root'?" + ); + } + options.referenceMap = new ReferenceMap(node); + return printRoot(path2, print, options); + case "argument": + return printArgument(path2, print, options); + case "comment": + return printComment(path2, print, options); + case "environment": + case "mathenv": + if (renderInfo.alignContent) { + return printAlignedEnvironment(path2, print, options); + } + return printEnvironment(path2, print, options); + case "displaymath": + return printDisplayMath(path2, print, options); + case "group": + const content = printRaw(node.content, { + asArray: true + }).map((token) => token === linebreak ? hardline2 : token); + return ["{", ...content, "}"]; + case "inlinemath": + return printInlineMath(path2, print, options); + case "macro": + return printMacro(path2, print, options); + case "parbreak": + return [hardline2, hardline2]; + case "string": + return node.content; + case "verb": + return [ + ESCAPE2, + node.env, + node.escape, + printRaw(node.content), + node.escape + ]; + case "verbatim": + return printVerbatimEnvironment(path2, print, options); + case "whitespace": + return line2; + default: + console.warn("Printing unknown type", node); + return printRaw(node); + } +} + +// ../../node_modules/bail/index.js +function bail(error) { + if (error) { + throw error; + } +} + +// ../../node_modules/unified/lib/index.js +var import_is_buffer2 = __toESM(require_is_buffer(), 1); +var import_extend = __toESM(require_extend(), 1); + +// ../../node_modules/unified/node_modules/is-plain-obj/index.js +function isPlainObject(value) { + if (typeof value !== "object" || value === null) { + return false; + } + const prototype = Object.getPrototypeOf(value); + return (prototype === null || prototype === Object.prototype || Object.getPrototypeOf(prototype) === null) && !(Symbol.toStringTag in value) && !(Symbol.iterator in value); +} + +// ../../node_modules/trough/index.js +function trough() { + const fns = []; + const pipeline = { run, use }; + return pipeline; + function run(...values) { + let middlewareIndex = -1; + const callback = values.pop(); + if (typeof callback !== "function") { + throw new TypeError("Expected function as last argument, not " + callback); + } + next(null, ...values); + function next(error, ...output) { + const fn = fns[++middlewareIndex]; + let index2 = -1; + if (error) { + callback(error); + return; + } + while (++index2 < values.length) { + if (output[index2] === null || output[index2] === void 0) { + output[index2] = values[index2]; + } + } + values = output; + if (fn) { + wrap(fn, next)(...output); + } else { + callback(null, ...output); + } + } + } + function use(middelware) { + if (typeof middelware !== "function") { + throw new TypeError( + "Expected `middelware` to be a function, not " + middelware + ); + } + fns.push(middelware); + return pipeline; + } +} +function wrap(middleware, callback) { + let called; + return wrapped; + function wrapped(...parameters) { + const fnExpectsCallback = middleware.length > parameters.length; + let result; + if (fnExpectsCallback) { + parameters.push(done); + } + try { + result = middleware.apply(this, parameters); + } catch (error) { + const exception = ( + /** @type {Error} */ + error + ); + if (fnExpectsCallback && called) { + throw exception; + } + return done(exception); + } + if (!fnExpectsCallback) { + if (result instanceof Promise) { + result.then(then, done); + } else if (result instanceof Error) { + done(result); + } else { + then(result); + } + } + } + function done(error, ...output) { + if (!called) { + called = true; + callback(error, ...output); + } + } + function then(value) { + done(null, value); + } +} + +// ../../node_modules/vfile/lib/index.js +var import_is_buffer = __toESM(require_is_buffer(), 1); + +// ../../node_modules/unist-util-stringify-position/lib/index.js +function stringifyPosition(value) { + if (!value || typeof value !== "object") { + return ""; + } + if ("position" in value || "type" in value) { + return position(value.position); + } + if ("start" in value || "end" in value) { + return position(value); + } + if ("line" in value || "column" in value) { + return point(value); + } + return ""; +} +function point(point2) { + return index(point2 && point2.line) + ":" + index(point2 && point2.column); +} +function position(pos) { + return point(pos && pos.start) + "-" + point(pos && pos.end); +} +function index(value) { + return value && typeof value === "number" ? value : 1; +} + +// ../../node_modules/vfile-message/index.js +var VFileMessage = class extends Error { + /** + * Create a message for `reason` at `place` from `origin`. + * + * When an error is passed in as `reason`, the `stack` is copied. + * + * @param {string|Error|VFileMessage} reason + * Reason for message. + * Uses the stack and message of the error if given. + * @param {Node|NodeLike|Position|Point} [place] + * Place at which the message occurred in a file. + * @param {string} [origin] + * Place in code the message originates from (example `'my-package:my-rule-name'`) + */ + constructor(reason, place, origin) { + const parts = [null, null]; + let position2 = { + // @ts-expect-error: we always follows the structure of `position`. + start: { line: null, column: null }, + // @ts-expect-error: " + end: { line: null, column: null } + }; + super(); + if (typeof place === "string") { + origin = place; + place = void 0; + } + if (typeof origin === "string") { + const index2 = origin.indexOf(":"); + if (index2 === -1) { + parts[1] = origin; + } else { + parts[0] = origin.slice(0, index2); + parts[1] = origin.slice(index2 + 1); + } + } + if (place) { + if ("type" in place || "position" in place) { + if (place.position) { + position2 = place.position; + } + } else if ("start" in place || "end" in place) { + position2 = place; + } else if ("line" in place || "column" in place) { + position2.start = place; + } + } + this.name = stringifyPosition(place) || "1:1"; + this.message = typeof reason === "object" ? reason.message : reason; + this.stack = ""; + if (typeof reason === "object" && reason.stack) { + this.stack = reason.stack; + } + this.reason = this.message; + this.fatal; + this.line = position2.start.line; + this.column = position2.start.column; + this.position = position2; + this.source = parts[0]; + this.ruleId = parts[1]; + this.file; + this.actual; + this.expected; + this.url; + this.note; + } +}; +VFileMessage.prototype.file = ""; +VFileMessage.prototype.name = ""; +VFileMessage.prototype.reason = ""; +VFileMessage.prototype.message = ""; +VFileMessage.prototype.stack = ""; +VFileMessage.prototype.fatal = null; +VFileMessage.prototype.column = null; +VFileMessage.prototype.line = null; +VFileMessage.prototype.source = null; +VFileMessage.prototype.ruleId = null; +VFileMessage.prototype.position = null; + +// ../../node_modules/vfile/lib/minpath.browser.js +var path = { basename, dirname, extname, join: join3, sep: "/" }; +function basename(path2, ext) { + if (ext !== void 0 && typeof ext !== "string") { + throw new TypeError('"ext" argument must be a string'); + } + assertPath(path2); + let start = 0; + let end = -1; + let index2 = path2.length; + let seenNonSlash; + if (ext === void 0 || ext.length === 0 || ext.length > path2.length) { + while (index2--) { + if (path2.charCodeAt(index2) === 47) { + if (seenNonSlash) { + start = index2 + 1; + break; + } + } else if (end < 0) { + seenNonSlash = true; + end = index2 + 1; + } + } + return end < 0 ? "" : path2.slice(start, end); + } + if (ext === path2) { + return ""; + } + let firstNonSlashEnd = -1; + let extIndex = ext.length - 1; + while (index2--) { + if (path2.charCodeAt(index2) === 47) { + if (seenNonSlash) { + start = index2 + 1; + break; + } + } else { + if (firstNonSlashEnd < 0) { + seenNonSlash = true; + firstNonSlashEnd = index2 + 1; + } + if (extIndex > -1) { + if (path2.charCodeAt(index2) === ext.charCodeAt(extIndex--)) { + if (extIndex < 0) { + end = index2; + } + } else { + extIndex = -1; + end = firstNonSlashEnd; + } + } + } + } + if (start === end) { + end = firstNonSlashEnd; + } else if (end < 0) { + end = path2.length; + } + return path2.slice(start, end); +} +function dirname(path2) { + assertPath(path2); + if (path2.length === 0) { + return "."; + } + let end = -1; + let index2 = path2.length; + let unmatchedSlash; + while (--index2) { + if (path2.charCodeAt(index2) === 47) { + if (unmatchedSlash) { + end = index2; + break; + } + } else if (!unmatchedSlash) { + unmatchedSlash = true; + } + } + return end < 0 ? path2.charCodeAt(0) === 47 ? "/" : "." : end === 1 && path2.charCodeAt(0) === 47 ? "//" : path2.slice(0, end); +} +function extname(path2) { + assertPath(path2); + let index2 = path2.length; + let end = -1; + let startPart = 0; + let startDot = -1; + let preDotState = 0; + let unmatchedSlash; + while (index2--) { + const code = path2.charCodeAt(index2); + if (code === 47) { + if (unmatchedSlash) { + startPart = index2 + 1; + break; + } + continue; + } + if (end < 0) { + unmatchedSlash = true; + end = index2 + 1; + } + if (code === 46) { + if (startDot < 0) { + startDot = index2; + } else if (preDotState !== 1) { + preDotState = 1; + } + } else if (startDot > -1) { + preDotState = -1; + } + } + if (startDot < 0 || end < 0 || // We saw a non-dot character immediately before the dot. + preDotState === 0 || // The (right-most) trimmed path component is exactly `..`. + preDotState === 1 && startDot === end - 1 && startDot === startPart + 1) { + return ""; + } + return path2.slice(startDot, end); +} +function join3(...segments) { + let index2 = -1; + let joined; + while (++index2 < segments.length) { + assertPath(segments[index2]); + if (segments[index2]) { + joined = joined === void 0 ? segments[index2] : joined + "/" + segments[index2]; + } + } + return joined === void 0 ? "." : normalize(joined); +} +function normalize(path2) { + assertPath(path2); + const absolute = path2.charCodeAt(0) === 47; + let value = normalizeString(path2, !absolute); + if (value.length === 0 && !absolute) { + value = "."; + } + if (value.length > 0 && path2.charCodeAt(path2.length - 1) === 47) { + value += "/"; + } + return absolute ? "/" + value : value; +} +function normalizeString(path2, allowAboveRoot) { + let result = ""; + let lastSegmentLength = 0; + let lastSlash = -1; + let dots = 0; + let index2 = -1; + let code; + let lastSlashIndex; + while (++index2 <= path2.length) { + if (index2 < path2.length) { + code = path2.charCodeAt(index2); + } else if (code === 47) { + break; + } else { + code = 47; + } + if (code === 47) { + if (lastSlash === index2 - 1 || dots === 1) { + } else if (lastSlash !== index2 - 1 && dots === 2) { + if (result.length < 2 || lastSegmentLength !== 2 || result.charCodeAt(result.length - 1) !== 46 || result.charCodeAt(result.length - 2) !== 46) { + if (result.length > 2) { + lastSlashIndex = result.lastIndexOf("/"); + if (lastSlashIndex !== result.length - 1) { + if (lastSlashIndex < 0) { + result = ""; + lastSegmentLength = 0; + } else { + result = result.slice(0, lastSlashIndex); + lastSegmentLength = result.length - 1 - result.lastIndexOf("/"); + } + lastSlash = index2; + dots = 0; + continue; + } + } else if (result.length > 0) { + result = ""; + lastSegmentLength = 0; + lastSlash = index2; + dots = 0; + continue; + } + } + if (allowAboveRoot) { + result = result.length > 0 ? result + "/.." : ".."; + lastSegmentLength = 2; + } + } else { + if (result.length > 0) { + result += "/" + path2.slice(lastSlash + 1, index2); + } else { + result = path2.slice(lastSlash + 1, index2); + } + lastSegmentLength = index2 - lastSlash - 1; + } + lastSlash = index2; + dots = 0; + } else if (code === 46 && dots > -1) { + dots++; + } else { + dots = -1; + } + } + return result; +} +function assertPath(path2) { + if (typeof path2 !== "string") { + throw new TypeError( + "Path must be a string. Received " + JSON.stringify(path2) + ); + } +} + +// ../../node_modules/vfile/lib/minproc.browser.js +var proc = { cwd }; +function cwd() { + return "/"; +} + +// ../../node_modules/vfile/lib/minurl.shared.js +function isUrl(fileURLOrPath) { + return fileURLOrPath !== null && typeof fileURLOrPath === "object" && // @ts-expect-error: indexable. + fileURLOrPath.href && // @ts-expect-error: indexable. + fileURLOrPath.origin; +} + +// ../../node_modules/vfile/lib/minurl.browser.js +function urlToPath(path2) { + if (typeof path2 === "string") { + path2 = new URL(path2); + } else if (!isUrl(path2)) { + const error = new TypeError( + 'The "path" argument must be of type string or an instance of URL. Received `' + path2 + "`" + ); + error.code = "ERR_INVALID_ARG_TYPE"; + throw error; + } + if (path2.protocol !== "file:") { + const error = new TypeError("The URL must be of scheme file"); + error.code = "ERR_INVALID_URL_SCHEME"; + throw error; + } + return getPathFromURLPosix(path2); +} +function getPathFromURLPosix(url) { + if (url.hostname !== "") { + const error = new TypeError( + 'File URL host must be "localhost" or empty on darwin' + ); + error.code = "ERR_INVALID_FILE_URL_HOST"; + throw error; + } + const pathname = url.pathname; + let index2 = -1; + while (++index2 < pathname.length) { + if (pathname.charCodeAt(index2) === 37 && pathname.charCodeAt(index2 + 1) === 50) { + const third = pathname.charCodeAt(index2 + 2); + if (third === 70 || third === 102) { + const error = new TypeError( + "File URL path must not include encoded / characters" + ); + error.code = "ERR_INVALID_FILE_URL_PATH"; + throw error; + } + } + } + return decodeURIComponent(pathname); +} + +// ../../node_modules/vfile/lib/index.js +var order = ["history", "path", "basename", "stem", "extname", "dirname"]; +var VFile = class { + /** + * Create a new virtual file. + * + * If `options` is `string` or `Buffer`, it’s treated as `{value: options}`. + * If `options` is a `URL`, it’s treated as `{path: options}`. + * If `options` is a `VFile`, shallow copies its data over to the new file. + * All fields in `options` are set on the newly created `VFile`. + * + * Path related fields are set in the following order (least specific to + * most specific): `history`, `path`, `basename`, `stem`, `extname`, + * `dirname`. + * + * It’s not possible to set either `dirname` or `extname` without setting + * either `history`, `path`, `basename`, or `stem` as well. + * + * @param {Compatible} [value] + */ + constructor(value) { + let options; + if (!value) { + options = {}; + } else if (typeof value === "string" || (0, import_is_buffer.default)(value)) { + options = { value }; + } else if (isUrl(value)) { + options = { path: value }; + } else { + options = value; + } + this.data = {}; + this.messages = []; + this.history = []; + this.cwd = proc.cwd(); + this.value; + this.stored; + this.result; + this.map; + let index2 = -1; + while (++index2 < order.length) { + const prop2 = order[index2]; + if (prop2 in options && options[prop2] !== void 0) { + this[prop2] = prop2 === "history" ? [...options[prop2]] : options[prop2]; + } + } + let prop; + for (prop in options) { + if (!order.includes(prop)) + this[prop] = options[prop]; + } + } + /** + * Get the full path (example: `'~/index.min.js'`). + * @returns {string} + */ + get path() { + return this.history[this.history.length - 1]; + } + /** + * Set the full path (example: `'~/index.min.js'`). + * Cannot be nullified. + * You can set a file URL (a `URL` object with a `file:` protocol) which will + * be turned into a path with `url.fileURLToPath`. + * @param {string|URL} path + */ + set path(path2) { + if (isUrl(path2)) { + path2 = urlToPath(path2); + } + assertNonEmpty(path2, "path"); + if (this.path !== path2) { + this.history.push(path2); + } + } + /** + * Get the parent path (example: `'~'`). + */ + get dirname() { + return typeof this.path === "string" ? path.dirname(this.path) : void 0; + } + /** + * Set the parent path (example: `'~'`). + * Cannot be set if there’s no `path` yet. + */ + set dirname(dirname2) { + assertPath2(this.basename, "dirname"); + this.path = path.join(dirname2 || "", this.basename); + } + /** + * Get the basename (including extname) (example: `'index.min.js'`). + */ + get basename() { + return typeof this.path === "string" ? path.basename(this.path) : void 0; + } + /** + * Set basename (including extname) (`'index.min.js'`). + * Cannot contain path separators (`'/'` on unix, macOS, and browsers, `'\'` + * on windows). + * Cannot be nullified (use `file.path = file.dirname` instead). + */ + set basename(basename2) { + assertNonEmpty(basename2, "basename"); + assertPart(basename2, "basename"); + this.path = path.join(this.dirname || "", basename2); + } + /** + * Get the extname (including dot) (example: `'.js'`). + */ + get extname() { + return typeof this.path === "string" ? path.extname(this.path) : void 0; + } + /** + * Set the extname (including dot) (example: `'.js'`). + * Cannot contain path separators (`'/'` on unix, macOS, and browsers, `'\'` + * on windows). + * Cannot be set if there’s no `path` yet. + */ + set extname(extname2) { + assertPart(extname2, "extname"); + assertPath2(this.dirname, "extname"); + if (extname2) { + if (extname2.charCodeAt(0) !== 46) { + throw new Error("`extname` must start with `.`"); + } + if (extname2.includes(".", 1)) { + throw new Error("`extname` cannot contain multiple dots"); + } + } + this.path = path.join(this.dirname, this.stem + (extname2 || "")); + } + /** + * Get the stem (basename w/o extname) (example: `'index.min'`). + */ + get stem() { + return typeof this.path === "string" ? path.basename(this.path, this.extname) : void 0; + } + /** + * Set the stem (basename w/o extname) (example: `'index.min'`). + * Cannot contain path separators (`'/'` on unix, macOS, and browsers, `'\'` + * on windows). + * Cannot be nullified (use `file.path = file.dirname` instead). + */ + set stem(stem) { + assertNonEmpty(stem, "stem"); + assertPart(stem, "stem"); + this.path = path.join(this.dirname || "", stem + (this.extname || "")); + } + /** + * Serialize the file. + * + * @param {BufferEncoding} [encoding='utf8'] + * When `value` is a `Buffer`, `encoding` is a character encoding to + * understand it as (default: `'utf8'`). + * @returns {string} + * Serialized file. + */ + toString(encoding) { + return (this.value || "").toString(encoding); + } + /** + * Constructs a new `VFileMessage`, where `fatal` is set to `false`, and + * associates it with the file by adding it to `vfile.messages` and setting + * `message.file` to the current filepath. + * + * @param {string|Error|VFileMessage} reason + * Human readable reason for the message, uses the stack and message of the error if given. + * @param {Node|NodeLike|Position|Point} [place] + * Place where the message occurred in the file. + * @param {string} [origin] + * Computer readable reason for the message + * @returns {VFileMessage} + * Message. + */ + message(reason, place, origin) { + const message = new VFileMessage(reason, place, origin); + if (this.path) { + message.name = this.path + ":" + message.name; + message.file = this.path; + } + message.fatal = false; + this.messages.push(message); + return message; + } + /** + * Like `VFile#message()`, but associates an informational message where + * `fatal` is set to `null`. + * + * @param {string|Error|VFileMessage} reason + * Human readable reason for the message, uses the stack and message of the error if given. + * @param {Node|NodeLike|Position|Point} [place] + * Place where the message occurred in the file. + * @param {string} [origin] + * Computer readable reason for the message + * @returns {VFileMessage} + * Message. + */ + info(reason, place, origin) { + const message = this.message(reason, place, origin); + message.fatal = null; + return message; + } + /** + * Like `VFile#message()`, but associates a fatal message where `fatal` is + * set to `true`, and then immediately throws it. + * + * > 👉 **Note**: a fatal error means that a file is no longer processable. + * + * @param {string|Error|VFileMessage} reason + * Human readable reason for the message, uses the stack and message of the error if given. + * @param {Node|NodeLike|Position|Point} [place] + * Place where the message occurred in the file. + * @param {string} [origin] + * Computer readable reason for the message + * @returns {never} + * Message. + */ + fail(reason, place, origin) { + const message = this.message(reason, place, origin); + message.fatal = true; + throw message; + } +}; +function assertPart(part, name) { + if (part && part.includes(path.sep)) { + throw new Error( + "`" + name + "` cannot be a path: did not expect `" + path.sep + "`" + ); + } +} +function assertNonEmpty(part, name) { + if (!part) { + throw new Error("`" + name + "` cannot be empty"); + } +} +function assertPath2(path2, name) { + if (!path2) { + throw new Error("Setting `" + name + "` requires `path` to be set too"); + } +} + +// ../../node_modules/unified/lib/index.js +var unified = base().freeze(); +var own = {}.hasOwnProperty; +function base() { + const transformers = trough(); + const attachers = []; + let namespace = {}; + let frozen; + let freezeIndex = -1; + processor.data = data; + processor.Parser = void 0; + processor.Compiler = void 0; + processor.freeze = freeze; + processor.attachers = attachers; + processor.use = use; + processor.parse = parse4; + processor.stringify = stringify; + processor.run = run; + processor.runSync = runSync; + processor.process = process; + processor.processSync = processSync; + return processor; + function processor() { + const destination = base(); + let index2 = -1; + while (++index2 < attachers.length) { + destination.use(...attachers[index2]); + } + destination.data((0, import_extend.default)(true, {}, namespace)); + return destination; + } + function data(key, value) { + if (typeof key === "string") { + if (arguments.length === 2) { + assertUnfrozen("data", frozen); + namespace[key] = value; + return processor; + } + return own.call(namespace, key) && namespace[key] || null; + } + if (key) { + assertUnfrozen("data", frozen); + namespace = key; + return processor; + } + return namespace; + } + function freeze() { + if (frozen) { + return processor; + } + while (++freezeIndex < attachers.length) { + const [attacher, ...options] = attachers[freezeIndex]; + if (options[0] === false) { + continue; + } + if (options[0] === true) { + options[0] = void 0; + } + const transformer = attacher.call(processor, ...options); + if (typeof transformer === "function") { + transformers.use(transformer); + } + } + frozen = true; + freezeIndex = Number.POSITIVE_INFINITY; + return processor; + } + function use(value, ...options) { + let settings; + assertUnfrozen("use", frozen); + if (value === null || value === void 0) { + } else if (typeof value === "function") { + addPlugin(value, ...options); + } else if (typeof value === "object") { + if (Array.isArray(value)) { + addList(value); + } else { + addPreset(value); + } + } else { + throw new TypeError("Expected usable value, not `" + value + "`"); + } + if (settings) { + namespace.settings = Object.assign(namespace.settings || {}, settings); + } + return processor; + function add(value2) { + if (typeof value2 === "function") { + addPlugin(value2); + } else if (typeof value2 === "object") { + if (Array.isArray(value2)) { + const [plugin, ...options2] = value2; + addPlugin(plugin, ...options2); + } else { + addPreset(value2); + } + } else { + throw new TypeError("Expected usable value, not `" + value2 + "`"); + } + } + function addPreset(result) { + addList(result.plugins); + if (result.settings) { + settings = Object.assign(settings || {}, result.settings); + } + } + function addList(plugins) { + let index2 = -1; + if (plugins === null || plugins === void 0) { + } else if (Array.isArray(plugins)) { + while (++index2 < plugins.length) { + const thing = plugins[index2]; + add(thing); + } + } else { + throw new TypeError("Expected a list of plugins, not `" + plugins + "`"); + } + } + function addPlugin(plugin, value2) { + let index2 = -1; + let entry; + while (++index2 < attachers.length) { + if (attachers[index2][0] === plugin) { + entry = attachers[index2]; + break; + } + } + if (entry) { + if (isPlainObject(entry[1]) && isPlainObject(value2)) { + value2 = (0, import_extend.default)(true, entry[1], value2); + } + entry[1] = value2; + } else { + attachers.push([...arguments]); + } + } + } + function parse4(doc) { + processor.freeze(); + const file = vfile(doc); + const Parser = processor.Parser; + assertParser("parse", Parser); + if (newable(Parser, "parse")) { + return new Parser(String(file), file).parse(); + } + return Parser(String(file), file); + } + function stringify(node, doc) { + processor.freeze(); + const file = vfile(doc); + const Compiler = processor.Compiler; + assertCompiler("stringify", Compiler); + assertNode(node); + if (newable(Compiler, "compile")) { + return new Compiler(node, file).compile(); + } + return Compiler(node, file); + } + function run(node, doc, callback) { + assertNode(node); + processor.freeze(); + if (!callback && typeof doc === "function") { + callback = doc; + doc = void 0; + } + if (!callback) { + return new Promise(executor); + } + executor(null, callback); + function executor(resolve, reject) { + transformers.run(node, vfile(doc), done); + function done(error, tree, file) { + tree = tree || node; + if (error) { + reject(error); + } else if (resolve) { + resolve(tree); + } else { + callback(null, tree, file); + } + } + } + } + function runSync(node, file) { + let result; + let complete; + processor.run(node, file, done); + assertDone("runSync", "run", complete); + return result; + function done(error, tree) { + bail(error); + result = tree; + complete = true; + } + } + function process(doc, callback) { + processor.freeze(); + assertParser("process", processor.Parser); + assertCompiler("process", processor.Compiler); + if (!callback) { + return new Promise(executor); + } + executor(null, callback); + function executor(resolve, reject) { + const file = vfile(doc); + processor.run(processor.parse(file), file, (error, tree, file2) => { + if (error || !tree || !file2) { + done(error); + } else { + const result = processor.stringify(tree, file2); + if (result === void 0 || result === null) { + } else if (looksLikeAVFileValue(result)) { + file2.value = result; + } else { + file2.result = result; + } + done(error, file2); + } + }); + function done(error, file2) { + if (error || !file2) { + reject(error); + } else if (resolve) { + resolve(file2); + } else { + callback(null, file2); + } + } + } + } + function processSync(doc) { + let complete; + processor.freeze(); + assertParser("processSync", processor.Parser); + assertCompiler("processSync", processor.Compiler); + const file = vfile(doc); + processor.process(file, done); + assertDone("processSync", "process", complete); + return file; + function done(error) { + complete = true; + bail(error); + } + } +} +function newable(value, name) { + return typeof value === "function" && // Prototypes do exist. + // type-coverage:ignore-next-line + value.prototype && // A function with keys in its prototype is probably a constructor. + // Classes’ prototype methods are not enumerable, so we check if some value + // exists in the prototype. + // type-coverage:ignore-next-line + (keys(value.prototype) || name in value.prototype); +} +function keys(value) { + let key; + for (key in value) { + if (own.call(value, key)) { + return true; + } + } + return false; +} +function assertParser(name, value) { + if (typeof value !== "function") { + throw new TypeError("Cannot `" + name + "` without `Parser`"); + } +} +function assertCompiler(name, value) { + if (typeof value !== "function") { + throw new TypeError("Cannot `" + name + "` without `Compiler`"); + } +} +function assertUnfrozen(name, frozen) { + if (frozen) { + throw new Error( + "Cannot call `" + name + "` on a frozen processor.\nCreate a new processor first, by calling it: use `processor()` instead of `processor`." + ); + } +} +function assertNode(node) { + if (!isPlainObject(node) || typeof node.type !== "string") { + throw new TypeError("Expected node, got `" + node + "`"); + } +} +function assertDone(name, asyncName, complete) { + if (!complete) { + throw new Error( + "`" + name + "` finished async. Use `" + asyncName + "` instead" + ); + } +} +function vfile(value) { + return looksLikeAVFile(value) ? value : new VFile(value); +} +function looksLikeAVFile(value) { + return Boolean( + value && typeof value === "object" && "message" in value && "messages" in value + ); +} +function looksLikeAVFileValue(value) { + return typeof value === "string" || (0, import_is_buffer2.default)(value); +} + +// ../unified-latex-util-split/dist/index.js +function splitOnCondition(nodes, splitFunc = () => false, options) { + if (!Array.isArray(nodes)) { + throw new Error(`Can only split an Array, not ${nodes}`); + } + const { onlySplitOnFirstOccurrence = false } = options || {}; + const splitIndices = []; + for (let i = 0; i < nodes.length; i++) { + if (splitFunc(nodes[i])) { + splitIndices.push(i); + if (onlySplitOnFirstOccurrence) { + break; + } + } + } + if (splitIndices.length === 0) { + return { segments: [nodes], separators: [] }; + } + let separators = splitIndices.map((i) => nodes[i]); + let segments = splitIndices.map((splitEnd, i) => { + const splitStart = i === 0 ? 0 : splitIndices[i - 1] + 1; + return nodes.slice(splitStart, splitEnd); + }); + segments.push( + nodes.slice(splitIndices[splitIndices.length - 1] + 1, nodes.length) + ); + return { segments, separators }; +} +function splitOnMacro(ast, macroName) { + if (typeof macroName === "string") { + macroName = [macroName]; + } + if (!Array.isArray(macroName)) { + throw new Error("Type coercion failed"); + } + const isSeparator = match.createMacroMatcher(macroName); + const { segments, separators } = splitOnCondition(ast, isSeparator); + return { segments, macros: separators }; +} + +// ../unified-latex-util-replace/dist/index.js +function lastSignificantNodeIndex(nodes, parbreaksAreInsignificant) { + for (let i = nodes.length - 1; i >= 0; i--) { + const node = nodes[i]; + if (match.whitespace(node) || match.comment(node) || parbreaksAreInsignificant && match.parbreak(node)) { + continue; + } + return i; + } + return void 0; +} + +// ../unified-latex-ctan/dist/index.js +var import_color = __toESM(require_color(), 1); +var import_color2 = __toESM(require_color(), 1); +var macros = { + cref: { signature: "s m" }, + Cref: { signature: "s m" }, + crefrange: { signature: "s m m" }, + Crefrange: { signature: "s m m" }, + cpageref: { signature: "s m" }, + Cpageref: { signature: "s m" }, + ref: { signature: "m" }, + pageref: { signature: "m" }, + namecref: { signature: "m" }, + nameCref: { signature: "m" }, + lcnamecref: { signature: "m" }, + namecrefs: { signature: "m" }, + nameCrefs: { signature: "m" }, + lcnamecrefs: { signature: "m" }, + labelcref: { signature: "m" }, + labelcpageref: { signature: "m" }, + crefalias: { signature: "m m" }, + crefname: { signature: "m m m" }, + // XXX there are many more obscure commands to add here + // https://ctan.org/pkg/cleveref + crefdefaultlabelformat: { signature: "m" }, + crefrangeconjunction: { signature: "m" } +}; +var environments = {}; +function cleanEnumerateBody(ast, itemName = "item") { + let { segments, macros: macros17 } = splitOnMacro(ast, itemName); + for (let i = 0; i < segments.length; i++) { + const segment = segments[i]; + if (i === 0) { + trimEnd(segment); + } else { + trim3(segment); + } + if (segment.length > 0 && i > 0) { + segment.unshift({ type: "whitespace" }); + } + } + let insertParbreakBefore = /* @__PURE__ */ new WeakSet(); + let body = macros17.flatMap((node, i) => { + var _a; + const segment = segments[i + 1]; + const trailingComments = popTrailingComments(segment); + node.args = node.args || []; + node.args.push(arg(segment, { openMark: "", closeMark: "" })); + updateRenderInfo(node, { inParMode: true }); + if (i > 0 || ((_a = segments[0]) == null ? void 0 : _a.length) > 0) { + insertParbreakBefore.add(node); + } + return [node, ...trailingComments]; + }); + body = body.flatMap( + (node) => insertParbreakBefore.has(node) ? [{ type: "parbreak" }, node] : node + ); + body.unshift(...segments[0]); + for (let i = 0; i < body.length - 1; i++) { + const node = body[i]; + const nextNode = body[i + 1]; + if (!match.parbreak(nextNode)) { + continue; + } + if (match.comment(node)) { + node.suffixParbreak = true; + } + if (match.macro(node) && node.args && node.args[node.args.length - 1].closeMark === "") { + const args = node.args[node.args.length - 1].content; + const lastArg = args[args.length - 1]; + if (match.comment(lastArg)) { + lastArg.suffixParbreak = true; + } + } + } + return body; +} +function popTrailingComments(nodes) { + let lastNodeIndex = lastSignificantNodeIndex(nodes, true); + if (lastNodeIndex === nodes.length - 1 || lastNodeIndex == null && nodes.length === 0) { + return []; + } + if (lastNodeIndex == null) { + lastNodeIndex = -1; + } + return nodes.splice(lastNodeIndex + 1); +} +var macros2 = { + answerline: { signature: "o" }, + fillin: { signature: "o o" }, + fullwidth: { signature: "m" }, + fillwidthlines: { signature: "m" }, + fillwidthdottedlines: { signature: "m" }, + fillwidthgrid: { signature: "m" }, + makeemptybox: { signature: "m" }, + CorrectChoiceEmphasis: { + signature: "m", + renderInfo: { breakAround: true } + }, + SolutionEmphasis: { signature: "m", renderInfo: { breakAround: true } }, + uplevel: { signature: "m", renderInfo: { breakAround: true } }, + checkboxchar: { signature: "m", renderInfo: { breakAround: true } }, + checkedchar: { signature: "m", renderInfo: { breakAround: true } }, + pointname: { signature: "m", renderInfo: { breakAround: true } }, + marginpointname: { signature: "m", renderInfo: { breakAround: true } }, + extrawidth: { signature: "m", renderInfo: { breakAround: true } }, + pointformat: { signature: "m", renderInfo: { breakAround: true } }, + bonuspointformat: { signature: "m", renderInfo: { breakAround: true } }, + totalformat: { signature: "m", renderInfo: { breakAround: true } }, + qformat: { signature: "m", renderInfo: { breakAround: true } }, + titledquestion: { signature: "m o", renderInfo: { breakAround: true } }, + pointpoints: { signature: "m m", renderInfo: { breakAround: true } }, + bonuspointpoints: { signature: "m m", renderInfo: { breakAround: true } } +}; +var environments2 = { + choices: { + signature: "o", + processContent: (nodes) => cleanEnumerateBody(nodes, "choice") + }, + checkboxes: { + signature: "o", + processContent: (nodes) => cleanEnumerateBody(nodes, "choice") + }, + oneparchoices: { + signature: "o", + processContent: (nodes) => cleanEnumerateBody(nodes, "choice") + }, + oneparcheckboxes: { + signature: "o", + processContent: (nodes) => cleanEnumerateBody(nodes, "choice") + }, + parts: { + signature: "o", + processContent: (nodes) => cleanEnumerateBody(nodes, "part") + }, + subparts: { + signature: "o", + processContent: (nodes) => cleanEnumerateBody(nodes, "subpart") + }, + subsubparts: { + signature: "o", + processContent: (nodes) => cleanEnumerateBody(nodes, "subsubpart") + }, + questions: { + signature: "o", + processContent: (nodes) => cleanEnumerateBody(nodes, "question") + } +}; +var macros3 = { + geometry: { + signature: "m", + renderInfo: { breakAround: true, pgfkeysArgs: true } + } +}; +var environments3 = {}; +var macros4 = { + hypersetup: { + signature: "m", + renderInfo: { breakAround: true, pgfkeysArgs: true } + }, + href: { signature: "o m m" }, + url: { signature: "m" }, + nolinkurl: { signature: "m" }, + hyperbaseurl: { signature: "m" }, + hyperimage: { signature: "m m" }, + hyperdef: { signature: "m m m" }, + hyperref: { signature: "o m" }, + hyperlink: { signature: "m m" }, + hypertarget: { signature: "m m" }, + autoref: { signature: "s m" }, + pageref: { signature: "s m" }, + autopageref: { signature: "s m" }, + pdfstringdef: { signature: "m m" }, + pdfbookmark: { signature: "o m m" }, + currentpdfbookmark: { signature: "m m" }, + subpdfbookmark: { signature: "m m" }, + belowpdfbookmark: { signature: "m m" }, + texorpdfstring: { signature: "m m" }, + thispdfpagelabel: { signature: "m" }, + hypercalcbp: { signature: "m" } +}; +var environments4 = {}; +var macros5 = { + // Special + "\\": { signature: "!s !o" }, + _: { signature: "m", escapeToken: "" }, + "^": { signature: "m", escapeToken: "" }, + // \newcommand arg signature from https://www.texdev.net/2020/08/19/the-good-the-bad-and-the-ugly-creating-document-commands + // List can be found in latex2e.pdf "An unofficial reference manual" + newcommand: { + signature: "s +m o +o +m", + renderInfo: { + breakAround: true, + namedArguments: ["starred", "name", "numArgs", "default", "body"] + } + }, + renewcommand: { + signature: "s +m o +o +m", + renderInfo: { + breakAround: true, + namedArguments: ["starred", "name", "numArgs", "default", "body"] + } + }, + providecommand: { + signature: "s +m o +o +m", + renderInfo: { breakAround: true } + }, + // Counters + newcounter: { + signature: "m o", + renderInfo: { breakAround: true } + }, + usecounter: { + signature: "m" + }, + setcounter: { + signature: "m m", + renderInfo: { breakAround: true } + }, + addtocounter: { + signature: "m m", + renderInfo: { breakAround: true } + }, + stepcounter: { + signature: "m", + renderInfo: { breakAround: true } + }, + refstepcounter: { + signature: "m", + renderInfo: { breakAround: true } + }, + // Lengths + newlength: { + signature: "m", + renderInfo: { breakAround: true } + }, + addtolength: { + signature: "m m", + renderInfo: { breakAround: true } + }, + settodepth: { + signature: "m m", + renderInfo: { breakAround: true } + }, + settoheight: { + signature: "m m", + renderInfo: { breakAround: true } + }, + settowidth: { + signature: "m m", + renderInfo: { breakAround: true } + }, + // Spaces + stretch: { signature: "m" }, + hspace: { signature: "s m" }, + vspace: { signature: "s m", renderInfo: { breakAround: true } }, + vfill: { renderInfo: { breakAround: true } }, + indent: { renderInfo: { breakAround: true } }, + phantom: { signature: "m" }, + vphantom: { signature: "m" }, + hphantom: { signature: "m" }, + noindent: { renderInfo: { breakAround: true } }, + smallskip: { renderInfo: { breakAround: true } }, + medskip: { renderInfo: { breakAround: true } }, + bigskip: { renderInfo: { breakAround: true } }, + smallbreak: { renderInfo: { breakAround: true } }, + medbreak: { renderInfo: { breakAround: true } }, + bigbreak: { renderInfo: { breakAround: true } }, + newline: { renderInfo: { breakAround: true } }, + linebreak: { signature: "o", renderInfo: { breakAround: true } }, + nolinebreak: { signature: "o", renderInfo: { breakAround: true } }, + clearpage: { renderInfo: { breakAround: true } }, + cleardoublepage: { renderInfo: { breakAround: true } }, + newpage: { renderInfo: { breakAround: true } }, + enlargethispage: { signature: "s", renderInfo: { breakAround: true } }, + pagebreak: { signature: "o", renderInfo: { breakAround: true } }, + nopagebreak: { signature: "o", renderInfo: { breakAround: true } }, + // Boxes + newsavebox: { + signature: "m", + renderInfo: { breakAround: true } + }, + sbox: { + signature: "m m", + renderInfo: { breakAround: true } + }, + savebox: { + signature: "m o o m", + renderInfo: { breakAround: true } + }, + mbox: { signature: "m" }, + makebox: { signature: "d() o o m", renderInfo: { breakAround: true } }, + fbox: { signature: "m" }, + framebox: { signature: "o o m", renderInfo: { breakAround: true } }, + frame: { signature: "m", renderInfo: { breakAround: true } }, + parbox: { signature: "o o o m m", renderInfo: { breakAround: true } }, + raisebox: { signature: "m o o m" }, + marginpar: { signature: "o m", renderInfo: { breakAround: true } }, + colorbox: { signature: "o m m", renderInfo: { breakAround: true } }, + fcolorbox: { signature: "o m m", renderInfo: { breakAround: true } }, + rotatebox: { signature: "o m m" }, + scalebox: { signature: "m o m" }, + reflectbox: { signature: "m" }, + resizebox: { signature: "s m m m" }, + // Define environments + newenvironment: { + signature: "s m o o m m", + renderInfo: { breakAround: true } + }, + renewenvironment: { + signature: "s m o o m m", + renderInfo: { breakAround: true } + }, + newtheorem: { + signature: "s m o m o", + renderInfo: { breakAround: true } + }, + newfont: { + signature: "m m", + renderInfo: { breakAround: true } + }, + // Counters + alph: { signature: "m" }, + Alph: { signature: "m" }, + arabic: { signature: "m" }, + roman: { signature: "m" }, + Roman: { signature: "m" }, + fnsymbol: { signature: "m" }, + // Other + documentclass: { + signature: "o m", + renderInfo: { breakAround: true, pgfkeysArgs: true } + }, + usepackage: { + signature: "o m", + renderInfo: { breakAround: true, pgfkeysArgs: true } + }, + item: { + signature: "o", + renderInfo: { hangingIndent: true, namedArguments: ["label"] } + }, + value: { signature: "m" }, + centering: { renderInfo: { breakAround: true } }, + input: { signature: "m", renderInfo: { breakAround: true } }, + include: { signature: "m", renderInfo: { breakAround: true } }, + includeonly: { + signature: "m", + renderInfo: { breakAround: true, pgfkeysArgs: true } + }, + discretionary: { signature: "m m m" }, + hyphenation: { signature: "m m m" }, + footnote: { signature: "o m", renderInfo: { inParMode: true } }, + footnotemark: { signature: "o" }, + footnotetext: { signature: "o m", renderInfo: { inParMode: true } }, + caption: { + signature: "o m", + renderInfo: { inParMode: true, breakAround: true } + }, + // Math Commands + sqrt: { signature: "o m", renderInfo: { inMathMode: true } }, + frac: { signature: "m m", renderInfo: { inMathMode: true } }, + stackrel: { signature: "m m" }, + ensuremath: { signature: "m", renderInfo: { inMathMode: true } }, + // Layout commands + abstract: { + signature: "m", + renderInfo: { breakAround: true, inParMode: true } + }, + maketitle: { renderInfo: { breakAround: true } }, + doublespacing: { renderInfo: { breakAround: true } }, + singlespacing: { renderInfo: { breakAround: true } }, + author: { + signature: "m", + renderInfo: { breakAround: true, inParMode: true } + }, + date: { signature: "o m", renderInfo: { breakAround: true } }, + thanks: { + signature: "m", + renderInfo: { breakAround: true, inParMode: true } + }, + // amsart document class adds an optional argument + title: { + signature: "o m", + renderInfo: { breakAround: true, inParMode: true } + }, + pagenumbering: { signature: "m", renderInfo: { breakAround: true } }, + pagestyle: { signature: "m", renderInfo: { breakAround: true } }, + thispagestyle: { signature: "m", renderInfo: { breakAround: true } }, + // Colors + definecolor: { signature: "m m m", renderInfo: { breakAround: true } }, + pagecolor: { signature: "o m", renderInfo: { breakAround: true } }, + nopagecolor: { renderInfo: { breakAround: true } }, + multicolumn: { signature: "m m m" }, + // Graphics + includegraphics: { + signature: "s o o m", + renderInfo: { breakAround: true, pgfkeysArgs: true } + }, + rule: { signature: "o m m" }, + // Sectioning + part: { + signature: "s o m", + renderInfo: { + breakAround: true, + inParMode: true, + namedArguments: ["starred", "tocTitle", "title"] + } + }, + chapter: { + signature: "s o m", + renderInfo: { + breakAround: true, + inParMode: true, + namedArguments: ["starred", "tocTitle", "title"] + } + }, + section: { + signature: "s o m", + renderInfo: { + breakAround: true, + inParMode: true, + namedArguments: ["starred", "tocTitle", "title"] + } + }, + subsection: { + signature: "s o m", + renderInfo: { + breakAround: true, + inParMode: true, + namedArguments: ["starred", "tocTitle", "title"] + } + }, + subsubsection: { + signature: "s o m", + renderInfo: { + breakAround: true, + inParMode: true, + namedArguments: ["starred", "tocTitle", "title"] + } + }, + paragraph: { + signature: "s o m", + renderInfo: { + breakAround: true, + inParMode: true, + namedArguments: ["starred", "tocTitle", "title"] + } + }, + subparagraph: { + signature: "s o m", + renderInfo: { + breakAround: true, + inParMode: true, + namedArguments: ["starred", "tocTitle", "title"] + } + }, + appendix: { renderInfo: { breakAround: true, inParMode: true } }, + frontmatter: { renderInfo: { breakAround: true, inParMode: true } }, + mainmatter: { renderInfo: { breakAround: true, inParMode: true } }, + backmatter: { renderInfo: { breakAround: true, inParMode: true } }, + // Citing and references + bibitem: { signature: "o m", renderInfo: { hangingIndent: true } }, + cite: { signature: "o m" }, + // Fonts + textrm: { signature: "m", renderInfo: { inParMode: true } }, + textit: { signature: "m", renderInfo: { inParMode: true } }, + textmd: { signature: "m", renderInfo: { inParMode: true } }, + textbf: { signature: "m", renderInfo: { inParMode: true } }, + textup: { signature: "m", renderInfo: { inParMode: true } }, + textsl: { signature: "m", renderInfo: { inParMode: true } }, + textsf: { signature: "m", renderInfo: { inParMode: true } }, + textsc: { signature: "m", renderInfo: { inParMode: true } }, + texttt: { signature: "m", renderInfo: { inParMode: true } }, + emph: { signature: "m", renderInfo: { inParMode: true } }, + textnormal: { signature: "m", renderInfo: { inParMode: true } }, + uppercase: { signature: "m", renderInfo: { inParMode: true } }, + mathbf: { signature: "m" }, + mathsf: { signature: "m" }, + mathtt: { signature: "m" }, + mathit: { signature: "m" }, + mathnormal: { signature: "m" }, + mathcal: { signature: "m" }, + mathrm: { signature: "m" }, + // Other + setlength: { signature: "m m", renderInfo: { breakAround: true } }, + ref: { signature: "s m" }, + label: { signature: "o m" }, + // cleveref changes \label to have this signature + printbibliography: { renderInfo: { breakAround: true } }, + addtocontents: { signature: "m m", renderInfo: { breakAround: true } }, + addcontentsline: { signature: "m m m", renderInfo: { breakAround: true } }, + contentsline: { signature: "m m m", renderInfo: { breakAround: true } }, + bibliography: { signature: "m", renderInfo: { breakAround: true } }, + bibliographystyle: { signature: "m", renderInfo: { breakAround: true } } +}; +var environments5 = { + document: { + processContent: (nodes) => { + trim3(nodes); + return nodes; + } + }, + array: { signature: "o m", renderInfo: { alignContent: true } }, + description: { signature: "o", processContent: cleanEnumerateBody }, + enumerate: { + signature: "o", + processContent: cleanEnumerateBody, + renderInfo: { pgfkeysArgs: true } + }, + itemize: { signature: "o", processContent: cleanEnumerateBody }, + trivlist: { signature: "o", processContent: cleanEnumerateBody }, + list: { signature: "m m", processContent: cleanEnumerateBody }, + figure: { signature: "o" }, + "figure*": { signature: "o" }, + filecontents: { signature: "o m" }, + "filecontents*": { signature: "o m" }, + minipage: { signature: "o o o m" }, + picture: { signature: "r() d()" }, + tabbing: { renderInfo: { alignContent: true } }, + table: { signature: "o" }, + tabular: { signature: "o m", renderInfo: { alignContent: true } }, + "tabular*": { signature: "m o m", renderInfo: { alignContent: true } }, + thebibliography: { + signature: "m", + processContent: (nodes) => cleanEnumerateBody(nodes, "bibitem") + }, + // Math + math: { renderInfo: { inMathMode: true } } +}; +var argSpecM = parse("m")[0]; +var argSpecO = parse("o")[0]; +var argSpecRDelim = {}; +var argumentParser = (nodes, startPos) => { + const { argument: optionalArg, nodesRemoved: optionalArgNodesRemoved } = gobbleSingleArgument(nodes, argSpecO, startPos); + let codeArg = null; + let codeArgNodesRemoved = 0; + const nextNode = nodes[startPos]; + if (match.group(nextNode)) { + const mandatoryArg = gobbleSingleArgument(nodes, argSpecM, startPos); + codeArg = mandatoryArg.argument; + codeArgNodesRemoved = mandatoryArg.nodesRemoved; + } else if (match.string(nextNode) && nextNode.content.length === 1) { + const delim = nextNode.content; + argSpecRDelim[delim] = argSpecRDelim[delim] || parse(`r${delim}${delim}`)[0]; + const delimArg = gobbleSingleArgument( + nodes, + argSpecRDelim[delim], + startPos + ); + codeArg = delimArg.argument; + codeArgNodesRemoved = delimArg.nodesRemoved; + } + return { + args: [optionalArg || arg(null), codeArg || arg(null)], + nodesRemoved: optionalArgNodesRemoved + codeArgNodesRemoved + }; +}; +var macros6 = { + lstset: { signature: "m" }, + lstinline: { argumentParser }, + lstinputlisting: { signature: "o m" }, + lstdefinestyle: { signature: "m m" }, + lstnewenvironment: { signature: "m o o m m" }, + lstMakeShortInline: { signature: "o m" }, + lstDeleteShortInline: { signature: "m" }, + lstdefineformat: { signature: "m m" }, + lstdefinelanguage: { signature: "o m o m o" }, + lstalias: { signature: "o m o m" }, + lstloadlanguages: { signature: "m" } +}; +var environments6 = {}; +var macros7 = { + see: { signature: "m m" }, + seealso: { signature: "m m" }, + seename: { signature: "m" }, + alsoname: { signature: "m" }, + index: { signature: "m" } +}; +var environments7 = {}; +var macros8 = { + mathtoolsset: { + signature: "m", + renderInfo: { breakAround: true, pgfkeysArgs: true } + }, + mathllap: { + signature: "o m" + }, + mathrlap: { + signature: "o m" + }, + mathclap: { + signature: "o m" + }, + clap: { + signature: "m" + }, + mathmbox: { + signature: "m" + }, + mathmakebox: { + signature: "o o m" + }, + cramped: { + signature: "o m" + }, + crampedllap: { + signature: "o m" + }, + crampedrlap: { + signature: "o m" + }, + crampedclap: { + signature: "o m" + }, + crampedsubstack: { + signature: "o m" + }, + smashoperator: { + signature: "o m" + }, + newtagform: { + signature: "m o m m" + }, + renewtagform: { + signature: "m o m m" + }, + usetagform: { + signature: "m" + }, + xleftrightarrow: { signature: "o m" }, + xLeftarrow: { signature: "o m" }, + xhookleftarrow: { signature: "o m" }, + xmapsto: { signature: "o m" }, + xRightarrow: { signature: "o m" }, + xLeftrightarrow: { signature: "o m" }, + xhookrightarrow: { signature: "o m" }, + underbracket: { signature: "o o m" }, + overbracket: { signature: "o o m" }, + underbrace: { signature: "m" }, + overbrace: { signature: "m" }, + shoveleft: { signature: "o m" }, + shoveright: { signature: "o m" }, + ArrowBetweenLines: { signature: "s o" }, + vdotswithin: { signature: "m" }, + shortdotswithin: { signature: "s m" }, + DeclarePairedDelimiter: { + signature: "m m m", + renderInfo: { breakAround: true } + }, + DeclarePairedDelimiterX: { + signature: "m o m m m", + renderInfo: { breakAround: true } + }, + DeclarePairedDelimiterXPP: { + signature: "m o m m m m m", + renderInfo: { breakAround: true } + }, + prescript: { signature: "m m m" }, + DeclareMathSizes: { signature: "m m m m" }, + newgathered: { signature: "m m m m" }, + renewgathered: { signature: "m m m m" }, + splitfrac: { signature: "m m" }, + splitdfrac: { signature: "m m" }, + xmathstrut: { signature: "o m" }, + // amsthm + newtheorem: { signature: "s m o m o", renderInfo: { breakAround: true } }, + theoremstyle: { signature: "m", renderInfo: { breakAround: true } }, + newtheoremstyle: { + signature: "m m m m m m m m m", + renderInfo: { breakAround: true } + }, + // amsmath + text: { signature: "m", renderInfo: { inMathMode: false } }, + // amsfonts + mathbb: { signature: "m" }, + mathscr: { signature: "m" }, + mathfrak: { signature: "m" }, + frak: { signature: "m" }, + Bdd: { signature: "m" }, + bold: { signature: "m" }, + // amsopn + operatorname: { signature: "s m" }, + DeclareMathOperator: { + signature: "s m m", + renderInfo: { breakAround: true } + } +}; +var environments8 = { + crampedsubarray: { + signature: "m", + renderInfo: { alignContent: true, inMathMode: true } + }, + matrix: { renderInfo: { alignContent: true, inMathMode: true } }, + bmatrix: { renderInfo: { alignContent: true, inMathMode: true } }, + pmatrix: { renderInfo: { alignContent: true, inMathMode: true } }, + vmatrix: { renderInfo: { alignContent: true, inMathMode: true } }, + Bmatrix: { renderInfo: { alignContent: true, inMathMode: true } }, + Vmatrix: { renderInfo: { alignContent: true, inMathMode: true } }, + smallmatrix: { renderInfo: { alignContent: true, inMathMode: true } }, + psmallmatrix: { renderInfo: { alignContent: true, inMathMode: true } }, + vsmallmatrix: { renderInfo: { alignContent: true, inMathMode: true } }, + bsmallmatrix: { renderInfo: { alignContent: true, inMathMode: true } }, + Bsmallmatrix: { renderInfo: { alignContent: true, inMathMode: true } }, + Vsmallmatrix: { renderInfo: { alignContent: true, inMathMode: true } }, + "matrix*": { + signature: "o", + renderInfo: { alignContent: true, inMathMode: true } + }, + "bmatrix*": { + signature: "o", + renderInfo: { alignContent: true, inMathMode: true } + }, + "pmatrix*": { + signature: "o", + renderInfo: { alignContent: true, inMathMode: true } + }, + "vmatrix*": { + signature: "o", + renderInfo: { alignContent: true, inMathMode: true } + }, + "Bmatrix*": { + signature: "o", + renderInfo: { alignContent: true, inMathMode: true } + }, + "Vmatrix*": { + signature: "o", + renderInfo: { alignContent: true, inMathMode: true } + }, + "smallmatrix*": { + signature: "o", + renderInfo: { alignContent: true, inMathMode: true } + }, + "psmallmatrix*": { + signature: "o", + renderInfo: { alignContent: true, inMathMode: true } + }, + "bsmallmatrix*": { + signature: "o", + renderInfo: { alignContent: true, inMathMode: true } + }, + "vsmallmatrix*": { + signature: "o", + renderInfo: { alignContent: true, inMathMode: true } + }, + "Bsmallmatrix*": { + signature: "o", + renderInfo: { alignContent: true, inMathMode: true } + }, + "Vsmallmatrix*": { + signature: "o", + renderInfo: { alignContent: true, inMathMode: true } + }, + multilined: { signature: "o o", renderInfo: { inMathMode: true } }, + cases: { renderInfo: { alignContent: true, inMathMode: true } }, + "cases*": { renderInfo: { alignContent: true, inMathMode: true } }, + dcases: { renderInfo: { alignContent: true, inMathMode: true } }, + "dcases*": { renderInfo: { alignContent: true, inMathMode: true } }, + rcases: { renderInfo: { alignContent: true, inMathMode: true } }, + "rcases*": { renderInfo: { alignContent: true, inMathMode: true } }, + drcases: { renderInfo: { alignContent: true, inMathMode: true } }, + "drcases*": { renderInfo: { alignContent: true, inMathMode: true } }, + spreadlines: { signature: "m", renderInfo: { inMathMode: true } }, + lgathered: { signature: "o", renderInfo: { inMathMode: true } }, + rgathered: { signature: "o", renderInfo: { inMathMode: true } }, + // amsmath + "align*": { renderInfo: { inMathMode: true, alignContent: true } }, + align: { renderInfo: { inMathMode: true, alignContent: true } }, + aligned: { renderInfo: { inMathMode: true, alignContent: true } }, + "alignat*": { renderInfo: { inMathMode: true, alignContent: true } }, + alignat: { renderInfo: { inMathMode: true, alignContent: true } }, + "equation*": { renderInfo: { inMathMode: true } }, + equation: { renderInfo: { inMathMode: true } }, + "gather*": { renderInfo: { inMathMode: true } }, + gather: { renderInfo: { inMathMode: true } }, + "multline*": { renderInfo: { inMathMode: true } }, + multline: { renderInfo: { inMathMode: true } }, + "flalign*": { renderInfo: { inMathMode: true, alignContent: true } }, + flalign: { renderInfo: { inMathMode: true, alignContent: true } }, + split: { renderInfo: { inMathMode: true } }, + // Math environments + displaymath: { renderInfo: { inMathMode: true } }, + // Typical amsthm environments + theorem: { signature: "o" }, + lemma: { signature: "o" }, + definition: { signature: "o" }, + proposition: { signature: "o" }, + corollary: { signature: "o" }, + remark: { signature: "!o" }, + example: { signature: "!o" }, + proof: { signature: "o" } +}; +var argSpecM2 = parse("m")[0]; +var argSpecO2 = parse("o")[0]; +var argSpecRDelim2 = {}; +var argumentParser2 = (nodes, startPos) => { + const { argument: optionalArg, nodesRemoved: optionalArgNodesRemoved } = gobbleSingleArgument(nodes, argSpecO2, startPos); + const { argument: languageArg, nodesRemoved: languageArgNodesRemoved } = gobbleSingleArgument(nodes, argSpecM2, startPos); + let codeArg = null; + let codeArgNodesRemoved = 0; + const nextNode = nodes[startPos]; + if (match.group(nextNode)) { + const mandatoryArg = gobbleSingleArgument(nodes, argSpecM2, startPos); + codeArg = mandatoryArg.argument; + codeArgNodesRemoved = mandatoryArg.nodesRemoved; + } else if (match.string(nextNode) && nextNode.content.length === 1) { + const delim = nextNode.content; + argSpecRDelim2[delim] = argSpecRDelim2[delim] || parse(`r${delim}${delim}`)[0]; + const delimArg = gobbleSingleArgument( + nodes, + argSpecRDelim2[delim], + startPos + ); + codeArg = delimArg.argument; + codeArgNodesRemoved = delimArg.nodesRemoved; + } + return { + args: [ + optionalArg || arg(null), + languageArg || arg(null), + codeArg || arg(null) + ], + nodesRemoved: optionalArgNodesRemoved + languageArgNodesRemoved + codeArgNodesRemoved + }; +}; +var macros9 = { + mint: { argumentParser: argumentParser2 }, + mintinline: { argumentParser: argumentParser2 }, + inputminted: { argumentParser: argumentParser2 }, + usemintedstyle: { signature: "m" }, + setminted: { signature: "o m" }, + setmintedinline: { signature: "o m" }, + newmint: { signature: "o m m" }, + newminted: { signature: "o m m" }, + newmintinline: { signature: "o m m" }, + newmintedfile: { signature: "o m m" } +}; +var environments9 = {}; +var macros10 = { + NiceMatrixOptions: { + signature: "m", + renderInfo: { pgfkeysArgs: true, breakAround: true } + } +}; +var environments10 = { + NiceTabular: { + signature: "o m !o", + renderInfo: { pgfkeysArgs: true, alignContent: true } + }, + NiceMatrixBlock: { + signature: "!o", + renderInfo: { pgfkeysArgs: true, alignContent: true } + }, + NiceArrayWithDelims: { + signature: "m m o m !o", + renderInfo: { pgfkeysArgs: true, alignContent: true } + }, + NiceArray: { + signature: "o m !o", + renderInfo: { pgfkeysArgs: true, alignContent: true } + }, + pNiceArray: { + signature: "o m !o", + renderInfo: { pgfkeysArgs: true, alignContent: true } + }, + bNiceArray: { + signature: "o m !o", + renderInfo: { pgfkeysArgs: true, alignContent: true } + }, + BNiceArray: { + signature: "o m !o", + renderInfo: { pgfkeysArgs: true, alignContent: true } + }, + vNiceArray: { + signature: "o m !o", + renderInfo: { pgfkeysArgs: true, alignContent: true } + }, + VNiceArray: { + signature: "o m !o", + renderInfo: { pgfkeysArgs: true, alignContent: true } + }, + NiceMatrix: { + signature: "!o", + renderInfo: { pgfkeysArgs: true, alignContent: true } + }, + pNiceMatrix: { + signature: "!o", + renderInfo: { pgfkeysArgs: true, alignContent: true } + }, + bNiceMatrix: { + signature: "!o", + renderInfo: { pgfkeysArgs: true, alignContent: true } + }, + BNiceMatrix: { + signature: "!o", + renderInfo: { pgfkeysArgs: true, alignContent: true } + }, + vNiceMatrix: { + signature: "!o", + renderInfo: { pgfkeysArgs: true, alignContent: true } + }, + VNiceMatrix: { + signature: "!o", + renderInfo: { pgfkeysArgs: true, alignContent: true } + } +}; +var macros11 = { + systeme: { + signature: "s o o m", + renderInfo: { inMathMode: true } + }, + sysdelim: { + signature: "m m" + }, + syseqsep: { signature: "m" }, + sysalign: { signature: "m" }, + syssignspace: { signature: "m" }, + syseqspace: { signature: "m" }, + syslineskipcoeff: { signature: "m" }, + syseqivsign: { signature: "m" }, + sysaddeqsign: { signature: "m" }, + sysremoveeqsign: { signature: "m" }, + sysextracolonsign: { signature: "m" }, + syscodeextracol: { signature: "m" }, + sysautonum: { signature: "m" }, + syssubstitute: { signature: "m" } +}; +var environments11 = {}; +(function() { + if (typeof globalThis === "object") + return; + Object.defineProperty(Object.prototype, "__magic__", { + get: function() { + return this; + }, + configurable: true + // This makes it possible to `delete` the getter later. + }); + __magic__.globalThis = __magic__; + delete Object.prototype.__magic__; +})(); +var clone = typeof globalThis.structuredClone === "function" ? globalThis.structuredClone : (obj) => JSON.parse(JSON.stringify(obj)); +var OPTIONAL_ARGUMENT_ARG_SPEC2 = parse("o")[0]; +function blankArg() { + return arg([], { openMark: "", closeMark: "" }); +} +var tikzCommandArgumentParser2 = (nodes, startPos) => { + const origStartPos = startPos; + let pos = startPos; + let nodesRemoved = 0; + const cursorPosAfterAnimations = eatAllAnimationSpecs(nodes, pos); + let animationArg = blankArg(); + if (cursorPosAfterAnimations !== pos) { + const argContent = nodes.splice(pos, cursorPosAfterAnimations - pos); + trim3(argContent); + animationArg = arg(argContent, { + openMark: " ", + closeMark: " " + }); + } + nodesRemoved += cursorPosAfterAnimations - pos; + const { + argument: _optionalArgument, + nodesRemoved: optionalArgumentNodesRemoved + } = gobbleSingleArgument(nodes, OPTIONAL_ARGUMENT_ARG_SPEC2, pos); + nodesRemoved += optionalArgumentNodesRemoved; + const optionalArg = _optionalArgument || blankArg(); + while (match.whitespace(nodes[pos])) { + pos++; + } + const firstNode = nodes[pos]; + if (!firstNode) { + return { + args: [animationArg, optionalArg, blankArg()], + nodesRemoved: 0 + }; + } + if (match.group(firstNode)) { + const args = [animationArg, optionalArg, arg(firstNode.content)]; + nodes.splice(origStartPos, pos - origStartPos + 1); + return { args, nodesRemoved: pos - origStartPos + 1 + nodesRemoved }; + } + const semicolonPosition = scan(nodes, ";", { startIndex: pos }); + if (semicolonPosition != null) { + const argNodes = nodes.splice( + origStartPos, + semicolonPosition - origStartPos + 1 + ); + trim3(argNodes); + const args = [animationArg, optionalArg, arg(argNodes)]; + return { + args, + nodesRemoved: origStartPos - semicolonPosition + 1 + nodesRemoved + }; + } + return { + args: [animationArg, optionalArg, blankArg()], + nodesRemoved: 0 + }; +}; +function eatAllAnimationSpecs(nodes, startPos) { + const colonPos = scan(nodes, ":", { + startIndex: startPos, + allowSubstringMatches: true, + onlySkipWhitespaceAndComments: true + }); + if (!colonPos) { + return startPos; + } + let lastMatchPos = startPos; + let i = colonPos + 1; + for (; i < nodes.length; i++) { + const node = nodes[i]; + if (match.string(node, "[")) { + break; + } + if (match.string(node, "=")) { + i++; + while (match.whitespace(nodes[i]) || match.comment(nodes[i])) { + i++; + } + if (!match.group(nodes[i])) { + break; + } + lastMatchPos = i + 1; + const colonPos2 = scan(nodes, ":", { + startIndex: lastMatchPos, + allowSubstringMatches: true, + onlySkipWhitespaceAndComments: true + }); + if (colonPos2 == null) { + break; + } + i = colonPos2 + 1; + } + } + return lastMatchPos; +} +var macros12 = { + pgfkeys: { + signature: "m", + renderInfo: { breakAround: true, pgfkeysArgs: true } + }, + tikzoption: { + signature: "m", + renderInfo: { breakAround: true, pgfkeysArgs: true } + }, + tikzstyle: { + signature: "m", + renderInfo: { breakAround: true, pgfkeysArgs: true } + }, + usetikzlibrary: { + signature: "m", + renderInfo: { breakAround: true, pgfkeysArgs: true } + }, + usepgfmodule: { signature: "m", renderInfo: { pgfkeysArgs: true } }, + usepgflibrary: { signature: "m", renderInfo: { pgfkeysArgs: true } }, + pgfplotsset: { + signature: "m", + renderInfo: { breakAround: true, pgfkeysArgs: true } + }, + pgfplotstabletypeset: { + signature: "o m", + renderInfo: { breakAround: true, pgfkeysArgs: true } + }, + tikz: { + signature: "o o m", + argumentParser: tikzCommandArgumentParser2, + renderInfo: { namedArguments: ["animation", "options", "command"] } + } +}; +var environments12 = { + tikzpicture: { + signature: "o", + renderInfo: { pgfkeysArgs: true, tikzEnvironment: true }, + processContent: processTikzEnvironmentContent + }, + axis: { + signature: "o", + renderInfo: { pgfkeysArgs: true, tikzEnvironment: true }, + processContent: processTikzEnvironmentContent + }, + scope: { + signature: "o", + renderInfo: { pgfkeysArgs: true, tikzEnvironment: true }, + processContent: processTikzEnvironmentContent + }, + pgfonlayer: { + signature: "m", + renderInfo: { tikzEnvironment: true }, + processContent: processTikzEnvironmentContent + }, + pgflowlevelscope: { + signature: "m", + renderInfo: { tikzEnvironment: true }, + processContent: processTikzEnvironmentContent + }, + pgfviewboxscope: { + signature: "m m m m m", + renderInfo: { tikzEnvironment: true }, + processContent: processTikzEnvironmentContent + }, + pgftransparencygroup: { + signature: "o", + renderInfo: { pgfkeysArgs: true, tikzEnvironment: true }, + processContent: processTikzEnvironmentContent + }, + behindforegroundpath: { + signature: "m", + processContent: processTikzEnvironmentContent + }, + pgfmetadecoration: { + signature: "m", + processContent: processTikzEnvironmentContent + }, + colormixin: { signature: "m", renderInfo: { pgfkeysArgs: true } } +}; +function processTikzEnvironmentContent(nodes) { + attachMacroArgsInArray(nodes, conditionalMacros); + return nodes; +} +var conditionalMacros = { + pgfextra: { signature: "m" }, + beginpgfgraphicnamed: { signature: "m" }, + pgfrealjobname: { signature: "m" }, + pgfplotstreampoint: { signature: "m" }, + pgfplotstreampointoutlier: { signature: "m" }, + pgfplotstreamspecial: { signature: "m" }, + pgfplotxyfile: { signature: "m" }, + pgfplotxyzfile: { signature: "m" }, + pgfplotfunction: { signature: "mmm" }, + pgfplotgnuplot: { signature: "o m" }, + pgfplothandlerrecord: { signature: "m" }, + pgfdeclareplothandler: { signature: "m m m" }, + pgfdeclarelayer: { signature: "m" }, + pgfsetlayers: { signature: "m", renderInfo: { pgfkeysArgs: true } }, + pgfonlayer: { signature: "m" }, + startpgfonlayer: { signature: "m" }, + pgfdeclarehorizontalshading: { signature: "o m m m " }, + pgfdeclareradialshading: { signature: "o m m m" }, + pgfdeclarefunctionalshading: { signature: "o m m m m m" }, + pgfshadecolortorgb: { signature: "m m" }, + pgfshadecolortocmyk: { signature: "m m" }, + pgfshadecolortogray: { signature: "m m" }, + pgfuseshading: { signature: "m" }, + pgfshadepath: { signature: "m m" }, + pgfsetadditionalshadetransform: { signature: "m" }, + pgfsetstrokeopacity: { signature: "m" }, + pgfsetfillopacity: { signature: "m" }, + pgfsetblendmode: { signature: "m" }, + pgfdeclarefading: { signature: "m m" }, + pgfsetfading: { signature: "m m" }, + pgfsetfadingforcurrentpath: { signature: "m m" }, + pgfsetfadingforcurrentpathstroked: { signature: "m m" }, + pgfanimateattribute: { signature: "m m" }, + pgfsnapshot: { signature: "m" }, + pgfqpoint: { signature: "m m" }, + pgfqpointxy: { signature: "m m" }, + pgfqpointxyz: { signature: "m m m" }, + pgfqpointscale: { signature: "m m" }, + pgfpathqmoveto: { signature: "m m" }, + pgfpathqlineto: { signature: "m m" }, + pgfpathqcurveto: { signature: "m m m m m m" }, + pgfpathqcircle: { signature: "m" }, + pgfqbox: { signature: "m" }, + pgfqboxsynced: { signature: "m" }, + pgfaliasimage: { signature: "m m" }, + pgfuseimage: { signature: "m" }, + pgfimage: { signature: "o m", renderInfo: { pgfkeysArgs: true } }, + pgfdeclaremask: { signature: "o m m", renderInfo: { pgfkeysArgs: true } }, + pgfdeclarepatternformonly: { signature: "o m m m m m" }, + pgfdeclarepatterninherentlycolored: { signature: "o m m m m m" }, + pgfsetfillpattern: { signature: "m m" }, + // Coordinate canvas and nonlinear transformations + pgftransformshift: { signature: "m" }, + pgftransformxshift: { signature: "m" }, + pgftransformyshift: { signature: "m" }, + pgftransformscale: { signature: "m" }, + pgftransformxscale: { signature: "m" }, + pgftransformyscale: { signature: "m" }, + pgftransformxslant: { signature: "m" }, + pgftransformyslant: { signature: "m" }, + pgftransformrotate: { signature: "m" }, + pgftransformtriangle: { signature: "m m m" }, + pgftransformcm: { signature: "m m m m m" }, + pgftransformarrow: { signature: "m m" }, + pgftransformlineattime: { signature: "m m m" }, + pgftransformcurveattime: { signature: "m m m m m" }, + pgftransformarcaxesattime: { signature: "m m m m m m" }, + pgfgettransform: { signature: "m" }, + pgfsettransform: { signature: "m" }, + pgfgettransformentries: { signature: "m m m m m m" }, + pgfsettransformentries: { signature: "m m m m m m" }, + pgfpointtransformed: { signature: "m" }, + pgflowlevel: { signature: "m" }, + pgflowlevelobj: { signature: "m m" }, + pgflowlevelscope: { signature: "m" }, + startpgflowlevelscope: { signature: "m" }, + pgfviewboxscope: { signature: "m m m m m" }, + startpgfviewboxscope: { signature: "m m m m m" }, + pgftransformnonlinear: { signature: "m" }, + pgfpointtransformednonlinear: { signature: "m" }, + pgfsetcurvilinearbeziercurve: { signature: "m m m m" }, + pgfcurvilineardistancetotime: { signature: "m" }, + pgfpointcurvilinearbezierorthogonal: { signature: "m m" }, + pgfpointcurvilinearbezierpolar: { signature: "m m" }, + // Matrices + pgfmatrix: { signature: "m m m m m m m" }, + pgfsetmatrixcolumnsep: { signature: "m" }, + pgfmatrixnextcell: { signature: "o" }, + pgfsetmatrixrowsep: { signature: "m" }, + pgfmatrixendrow: { signature: "o" }, + // Nodes and shapes + pgfnode: { signature: "m m m m m" }, + pgfmultipartnode: { signature: "m m m m" }, + pgfcoordinate: { signature: "m m" }, + pgfnodealias: { signature: "m m" }, + pgfnoderename: { signature: "m m" }, + pgfpositionnodelater: { signature: "m" }, + pgfpositionnodenow: { signature: "m" }, + pgfnodepostsetupcode: { signature: "m m" }, + pgfpointanchor: { signature: "m m" }, + pgfpointshapeborder: { signature: "m m" }, + pgfdeclareshape: { signature: "m m" }, + saveddimen: { signature: "m m" }, + savedmacro: { signature: " m" }, + anchor: { signature: "m m" }, + deferredanchor: { signature: "m m" }, + anchorborder: { signature: "m" }, + backgroundpath: { signature: "m" }, + foregroundpath: { signature: "m" }, + behindbackgroundpath: { signature: "m" }, + beforebackgroundpath: { signature: "m" }, + beforeforegroundpath: { signature: "m" }, + behindforegroundpath: { signature: "m" }, + // Arrows + pgfdeclarearrow: { signature: "m" }, + pgfarrowssettipend: { signature: "m" }, + pgfarrowssetbackend: { signature: "m" }, + pgfarrowssetlineend: { signature: "m" }, + pgfarrowssetvisualbackend: { signature: "m" }, + pgfarrowssetvisualtipend: { signature: "m" }, + pgfarrowshullpoint: { signature: "m m" }, + pgfarrowsupperhullpoint: { signature: "m m" }, + pgfarrowssave: { signature: "m" }, + pgfarrowssavethe: { signature: "m" }, + pgfarrowsaddtooptions: { signature: "m" }, + pgfarrowsaddtolateoptions: { signature: "m" }, + pgfarrowsaddtolengthscalelist: { signature: "m" }, + pgfarrowsaddtowidthscalelist: { signature: "m" }, + pgfarrowsthreeparameters: { signature: "m" }, + pgfarrowslinewidthdependent: { signature: "m m m" }, + pgfarrowslengthdependent: { signature: "m" }, + // Path + pgfusepath: { signature: "m" }, + pgfsetlinewidth: { signature: "m" }, + pgfsetmiterlimit: { signature: "m" }, + pgfsetdash: { signature: "m m" }, + pgfsetstrokecolor: { signature: "m" }, + pgfsetcolor: { signature: "m" }, + pgfsetinnerlinewidth: { signature: "m" }, + pgfsetinnerstrokecolor: { signature: "m" }, + pgfsetarrowsstart: { signature: "m" }, + pgfsetarrowsend: { signature: "m" }, + pgfsetarrows: { signature: "m" }, + pgfsetshortenstart: { signature: "m" }, + pgfsetshortenend: { signature: "m" }, + pgfsetfillcolor: { signature: "m" }, + // Decorations + pgfdeclaredecoration: { signature: "m m m" }, + state: { signature: "m o m" }, + pgfdecoratepath: { signature: "m m" }, + startpgfdecoration: { signature: "m" }, + pgfdecoration: { signature: "m" }, + pgfdecoratecurrentpath: { signature: "m" }, + pgfsetdecorationsegmenttransformation: { signature: "m" }, + pgfdeclaremetadecorate: { signature: "m m m" }, + pgfmetadecoration: { signature: "m" }, + startpgfmetadecoration: { signature: "m" }, + // Constructing paths + pgfpathmoveto: { signature: "m" }, + pgfpathlineto: { signature: "m" }, + pgfpathcurveto: { signature: "m m m" }, + pgfpathquadraticcurveto: { signature: "m m" }, + pgfpathcurvebetweentime: { signature: "m m m m m m" }, + pgfpathcurvebetweentimecontinue: { signature: "m m m m m m" }, + pgfpatharc: { signature: "m m m" }, + pgfpatharcaxes: { signature: "m m m m" }, + pgfpatharcto: { signature: "m m m m m m" }, + pgfpatharctoprecomputed: { signature: "m m m m m m m m" }, + pgfpathellipse: { signature: "m m m" }, + pgfpathcircle: { signature: "m m" }, + pgfpathrectangle: { signature: "m m" }, + pgfpathrectanglecorners: { signature: "m m" }, + pgfpathgrid: { signature: " o m m" }, + pgfpathparabola: { signature: "m m" }, + pgfpathsine: { signature: "m" }, + pgfpathcosine: { signature: "m" }, + pgfsetcornersarced: { signature: "m" }, + "pgf@protocolsizes": { signature: "m m" }, + // Specifying coordinates + pgfpoint: { signature: "m m" }, + pgfpointpolar: { signature: "m m m" }, + pgfpointxy: { signature: "m m" }, + pgfsetxvec: { signature: "m" }, + pgfsetyvec: { signature: "m" }, + pgfpointpolarxy: { signature: "m m" }, + pgfpointxyz: { signature: "m m m" }, + pgfsetzvec: { signature: "m" }, + pgfpointcylindrical: { signature: "m m m" }, + pgfpointspherical: { signature: "m m m" }, + pgfpointadd: { signature: "m m" }, + pgfpointscale: { signature: "m m" }, + pgfpointdiff: { signature: "m m" }, + pgfpointnormalised: { signature: "m" }, + pgfpointlineattime: { signature: "m m m" }, + pgfpointlineatdistance: { signature: "m m m" }, + pgfpointarcaxesattime: { signature: "m m m m m m" }, + pgfpointcurveattime: { signature: "m m m m m" }, + pgfpointborderrectangle: { signature: "m m" }, + pgfpointborderellipse: { signature: "m m" }, + pgfpointintersectionoflines: { signature: "m m m m" }, + pgfpointintersectionofcircles: { signature: "m m m m m" }, + pgfintersectionofpaths: { signature: "m m" }, + pgfpointintersectionsolution: { signature: "m" }, + pgfextractx: { signature: "m m" }, + pgfextracty: { signature: "m m" }, + pgfgetlastxy: { signature: "m m" }, + "pgf@process": { signature: "m" }, + // Heirarchical structres ... + pgfsetbaseline: { signature: "m" }, + pgfsetbaselinepointnow: { signature: "m" }, + pgfsetbaselinepointlater: { signature: "m" }, + pgftext: { signature: "o m", renderInfo: { pgfkeysArgs: true } }, + pgfuseid: { signature: "m" }, + pgfusetype: { signature: "m" }, + pgfidrefnextuse: { signature: "m m" }, + pgfidrefprevuse: { signature: "m m" }, + pgfaliasid: { signature: "m m" }, + pgfgaliasid: { signature: "m m" }, + pgfifidreferenced: { signature: "m m m" }, + pgfrdfabout: { signature: "m" }, + pgfrdfcontent: { signature: "m" }, + pgfrdfdatatype: { signature: "m" }, + pgfrdfhref: { signature: "m" }, + pgfrdfprefix: { signature: "m" }, + pgfrdfproperty: { signature: "m" }, + pgfrdfrel: { signature: "m" }, + pgfrdfresource: { signature: "m" }, + pgfrdfrev: { signature: "m" }, + pgfrdfsrc: { signature: "m" }, + pgfrdftypeof: { signature: "m" }, + pgfrdfvocab: { signature: "m" }, + pgferror: { signature: "m" }, + pgfwarning: { signature: "m" }, + path: { + signature: "u;", + renderInfo: { breakAround: true, tikzPathCommand: true } + }, + draw: { + signature: "u;", + renderInfo: { breakAround: true, tikzPathCommand: true } + }, + fill: { + signature: "u;", + renderInfo: { breakAround: true, tikzPathCommand: true } + }, + filldraw: { + signature: "u;", + renderInfo: { breakAround: true, tikzPathCommand: true } + }, + pattern: { + signature: "u;", + renderInfo: { breakAround: true, tikzPathCommand: true } + }, + shade: { + signature: "u;", + renderInfo: { breakAround: true, tikzPathCommand: true } + }, + clip: { + signature: "u;", + renderInfo: { breakAround: true, tikzPathCommand: true } + }, + useasboundingbox: { + signature: "u;", + renderInfo: { breakAround: true, tikzPathCommand: true } + }, + node: { + signature: "u;", + renderInfo: { breakAround: true, tikzPathCommand: true } + }, + coordinate: { + signature: "u;", + renderInfo: { breakAround: true, tikzPathCommand: true } + }, + graph: { + signature: "u;", + renderInfo: { breakAround: true, tikzPathCommand: true } + }, + scoped: { + signature: "o o m", + argumentParser: tikzCommandArgumentParser2, + renderInfo: { + namedArguments: ["animation", "options", "command"], + breakAround: true + } + } +}; +function createMatchers5() { + return { + isChar: match.string, + isTerminal: (node) => match.string(node, ";"), + isOperation: (node) => match.anyString(node) && node.content.match(/[a-zA-Z]/), + isWhitespace: (node) => match.whitespace(node) || match.parbreak(node), + isComment: match.comment, + isGroup: match.group, + isMacro: match.macro, + isAnyMacro: match.anyMacro + }; +} +var matchers2 = createMatchers5(); +var macros13 = { + substitutecolormodel: { + signature: "m m", + renderInfo: { breakAround: true } + }, + selectcolormodel: { + signature: "m", + renderInfo: { breakAround: true } + }, + definecolor: { + signature: "o m m m", + renderInfo: { breakAround: true } + }, + providecolor: { + signature: "o m m m", + renderInfo: { breakAround: true } + }, + colorlet: { + signature: "o m o m", + renderInfo: { breakAround: true } + }, + definecolorset: { + signature: "o m m m", + renderInfo: { breakAround: true } + }, + providecolorset: { + signature: "o m m m m", + renderInfo: { breakAround: true } + }, + preparecolor: { + signature: "o m m m", + renderInfo: { breakAround: true } + }, + preparecolorset: { + signature: "o m m m m", + renderInfo: { breakAround: true } + }, + DefineNamedColor: { + signature: "m m m m", + renderInfo: { breakAround: true } + }, + definecolors: { + signature: "m", + renderInfo: { breakAround: true } + }, + providecolors: { + signature: "m", + renderInfo: { breakAround: true } + }, + color: { signature: "o m", renderInfo: { breakAround: true } }, + textcolor: { signature: "o m m", renderInfo: { inParMode: true } }, + pagecolor: { signature: "o m" }, + colorbox: { signature: "o m m" }, + fcolorbox: { signature: "o m o m m" }, + boxframe: { signature: "o m" }, + testcolor: { signature: "o m" }, + blendcolors: { signature: "s m" }, + maskcolors: { signature: "o m" }, + definecolorseries: { + signature: "m m m o m o m", + renderInfo: { breakAround: true } + }, + resetcolorseries: { + signature: "o m", + renderInfo: { breakAround: true } + }, + rowcolors: { signature: "s o m m m" }, + extractcolorspec: { signature: "m m" }, + extractcolorspecs: { signature: "m m m" }, + convertcolorspec: { signature: "m m m m" } +}; +var environments13 = { + testcolors: { signature: "o", renderInfo: { pgfkeysArgs: true } } +}; +var fromRgb = ([r, g, b]) => (0, import_color2.default)([r * 255, g * 255, b * 255], "rgb"); +var DVI_PS_NAMES = { + Apricot: (0, import_color2.default)("#FBB982"), + Aquamarine: (0, import_color2.default)("#00B5BE"), + Bittersweet: (0, import_color2.default)("#C04F17"), + Black: (0, import_color2.default)("#221E1F"), + Blue: (0, import_color2.default)("#2D2F92"), + BlueGreen: (0, import_color2.default)("#00B3B8"), + BlueViolet: (0, import_color2.default)("#473992"), + BrickRed: (0, import_color2.default)("#B6321C"), + Brown: (0, import_color2.default)("#792500"), + BurntOrange: (0, import_color2.default)("#F7921D"), + CadetBlue: (0, import_color2.default)("#74729A"), + CarnationPink: (0, import_color2.default)("#F282B4"), + Cerulean: (0, import_color2.default)("#00A2E3"), + CornflowerBlue: (0, import_color2.default)("#41B0E4"), + Cyan: (0, import_color2.default)("#00AEEF"), + Dandelion: (0, import_color2.default)("#FDBC42"), + DarkOrchid: (0, import_color2.default)("#A4538A"), + Emerald: (0, import_color2.default)("#00A99D"), + ForestGreen: (0, import_color2.default)("#009B55"), + Fuchsia: (0, import_color2.default)("#8C368C"), + Goldenrod: (0, import_color2.default)("#FFDF42"), + Gray: (0, import_color2.default)("#949698"), + Green: (0, import_color2.default)("#00A64F"), + GreenYellow: (0, import_color2.default)("#DFE674"), + JungleGreen: (0, import_color2.default)("#00A99A"), + Lavender: (0, import_color2.default)("#F49EC4"), + LimeGreen: (0, import_color2.default)("#8DC73E"), + Magenta: (0, import_color2.default)("#EC008C"), + Mahogany: (0, import_color2.default)("#A9341F"), + Maroon: (0, import_color2.default)("#AF3235"), + Melon: (0, import_color2.default)("#F89E7B"), + MidnightBlue: (0, import_color2.default)("#006795"), + Mulberry: (0, import_color2.default)("#A93C93"), + NavyBlue: (0, import_color2.default)("#006EB8"), + OliveGreen: (0, import_color2.default)("#3C8031"), + Orange: (0, import_color2.default)("#F58137"), + OrangeRed: (0, import_color2.default)("#ED135A"), + Orchid: (0, import_color2.default)("#AF72B0"), + Peach: (0, import_color2.default)("#F7965A"), + Periwinkle: (0, import_color2.default)("#7977B8"), + PineGreen: (0, import_color2.default)("#008B72"), + Plum: (0, import_color2.default)("#92268F"), + ProcessBlue: (0, import_color2.default)("#00B0F0"), + Purple: (0, import_color2.default)("#99479B"), + RawSienna: (0, import_color2.default)("#974006"), + Red: (0, import_color2.default)("#ED1B23"), + RedOrange: (0, import_color2.default)("#F26035"), + RedViolet: (0, import_color2.default)("#A1246B"), + Rhodamine: (0, import_color2.default)("#EF559F"), + RoyalBlue: (0, import_color2.default)("#0071BC"), + RoyalPurple: (0, import_color2.default)("#613F99"), + RubineRed: (0, import_color2.default)("#ED017D"), + Salmon: (0, import_color2.default)("#F69289"), + SeaGreen: (0, import_color2.default)("#3FBC9D"), + Sepia: (0, import_color2.default)("#671800"), + SkyBlue: (0, import_color2.default)("#46C5DD"), + SpringGreen: (0, import_color2.default)("#C6DC67"), + Tan: (0, import_color2.default)("#DA9D76"), + TealBlue: (0, import_color2.default)("#00AEB3"), + Thistle: (0, import_color2.default)("#D883B7"), + Turquoise: (0, import_color2.default)("#00B4CE"), + Violet: (0, import_color2.default)("#58429B"), + VioletRed: (0, import_color2.default)("#EF58A0"), + White: (0, import_color2.default)("#FFFFFF"), + WildStrawberry: (0, import_color2.default)("#EE2967"), + Yellow: (0, import_color2.default)("#FFF200"), + YellowGreen: (0, import_color2.default)("#98CC70"), + YellowOrange: (0, import_color2.default)("#FAA21A") +}; +var SVG_NAMES = { + AliceBlue: fromRgb([0.94, 0.972, 1]), + AntiqueWhite: fromRgb([0.98, 0.92, 0.844]), + Aqua: fromRgb([0, 1, 1]), + Aquamarine: fromRgb([0.498, 1, 0.83]), + Azure: fromRgb([0.94, 1, 1]), + Beige: fromRgb([0.96, 0.96, 0.864]), + Bisque: fromRgb([1, 0.894, 0.77]), + Black: fromRgb([0, 0, 0]), + BlanchedAlmond: fromRgb([1, 0.92, 0.804]), + Blue: fromRgb([0, 0, 1]), + BlueViolet: fromRgb([0.54, 0.17, 0.888]), + Brown: fromRgb([0.648, 0.165, 0.165]), + BurlyWood: fromRgb([0.87, 0.72, 0.53]), + CadetBlue: fromRgb([0.372, 0.62, 0.628]), + Chartreuse: fromRgb([0.498, 1, 0]), + Chocolate: fromRgb([0.824, 0.41, 0.116]), + Coral: fromRgb([1, 0.498, 0.312]), + CornflowerBlue: fromRgb([0.392, 0.585, 0.93]), + Cornsilk: fromRgb([1, 0.972, 0.864]), + Crimson: fromRgb([0.864, 0.08, 0.235]), + Cyan: fromRgb([0, 1, 1]), + DarkBlue: fromRgb([0, 0, 0.545]), + DarkCyan: fromRgb([0, 0.545, 0.545]), + DarkGoldenrod: fromRgb([0.72, 0.525, 0.044]), + DarkGray: fromRgb([0.664, 0.664, 0.664]), + DarkGreen: fromRgb([0, 0.392, 0]), + DarkGrey: fromRgb([0.664, 0.664, 0.664]), + DarkKhaki: fromRgb([0.74, 0.716, 0.42]), + DarkMagenta: fromRgb([0.545, 0, 0.545]), + DarkOliveGreen: fromRgb([0.332, 0.42, 0.185]), + DarkOrange: fromRgb([1, 0.55, 0]), + DarkOrchid: fromRgb([0.6, 0.196, 0.8]), + DarkRed: fromRgb([0.545, 0, 0]), + DarkSalmon: fromRgb([0.912, 0.59, 0.48]), + DarkSeaGreen: fromRgb([0.56, 0.736, 0.56]), + DarkSlateBlue: fromRgb([0.284, 0.24, 0.545]), + DarkSlateGray: fromRgb([0.185, 0.31, 0.31]), + DarkSlateGrey: fromRgb([0.185, 0.31, 0.31]), + DarkTurquoise: fromRgb([0, 0.808, 0.82]), + DarkViolet: fromRgb([0.58, 0, 0.828]), + DeepPink: fromRgb([1, 0.08, 0.576]), + DeepSkyBlue: fromRgb([0, 0.75, 1]), + DimGray: fromRgb([0.41, 0.41, 0.41]), + DimGrey: fromRgb([0.41, 0.41, 0.41]), + DodgerBlue: fromRgb([0.116, 0.565, 1]), + FireBrick: fromRgb([0.698, 0.132, 0.132]), + FloralWhite: fromRgb([1, 0.98, 0.94]), + ForestGreen: fromRgb([0.132, 0.545, 0.132]), + Fuchsia: fromRgb([1, 0, 1]), + Gainsboro: fromRgb([0.864, 0.864, 0.864]), + GhostWhite: fromRgb([0.972, 0.972, 1]), + Gold: fromRgb([1, 0.844, 0]), + Goldenrod: fromRgb([0.855, 0.648, 0.125]), + Gray: fromRgb([0.5, 0.5, 0.5]), + Green: fromRgb([0, 0.5, 0]), + GreenYellow: fromRgb([0.68, 1, 0.185]), + Grey: fromRgb([0.5, 0.5, 0.5]), + Honeydew: fromRgb([0.94, 1, 0.94]), + HotPink: fromRgb([1, 0.41, 0.705]), + IndianRed: fromRgb([0.804, 0.36, 0.36]), + Indigo: fromRgb([0.294, 0, 0.51]), + Ivory: fromRgb([1, 1, 0.94]), + Khaki: fromRgb([0.94, 0.9, 0.55]), + Lavender: fromRgb([0.9, 0.9, 0.98]), + LavenderBlush: fromRgb([1, 0.94, 0.96]), + LawnGreen: fromRgb([0.488, 0.99, 0]), + LemonChiffon: fromRgb([1, 0.98, 0.804]), + LightBlue: fromRgb([0.68, 0.848, 0.9]), + LightCoral: fromRgb([0.94, 0.5, 0.5]), + LightCyan: fromRgb([0.88, 1, 1]), + LightGoldenrod: fromRgb([0.933, 0.867, 0.51]), + LightGoldenrodYellow: fromRgb([0.98, 0.98, 0.824]), + LightGray: fromRgb([0.828, 0.828, 0.828]), + LightGreen: fromRgb([0.565, 0.932, 0.565]), + LightGrey: fromRgb([0.828, 0.828, 0.828]), + LightPink: fromRgb([1, 0.712, 0.756]), + LightSalmon: fromRgb([1, 0.628, 0.48]), + LightSeaGreen: fromRgb([0.125, 0.698, 0.668]), + LightSkyBlue: fromRgb([0.53, 0.808, 0.98]), + LightSlateBlue: fromRgb([0.518, 0.44, 1]), + LightSlateGray: fromRgb([0.468, 0.532, 0.6]), + LightSlateGrey: fromRgb([0.468, 0.532, 0.6]), + LightSteelBlue: fromRgb([0.69, 0.77, 0.87]), + LightYellow: fromRgb([1, 1, 0.88]), + Lime: fromRgb([0, 1, 0]), + LimeGreen: fromRgb([0.196, 0.804, 0.196]), + Linen: fromRgb([0.98, 0.94, 0.9]), + Magenta: fromRgb([1, 0, 1]), + Maroon: fromRgb([0.5, 0, 0]), + MediumAquamarine: fromRgb([0.4, 0.804, 0.668]), + MediumBlue: fromRgb([0, 0, 0.804]), + MediumOrchid: fromRgb([0.73, 0.332, 0.828]), + MediumPurple: fromRgb([0.576, 0.44, 0.86]), + MediumSeaGreen: fromRgb([0.235, 0.7, 0.444]), + MediumSlateBlue: fromRgb([0.484, 0.408, 0.932]), + MediumSpringGreen: fromRgb([0, 0.98, 0.604]), + MediumTurquoise: fromRgb([0.284, 0.82, 0.8]), + MediumVioletRed: fromRgb([0.78, 0.084, 0.52]), + MidnightBlue: fromRgb([0.098, 0.098, 0.44]), + MintCream: fromRgb([0.96, 1, 0.98]), + MistyRose: fromRgb([1, 0.894, 0.884]), + Moccasin: fromRgb([1, 0.894, 0.71]), + NavajoWhite: fromRgb([1, 0.87, 0.68]), + Navy: fromRgb([0, 0, 0.5]), + NavyBlue: fromRgb([0, 0, 0.5]), + OldLace: fromRgb([0.992, 0.96, 0.9]), + Olive: fromRgb([0.5, 0.5, 0]), + OliveDrab: fromRgb([0.42, 0.556, 0.136]), + Orange: fromRgb([1, 0.648, 0]), + OrangeRed: fromRgb([1, 0.27, 0]), + Orchid: fromRgb([0.855, 0.44, 0.84]), + PaleGoldenrod: fromRgb([0.932, 0.91, 0.668]), + PaleGreen: fromRgb([0.596, 0.985, 0.596]), + PaleTurquoise: fromRgb([0.688, 0.932, 0.932]), + PaleVioletRed: fromRgb([0.86, 0.44, 0.576]), + PapayaWhip: fromRgb([1, 0.936, 0.835]), + PeachPuff: fromRgb([1, 0.855, 0.725]), + Peru: fromRgb([0.804, 0.52, 0.248]), + Pink: fromRgb([1, 0.752, 0.796]), + Plum: fromRgb([0.868, 0.628, 0.868]), + PowderBlue: fromRgb([0.69, 0.88, 0.9]), + Purple: fromRgb([0.5, 0, 0.5]), + Red: fromRgb([1, 0, 0]), + RosyBrown: fromRgb([0.736, 0.56, 0.56]), + RoyalBlue: fromRgb([0.255, 0.41, 0.884]), + SaddleBrown: fromRgb([0.545, 0.27, 0.075]), + Salmon: fromRgb([0.98, 0.5, 0.448]), + SandyBrown: fromRgb([0.956, 0.644, 0.376]), + SeaGreen: fromRgb([0.18, 0.545, 0.34]), + Seashell: fromRgb([1, 0.96, 0.932]), + Sienna: fromRgb([0.628, 0.32, 0.176]), + Silver: fromRgb([0.752, 0.752, 0.752]), + SkyBlue: fromRgb([0.53, 0.808, 0.92]), + SlateBlue: fromRgb([0.415, 0.352, 0.804]), + SlateGray: fromRgb([0.44, 0.5, 0.565]), + SlateGrey: fromRgb([0.44, 0.5, 0.565]), + Snow: fromRgb([1, 0.98, 0.98]), + SpringGreen: fromRgb([0, 1, 0.498]), + SteelBlue: fromRgb([0.275, 0.51, 0.705]), + Tan: fromRgb([0.824, 0.705, 0.55]), + Teal: fromRgb([0, 0.5, 0.5]), + Thistle: fromRgb([0.848, 0.75, 0.848]), + Tomato: fromRgb([1, 0.39, 0.28]), + Turquoise: fromRgb([0.25, 0.88, 0.815]), + Violet: fromRgb([0.932, 0.51, 0.932]), + VioletRed: fromRgb([0.816, 0.125, 0.565]), + Wheat: fromRgb([0.96, 0.87, 0.7]), + White: fromRgb([1, 1, 1]), + WhiteSmoke: fromRgb([0.96, 0.96, 0.96]), + Yellow: fromRgb([1, 1, 0]), + YellowGreen: fromRgb([0.604, 0.804, 0.196]) +}; +var X11_NAMES = { + AntiqueWhite1: fromRgb([1, 0.936, 0.86]), + AntiqueWhite2: fromRgb([0.932, 0.875, 0.8]), + AntiqueWhite3: fromRgb([0.804, 0.752, 0.69]), + AntiqueWhite4: fromRgb([0.545, 0.512, 0.47]), + Aquamarine1: fromRgb([0.498, 1, 0.83]), + Aquamarine2: fromRgb([0.464, 0.932, 0.776]), + Aquamarine3: fromRgb([0.4, 0.804, 0.668]), + Aquamarine4: fromRgb([0.27, 0.545, 0.455]), + Azure1: fromRgb([0.94, 1, 1]), + Azure2: fromRgb([0.88, 0.932, 0.932]), + Azure3: fromRgb([0.756, 0.804, 0.804]), + Azure4: fromRgb([0.512, 0.545, 0.545]), + Bisque1: fromRgb([1, 0.894, 0.77]), + Bisque2: fromRgb([0.932, 0.835, 0.716]), + Bisque3: fromRgb([0.804, 0.716, 0.62]), + Bisque4: fromRgb([0.545, 0.49, 0.42]), + Blue1: fromRgb([0, 0, 1]), + Blue2: fromRgb([0, 0, 0.932]), + Blue3: fromRgb([0, 0, 0.804]), + Blue4: fromRgb([0, 0, 0.545]), + Brown1: fromRgb([1, 0.25, 0.25]), + Brown2: fromRgb([0.932, 0.23, 0.23]), + Brown3: fromRgb([0.804, 0.2, 0.2]), + Brown4: fromRgb([0.545, 0.136, 0.136]), + Burlywood1: fromRgb([1, 0.828, 0.608]), + Burlywood2: fromRgb([0.932, 0.772, 0.57]), + Burlywood3: fromRgb([0.804, 0.668, 0.49]), + Burlywood4: fromRgb([0.545, 0.45, 0.332]), + CadetBlue1: fromRgb([0.596, 0.96, 1]), + CadetBlue2: fromRgb([0.556, 0.898, 0.932]), + CadetBlue3: fromRgb([0.48, 0.772, 0.804]), + CadetBlue4: fromRgb([0.325, 0.525, 0.545]), + Chartreuse1: fromRgb([0.498, 1, 0]), + Chartreuse2: fromRgb([0.464, 0.932, 0]), + Chartreuse3: fromRgb([0.4, 0.804, 0]), + Chartreuse4: fromRgb([0.27, 0.545, 0]), + Chocolate1: fromRgb([1, 0.498, 0.14]), + Chocolate2: fromRgb([0.932, 0.464, 0.13]), + Chocolate3: fromRgb([0.804, 0.4, 0.112]), + Chocolate4: fromRgb([0.545, 0.27, 0.075]), + Coral1: fromRgb([1, 0.448, 0.336]), + Coral2: fromRgb([0.932, 0.415, 0.312]), + Coral3: fromRgb([0.804, 0.356, 0.27]), + Coral4: fromRgb([0.545, 0.244, 0.185]), + Cornsilk1: fromRgb([1, 0.972, 0.864]), + Cornsilk2: fromRgb([0.932, 0.91, 0.804]), + Cornsilk3: fromRgb([0.804, 0.785, 0.694]), + Cornsilk4: fromRgb([0.545, 0.532, 0.47]), + Cyan1: fromRgb([0, 1, 1]), + Cyan2: fromRgb([0, 0.932, 0.932]), + Cyan3: fromRgb([0, 0.804, 0.804]), + Cyan4: fromRgb([0, 0.545, 0.545]), + DarkGoldenrod1: fromRgb([1, 0.725, 0.06]), + DarkGoldenrod2: fromRgb([0.932, 0.68, 0.055]), + DarkGoldenrod3: fromRgb([0.804, 0.585, 0.048]), + DarkGoldenrod4: fromRgb([0.545, 0.396, 0.03]), + DarkOliveGreen1: fromRgb([0.792, 1, 0.44]), + DarkOliveGreen2: fromRgb([0.736, 0.932, 0.408]), + DarkOliveGreen3: fromRgb([0.635, 0.804, 0.352]), + DarkOliveGreen4: fromRgb([0.43, 0.545, 0.24]), + DarkOrange1: fromRgb([1, 0.498, 0]), + DarkOrange2: fromRgb([0.932, 0.464, 0]), + DarkOrange3: fromRgb([0.804, 0.4, 0]), + DarkOrange4: fromRgb([0.545, 0.27, 0]), + DarkOrchid1: fromRgb([0.75, 0.244, 1]), + DarkOrchid2: fromRgb([0.698, 0.228, 0.932]), + DarkOrchid3: fromRgb([0.604, 0.196, 0.804]), + DarkOrchid4: fromRgb([0.408, 0.132, 0.545]), + DarkSeaGreen1: fromRgb([0.756, 1, 0.756]), + DarkSeaGreen2: fromRgb([0.705, 0.932, 0.705]), + DarkSeaGreen3: fromRgb([0.608, 0.804, 0.608]), + DarkSeaGreen4: fromRgb([0.41, 0.545, 0.41]), + DarkSlateGray1: fromRgb([0.592, 1, 1]), + DarkSlateGray2: fromRgb([0.552, 0.932, 0.932]), + DarkSlateGray3: fromRgb([0.475, 0.804, 0.804]), + DarkSlateGray4: fromRgb([0.32, 0.545, 0.545]), + DeepPink1: fromRgb([1, 0.08, 0.576]), + DeepPink2: fromRgb([0.932, 0.07, 0.536]), + DeepPink3: fromRgb([0.804, 0.064, 0.464]), + DeepPink4: fromRgb([0.545, 0.04, 0.312]), + DeepSkyBlue1: fromRgb([0, 0.75, 1]), + DeepSkyBlue2: fromRgb([0, 0.698, 0.932]), + DeepSkyBlue3: fromRgb([0, 0.604, 0.804]), + DeepSkyBlue4: fromRgb([0, 0.408, 0.545]), + DodgerBlue1: fromRgb([0.116, 0.565, 1]), + DodgerBlue2: fromRgb([0.11, 0.525, 0.932]), + DodgerBlue3: fromRgb([0.094, 0.455, 0.804]), + DodgerBlue4: fromRgb([0.064, 0.305, 0.545]), + Firebrick1: fromRgb([1, 0.19, 0.19]), + Firebrick2: fromRgb([0.932, 0.172, 0.172]), + Firebrick3: fromRgb([0.804, 0.15, 0.15]), + Firebrick4: fromRgb([0.545, 0.1, 0.1]), + Gold1: fromRgb([1, 0.844, 0]), + Gold2: fromRgb([0.932, 0.79, 0]), + Gold3: fromRgb([0.804, 0.68, 0]), + Gold4: fromRgb([0.545, 0.46, 0]), + Goldenrod1: fromRgb([1, 0.756, 0.145]), + Goldenrod2: fromRgb([0.932, 0.705, 0.132]), + Goldenrod3: fromRgb([0.804, 0.608, 0.112]), + Goldenrod4: fromRgb([0.545, 0.41, 0.08]), + Green1: fromRgb([0, 1, 0]), + Green2: fromRgb([0, 0.932, 0]), + Green3: fromRgb([0, 0.804, 0]), + Green4: fromRgb([0, 0.545, 0]), + Honeydew1: fromRgb([0.94, 1, 0.94]), + Honeydew2: fromRgb([0.88, 0.932, 0.88]), + Honeydew3: fromRgb([0.756, 0.804, 0.756]), + Honeydew4: fromRgb([0.512, 0.545, 0.512]), + HotPink1: fromRgb([1, 0.43, 0.705]), + HotPink2: fromRgb([0.932, 0.415, 0.655]), + HotPink3: fromRgb([0.804, 0.376, 0.565]), + HotPink4: fromRgb([0.545, 0.228, 0.385]), + IndianRed1: fromRgb([1, 0.415, 0.415]), + IndianRed2: fromRgb([0.932, 0.39, 0.39]), + IndianRed3: fromRgb([0.804, 0.332, 0.332]), + IndianRed4: fromRgb([0.545, 0.228, 0.228]), + Ivory1: fromRgb([1, 1, 0.94]), + Ivory2: fromRgb([0.932, 0.932, 0.88]), + Ivory3: fromRgb([0.804, 0.804, 0.756]), + Ivory4: fromRgb([0.545, 0.545, 0.512]), + Khaki1: fromRgb([1, 0.965, 0.56]), + Khaki2: fromRgb([0.932, 0.9, 0.52]), + Khaki3: fromRgb([0.804, 0.776, 0.45]), + Khaki4: fromRgb([0.545, 0.525, 0.305]), + LavenderBlush1: fromRgb([1, 0.94, 0.96]), + LavenderBlush2: fromRgb([0.932, 0.88, 0.898]), + LavenderBlush3: fromRgb([0.804, 0.756, 0.772]), + LavenderBlush4: fromRgb([0.545, 0.512, 0.525]), + LemonChiffon1: fromRgb([1, 0.98, 0.804]), + LemonChiffon2: fromRgb([0.932, 0.912, 0.75]), + LemonChiffon3: fromRgb([0.804, 0.79, 0.648]), + LemonChiffon4: fromRgb([0.545, 0.536, 0.44]), + LightBlue1: fromRgb([0.75, 0.936, 1]), + LightBlue2: fromRgb([0.698, 0.875, 0.932]), + LightBlue3: fromRgb([0.604, 0.752, 0.804]), + LightBlue4: fromRgb([0.408, 0.512, 0.545]), + LightCyan1: fromRgb([0.88, 1, 1]), + LightCyan2: fromRgb([0.82, 0.932, 0.932]), + LightCyan3: fromRgb([0.705, 0.804, 0.804]), + LightCyan4: fromRgb([0.48, 0.545, 0.545]), + LightGoldenrod1: fromRgb([1, 0.925, 0.545]), + LightGoldenrod2: fromRgb([0.932, 0.864, 0.51]), + LightGoldenrod3: fromRgb([0.804, 0.745, 0.44]), + LightGoldenrod4: fromRgb([0.545, 0.505, 0.298]), + LightPink1: fromRgb([1, 0.684, 0.725]), + LightPink2: fromRgb([0.932, 0.635, 0.68]), + LightPink3: fromRgb([0.804, 0.55, 0.585]), + LightPink4: fromRgb([0.545, 0.372, 0.396]), + LightSalmon1: fromRgb([1, 0.628, 0.48]), + LightSalmon2: fromRgb([0.932, 0.585, 0.448]), + LightSalmon3: fromRgb([0.804, 0.505, 0.385]), + LightSalmon4: fromRgb([0.545, 0.34, 0.26]), + LightSkyBlue1: fromRgb([0.69, 0.888, 1]), + LightSkyBlue2: fromRgb([0.644, 0.828, 0.932]), + LightSkyBlue3: fromRgb([0.552, 0.712, 0.804]), + LightSkyBlue4: fromRgb([0.376, 0.484, 0.545]), + LightSteelBlue1: fromRgb([0.792, 0.884, 1]), + LightSteelBlue2: fromRgb([0.736, 0.824, 0.932]), + LightSteelBlue3: fromRgb([0.635, 0.71, 0.804]), + LightSteelBlue4: fromRgb([0.43, 0.484, 0.545]), + LightYellow1: fromRgb([1, 1, 0.88]), + LightYellow2: fromRgb([0.932, 0.932, 0.82]), + LightYellow3: fromRgb([0.804, 0.804, 0.705]), + LightYellow4: fromRgb([0.545, 0.545, 0.48]), + Magenta1: fromRgb([1, 0, 1]), + Magenta2: fromRgb([0.932, 0, 0.932]), + Magenta3: fromRgb([0.804, 0, 0.804]), + Magenta4: fromRgb([0.545, 0, 0.545]), + Maroon1: fromRgb([1, 0.204, 0.7]), + Maroon2: fromRgb([0.932, 0.19, 0.655]), + Maroon3: fromRgb([0.804, 0.16, 0.565]), + Maroon4: fromRgb([0.545, 0.11, 0.385]), + MediumOrchid1: fromRgb([0.88, 0.4, 1]), + MediumOrchid2: fromRgb([0.82, 0.372, 0.932]), + MediumOrchid3: fromRgb([0.705, 0.32, 0.804]), + MediumOrchid4: fromRgb([0.48, 0.215, 0.545]), + MediumPurple1: fromRgb([0.67, 0.51, 1]), + MediumPurple2: fromRgb([0.624, 0.475, 0.932]), + MediumPurple3: fromRgb([0.536, 0.408, 0.804]), + MediumPurple4: fromRgb([0.365, 0.28, 0.545]), + MistyRose1: fromRgb([1, 0.894, 0.884]), + MistyRose2: fromRgb([0.932, 0.835, 0.824]), + MistyRose3: fromRgb([0.804, 0.716, 0.71]), + MistyRose4: fromRgb([0.545, 0.49, 0.484]), + NavajoWhite1: fromRgb([1, 0.87, 0.68]), + NavajoWhite2: fromRgb([0.932, 0.81, 0.63]), + NavajoWhite3: fromRgb([0.804, 0.7, 0.545]), + NavajoWhite4: fromRgb([0.545, 0.475, 0.37]), + OliveDrab1: fromRgb([0.752, 1, 0.244]), + OliveDrab2: fromRgb([0.7, 0.932, 0.228]), + OliveDrab3: fromRgb([0.604, 0.804, 0.196]), + OliveDrab4: fromRgb([0.41, 0.545, 0.132]), + Orange1: fromRgb([1, 0.648, 0]), + Orange2: fromRgb([0.932, 0.604, 0]), + Orange3: fromRgb([0.804, 0.52, 0]), + Orange4: fromRgb([0.545, 0.352, 0]), + OrangeRed1: fromRgb([1, 0.27, 0]), + OrangeRed2: fromRgb([0.932, 0.25, 0]), + OrangeRed3: fromRgb([0.804, 0.215, 0]), + OrangeRed4: fromRgb([0.545, 0.145, 0]), + Orchid1: fromRgb([1, 0.512, 0.98]), + Orchid2: fromRgb([0.932, 0.48, 0.912]), + Orchid3: fromRgb([0.804, 0.41, 0.79]), + Orchid4: fromRgb([0.545, 0.28, 0.536]), + PaleGreen1: fromRgb([0.604, 1, 0.604]), + PaleGreen2: fromRgb([0.565, 0.932, 0.565]), + PaleGreen3: fromRgb([0.488, 0.804, 0.488]), + PaleGreen4: fromRgb([0.33, 0.545, 0.33]), + PaleTurquoise1: fromRgb([0.732, 1, 1]), + PaleTurquoise2: fromRgb([0.684, 0.932, 0.932]), + PaleTurquoise3: fromRgb([0.59, 0.804, 0.804]), + PaleTurquoise4: fromRgb([0.4, 0.545, 0.545]), + PaleVioletRed1: fromRgb([1, 0.51, 0.67]), + PaleVioletRed2: fromRgb([0.932, 0.475, 0.624]), + PaleVioletRed3: fromRgb([0.804, 0.408, 0.536]), + PaleVioletRed4: fromRgb([0.545, 0.28, 0.365]), + PeachPuff1: fromRgb([1, 0.855, 0.725]), + PeachPuff2: fromRgb([0.932, 0.796, 0.68]), + PeachPuff3: fromRgb([0.804, 0.688, 0.585]), + PeachPuff4: fromRgb([0.545, 0.468, 0.396]), + Pink1: fromRgb([1, 0.71, 0.772]), + Pink2: fromRgb([0.932, 0.664, 0.72]), + Pink3: fromRgb([0.804, 0.57, 0.62]), + Pink4: fromRgb([0.545, 0.39, 0.424]), + Plum1: fromRgb([1, 0.732, 1]), + Plum2: fromRgb([0.932, 0.684, 0.932]), + Plum3: fromRgb([0.804, 0.59, 0.804]), + Plum4: fromRgb([0.545, 0.4, 0.545]), + Purple1: fromRgb([0.608, 0.19, 1]), + Purple2: fromRgb([0.57, 0.172, 0.932]), + Purple3: fromRgb([0.49, 0.15, 0.804]), + Purple4: fromRgb([0.332, 0.1, 0.545]), + Red1: fromRgb([1, 0, 0]), + Red2: fromRgb([0.932, 0, 0]), + Red3: fromRgb([0.804, 0, 0]), + Red4: fromRgb([0.545, 0, 0]), + RosyBrown1: fromRgb([1, 0.756, 0.756]), + RosyBrown2: fromRgb([0.932, 0.705, 0.705]), + RosyBrown3: fromRgb([0.804, 0.608, 0.608]), + RosyBrown4: fromRgb([0.545, 0.41, 0.41]), + RoyalBlue1: fromRgb([0.284, 0.464, 1]), + RoyalBlue2: fromRgb([0.264, 0.43, 0.932]), + RoyalBlue3: fromRgb([0.228, 0.372, 0.804]), + RoyalBlue4: fromRgb([0.152, 0.25, 0.545]), + Salmon1: fromRgb([1, 0.55, 0.41]), + Salmon2: fromRgb([0.932, 0.51, 0.385]), + Salmon3: fromRgb([0.804, 0.44, 0.33]), + Salmon4: fromRgb([0.545, 0.298, 0.224]), + SeaGreen1: fromRgb([0.33, 1, 0.624]), + SeaGreen2: fromRgb([0.305, 0.932, 0.58]), + SeaGreen3: fromRgb([0.264, 0.804, 0.5]), + SeaGreen4: fromRgb([0.18, 0.545, 0.34]), + Seashell1: fromRgb([1, 0.96, 0.932]), + Seashell2: fromRgb([0.932, 0.898, 0.87]), + Seashell3: fromRgb([0.804, 0.772, 0.75]), + Seashell4: fromRgb([0.545, 0.525, 0.51]), + Sienna1: fromRgb([1, 0.51, 0.28]), + Sienna2: fromRgb([0.932, 0.475, 0.26]), + Sienna3: fromRgb([0.804, 0.408, 0.224]), + Sienna4: fromRgb([0.545, 0.28, 0.15]), + SkyBlue1: fromRgb([0.53, 0.808, 1]), + SkyBlue2: fromRgb([0.494, 0.752, 0.932]), + SkyBlue3: fromRgb([0.424, 0.65, 0.804]), + SkyBlue4: fromRgb([0.29, 0.44, 0.545]), + SlateBlue1: fromRgb([0.512, 0.435, 1]), + SlateBlue2: fromRgb([0.48, 0.404, 0.932]), + SlateBlue3: fromRgb([0.41, 0.35, 0.804]), + SlateBlue4: fromRgb([0.28, 0.235, 0.545]), + SlateGray1: fromRgb([0.776, 0.888, 1]), + SlateGray2: fromRgb([0.725, 0.828, 0.932]), + SlateGray3: fromRgb([0.624, 0.712, 0.804]), + SlateGray4: fromRgb([0.424, 0.484, 0.545]), + Snow1: fromRgb([1, 0.98, 0.98]), + Snow2: fromRgb([0.932, 0.912, 0.912]), + Snow3: fromRgb([0.804, 0.79, 0.79]), + Snow4: fromRgb([0.545, 0.536, 0.536]), + SpringGreen1: fromRgb([0, 1, 0.498]), + SpringGreen2: fromRgb([0, 0.932, 0.464]), + SpringGreen3: fromRgb([0, 0.804, 0.4]), + SpringGreen4: fromRgb([0, 0.545, 0.27]), + SteelBlue1: fromRgb([0.39, 0.72, 1]), + SteelBlue2: fromRgb([0.36, 0.675, 0.932]), + SteelBlue3: fromRgb([0.31, 0.58, 0.804]), + SteelBlue4: fromRgb([0.21, 0.392, 0.545]), + Tan1: fromRgb([1, 0.648, 0.31]), + Tan2: fromRgb([0.932, 0.604, 0.288]), + Tan3: fromRgb([0.804, 0.52, 0.248]), + Tan4: fromRgb([0.545, 0.352, 0.17]), + Thistle1: fromRgb([1, 0.884, 1]), + Thistle2: fromRgb([0.932, 0.824, 0.932]), + Thistle3: fromRgb([0.804, 0.71, 0.804]), + Thistle4: fromRgb([0.545, 0.484, 0.545]), + Tomato1: fromRgb([1, 0.39, 0.28]), + Tomato2: fromRgb([0.932, 0.36, 0.26]), + Tomato3: fromRgb([0.804, 0.31, 0.224]), + Tomato4: fromRgb([0.545, 0.21, 0.15]), + Turquoise1: fromRgb([0, 0.96, 1]), + Turquoise2: fromRgb([0, 0.898, 0.932]), + Turquoise3: fromRgb([0, 0.772, 0.804]), + Turquoise4: fromRgb([0, 0.525, 0.545]), + VioletRed1: fromRgb([1, 0.244, 0.59]), + VioletRed2: fromRgb([0.932, 0.228, 0.55]), + VioletRed3: fromRgb([0.804, 0.196, 0.47]), + VioletRed4: fromRgb([0.545, 0.132, 0.32]), + Wheat1: fromRgb([1, 0.905, 0.73]), + Wheat2: fromRgb([0.932, 0.848, 0.684]), + Wheat3: fromRgb([0.804, 0.73, 0.59]), + Wheat4: fromRgb([0.545, 0.494, 0.4]), + Yellow1: fromRgb([1, 1, 0]), + Yellow2: fromRgb([0.932, 0.932, 0]), + Yellow3: fromRgb([0.804, 0.804, 0]), + Yellow4: fromRgb([0.545, 0.545, 0]), + Gray0: fromRgb([0.745, 0.745, 0.745]), + Green0: fromRgb([0, 1, 0]), + Grey0: fromRgb([0.745, 0.745, 0.745]), + Maroon0: fromRgb([0.69, 0.19, 0.376]), + Purple0: fromRgb([0.628, 0.125, 0.94]) +}; +var XColorCoreModelToColor = { + rgb: ([r, g, b]) => (0, import_color.default)([r * 255, g * 255, b * 255], "rgb"), + cmy: ([c, m, y]) => XColorCoreModelToColor.rgb([1 - c, 1 - m, 1 - y]), + cmyk: ([c, m, y, k]) => (0, import_color.default)([c * 255, m * 255, y * 255, k * 100], "cmyk"), + hsb: ([h, s2, b]) => (0, import_color.default)([h * 360, s2 * 100, b * 100], "hsv"), + gray: ([v]) => (0, import_color.default)([v * 255, v * 255, v * 255], "rgb") +}; +var XColorModelToColor = { + wave: ([lambda]) => { + const gamma = 0.8; + let baseRgb = [0, 0, 0]; + if (380 <= lambda && lambda < 440) { + baseRgb = [(440 - lambda) / (440 - 380), 0, 1]; + } + if (440 <= lambda && lambda < 490) { + baseRgb = [0, (lambda - 440) / (490 - 440), 1]; + } + if (490 <= lambda && lambda < 510) { + baseRgb = [0, 1, (510 - lambda) / (510 - 490)]; + } + if (510 <= lambda && lambda < 580) { + baseRgb = [(lambda - 510) / (580 - 510), 1, 0]; + } + if (580 <= lambda && lambda < 6450) { + baseRgb = [1, (645 - lambda) / (645 - 580), 0]; + } + if (645 <= lambda && lambda <= 780) { + baseRgb = [1, 0, 0]; + } + let f = 1; + if (380 <= lambda && 420 < lambda) { + f = 0.3 + 0.7 * (lambda - 380) / (420 - 380); + } + if (700 < lambda && lambda <= 780) { + f = 0.3 + 0.7 * (780 - lambda) / (780 - 700); + } + const rgb = [ + Math.pow(baseRgb[0] * f, gamma), + Math.pow(baseRgb[1] * f, gamma), + Math.pow(baseRgb[2] * f, gamma) + ]; + return (0, import_color.default)([rgb[0] * 255, rgb[1] * 255, rgb[2] * 255], "rgb"); + }, + Hsb: ([h, s2, b]) => XColorCoreModelToColor.hsb([h / 360, s2, b]), + HSB: ([h, s2, b]) => XColorCoreModelToColor.hsb([h / 240, s2 / 240, b / 240]), + HTML: ([v]) => v.startsWith("#") ? (0, import_color.default)(v) : (0, import_color.default)(`#${v}`), + RGB: ([r, g, b]) => (0, import_color.default)([r, g, b], "rgb"), + Gray: ([v]) => XColorCoreModelToColor.gray([v / 15]), + ...XColorCoreModelToColor +}; +var PREDEFINED_XCOLOR_COLORS = { + // Core colors + red: XColorCoreModelToColor.rgb([1, 0, 0]), + green: XColorCoreModelToColor.rgb([0, 1, 0]), + blue: XColorCoreModelToColor.rgb([0, 0, 1]), + brown: XColorCoreModelToColor.rgb([0.75, 0.5, 0.25]), + lime: XColorCoreModelToColor.rgb([0.75, 1, 0]), + orange: XColorCoreModelToColor.rgb([1, 0.5, 0]), + pink: XColorCoreModelToColor.rgb([1, 0.75, 0.75]), + purple: XColorCoreModelToColor.rgb([0.75, 0, 0.25]), + teal: XColorCoreModelToColor.rgb([0, 0.5, 0.5]), + violet: XColorCoreModelToColor.rgb([0.5, 0, 0.5]), + cyan: XColorCoreModelToColor.rgb([0, 1, 1]), + magenta: XColorCoreModelToColor.rgb([1, 0, 1]), + yellow: XColorCoreModelToColor.rgb([1, 1, 0]), + olive: XColorCoreModelToColor.rgb([0.5, 0.5, 0]), + black: XColorCoreModelToColor.rgb([0, 0, 0]), + darkgray: XColorCoreModelToColor.rgb([0.25, 0.25, 0.25]), + gray: XColorCoreModelToColor.rgb([0.5, 0.5, 0.5]), + lightgray: XColorCoreModelToColor.rgb([0.75, 0.75, 0.75]), + white: XColorCoreModelToColor.rgb([1, 1, 1]), + ...DVI_PS_NAMES, + ...SVG_NAMES, + ...X11_NAMES +}; +var macros14 = { + NewDocumentCommand: { + signature: "m m m", + renderInfo: { breakAround: true } + }, + RenewDocumentCommand: { + signature: "m m m", + renderInfo: { breakAround: true } + }, + ProvideDocumentCommand: { + signature: "m m m", + renderInfo: { breakAround: true } + }, + DeclareDocumentCommand: { + signature: "m m m", + renderInfo: { breakAround: true } + }, + NewDocumentEnvironment: { + signature: "m m m m", + renderInfo: { breakAround: true } + }, + RenewDocumentEnvironment: { + signature: "m m m m", + renderInfo: { breakAround: true } + }, + ProvideDocumentEnvironment: { + signature: "m m m m", + renderInfo: { breakAround: true } + }, + DeclareDocumentEnvironment: { + signature: "m m m m", + renderInfo: { breakAround: true } + }, + NewExpandableDocumentCommand: { + signature: "m m m", + renderInfo: { breakAround: true } + }, + RenewExpandableDocumentCommand: { + signature: "m m m", + renderInfo: { breakAround: true } + }, + ProvideExpandableDocumentCommand: { + signature: "m m m", + renderInfo: { breakAround: true } + }, + DeclareExpandableDocumentCommand: { + signature: "m m m", + renderInfo: { breakAround: true } + }, + RequirePackage: { + signature: "o m", + renderInfo: { pgfkeysArgs: true, breakAround: true } + }, + DeclareOption: { signature: "m m", renderInfo: { breakAround: true } } +}; +var environments14 = {}; +var macros15 = { + mode: { signature: "s d<> d{}", renderInfo: { breakAround: true } }, + insertnavigation: { signature: "m", renderInfo: { breakAround: true } }, + insertsectionnavigation: { + signature: "m", + renderInfo: { breakAround: true } + }, + insertsectionnavigationhorizontal: { + signature: "m m m", + renderInfo: { breakAround: true } + }, + insertauthor: { signature: "o", renderInfo: { breakAround: true } }, + insertshortauthor: { signature: "o", renderInfo: { breakAround: true } }, + insertshortdate: { signature: "o", renderInfo: { breakAround: true } }, + insertshortinstitute: { signature: "o", renderInfo: { breakAround: true } }, + insertshortpart: { signature: "o", renderInfo: { breakAround: true } }, + insertshorttitle: { signature: "o", renderInfo: { breakAround: true } }, + insertsubsectionnavigation: { + signature: "m", + renderInfo: { breakAround: true } + }, + insertsubsectionnavigationhorizontal: { + signature: "m m m", + renderInfo: { breakAround: true } + }, + insertverticalnavigation: { + signature: "m", + renderInfo: { breakAround: true } + }, + usebeamercolor: { signature: "s m", renderInfo: { breakAround: true } }, + usebeamertemplate: { signature: "s m", renderInfo: { breakAround: true } }, + setbeamercolor: { + signature: "m m", + renderInfo: { breakAround: true, pgfkeysArgs: true } + }, + setbeamersize: { + signature: "m o o", + renderInfo: { breakAround: true, pgfkeysArgs: true } + }, + setbeamertemplate: { + signature: "m o o d{}", + renderInfo: { breakAround: true, pgfkeysArgs: true } + }, + newcommand: { + signature: "s d<> +m o +o +m", + renderInfo: { + breakAround: true, + namedArguments: [ + "starred", + null, + "name", + "numArgs", + "default", + "body" + ] + } + }, + renewcommand: { + signature: "s d<> +m o +o +m", + renderInfo: { + breakAround: true, + namedArguments: [ + "starred", + null, + "name", + "numArgs", + "default", + "body" + ] + } + }, + newenvironment: { + signature: "s d<> m o o m m", + renderInfo: { breakAround: true } + }, + renewenvironment: { + signature: "s d<> m o o m m", + renderInfo: { breakAround: true } + }, + resetcounteronoverlays: { + signature: "m", + renderInfo: { breakAround: true } + }, + resetcountonoverlays: { signature: "m", renderInfo: { breakAround: true } }, + logo: { signature: "m", renderInfo: { breakAround: true } }, + frametitle: { signature: "d<> o m", renderInfo: { breakAround: true } }, + framesubtitle: { signature: "d<> m", renderInfo: { breakAround: true } }, + pause: { signature: "o" }, + onslide: { signature: "t+ t* d<> d{}" }, + only: { signature: "d<> m d<>" }, + uncover: { signature: "d<> m" }, + visible: { signature: "d<> m" }, + invisible: { signature: "d<> m" }, + alt: { signature: "d<> m m d<>" }, + temporal: { signature: "r<> m m m" }, + item: { + signature: "d<> o d<>", + renderInfo: { + hangingIndent: true, + namedArguments: [null, "label", null] + } + }, + label: { signature: "d<> o m" }, + // cleveref adds an optional argument to label; this gives maximum compatibility. + action: { signature: "d<> m" }, + beamerdefaultoverlayspecification: { signature: "m" }, + titlegraphic: { signature: "m", renderInfo: { breakAround: true } }, + subject: { signature: "m", renderInfo: { breakAround: true } }, + keywords: { signature: "m", renderInfo: { breakAround: true } }, + lecture: { signature: "o m m", renderInfo: { breakAround: true } }, + partpage: { renderInfo: { breakAround: true } }, + sectionpage: { renderInfo: { breakAround: true } }, + subsectionpage: { renderInfo: { breakAround: true } }, + AtBeginLecture: { signature: "m", renderInfo: { breakAround: true } }, + AtBeginPart: { signature: "m", renderInfo: { breakAround: true } }, + tableofcontents: { + signature: "o", + renderInfo: { breakAround: true, pgfkeysArgs: true } + }, + againframe: { signature: "d<> o o m", renderInfo: { breakAround: true } }, + framezoom: { + signature: "r<> r<> o r() r()", + renderInfo: { breakAround: true } + }, + column: { signature: "d<> o m", renderInfo: { breakAround: true } }, + animate: { signature: "r<>", renderInfo: { breakAround: true } }, + animatevalue: { signature: "r<> m m m", renderInfo: { breakAround: true } }, + sound: { + signature: "o m m", + renderInfo: { breakAround: true, pgfkeysArgs: true } + }, + hyperlinksound: { + signature: "o m m", + renderInfo: { breakAround: true, pgfkeysArgs: true } + }, + hyperlinkmute: { signature: "m", renderInfo: { breakAround: true } }, + // These signatures conflict with the default signatures. + // Care must be taken when processing an AST. + section: { + signature: "s d<> o m", + renderInfo: { + breakAround: true, + namedArguments: ["starred", null, "tocTitle", "title"] + } + }, + subsection: { + signature: "s d<> o m", + renderInfo: { + breakAround: true, + namedArguments: ["starred", null, "tocTitle", "title"] + } + }, + subsubsection: { + signature: "s d<> o m", + renderInfo: { + breakAround: true, + namedArguments: ["starred", null, "tocTitle", "title"] + } + }, + part: { + signature: "s d<> o m", + renderInfo: { + breakAround: true, + namedArguments: ["starred", null, "tocTitle", "title"] + } + }, + bibitem: { + signature: "s d<> o m", + renderInfo: { + hangingIndent: true, + namedArguments: ["starred", null, "tocTitle", "title"] + } + } +}; +var environments15 = { + frame: { + signature: "!d<> !o !o !d{} !d{}" + }, + block: { + signature: "!d<> !d{} !d<>" + }, + alertblock: { + signature: "!d<> !d{} !d<>" + }, + exampleblock: { + signature: "!d<> !d{} !d<>" + }, + onlyenv: { + signature: "!d<>" + }, + altenv: { + signature: "!d<> m m m m !d<>" + }, + overlayarea: { signature: "m m" }, + overprint: { signature: "o" }, + actionenv: { signature: "!d<>" }, + columns: { signature: "d<> o" }, + column: { signature: "d<> o m" } +}; +var macros16 = { + columnbreak: { renderInfo: { breakAround: true } } +}; +var environments16 = { + multicols: { + signature: "m o o" + }, + "multicols*": { + signature: "m o o" + } +}; +var macroInfo = { + cleveref: macros, + exam: macros2, + geometry: macros3, + hyperref: macros4, + latex2e: macros5, + listings: macros6, + makeidx: macros7, + mathtools: macros8, + minted: macros9, + nicematrix: macros10, + systeme: macros11, + tikz: macros12, + xcolor: macros13, + xparse: macros14, + beamer: macros15, + multicol: macros16 +}; +var environmentInfo = { + cleveref: environments, + exam: environments2, + geometry: environments3, + hyperref: environments4, + latex2e: environments5, + listings: environments6, + makeidx: environments7, + mathtools: environments8, + minted: environments9, + nicematrix: environments10, + systeme: environments11, + tikz: environments12, + xcolor: environments13, + xparse: environments14, + beamer: environments15, + multicol: environments16 +}; + +// ../unified-latex-util-environments/dist/index.js +function processEnvironment(envNode, envInfo) { + if (envInfo.signature && envNode.args == null) { + const { args } = gobbleArguments(envNode.content, envInfo.signature); + envNode.args = args; + } + updateRenderInfo(envNode, envInfo.renderInfo); + if (typeof envInfo.processContent === "function") { + envNode.content = envInfo.processContent(envNode.content); + } +} + +// ../unified-latex-util-catcode/dist/index.js +function findRegionInArray(tree, start, end) { + const ret = []; + let currRegion = { start: void 0, end: tree.length }; + for (let i = 0; i < tree.length; i++) { + const node = tree[i]; + if (start(node)) { + currRegion.start = i; + } + if (end(node)) { + currRegion.end = i + 1; + ret.push(currRegion); + currRegion = { start: void 0, end: tree.length }; + } + } + if (currRegion.start != null) { + ret.push(currRegion); + } + return ret; +} +function refineRegions(regions) { + const _regions = [...regions]; + _regions.sort((a, b) => a.start - b.start); + const cutPointsSet = new Set(_regions.flatMap((r) => [r.start, r.end])); + const cutPoints = Array.from(cutPointsSet); + cutPoints.sort((a, b) => a - b); + const retRegions = []; + const retRegionsContainedIn = []; + let seekIndex = 0; + for (let i = 0; i < cutPoints.length - 1; i++) { + const start = cutPoints[i]; + const end = cutPoints[i + 1]; + const region = { start, end }; + const regionContainedIn = /* @__PURE__ */ new Set(); + let encounteredEndPastStart = false; + for (let j = seekIndex; j < _regions.length; j++) { + const superRegion = _regions[j]; + if (superRegion.end >= region.start) { + encounteredEndPastStart = true; + } + if (!encounteredEndPastStart && superRegion.end < region.start) { + seekIndex = j + 1; + continue; + } + if (superRegion.start > end) { + break; + } + if (superRegion.start <= region.start && superRegion.end >= region.end) { + encounteredEndPastStart = true; + regionContainedIn.add(superRegion); + } + } + if (regionContainedIn.size > 0) { + retRegions.push(region); + retRegionsContainedIn.push(regionContainedIn); + } + } + return { regions: retRegions, regionsContainedIn: retRegionsContainedIn }; +} +function splitByRegions(array, regionsRecord) { + const ret = []; + const indices = [0, array.length]; + const reverseMap = {}; + for (const [key, records] of Object.entries(regionsRecord)) { + indices.push( + ...records.flatMap((r) => { + reverseMap["" + [r.start, r.end]] = key; + return [r.start, r.end]; + }) + ); + } + indices.sort((a, b) => a - b); + for (let i = 0; i < indices.length - 1; i++) { + const start = indices[i]; + const end = indices[i + 1]; + if (start === end) { + continue; + } + const regionKey = reverseMap["" + [start, end]]; + ret.push([regionKey || null, array.slice(start, end)]); + } + return ret; +} +function escapeRegExp(str) { + return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"); +} +function buildWordRegex(allowedSet) { + const regexpStr = `^(${["\\p{L}"].concat(Array.from(allowedSet).map(escapeRegExp)).join("|")})*`; + return new RegExp(regexpStr, "u"); +} +function hasReparsableMacroNamesInArray(tree, allowedTokens) { + for (let i = 0; i < tree.length; i++) { + const macro2 = tree[i]; + const string2 = tree[i + 1]; + if (match.anyMacro(macro2) && match.anyString(string2)) { + if (allowedTokens.has( + macro2.content.charAt(macro2.content.length - 1) + ) || allowedTokens.has(string2.content.charAt(0))) { + return true; + } + } + } + return false; +} +function hasReparsableMacroNames(tree, allowedTokens) { + if (typeof allowedTokens === "string") { + allowedTokens = new Set(allowedTokens.split("")); + } + const _allowedTokens = allowedTokens; + for (const v of _allowedTokens) { + if (v.length > 1) { + throw new Error( + `Only single characters are allowed as \`allowedTokens\` when reparsing macro names, not \`${v}\`.` + ); + } + } + let ret = false; + visit( + tree, + (nodes) => { + if (hasReparsableMacroNamesInArray(nodes, _allowedTokens)) { + ret = true; + return EXIT; + } + }, + { includeArrays: true, test: Array.isArray } + ); + return ret; +} +function reparseMacroNamesInArray(tree, allowedTokens) { + var _a, _b, _c; + const regex = buildWordRegex(allowedTokens); + let i = 0; + while (i < tree.length) { + const macro2 = tree[i]; + const string2 = tree[i + 1]; + if (match.anyMacro(macro2) && // The _^ macros in math mode should not be extended no-matter what; + // So we check to make sure that the macro we're dealing with has the default escape token. + (macro2.escapeToken == null || macro2.escapeToken === "\\") && match.anyString(string2) && // There are two options. Either the macro ends with the special character, + // e.g. `\@foo` or the special character starts the next string, e.g. `\foo@`. + (allowedTokens.has( + macro2.content.charAt(macro2.content.length - 1) + ) || allowedTokens.has(string2.content.charAt(0)))) { + const match3 = string2.content.match(regex); + const takeable = match3 ? match3[0] : ""; + if (takeable.length > 0) { + if (takeable.length === string2.content.length) { + macro2.content += string2.content; + tree.splice(i + 1, 1); + if (macro2.position && ((_a = string2.position) == null ? void 0 : _a.end)) { + macro2.position.end = string2.position.end; + } + } else { + macro2.content += takeable; + string2.content = string2.content.slice(takeable.length); + if ((_b = macro2.position) == null ? void 0 : _b.end) { + macro2.position.end.offset += takeable.length; + macro2.position.end.column += takeable.length; + } + if ((_c = string2.position) == null ? void 0 : _c.start) { + string2.position.start.offset += takeable.length; + string2.position.start.column += takeable.length; + } + } + } else { + i++; + } + } else { + ++i; + } + } +} +function reparseMacroNames(tree, allowedTokens) { + if (typeof allowedTokens === "string") { + allowedTokens = new Set(allowedTokens.split("")); + } + const _allowedTokens = allowedTokens; + for (const v of _allowedTokens) { + if (v.length > 1) { + throw new Error( + `Only single characters are allowed as \`allowedTokens\` when reparsing macro names, not \`${v}\`.` + ); + } + } + visit( + tree, + (nodes) => { + reparseMacroNamesInArray(nodes, _allowedTokens); + }, + { includeArrays: true, test: Array.isArray } + ); +} +var expl3Find = { + start: match.createMacroMatcher(["ExplSyntaxOn"]), + end: match.createMacroMatcher(["ExplSyntaxOff"]) +}; +var atLetterFind = { + start: match.createMacroMatcher(["makeatletter"]), + end: match.createMacroMatcher(["makeatother"]) +}; +function findExpl3AndAtLetterRegionsInArray(tree) { + const expl3 = findRegionInArray(tree, expl3Find.start, expl3Find.end); + const atLetter = findRegionInArray( + tree, + atLetterFind.start, + atLetterFind.end + ); + const regionMap = new Map([ + ...expl3.map((x) => [x, "expl"]), + ...atLetter.map((x) => [x, "atLetter"]) + ]); + const all = refineRegions([...expl3, ...atLetter]); + const ret = { + explOnly: [], + atLetterOnly: [], + both: [] + }; + for (let i = 0; i < all.regions.length; i++) { + const region = all.regions[i]; + const containedIn = all.regionsContainedIn[i]; + if (containedIn.size === 2) { + ret.both.push(region); + continue; + } + for (const v of containedIn.values()) { + if (regionMap.get(v) === "expl") { + ret.explOnly.push(region); + } + if (regionMap.get(v) === "atLetter") { + ret.atLetterOnly.push(region); + } + } + } + ret.explOnly = ret.explOnly.filter((r) => r.end - r.start > 1); + ret.atLetterOnly = ret.atLetterOnly.filter((r) => r.end - r.start > 1); + ret.both = ret.both.filter((r) => r.end - r.start > 1); + return ret; +} +var atLetterSet = /* @__PURE__ */ new Set(["@"]); +var explSet = /* @__PURE__ */ new Set(["_", ":"]); +var bothSet = /* @__PURE__ */ new Set(["_", ":", "@"]); +function reparseExpl3AndAtLetterRegions(tree) { + visit( + tree, + { + leave: (nodes) => { + const regions = findExpl3AndAtLetterRegionsInArray(nodes); + const totalNumRegions = regions.both.length + regions.atLetterOnly.length + regions.explOnly.length; + if (totalNumRegions === 0) { + return; + } + const splits = splitByRegions(nodes, regions); + const processed = []; + for (const [key, slice] of splits) { + switch (key) { + case null: + processed.push(...slice); + continue; + case "atLetterOnly": + reparseMacroNames(slice, atLetterSet); + processed.push(...slice); + continue; + case "explOnly": + reparseMacroNames(slice, explSet); + processed.push(...slice); + continue; + case "both": + reparseMacroNames(slice, bothSet); + processed.push(...slice); + continue; + default: + throw new Error( + `Unexpected case when splitting ${key}` + ); + } + } + nodes.length = 0; + nodes.push(...processed); + return SKIP; + } + }, + { includeArrays: true, test: Array.isArray } + ); +} + +// ../unified-latex-util-parse/dist/index.js +var unifiedLatexAstComplier = function unifiedLatexAstComplier2() { + Object.assign(this, { Compiler: (x) => x }); +}; +function parseMinimal(str) { + return LatexPegParser.parse(str); +} +function parseMathMinimal(str) { + return LatexPegParser.parse(str, { startRule: "math" }); +} +var unifiedLatexFromStringMinimal = function unifiedLatexFromStringMinimal2(options) { + const parser2 = (str) => { + if ((options == null ? void 0 : options.mode) === "math") { + return { + type: "root", + content: parseMathMinimal(str), + _renderInfo: { inMathMode: true } + }; + } + return parseMinimal(str); + }; + Object.assign(this, { Parser: parser2 }); +}; +function unifiedLatexReparseMathConstructPlugin({ + mathEnvs, + mathMacros +}) { + const isMathEnvironment = match.createEnvironmentMatcher(mathEnvs); + const isMathMacro = match.createMacroMatcher(mathMacros); + return (tree) => { + visit( + tree, + (node) => { + if (match.anyMacro(node)) { + for (const arg2 of node.args || []) { + if (arg2.content.length > 0 && !wasParsedInMathMode(arg2.content)) { + arg2.content = parseMathMinimal( + printRaw(arg2.content) + ); + } + } + } + if (match.anyEnvironment(node)) { + if (!wasParsedInMathMode(node.content)) { + node.content = parseMathMinimal(printRaw(node.content)); + } + } + }, + { + test: (node) => isMathEnvironment(node) || isMathMacro(node) + } + ); + }; +} +function wasParsedInMathMode(nodes) { + return !nodes.some( + (node) => ( + // If there are multi-char strings or ^ and _ have been parsed as strings, we know + // that we were not parsed in math mode. + match.anyString(node) && node.content.length > 1 || match.string(node, "^") || match.string(node, "_") + ) + ); +} +var unifiedLatexProcessMacrosAndEnvironmentsWithMathReparse = function unifiedLatexProcessMacrosAndEnvironmentsWithMathReparse2(options) { + const { environments: environments17 = {}, macros: macros17 = {} } = options || {}; + const mathMacros = Object.fromEntries( + Object.entries(macros17).filter( + ([_, info]) => { + var _a; + return ((_a = info.renderInfo) == null ? void 0 : _a.inMathMode) === true; + } + ) + ); + const mathEnvs = Object.fromEntries( + Object.entries(environments17).filter( + ([_, info]) => { + var _a; + return ((_a = info.renderInfo) == null ? void 0 : _a.inMathMode) === true; + } + ) + ); + const mathReparser = unifiedLatexReparseMathConstructPlugin({ + mathEnvs: Object.keys(mathEnvs), + mathMacros: Object.keys(mathMacros) + }); + const isRelevantEnvironment = match.createEnvironmentMatcher(environments17); + const isRelevantMathEnvironment = match.createEnvironmentMatcher(mathEnvs); + return (tree) => { + visit( + tree, + { + enter: (nodes) => { + if (!Array.isArray(nodes)) { + return; + } + attachMacroArgsInArray(nodes, mathMacros); + }, + leave: (node) => { + if (!isRelevantMathEnvironment(node)) { + return; + } + const envName = printRaw(node.env); + const envInfo = environments17[envName]; + if (!envInfo) { + throw new Error( + `Could not find environment info for environment "${envName}"` + ); + } + processEnvironment(node, envInfo); + } + }, + { includeArrays: true } + ); + mathReparser(tree); + visit( + tree, + { + enter: (nodes) => { + if (!Array.isArray(nodes)) { + return; + } + attachMacroArgsInArray(nodes, macros17); + }, + leave: (node) => { + if (!isRelevantEnvironment(node)) { + return; + } + const envName = printRaw(node.env); + const envInfo = environments17[envName]; + if (!envInfo) { + throw new Error( + `Could not find environment info for environment "${envName}"` + ); + } + processEnvironment(node, envInfo); + } + }, + { includeArrays: true } + ); + }; +}; +var unifiedLatexProcessAtLetterAndExplMacros = function unifiedLatexProcessAtLetterAndExplMacros2(options) { + let { + atLetter = false, + expl3 = false, + autodetectExpl3AndAtLetter = false + } = options || {}; + return (tree) => { + reparseExpl3AndAtLetterRegions(tree); + if (atLetter || expl3) { + autodetectExpl3AndAtLetter = false; + } + if (autodetectExpl3AndAtLetter) { + atLetter = hasReparsableMacroNames(tree, "@"); + expl3 = hasReparsableMacroNames(tree, "_"); + } + const charSet = /* @__PURE__ */ new Set(); + if (atLetter) { + charSet.add("@"); + } + if (expl3) { + charSet.add(":"); + charSet.add("_"); + } + if (charSet.size > 0) { + reparseMacroNames(tree, charSet); + } + }; +}; +var unifiedLatexFromString = function unifiedLatexFromString2(options) { + const { + mode = "regular", + macros: macros17 = {}, + environments: environments17 = {}, + flags: { + atLetter = false, + expl3 = false, + autodetectExpl3AndAtLetter = false + } = {} + } = options || {}; + const allMacroInfo = Object.assign( + {}, + ...Object.values(macroInfo), + macros17 + ); + const allEnvInfo = Object.assign( + {}, + ...Object.values(environmentInfo), + environments17 + ); + const fullParser = unified().use(unifiedLatexFromStringMinimal, { mode }).use(unifiedLatexProcessAtLetterAndExplMacros, { + atLetter, + expl3, + autodetectExpl3AndAtLetter + }).use(unifiedLatexProcessMacrosAndEnvironmentsWithMathReparse, { + macros: allMacroInfo, + environments: allEnvInfo + }).use(unifiedLatexTrimEnvironmentContents).use(unifiedLatexTrimRoot).use(unifiedLatexAstComplier); + const parser2 = (str) => { + const file = fullParser.processSync({ value: str }); + return file.result; + }; + Object.assign(this, { Parser: parser2 }); +}; +var parser = unified().use(unifiedLatexFromString).freeze(); +function parse3(str) { + return parser.parse(str); +} + +// libs/prettier-plugin-latex.ts +var languages = [ + { + name: "latex", + extensions: [".tex"], + parsers: ["latex-parser"] + } +]; +var parsers = { + "latex-parser": { + parse: parse3, + astFormat: "latex-ast", + locStart: (node) => node.position ? node.position.start.offset : 0, + locEnd: (node) => node.position ? node.position.end.offset : 1 + } +}; +var printers = { + "latex-ast": { + print: printLatexAst + } +}; +var prettierPluginLatex = { languages, parsers, printers }; +/*! Bundled license information: + +is-buffer/index.js: + (*! + * Determine if an object is a Buffer + * + * @author Feross Aboukhadijeh + * @license MIT + *) +*/ +//# sourceMappingURL=index.cjs.map diff --git a/node_modules/@unified-latex/unified-latex-prettier/index.cjs.map b/node_modules/@unified-latex/unified-latex-prettier/index.cjs.map new file mode 100644 index 0000000..0e465ec --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-prettier/index.cjs.map @@ -0,0 +1,7 @@ +{ + "version": 3, + "sources": ["../../../node_modules/trie-prefix-tree/dist/config.js", "../../../node_modules/trie-prefix-tree/dist/append.js", "../../../node_modules/trie-prefix-tree/dist/create.js", "../../../node_modules/trie-prefix-tree/dist/utils.js", "../../../node_modules/trie-prefix-tree/dist/checkPrefix.js", "../../../node_modules/trie-prefix-tree/dist/recursePrefix.js", "../../../node_modules/trie-prefix-tree/dist/recurseRandomWord.js", "../../../node_modules/trie-prefix-tree/dist/permutations.js", "../../../node_modules/trie-prefix-tree/dist/index.js", "../../../node_modules/is-buffer/index.js", "../../../node_modules/extend/index.js", "../../../node_modules/color-name/index.js", "../../../node_modules/simple-swizzle/node_modules/is-arrayish/index.js", "../../../node_modules/simple-swizzle/index.js", "../../../node_modules/color-string/index.js", "../../../node_modules/color-convert/conversions.js", "../../../node_modules/color-convert/route.js", "../../../node_modules/color-convert/index.js", "../../../node_modules/color/index.js", "../index.ts", "../node_modules/prettier/doc.mjs", "../../unified-latex-util-print-raw/libs/print-raw.ts", "../../unified-latex-util-match/libs/match.ts", "../libs/printer/common.ts", "../libs/zip.ts", "../libs/printer/macro.ts", "../../unified-latex-util-visit/libs/list-math-children.ts", "../../unified-latex-util-visit/libs/visit.ts", "../../unified-latex-util-trim/libs/trim.ts", "../../unified-latex-util-trim/libs/unified-latex-trim-environment-contents.ts", "../../unified-latex-util-trim/libs/unified-latex-trim-root.ts", "../../unified-latex-util-trim/libs/has-whitespace-equivalent.ts", "../../unified-latex-util-pegjs/libs/decorate-array-for-pegjs.ts", "../../unified-latex-util-pegjs/libs/split-strings.ts", "../../unified-latex-util-pegjs/grammars/latex.pegjs", "../../unified-latex-util-pegjs/grammars/align-environment.pegjs", "../../unified-latex-util-pegjs/grammars/xparse-argspec.pegjs", "../../unified-latex-util-pegjs/grammars/pgfkeys.pegjs", "../../unified-latex-util-pegjs/grammars/macro-substitutions.pegjs", "../../unified-latex-util-pegjs/grammars/ligatures.pegjs", "../../unified-latex-util-pegjs/grammars/xcolor-expressions.pegjs", "../../unified-latex-util-pegjs/grammars/tabular-spec.pegjs", "../../unified-latex-util-pegjs/grammars/systeme-environment.pegjs", "../../unified-latex-util-pegjs/grammars/tex-glue.pegjs", "../../unified-latex-util-pegjs/grammars/tikz.pegjs", "../../unified-latex-util-pegjs/libs/pegjs-parsers.ts", "../../unified-latex-util-argspec/libs/argspec-parser.ts", "../../unified-latex-util-argspec/libs/argspec-types.ts", "../../unified-latex-builder/libs/builders.ts", "../../unified-latex-util-scan/libs/scan.ts", "../../unified-latex-util-scan/libs/prefix-match.ts", "../../unified-latex-util-render-info/index.ts", "../../unified-latex-util-arguments/libs/gobble-arguments.ts", "../../unified-latex-util-arguments/libs/gobble-single-argument.ts", "../../unified-latex-util-arguments/libs/attach-arguments.ts", "../../unified-latex-util-arguments/libs/unified-latex-attach-macro-arguments.ts", "../../unified-latex-util-arguments/libs/get-args-content.ts", "../../unified-latex-ctan/package/tikz/libs/tikz-command-argument-parser.ts", "../../unified-latex-ctan/package/tikz/libs/parser.ts", "../../unified-latex-util-pgfkeys/libs/pgfkeys-parser.ts", "../../unified-latex-util-pgfkeys/libs/pgfkeys-to-object.ts", "../libs/printer/print-argument-pgfkeys.ts", "../libs/printer/tikz.ts", "../libs/printer/argument.ts", "../libs/printer/root.ts", "../libs/printer/comment.ts", "../libs/printer/math.ts", "../../unified-latex-util-align/libs/parse-align-environment.ts", "../libs/printer/environment.ts", "../libs/reference-map.ts", "../libs/printer/printer.ts", "../../../node_modules/bail/index.js", "../../../node_modules/unified/lib/index.js", "../../../node_modules/unified/node_modules/is-plain-obj/index.js", "../../../node_modules/trough/index.js", "../../../node_modules/vfile/lib/index.js", "../../../node_modules/unist-util-stringify-position/lib/index.js", "../../../node_modules/vfile-message/index.js", "../../../node_modules/vfile/lib/minpath.browser.js", "../../../node_modules/vfile/lib/minproc.browser.js", "../../../node_modules/vfile/lib/minurl.shared.js", "../../../node_modules/vfile/lib/minurl.browser.js", "../../unified-latex-util-split/libs/split-on-macro.ts", "../../unified-latex-util-split/libs/split-on-condition.ts", "../../unified-latex-util-split/libs/unsplit-on-macro.ts", "../../unified-latex-util-split/libs/array-join.ts", "../../unified-latex-util-replace/libs/replace-node.ts", "../../unified-latex-util-replace/libs/unified-latex-streaming-command.ts", "../../unified-latex-util-replace/libs/replace-streaming-command.ts", "../../unified-latex-util-replace/libs/utils/significant-node.ts", "../../unified-latex-util-replace/libs/utils/replace-streaming-command-in-array.ts", "../../unified-latex-util-replace/libs/utils/join-without-excess-whitespace.ts", "../../unified-latex-util-replace/libs/utils/wrap-significant-content.ts", "../../unified-latex-util-replace/libs/replace-node-during-visit.ts", "../../unified-latex-ctan/package/cleveref/provides.ts", "../../unified-latex-ctan/utils/enumerate.ts", "../../unified-latex-ctan/package/exam/provides.ts", "../../unified-latex-ctan/package/geometry/provides.ts", "../../unified-latex-ctan/package/hyperref/provides.ts", "../../unified-latex-ctan/package/latex2e/provides.ts", "../../unified-latex-ctan/package/listings/libs/argument-parser.ts", "../../unified-latex-ctan/package/listings/provides.ts", "../../unified-latex-ctan/package/makeidx/provides.ts", "../../unified-latex-ctan/package/mathtools/provides.ts", "../../unified-latex-ctan/package/minted/libs/argument-parser.ts", "../../unified-latex-ctan/package/minted/provides.ts", "../../unified-latex-ctan/package/nicematrix/provides.ts", "../../unified-latex-ctan/package/systeme/provides.ts", "../../unified-latex-ctan/package/systeme/libs/parser.ts", "../../unified-latex-ctan/package/systeme/libs/print-raw.ts", "../../unified-latex-ctan/package/systeme/libs/systeme.ts", "../../structured-clone/index.ts", "../../unified-latex-ctan/package/tikz/provides.ts", "../../unified-latex-ctan/package/tikz/libs/tikz-command-argument-parser.ts", "../../unified-latex-ctan/package/tikz/libs/print-raw.ts", "../../unified-latex-ctan/package/tikz/libs/parser.ts", "../../unified-latex-ctan/package/xcolor/provides.ts", "../../unified-latex-ctan/package/xcolor/libs/xcolor.ts", "../../unified-latex-ctan/package/xcolor/libs/predefined-colors.ts", "../../unified-latex-ctan/package/xcolor/libs/parser.ts", "../../unified-latex-ctan/package/xcolor/libs/xcolor-macro-to-hex.ts", "../../unified-latex-ctan/package/xcolor/libs/color-to-textcolor-macro.ts", "../../unified-latex-ctan/package/xparse/provides.ts", "../../unified-latex-ctan/package/beamer/provides.ts", "../../unified-latex-ctan/package/multicol/provides.ts", "../../unified-latex-ctan/index.ts", "../../unified-latex-util-environments/libs/process-environment.ts", "../../unified-latex-util-environments/libs/unified-latex-process-environment.ts", "../../unified-latex-util-catcode/libs/find-region.ts", "../../unified-latex-util-catcode/libs/special-regions.ts", "../../unified-latex-util-catcode/libs/regions.ts", "../../unified-latex-util-catcode/libs/reparse-macro-names.ts", "../../unified-latex-util-parse/libs/compiler-ast.ts", "../../unified-latex-util-parse/libs/plugin-from-string.ts", "../../unified-latex-util-parse/libs/parse-minimal.ts", "../../unified-latex-util-parse/libs/plugin-from-string-minimal.ts", "../../unified-latex-util-parse/libs/process-macros-and-environments.ts", "../../unified-latex-util-parse/libs/reparse-math.ts", "../../unified-latex-util-parse/libs/process-at-letter-and-expl-macros.ts", "../../unified-latex-util-parse/libs/parse.ts", "../../unified-latex-util-parse/libs/parse-math.ts", "../libs/prettier-plugin-latex.ts"], + "sourcesContent": ["'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\nexports.default = {\n END_WORD: '$',\n END_WORD_REPLACER: '9a219a89-91cd-42e2-abd5-eb113af08ca8',\n PERMS_MIN_LEN: 2\n};\nmodule.exports = exports['default'];", "'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\nexports.default = append;\n\nvar _config = require('./config');\n\nvar _config2 = _interopRequireDefault(_config);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nfunction append(trie, letter, index, array) {\n var isEndWordLetter = letter === _config2.default.END_WORD;\n var isLastLetter = index === array.length - 1;\n\n if (isEndWordLetter && !isLastLetter) {\n trie[_config2.default.END_WORD] = 1;\n trie[_config2.default.END_WORD_REPLACER] = {};\n trie = trie[_config2.default.END_WORD_REPLACER];\n } else {\n trie[letter] = trie[letter] || {};\n trie = trie[letter];\n }\n\n if (isLastLetter) {\n trie[_config2.default.END_WORD] = 1;\n }\n\n return trie;\n}\nmodule.exports = exports['default'];", "'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\n\nvar _typeof = typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; };\n\nexports.default = create;\n\nvar _append = require('./append');\n\nvar _append2 = _interopRequireDefault(_append);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nfunction create(input) {\n if (!Array.isArray(input)) {\n throw 'Expected parameter Array, received ' + (typeof input === 'undefined' ? 'undefined' : _typeof(input));\n }\n\n var trie = input.reduce(function (accumulator, item) {\n item.toLowerCase().split('').reduce(_append2.default, accumulator);\n\n return accumulator;\n }, {});\n\n return trie;\n};\nmodule.exports = exports['default'];", "'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\nexports.default = {\n objectCopy: function objectCopy(obj) {\n if (typeof obj === 'undefined') {\n return {};\n }\n return JSON.parse(JSON.stringify(obj));\n },\n stringify: function stringify(obj) {\n var spacer = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 2;\n\n if (typeof obj === 'undefined') {\n return '';\n }\n return JSON.stringify(obj, null, spacer);\n }\n};\nmodule.exports = exports['default'];", "'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\nexports.default = checkPrefix;\n\nvar _utils = require('./utils');\n\nvar _utils2 = _interopRequireDefault(_utils);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nfunction checkPrefix(prefixNode, prefix) {\n var input = prefix.toLowerCase().split('');\n var prefixFound = input.every(function (letter, index) {\n if (!prefixNode[letter]) {\n return false;\n }\n return prefixNode = prefixNode[letter];\n });\n\n return {\n prefixFound: prefixFound,\n prefixNode: prefixNode\n };\n};\nmodule.exports = exports['default'];", "'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\nexports.default = recursePrefix;\n\nvar _config = require('./config');\n\nvar _config2 = _interopRequireDefault(_config);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\n// sort items as they're being found\n// to prevent slow .sort() in NodeJs\nvar pushInOrder = function pushInOrder(word, prefixes) {\n var i = 0;\n\n while (i < prefixes.length) {\n if (word < prefixes[i]) {\n break;\n }\n i += 1;\n }\n\n prefixes.splice(i, 0, word);\n\n return prefixes;\n};\n\nfunction recursePrefix(node, prefix, sorted) {\n var prefixes = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : [];\n\n var word = prefix;\n\n for (var branch in node) {\n var currentLetter = branch;\n if (branch === _config2.default.END_WORD && typeof node[branch] === 'number') {\n if (sorted) {\n pushInOrder(word, prefixes);\n } else {\n prefixes.push(word);\n }\n word = '';\n } else if (branch === _config2.default.END_WORD_REPLACER) {\n currentLetter = _config2.default.END_WORD;\n }\n recursePrefix(node[branch], prefix + currentLetter, sorted, prefixes);\n }\n\n return prefixes;\n}\nmodule.exports = exports['default'];", "'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\nexports.default = recurseRandomWord;\n\nvar _config = require('./config');\n\nvar _config2 = _interopRequireDefault(_config);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nfunction recurseRandomWord(node, prefix) {\n var word = prefix;\n var branches = Object.keys(node);\n var branch = branches[Math.floor(Math.random() * branches.length)];\n\n if (branch === _config2.default.END_WORD) {\n return word;\n }\n return recurseRandomWord(node[branch], prefix + branch);\n};\nmodule.exports = exports['default'];", "'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\n\nvar _typeof = typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; };\n\nexports.default = permutations;\n\nvar _config = require('./config');\n\nvar _config2 = _interopRequireDefault(_config);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nfunction permutations(letters, trie) {\n var opts = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {\n type: 'anagram'\n };\n\n if (typeof letters !== 'string') {\n throw 'Permutations expects string letters, received ' + (typeof letters === 'undefined' ? 'undefined' : _typeof(letters));\n }\n\n var words = [];\n\n var permute = function permute(word, node) {\n var prefix = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : '';\n\n var wordIsEmpty = word.length === 0;\n var wordFound = words.indexOf(prefix) !== -1;\n var endWordFound = node[_config2.default.END_WORD] === 1;\n\n if (wordIsEmpty && endWordFound && !wordFound) {\n words.push(prefix);\n }\n\n for (var i = 0, len = word.length; i < len; i++) {\n var letter = word[i];\n\n if (opts.type === 'sub-anagram') {\n if (endWordFound && !(words.indexOf(prefix) !== -1)) {\n words.push(prefix);\n }\n }\n\n if (node[letter]) {\n var remaining = word.substring(0, i) + word.substring(i + 1, len);\n permute(remaining, node[letter], prefix + letter, words);\n }\n }\n\n return words.sort();\n };\n\n return permute(letters, trie);\n};\nmodule.exports = exports['default'];", "'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\n\nvar _typeof = typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; };\n\nexports.default = function (input) {\n if (!Array.isArray(input)) {\n throw 'Expected parameter Array, received ' + (typeof input === 'undefined' ? 'undefined' : _typeof(input));\n }\n\n var trie = (0, _create2.default)([].concat(_toConsumableArray(input)));\n\n return {\n /**\n * Get the generated raw trie object\n */\n tree: function tree() {\n return trie;\n },\n\n\n /**\n * Get a string representation of the trie\n */\n dump: function dump() {\n var spacer = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;\n\n return _utils2.default.stringify(trie, spacer);\n },\n\n\n /**\n * Add a new word to the trie\n */\n addWord: function addWord(word) {\n if (typeof word !== 'string' || word === '') {\n throw 'Expected parameter string, received ' + (typeof word === 'undefined' ? 'undefined' : _typeof(word));\n }\n\n var reducer = function reducer() {\n return _append2.default.apply(undefined, arguments);\n };\n\n var input = word.toLowerCase().split('');\n input.reduce(reducer, trie);\n\n return this;\n },\n\n\n /**\n * Remove an existing word from the trie\n */\n removeWord: function removeWord(word) {\n if (typeof word !== 'string' || word === '') {\n throw 'Expected parameter string, received ' + (typeof word === 'undefined' ? 'undefined' : _typeof(word));\n }\n\n var _checkPrefix = (0, _checkPrefix6.default)(trie, word),\n prefixFound = _checkPrefix.prefixFound,\n prefixNode = _checkPrefix.prefixNode;\n\n if (prefixFound) {\n delete prefixNode[_config2.default.END_WORD];\n }\n\n return this;\n },\n\n\n /**\n * Check a prefix is valid\n * @returns Boolean\n */\n isPrefix: function isPrefix(prefix) {\n if (typeof prefix !== 'string') {\n throw 'Expected string prefix, received ' + (typeof prefix === 'undefined' ? 'undefined' : _typeof(prefix));\n }\n\n var _checkPrefix2 = (0, _checkPrefix6.default)(trie, prefix),\n prefixFound = _checkPrefix2.prefixFound;\n\n return prefixFound;\n },\n\n\n /**\n * Get a list of all words in the trie with the given prefix\n * @returns Array\n */\n getPrefix: function getPrefix(strPrefix) {\n var sorted = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;\n\n if (typeof strPrefix !== 'string') {\n throw 'Expected string prefix, received ' + (typeof strPrefix === 'undefined' ? 'undefined' : _typeof(strPrefix));\n }\n\n if (typeof sorted !== 'boolean') {\n throw 'Expected sort parameter as boolean, received ' + (typeof sorted === 'undefined' ? 'undefined' : _typeof(sorted));\n }\n\n if (!this.isPrefix(strPrefix)) {\n return [];\n }\n\n var prefixNode = strPrefix.length ? (0, _checkPrefix6.default)(trie, strPrefix).prefixNode : trie;\n\n return (0, _recursePrefix2.default)(prefixNode, strPrefix, sorted);\n },\n\n\n /**\n * Get a random word in the trie with the given prefix\n * @returns Array\n */\n getRandomWordWithPrefix: function getRandomWordWithPrefix(strPrefix) {\n if (typeof strPrefix !== 'string') {\n throw 'Expected string prefix, received ' + (typeof strPrefix === 'undefined' ? 'undefined' : _typeof(strPrefix));\n }\n\n if (!this.isPrefix(strPrefix)) {\n return '';\n }\n\n var _checkPrefix3 = (0, _checkPrefix6.default)(trie, strPrefix),\n prefixNode = _checkPrefix3.prefixNode;\n\n return (0, _recurseRandomWord2.default)(prefixNode, strPrefix);\n },\n\n\n /**\n * Count the number of words with the given prefixSearch\n * @returns Number\n */\n countPrefix: function countPrefix(strPrefix) {\n var prefixes = this.getPrefix(strPrefix);\n\n return prefixes.length;\n },\n\n\n /**\n * Get all words in the trie\n * @returns Array\n */\n getWords: function getWords() {\n var sorted = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;\n\n return this.getPrefix('', sorted);\n },\n\n\n /**\n * Check the existence of a word in the trie\n * @returns Boolean\n */\n hasWord: function hasWord(word) {\n if (typeof word !== 'string') {\n throw 'Expected string word, received ' + (typeof word === 'undefined' ? 'undefined' : _typeof(word));\n }\n\n var _checkPrefix4 = (0, _checkPrefix6.default)(trie, word),\n prefixFound = _checkPrefix4.prefixFound,\n prefixNode = _checkPrefix4.prefixNode;\n\n if (prefixFound) {\n return prefixNode[_config2.default.END_WORD] === 1;\n }\n\n return false;\n },\n\n\n /**\n * Get a list of valid anagrams that can be made from the given letters\n * @returns Array\n */\n getAnagrams: function getAnagrams(letters) {\n if (typeof letters !== 'string') {\n throw 'Anagrams expected string letters, received ' + (typeof letters === 'undefined' ? 'undefined' : _typeof(letters));\n }\n\n if (letters.length < PERMS_MIN_LEN) {\n throw 'getAnagrams expects at least ' + PERMS_MIN_LEN + ' letters';\n }\n\n return (0, _permutations2.default)(letters, trie, {\n type: 'anagram'\n });\n },\n\n\n /**\n * Get a list of all sub-anagrams that can be made from the given letters\n * @returns Array\n */\n getSubAnagrams: function getSubAnagrams(letters) {\n if (typeof letters !== 'string') {\n throw 'Expected string letters, received ' + (typeof letters === 'undefined' ? 'undefined' : _typeof(letters));\n }\n\n if (letters.length < PERMS_MIN_LEN) {\n throw 'getSubAnagrams expects at least ' + PERMS_MIN_LEN + ' letters';\n }\n\n return (0, _permutations2.default)(letters, trie, {\n type: 'sub-anagram'\n });\n }\n };\n};\n\nvar _create = require('./create');\n\nvar _create2 = _interopRequireDefault(_create);\n\nvar _append = require('./append');\n\nvar _append2 = _interopRequireDefault(_append);\n\nvar _checkPrefix5 = require('./checkPrefix');\n\nvar _checkPrefix6 = _interopRequireDefault(_checkPrefix5);\n\nvar _recursePrefix = require('./recursePrefix');\n\nvar _recursePrefix2 = _interopRequireDefault(_recursePrefix);\n\nvar _recurseRandomWord = require('./recurseRandomWord');\n\nvar _recurseRandomWord2 = _interopRequireDefault(_recurseRandomWord);\n\nvar _utils = require('./utils');\n\nvar _utils2 = _interopRequireDefault(_utils);\n\nvar _config = require('./config');\n\nvar _config2 = _interopRequireDefault(_config);\n\nvar _permutations = require('./permutations');\n\nvar _permutations2 = _interopRequireDefault(_permutations);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nfunction _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } else { return Array.from(arr); } }\n\nvar PERMS_MIN_LEN = _config2.default.PERMS_MIN_LEN;\n\n;\nmodule.exports = exports['default'];", "/*!\n * Determine if an object is a Buffer\n *\n * @author Feross Aboukhadijeh \n * @license MIT\n */\n\nmodule.exports = function isBuffer (obj) {\n return obj != null && obj.constructor != null &&\n typeof obj.constructor.isBuffer === 'function' && obj.constructor.isBuffer(obj)\n}\n", "'use strict';\n\nvar hasOwn = Object.prototype.hasOwnProperty;\nvar toStr = Object.prototype.toString;\nvar defineProperty = Object.defineProperty;\nvar gOPD = Object.getOwnPropertyDescriptor;\n\nvar isArray = function isArray(arr) {\n\tif (typeof Array.isArray === 'function') {\n\t\treturn Array.isArray(arr);\n\t}\n\n\treturn toStr.call(arr) === '[object Array]';\n};\n\nvar isPlainObject = function isPlainObject(obj) {\n\tif (!obj || toStr.call(obj) !== '[object Object]') {\n\t\treturn false;\n\t}\n\n\tvar hasOwnConstructor = hasOwn.call(obj, 'constructor');\n\tvar hasIsPrototypeOf = obj.constructor && obj.constructor.prototype && hasOwn.call(obj.constructor.prototype, 'isPrototypeOf');\n\t// Not own constructor property must be Object\n\tif (obj.constructor && !hasOwnConstructor && !hasIsPrototypeOf) {\n\t\treturn false;\n\t}\n\n\t// Own properties are enumerated firstly, so to speed up,\n\t// if last one is own, then all properties are own.\n\tvar key;\n\tfor (key in obj) { /**/ }\n\n\treturn typeof key === 'undefined' || hasOwn.call(obj, key);\n};\n\n// If name is '__proto__', and Object.defineProperty is available, define __proto__ as an own property on target\nvar setProperty = function setProperty(target, options) {\n\tif (defineProperty && options.name === '__proto__') {\n\t\tdefineProperty(target, options.name, {\n\t\t\tenumerable: true,\n\t\t\tconfigurable: true,\n\t\t\tvalue: options.newValue,\n\t\t\twritable: true\n\t\t});\n\t} else {\n\t\ttarget[options.name] = options.newValue;\n\t}\n};\n\n// Return undefined instead of __proto__ if '__proto__' is not an own property\nvar getProperty = function getProperty(obj, name) {\n\tif (name === '__proto__') {\n\t\tif (!hasOwn.call(obj, name)) {\n\t\t\treturn void 0;\n\t\t} else if (gOPD) {\n\t\t\t// In early versions of node, obj['__proto__'] is buggy when obj has\n\t\t\t// __proto__ as an own property. Object.getOwnPropertyDescriptor() works.\n\t\t\treturn gOPD(obj, name).value;\n\t\t}\n\t}\n\n\treturn obj[name];\n};\n\nmodule.exports = function extend() {\n\tvar options, name, src, copy, copyIsArray, clone;\n\tvar target = arguments[0];\n\tvar i = 1;\n\tvar length = arguments.length;\n\tvar deep = false;\n\n\t// Handle a deep copy situation\n\tif (typeof target === 'boolean') {\n\t\tdeep = target;\n\t\ttarget = arguments[1] || {};\n\t\t// skip the boolean and the target\n\t\ti = 2;\n\t}\n\tif (target == null || (typeof target !== 'object' && typeof target !== 'function')) {\n\t\ttarget = {};\n\t}\n\n\tfor (; i < length; ++i) {\n\t\toptions = arguments[i];\n\t\t// Only deal with non-null/undefined values\n\t\tif (options != null) {\n\t\t\t// Extend the base object\n\t\t\tfor (name in options) {\n\t\t\t\tsrc = getProperty(target, name);\n\t\t\t\tcopy = getProperty(options, name);\n\n\t\t\t\t// Prevent never-ending loop\n\t\t\t\tif (target !== copy) {\n\t\t\t\t\t// Recurse if we're merging plain objects or arrays\n\t\t\t\t\tif (deep && copy && (isPlainObject(copy) || (copyIsArray = isArray(copy)))) {\n\t\t\t\t\t\tif (copyIsArray) {\n\t\t\t\t\t\t\tcopyIsArray = false;\n\t\t\t\t\t\t\tclone = src && isArray(src) ? src : [];\n\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\tclone = src && isPlainObject(src) ? src : {};\n\t\t\t\t\t\t}\n\n\t\t\t\t\t\t// Never move original objects, clone them\n\t\t\t\t\t\tsetProperty(target, { name: name, newValue: extend(deep, clone, copy) });\n\n\t\t\t\t\t// Don't bring in undefined values\n\t\t\t\t\t} else if (typeof copy !== 'undefined') {\n\t\t\t\t\t\tsetProperty(target, { name: name, newValue: copy });\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\t// Return the modified object\n\treturn target;\n};\n", "'use strict'\r\n\r\nmodule.exports = {\r\n\t\"aliceblue\": [240, 248, 255],\r\n\t\"antiquewhite\": [250, 235, 215],\r\n\t\"aqua\": [0, 255, 255],\r\n\t\"aquamarine\": [127, 255, 212],\r\n\t\"azure\": [240, 255, 255],\r\n\t\"beige\": [245, 245, 220],\r\n\t\"bisque\": [255, 228, 196],\r\n\t\"black\": [0, 0, 0],\r\n\t\"blanchedalmond\": [255, 235, 205],\r\n\t\"blue\": [0, 0, 255],\r\n\t\"blueviolet\": [138, 43, 226],\r\n\t\"brown\": [165, 42, 42],\r\n\t\"burlywood\": [222, 184, 135],\r\n\t\"cadetblue\": [95, 158, 160],\r\n\t\"chartreuse\": [127, 255, 0],\r\n\t\"chocolate\": [210, 105, 30],\r\n\t\"coral\": [255, 127, 80],\r\n\t\"cornflowerblue\": [100, 149, 237],\r\n\t\"cornsilk\": [255, 248, 220],\r\n\t\"crimson\": [220, 20, 60],\r\n\t\"cyan\": [0, 255, 255],\r\n\t\"darkblue\": [0, 0, 139],\r\n\t\"darkcyan\": [0, 139, 139],\r\n\t\"darkgoldenrod\": [184, 134, 11],\r\n\t\"darkgray\": [169, 169, 169],\r\n\t\"darkgreen\": [0, 100, 0],\r\n\t\"darkgrey\": [169, 169, 169],\r\n\t\"darkkhaki\": [189, 183, 107],\r\n\t\"darkmagenta\": [139, 0, 139],\r\n\t\"darkolivegreen\": [85, 107, 47],\r\n\t\"darkorange\": [255, 140, 0],\r\n\t\"darkorchid\": [153, 50, 204],\r\n\t\"darkred\": [139, 0, 0],\r\n\t\"darksalmon\": [233, 150, 122],\r\n\t\"darkseagreen\": [143, 188, 143],\r\n\t\"darkslateblue\": [72, 61, 139],\r\n\t\"darkslategray\": [47, 79, 79],\r\n\t\"darkslategrey\": [47, 79, 79],\r\n\t\"darkturquoise\": [0, 206, 209],\r\n\t\"darkviolet\": [148, 0, 211],\r\n\t\"deeppink\": [255, 20, 147],\r\n\t\"deepskyblue\": [0, 191, 255],\r\n\t\"dimgray\": [105, 105, 105],\r\n\t\"dimgrey\": [105, 105, 105],\r\n\t\"dodgerblue\": [30, 144, 255],\r\n\t\"firebrick\": [178, 34, 34],\r\n\t\"floralwhite\": [255, 250, 240],\r\n\t\"forestgreen\": [34, 139, 34],\r\n\t\"fuchsia\": [255, 0, 255],\r\n\t\"gainsboro\": [220, 220, 220],\r\n\t\"ghostwhite\": [248, 248, 255],\r\n\t\"gold\": [255, 215, 0],\r\n\t\"goldenrod\": [218, 165, 32],\r\n\t\"gray\": [128, 128, 128],\r\n\t\"green\": [0, 128, 0],\r\n\t\"greenyellow\": [173, 255, 47],\r\n\t\"grey\": [128, 128, 128],\r\n\t\"honeydew\": [240, 255, 240],\r\n\t\"hotpink\": [255, 105, 180],\r\n\t\"indianred\": [205, 92, 92],\r\n\t\"indigo\": [75, 0, 130],\r\n\t\"ivory\": [255, 255, 240],\r\n\t\"khaki\": [240, 230, 140],\r\n\t\"lavender\": [230, 230, 250],\r\n\t\"lavenderblush\": [255, 240, 245],\r\n\t\"lawngreen\": [124, 252, 0],\r\n\t\"lemonchiffon\": [255, 250, 205],\r\n\t\"lightblue\": [173, 216, 230],\r\n\t\"lightcoral\": [240, 128, 128],\r\n\t\"lightcyan\": [224, 255, 255],\r\n\t\"lightgoldenrodyellow\": [250, 250, 210],\r\n\t\"lightgray\": [211, 211, 211],\r\n\t\"lightgreen\": [144, 238, 144],\r\n\t\"lightgrey\": [211, 211, 211],\r\n\t\"lightpink\": [255, 182, 193],\r\n\t\"lightsalmon\": [255, 160, 122],\r\n\t\"lightseagreen\": [32, 178, 170],\r\n\t\"lightskyblue\": [135, 206, 250],\r\n\t\"lightslategray\": [119, 136, 153],\r\n\t\"lightslategrey\": [119, 136, 153],\r\n\t\"lightsteelblue\": [176, 196, 222],\r\n\t\"lightyellow\": [255, 255, 224],\r\n\t\"lime\": [0, 255, 0],\r\n\t\"limegreen\": [50, 205, 50],\r\n\t\"linen\": [250, 240, 230],\r\n\t\"magenta\": [255, 0, 255],\r\n\t\"maroon\": [128, 0, 0],\r\n\t\"mediumaquamarine\": [102, 205, 170],\r\n\t\"mediumblue\": [0, 0, 205],\r\n\t\"mediumorchid\": [186, 85, 211],\r\n\t\"mediumpurple\": [147, 112, 219],\r\n\t\"mediumseagreen\": [60, 179, 113],\r\n\t\"mediumslateblue\": [123, 104, 238],\r\n\t\"mediumspringgreen\": [0, 250, 154],\r\n\t\"mediumturquoise\": [72, 209, 204],\r\n\t\"mediumvioletred\": [199, 21, 133],\r\n\t\"midnightblue\": [25, 25, 112],\r\n\t\"mintcream\": [245, 255, 250],\r\n\t\"mistyrose\": [255, 228, 225],\r\n\t\"moccasin\": [255, 228, 181],\r\n\t\"navajowhite\": [255, 222, 173],\r\n\t\"navy\": [0, 0, 128],\r\n\t\"oldlace\": [253, 245, 230],\r\n\t\"olive\": [128, 128, 0],\r\n\t\"olivedrab\": [107, 142, 35],\r\n\t\"orange\": [255, 165, 0],\r\n\t\"orangered\": [255, 69, 0],\r\n\t\"orchid\": [218, 112, 214],\r\n\t\"palegoldenrod\": [238, 232, 170],\r\n\t\"palegreen\": [152, 251, 152],\r\n\t\"paleturquoise\": [175, 238, 238],\r\n\t\"palevioletred\": [219, 112, 147],\r\n\t\"papayawhip\": [255, 239, 213],\r\n\t\"peachpuff\": [255, 218, 185],\r\n\t\"peru\": [205, 133, 63],\r\n\t\"pink\": [255, 192, 203],\r\n\t\"plum\": [221, 160, 221],\r\n\t\"powderblue\": [176, 224, 230],\r\n\t\"purple\": [128, 0, 128],\r\n\t\"rebeccapurple\": [102, 51, 153],\r\n\t\"red\": [255, 0, 0],\r\n\t\"rosybrown\": [188, 143, 143],\r\n\t\"royalblue\": [65, 105, 225],\r\n\t\"saddlebrown\": [139, 69, 19],\r\n\t\"salmon\": [250, 128, 114],\r\n\t\"sandybrown\": [244, 164, 96],\r\n\t\"seagreen\": [46, 139, 87],\r\n\t\"seashell\": [255, 245, 238],\r\n\t\"sienna\": [160, 82, 45],\r\n\t\"silver\": [192, 192, 192],\r\n\t\"skyblue\": [135, 206, 235],\r\n\t\"slateblue\": [106, 90, 205],\r\n\t\"slategray\": [112, 128, 144],\r\n\t\"slategrey\": [112, 128, 144],\r\n\t\"snow\": [255, 250, 250],\r\n\t\"springgreen\": [0, 255, 127],\r\n\t\"steelblue\": [70, 130, 180],\r\n\t\"tan\": [210, 180, 140],\r\n\t\"teal\": [0, 128, 128],\r\n\t\"thistle\": [216, 191, 216],\r\n\t\"tomato\": [255, 99, 71],\r\n\t\"turquoise\": [64, 224, 208],\r\n\t\"violet\": [238, 130, 238],\r\n\t\"wheat\": [245, 222, 179],\r\n\t\"white\": [255, 255, 255],\r\n\t\"whitesmoke\": [245, 245, 245],\r\n\t\"yellow\": [255, 255, 0],\r\n\t\"yellowgreen\": [154, 205, 50]\r\n};\r\n", "module.exports = function isArrayish(obj) {\n\tif (!obj || typeof obj === 'string') {\n\t\treturn false;\n\t}\n\n\treturn obj instanceof Array || Array.isArray(obj) ||\n\t\t(obj.length >= 0 && (obj.splice instanceof Function ||\n\t\t\t(Object.getOwnPropertyDescriptor(obj, (obj.length - 1)) && obj.constructor.name !== 'String')));\n};\n", "'use strict';\n\nvar isArrayish = require('is-arrayish');\n\nvar concat = Array.prototype.concat;\nvar slice = Array.prototype.slice;\n\nvar swizzle = module.exports = function swizzle(args) {\n\tvar results = [];\n\n\tfor (var i = 0, len = args.length; i < len; i++) {\n\t\tvar arg = args[i];\n\n\t\tif (isArrayish(arg)) {\n\t\t\t// http://jsperf.com/javascript-array-concat-vs-push/98\n\t\t\tresults = concat.call(results, slice.call(arg));\n\t\t} else {\n\t\t\tresults.push(arg);\n\t\t}\n\t}\n\n\treturn results;\n};\n\nswizzle.wrap = function (fn) {\n\treturn function () {\n\t\treturn fn(swizzle(arguments));\n\t};\n};\n", "/* MIT license */\nvar colorNames = require('color-name');\nvar swizzle = require('simple-swizzle');\nvar hasOwnProperty = Object.hasOwnProperty;\n\nvar reverseNames = Object.create(null);\n\n// create a list of reverse color names\nfor (var name in colorNames) {\n\tif (hasOwnProperty.call(colorNames, name)) {\n\t\treverseNames[colorNames[name]] = name;\n\t}\n}\n\nvar cs = module.exports = {\n\tto: {},\n\tget: {}\n};\n\ncs.get = function (string) {\n\tvar prefix = string.substring(0, 3).toLowerCase();\n\tvar val;\n\tvar model;\n\tswitch (prefix) {\n\t\tcase 'hsl':\n\t\t\tval = cs.get.hsl(string);\n\t\t\tmodel = 'hsl';\n\t\t\tbreak;\n\t\tcase 'hwb':\n\t\t\tval = cs.get.hwb(string);\n\t\t\tmodel = 'hwb';\n\t\t\tbreak;\n\t\tdefault:\n\t\t\tval = cs.get.rgb(string);\n\t\t\tmodel = 'rgb';\n\t\t\tbreak;\n\t}\n\n\tif (!val) {\n\t\treturn null;\n\t}\n\n\treturn {model: model, value: val};\n};\n\ncs.get.rgb = function (string) {\n\tif (!string) {\n\t\treturn null;\n\t}\n\n\tvar abbr = /^#([a-f0-9]{3,4})$/i;\n\tvar hex = /^#([a-f0-9]{6})([a-f0-9]{2})?$/i;\n\tvar rgba = /^rgba?\\(\\s*([+-]?\\d+)(?=[\\s,])\\s*(?:,\\s*)?([+-]?\\d+)(?=[\\s,])\\s*(?:,\\s*)?([+-]?\\d+)\\s*(?:[,|\\/]\\s*([+-]?[\\d\\.]+)(%?)\\s*)?\\)$/;\n\tvar per = /^rgba?\\(\\s*([+-]?[\\d\\.]+)\\%\\s*,?\\s*([+-]?[\\d\\.]+)\\%\\s*,?\\s*([+-]?[\\d\\.]+)\\%\\s*(?:[,|\\/]\\s*([+-]?[\\d\\.]+)(%?)\\s*)?\\)$/;\n\tvar keyword = /^(\\w+)$/;\n\n\tvar rgb = [0, 0, 0, 1];\n\tvar match;\n\tvar i;\n\tvar hexAlpha;\n\n\tif (match = string.match(hex)) {\n\t\thexAlpha = match[2];\n\t\tmatch = match[1];\n\n\t\tfor (i = 0; i < 3; i++) {\n\t\t\t// https://jsperf.com/slice-vs-substr-vs-substring-methods-long-string/19\n\t\t\tvar i2 = i * 2;\n\t\t\trgb[i] = parseInt(match.slice(i2, i2 + 2), 16);\n\t\t}\n\n\t\tif (hexAlpha) {\n\t\t\trgb[3] = parseInt(hexAlpha, 16) / 255;\n\t\t}\n\t} else if (match = string.match(abbr)) {\n\t\tmatch = match[1];\n\t\thexAlpha = match[3];\n\n\t\tfor (i = 0; i < 3; i++) {\n\t\t\trgb[i] = parseInt(match[i] + match[i], 16);\n\t\t}\n\n\t\tif (hexAlpha) {\n\t\t\trgb[3] = parseInt(hexAlpha + hexAlpha, 16) / 255;\n\t\t}\n\t} else if (match = string.match(rgba)) {\n\t\tfor (i = 0; i < 3; i++) {\n\t\t\trgb[i] = parseInt(match[i + 1], 0);\n\t\t}\n\n\t\tif (match[4]) {\n\t\t\tif (match[5]) {\n\t\t\t\trgb[3] = parseFloat(match[4]) * 0.01;\n\t\t\t} else {\n\t\t\t\trgb[3] = parseFloat(match[4]);\n\t\t\t}\n\t\t}\n\t} else if (match = string.match(per)) {\n\t\tfor (i = 0; i < 3; i++) {\n\t\t\trgb[i] = Math.round(parseFloat(match[i + 1]) * 2.55);\n\t\t}\n\n\t\tif (match[4]) {\n\t\t\tif (match[5]) {\n\t\t\t\trgb[3] = parseFloat(match[4]) * 0.01;\n\t\t\t} else {\n\t\t\t\trgb[3] = parseFloat(match[4]);\n\t\t\t}\n\t\t}\n\t} else if (match = string.match(keyword)) {\n\t\tif (match[1] === 'transparent') {\n\t\t\treturn [0, 0, 0, 0];\n\t\t}\n\n\t\tif (!hasOwnProperty.call(colorNames, match[1])) {\n\t\t\treturn null;\n\t\t}\n\n\t\trgb = colorNames[match[1]];\n\t\trgb[3] = 1;\n\n\t\treturn rgb;\n\t} else {\n\t\treturn null;\n\t}\n\n\tfor (i = 0; i < 3; i++) {\n\t\trgb[i] = clamp(rgb[i], 0, 255);\n\t}\n\trgb[3] = clamp(rgb[3], 0, 1);\n\n\treturn rgb;\n};\n\ncs.get.hsl = function (string) {\n\tif (!string) {\n\t\treturn null;\n\t}\n\n\tvar hsl = /^hsla?\\(\\s*([+-]?(?:\\d{0,3}\\.)?\\d+)(?:deg)?\\s*,?\\s*([+-]?[\\d\\.]+)%\\s*,?\\s*([+-]?[\\d\\.]+)%\\s*(?:[,|\\/]\\s*([+-]?(?=\\.\\d|\\d)(?:0|[1-9]\\d*)?(?:\\.\\d*)?(?:[eE][+-]?\\d+)?)\\s*)?\\)$/;\n\tvar match = string.match(hsl);\n\n\tif (match) {\n\t\tvar alpha = parseFloat(match[4]);\n\t\tvar h = ((parseFloat(match[1]) % 360) + 360) % 360;\n\t\tvar s = clamp(parseFloat(match[2]), 0, 100);\n\t\tvar l = clamp(parseFloat(match[3]), 0, 100);\n\t\tvar a = clamp(isNaN(alpha) ? 1 : alpha, 0, 1);\n\n\t\treturn [h, s, l, a];\n\t}\n\n\treturn null;\n};\n\ncs.get.hwb = function (string) {\n\tif (!string) {\n\t\treturn null;\n\t}\n\n\tvar hwb = /^hwb\\(\\s*([+-]?\\d{0,3}(?:\\.\\d+)?)(?:deg)?\\s*,\\s*([+-]?[\\d\\.]+)%\\s*,\\s*([+-]?[\\d\\.]+)%\\s*(?:,\\s*([+-]?(?=\\.\\d|\\d)(?:0|[1-9]\\d*)?(?:\\.\\d*)?(?:[eE][+-]?\\d+)?)\\s*)?\\)$/;\n\tvar match = string.match(hwb);\n\n\tif (match) {\n\t\tvar alpha = parseFloat(match[4]);\n\t\tvar h = ((parseFloat(match[1]) % 360) + 360) % 360;\n\t\tvar w = clamp(parseFloat(match[2]), 0, 100);\n\t\tvar b = clamp(parseFloat(match[3]), 0, 100);\n\t\tvar a = clamp(isNaN(alpha) ? 1 : alpha, 0, 1);\n\t\treturn [h, w, b, a];\n\t}\n\n\treturn null;\n};\n\ncs.to.hex = function () {\n\tvar rgba = swizzle(arguments);\n\n\treturn (\n\t\t'#' +\n\t\thexDouble(rgba[0]) +\n\t\thexDouble(rgba[1]) +\n\t\thexDouble(rgba[2]) +\n\t\t(rgba[3] < 1\n\t\t\t? (hexDouble(Math.round(rgba[3] * 255)))\n\t\t\t: '')\n\t);\n};\n\ncs.to.rgb = function () {\n\tvar rgba = swizzle(arguments);\n\n\treturn rgba.length < 4 || rgba[3] === 1\n\t\t? 'rgb(' + Math.round(rgba[0]) + ', ' + Math.round(rgba[1]) + ', ' + Math.round(rgba[2]) + ')'\n\t\t: 'rgba(' + Math.round(rgba[0]) + ', ' + Math.round(rgba[1]) + ', ' + Math.round(rgba[2]) + ', ' + rgba[3] + ')';\n};\n\ncs.to.rgb.percent = function () {\n\tvar rgba = swizzle(arguments);\n\n\tvar r = Math.round(rgba[0] / 255 * 100);\n\tvar g = Math.round(rgba[1] / 255 * 100);\n\tvar b = Math.round(rgba[2] / 255 * 100);\n\n\treturn rgba.length < 4 || rgba[3] === 1\n\t\t? 'rgb(' + r + '%, ' + g + '%, ' + b + '%)'\n\t\t: 'rgba(' + r + '%, ' + g + '%, ' + b + '%, ' + rgba[3] + ')';\n};\n\ncs.to.hsl = function () {\n\tvar hsla = swizzle(arguments);\n\treturn hsla.length < 4 || hsla[3] === 1\n\t\t? 'hsl(' + hsla[0] + ', ' + hsla[1] + '%, ' + hsla[2] + '%)'\n\t\t: 'hsla(' + hsla[0] + ', ' + hsla[1] + '%, ' + hsla[2] + '%, ' + hsla[3] + ')';\n};\n\n// hwb is a bit different than rgb(a) & hsl(a) since there is no alpha specific syntax\n// (hwb have alpha optional & 1 is default value)\ncs.to.hwb = function () {\n\tvar hwba = swizzle(arguments);\n\n\tvar a = '';\n\tif (hwba.length >= 4 && hwba[3] !== 1) {\n\t\ta = ', ' + hwba[3];\n\t}\n\n\treturn 'hwb(' + hwba[0] + ', ' + hwba[1] + '%, ' + hwba[2] + '%' + a + ')';\n};\n\ncs.to.keyword = function (rgb) {\n\treturn reverseNames[rgb.slice(0, 3)];\n};\n\n// helpers\nfunction clamp(num, min, max) {\n\treturn Math.min(Math.max(min, num), max);\n}\n\nfunction hexDouble(num) {\n\tvar str = Math.round(num).toString(16).toUpperCase();\n\treturn (str.length < 2) ? '0' + str : str;\n}\n", "/* MIT license */\n/* eslint-disable no-mixed-operators */\nconst cssKeywords = require('color-name');\n\n// NOTE: conversions should only return primitive values (i.e. arrays, or\n// values that give correct `typeof` results).\n// do not use box values types (i.e. Number(), String(), etc.)\n\nconst reverseKeywords = {};\nfor (const key of Object.keys(cssKeywords)) {\n\treverseKeywords[cssKeywords[key]] = key;\n}\n\nconst convert = {\n\trgb: {channels: 3, labels: 'rgb'},\n\thsl: {channels: 3, labels: 'hsl'},\n\thsv: {channels: 3, labels: 'hsv'},\n\thwb: {channels: 3, labels: 'hwb'},\n\tcmyk: {channels: 4, labels: 'cmyk'},\n\txyz: {channels: 3, labels: 'xyz'},\n\tlab: {channels: 3, labels: 'lab'},\n\tlch: {channels: 3, labels: 'lch'},\n\thex: {channels: 1, labels: ['hex']},\n\tkeyword: {channels: 1, labels: ['keyword']},\n\tansi16: {channels: 1, labels: ['ansi16']},\n\tansi256: {channels: 1, labels: ['ansi256']},\n\thcg: {channels: 3, labels: ['h', 'c', 'g']},\n\tapple: {channels: 3, labels: ['r16', 'g16', 'b16']},\n\tgray: {channels: 1, labels: ['gray']}\n};\n\nmodule.exports = convert;\n\n// Hide .channels and .labels properties\nfor (const model of Object.keys(convert)) {\n\tif (!('channels' in convert[model])) {\n\t\tthrow new Error('missing channels property: ' + model);\n\t}\n\n\tif (!('labels' in convert[model])) {\n\t\tthrow new Error('missing channel labels property: ' + model);\n\t}\n\n\tif (convert[model].labels.length !== convert[model].channels) {\n\t\tthrow new Error('channel and label counts mismatch: ' + model);\n\t}\n\n\tconst {channels, labels} = convert[model];\n\tdelete convert[model].channels;\n\tdelete convert[model].labels;\n\tObject.defineProperty(convert[model], 'channels', {value: channels});\n\tObject.defineProperty(convert[model], 'labels', {value: labels});\n}\n\nconvert.rgb.hsl = function (rgb) {\n\tconst r = rgb[0] / 255;\n\tconst g = rgb[1] / 255;\n\tconst b = rgb[2] / 255;\n\tconst min = Math.min(r, g, b);\n\tconst max = Math.max(r, g, b);\n\tconst delta = max - min;\n\tlet h;\n\tlet s;\n\n\tif (max === min) {\n\t\th = 0;\n\t} else if (r === max) {\n\t\th = (g - b) / delta;\n\t} else if (g === max) {\n\t\th = 2 + (b - r) / delta;\n\t} else if (b === max) {\n\t\th = 4 + (r - g) / delta;\n\t}\n\n\th = Math.min(h * 60, 360);\n\n\tif (h < 0) {\n\t\th += 360;\n\t}\n\n\tconst l = (min + max) / 2;\n\n\tif (max === min) {\n\t\ts = 0;\n\t} else if (l <= 0.5) {\n\t\ts = delta / (max + min);\n\t} else {\n\t\ts = delta / (2 - max - min);\n\t}\n\n\treturn [h, s * 100, l * 100];\n};\n\nconvert.rgb.hsv = function (rgb) {\n\tlet rdif;\n\tlet gdif;\n\tlet bdif;\n\tlet h;\n\tlet s;\n\n\tconst r = rgb[0] / 255;\n\tconst g = rgb[1] / 255;\n\tconst b = rgb[2] / 255;\n\tconst v = Math.max(r, g, b);\n\tconst diff = v - Math.min(r, g, b);\n\tconst diffc = function (c) {\n\t\treturn (v - c) / 6 / diff + 1 / 2;\n\t};\n\n\tif (diff === 0) {\n\t\th = 0;\n\t\ts = 0;\n\t} else {\n\t\ts = diff / v;\n\t\trdif = diffc(r);\n\t\tgdif = diffc(g);\n\t\tbdif = diffc(b);\n\n\t\tif (r === v) {\n\t\t\th = bdif - gdif;\n\t\t} else if (g === v) {\n\t\t\th = (1 / 3) + rdif - bdif;\n\t\t} else if (b === v) {\n\t\t\th = (2 / 3) + gdif - rdif;\n\t\t}\n\n\t\tif (h < 0) {\n\t\t\th += 1;\n\t\t} else if (h > 1) {\n\t\t\th -= 1;\n\t\t}\n\t}\n\n\treturn [\n\t\th * 360,\n\t\ts * 100,\n\t\tv * 100\n\t];\n};\n\nconvert.rgb.hwb = function (rgb) {\n\tconst r = rgb[0];\n\tconst g = rgb[1];\n\tlet b = rgb[2];\n\tconst h = convert.rgb.hsl(rgb)[0];\n\tconst w = 1 / 255 * Math.min(r, Math.min(g, b));\n\n\tb = 1 - 1 / 255 * Math.max(r, Math.max(g, b));\n\n\treturn [h, w * 100, b * 100];\n};\n\nconvert.rgb.cmyk = function (rgb) {\n\tconst r = rgb[0] / 255;\n\tconst g = rgb[1] / 255;\n\tconst b = rgb[2] / 255;\n\n\tconst k = Math.min(1 - r, 1 - g, 1 - b);\n\tconst c = (1 - r - k) / (1 - k) || 0;\n\tconst m = (1 - g - k) / (1 - k) || 0;\n\tconst y = (1 - b - k) / (1 - k) || 0;\n\n\treturn [c * 100, m * 100, y * 100, k * 100];\n};\n\nfunction comparativeDistance(x, y) {\n\t/*\n\t\tSee https://en.m.wikipedia.org/wiki/Euclidean_distance#Squared_Euclidean_distance\n\t*/\n\treturn (\n\t\t((x[0] - y[0]) ** 2) +\n\t\t((x[1] - y[1]) ** 2) +\n\t\t((x[2] - y[2]) ** 2)\n\t);\n}\n\nconvert.rgb.keyword = function (rgb) {\n\tconst reversed = reverseKeywords[rgb];\n\tif (reversed) {\n\t\treturn reversed;\n\t}\n\n\tlet currentClosestDistance = Infinity;\n\tlet currentClosestKeyword;\n\n\tfor (const keyword of Object.keys(cssKeywords)) {\n\t\tconst value = cssKeywords[keyword];\n\n\t\t// Compute comparative distance\n\t\tconst distance = comparativeDistance(rgb, value);\n\n\t\t// Check if its less, if so set as closest\n\t\tif (distance < currentClosestDistance) {\n\t\t\tcurrentClosestDistance = distance;\n\t\t\tcurrentClosestKeyword = keyword;\n\t\t}\n\t}\n\n\treturn currentClosestKeyword;\n};\n\nconvert.keyword.rgb = function (keyword) {\n\treturn cssKeywords[keyword];\n};\n\nconvert.rgb.xyz = function (rgb) {\n\tlet r = rgb[0] / 255;\n\tlet g = rgb[1] / 255;\n\tlet b = rgb[2] / 255;\n\n\t// Assume sRGB\n\tr = r > 0.04045 ? (((r + 0.055) / 1.055) ** 2.4) : (r / 12.92);\n\tg = g > 0.04045 ? (((g + 0.055) / 1.055) ** 2.4) : (g / 12.92);\n\tb = b > 0.04045 ? (((b + 0.055) / 1.055) ** 2.4) : (b / 12.92);\n\n\tconst x = (r * 0.4124) + (g * 0.3576) + (b * 0.1805);\n\tconst y = (r * 0.2126) + (g * 0.7152) + (b * 0.0722);\n\tconst z = (r * 0.0193) + (g * 0.1192) + (b * 0.9505);\n\n\treturn [x * 100, y * 100, z * 100];\n};\n\nconvert.rgb.lab = function (rgb) {\n\tconst xyz = convert.rgb.xyz(rgb);\n\tlet x = xyz[0];\n\tlet y = xyz[1];\n\tlet z = xyz[2];\n\n\tx /= 95.047;\n\ty /= 100;\n\tz /= 108.883;\n\n\tx = x > 0.008856 ? (x ** (1 / 3)) : (7.787 * x) + (16 / 116);\n\ty = y > 0.008856 ? (y ** (1 / 3)) : (7.787 * y) + (16 / 116);\n\tz = z > 0.008856 ? (z ** (1 / 3)) : (7.787 * z) + (16 / 116);\n\n\tconst l = (116 * y) - 16;\n\tconst a = 500 * (x - y);\n\tconst b = 200 * (y - z);\n\n\treturn [l, a, b];\n};\n\nconvert.hsl.rgb = function (hsl) {\n\tconst h = hsl[0] / 360;\n\tconst s = hsl[1] / 100;\n\tconst l = hsl[2] / 100;\n\tlet t2;\n\tlet t3;\n\tlet val;\n\n\tif (s === 0) {\n\t\tval = l * 255;\n\t\treturn [val, val, val];\n\t}\n\n\tif (l < 0.5) {\n\t\tt2 = l * (1 + s);\n\t} else {\n\t\tt2 = l + s - l * s;\n\t}\n\n\tconst t1 = 2 * l - t2;\n\n\tconst rgb = [0, 0, 0];\n\tfor (let i = 0; i < 3; i++) {\n\t\tt3 = h + 1 / 3 * -(i - 1);\n\t\tif (t3 < 0) {\n\t\t\tt3++;\n\t\t}\n\n\t\tif (t3 > 1) {\n\t\t\tt3--;\n\t\t}\n\n\t\tif (6 * t3 < 1) {\n\t\t\tval = t1 + (t2 - t1) * 6 * t3;\n\t\t} else if (2 * t3 < 1) {\n\t\t\tval = t2;\n\t\t} else if (3 * t3 < 2) {\n\t\t\tval = t1 + (t2 - t1) * (2 / 3 - t3) * 6;\n\t\t} else {\n\t\t\tval = t1;\n\t\t}\n\n\t\trgb[i] = val * 255;\n\t}\n\n\treturn rgb;\n};\n\nconvert.hsl.hsv = function (hsl) {\n\tconst h = hsl[0];\n\tlet s = hsl[1] / 100;\n\tlet l = hsl[2] / 100;\n\tlet smin = s;\n\tconst lmin = Math.max(l, 0.01);\n\n\tl *= 2;\n\ts *= (l <= 1) ? l : 2 - l;\n\tsmin *= lmin <= 1 ? lmin : 2 - lmin;\n\tconst v = (l + s) / 2;\n\tconst sv = l === 0 ? (2 * smin) / (lmin + smin) : (2 * s) / (l + s);\n\n\treturn [h, sv * 100, v * 100];\n};\n\nconvert.hsv.rgb = function (hsv) {\n\tconst h = hsv[0] / 60;\n\tconst s = hsv[1] / 100;\n\tlet v = hsv[2] / 100;\n\tconst hi = Math.floor(h) % 6;\n\n\tconst f = h - Math.floor(h);\n\tconst p = 255 * v * (1 - s);\n\tconst q = 255 * v * (1 - (s * f));\n\tconst t = 255 * v * (1 - (s * (1 - f)));\n\tv *= 255;\n\n\tswitch (hi) {\n\t\tcase 0:\n\t\t\treturn [v, t, p];\n\t\tcase 1:\n\t\t\treturn [q, v, p];\n\t\tcase 2:\n\t\t\treturn [p, v, t];\n\t\tcase 3:\n\t\t\treturn [p, q, v];\n\t\tcase 4:\n\t\t\treturn [t, p, v];\n\t\tcase 5:\n\t\t\treturn [v, p, q];\n\t}\n};\n\nconvert.hsv.hsl = function (hsv) {\n\tconst h = hsv[0];\n\tconst s = hsv[1] / 100;\n\tconst v = hsv[2] / 100;\n\tconst vmin = Math.max(v, 0.01);\n\tlet sl;\n\tlet l;\n\n\tl = (2 - s) * v;\n\tconst lmin = (2 - s) * vmin;\n\tsl = s * vmin;\n\tsl /= (lmin <= 1) ? lmin : 2 - lmin;\n\tsl = sl || 0;\n\tl /= 2;\n\n\treturn [h, sl * 100, l * 100];\n};\n\n// http://dev.w3.org/csswg/css-color/#hwb-to-rgb\nconvert.hwb.rgb = function (hwb) {\n\tconst h = hwb[0] / 360;\n\tlet wh = hwb[1] / 100;\n\tlet bl = hwb[2] / 100;\n\tconst ratio = wh + bl;\n\tlet f;\n\n\t// Wh + bl cant be > 1\n\tif (ratio > 1) {\n\t\twh /= ratio;\n\t\tbl /= ratio;\n\t}\n\n\tconst i = Math.floor(6 * h);\n\tconst v = 1 - bl;\n\tf = 6 * h - i;\n\n\tif ((i & 0x01) !== 0) {\n\t\tf = 1 - f;\n\t}\n\n\tconst n = wh + f * (v - wh); // Linear interpolation\n\n\tlet r;\n\tlet g;\n\tlet b;\n\t/* eslint-disable max-statements-per-line,no-multi-spaces */\n\tswitch (i) {\n\t\tdefault:\n\t\tcase 6:\n\t\tcase 0: r = v; g = n; b = wh; break;\n\t\tcase 1: r = n; g = v; b = wh; break;\n\t\tcase 2: r = wh; g = v; b = n; break;\n\t\tcase 3: r = wh; g = n; b = v; break;\n\t\tcase 4: r = n; g = wh; b = v; break;\n\t\tcase 5: r = v; g = wh; b = n; break;\n\t}\n\t/* eslint-enable max-statements-per-line,no-multi-spaces */\n\n\treturn [r * 255, g * 255, b * 255];\n};\n\nconvert.cmyk.rgb = function (cmyk) {\n\tconst c = cmyk[0] / 100;\n\tconst m = cmyk[1] / 100;\n\tconst y = cmyk[2] / 100;\n\tconst k = cmyk[3] / 100;\n\n\tconst r = 1 - Math.min(1, c * (1 - k) + k);\n\tconst g = 1 - Math.min(1, m * (1 - k) + k);\n\tconst b = 1 - Math.min(1, y * (1 - k) + k);\n\n\treturn [r * 255, g * 255, b * 255];\n};\n\nconvert.xyz.rgb = function (xyz) {\n\tconst x = xyz[0] / 100;\n\tconst y = xyz[1] / 100;\n\tconst z = xyz[2] / 100;\n\tlet r;\n\tlet g;\n\tlet b;\n\n\tr = (x * 3.2406) + (y * -1.5372) + (z * -0.4986);\n\tg = (x * -0.9689) + (y * 1.8758) + (z * 0.0415);\n\tb = (x * 0.0557) + (y * -0.2040) + (z * 1.0570);\n\n\t// Assume sRGB\n\tr = r > 0.0031308\n\t\t? ((1.055 * (r ** (1.0 / 2.4))) - 0.055)\n\t\t: r * 12.92;\n\n\tg = g > 0.0031308\n\t\t? ((1.055 * (g ** (1.0 / 2.4))) - 0.055)\n\t\t: g * 12.92;\n\n\tb = b > 0.0031308\n\t\t? ((1.055 * (b ** (1.0 / 2.4))) - 0.055)\n\t\t: b * 12.92;\n\n\tr = Math.min(Math.max(0, r), 1);\n\tg = Math.min(Math.max(0, g), 1);\n\tb = Math.min(Math.max(0, b), 1);\n\n\treturn [r * 255, g * 255, b * 255];\n};\n\nconvert.xyz.lab = function (xyz) {\n\tlet x = xyz[0];\n\tlet y = xyz[1];\n\tlet z = xyz[2];\n\n\tx /= 95.047;\n\ty /= 100;\n\tz /= 108.883;\n\n\tx = x > 0.008856 ? (x ** (1 / 3)) : (7.787 * x) + (16 / 116);\n\ty = y > 0.008856 ? (y ** (1 / 3)) : (7.787 * y) + (16 / 116);\n\tz = z > 0.008856 ? (z ** (1 / 3)) : (7.787 * z) + (16 / 116);\n\n\tconst l = (116 * y) - 16;\n\tconst a = 500 * (x - y);\n\tconst b = 200 * (y - z);\n\n\treturn [l, a, b];\n};\n\nconvert.lab.xyz = function (lab) {\n\tconst l = lab[0];\n\tconst a = lab[1];\n\tconst b = lab[2];\n\tlet x;\n\tlet y;\n\tlet z;\n\n\ty = (l + 16) / 116;\n\tx = a / 500 + y;\n\tz = y - b / 200;\n\n\tconst y2 = y ** 3;\n\tconst x2 = x ** 3;\n\tconst z2 = z ** 3;\n\ty = y2 > 0.008856 ? y2 : (y - 16 / 116) / 7.787;\n\tx = x2 > 0.008856 ? x2 : (x - 16 / 116) / 7.787;\n\tz = z2 > 0.008856 ? z2 : (z - 16 / 116) / 7.787;\n\n\tx *= 95.047;\n\ty *= 100;\n\tz *= 108.883;\n\n\treturn [x, y, z];\n};\n\nconvert.lab.lch = function (lab) {\n\tconst l = lab[0];\n\tconst a = lab[1];\n\tconst b = lab[2];\n\tlet h;\n\n\tconst hr = Math.atan2(b, a);\n\th = hr * 360 / 2 / Math.PI;\n\n\tif (h < 0) {\n\t\th += 360;\n\t}\n\n\tconst c = Math.sqrt(a * a + b * b);\n\n\treturn [l, c, h];\n};\n\nconvert.lch.lab = function (lch) {\n\tconst l = lch[0];\n\tconst c = lch[1];\n\tconst h = lch[2];\n\n\tconst hr = h / 360 * 2 * Math.PI;\n\tconst a = c * Math.cos(hr);\n\tconst b = c * Math.sin(hr);\n\n\treturn [l, a, b];\n};\n\nconvert.rgb.ansi16 = function (args, saturation = null) {\n\tconst [r, g, b] = args;\n\tlet value = saturation === null ? convert.rgb.hsv(args)[2] : saturation; // Hsv -> ansi16 optimization\n\n\tvalue = Math.round(value / 50);\n\n\tif (value === 0) {\n\t\treturn 30;\n\t}\n\n\tlet ansi = 30\n\t\t+ ((Math.round(b / 255) << 2)\n\t\t| (Math.round(g / 255) << 1)\n\t\t| Math.round(r / 255));\n\n\tif (value === 2) {\n\t\tansi += 60;\n\t}\n\n\treturn ansi;\n};\n\nconvert.hsv.ansi16 = function (args) {\n\t// Optimization here; we already know the value and don't need to get\n\t// it converted for us.\n\treturn convert.rgb.ansi16(convert.hsv.rgb(args), args[2]);\n};\n\nconvert.rgb.ansi256 = function (args) {\n\tconst r = args[0];\n\tconst g = args[1];\n\tconst b = args[2];\n\n\t// We use the extended greyscale palette here, with the exception of\n\t// black and white. normal palette only has 4 greyscale shades.\n\tif (r === g && g === b) {\n\t\tif (r < 8) {\n\t\t\treturn 16;\n\t\t}\n\n\t\tif (r > 248) {\n\t\t\treturn 231;\n\t\t}\n\n\t\treturn Math.round(((r - 8) / 247) * 24) + 232;\n\t}\n\n\tconst ansi = 16\n\t\t+ (36 * Math.round(r / 255 * 5))\n\t\t+ (6 * Math.round(g / 255 * 5))\n\t\t+ Math.round(b / 255 * 5);\n\n\treturn ansi;\n};\n\nconvert.ansi16.rgb = function (args) {\n\tlet color = args % 10;\n\n\t// Handle greyscale\n\tif (color === 0 || color === 7) {\n\t\tif (args > 50) {\n\t\t\tcolor += 3.5;\n\t\t}\n\n\t\tcolor = color / 10.5 * 255;\n\n\t\treturn [color, color, color];\n\t}\n\n\tconst mult = (~~(args > 50) + 1) * 0.5;\n\tconst r = ((color & 1) * mult) * 255;\n\tconst g = (((color >> 1) & 1) * mult) * 255;\n\tconst b = (((color >> 2) & 1) * mult) * 255;\n\n\treturn [r, g, b];\n};\n\nconvert.ansi256.rgb = function (args) {\n\t// Handle greyscale\n\tif (args >= 232) {\n\t\tconst c = (args - 232) * 10 + 8;\n\t\treturn [c, c, c];\n\t}\n\n\targs -= 16;\n\n\tlet rem;\n\tconst r = Math.floor(args / 36) / 5 * 255;\n\tconst g = Math.floor((rem = args % 36) / 6) / 5 * 255;\n\tconst b = (rem % 6) / 5 * 255;\n\n\treturn [r, g, b];\n};\n\nconvert.rgb.hex = function (args) {\n\tconst integer = ((Math.round(args[0]) & 0xFF) << 16)\n\t\t+ ((Math.round(args[1]) & 0xFF) << 8)\n\t\t+ (Math.round(args[2]) & 0xFF);\n\n\tconst string = integer.toString(16).toUpperCase();\n\treturn '000000'.substring(string.length) + string;\n};\n\nconvert.hex.rgb = function (args) {\n\tconst match = args.toString(16).match(/[a-f0-9]{6}|[a-f0-9]{3}/i);\n\tif (!match) {\n\t\treturn [0, 0, 0];\n\t}\n\n\tlet colorString = match[0];\n\n\tif (match[0].length === 3) {\n\t\tcolorString = colorString.split('').map(char => {\n\t\t\treturn char + char;\n\t\t}).join('');\n\t}\n\n\tconst integer = parseInt(colorString, 16);\n\tconst r = (integer >> 16) & 0xFF;\n\tconst g = (integer >> 8) & 0xFF;\n\tconst b = integer & 0xFF;\n\n\treturn [r, g, b];\n};\n\nconvert.rgb.hcg = function (rgb) {\n\tconst r = rgb[0] / 255;\n\tconst g = rgb[1] / 255;\n\tconst b = rgb[2] / 255;\n\tconst max = Math.max(Math.max(r, g), b);\n\tconst min = Math.min(Math.min(r, g), b);\n\tconst chroma = (max - min);\n\tlet grayscale;\n\tlet hue;\n\n\tif (chroma < 1) {\n\t\tgrayscale = min / (1 - chroma);\n\t} else {\n\t\tgrayscale = 0;\n\t}\n\n\tif (chroma <= 0) {\n\t\thue = 0;\n\t} else\n\tif (max === r) {\n\t\thue = ((g - b) / chroma) % 6;\n\t} else\n\tif (max === g) {\n\t\thue = 2 + (b - r) / chroma;\n\t} else {\n\t\thue = 4 + (r - g) / chroma;\n\t}\n\n\thue /= 6;\n\thue %= 1;\n\n\treturn [hue * 360, chroma * 100, grayscale * 100];\n};\n\nconvert.hsl.hcg = function (hsl) {\n\tconst s = hsl[1] / 100;\n\tconst l = hsl[2] / 100;\n\n\tconst c = l < 0.5 ? (2.0 * s * l) : (2.0 * s * (1.0 - l));\n\n\tlet f = 0;\n\tif (c < 1.0) {\n\t\tf = (l - 0.5 * c) / (1.0 - c);\n\t}\n\n\treturn [hsl[0], c * 100, f * 100];\n};\n\nconvert.hsv.hcg = function (hsv) {\n\tconst s = hsv[1] / 100;\n\tconst v = hsv[2] / 100;\n\n\tconst c = s * v;\n\tlet f = 0;\n\n\tif (c < 1.0) {\n\t\tf = (v - c) / (1 - c);\n\t}\n\n\treturn [hsv[0], c * 100, f * 100];\n};\n\nconvert.hcg.rgb = function (hcg) {\n\tconst h = hcg[0] / 360;\n\tconst c = hcg[1] / 100;\n\tconst g = hcg[2] / 100;\n\n\tif (c === 0.0) {\n\t\treturn [g * 255, g * 255, g * 255];\n\t}\n\n\tconst pure = [0, 0, 0];\n\tconst hi = (h % 1) * 6;\n\tconst v = hi % 1;\n\tconst w = 1 - v;\n\tlet mg = 0;\n\n\t/* eslint-disable max-statements-per-line */\n\tswitch (Math.floor(hi)) {\n\t\tcase 0:\n\t\t\tpure[0] = 1; pure[1] = v; pure[2] = 0; break;\n\t\tcase 1:\n\t\t\tpure[0] = w; pure[1] = 1; pure[2] = 0; break;\n\t\tcase 2:\n\t\t\tpure[0] = 0; pure[1] = 1; pure[2] = v; break;\n\t\tcase 3:\n\t\t\tpure[0] = 0; pure[1] = w; pure[2] = 1; break;\n\t\tcase 4:\n\t\t\tpure[0] = v; pure[1] = 0; pure[2] = 1; break;\n\t\tdefault:\n\t\t\tpure[0] = 1; pure[1] = 0; pure[2] = w;\n\t}\n\t/* eslint-enable max-statements-per-line */\n\n\tmg = (1.0 - c) * g;\n\n\treturn [\n\t\t(c * pure[0] + mg) * 255,\n\t\t(c * pure[1] + mg) * 255,\n\t\t(c * pure[2] + mg) * 255\n\t];\n};\n\nconvert.hcg.hsv = function (hcg) {\n\tconst c = hcg[1] / 100;\n\tconst g = hcg[2] / 100;\n\n\tconst v = c + g * (1.0 - c);\n\tlet f = 0;\n\n\tif (v > 0.0) {\n\t\tf = c / v;\n\t}\n\n\treturn [hcg[0], f * 100, v * 100];\n};\n\nconvert.hcg.hsl = function (hcg) {\n\tconst c = hcg[1] / 100;\n\tconst g = hcg[2] / 100;\n\n\tconst l = g * (1.0 - c) + 0.5 * c;\n\tlet s = 0;\n\n\tif (l > 0.0 && l < 0.5) {\n\t\ts = c / (2 * l);\n\t} else\n\tif (l >= 0.5 && l < 1.0) {\n\t\ts = c / (2 * (1 - l));\n\t}\n\n\treturn [hcg[0], s * 100, l * 100];\n};\n\nconvert.hcg.hwb = function (hcg) {\n\tconst c = hcg[1] / 100;\n\tconst g = hcg[2] / 100;\n\tconst v = c + g * (1.0 - c);\n\treturn [hcg[0], (v - c) * 100, (1 - v) * 100];\n};\n\nconvert.hwb.hcg = function (hwb) {\n\tconst w = hwb[1] / 100;\n\tconst b = hwb[2] / 100;\n\tconst v = 1 - b;\n\tconst c = v - w;\n\tlet g = 0;\n\n\tif (c < 1) {\n\t\tg = (v - c) / (1 - c);\n\t}\n\n\treturn [hwb[0], c * 100, g * 100];\n};\n\nconvert.apple.rgb = function (apple) {\n\treturn [(apple[0] / 65535) * 255, (apple[1] / 65535) * 255, (apple[2] / 65535) * 255];\n};\n\nconvert.rgb.apple = function (rgb) {\n\treturn [(rgb[0] / 255) * 65535, (rgb[1] / 255) * 65535, (rgb[2] / 255) * 65535];\n};\n\nconvert.gray.rgb = function (args) {\n\treturn [args[0] / 100 * 255, args[0] / 100 * 255, args[0] / 100 * 255];\n};\n\nconvert.gray.hsl = function (args) {\n\treturn [0, 0, args[0]];\n};\n\nconvert.gray.hsv = convert.gray.hsl;\n\nconvert.gray.hwb = function (gray) {\n\treturn [0, 100, gray[0]];\n};\n\nconvert.gray.cmyk = function (gray) {\n\treturn [0, 0, 0, gray[0]];\n};\n\nconvert.gray.lab = function (gray) {\n\treturn [gray[0], 0, 0];\n};\n\nconvert.gray.hex = function (gray) {\n\tconst val = Math.round(gray[0] / 100 * 255) & 0xFF;\n\tconst integer = (val << 16) + (val << 8) + val;\n\n\tconst string = integer.toString(16).toUpperCase();\n\treturn '000000'.substring(string.length) + string;\n};\n\nconvert.rgb.gray = function (rgb) {\n\tconst val = (rgb[0] + rgb[1] + rgb[2]) / 3;\n\treturn [val / 255 * 100];\n};\n", "const conversions = require('./conversions');\n\n/*\n\tThis function routes a model to all other models.\n\n\tall functions that are routed have a property `.conversion` attached\n\tto the returned synthetic function. This property is an array\n\tof strings, each with the steps in between the 'from' and 'to'\n\tcolor models (inclusive).\n\n\tconversions that are not possible simply are not included.\n*/\n\nfunction buildGraph() {\n\tconst graph = {};\n\t// https://jsperf.com/object-keys-vs-for-in-with-closure/3\n\tconst models = Object.keys(conversions);\n\n\tfor (let len = models.length, i = 0; i < len; i++) {\n\t\tgraph[models[i]] = {\n\t\t\t// http://jsperf.com/1-vs-infinity\n\t\t\t// micro-opt, but this is simple.\n\t\t\tdistance: -1,\n\t\t\tparent: null\n\t\t};\n\t}\n\n\treturn graph;\n}\n\n// https://en.wikipedia.org/wiki/Breadth-first_search\nfunction deriveBFS(fromModel) {\n\tconst graph = buildGraph();\n\tconst queue = [fromModel]; // Unshift -> queue -> pop\n\n\tgraph[fromModel].distance = 0;\n\n\twhile (queue.length) {\n\t\tconst current = queue.pop();\n\t\tconst adjacents = Object.keys(conversions[current]);\n\n\t\tfor (let len = adjacents.length, i = 0; i < len; i++) {\n\t\t\tconst adjacent = adjacents[i];\n\t\t\tconst node = graph[adjacent];\n\n\t\t\tif (node.distance === -1) {\n\t\t\t\tnode.distance = graph[current].distance + 1;\n\t\t\t\tnode.parent = current;\n\t\t\t\tqueue.unshift(adjacent);\n\t\t\t}\n\t\t}\n\t}\n\n\treturn graph;\n}\n\nfunction link(from, to) {\n\treturn function (args) {\n\t\treturn to(from(args));\n\t};\n}\n\nfunction wrapConversion(toModel, graph) {\n\tconst path = [graph[toModel].parent, toModel];\n\tlet fn = conversions[graph[toModel].parent][toModel];\n\n\tlet cur = graph[toModel].parent;\n\twhile (graph[cur].parent) {\n\t\tpath.unshift(graph[cur].parent);\n\t\tfn = link(conversions[graph[cur].parent][cur], fn);\n\t\tcur = graph[cur].parent;\n\t}\n\n\tfn.conversion = path;\n\treturn fn;\n}\n\nmodule.exports = function (fromModel) {\n\tconst graph = deriveBFS(fromModel);\n\tconst conversion = {};\n\n\tconst models = Object.keys(graph);\n\tfor (let len = models.length, i = 0; i < len; i++) {\n\t\tconst toModel = models[i];\n\t\tconst node = graph[toModel];\n\n\t\tif (node.parent === null) {\n\t\t\t// No possible conversion, or this node is the source model.\n\t\t\tcontinue;\n\t\t}\n\n\t\tconversion[toModel] = wrapConversion(toModel, graph);\n\t}\n\n\treturn conversion;\n};\n\n", "const conversions = require('./conversions');\nconst route = require('./route');\n\nconst convert = {};\n\nconst models = Object.keys(conversions);\n\nfunction wrapRaw(fn) {\n\tconst wrappedFn = function (...args) {\n\t\tconst arg0 = args[0];\n\t\tif (arg0 === undefined || arg0 === null) {\n\t\t\treturn arg0;\n\t\t}\n\n\t\tif (arg0.length > 1) {\n\t\t\targs = arg0;\n\t\t}\n\n\t\treturn fn(args);\n\t};\n\n\t// Preserve .conversion property if there is one\n\tif ('conversion' in fn) {\n\t\twrappedFn.conversion = fn.conversion;\n\t}\n\n\treturn wrappedFn;\n}\n\nfunction wrapRounded(fn) {\n\tconst wrappedFn = function (...args) {\n\t\tconst arg0 = args[0];\n\n\t\tif (arg0 === undefined || arg0 === null) {\n\t\t\treturn arg0;\n\t\t}\n\n\t\tif (arg0.length > 1) {\n\t\t\targs = arg0;\n\t\t}\n\n\t\tconst result = fn(args);\n\n\t\t// We're assuming the result is an array here.\n\t\t// see notice in conversions.js; don't use box types\n\t\t// in conversion functions.\n\t\tif (typeof result === 'object') {\n\t\t\tfor (let len = result.length, i = 0; i < len; i++) {\n\t\t\t\tresult[i] = Math.round(result[i]);\n\t\t\t}\n\t\t}\n\n\t\treturn result;\n\t};\n\n\t// Preserve .conversion property if there is one\n\tif ('conversion' in fn) {\n\t\twrappedFn.conversion = fn.conversion;\n\t}\n\n\treturn wrappedFn;\n}\n\nmodels.forEach(fromModel => {\n\tconvert[fromModel] = {};\n\n\tObject.defineProperty(convert[fromModel], 'channels', {value: conversions[fromModel].channels});\n\tObject.defineProperty(convert[fromModel], 'labels', {value: conversions[fromModel].labels});\n\n\tconst routes = route(fromModel);\n\tconst routeModels = Object.keys(routes);\n\n\trouteModels.forEach(toModel => {\n\t\tconst fn = routes[toModel];\n\n\t\tconvert[fromModel][toModel] = wrapRounded(fn);\n\t\tconvert[fromModel][toModel].raw = wrapRaw(fn);\n\t});\n});\n\nmodule.exports = convert;\n", "const colorString = require('color-string');\nconst convert = require('color-convert');\n\nconst skippedModels = [\n\t// To be honest, I don't really feel like keyword belongs in color convert, but eh.\n\t'keyword',\n\n\t// Gray conflicts with some method names, and has its own method defined.\n\t'gray',\n\n\t// Shouldn't really be in color-convert either...\n\t'hex',\n];\n\nconst hashedModelKeys = {};\nfor (const model of Object.keys(convert)) {\n\thashedModelKeys[[...convert[model].labels].sort().join('')] = model;\n}\n\nconst limiters = {};\n\nfunction Color(object, model) {\n\tif (!(this instanceof Color)) {\n\t\treturn new Color(object, model);\n\t}\n\n\tif (model && model in skippedModels) {\n\t\tmodel = null;\n\t}\n\n\tif (model && !(model in convert)) {\n\t\tthrow new Error('Unknown model: ' + model);\n\t}\n\n\tlet i;\n\tlet channels;\n\n\tif (object == null) { // eslint-disable-line no-eq-null,eqeqeq\n\t\tthis.model = 'rgb';\n\t\tthis.color = [0, 0, 0];\n\t\tthis.valpha = 1;\n\t} else if (object instanceof Color) {\n\t\tthis.model = object.model;\n\t\tthis.color = [...object.color];\n\t\tthis.valpha = object.valpha;\n\t} else if (typeof object === 'string') {\n\t\tconst result = colorString.get(object);\n\t\tif (result === null) {\n\t\t\tthrow new Error('Unable to parse color from string: ' + object);\n\t\t}\n\n\t\tthis.model = result.model;\n\t\tchannels = convert[this.model].channels;\n\t\tthis.color = result.value.slice(0, channels);\n\t\tthis.valpha = typeof result.value[channels] === 'number' ? result.value[channels] : 1;\n\t} else if (object.length > 0) {\n\t\tthis.model = model || 'rgb';\n\t\tchannels = convert[this.model].channels;\n\t\tconst newArray = Array.prototype.slice.call(object, 0, channels);\n\t\tthis.color = zeroArray(newArray, channels);\n\t\tthis.valpha = typeof object[channels] === 'number' ? object[channels] : 1;\n\t} else if (typeof object === 'number') {\n\t\t// This is always RGB - can be converted later on.\n\t\tthis.model = 'rgb';\n\t\tthis.color = [\n\t\t\t(object >> 16) & 0xFF,\n\t\t\t(object >> 8) & 0xFF,\n\t\t\tobject & 0xFF,\n\t\t];\n\t\tthis.valpha = 1;\n\t} else {\n\t\tthis.valpha = 1;\n\n\t\tconst keys = Object.keys(object);\n\t\tif ('alpha' in object) {\n\t\t\tkeys.splice(keys.indexOf('alpha'), 1);\n\t\t\tthis.valpha = typeof object.alpha === 'number' ? object.alpha : 0;\n\t\t}\n\n\t\tconst hashedKeys = keys.sort().join('');\n\t\tif (!(hashedKeys in hashedModelKeys)) {\n\t\t\tthrow new Error('Unable to parse color from object: ' + JSON.stringify(object));\n\t\t}\n\n\t\tthis.model = hashedModelKeys[hashedKeys];\n\n\t\tconst {labels} = convert[this.model];\n\t\tconst color = [];\n\t\tfor (i = 0; i < labels.length; i++) {\n\t\t\tcolor.push(object[labels[i]]);\n\t\t}\n\n\t\tthis.color = zeroArray(color);\n\t}\n\n\t// Perform limitations (clamping, etc.)\n\tif (limiters[this.model]) {\n\t\tchannels = convert[this.model].channels;\n\t\tfor (i = 0; i < channels; i++) {\n\t\t\tconst limit = limiters[this.model][i];\n\t\t\tif (limit) {\n\t\t\t\tthis.color[i] = limit(this.color[i]);\n\t\t\t}\n\t\t}\n\t}\n\n\tthis.valpha = Math.max(0, Math.min(1, this.valpha));\n\n\tif (Object.freeze) {\n\t\tObject.freeze(this);\n\t}\n}\n\nColor.prototype = {\n\ttoString() {\n\t\treturn this.string();\n\t},\n\n\ttoJSON() {\n\t\treturn this[this.model]();\n\t},\n\n\tstring(places) {\n\t\tlet self = this.model in colorString.to ? this : this.rgb();\n\t\tself = self.round(typeof places === 'number' ? places : 1);\n\t\tconst args = self.valpha === 1 ? self.color : [...self.color, this.valpha];\n\t\treturn colorString.to[self.model](args);\n\t},\n\n\tpercentString(places) {\n\t\tconst self = this.rgb().round(typeof places === 'number' ? places : 1);\n\t\tconst args = self.valpha === 1 ? self.color : [...self.color, this.valpha];\n\t\treturn colorString.to.rgb.percent(args);\n\t},\n\n\tarray() {\n\t\treturn this.valpha === 1 ? [...this.color] : [...this.color, this.valpha];\n\t},\n\n\tobject() {\n\t\tconst result = {};\n\t\tconst {channels} = convert[this.model];\n\t\tconst {labels} = convert[this.model];\n\n\t\tfor (let i = 0; i < channels; i++) {\n\t\t\tresult[labels[i]] = this.color[i];\n\t\t}\n\n\t\tif (this.valpha !== 1) {\n\t\t\tresult.alpha = this.valpha;\n\t\t}\n\n\t\treturn result;\n\t},\n\n\tunitArray() {\n\t\tconst rgb = this.rgb().color;\n\t\trgb[0] /= 255;\n\t\trgb[1] /= 255;\n\t\trgb[2] /= 255;\n\n\t\tif (this.valpha !== 1) {\n\t\t\trgb.push(this.valpha);\n\t\t}\n\n\t\treturn rgb;\n\t},\n\n\tunitObject() {\n\t\tconst rgb = this.rgb().object();\n\t\trgb.r /= 255;\n\t\trgb.g /= 255;\n\t\trgb.b /= 255;\n\n\t\tif (this.valpha !== 1) {\n\t\t\trgb.alpha = this.valpha;\n\t\t}\n\n\t\treturn rgb;\n\t},\n\n\tround(places) {\n\t\tplaces = Math.max(places || 0, 0);\n\t\treturn new Color([...this.color.map(roundToPlace(places)), this.valpha], this.model);\n\t},\n\n\talpha(value) {\n\t\tif (value !== undefined) {\n\t\t\treturn new Color([...this.color, Math.max(0, Math.min(1, value))], this.model);\n\t\t}\n\n\t\treturn this.valpha;\n\t},\n\n\t// Rgb\n\tred: getset('rgb', 0, maxfn(255)),\n\tgreen: getset('rgb', 1, maxfn(255)),\n\tblue: getset('rgb', 2, maxfn(255)),\n\n\thue: getset(['hsl', 'hsv', 'hsl', 'hwb', 'hcg'], 0, value => ((value % 360) + 360) % 360),\n\n\tsaturationl: getset('hsl', 1, maxfn(100)),\n\tlightness: getset('hsl', 2, maxfn(100)),\n\n\tsaturationv: getset('hsv', 1, maxfn(100)),\n\tvalue: getset('hsv', 2, maxfn(100)),\n\n\tchroma: getset('hcg', 1, maxfn(100)),\n\tgray: getset('hcg', 2, maxfn(100)),\n\n\twhite: getset('hwb', 1, maxfn(100)),\n\twblack: getset('hwb', 2, maxfn(100)),\n\n\tcyan: getset('cmyk', 0, maxfn(100)),\n\tmagenta: getset('cmyk', 1, maxfn(100)),\n\tyellow: getset('cmyk', 2, maxfn(100)),\n\tblack: getset('cmyk', 3, maxfn(100)),\n\n\tx: getset('xyz', 0, maxfn(95.047)),\n\ty: getset('xyz', 1, maxfn(100)),\n\tz: getset('xyz', 2, maxfn(108.833)),\n\n\tl: getset('lab', 0, maxfn(100)),\n\ta: getset('lab', 1),\n\tb: getset('lab', 2),\n\n\tkeyword(value) {\n\t\tif (value !== undefined) {\n\t\t\treturn new Color(value);\n\t\t}\n\n\t\treturn convert[this.model].keyword(this.color);\n\t},\n\n\thex(value) {\n\t\tif (value !== undefined) {\n\t\t\treturn new Color(value);\n\t\t}\n\n\t\treturn colorString.to.hex(this.rgb().round().color);\n\t},\n\n\thexa(value) {\n\t\tif (value !== undefined) {\n\t\t\treturn new Color(value);\n\t\t}\n\n\t\tconst rgbArray = this.rgb().round().color;\n\n\t\tlet alphaHex = Math.round(this.valpha * 255).toString(16).toUpperCase();\n\t\tif (alphaHex.length === 1) {\n\t\t\talphaHex = '0' + alphaHex;\n\t\t}\n\n\t\treturn colorString.to.hex(rgbArray) + alphaHex;\n\t},\n\n\trgbNumber() {\n\t\tconst rgb = this.rgb().color;\n\t\treturn ((rgb[0] & 0xFF) << 16) | ((rgb[1] & 0xFF) << 8) | (rgb[2] & 0xFF);\n\t},\n\n\tluminosity() {\n\t\t// http://www.w3.org/TR/WCAG20/#relativeluminancedef\n\t\tconst rgb = this.rgb().color;\n\n\t\tconst lum = [];\n\t\tfor (const [i, element] of rgb.entries()) {\n\t\t\tconst chan = element / 255;\n\t\t\tlum[i] = (chan <= 0.04045) ? chan / 12.92 : ((chan + 0.055) / 1.055) ** 2.4;\n\t\t}\n\n\t\treturn 0.2126 * lum[0] + 0.7152 * lum[1] + 0.0722 * lum[2];\n\t},\n\n\tcontrast(color2) {\n\t\t// http://www.w3.org/TR/WCAG20/#contrast-ratiodef\n\t\tconst lum1 = this.luminosity();\n\t\tconst lum2 = color2.luminosity();\n\n\t\tif (lum1 > lum2) {\n\t\t\treturn (lum1 + 0.05) / (lum2 + 0.05);\n\t\t}\n\n\t\treturn (lum2 + 0.05) / (lum1 + 0.05);\n\t},\n\n\tlevel(color2) {\n\t\t// https://www.w3.org/TR/WCAG/#contrast-enhanced\n\t\tconst contrastRatio = this.contrast(color2);\n\t\tif (contrastRatio >= 7) {\n\t\t\treturn 'AAA';\n\t\t}\n\n\t\treturn (contrastRatio >= 4.5) ? 'AA' : '';\n\t},\n\n\tisDark() {\n\t\t// YIQ equation from http://24ways.org/2010/calculating-color-contrast\n\t\tconst rgb = this.rgb().color;\n\t\tconst yiq = (rgb[0] * 2126 + rgb[1] * 7152 + rgb[2] * 722) / 10000;\n\t\treturn yiq < 128;\n\t},\n\n\tisLight() {\n\t\treturn !this.isDark();\n\t},\n\n\tnegate() {\n\t\tconst rgb = this.rgb();\n\t\tfor (let i = 0; i < 3; i++) {\n\t\t\trgb.color[i] = 255 - rgb.color[i];\n\t\t}\n\n\t\treturn rgb;\n\t},\n\n\tlighten(ratio) {\n\t\tconst hsl = this.hsl();\n\t\thsl.color[2] += hsl.color[2] * ratio;\n\t\treturn hsl;\n\t},\n\n\tdarken(ratio) {\n\t\tconst hsl = this.hsl();\n\t\thsl.color[2] -= hsl.color[2] * ratio;\n\t\treturn hsl;\n\t},\n\n\tsaturate(ratio) {\n\t\tconst hsl = this.hsl();\n\t\thsl.color[1] += hsl.color[1] * ratio;\n\t\treturn hsl;\n\t},\n\n\tdesaturate(ratio) {\n\t\tconst hsl = this.hsl();\n\t\thsl.color[1] -= hsl.color[1] * ratio;\n\t\treturn hsl;\n\t},\n\n\twhiten(ratio) {\n\t\tconst hwb = this.hwb();\n\t\thwb.color[1] += hwb.color[1] * ratio;\n\t\treturn hwb;\n\t},\n\n\tblacken(ratio) {\n\t\tconst hwb = this.hwb();\n\t\thwb.color[2] += hwb.color[2] * ratio;\n\t\treturn hwb;\n\t},\n\n\tgrayscale() {\n\t\t// http://en.wikipedia.org/wiki/Grayscale#Converting_color_to_grayscale\n\t\tconst rgb = this.rgb().color;\n\t\tconst value = rgb[0] * 0.3 + rgb[1] * 0.59 + rgb[2] * 0.11;\n\t\treturn Color.rgb(value, value, value);\n\t},\n\n\tfade(ratio) {\n\t\treturn this.alpha(this.valpha - (this.valpha * ratio));\n\t},\n\n\topaquer(ratio) {\n\t\treturn this.alpha(this.valpha + (this.valpha * ratio));\n\t},\n\n\trotate(degrees) {\n\t\tconst hsl = this.hsl();\n\t\tlet hue = hsl.color[0];\n\t\thue = (hue + degrees) % 360;\n\t\thue = hue < 0 ? 360 + hue : hue;\n\t\thsl.color[0] = hue;\n\t\treturn hsl;\n\t},\n\n\tmix(mixinColor, weight) {\n\t\t// Ported from sass implementation in C\n\t\t// https://github.com/sass/libsass/blob/0e6b4a2850092356aa3ece07c6b249f0221caced/functions.cpp#L209\n\t\tif (!mixinColor || !mixinColor.rgb) {\n\t\t\tthrow new Error('Argument to \"mix\" was not a Color instance, but rather an instance of ' + typeof mixinColor);\n\t\t}\n\n\t\tconst color1 = mixinColor.rgb();\n\t\tconst color2 = this.rgb();\n\t\tconst p = weight === undefined ? 0.5 : weight;\n\n\t\tconst w = 2 * p - 1;\n\t\tconst a = color1.alpha() - color2.alpha();\n\n\t\tconst w1 = (((w * a === -1) ? w : (w + a) / (1 + w * a)) + 1) / 2;\n\t\tconst w2 = 1 - w1;\n\n\t\treturn Color.rgb(\n\t\t\tw1 * color1.red() + w2 * color2.red(),\n\t\t\tw1 * color1.green() + w2 * color2.green(),\n\t\t\tw1 * color1.blue() + w2 * color2.blue(),\n\t\t\tcolor1.alpha() * p + color2.alpha() * (1 - p));\n\t},\n};\n\n// Model conversion methods and static constructors\nfor (const model of Object.keys(convert)) {\n\tif (skippedModels.includes(model)) {\n\t\tcontinue;\n\t}\n\n\tconst {channels} = convert[model];\n\n\t// Conversion methods\n\tColor.prototype[model] = function (...args) {\n\t\tif (this.model === model) {\n\t\t\treturn new Color(this);\n\t\t}\n\n\t\tif (args.length > 0) {\n\t\t\treturn new Color(args, model);\n\t\t}\n\n\t\treturn new Color([...assertArray(convert[this.model][model].raw(this.color)), this.valpha], model);\n\t};\n\n\t// 'static' construction methods\n\tColor[model] = function (...args) {\n\t\tlet color = args[0];\n\t\tif (typeof color === 'number') {\n\t\t\tcolor = zeroArray(args, channels);\n\t\t}\n\n\t\treturn new Color(color, model);\n\t};\n}\n\nfunction roundTo(number, places) {\n\treturn Number(number.toFixed(places));\n}\n\nfunction roundToPlace(places) {\n\treturn function (number) {\n\t\treturn roundTo(number, places);\n\t};\n}\n\nfunction getset(model, channel, modifier) {\n\tmodel = Array.isArray(model) ? model : [model];\n\n\tfor (const m of model) {\n\t\t(limiters[m] || (limiters[m] = []))[channel] = modifier;\n\t}\n\n\tmodel = model[0];\n\n\treturn function (value) {\n\t\tlet result;\n\n\t\tif (value !== undefined) {\n\t\t\tif (modifier) {\n\t\t\t\tvalue = modifier(value);\n\t\t\t}\n\n\t\t\tresult = this[model]();\n\t\t\tresult.color[channel] = value;\n\t\t\treturn result;\n\t\t}\n\n\t\tresult = this[model]().color[channel];\n\t\tif (modifier) {\n\t\t\tresult = modifier(result);\n\t\t}\n\n\t\treturn result;\n\t};\n}\n\nfunction maxfn(max) {\n\treturn function (v) {\n\t\treturn Math.max(0, Math.min(max, v));\n\t};\n}\n\nfunction assertArray(value) {\n\treturn Array.isArray(value) ? value : [value];\n}\n\nfunction zeroArray(array, length) {\n\tfor (let i = 0; i < length; i++) {\n\t\tif (typeof array[i] !== 'number') {\n\t\t\tarray[i] = 0;\n\t\t}\n\t}\n\n\treturn array;\n}\n\nmodule.exports = Color;\n", "export * from \"./libs/printer\";\nexport * from \"./libs/prettier-plugin-latex\";\n\n// NOTE: The docstring comment must be the last item in the index.ts file!\n/**\n * ## What is this?\n *\n * A [Prettier](https://prettier.io/) plugin for formatting and pretty-printing LaTeX source code.\n *\n * ## When should I use this?\n *\n * If you want to construct a `Prettier` instance that has LaTeX parsing abilities.\n * \n * You should probably use the `prettier-plugin-latex` package instead of directly accessing this package.\n */\n", "var __defProp = Object.defineProperty;\nvar __export = (target, all) => {\n for (var name in all)\n __defProp(target, name, { get: all[name], enumerable: true });\n};\n\n// src/document/public.js\nvar public_exports = {};\n__export(public_exports, {\n builders: () => builders,\n printer: () => printer,\n utils: () => utils\n});\n\n// src/document/constants.js\nvar DOC_TYPE_STRING = \"string\";\nvar DOC_TYPE_ARRAY = \"array\";\nvar DOC_TYPE_CURSOR = \"cursor\";\nvar DOC_TYPE_INDENT = \"indent\";\nvar DOC_TYPE_ALIGN = \"align\";\nvar DOC_TYPE_TRIM = \"trim\";\nvar DOC_TYPE_GROUP = \"group\";\nvar DOC_TYPE_FILL = \"fill\";\nvar DOC_TYPE_IF_BREAK = \"if-break\";\nvar DOC_TYPE_INDENT_IF_BREAK = \"indent-if-break\";\nvar DOC_TYPE_LINE_SUFFIX = \"line-suffix\";\nvar DOC_TYPE_LINE_SUFFIX_BOUNDARY = \"line-suffix-boundary\";\nvar DOC_TYPE_LINE = \"line\";\nvar DOC_TYPE_LABEL = \"label\";\nvar DOC_TYPE_BREAK_PARENT = \"break-parent\";\nvar VALID_OBJECT_DOC_TYPES = /* @__PURE__ */ new Set([\n DOC_TYPE_CURSOR,\n DOC_TYPE_INDENT,\n DOC_TYPE_ALIGN,\n DOC_TYPE_TRIM,\n DOC_TYPE_GROUP,\n DOC_TYPE_FILL,\n DOC_TYPE_IF_BREAK,\n DOC_TYPE_INDENT_IF_BREAK,\n DOC_TYPE_LINE_SUFFIX,\n DOC_TYPE_LINE_SUFFIX_BOUNDARY,\n DOC_TYPE_LINE,\n DOC_TYPE_LABEL,\n DOC_TYPE_BREAK_PARENT\n]);\n\n// src/document/utils/get-doc-type.js\nfunction getDocType(doc) {\n if (typeof doc === \"string\") {\n return DOC_TYPE_STRING;\n }\n if (Array.isArray(doc)) {\n return DOC_TYPE_ARRAY;\n }\n if (!doc) {\n return;\n }\n const { type } = doc;\n if (VALID_OBJECT_DOC_TYPES.has(type)) {\n return type;\n }\n}\nvar get_doc_type_default = getDocType;\n\n// src/document/invalid-doc-error.js\nvar disjunctionListFormat = (list) => new Intl.ListFormat(\"en-US\", { type: \"disjunction\" }).format(list);\nfunction getDocErrorMessage(doc) {\n const type = doc === null ? \"null\" : typeof doc;\n if (type !== \"string\" && type !== \"object\") {\n return `Unexpected doc '${type}', \nExpected it to be 'string' or 'object'.`;\n }\n if (get_doc_type_default(doc)) {\n throw new Error(\"doc is valid.\");\n }\n const objectType = Object.prototype.toString.call(doc);\n if (objectType !== \"[object Object]\") {\n return `Unexpected doc '${objectType}'.`;\n }\n const EXPECTED_TYPE_VALUES = disjunctionListFormat(\n [...VALID_OBJECT_DOC_TYPES].map((type2) => `'${type2}'`)\n );\n return `Unexpected doc.type '${doc.type}'.\nExpected it to be ${EXPECTED_TYPE_VALUES}.`;\n}\nvar InvalidDocError = class extends Error {\n name = \"InvalidDocError\";\n constructor(doc) {\n super(getDocErrorMessage(doc));\n this.doc = doc;\n }\n};\nvar invalid_doc_error_default = InvalidDocError;\n\n// src/document/utils/traverse-doc.js\nvar traverseDocOnExitStackMarker = {};\nfunction traverseDoc(doc, onEnter, onExit, shouldTraverseConditionalGroups) {\n const docsStack = [doc];\n while (docsStack.length > 0) {\n const doc2 = docsStack.pop();\n if (doc2 === traverseDocOnExitStackMarker) {\n onExit(docsStack.pop());\n continue;\n }\n if (onExit) {\n docsStack.push(doc2, traverseDocOnExitStackMarker);\n }\n const docType = get_doc_type_default(doc2);\n if (!docType) {\n throw new invalid_doc_error_default(doc2);\n }\n if ((onEnter == null ? void 0 : onEnter(doc2)) === false) {\n continue;\n }\n switch (docType) {\n case DOC_TYPE_ARRAY:\n case DOC_TYPE_FILL: {\n const parts = docType === DOC_TYPE_ARRAY ? doc2 : doc2.parts;\n for (let ic = parts.length, i = ic - 1; i >= 0; --i) {\n docsStack.push(parts[i]);\n }\n break;\n }\n case DOC_TYPE_IF_BREAK:\n docsStack.push(doc2.flatContents, doc2.breakContents);\n break;\n case DOC_TYPE_GROUP:\n if (shouldTraverseConditionalGroups && doc2.expandedStates) {\n for (let ic = doc2.expandedStates.length, i = ic - 1; i >= 0; --i) {\n docsStack.push(doc2.expandedStates[i]);\n }\n } else {\n docsStack.push(doc2.contents);\n }\n break;\n case DOC_TYPE_ALIGN:\n case DOC_TYPE_INDENT:\n case DOC_TYPE_INDENT_IF_BREAK:\n case DOC_TYPE_LABEL:\n case DOC_TYPE_LINE_SUFFIX:\n docsStack.push(doc2.contents);\n break;\n case DOC_TYPE_STRING:\n case DOC_TYPE_CURSOR:\n case DOC_TYPE_TRIM:\n case DOC_TYPE_LINE_SUFFIX_BOUNDARY:\n case DOC_TYPE_LINE:\n case DOC_TYPE_BREAK_PARENT:\n break;\n default:\n throw new invalid_doc_error_default(doc2);\n }\n }\n}\nvar traverse_doc_default = traverseDoc;\n\n// src/document/utils/assert-doc.js\nvar noop = () => {\n};\nvar assertDoc = true ? noop : function(doc) {\n traverse_doc_default(doc, (doc2) => {\n if (checked.has(doc2)) {\n return false;\n }\n if (typeof doc2 !== \"string\") {\n checked.add(doc2);\n }\n });\n};\nvar assertDocArray = true ? noop : function(docs, optional = false) {\n if (optional && !docs) {\n return;\n }\n if (!Array.isArray(docs)) {\n throw new TypeError(\"Unexpected doc array.\");\n }\n for (const doc of docs) {\n assertDoc(doc);\n }\n};\n\n// src/document/builders.js\nfunction indent(contents) {\n assertDoc(contents);\n return { type: DOC_TYPE_INDENT, contents };\n}\nfunction align(widthOrString, contents) {\n assertDoc(contents);\n return { type: DOC_TYPE_ALIGN, contents, n: widthOrString };\n}\nfunction group(contents, opts = {}) {\n assertDoc(contents);\n assertDocArray(\n opts.expandedStates,\n /* optional */\n true\n );\n return {\n type: DOC_TYPE_GROUP,\n id: opts.id,\n contents,\n break: Boolean(opts.shouldBreak),\n expandedStates: opts.expandedStates\n };\n}\nfunction dedentToRoot(contents) {\n return align(Number.NEGATIVE_INFINITY, contents);\n}\nfunction markAsRoot(contents) {\n return align({ type: \"root\" }, contents);\n}\nfunction dedent(contents) {\n return align(-1, contents);\n}\nfunction conditionalGroup(states, opts) {\n return group(states[0], { ...opts, expandedStates: states });\n}\nfunction fill(parts) {\n assertDocArray(parts);\n return { type: DOC_TYPE_FILL, parts };\n}\nfunction ifBreak(breakContents, flatContents = \"\", opts = {}) {\n assertDoc(breakContents);\n if (flatContents !== \"\") {\n assertDoc(flatContents);\n }\n return {\n type: DOC_TYPE_IF_BREAK,\n breakContents,\n flatContents,\n groupId: opts.groupId\n };\n}\nfunction indentIfBreak(contents, opts) {\n assertDoc(contents);\n return {\n type: DOC_TYPE_INDENT_IF_BREAK,\n contents,\n groupId: opts.groupId,\n negate: opts.negate\n };\n}\nfunction lineSuffix(contents) {\n assertDoc(contents);\n return { type: DOC_TYPE_LINE_SUFFIX, contents };\n}\nvar lineSuffixBoundary = { type: DOC_TYPE_LINE_SUFFIX_BOUNDARY };\nvar breakParent = { type: DOC_TYPE_BREAK_PARENT };\nvar trim = { type: DOC_TYPE_TRIM };\nvar hardlineWithoutBreakParent = { type: DOC_TYPE_LINE, hard: true };\nvar literallineWithoutBreakParent = {\n type: DOC_TYPE_LINE,\n hard: true,\n literal: true\n};\nvar line = { type: DOC_TYPE_LINE };\nvar softline = { type: DOC_TYPE_LINE, soft: true };\nvar hardline = [hardlineWithoutBreakParent, breakParent];\nvar literalline = [literallineWithoutBreakParent, breakParent];\nvar cursor = { type: DOC_TYPE_CURSOR };\nfunction join(separator, docs) {\n assertDoc(separator);\n assertDocArray(docs);\n const parts = [];\n for (let i = 0; i < docs.length; i++) {\n if (i !== 0) {\n parts.push(separator);\n }\n parts.push(docs[i]);\n }\n return parts;\n}\nfunction addAlignmentToDoc(doc, size, tabWidth) {\n assertDoc(doc);\n let aligned = doc;\n if (size > 0) {\n for (let i = 0; i < Math.floor(size / tabWidth); ++i) {\n aligned = indent(aligned);\n }\n aligned = align(size % tabWidth, aligned);\n aligned = align(Number.NEGATIVE_INFINITY, aligned);\n }\n return aligned;\n}\nfunction label(label2, contents) {\n assertDoc(contents);\n return label2 ? { type: DOC_TYPE_LABEL, label: label2, contents } : contents;\n}\n\n// scripts/build/shims/at.js\nvar at = (isOptionalObject, object, index) => {\n if (isOptionalObject && (object === void 0 || object === null)) {\n return;\n }\n if (Array.isArray(object) || typeof object === \"string\") {\n return object[index < 0 ? object.length + index : index];\n }\n return object.at(index);\n};\nvar at_default = at;\n\n// scripts/build/shims/string-replace-all.js\nvar stringReplaceAll = (isOptionalObject, original, pattern, replacement) => {\n if (isOptionalObject && (original === void 0 || original === null)) {\n return;\n }\n if (original.replaceAll) {\n return original.replaceAll(pattern, replacement);\n }\n if (pattern.global) {\n return original.replace(pattern, replacement);\n }\n return original.split(pattern).join(replacement);\n};\nvar string_replace_all_default = stringReplaceAll;\n\n// src/common/end-of-line.js\nfunction convertEndOfLineToChars(value) {\n switch (value) {\n case \"cr\":\n return \"\\r\";\n case \"crlf\":\n return \"\\r\\n\";\n default:\n return \"\\n\";\n }\n}\n\n// node_modules/emoji-regex/index.mjs\nvar emoji_regex_default = () => {\n return /[#*0-9]\\uFE0F?\\u20E3|[\\xA9\\xAE\\u203C\\u2049\\u2122\\u2139\\u2194-\\u2199\\u21A9\\u21AA\\u231A\\u231B\\u2328\\u23CF\\u23ED-\\u23EF\\u23F1\\u23F2\\u23F8-\\u23FA\\u24C2\\u25AA\\u25AB\\u25B6\\u25C0\\u25FB\\u25FC\\u25FE\\u2600-\\u2604\\u260E\\u2611\\u2614\\u2615\\u2618\\u2620\\u2622\\u2623\\u2626\\u262A\\u262E\\u262F\\u2638-\\u263A\\u2640\\u2642\\u2648-\\u2653\\u265F\\u2660\\u2663\\u2665\\u2666\\u2668\\u267B\\u267E\\u267F\\u2692\\u2694-\\u2697\\u2699\\u269B\\u269C\\u26A0\\u26A7\\u26AA\\u26B0\\u26B1\\u26BD\\u26BE\\u26C4\\u26C8\\u26CF\\u26D1\\u26D3\\u26E9\\u26F0-\\u26F5\\u26F7\\u26F8\\u26FA\\u2702\\u2708\\u2709\\u270F\\u2712\\u2714\\u2716\\u271D\\u2721\\u2733\\u2734\\u2744\\u2747\\u2757\\u2763\\u27A1\\u2934\\u2935\\u2B05-\\u2B07\\u2B1B\\u2B1C\\u2B55\\u3030\\u303D\\u3297\\u3299]\\uFE0F?|[\\u261D\\u270C\\u270D](?:\\uFE0F|\\uD83C[\\uDFFB-\\uDFFF])?|[\\u270A\\u270B](?:\\uD83C[\\uDFFB-\\uDFFF])?|[\\u23E9-\\u23EC\\u23F0\\u23F3\\u25FD\\u2693\\u26A1\\u26AB\\u26C5\\u26CE\\u26D4\\u26EA\\u26FD\\u2705\\u2728\\u274C\\u274E\\u2753-\\u2755\\u2795-\\u2797\\u27B0\\u27BF\\u2B50]|\\u26F9(?:\\uFE0F|\\uD83C[\\uDFFB-\\uDFFF])?(?:\\u200D[\\u2640\\u2642]\\uFE0F?)?|\\u2764\\uFE0F?(?:\\u200D(?:\\uD83D\\uDD25|\\uD83E\\uDE79))?|\\uD83C(?:[\\uDC04\\uDD70\\uDD71\\uDD7E\\uDD7F\\uDE02\\uDE37\\uDF21\\uDF24-\\uDF2C\\uDF36\\uDF7D\\uDF96\\uDF97\\uDF99-\\uDF9B\\uDF9E\\uDF9F\\uDFCD\\uDFCE\\uDFD4-\\uDFDF\\uDFF5\\uDFF7]\\uFE0F?|[\\uDF85\\uDFC2\\uDFC7](?:\\uD83C[\\uDFFB-\\uDFFF])?|[\\uDFC3\\uDFC4\\uDFCA](?:\\uD83C[\\uDFFB-\\uDFFF])?(?:\\u200D[\\u2640\\u2642]\\uFE0F?)?|[\\uDFCB\\uDFCC](?:\\uFE0F|\\uD83C[\\uDFFB-\\uDFFF])?(?:\\u200D[\\u2640\\u2642]\\uFE0F?)?|[\\uDCCF\\uDD8E\\uDD91-\\uDD9A\\uDE01\\uDE1A\\uDE2F\\uDE32-\\uDE36\\uDE38-\\uDE3A\\uDE50\\uDE51\\uDF00-\\uDF20\\uDF2D-\\uDF35\\uDF37-\\uDF7C\\uDF7E-\\uDF84\\uDF86-\\uDF93\\uDFA0-\\uDFC1\\uDFC5\\uDFC6\\uDFC8\\uDFC9\\uDFCF-\\uDFD3\\uDFE0-\\uDFF0\\uDFF8-\\uDFFF]|\\uDDE6\\uD83C[\\uDDE8-\\uDDEC\\uDDEE\\uDDF1\\uDDF2\\uDDF4\\uDDF6-\\uDDFA\\uDDFC\\uDDFD\\uDDFF]|\\uDDE7\\uD83C[\\uDDE6\\uDDE7\\uDDE9-\\uDDEF\\uDDF1-\\uDDF4\\uDDF6-\\uDDF9\\uDDFB\\uDDFC\\uDDFE\\uDDFF]|\\uDDE8\\uD83C[\\uDDE6\\uDDE8\\uDDE9\\uDDEB-\\uDDEE\\uDDF0-\\uDDF5\\uDDF7\\uDDFA-\\uDDFF]|\\uDDE9\\uD83C[\\uDDEA\\uDDEC\\uDDEF\\uDDF0\\uDDF2\\uDDF4\\uDDFF]|\\uDDEA\\uD83C[\\uDDE6\\uDDE8\\uDDEA\\uDDEC\\uDDED\\uDDF7-\\uDDFA]|\\uDDEB\\uD83C[\\uDDEE-\\uDDF0\\uDDF2\\uDDF4\\uDDF7]|\\uDDEC\\uD83C[\\uDDE6\\uDDE7\\uDDE9-\\uDDEE\\uDDF1-\\uDDF3\\uDDF5-\\uDDFA\\uDDFC\\uDDFE]|\\uDDED\\uD83C[\\uDDF0\\uDDF2\\uDDF3\\uDDF7\\uDDF9\\uDDFA]|\\uDDEE\\uD83C[\\uDDE8-\\uDDEA\\uDDF1-\\uDDF4\\uDDF6-\\uDDF9]|\\uDDEF\\uD83C[\\uDDEA\\uDDF2\\uDDF4\\uDDF5]|\\uDDF0\\uD83C[\\uDDEA\\uDDEC-\\uDDEE\\uDDF2\\uDDF3\\uDDF5\\uDDF7\\uDDFC\\uDDFE\\uDDFF]|\\uDDF1\\uD83C[\\uDDE6-\\uDDE8\\uDDEE\\uDDF0\\uDDF7-\\uDDFB\\uDDFE]|\\uDDF2\\uD83C[\\uDDE6\\uDDE8-\\uDDED\\uDDF0-\\uDDFF]|\\uDDF3\\uD83C[\\uDDE6\\uDDE8\\uDDEA-\\uDDEC\\uDDEE\\uDDF1\\uDDF4\\uDDF5\\uDDF7\\uDDFA\\uDDFF]|\\uDDF4\\uD83C\\uDDF2|\\uDDF5\\uD83C[\\uDDE6\\uDDEA-\\uDDED\\uDDF0-\\uDDF3\\uDDF7-\\uDDF9\\uDDFC\\uDDFE]|\\uDDF6\\uD83C\\uDDE6|\\uDDF7\\uD83C[\\uDDEA\\uDDF4\\uDDF8\\uDDFA\\uDDFC]|\\uDDF8\\uD83C[\\uDDE6-\\uDDEA\\uDDEC-\\uDDF4\\uDDF7-\\uDDF9\\uDDFB\\uDDFD-\\uDDFF]|\\uDDF9\\uD83C[\\uDDE6\\uDDE8\\uDDE9\\uDDEB-\\uDDED\\uDDEF-\\uDDF4\\uDDF7\\uDDF9\\uDDFB\\uDDFC\\uDDFF]|\\uDDFA\\uD83C[\\uDDE6\\uDDEC\\uDDF2\\uDDF3\\uDDF8\\uDDFE\\uDDFF]|\\uDDFB\\uD83C[\\uDDE6\\uDDE8\\uDDEA\\uDDEC\\uDDEE\\uDDF3\\uDDFA]|\\uDDFC\\uD83C[\\uDDEB\\uDDF8]|\\uDDFD\\uD83C\\uDDF0|\\uDDFE\\uD83C[\\uDDEA\\uDDF9]|\\uDDFF\\uD83C[\\uDDE6\\uDDF2\\uDDFC]|\\uDFF3\\uFE0F?(?:\\u200D(?:\\u26A7\\uFE0F?|\\uD83C\\uDF08))?|\\uDFF4(?:\\u200D\\u2620\\uFE0F?|\\uDB40\\uDC67\\uDB40\\uDC62\\uDB40(?:\\uDC65\\uDB40\\uDC6E\\uDB40\\uDC67|\\uDC73\\uDB40\\uDC63\\uDB40\\uDC74|\\uDC77\\uDB40\\uDC6C\\uDB40\\uDC73)\\uDB40\\uDC7F)?)|\\uD83D(?:[\\uDC08\\uDC26](?:\\u200D\\u2B1B)?|[\\uDC3F\\uDCFD\\uDD49\\uDD4A\\uDD6F\\uDD70\\uDD73\\uDD76-\\uDD79\\uDD87\\uDD8A-\\uDD8D\\uDDA5\\uDDA8\\uDDB1\\uDDB2\\uDDBC\\uDDC2-\\uDDC4\\uDDD1-\\uDDD3\\uDDDC-\\uDDDE\\uDDE1\\uDDE3\\uDDE8\\uDDEF\\uDDF3\\uDDFA\\uDECB\\uDECD-\\uDECF\\uDEE0-\\uDEE5\\uDEE9\\uDEF0\\uDEF3]\\uFE0F?|[\\uDC42\\uDC43\\uDC46-\\uDC50\\uDC66\\uDC67\\uDC6B-\\uDC6D\\uDC72\\uDC74-\\uDC76\\uDC78\\uDC7C\\uDC83\\uDC85\\uDC8F\\uDC91\\uDCAA\\uDD7A\\uDD95\\uDD96\\uDE4C\\uDE4F\\uDEC0\\uDECC](?:\\uD83C[\\uDFFB-\\uDFFF])?|[\\uDC6E\\uDC70\\uDC71\\uDC73\\uDC77\\uDC81\\uDC82\\uDC86\\uDC87\\uDE45-\\uDE47\\uDE4B\\uDE4D\\uDE4E\\uDEA3\\uDEB4-\\uDEB6](?:\\uD83C[\\uDFFB-\\uDFFF])?(?:\\u200D[\\u2640\\u2642]\\uFE0F?)?|[\\uDD74\\uDD90](?:\\uFE0F|\\uD83C[\\uDFFB-\\uDFFF])?|[\\uDC00-\\uDC07\\uDC09-\\uDC14\\uDC16-\\uDC25\\uDC27-\\uDC3A\\uDC3C-\\uDC3E\\uDC40\\uDC44\\uDC45\\uDC51-\\uDC65\\uDC6A\\uDC79-\\uDC7B\\uDC7D-\\uDC80\\uDC84\\uDC88-\\uDC8E\\uDC90\\uDC92-\\uDCA9\\uDCAB-\\uDCFC\\uDCFF-\\uDD3D\\uDD4B-\\uDD4E\\uDD50-\\uDD67\\uDDA4\\uDDFB-\\uDE2D\\uDE2F-\\uDE34\\uDE37-\\uDE44\\uDE48-\\uDE4A\\uDE80-\\uDEA2\\uDEA4-\\uDEB3\\uDEB7-\\uDEBF\\uDEC1-\\uDEC5\\uDED0-\\uDED2\\uDED5-\\uDED7\\uDEDC-\\uDEDF\\uDEEB\\uDEEC\\uDEF4-\\uDEFC\\uDFE0-\\uDFEB\\uDFF0]|\\uDC15(?:\\u200D\\uD83E\\uDDBA)?|\\uDC3B(?:\\u200D\\u2744\\uFE0F?)?|\\uDC41\\uFE0F?(?:\\u200D\\uD83D\\uDDE8\\uFE0F?)?|\\uDC68(?:\\u200D(?:[\\u2695\\u2696\\u2708]\\uFE0F?|\\u2764\\uFE0F?\\u200D\\uD83D(?:\\uDC8B\\u200D\\uD83D)?\\uDC68|\\uD83C[\\uDF3E\\uDF73\\uDF7C\\uDF93\\uDFA4\\uDFA8\\uDFEB\\uDFED]|\\uD83D(?:[\\uDC68\\uDC69]\\u200D\\uD83D(?:\\uDC66(?:\\u200D\\uD83D\\uDC66)?|\\uDC67(?:\\u200D\\uD83D[\\uDC66\\uDC67])?)|[\\uDCBB\\uDCBC\\uDD27\\uDD2C\\uDE80\\uDE92]|\\uDC66(?:\\u200D\\uD83D\\uDC66)?|\\uDC67(?:\\u200D\\uD83D[\\uDC66\\uDC67])?)|\\uD83E[\\uDDAF-\\uDDB3\\uDDBC\\uDDBD])|\\uD83C(?:\\uDFFB(?:\\u200D(?:[\\u2695\\u2696\\u2708]\\uFE0F?|\\u2764\\uFE0F?\\u200D\\uD83D(?:\\uDC8B\\u200D\\uD83D)?\\uDC68\\uD83C[\\uDFFB-\\uDFFF]|\\uD83C[\\uDF3E\\uDF73\\uDF7C\\uDF93\\uDFA4\\uDFA8\\uDFEB\\uDFED]|\\uD83D[\\uDCBB\\uDCBC\\uDD27\\uDD2C\\uDE80\\uDE92]|\\uD83E(?:[\\uDDAF-\\uDDB3\\uDDBC\\uDDBD]|\\uDD1D\\u200D\\uD83D\\uDC68\\uD83C[\\uDFFC-\\uDFFF])))?|\\uDFFC(?:\\u200D(?:[\\u2695\\u2696\\u2708]\\uFE0F?|\\u2764\\uFE0F?\\u200D\\uD83D(?:\\uDC8B\\u200D\\uD83D)?\\uDC68\\uD83C[\\uDFFB-\\uDFFF]|\\uD83C[\\uDF3E\\uDF73\\uDF7C\\uDF93\\uDFA4\\uDFA8\\uDFEB\\uDFED]|\\uD83D[\\uDCBB\\uDCBC\\uDD27\\uDD2C\\uDE80\\uDE92]|\\uD83E(?:[\\uDDAF-\\uDDB3\\uDDBC\\uDDBD]|\\uDD1D\\u200D\\uD83D\\uDC68\\uD83C[\\uDFFB\\uDFFD-\\uDFFF])))?|\\uDFFD(?:\\u200D(?:[\\u2695\\u2696\\u2708]\\uFE0F?|\\u2764\\uFE0F?\\u200D\\uD83D(?:\\uDC8B\\u200D\\uD83D)?\\uDC68\\uD83C[\\uDFFB-\\uDFFF]|\\uD83C[\\uDF3E\\uDF73\\uDF7C\\uDF93\\uDFA4\\uDFA8\\uDFEB\\uDFED]|\\uD83D[\\uDCBB\\uDCBC\\uDD27\\uDD2C\\uDE80\\uDE92]|\\uD83E(?:[\\uDDAF-\\uDDB3\\uDDBC\\uDDBD]|\\uDD1D\\u200D\\uD83D\\uDC68\\uD83C[\\uDFFB\\uDFFC\\uDFFE\\uDFFF])))?|\\uDFFE(?:\\u200D(?:[\\u2695\\u2696\\u2708]\\uFE0F?|\\u2764\\uFE0F?\\u200D\\uD83D(?:\\uDC8B\\u200D\\uD83D)?\\uDC68\\uD83C[\\uDFFB-\\uDFFF]|\\uD83C[\\uDF3E\\uDF73\\uDF7C\\uDF93\\uDFA4\\uDFA8\\uDFEB\\uDFED]|\\uD83D[\\uDCBB\\uDCBC\\uDD27\\uDD2C\\uDE80\\uDE92]|\\uD83E(?:[\\uDDAF-\\uDDB3\\uDDBC\\uDDBD]|\\uDD1D\\u200D\\uD83D\\uDC68\\uD83C[\\uDFFB-\\uDFFD\\uDFFF])))?|\\uDFFF(?:\\u200D(?:[\\u2695\\u2696\\u2708]\\uFE0F?|\\u2764\\uFE0F?\\u200D\\uD83D(?:\\uDC8B\\u200D\\uD83D)?\\uDC68\\uD83C[\\uDFFB-\\uDFFF]|\\uD83C[\\uDF3E\\uDF73\\uDF7C\\uDF93\\uDFA4\\uDFA8\\uDFEB\\uDFED]|\\uD83D[\\uDCBB\\uDCBC\\uDD27\\uDD2C\\uDE80\\uDE92]|\\uD83E(?:[\\uDDAF-\\uDDB3\\uDDBC\\uDDBD]|\\uDD1D\\u200D\\uD83D\\uDC68\\uD83C[\\uDFFB-\\uDFFE])))?))?|\\uDC69(?:\\u200D(?:[\\u2695\\u2696\\u2708]\\uFE0F?|\\u2764\\uFE0F?\\u200D\\uD83D(?:\\uDC8B\\u200D\\uD83D)?[\\uDC68\\uDC69]|\\uD83C[\\uDF3E\\uDF73\\uDF7C\\uDF93\\uDFA4\\uDFA8\\uDFEB\\uDFED]|\\uD83D(?:[\\uDCBB\\uDCBC\\uDD27\\uDD2C\\uDE80\\uDE92]|\\uDC66(?:\\u200D\\uD83D\\uDC66)?|\\uDC67(?:\\u200D\\uD83D[\\uDC66\\uDC67])?|\\uDC69\\u200D\\uD83D(?:\\uDC66(?:\\u200D\\uD83D\\uDC66)?|\\uDC67(?:\\u200D\\uD83D[\\uDC66\\uDC67])?))|\\uD83E[\\uDDAF-\\uDDB3\\uDDBC\\uDDBD])|\\uD83C(?:\\uDFFB(?:\\u200D(?:[\\u2695\\u2696\\u2708]\\uFE0F?|\\u2764\\uFE0F?\\u200D\\uD83D(?:[\\uDC68\\uDC69]|\\uDC8B\\u200D\\uD83D[\\uDC68\\uDC69])\\uD83C[\\uDFFB-\\uDFFF]|\\uD83C[\\uDF3E\\uDF73\\uDF7C\\uDF93\\uDFA4\\uDFA8\\uDFEB\\uDFED]|\\uD83D[\\uDCBB\\uDCBC\\uDD27\\uDD2C\\uDE80\\uDE92]|\\uD83E(?:[\\uDDAF-\\uDDB3\\uDDBC\\uDDBD]|\\uDD1D\\u200D\\uD83D[\\uDC68\\uDC69]\\uD83C[\\uDFFC-\\uDFFF])))?|\\uDFFC(?:\\u200D(?:[\\u2695\\u2696\\u2708]\\uFE0F?|\\u2764\\uFE0F?\\u200D\\uD83D(?:[\\uDC68\\uDC69]|\\uDC8B\\u200D\\uD83D[\\uDC68\\uDC69])\\uD83C[\\uDFFB-\\uDFFF]|\\uD83C[\\uDF3E\\uDF73\\uDF7C\\uDF93\\uDFA4\\uDFA8\\uDFEB\\uDFED]|\\uD83D[\\uDCBB\\uDCBC\\uDD27\\uDD2C\\uDE80\\uDE92]|\\uD83E(?:[\\uDDAF-\\uDDB3\\uDDBC\\uDDBD]|\\uDD1D\\u200D\\uD83D[\\uDC68\\uDC69]\\uD83C[\\uDFFB\\uDFFD-\\uDFFF])))?|\\uDFFD(?:\\u200D(?:[\\u2695\\u2696\\u2708]\\uFE0F?|\\u2764\\uFE0F?\\u200D\\uD83D(?:[\\uDC68\\uDC69]|\\uDC8B\\u200D\\uD83D[\\uDC68\\uDC69])\\uD83C[\\uDFFB-\\uDFFF]|\\uD83C[\\uDF3E\\uDF73\\uDF7C\\uDF93\\uDFA4\\uDFA8\\uDFEB\\uDFED]|\\uD83D[\\uDCBB\\uDCBC\\uDD27\\uDD2C\\uDE80\\uDE92]|\\uD83E(?:[\\uDDAF-\\uDDB3\\uDDBC\\uDDBD]|\\uDD1D\\u200D\\uD83D[\\uDC68\\uDC69]\\uD83C[\\uDFFB\\uDFFC\\uDFFE\\uDFFF])))?|\\uDFFE(?:\\u200D(?:[\\u2695\\u2696\\u2708]\\uFE0F?|\\u2764\\uFE0F?\\u200D\\uD83D(?:[\\uDC68\\uDC69]|\\uDC8B\\u200D\\uD83D[\\uDC68\\uDC69])\\uD83C[\\uDFFB-\\uDFFF]|\\uD83C[\\uDF3E\\uDF73\\uDF7C\\uDF93\\uDFA4\\uDFA8\\uDFEB\\uDFED]|\\uD83D[\\uDCBB\\uDCBC\\uDD27\\uDD2C\\uDE80\\uDE92]|\\uD83E(?:[\\uDDAF-\\uDDB3\\uDDBC\\uDDBD]|\\uDD1D\\u200D\\uD83D[\\uDC68\\uDC69]\\uD83C[\\uDFFB-\\uDFFD\\uDFFF])))?|\\uDFFF(?:\\u200D(?:[\\u2695\\u2696\\u2708]\\uFE0F?|\\u2764\\uFE0F?\\u200D\\uD83D(?:[\\uDC68\\uDC69]|\\uDC8B\\u200D\\uD83D[\\uDC68\\uDC69])\\uD83C[\\uDFFB-\\uDFFF]|\\uD83C[\\uDF3E\\uDF73\\uDF7C\\uDF93\\uDFA4\\uDFA8\\uDFEB\\uDFED]|\\uD83D[\\uDCBB\\uDCBC\\uDD27\\uDD2C\\uDE80\\uDE92]|\\uD83E(?:[\\uDDAF-\\uDDB3\\uDDBC\\uDDBD]|\\uDD1D\\u200D\\uD83D[\\uDC68\\uDC69]\\uD83C[\\uDFFB-\\uDFFE])))?))?|\\uDC6F(?:\\u200D[\\u2640\\u2642]\\uFE0F?)?|\\uDD75(?:\\uFE0F|\\uD83C[\\uDFFB-\\uDFFF])?(?:\\u200D[\\u2640\\u2642]\\uFE0F?)?|\\uDE2E(?:\\u200D\\uD83D\\uDCA8)?|\\uDE35(?:\\u200D\\uD83D\\uDCAB)?|\\uDE36(?:\\u200D\\uD83C\\uDF2B\\uFE0F?)?)|\\uD83E(?:[\\uDD0C\\uDD0F\\uDD18-\\uDD1F\\uDD30-\\uDD34\\uDD36\\uDD77\\uDDB5\\uDDB6\\uDDBB\\uDDD2\\uDDD3\\uDDD5\\uDEC3-\\uDEC5\\uDEF0\\uDEF2-\\uDEF8](?:\\uD83C[\\uDFFB-\\uDFFF])?|[\\uDD26\\uDD35\\uDD37-\\uDD39\\uDD3D\\uDD3E\\uDDB8\\uDDB9\\uDDCD-\\uDDCF\\uDDD4\\uDDD6-\\uDDDD](?:\\uD83C[\\uDFFB-\\uDFFF])?(?:\\u200D[\\u2640\\u2642]\\uFE0F?)?|[\\uDDDE\\uDDDF](?:\\u200D[\\u2640\\u2642]\\uFE0F?)?|[\\uDD0D\\uDD0E\\uDD10-\\uDD17\\uDD20-\\uDD25\\uDD27-\\uDD2F\\uDD3A\\uDD3F-\\uDD45\\uDD47-\\uDD76\\uDD78-\\uDDB4\\uDDB7\\uDDBA\\uDDBC-\\uDDCC\\uDDD0\\uDDE0-\\uDDFF\\uDE70-\\uDE7C\\uDE80-\\uDE88\\uDE90-\\uDEBD\\uDEBF-\\uDEC2\\uDECE-\\uDEDB\\uDEE0-\\uDEE8]|\\uDD3C(?:\\u200D[\\u2640\\u2642]\\uFE0F?|\\uD83C[\\uDFFB-\\uDFFF])?|\\uDDD1(?:\\u200D(?:[\\u2695\\u2696\\u2708]\\uFE0F?|\\uD83C[\\uDF3E\\uDF73\\uDF7C\\uDF84\\uDF93\\uDFA4\\uDFA8\\uDFEB\\uDFED]|\\uD83D[\\uDCBB\\uDCBC\\uDD27\\uDD2C\\uDE80\\uDE92]|\\uD83E(?:[\\uDDAF-\\uDDB3\\uDDBC\\uDDBD]|\\uDD1D\\u200D\\uD83E\\uDDD1))|\\uD83C(?:\\uDFFB(?:\\u200D(?:[\\u2695\\u2696\\u2708]\\uFE0F?|\\u2764\\uFE0F?\\u200D(?:\\uD83D\\uDC8B\\u200D)?\\uD83E\\uDDD1\\uD83C[\\uDFFC-\\uDFFF]|\\uD83C[\\uDF3E\\uDF73\\uDF7C\\uDF84\\uDF93\\uDFA4\\uDFA8\\uDFEB\\uDFED]|\\uD83D[\\uDCBB\\uDCBC\\uDD27\\uDD2C\\uDE80\\uDE92]|\\uD83E(?:[\\uDDAF-\\uDDB3\\uDDBC\\uDDBD]|\\uDD1D\\u200D\\uD83E\\uDDD1\\uD83C[\\uDFFB-\\uDFFF])))?|\\uDFFC(?:\\u200D(?:[\\u2695\\u2696\\u2708]\\uFE0F?|\\u2764\\uFE0F?\\u200D(?:\\uD83D\\uDC8B\\u200D)?\\uD83E\\uDDD1\\uD83C[\\uDFFB\\uDFFD-\\uDFFF]|\\uD83C[\\uDF3E\\uDF73\\uDF7C\\uDF84\\uDF93\\uDFA4\\uDFA8\\uDFEB\\uDFED]|\\uD83D[\\uDCBB\\uDCBC\\uDD27\\uDD2C\\uDE80\\uDE92]|\\uD83E(?:[\\uDDAF-\\uDDB3\\uDDBC\\uDDBD]|\\uDD1D\\u200D\\uD83E\\uDDD1\\uD83C[\\uDFFB-\\uDFFF])))?|\\uDFFD(?:\\u200D(?:[\\u2695\\u2696\\u2708]\\uFE0F?|\\u2764\\uFE0F?\\u200D(?:\\uD83D\\uDC8B\\u200D)?\\uD83E\\uDDD1\\uD83C[\\uDFFB\\uDFFC\\uDFFE\\uDFFF]|\\uD83C[\\uDF3E\\uDF73\\uDF7C\\uDF84\\uDF93\\uDFA4\\uDFA8\\uDFEB\\uDFED]|\\uD83D[\\uDCBB\\uDCBC\\uDD27\\uDD2C\\uDE80\\uDE92]|\\uD83E(?:[\\uDDAF-\\uDDB3\\uDDBC\\uDDBD]|\\uDD1D\\u200D\\uD83E\\uDDD1\\uD83C[\\uDFFB-\\uDFFF])))?|\\uDFFE(?:\\u200D(?:[\\u2695\\u2696\\u2708]\\uFE0F?|\\u2764\\uFE0F?\\u200D(?:\\uD83D\\uDC8B\\u200D)?\\uD83E\\uDDD1\\uD83C[\\uDFFB-\\uDFFD\\uDFFF]|\\uD83C[\\uDF3E\\uDF73\\uDF7C\\uDF84\\uDF93\\uDFA4\\uDFA8\\uDFEB\\uDFED]|\\uD83D[\\uDCBB\\uDCBC\\uDD27\\uDD2C\\uDE80\\uDE92]|\\uD83E(?:[\\uDDAF-\\uDDB3\\uDDBC\\uDDBD]|\\uDD1D\\u200D\\uD83E\\uDDD1\\uD83C[\\uDFFB-\\uDFFF])))?|\\uDFFF(?:\\u200D(?:[\\u2695\\u2696\\u2708]\\uFE0F?|\\u2764\\uFE0F?\\u200D(?:\\uD83D\\uDC8B\\u200D)?\\uD83E\\uDDD1\\uD83C[\\uDFFB-\\uDFFE]|\\uD83C[\\uDF3E\\uDF73\\uDF7C\\uDF84\\uDF93\\uDFA4\\uDFA8\\uDFEB\\uDFED]|\\uD83D[\\uDCBB\\uDCBC\\uDD27\\uDD2C\\uDE80\\uDE92]|\\uD83E(?:[\\uDDAF-\\uDDB3\\uDDBC\\uDDBD]|\\uDD1D\\u200D\\uD83E\\uDDD1\\uD83C[\\uDFFB-\\uDFFF])))?))?|\\uDEF1(?:\\uD83C(?:\\uDFFB(?:\\u200D\\uD83E\\uDEF2\\uD83C[\\uDFFC-\\uDFFF])?|\\uDFFC(?:\\u200D\\uD83E\\uDEF2\\uD83C[\\uDFFB\\uDFFD-\\uDFFF])?|\\uDFFD(?:\\u200D\\uD83E\\uDEF2\\uD83C[\\uDFFB\\uDFFC\\uDFFE\\uDFFF])?|\\uDFFE(?:\\u200D\\uD83E\\uDEF2\\uD83C[\\uDFFB-\\uDFFD\\uDFFF])?|\\uDFFF(?:\\u200D\\uD83E\\uDEF2\\uD83C[\\uDFFB-\\uDFFE])?))?)/g;\n};\n\n// node_modules/eastasianwidth/eastasianwidth.js\nvar eastasianwidth_default = {\n eastAsianWidth(character) {\n var x = character.charCodeAt(0);\n var y = character.length == 2 ? character.charCodeAt(1) : 0;\n var codePoint = x;\n if (55296 <= x && x <= 56319 && 56320 <= y && y <= 57343) {\n x &= 1023;\n y &= 1023;\n codePoint = x << 10 | y;\n codePoint += 65536;\n }\n if (12288 == codePoint || 65281 <= codePoint && codePoint <= 65376 || 65504 <= codePoint && codePoint <= 65510) {\n return \"F\";\n }\n if (4352 <= codePoint && codePoint <= 4447 || 4515 <= codePoint && codePoint <= 4519 || 4602 <= codePoint && codePoint <= 4607 || 9001 <= codePoint && codePoint <= 9002 || 11904 <= codePoint && codePoint <= 11929 || 11931 <= codePoint && codePoint <= 12019 || 12032 <= codePoint && codePoint <= 12245 || 12272 <= codePoint && codePoint <= 12283 || 12289 <= codePoint && codePoint <= 12350 || 12353 <= codePoint && codePoint <= 12438 || 12441 <= codePoint && codePoint <= 12543 || 12549 <= codePoint && codePoint <= 12589 || 12593 <= codePoint && codePoint <= 12686 || 12688 <= codePoint && codePoint <= 12730 || 12736 <= codePoint && codePoint <= 12771 || 12784 <= codePoint && codePoint <= 12830 || 12832 <= codePoint && codePoint <= 12871 || 12880 <= codePoint && codePoint <= 13054 || 13056 <= codePoint && codePoint <= 19903 || 19968 <= codePoint && codePoint <= 42124 || 42128 <= codePoint && codePoint <= 42182 || 43360 <= codePoint && codePoint <= 43388 || 44032 <= codePoint && codePoint <= 55203 || 55216 <= codePoint && codePoint <= 55238 || 55243 <= codePoint && codePoint <= 55291 || 63744 <= codePoint && codePoint <= 64255 || 65040 <= codePoint && codePoint <= 65049 || 65072 <= codePoint && codePoint <= 65106 || 65108 <= codePoint && codePoint <= 65126 || 65128 <= codePoint && codePoint <= 65131 || 110592 <= codePoint && codePoint <= 110593 || 127488 <= codePoint && codePoint <= 127490 || 127504 <= codePoint && codePoint <= 127546 || 127552 <= codePoint && codePoint <= 127560 || 127568 <= codePoint && codePoint <= 127569 || 131072 <= codePoint && codePoint <= 194367 || 177984 <= codePoint && codePoint <= 196605 || 196608 <= codePoint && codePoint <= 262141) {\n return \"W\";\n }\n return \"N\";\n }\n};\n\n// src/utils/get-string-width.js\nvar notAsciiRegex = /[^\\x20-\\x7F]/;\nfunction getStringWidth(text) {\n if (!text) {\n return 0;\n }\n if (!notAsciiRegex.test(text)) {\n return text.length;\n }\n text = text.replace(emoji_regex_default(), \" \");\n let width = 0;\n for (const character of text) {\n const codePoint = character.codePointAt(0);\n if (codePoint <= 31 || codePoint >= 127 && codePoint <= 159) {\n continue;\n }\n if (codePoint >= 768 && codePoint <= 879) {\n continue;\n }\n const code = eastasianwidth_default.eastAsianWidth(character);\n width += code === \"F\" || code === \"W\" ? 2 : 1;\n }\n return width;\n}\nvar get_string_width_default = getStringWidth;\n\n// src/document/utils.js\nvar getDocParts = (doc) => {\n if (Array.isArray(doc)) {\n return doc;\n }\n if (doc.type !== DOC_TYPE_FILL) {\n throw new Error(`Expect doc to be 'array' or '${DOC_TYPE_FILL}'.`);\n }\n return doc.parts;\n};\nfunction mapDoc(doc, cb) {\n if (typeof doc === \"string\") {\n return cb(doc);\n }\n const mapped = /* @__PURE__ */ new Map();\n return rec(doc);\n function rec(doc2) {\n if (mapped.has(doc2)) {\n return mapped.get(doc2);\n }\n const result = process2(doc2);\n mapped.set(doc2, result);\n return result;\n }\n function process2(doc2) {\n switch (get_doc_type_default(doc2)) {\n case DOC_TYPE_ARRAY:\n return cb(doc2.map(rec));\n case DOC_TYPE_FILL:\n return cb({\n ...doc2,\n parts: doc2.parts.map(rec)\n });\n case DOC_TYPE_IF_BREAK:\n return cb({\n ...doc2,\n breakContents: rec(doc2.breakContents),\n flatContents: rec(doc2.flatContents)\n });\n case DOC_TYPE_GROUP: {\n let {\n expandedStates,\n contents\n } = doc2;\n if (expandedStates) {\n expandedStates = expandedStates.map(rec);\n contents = expandedStates[0];\n } else {\n contents = rec(contents);\n }\n return cb({\n ...doc2,\n contents,\n expandedStates\n });\n }\n case DOC_TYPE_ALIGN:\n case DOC_TYPE_INDENT:\n case DOC_TYPE_INDENT_IF_BREAK:\n case DOC_TYPE_LABEL:\n case DOC_TYPE_LINE_SUFFIX:\n return cb({\n ...doc2,\n contents: rec(doc2.contents)\n });\n case DOC_TYPE_STRING:\n case DOC_TYPE_CURSOR:\n case DOC_TYPE_TRIM:\n case DOC_TYPE_LINE_SUFFIX_BOUNDARY:\n case DOC_TYPE_LINE:\n case DOC_TYPE_BREAK_PARENT:\n return cb(doc2);\n default:\n throw new invalid_doc_error_default(doc2);\n }\n }\n}\nfunction findInDoc(doc, fn, defaultValue) {\n let result = defaultValue;\n let shouldSkipFurtherProcessing = false;\n function findInDocOnEnterFn(doc2) {\n if (shouldSkipFurtherProcessing) {\n return false;\n }\n const maybeResult = fn(doc2);\n if (maybeResult !== void 0) {\n shouldSkipFurtherProcessing = true;\n result = maybeResult;\n }\n }\n traverse_doc_default(doc, findInDocOnEnterFn);\n return result;\n}\nfunction willBreakFn(doc) {\n if (doc.type === DOC_TYPE_GROUP && doc.break) {\n return true;\n }\n if (doc.type === DOC_TYPE_LINE && doc.hard) {\n return true;\n }\n if (doc.type === DOC_TYPE_BREAK_PARENT) {\n return true;\n }\n}\nfunction willBreak(doc) {\n return findInDoc(doc, willBreakFn, false);\n}\nfunction breakParentGroup(groupStack) {\n if (groupStack.length > 0) {\n const parentGroup = at_default(\n /* isOptionalObject*/\n false,\n groupStack,\n -1\n );\n if (!parentGroup.expandedStates && !parentGroup.break) {\n parentGroup.break = \"propagated\";\n }\n }\n return null;\n}\nfunction propagateBreaks(doc) {\n const alreadyVisitedSet = /* @__PURE__ */ new Set();\n const groupStack = [];\n function propagateBreaksOnEnterFn(doc2) {\n if (doc2.type === DOC_TYPE_BREAK_PARENT) {\n breakParentGroup(groupStack);\n }\n if (doc2.type === DOC_TYPE_GROUP) {\n groupStack.push(doc2);\n if (alreadyVisitedSet.has(doc2)) {\n return false;\n }\n alreadyVisitedSet.add(doc2);\n }\n }\n function propagateBreaksOnExitFn(doc2) {\n if (doc2.type === DOC_TYPE_GROUP) {\n const group2 = groupStack.pop();\n if (group2.break) {\n breakParentGroup(groupStack);\n }\n }\n }\n traverse_doc_default(\n doc,\n propagateBreaksOnEnterFn,\n propagateBreaksOnExitFn,\n /* shouldTraverseConditionalGroups */\n true\n );\n}\nfunction removeLinesFn(doc) {\n if (doc.type === DOC_TYPE_LINE && !doc.hard) {\n return doc.soft ? \"\" : \" \";\n }\n if (doc.type === DOC_TYPE_IF_BREAK) {\n return doc.flatContents;\n }\n return doc;\n}\nfunction removeLines(doc) {\n return mapDoc(doc, removeLinesFn);\n}\nfunction stripTrailingHardlineFromParts(parts) {\n parts = [...parts];\n while (parts.length >= 2 && at_default(\n /* isOptionalObject*/\n false,\n parts,\n -2\n ).type === DOC_TYPE_LINE && at_default(\n /* isOptionalObject*/\n false,\n parts,\n -1\n ).type === DOC_TYPE_BREAK_PARENT) {\n parts.length -= 2;\n }\n if (parts.length > 0) {\n const lastPart = stripTrailingHardlineFromDoc(at_default(\n /* isOptionalObject*/\n false,\n parts,\n -1\n ));\n parts[parts.length - 1] = lastPart;\n }\n return parts;\n}\nfunction stripTrailingHardlineFromDoc(doc) {\n switch (get_doc_type_default(doc)) {\n case DOC_TYPE_ALIGN:\n case DOC_TYPE_INDENT:\n case DOC_TYPE_INDENT_IF_BREAK:\n case DOC_TYPE_GROUP:\n case DOC_TYPE_LINE_SUFFIX:\n case DOC_TYPE_LABEL: {\n const contents = stripTrailingHardlineFromDoc(doc.contents);\n return {\n ...doc,\n contents\n };\n }\n case DOC_TYPE_IF_BREAK:\n return {\n ...doc,\n breakContents: stripTrailingHardlineFromDoc(doc.breakContents),\n flatContents: stripTrailingHardlineFromDoc(doc.flatContents)\n };\n case DOC_TYPE_FILL:\n return {\n ...doc,\n parts: stripTrailingHardlineFromParts(doc.parts)\n };\n case DOC_TYPE_ARRAY:\n return stripTrailingHardlineFromParts(doc);\n case DOC_TYPE_STRING:\n return doc.replace(/[\\n\\r]*$/, \"\");\n case DOC_TYPE_CURSOR:\n case DOC_TYPE_TRIM:\n case DOC_TYPE_LINE_SUFFIX_BOUNDARY:\n case DOC_TYPE_LINE:\n case DOC_TYPE_BREAK_PARENT:\n break;\n default:\n throw new invalid_doc_error_default(doc);\n }\n return doc;\n}\nfunction stripTrailingHardline(doc) {\n return stripTrailingHardlineFromDoc(cleanDoc(doc));\n}\nfunction cleanDocFn(doc) {\n switch (get_doc_type_default(doc)) {\n case DOC_TYPE_FILL:\n if (doc.parts.every((part) => part === \"\")) {\n return \"\";\n }\n break;\n case DOC_TYPE_GROUP:\n if (!doc.contents && !doc.id && !doc.break && !doc.expandedStates) {\n return \"\";\n }\n if (doc.contents.type === DOC_TYPE_GROUP && doc.contents.id === doc.id && doc.contents.break === doc.break && doc.contents.expandedStates === doc.expandedStates) {\n return doc.contents;\n }\n break;\n case DOC_TYPE_ALIGN:\n case DOC_TYPE_INDENT:\n case DOC_TYPE_INDENT_IF_BREAK:\n case DOC_TYPE_LINE_SUFFIX:\n if (!doc.contents) {\n return \"\";\n }\n break;\n case DOC_TYPE_IF_BREAK:\n if (!doc.flatContents && !doc.breakContents) {\n return \"\";\n }\n break;\n case DOC_TYPE_ARRAY: {\n const parts = [];\n for (const part of doc) {\n if (!part) {\n continue;\n }\n const [currentPart, ...restParts] = Array.isArray(part) ? part : [part];\n if (typeof currentPart === \"string\" && typeof at_default(\n /* isOptionalObject*/\n false,\n parts,\n -1\n ) === \"string\") {\n parts[parts.length - 1] += currentPart;\n } else {\n parts.push(currentPart);\n }\n parts.push(...restParts);\n }\n if (parts.length === 0) {\n return \"\";\n }\n if (parts.length === 1) {\n return parts[0];\n }\n return parts;\n }\n case DOC_TYPE_STRING:\n case DOC_TYPE_CURSOR:\n case DOC_TYPE_TRIM:\n case DOC_TYPE_LINE_SUFFIX_BOUNDARY:\n case DOC_TYPE_LINE:\n case DOC_TYPE_LABEL:\n case DOC_TYPE_BREAK_PARENT:\n break;\n default:\n throw new invalid_doc_error_default(doc);\n }\n return doc;\n}\nfunction cleanDoc(doc) {\n return mapDoc(doc, (currentDoc) => cleanDocFn(currentDoc));\n}\nfunction replaceEndOfLine(doc, replacement = literalline) {\n return mapDoc(doc, (currentDoc) => typeof currentDoc === \"string\" ? join(replacement, currentDoc.split(\"\\n\")) : currentDoc);\n}\nfunction canBreakFn(doc) {\n if (doc.type === DOC_TYPE_LINE) {\n return true;\n }\n}\nfunction canBreak(doc) {\n return findInDoc(doc, canBreakFn, false);\n}\n\n// src/document/printer.js\nvar MODE_BREAK = Symbol(\"MODE_BREAK\");\nvar MODE_FLAT = Symbol(\"MODE_FLAT\");\nvar CURSOR_PLACEHOLDER = Symbol(\"cursor\");\nfunction rootIndent() {\n return {\n value: \"\",\n length: 0,\n queue: []\n };\n}\nfunction makeIndent(ind, options) {\n return generateInd(ind, {\n type: \"indent\"\n }, options);\n}\nfunction makeAlign(indent2, widthOrDoc, options) {\n if (widthOrDoc === Number.NEGATIVE_INFINITY) {\n return indent2.root || rootIndent();\n }\n if (widthOrDoc < 0) {\n return generateInd(indent2, {\n type: \"dedent\"\n }, options);\n }\n if (!widthOrDoc) {\n return indent2;\n }\n if (widthOrDoc.type === \"root\") {\n return {\n ...indent2,\n root: indent2\n };\n }\n const alignType = typeof widthOrDoc === \"string\" ? \"stringAlign\" : \"numberAlign\";\n return generateInd(indent2, {\n type: alignType,\n n: widthOrDoc\n }, options);\n}\nfunction generateInd(ind, newPart, options) {\n const queue = newPart.type === \"dedent\" ? ind.queue.slice(0, -1) : [...ind.queue, newPart];\n let value = \"\";\n let length = 0;\n let lastTabs = 0;\n let lastSpaces = 0;\n for (const part of queue) {\n switch (part.type) {\n case \"indent\":\n flush();\n if (options.useTabs) {\n addTabs(1);\n } else {\n addSpaces(options.tabWidth);\n }\n break;\n case \"stringAlign\":\n flush();\n value += part.n;\n length += part.n.length;\n break;\n case \"numberAlign\":\n lastTabs += 1;\n lastSpaces += part.n;\n break;\n default:\n throw new Error(`Unexpected type '${part.type}'`);\n }\n }\n flushSpaces();\n return {\n ...ind,\n value,\n length,\n queue\n };\n function addTabs(count) {\n value += \"\t\".repeat(count);\n length += options.tabWidth * count;\n }\n function addSpaces(count) {\n value += \" \".repeat(count);\n length += count;\n }\n function flush() {\n if (options.useTabs) {\n flushTabs();\n } else {\n flushSpaces();\n }\n }\n function flushTabs() {\n if (lastTabs > 0) {\n addTabs(lastTabs);\n }\n resetLast();\n }\n function flushSpaces() {\n if (lastSpaces > 0) {\n addSpaces(lastSpaces);\n }\n resetLast();\n }\n function resetLast() {\n lastTabs = 0;\n lastSpaces = 0;\n }\n}\nfunction trim2(out) {\n let trimCount = 0;\n let cursorCount = 0;\n let outIndex = out.length;\n outer:\n while (outIndex--) {\n const last = out[outIndex];\n if (last === CURSOR_PLACEHOLDER) {\n cursorCount++;\n continue;\n }\n if (false) {\n throw new Error(`Unexpected value in trim: '${typeof last}'`);\n }\n for (let charIndex = last.length - 1; charIndex >= 0; charIndex--) {\n const char = last[charIndex];\n if (char === \" \" || char === \"\t\") {\n trimCount++;\n } else {\n out[outIndex] = last.slice(0, charIndex + 1);\n break outer;\n }\n }\n }\n if (trimCount > 0 || cursorCount > 0) {\n out.length = outIndex + 1;\n while (cursorCount-- > 0) {\n out.push(CURSOR_PLACEHOLDER);\n }\n }\n return trimCount;\n}\nfunction fits(next, restCommands, width, hasLineSuffix, groupModeMap, mustBeFlat) {\n if (width === Number.POSITIVE_INFINITY) {\n return true;\n }\n let restIdx = restCommands.length;\n const cmds = [next];\n const out = [];\n while (width >= 0) {\n if (cmds.length === 0) {\n if (restIdx === 0) {\n return true;\n }\n cmds.push(restCommands[--restIdx]);\n continue;\n }\n const {\n mode,\n doc\n } = cmds.pop();\n switch (get_doc_type_default(doc)) {\n case DOC_TYPE_STRING:\n out.push(doc);\n width -= get_string_width_default(doc);\n break;\n case DOC_TYPE_ARRAY:\n case DOC_TYPE_FILL: {\n const parts = getDocParts(doc);\n for (let i = parts.length - 1; i >= 0; i--) {\n cmds.push({\n mode,\n doc: parts[i]\n });\n }\n break;\n }\n case DOC_TYPE_INDENT:\n case DOC_TYPE_ALIGN:\n case DOC_TYPE_INDENT_IF_BREAK:\n case DOC_TYPE_LABEL:\n cmds.push({\n mode,\n doc: doc.contents\n });\n break;\n case DOC_TYPE_TRIM:\n width += trim2(out);\n break;\n case DOC_TYPE_GROUP: {\n if (mustBeFlat && doc.break) {\n return false;\n }\n const groupMode = doc.break ? MODE_BREAK : mode;\n const contents = doc.expandedStates && groupMode === MODE_BREAK ? at_default(\n /* isOptionalObject*/\n false,\n doc.expandedStates,\n -1\n ) : doc.contents;\n cmds.push({\n mode: groupMode,\n doc: contents\n });\n break;\n }\n case DOC_TYPE_IF_BREAK: {\n const groupMode = doc.groupId ? groupModeMap[doc.groupId] || MODE_FLAT : mode;\n const contents = groupMode === MODE_BREAK ? doc.breakContents : doc.flatContents;\n if (contents) {\n cmds.push({\n mode,\n doc: contents\n });\n }\n break;\n }\n case DOC_TYPE_LINE:\n if (mode === MODE_BREAK || doc.hard) {\n return true;\n }\n if (!doc.soft) {\n out.push(\" \");\n width--;\n }\n break;\n case DOC_TYPE_LINE_SUFFIX:\n hasLineSuffix = true;\n break;\n case DOC_TYPE_LINE_SUFFIX_BOUNDARY:\n if (hasLineSuffix) {\n return false;\n }\n break;\n }\n }\n return false;\n}\nfunction printDocToString(doc, options) {\n const groupModeMap = {};\n const width = options.printWidth;\n const newLine = convertEndOfLineToChars(options.endOfLine);\n let pos = 0;\n const cmds = [{\n ind: rootIndent(),\n mode: MODE_BREAK,\n doc\n }];\n const out = [];\n let shouldRemeasure = false;\n const lineSuffix2 = [];\n let printedCursorCount = 0;\n propagateBreaks(doc);\n while (cmds.length > 0) {\n const {\n ind,\n mode,\n doc: doc2\n } = cmds.pop();\n switch (get_doc_type_default(doc2)) {\n case DOC_TYPE_STRING: {\n const formatted = newLine !== \"\\n\" ? string_replace_all_default(\n /* isOptionalObject*/\n false,\n doc2,\n \"\\n\",\n newLine\n ) : doc2;\n out.push(formatted);\n if (cmds.length > 0) {\n pos += get_string_width_default(formatted);\n }\n break;\n }\n case DOC_TYPE_ARRAY:\n for (let i = doc2.length - 1; i >= 0; i--) {\n cmds.push({\n ind,\n mode,\n doc: doc2[i]\n });\n }\n break;\n case DOC_TYPE_CURSOR:\n if (printedCursorCount >= 2) {\n throw new Error(\"There are too many 'cursor' in doc.\");\n }\n out.push(CURSOR_PLACEHOLDER);\n printedCursorCount++;\n break;\n case DOC_TYPE_INDENT:\n cmds.push({\n ind: makeIndent(ind, options),\n mode,\n doc: doc2.contents\n });\n break;\n case DOC_TYPE_ALIGN:\n cmds.push({\n ind: makeAlign(ind, doc2.n, options),\n mode,\n doc: doc2.contents\n });\n break;\n case DOC_TYPE_TRIM:\n pos -= trim2(out);\n break;\n case DOC_TYPE_GROUP:\n switch (mode) {\n case MODE_FLAT:\n if (!shouldRemeasure) {\n cmds.push({\n ind,\n mode: doc2.break ? MODE_BREAK : MODE_FLAT,\n doc: doc2.contents\n });\n break;\n }\n case MODE_BREAK: {\n shouldRemeasure = false;\n const next = {\n ind,\n mode: MODE_FLAT,\n doc: doc2.contents\n };\n const rem = width - pos;\n const hasLineSuffix = lineSuffix2.length > 0;\n if (!doc2.break && fits(next, cmds, rem, hasLineSuffix, groupModeMap)) {\n cmds.push(next);\n } else {\n if (doc2.expandedStates) {\n const mostExpanded = at_default(\n /* isOptionalObject*/\n false,\n doc2.expandedStates,\n -1\n );\n if (doc2.break) {\n cmds.push({\n ind,\n mode: MODE_BREAK,\n doc: mostExpanded\n });\n break;\n } else {\n for (let i = 1; i < doc2.expandedStates.length + 1; i++) {\n if (i >= doc2.expandedStates.length) {\n cmds.push({\n ind,\n mode: MODE_BREAK,\n doc: mostExpanded\n });\n break;\n } else {\n const state = doc2.expandedStates[i];\n const cmd = {\n ind,\n mode: MODE_FLAT,\n doc: state\n };\n if (fits(cmd, cmds, rem, hasLineSuffix, groupModeMap)) {\n cmds.push(cmd);\n break;\n }\n }\n }\n }\n } else {\n cmds.push({\n ind,\n mode: MODE_BREAK,\n doc: doc2.contents\n });\n }\n }\n break;\n }\n }\n if (doc2.id) {\n groupModeMap[doc2.id] = at_default(\n /* isOptionalObject*/\n false,\n cmds,\n -1\n ).mode;\n }\n break;\n case DOC_TYPE_FILL: {\n const rem = width - pos;\n const {\n parts\n } = doc2;\n if (parts.length === 0) {\n break;\n }\n const [content, whitespace] = parts;\n const contentFlatCmd = {\n ind,\n mode: MODE_FLAT,\n doc: content\n };\n const contentBreakCmd = {\n ind,\n mode: MODE_BREAK,\n doc: content\n };\n const contentFits = fits(contentFlatCmd, [], rem, lineSuffix2.length > 0, groupModeMap, true);\n if (parts.length === 1) {\n if (contentFits) {\n cmds.push(contentFlatCmd);\n } else {\n cmds.push(contentBreakCmd);\n }\n break;\n }\n const whitespaceFlatCmd = {\n ind,\n mode: MODE_FLAT,\n doc: whitespace\n };\n const whitespaceBreakCmd = {\n ind,\n mode: MODE_BREAK,\n doc: whitespace\n };\n if (parts.length === 2) {\n if (contentFits) {\n cmds.push(whitespaceFlatCmd, contentFlatCmd);\n } else {\n cmds.push(whitespaceBreakCmd, contentBreakCmd);\n }\n break;\n }\n parts.splice(0, 2);\n const remainingCmd = {\n ind,\n mode,\n doc: fill(parts)\n };\n const secondContent = parts[0];\n const firstAndSecondContentFlatCmd = {\n ind,\n mode: MODE_FLAT,\n doc: [content, whitespace, secondContent]\n };\n const firstAndSecondContentFits = fits(firstAndSecondContentFlatCmd, [], rem, lineSuffix2.length > 0, groupModeMap, true);\n if (firstAndSecondContentFits) {\n cmds.push(remainingCmd, whitespaceFlatCmd, contentFlatCmd);\n } else if (contentFits) {\n cmds.push(remainingCmd, whitespaceBreakCmd, contentFlatCmd);\n } else {\n cmds.push(remainingCmd, whitespaceBreakCmd, contentBreakCmd);\n }\n break;\n }\n case DOC_TYPE_IF_BREAK:\n case DOC_TYPE_INDENT_IF_BREAK: {\n const groupMode = doc2.groupId ? groupModeMap[doc2.groupId] : mode;\n if (groupMode === MODE_BREAK) {\n const breakContents = doc2.type === DOC_TYPE_IF_BREAK ? doc2.breakContents : doc2.negate ? doc2.contents : indent(doc2.contents);\n if (breakContents) {\n cmds.push({\n ind,\n mode,\n doc: breakContents\n });\n }\n }\n if (groupMode === MODE_FLAT) {\n const flatContents = doc2.type === DOC_TYPE_IF_BREAK ? doc2.flatContents : doc2.negate ? indent(doc2.contents) : doc2.contents;\n if (flatContents) {\n cmds.push({\n ind,\n mode,\n doc: flatContents\n });\n }\n }\n break;\n }\n case DOC_TYPE_LINE_SUFFIX:\n lineSuffix2.push({\n ind,\n mode,\n doc: doc2.contents\n });\n break;\n case DOC_TYPE_LINE_SUFFIX_BOUNDARY:\n if (lineSuffix2.length > 0) {\n cmds.push({\n ind,\n mode,\n doc: hardlineWithoutBreakParent\n });\n }\n break;\n case DOC_TYPE_LINE:\n switch (mode) {\n case MODE_FLAT:\n if (!doc2.hard) {\n if (!doc2.soft) {\n out.push(\" \");\n pos += 1;\n }\n break;\n } else {\n shouldRemeasure = true;\n }\n case MODE_BREAK:\n if (lineSuffix2.length > 0) {\n cmds.push({\n ind,\n mode,\n doc: doc2\n }, ...lineSuffix2.reverse());\n lineSuffix2.length = 0;\n break;\n }\n if (doc2.literal) {\n if (ind.root) {\n out.push(newLine, ind.root.value);\n pos = ind.root.length;\n } else {\n out.push(newLine);\n pos = 0;\n }\n } else {\n pos -= trim2(out);\n out.push(newLine + ind.value);\n pos = ind.length;\n }\n break;\n }\n break;\n case DOC_TYPE_LABEL:\n cmds.push({\n ind,\n mode,\n doc: doc2.contents\n });\n break;\n case DOC_TYPE_BREAK_PARENT:\n break;\n default:\n throw new invalid_doc_error_default(doc2);\n }\n if (cmds.length === 0 && lineSuffix2.length > 0) {\n cmds.push(...lineSuffix2.reverse());\n lineSuffix2.length = 0;\n }\n }\n const cursorPlaceholderIndex = out.indexOf(CURSOR_PLACEHOLDER);\n if (cursorPlaceholderIndex !== -1) {\n const otherCursorPlaceholderIndex = out.indexOf(CURSOR_PLACEHOLDER, cursorPlaceholderIndex + 1);\n const beforeCursor = out.slice(0, cursorPlaceholderIndex).join(\"\");\n const aroundCursor = out.slice(cursorPlaceholderIndex + 1, otherCursorPlaceholderIndex).join(\"\");\n const afterCursor = out.slice(otherCursorPlaceholderIndex + 1).join(\"\");\n return {\n formatted: beforeCursor + aroundCursor + afterCursor,\n cursorNodeStart: beforeCursor.length,\n cursorNodeText: aroundCursor\n };\n }\n return {\n formatted: out.join(\"\")\n };\n}\n\n// src/document/public.js\nvar builders = {\n join,\n line,\n softline,\n hardline,\n literalline,\n group,\n conditionalGroup,\n fill,\n lineSuffix,\n lineSuffixBoundary,\n cursor,\n breakParent,\n ifBreak,\n trim,\n indent,\n indentIfBreak,\n align,\n addAlignmentToDoc,\n markAsRoot,\n dedentToRoot,\n dedent,\n hardlineWithoutBreakParent,\n literallineWithoutBreakParent,\n label,\n // TODO: Remove this in v4\n concat: (parts) => parts\n};\nvar printer = { printDocToString };\nvar utils = {\n willBreak,\n traverseDoc: traverse_doc_default,\n findInDoc,\n mapDoc,\n removeLines,\n stripTrailingHardline,\n replaceEndOfLine,\n canBreak\n};\n\n// with-default-export:src/document/public.js\nvar public_default = public_exports;\nexport {\n builders,\n public_default as default,\n printer,\n utils\n};\n", "import * as Ast from \"@unified-latex/unified-latex-types\";\n\ntype Printable = Ast.Node | Ast.Argument | string;\ntype PrintToken = string | typeof linebreak;\n\nexport const linebreak = Symbol(\"linebreak\");\nconst ESCAPE = \"\\\\\";\n\n/**\n * Renders the AST to an array inserting `linebreak` where needed;\n * This array may be nested.\n *\n * @param {*} node\n */\nfunction _printRaw(node: Printable | Printable[]): PrintToken[] {\n if (typeof node === \"string\") {\n return [node];\n }\n if (Array.isArray(node)) {\n return ([] as PrintToken[]).concat(\n ...node.map((n: Printable) => _printRaw(n))\n );\n }\n // tmp variables\n let argsString, escape;\n switch (node.type) {\n case \"root\":\n return _printRaw(node.content);\n case \"argument\":\n return [node.openMark, ..._printRaw(node.content), node.closeMark];\n case \"comment\":\n var suffix = node.suffixParbreak ? \"\" : linebreak;\n // A comment is responsible for printing its own leading whitespace\n var leadingWhitespace = \"\";\n if (node.sameline && node.leadingWhitespace) {\n leadingWhitespace = \" \";\n }\n if (node.sameline) {\n return [\n leadingWhitespace,\n \"%\",\n ..._printRaw(node.content),\n suffix,\n ];\n }\n return [linebreak, \"%\", ..._printRaw(node.content), suffix];\n case \"environment\":\n case \"mathenv\":\n case \"verbatim\":\n var env = _printRaw(node.env);\n var envStart: PrintToken[] = [ESCAPE + \"begin{\", ...env, \"}\"];\n var envEnd: PrintToken[] = [ESCAPE + \"end{\", ...env, \"}\"];\n argsString =\n (node as any).args == null ? [] : _printRaw((node as any).args);\n return [\n ...envStart,\n ...argsString,\n ..._printRaw(node.content),\n ...envEnd,\n ];\n case \"displaymath\":\n return [ESCAPE + \"[\", ..._printRaw(node.content), ESCAPE + \"]\"];\n case \"group\":\n return [\"{\", ..._printRaw(node.content), \"}\"];\n case \"inlinemath\":\n return [\"$\", ..._printRaw(node.content), \"$\"];\n case \"macro\":\n argsString = node.args == null ? [] : _printRaw(node.args);\n escape = node.escapeToken == null ? ESCAPE : node.escapeToken;\n return [escape, ..._printRaw(node.content), ...argsString];\n case \"parbreak\":\n return [linebreak, linebreak];\n case \"string\":\n return [node.content];\n case \"verb\":\n return [\n ESCAPE,\n node.env,\n node.escape,\n ..._printRaw(node.content),\n node.escape,\n ];\n case \"whitespace\":\n return [\" \"];\n\n default:\n console.warn(\n \"Cannot find render for node \",\n node,\n `(of type ${typeof node})`\n );\n return [\"\" + node];\n }\n}\n\n/**\n * Renders the AST to a string without any pretty printing.\n *\n * @param {*} node\n * @param {*} options - Setting `asArray` to `true` will return an array of strings and the symbol `linebreak`, so that printing can be customized.\n */\nexport function printRaw(\n node: Printable | Printable[],\n options?: { asArray: false }\n): string;\nexport function printRaw(\n node: Printable | Printable[],\n options: { asArray: true }\n): PrintToken[];\nexport function printRaw(node: Printable | Printable[], options?: object): any {\n const asArray = options != null ? (options as any).asArray : false;\n const printedTokens = _printRaw(node);\n if (asArray) {\n return printedTokens;\n }\n return printedTokens.map((x) => (x === linebreak ? \"\\n\" : x)).join(\"\");\n}\n", "import * as Ast from \"@unified-latex/unified-latex-types\";\nimport {\n EnvInfo,\n MacroInfo,\n MacroInfoRecord,\n} from \"@unified-latex/unified-latex-types\";\nimport { printRaw } from \"@unified-latex/unified-latex-util-print-raw\";\n\n/**\n * Creates a macro matching function that uses a `SpecialMacroSpec` or list of macros\n * and generates a hash for quick lookup.\n */\nfunction createMacroMatcher(\n macros: Ast.Macro[] | S[] | Record\n) {\n // We first make sure we have a record type with keys being the macro's contents\n const macrosHash: Record = Array.isArray(macros)\n ? macros.length > 0\n ? typeof macros[0] === \"string\"\n ? Object.fromEntries(\n macros.map((macro) => {\n if (typeof macro !== \"string\") {\n throw new Error(\"Wrong branch of map function\");\n }\n return [macro, {}] as [string, MacroInfo];\n })\n )\n : Object.fromEntries(\n macros.map((macro) => {\n if (typeof macro === \"string\") {\n throw new Error(\"Wrong branch of map function\");\n }\n if (macro.escapeToken != null) {\n return [\n macro.content,\n { escapeToken: macro.escapeToken },\n ] as [string, MacroInfo];\n }\n return [macro.content, {}] as [string, MacroInfo];\n })\n )\n : {}\n : macros;\n\n return function matchAgainstMacros(node: any | Ast.Macro) {\n if (node == null || node.type !== \"macro\") {\n return false;\n }\n // At this point we have a macro type\n const spec = macrosHash[node.content];\n if (!spec) {\n return false;\n }\n\n if (typeof spec === \"object\" && \"escapeToken\" in spec) {\n return (\n (spec as MacroInfoRecord).escapeToken == null ||\n (spec as MacroInfoRecord).escapeToken === node.escapeToken\n );\n }\n return true;\n } as Ast.TypeGuard;\n}\n\n/**\n * Creates a macro matching function that uses a `SpecialMacroSpec` or list of macros\n * and generates a hash for quick lookup.\n */\nfunction createEnvironmentMatcher(macros: string[] | Record) {\n // We first make sure we have a record type with keys being the macro's contents\n const environmentsHash = Array.isArray(macros)\n ? Object.fromEntries(\n macros.map((str) => {\n return [str, {}] as [string, EnvInfo];\n })\n )\n : macros;\n\n return function matchAgainstEnvironments(node: any | Ast.Environment) {\n if (!match.anyEnvironment(node)) {\n return false;\n }\n // At this point we have an environment type\n const envName = printRaw(node.env);\n const spec = environmentsHash[envName];\n if (!spec) {\n return false;\n }\n\n return true;\n } as Ast.TypeGuard;\n}\n\n/**\n * Functions to match different types of nodes.\n */\nexport const match = {\n macro(node: any, macroName?: string): node is Ast.Macro {\n if (node == null) {\n return false;\n }\n return (\n node.type === \"macro\" &&\n (macroName == null || node.content === macroName)\n );\n },\n anyMacro(node: any): node is Ast.Macro {\n return match.macro(node);\n },\n environment(node: any, envName?: string): node is Ast.Environment {\n if (node == null) {\n return false;\n }\n return (\n (node.type === \"environment\" || node.type === \"mathenv\") &&\n (envName == null || printRaw(node.env) === envName)\n );\n },\n anyEnvironment(node: any): node is Ast.Environment {\n return match.environment(node);\n },\n comment(node: any): node is Ast.Comment {\n if (node == null) {\n return false;\n }\n return node.type === \"comment\";\n },\n parbreak(node: any): node is Ast.Parbreak {\n if (node == null) {\n return false;\n }\n return node.type === \"parbreak\";\n },\n whitespace(node: any): node is Ast.Whitespace {\n if (node == null) {\n return false;\n }\n return node.type === \"whitespace\";\n },\n /**\n * Matches whitespace or a comment with leading whitespace.\n */\n whitespaceLike(\n node: any\n ): node is Ast.Whitespace | (Ast.Comment & { leadingWhitespace: true }) {\n if (node == null) {\n return false;\n }\n return (\n node.type === \"whitespace\" ||\n (node.type === \"whitespace\" && node.leadingWhitespace === true)\n );\n },\n string(node: any, value?: string): node is Ast.String {\n if (node == null) {\n return false;\n }\n return (\n node.type === \"string\" && (value == null || node.content === value)\n );\n },\n anyString(node: any): node is Ast.String {\n return match.string(node);\n },\n group(node: any): node is Ast.Group {\n if (node == null) {\n return false;\n }\n return node.type === \"group\";\n },\n argument(node: any): node is Ast.Argument {\n if (node == null) {\n return false;\n }\n return node.type === \"argument\";\n },\n blankArgument(node: any): boolean {\n if (!match.argument(node)) {\n return false;\n }\n return (\n node.openMark === \"\" &&\n node.closeMark === \"\" &&\n node.content.length === 0\n );\n },\n math(node: any): node is Ast.DisplayMath | Ast.InlineMath {\n if (node == null) {\n return false;\n }\n return node.type === \"displaymath\" || node.type === \"inlinemath\";\n },\n createMacroMatcher,\n createEnvironmentMatcher,\n};\n\nexport const {\n anyEnvironment,\n anyMacro,\n anyString,\n argument,\n blankArgument,\n comment,\n environment,\n group,\n macro,\n math,\n parbreak,\n string,\n whitespace,\n} = match;\n", "import { builders } from \"prettier/doc\";\nimport type { Doc } from \"prettier\";\nimport * as Ast from \"@unified-latex/unified-latex-types\";\nimport * as PrettierTypes from \"./prettier-types\";\nimport { printRaw } from \"@unified-latex/unified-latex-util-print-raw\";\nimport { ReferenceMap } from \"../reference-map\";\nimport { match } from \"@unified-latex/unified-latex-util-match\";\n\n/**\n * Computes the environment name, start/end, and args.\n * E.g., for \"\\begin{x}abc\\end{x}\", it returns\n * ```\n * {\n * envName: \"x\",\n * start: \"\\\\begin{x}\",\n * end: \"\\\\end{x}\",\n * }\n * ```\n *\n * @param {*} node\n * @returns\n */\nexport function formatEnvSurround(node: Ast.Environment) {\n const env = printRaw(node.env);\n\n return {\n envName: env,\n start: ESCAPE + \"begin{\" + env + \"}\",\n end: ESCAPE + \"end{\" + env + \"}\",\n };\n}\n\n/**\n * Determine if `elm` is a line type (softline/hardline/etc). If `elm` is an\n * array or a concat, the first element is checked.\n */\nfunction isLineType(elm: Doc): boolean {\n if (elm == null || typeof elm === \"string\") {\n return false;\n }\n if (Array.isArray(elm)) {\n return isLineType(elm[0]);\n }\n // Perhaps we can sneak by with Prettier v2 compatibility?\n // @ts-ignore\n if (elm.type === \"concat\") {\n // @ts-ignore\n return isLineType(elm.parts);\n }\n return elm.type === \"line\";\n}\n\n/**\n * Join an array with `softline`. However, if a `line` is\n * found, do not insert an additional softline. For example\n * `[a, b, c]` -> `[a, softline, b, softline, c]`\n *\n * but\n *\n * `[a, line, b, c]` -> `[a, line, b, softline, c]`\n *\n * @param {*} arr\n * @returns\n */\nexport function joinWithSoftline(arr: Doc[]) {\n if (arr.length === 0 || arr.length === 1) {\n return arr;\n }\n const ret = [arr[0]];\n for (let i = 1; i < arr.length; i++) {\n const prevNode = arr[i - 1];\n const nextNode = arr[i];\n if (!isLineType(prevNode) && !isLineType(nextNode)) {\n ret.push(softline);\n }\n ret.push(nextNode);\n }\n return ret;\n}\n\nexport function getNodeInfo(\n node: any,\n options: PrettierTypes.Options & { referenceMap?: ReferenceMap }\n): {\n renderInfo: Record;\n renderCache?: object;\n previousNode?: Ast.Node;\n nextNode?: Ast.Node;\n referenceMap?: ReferenceMap;\n} {\n if (!node) {\n return { renderInfo: {} };\n }\n const renderInfo = node._renderInfo || {};\n const previousNode =\n options.referenceMap && options.referenceMap.getPreviousNode(node);\n const nextNode =\n options.referenceMap && options.referenceMap.getNextNode(node);\n const renderCache =\n options.referenceMap && options.referenceMap.getRenderCache(node);\n // It's useful to know whether we're the start or end node in an array,\n // so compute this information.\n return {\n renderInfo,\n renderCache,\n previousNode,\n nextNode,\n referenceMap: options.referenceMap,\n };\n}\n\nexport const ESCAPE = \"\\\\\";\n\n// Commands to build the prettier syntax tree\nexport const {\n group,\n fill,\n ifBreak,\n line,\n softline,\n hardline,\n lineSuffix,\n lineSuffixBoundary,\n breakParent,\n indent,\n markAsRoot,\n join,\n} = builders;\n\n/**\n * Given an array of nodes and the corresponding printed versions, prepares\n * a final Doc array. This function does things like ensures there are `hardlines`\n * around environments and that there aren't excess hardlines at the start or end.\n * It also unwraps `inParMode` macro contents.\n *\n * @export\n * @param {Ast.Node[]} nodes\n * @param {Doc[]} docArray\n * @param {*} options\n * @returns {Doc[]}\n */\nexport function formatDocArray(\n nodes: Ast.Node[],\n docArray: Doc[],\n options: any\n): Doc[] {\n const ret: Doc[] = [];\n\n for (let i = 0; i < nodes.length; i++) {\n const rawNode = nodes[i];\n const printedNode = docArray[i];\n const { renderInfo, referenceMap, previousNode, nextNode } =\n getNodeInfo(rawNode, options);\n const renderCache =\n referenceMap && referenceMap.getRenderCache(rawNode);\n\n switch (rawNode.type) {\n case \"comment\":\n // Comments don't insert hardlines themselves; they depend on appropriate\n // hardlines being inserted here.\n\n // This comment printer inserts hardlines after comments, so do not insert\n // a hardline before a comment if there is a comment right before.\n if (\n !rawNode.sameline &&\n previousNode &&\n !match.comment(previousNode) &&\n !match.parbreak(previousNode)\n ) {\n ret.push(hardline);\n }\n ret.push(printedNode);\n if (nextNode && !rawNode.suffixParbreak) {\n ret.push(hardline);\n }\n break;\n case \"environment\":\n case \"displaymath\":\n case \"mathenv\":\n // Environments always start on a new line (unless they are the first\n // item). Peek to see if there is a newline inserted already.\n if (previousNode && previousNode?.type !== \"parbreak\") {\n if (ret[ret.length - 1] === line) {\n // A preceding `line` should be converted into a `hardline`.\n // Remove the line so a hardline can be added\n ret.pop();\n }\n if (ret[ret.length - 1] !== hardline) {\n ret.push(hardline);\n }\n }\n ret.push(printedNode);\n // If an environment is followed by whitespace, replace it with a hardline\n // instead\n if (nextNode?.type === \"whitespace\") {\n ret.push(hardline);\n i++;\n }\n\n break;\n case \"macro\":\n if (renderInfo.breakBefore || renderInfo.breakAround) {\n // Commands like \\section{} should always be preceded by a hardline\n if (previousNode) {\n if (\n ret[ret.length - 1] === line ||\n ret[ret.length - 1] === hardline\n ) {\n // We may be replacing a hardline here for no reason. However,\n // if there is already a hardline, we don't want to continue\n // and accidentally add too many linebreaks\n ret.pop();\n ret.push(hardline);\n } else if (\n !match.comment(previousNode) &&\n !match.parbreak(previousNode)\n ) {\n ret.push(hardline);\n }\n }\n }\n // Macros marked as `inParMode` should be unwrapped\n // unless they have a hanging indent, in which case the macro\n // has already be wrapped in an `indent` block\n if (\n renderInfo.inParMode &&\n !renderInfo.hangingIndent &&\n renderCache\n ) {\n ret.push(\n (renderCache as any).content,\n ...((renderCache as any).rawArgs || [])\n );\n } else {\n ret.push(printedNode);\n }\n if (renderInfo.breakAfter || renderInfo.breakAround) {\n // Commands like \\section{} should always be followed by a hardline\n if (nextNode) {\n if (match.whitespace(nextNode)) {\n ret.push(hardline);\n i++;\n } else if (match.parbreak(nextNode)) {\n // If the next node is a parbreak, it will insert its own newline\n } else if (!match.comment(nextNode)) {\n ret.push(hardline);\n }\n }\n }\n break;\n case \"parbreak\":\n ret.push(hardline, hardline);\n break;\n default:\n ret.push(printedNode);\n break;\n }\n }\n\n return ret;\n}\n", "export function zip(array1: T[], array2: U[]): [T, U][] {\n const ret: [T, U][] = [];\n const len = Math.min(array1.length, array2.length);\n for (let i = 0; i < len; i++) {\n ret.push([array1[i], array2[i]]);\n }\n return ret;\n}\n", "import type { Doc } from \"prettier\";\nimport * as PrettierTypes from \"./prettier-types\";\nimport { getNodeInfo, fill, ESCAPE, indent, group } from \"./common\";\nimport { zip } from \"../zip\";\nimport * as Ast from \"@unified-latex/unified-latex-types\";\n\nexport function printMacro(\n path: PrettierTypes.AstPath,\n print: PrettierTypes.RecursivePrintFunc,\n options: any\n): Doc {\n const node = path.getNode() as Ast.Macro;\n const { renderInfo, previousNode, nextNode, referenceMap } = getNodeInfo(\n node,\n options\n );\n\n const content =\n (node.escapeToken != null ? node.escapeToken : ESCAPE) + node.content;\n const args = node.args ? path.map(print, \"args\" as any) : [];\n\n // Some of the arguments want to be printed \"inline\".\n // We loop through the arguments and unwrap the inline ones.\n const rawArgs = [];\n for (const [arg, printedArg] of zip(node.args || [], args)) {\n const renderCache = referenceMap && referenceMap.getRenderCache(arg);\n if (renderInfo.inParMode && renderCache) {\n rawArgs.push(...(renderCache as any[]));\n } else {\n rawArgs.push(printedArg);\n }\n }\n\n if (referenceMap) {\n referenceMap.setRenderCache(node, { rawArgs, content });\n }\n\n if (renderInfo.hangingIndent) {\n return indent(fill([content, ...rawArgs]));\n }\n\n return group([content, ...rawArgs]);\n}\n", "import * as Ast from \"@unified-latex/unified-latex-types\";\nimport { match } from \"@unified-latex/unified-latex-util-match\";\n\n/**\n * List all props of the current node that should be processed\n * in math mode or not in math mode. If math mode is not specified in the node's render\n * info, empty lists are returned.\n *\n * For example `\\text{foo}` will report that `args` should *not* be processed in math mode,\n * since it's contents should always be processed in text mode.\n */\nexport function listMathChildren(node: Ast.Ast): {\n enter: string[];\n leave: string[];\n} {\n const NULL_RETURN = { enter: [], leave: [] };\n if (Array.isArray(node)) {\n return NULL_RETURN;\n }\n if (match.math(node)) {\n // When we enter a math environment, our content is always\n // considered math mode\n return { enter: [\"content\"], leave: [] };\n }\n\n const renderInfo: { inMathMode?: boolean } = node._renderInfo || {};\n if (renderInfo.inMathMode == null) {\n return NULL_RETURN;\n }\n if (match.macro(node)) {\n if (renderInfo.inMathMode === true) {\n return { enter: [\"args\"], leave: [] };\n } else if (renderInfo.inMathMode === false) {\n return { enter: [], leave: [\"args\"] };\n }\n }\n if (match.environment(node)) {\n if (renderInfo.inMathMode === true) {\n return { enter: [\"content\"], leave: [] };\n } else {\n return { enter: [], leave: [\"content\"] };\n }\n }\n return NULL_RETURN;\n}\n", "import * as Ast from \"@unified-latex/unified-latex-types\";\nimport { listMathChildren } from \"./list-math-children\";\n\nexport type VisitorContext = {\n /**\n * Whether the node is being processed in math mode.\n *\n * This happens when the node is a director or indirect child\n * of a math environment (e.g. `$abc$`), but not when an environment\n * re-establishes text mode (e.g. `$\\text{abc}$`)\n */\n inMathMode?: boolean;\n /**\n * Whether the node has any ancestor that is processed in math mode.\n */\n hasMathModeAncestor?: boolean;\n};\n\ntype GetGuard = T extends (x: any, ...y: any[]) => x is infer R ? R : never;\n/**\n * Gets the type that a type-guard function is guarding. If\n * the guard type cannot be determined, the input type is returned.\n */\ntype GuardTypeOf boolean> = GetGuard extends never\n ? T extends (x: infer A) => any\n ? A\n : never\n : GetGuard;\n\n/**\n * Extracts the guard type from the `test` function provided in a\n * `VisitOptions` argument.\n */\ntype GuardFromOptions<\n Opts extends VisitOptions,\n PossibleTypes = Ast.Ast\n> = Opts extends {\n test: infer R;\n}\n ? R extends (x: any, ...y: any[]) => boolean\n ? // A guard like `typeof Array.isArray` will return `any[]` as the type.\n // This type cannot be narrowed, so instead we use it to pick from\n // the set of all possible types.\n Extract>\n : PossibleTypes\n : PossibleTypes;\n\n/**\n * Narrow the type `T` based on the `VisitOptions` supplied. If `{includeArrays: false}`\n * is specified in the `VisitOptions`, then arrays are excluded from `T`.\n */\ntype NarrowArraysBasedOnOptions = Opts extends {\n includeArrays: infer A;\n}\n ? A extends true\n ? T\n : Exclude\n : Exclude;\n\n/**\n * Get the type of the parameter to the `Visitor` function based on the\n * `VisitOptions` that are supplied.\n */\ntype VisitorTypeFromOptions =\n NarrowArraysBasedOnOptions, Opts>;\n\n/**\n * Continue traversing as normal\n */\nexport const CONTINUE = Symbol(\"continue\");\n/**\n * Do not traverse this node\u2019s children\n */\nexport const SKIP = Symbol(\"skip\");\n/**\n * Stop traversing immediately\n */\nexport const EXIT = Symbol(\"exit\");\n\ntype Action = typeof CONTINUE | typeof SKIP | typeof EXIT;\ntype Index = number;\ntype ActionTuple = [Action] | [typeof SKIP, Index] | [typeof CONTINUE, Index];\n\n/**\n * A visitor takes a `node`, `key`, `index`, and ...\n *\n * @param key - The key of the parent that we were accessed through.\n */\ntype Visitor = (\n node: T,\n info: VisitInfo\n) => null | undefined | Action | Index | ActionTuple | void;\ntype Visitors = { enter?: Visitor; leave?: Visitor };\n\ntype VisitOptions = {\n startingContext?: VisitorContext;\n /**\n * Type guard for types that are passed to the `visitor` function.\n */\n test?: (node: Ast.Ast, info: VisitInfo) => boolean;\n /**\n * Whether arrays will be sent to the `visitor` function. If falsy,\n * only nodes will be past to `visitor`.\n */\n includeArrays?: boolean;\n};\n\nconst DEFAULT_CONTEXT: VisitorContext = {\n inMathMode: false,\n hasMathModeAncestor: false,\n};\n\nexport type VisitInfo = {\n /**\n * If the element was accessed via an attribute, the attribute key is specified.\n */\n readonly key: string | undefined;\n /**\n * If the element was accessed in an array, the index is specified.\n */\n readonly index: number | undefined;\n /**\n * A list of ancestor nodes, `[parent, grandparent, great-grandparent, ...]`\n */\n readonly parents: (Ast.Node | Ast.Argument)[];\n /**\n * If the element was accessed in an array, the array that it is part of.\n */\n readonly containingArray: (Ast.Node | Ast.Argument)[] | undefined;\n /**\n * The LaTeX context of the current match.\n */\n readonly context: VisitorContext;\n};\n\n/**\n * Visit children of tree which pass a test\n *\n * @param {Node} tree Abstract syntax tree to walk\n * @param {Visitor|Visitors} [visitor] Function to run for each node\n */\nexport function visit(\n tree: Ast.Ast,\n visitor:\n | Visitor>\n | Visitors>,\n options?: Opts\n) {\n const {\n startingContext = DEFAULT_CONTEXT,\n test = () => true,\n includeArrays = false,\n } = options || {};\n let enter: Visitor> | undefined;\n let leave: Visitor> | undefined;\n\n if (typeof visitor === \"function\") {\n enter = visitor;\n } else if (visitor && typeof visitor === \"object\") {\n enter = visitor.enter;\n leave = visitor.leave;\n }\n\n walk(tree, {\n key: undefined,\n index: undefined,\n parents: [],\n containingArray: undefined,\n context: { ...startingContext },\n });\n\n /**\n * @param {Node} node\n * @param {string?} key\n * @param {number?} index\n * @param {Array.} parents\n */\n function walk(\n node: Ast.Ast,\n { key, index, parents, context, containingArray }: VisitInfo\n ): ActionTuple {\n const nodePassesTest = includeArrays\n ? test(node, { key, index, parents, context, containingArray })\n : !Array.isArray(node) &&\n test(node, { key, index, parents, context, containingArray });\n\n const result: ActionTuple =\n enter && nodePassesTest\n ? toResult(\n enter(node as any, {\n key,\n index,\n parents,\n context,\n containingArray,\n })\n )\n : [CONTINUE];\n\n if (result[0] === EXIT) {\n return result;\n }\n\n if (result[0] === SKIP) {\n return leave && nodePassesTest\n ? toResult(\n leave(node as any, {\n key,\n index,\n parents,\n context,\n containingArray,\n })\n )\n : result;\n }\n\n if (Array.isArray(node)) {\n // The `value` array might be modified in place as we traverse it, so\n // we use a traditional for loop.\n for (let index = 0; index > -1 && index < node.length; index++) {\n const item = node[index];\n const result = walk(item, {\n key,\n index,\n parents,\n context,\n containingArray: node,\n });\n if (result[0] === EXIT) {\n return result;\n }\n if (typeof result[1] === \"number\") {\n // The for loop will increment i every pass. However,\n // if an index was returned, that's where we want to start next time.\n index = result[1] - 1;\n }\n }\n } else {\n // We don't want to recursively apply to the `content`\n // of all types (e.g., comments and macros), so specify\n // a blacklist.\n let childProps: (\"content\" | \"args\")[] = [\"content\", \"args\"];\n switch (node.type) {\n case \"macro\":\n childProps = [\"args\"];\n break;\n case \"comment\":\n case \"string\":\n case \"verb\":\n case \"verbatim\":\n childProps = [];\n break;\n default:\n break;\n }\n\n const mathModeProps = listMathChildren(node);\n for (const key of childProps) {\n const value = node[key as keyof typeof node] as\n | Ast.Ast\n | undefined;\n const grandparents = [node].concat(parents);\n\n if (value == null) {\n continue;\n }\n\n // We may switch in/out of math mode as we pass to node[key]\n const newContext = { ...context };\n if (mathModeProps.enter.includes(key)) {\n newContext.inMathMode = true;\n newContext.hasMathModeAncestor = true;\n } else if (mathModeProps.leave.includes(key)) {\n newContext.inMathMode = false;\n }\n\n const result = walk(value, {\n key,\n index: undefined,\n parents: grandparents,\n context: newContext,\n containingArray: undefined,\n });\n if (result[0] === EXIT) {\n return result;\n }\n }\n }\n\n return leave && nodePassesTest\n ? toResult(\n leave(node as any, {\n key,\n index,\n parents,\n context,\n containingArray,\n })\n )\n : result;\n }\n}\n\n/**\n * Ensures a result is an `ActionTuple`s\n */\nfunction toResult(\n value: null | undefined | void | Action | Index | ActionTuple\n): ActionTuple {\n if (value == null) {\n return [CONTINUE];\n }\n\n if (Array.isArray(value)) {\n return value;\n }\n\n if (typeof value === \"number\") {\n return [CONTINUE, value];\n }\n\n return [value];\n}\n", "import * as Ast from \"@unified-latex/unified-latex-types\";\nimport { match } from \"@unified-latex/unified-latex-util-match\";\nimport { updateRenderInfo } from \"@unified-latex/unified-latex-util-render-info\";\n\n/**\n * Trims whitespace and parbreaks from the start and end\n * of an array. The number of trimmed nodes is returned.\n * Special care is taken to preserve comments, though any whitespace\n * before the first comment(s) or after the last comment(s) is trimmed.\n */\nexport function trim(nodes: Ast.Node[]): {\n trimmedStart: number;\n trimmedEnd: number;\n} {\n if (!Array.isArray(nodes)) {\n console.warn(\"Trying to trim a non-array ast\", nodes);\n return nodes;\n }\n\n const { trimmedStart } = trimStart(nodes);\n const { trimmedEnd } = trimEnd(nodes);\n\n return { trimmedStart, trimmedEnd };\n}\n\n/**\n * Trim whitespace and parbreaks from the left of an array.\n */\nexport function trimStart(nodes: Ast.Node[]): { trimmedStart: number } {\n const { start } = amountOfLeadingAndTrailingWhitespace(nodes);\n\n nodes.splice(0, start);\n\n // If there are comments at the start, they might have leading whitespace.\n // This leading whitespace should be trimmed\n for (const leadingToken of nodes) {\n if (!match.comment(leadingToken)) {\n break;\n }\n if (leadingToken.leadingWhitespace || leadingToken.sameline) {\n leadingToken.leadingWhitespace = false;\n // We remove the position information from this token to indicate that we've edited it\n delete leadingToken.position;\n }\n // Special care must be taken. If the comment was on the same line as a\n // parskip, it will no longer be on the same line after the trimming.\n // Thus, we must modify the comment.\n if (start > 0 && leadingToken.sameline) {\n leadingToken.sameline = false;\n delete leadingToken.position;\n }\n }\n\n return { trimmedStart: start };\n}\n\n/**\n * Trim whitespace and parbreaks from the right of an array.\n */\nexport function trimEnd(nodes: Ast.Node[]): { trimmedEnd: number } {\n const { end } = amountOfLeadingAndTrailingWhitespace(nodes);\n\n nodes.splice(nodes.length - end, end);\n\n // Trim off any spaces belonging to trailing comments\n for (let i = nodes.length - 1; i >= 0; i--) {\n const trailingToken = nodes[i];\n if (!match.comment(trailingToken)) {\n break;\n }\n\n // Any parbreaks have been trimmed, so there is no suffix parbreak here!\n delete trailingToken.suffixParbreak;\n\n // We don't trim spaces before trailing same-line comments. This is a stylistic choice\n // so that\n // `foo %xxx` does not become `foo%xxx`.\n // The latter is strictly \"correct\" for a trim function, but it is prettier to format\n // code preserving the space before the sameline comment\n if (\n match.comment(trailingToken) &&\n trailingToken.leadingWhitespace &&\n !trailingToken.sameline\n ) {\n trailingToken.leadingWhitespace = false;\n delete trailingToken.position;\n }\n }\n\n return { trimmedEnd: end };\n}\n\n/**\n * Returns the number of whitespace/parbreak nodes at the start and end of an array.\n */\nfunction amountOfLeadingAndTrailingWhitespace(ast: Ast.Node[]): {\n start: number;\n end: number;\n} {\n let start = 0;\n let end = 0;\n for (const node of ast) {\n if (match.whitespace(node) || match.parbreak(node)) {\n start++;\n } else {\n break;\n }\n }\n\n if (start === ast.length) {\n return { start, end: 0 };\n }\n\n // Find the padding on the right\n for (let i = ast.length - 1; i >= 0; i--) {\n const node = ast[i];\n if (match.whitespace(node) || match.parbreak(node)) {\n end++;\n } else {\n break;\n }\n }\n\n return { start, end };\n}\n", "import type { Plugin } from \"unified\";\nimport * as Ast from \"@unified-latex/unified-latex-types\";\nimport { match } from \"@unified-latex/unified-latex-util-match\";\nimport { visit } from \"@unified-latex/unified-latex-util-visit\";\nimport { trim, trimEnd, trimStart } from \"./trim\";\n\ntype PluginOptions = void;\n\n/**\n * Unified plugin to trim the whitespace from the start/end of any environments, including\n * math environments.\n */\nexport const unifiedLatexTrimEnvironmentContents: Plugin<\n PluginOptions[],\n Ast.Root,\n Ast.Root\n> = function unifiedLatexTrimEnvironmentContents() {\n return (tree) => {\n visit(tree, (node) => {\n if (!(match.math(node) || match.anyEnvironment(node))) {\n return;\n }\n\n // If the first thing in the environment is a sameline comment,\n // we actually want to start trimming *after* it.\n let firstNode = node.content[0];\n if (match.comment(firstNode) && firstNode.sameline) {\n firstNode.suffixParbreak = false;\n trimEnd(node.content);\n\n // We play a nasty trick here. This call to `trimStart`\n // will actually modify `node.content` if `node.content.slice(1)` starts\n // with a comment that has leading whitespace (it will remove that whitespace).\n // However, it won't remove any elements from `node.content`; we need\n // to do that ourselves.\n const { trimmedStart } = trimStart(node.content.slice(1));\n node.content.splice(1, trimmedStart);\n } else {\n trim(node.content);\n }\n });\n };\n};\n", "import type { Plugin } from \"unified\";\nimport * as Ast from \"@unified-latex/unified-latex-types\";\nimport { trim } from \"./trim\";\n\ntype PluginOptions = void;\n\n/**\n * Unified plugin to trim the whitespace from the start/end of the root element.\n */\nexport const unifiedLatexTrimRoot: Plugin =\n function unifiedLatexTrimRoot() {\n return (tree) => {\n trim(tree.content);\n };\n };\n", "import * as Ast from \"@unified-latex/unified-latex-types\";\nimport { match } from \"@unified-latex/unified-latex-util-match\";\n\n/**\n * Returns whether the array has whitespace at the start/end. Comments with `leadingWhitespace === true`\n * are counted as whitespace. Other comments are ignored.\n */\nexport function hasWhitespaceEquivalent(nodes: Ast.Node[]): {\n start: boolean;\n end: boolean;\n} {\n let start = false;\n let end = false;\n for (let i = 0; i < nodes.length; i++) {\n const node = nodes[i];\n if (match.comment(node)) {\n // A comment with leading whitespace will render with leading whitespace,\n // so if we encounter one, we should consider ourselves to have leading whitespace.\n if (node.leadingWhitespace) {\n start = true;\n break;\n }\n continue;\n }\n if (match.whitespace(node)) {\n start = true;\n }\n break;\n }\n for (let j = nodes.length - 1; j >= 0; j--) {\n const node = nodes[j];\n if (match.comment(node)) {\n if (node.leadingWhitespace) {\n end = true;\n break;\n }\n continue;\n }\n if (match.whitespace(node)) {\n end = true;\n }\n break;\n }\n return { start, end };\n}\n", "type StringlikeArray = any[] & string;\n\n/**\n * Pegjs operates on strings. However, strings and arrays are very similar!\n * This function adds `charAt`, `charCodeAt`, and `substring` methods to\n * `array` so that `array` can then be fed to a Pegjs generated parser.\n *\n * @param {[object]} array\n * @returns {[object]}\n */\nexport function decorateArrayForPegjs(array: any[]): StringlikeArray {\n (array as any).charAt = function (i: number) {\n return this[i];\n };\n // We don't have a hope of imitating `charCodeAt`, so\n // make it something that won't interfere\n (array as any).charCodeAt = () => 0;\n (array as any).substring = function (i: number, j: number) {\n return this.slice(i, j);\n };\n // This function is called when reporting an error,\n // so we convert back to a string.\n (array as any).replace = function (a: string, b: string) {\n const ret = JSON.stringify(this);\n return ret.replace(a, b);\n };\n return array as StringlikeArray;\n}\n", "import * as Ast from \"@unified-latex/unified-latex-types\";\nimport { match } from \"@unified-latex/unified-latex-util-match\";\n\n/**\n * Splits all multi-character strings into strings that are all single characters.\n */\nexport function splitStringsIntoSingleChars(nodes: Ast.Node[]): Ast.Node[] {\n return nodes.flatMap((node) =>\n match.anyString(node)\n ? (Array.from(node.content).map((c) => ({\n type: \"string\",\n content: c,\n })) as Ast.Node[])\n : node\n );\n}\n", "export default // Generated by Peggy 2.0.1.\n//\n// https://peggyjs.org/\n(function() {\n \"use strict\";\n\nfunction peg$subclass(child, parent) {\n function C() { this.constructor = child; }\n C.prototype = parent.prototype;\n child.prototype = new C();\n}\n\nfunction peg$SyntaxError(message, expected, found, location) {\n var self = Error.call(this, message);\n // istanbul ignore next Check is a necessary evil to support older environments\n if (Object.setPrototypeOf) {\n Object.setPrototypeOf(self, peg$SyntaxError.prototype);\n }\n self.expected = expected;\n self.found = found;\n self.location = location;\n self.name = \"SyntaxError\";\n return self;\n}\n\npeg$subclass(peg$SyntaxError, Error);\n\nfunction peg$padEnd(str, targetLength, padString) {\n padString = padString || \" \";\n if (str.length > targetLength) { return str; }\n targetLength -= str.length;\n padString += padString.repeat(targetLength);\n return str + padString.slice(0, targetLength);\n}\n\npeg$SyntaxError.prototype.format = function(sources) {\n var str = \"Error: \" + this.message;\n if (this.location) {\n var src = null;\n var k;\n for (k = 0; k < sources.length; k++) {\n if (sources[k].source === this.location.source) {\n src = sources[k].text.split(/\\r\\n|\\n|\\r/g);\n break;\n }\n }\n var s = this.location.start;\n var loc = this.location.source + \":\" + s.line + \":\" + s.column;\n if (src) {\n var e = this.location.end;\n var filler = peg$padEnd(\"\", s.line.toString().length, ' ');\n var line = src[s.line - 1];\n var last = s.line === e.line ? e.column : line.length + 1;\n var hatLen = (last - s.column) || 1;\n str += \"\\n --> \" + loc + \"\\n\"\n + filler + \" |\\n\"\n + s.line + \" | \" + line + \"\\n\"\n + filler + \" | \" + peg$padEnd(\"\", s.column - 1, ' ')\n + peg$padEnd(\"\", hatLen, \"^\");\n } else {\n str += \"\\n at \" + loc;\n }\n }\n return str;\n};\n\npeg$SyntaxError.buildMessage = function(expected, found) {\n var DESCRIBE_EXPECTATION_FNS = {\n literal: function(expectation) {\n return \"\\\"\" + literalEscape(expectation.text) + \"\\\"\";\n },\n\n class: function(expectation) {\n var escapedParts = expectation.parts.map(function(part) {\n return Array.isArray(part)\n ? classEscape(part[0]) + \"-\" + classEscape(part[1])\n : classEscape(part);\n });\n\n return \"[\" + (expectation.inverted ? \"^\" : \"\") + escapedParts.join(\"\") + \"]\";\n },\n\n any: function() {\n return \"any character\";\n },\n\n end: function() {\n return \"end of input\";\n },\n\n other: function(expectation) {\n return expectation.description;\n }\n };\n\n function hex(ch) {\n return ch.charCodeAt(0).toString(16).toUpperCase();\n }\n\n function literalEscape(s) {\n return s\n .replace(/\\\\/g, \"\\\\\\\\\")\n .replace(/\"/g, \"\\\\\\\"\")\n .replace(/\\0/g, \"\\\\0\")\n .replace(/\\t/g, \"\\\\t\")\n .replace(/\\n/g, \"\\\\n\")\n .replace(/\\r/g, \"\\\\r\")\n .replace(/[\\x00-\\x0F]/g, function(ch) { return \"\\\\x0\" + hex(ch); })\n .replace(/[\\x10-\\x1F\\x7F-\\x9F]/g, function(ch) { return \"\\\\x\" + hex(ch); });\n }\n\n function classEscape(s) {\n return s\n .replace(/\\\\/g, \"\\\\\\\\\")\n .replace(/\\]/g, \"\\\\]\")\n .replace(/\\^/g, \"\\\\^\")\n .replace(/-/g, \"\\\\-\")\n .replace(/\\0/g, \"\\\\0\")\n .replace(/\\t/g, \"\\\\t\")\n .replace(/\\n/g, \"\\\\n\")\n .replace(/\\r/g, \"\\\\r\")\n .replace(/[\\x00-\\x0F]/g, function(ch) { return \"\\\\x0\" + hex(ch); })\n .replace(/[\\x10-\\x1F\\x7F-\\x9F]/g, function(ch) { return \"\\\\x\" + hex(ch); });\n }\n\n function describeExpectation(expectation) {\n return DESCRIBE_EXPECTATION_FNS[expectation.type](expectation);\n }\n\n function describeExpected(expected) {\n var descriptions = expected.map(describeExpectation);\n var i, j;\n\n descriptions.sort();\n\n if (descriptions.length > 0) {\n for (i = 1, j = 1; i < descriptions.length; i++) {\n if (descriptions[i - 1] !== descriptions[i]) {\n descriptions[j] = descriptions[i];\n j++;\n }\n }\n descriptions.length = j;\n }\n\n switch (descriptions.length) {\n case 1:\n return descriptions[0];\n\n case 2:\n return descriptions[0] + \" or \" + descriptions[1];\n\n default:\n return descriptions.slice(0, -1).join(\", \")\n + \", or \"\n + descriptions[descriptions.length - 1];\n }\n }\n\n function describeFound(found) {\n return found ? \"\\\"\" + literalEscape(found) + \"\\\"\" : \"end of input\";\n }\n\n return \"Expected \" + describeExpected(expected) + \" but \" + describeFound(found) + \" found.\";\n};\n\nfunction peg$parse(input, options) {\n options = options !== undefined ? options : {};\n\n var peg$FAILED = {};\n var peg$source = options.grammarSource;\n\n var peg$startRuleFunctions = { document: peg$parsedocument, math: peg$parsemath };\n var peg$startRuleFunction = peg$parsedocument;\n\n var peg$c0 = \"%\";\n var peg$c1 = \".\";\n var peg$c2 = \"verb*\";\n var peg$c3 = \"verb\";\n var peg$c4 = \"[\";\n var peg$c5 = \"]\";\n var peg$c6 = \"lstinline\";\n var peg$c7 = \"mintinline\";\n var peg$c8 = \"mint\";\n var peg$c9 = \"minted\";\n var peg$c10 = \"verbatim*\";\n var peg$c11 = \"verbatim\";\n var peg$c12 = \"filecontents*\";\n var peg$c13 = \"filecontents\";\n var peg$c14 = \"comment\";\n var peg$c15 = \"lstlisting\";\n var peg$c16 = \"(\";\n var peg$c17 = \")\";\n var peg$c18 = \"begin\";\n var peg$c19 = \"end\";\n var peg$c20 = \"equation*\";\n var peg$c21 = \"equation\";\n var peg$c22 = \"align*\";\n var peg$c23 = \"align\";\n var peg$c24 = \"alignat*\";\n var peg$c25 = \"alignat\";\n var peg$c26 = \"gather*\";\n var peg$c27 = \"gather\";\n var peg$c28 = \"multline*\";\n var peg$c29 = \"multline\";\n var peg$c30 = \"flalign*\";\n var peg$c31 = \"flalign\";\n var peg$c32 = \"split\";\n var peg$c33 = \"math\";\n var peg$c34 = \"displaymath\";\n var peg$c35 = \"\\\\\";\n var peg$c36 = \"{\";\n var peg$c37 = \"}\";\n var peg$c38 = \"$\";\n var peg$c39 = \"&\";\n var peg$c40 = \"\\r\";\n var peg$c41 = \"\\n\";\n var peg$c42 = \"\\r\\n\";\n var peg$c43 = \"#\";\n var peg$c44 = \"^\";\n var peg$c45 = \"_\";\n var peg$c46 = \"\\0\";\n\n var peg$r0 = /^[^ \\t\\n\\r]/;\n var peg$r1 = /^[ \\t]/;\n var peg$r2 = /^[a-zA-Z]/;\n var peg$r3 = /^[0-9]/;\n var peg$r4 = /^[.,;:\\-*\\/()!?=+<>[\\]`'\"~]/;\n\n var peg$e0 = peg$otherExpectation(\"document\");\n var peg$e1 = peg$otherExpectation(\"math\");\n var peg$e2 = peg$otherExpectation(\"token\");\n var peg$e3 = peg$anyExpectation();\n var peg$e4 = peg$otherExpectation(\"parbreak\");\n var peg$e5 = peg$otherExpectation(\"math token\");\n var peg$e6 = peg$otherExpectation(\"nonchar token\");\n var peg$e7 = peg$literalExpectation(\"%\", false);\n var peg$e8 = peg$otherExpectation(\"whitespace\");\n var peg$e9 = peg$otherExpectation(\"number\");\n var peg$e10 = peg$literalExpectation(\".\", false);\n var peg$e11 = peg$otherExpectation(\"special macro\");\n var peg$e12 = peg$literalExpectation(\"verb*\", false);\n var peg$e13 = peg$literalExpectation(\"verb\", false);\n var peg$e14 = peg$literalExpectation(\"[\", false);\n var peg$e15 = peg$literalExpectation(\"]\", false);\n var peg$e16 = peg$classExpectation([\" \", \"\\t\", \"\\n\", \"\\r\"], true, false);\n var peg$e17 = peg$otherExpectation(\"verbatim listings\");\n var peg$e18 = peg$literalExpectation(\"lstinline\", false);\n var peg$e19 = peg$otherExpectation(\"verbatim minted\");\n var peg$e20 = peg$literalExpectation(\"mintinline\", false);\n var peg$e21 = peg$literalExpectation(\"mint\", false);\n var peg$e22 = peg$otherExpectation(\"verbatim minted environment\");\n var peg$e23 = peg$literalExpectation(\"minted\", false);\n var peg$e24 = peg$otherExpectation(\"verbatim environment\");\n var peg$e25 = peg$literalExpectation(\"verbatim*\", false);\n var peg$e26 = peg$literalExpectation(\"verbatim\", false);\n var peg$e27 = peg$literalExpectation(\"filecontents*\", false);\n var peg$e28 = peg$literalExpectation(\"filecontents\", false);\n var peg$e29 = peg$literalExpectation(\"comment\", false);\n var peg$e30 = peg$literalExpectation(\"lstlisting\", false);\n var peg$e31 = peg$otherExpectation(\"macro\");\n var peg$e32 = peg$otherExpectation(\"group\");\n var peg$e33 = peg$otherExpectation(\"environment\");\n var peg$e34 = peg$otherExpectation(\"math environment\");\n var peg$e35 = peg$otherExpectation(\"math group\");\n var peg$e36 = peg$literalExpectation(\"(\", false);\n var peg$e37 = peg$literalExpectation(\")\", false);\n var peg$e38 = peg$literalExpectation(\"begin\", false);\n var peg$e39 = peg$literalExpectation(\"end\", false);\n var peg$e40 = peg$literalExpectation(\"equation*\", false);\n var peg$e41 = peg$literalExpectation(\"equation\", false);\n var peg$e42 = peg$literalExpectation(\"align*\", false);\n var peg$e43 = peg$literalExpectation(\"align\", false);\n var peg$e44 = peg$literalExpectation(\"alignat*\", false);\n var peg$e45 = peg$literalExpectation(\"alignat\", false);\n var peg$e46 = peg$literalExpectation(\"gather*\", false);\n var peg$e47 = peg$literalExpectation(\"gather\", false);\n var peg$e48 = peg$literalExpectation(\"multline*\", false);\n var peg$e49 = peg$literalExpectation(\"multline\", false);\n var peg$e50 = peg$literalExpectation(\"flalign*\", false);\n var peg$e51 = peg$literalExpectation(\"flalign\", false);\n var peg$e52 = peg$literalExpectation(\"split\", false);\n var peg$e53 = peg$literalExpectation(\"math\", false);\n var peg$e54 = peg$literalExpectation(\"displaymath\", false);\n var peg$e55 = peg$otherExpectation(\"escape\");\n var peg$e56 = peg$literalExpectation(\"\\\\\", false);\n var peg$e57 = peg$literalExpectation(\"{\", false);\n var peg$e58 = peg$literalExpectation(\"}\", false);\n var peg$e59 = peg$literalExpectation(\"$\", false);\n var peg$e60 = peg$literalExpectation(\"&\", false);\n var peg$e61 = peg$otherExpectation(\"newline\");\n var peg$e62 = peg$literalExpectation(\"\\r\", false);\n var peg$e63 = peg$literalExpectation(\"\\n\", false);\n var peg$e64 = peg$literalExpectation(\"\\r\\n\", false);\n var peg$e65 = peg$literalExpectation(\"#\", false);\n var peg$e66 = peg$literalExpectation(\"^\", false);\n var peg$e67 = peg$literalExpectation(\"_\", false);\n var peg$e68 = peg$literalExpectation(\"\\0\", false);\n var peg$e69 = peg$classExpectation([\" \", \"\\t\"], false, false);\n var peg$e70 = peg$otherExpectation(\"letter\");\n var peg$e71 = peg$classExpectation([[\"a\", \"z\"], [\"A\", \"Z\"]], false, false);\n var peg$e72 = peg$otherExpectation(\"digit\");\n var peg$e73 = peg$classExpectation([[\"0\", \"9\"]], false, false);\n var peg$e74 = peg$otherExpectation(\"punctuation\");\n var peg$e75 = peg$classExpectation([\".\", \",\", \";\", \":\", \"-\", \"*\", \"/\", \"(\", \")\", \"!\", \"?\", \"=\", \"+\", \"<\", \">\", \"[\", \"]\", \"`\", \"'\", \"\\\"\", \"~\"], false, false);\n var peg$e76 = peg$otherExpectation(\"full comment\");\n var peg$e77 = peg$otherExpectation(\"comment\");\n\n var peg$f0 = function(content) {\n return createNode(\"root\", { content: content.flatMap((x) => x) });\n };\n var peg$f1 = function(t) { return t; };\n var peg$f2 = function(eq) {\n return createNode(\"inlinemath\", { content: eq.flatMap((x) => x) });\n };\n var peg$f3 = function(s) { return createNode(\"string\", { content: s }); };\n var peg$f4 = function(s) { return createNode(\"string\", { content: s }); };\n var peg$f5 = function() { return createNode(\"parbreak\"); };\n var peg$f6 = function(x) { return x; };\n var peg$f7 = function(x) { return x; };\n var peg$f8 = function() {\n return createNode(\"macro\", { content: \"^\", escapeToken: \"\" });\n };\n var peg$f9 = function() {\n return createNode(\"macro\", { content: \"_\", escapeToken: \"\" });\n };\n var peg$f10 = function(s) { return createNode(\"string\", { content: s }); };\n var peg$f11 = function() {\n return createNode(\"whitespace\");\n };\n var peg$f12 = function(a, b) { return a.join(\"\") + \".\" + b.join(\"\"); };\n var peg$f13 = function(b) { return \".\" + b.join(\"\"); };\n var peg$f14 = function(a) { return a.join(\"\") + \".\"; };\n var peg$f15 = function(s) { return createNode(\"string\", { content: s }); };\n var peg$f16 = function(env, e, end) { return end == e; };\n var peg$f17 = function(env, e, x) { return x; };\n var peg$f18 = function(env, e, x, end) { return end == e; };\n var peg$f19 = function(env, e, x) {\n return createNode(\"verb\", {\n env: env,\n escape: e,\n content: x.join(\"\"),\n });\n };\n var peg$f20 = function(x) { return x; };\n var peg$f21 = function(x) {\n return createNode(\"displaymath\", { content: x.flatMap((x) => x) });\n };\n var peg$f22 = function(x) { return x; };\n var peg$f23 = function(x) {\n return createNode(\"inlinemath\", { content: x.flatMap((x) => x) });\n };\n var peg$f24 = function(x) { return x; };\n var peg$f25 = function(x) {\n return createNode(\"displaymath\", { content: x.flatMap((x) => x) });\n };\n var peg$f26 = function(end) {\n return (\n end.type === \"string\" && end.content === \"]\"\n );\n };\n var peg$f27 = function(x) { return x; };\n var peg$f28 = function(o) {\n return [\n createNode(\"string\", { content: \"[\" }),\n ...o,\n createNode(\"string\", { content: \"]\" }),\n ];\n };\n var peg$f29 = function(x) { return x; };\n var peg$f30 = function(v) {\n return createNode(\"group\", {\n content: createNode(\"string\", { content: v.join(\"\") }),\n });\n };\n var peg$f31 = function(d, end) { return end == d; };\n var peg$f32 = function(d, x) { return x; };\n var peg$f33 = function(d, v, end) { return end == d; };\n var peg$f34 = function(d, v) {\n return [\n createNode(\"string\", { content: d }),\n createNode(\"string\", { content: v.join(\"\") }),\n createNode(\"string\", { content: d }),\n ];\n };\n var peg$f35 = function(macro, option, verbatim) {\n return [\n createNode(\"macro\", { content: macro }),\n ...(option || []),\n ...[].concat(verbatim),\n ];\n };\n var peg$f36 = function(macro, option, language, verbatim) {\n return [\n createNode(\"macro\", { content: macro }),\n ...(option || []),\n language,\n ...[].concat(verbatim),\n ];\n };\n var peg$f37 = function(env, lang, end_env) { return compare_env({ content: [env] }, end_env); };\n var peg$f38 = function(env, lang, x) { return x; };\n var peg$f39 = function(env, lang, body) {\n return createNode(\"verbatim\", {\n env: `${env}{${lang.content.content}}`,\n content: body.join(\"\"),\n });\n };\n var peg$f40 = function(env, end_env) { return compare_env({ content: [env] }, end_env); };\n var peg$f41 = function(env, x) { return x; };\n var peg$f42 = function(env, body) {\n return createNode(\"verbatim\", {\n env: env,\n content: body.join(\"\"),\n });\n };\n var peg$f43 = function(n) { return n.join(\"\"); };\n var peg$f44 = function(n) { return n; };\n var peg$f45 = function(m) {\n return createNode(\"macro\", { content: m });\n };\n var peg$f46 = function(c) { return c; };\n var peg$f47 = function(x) {\n return createNode(\"group\", { content: x.flatMap((x) => x) });\n };\n var peg$f48 = function(g) { return text().slice(1, -1); };\n var peg$f49 = function(env, env_comment, end_env) { return compare_env(env, end_env); };\n var peg$f50 = function(env, env_comment, x) { return x; };\n var peg$f51 = function(env, env_comment, body) {\n body = body.flatMap((x) => x);\n return createNode(\"environment\", {\n env,\n content: env_comment ? [env_comment, ...body] : body,\n });\n };\n var peg$f52 = function(env, env_comment, end_env) { return compare_env({ content: [env] }, end_env); };\n var peg$f53 = function(env, env_comment, x) { return x; };\n var peg$f54 = function(env, env_comment, body) {\n body = body.flatMap((x) => x);\n return createNode(\"mathenv\", {\n env: env,\n content: env_comment ? [env_comment, ...body] : body,\n });\n };\n var peg$f55 = function(c) { return c; };\n var peg$f56 = function(x) {\n return createNode(\"group\", { content: x.flatMap((x) => x) });\n };\n var peg$f57 = function(e) { return createNode(\"string\", { content: e }); };\n var peg$f58 = function() { return createNode(\"string\", { content: \"\\\\\" }); };\n var peg$f59 = function(s) { return createNode(\"string\", { content: s }); };\n var peg$f60 = function(s) { return createNode(\"string\", { content: s }); };\n var peg$f61 = function(s) { return createNode(\"string\", { content: s }); };\n var peg$f62 = function(s) { return createNode(\"string\", { content: s }); };\n var peg$f63 = function(s) { return createNode(\"string\", { content: s }); };\n var peg$f64 = function(s) { return createNode(\"string\", { content: s }); };\n var peg$f65 = function(s) { return createNode(\"string\", { content: s }); };\n var peg$f66 = function() { return \" \"; };\n var peg$f67 = function(p) {\n return createNode(\"string\", { content: p });\n };\n var peg$f68 = function(leading_sp, comment) {\n return createNode(\"comment\", {\n ...comment,\n sameline: false,\n leadingWhitespace: leading_sp.length > 0,\n });\n };\n var peg$f69 = function(spaces, x) {\n return createNode(\"comment\", {\n ...x,\n sameline: true,\n leadingWhitespace: spaces.length > 0,\n });\n };\n var peg$f70 = function(c) { return c; };\n var peg$f71 = function(c) {\n return { content: c.join(\"\"), suffixParbreak: true };\n };\n var peg$f72 = function(c) { return c; };\n var peg$f73 = function(c) { return { content: c.join(\"\") }; };\n var peg$f74 = function() {\n var loc = location();\n return loc.start.column === 1;\n };\n var peg$currPos = 0;\n var peg$savedPos = 0;\n var peg$posDetailsCache = [{ line: 1, column: 1 }];\n var peg$maxFailPos = 0;\n var peg$maxFailExpected = [];\n var peg$silentFails = 0;\n\n var peg$result;\n\n if (\"startRule\" in options) {\n if (!(options.startRule in peg$startRuleFunctions)) {\n throw new Error(\"Can't start parsing from rule \\\"\" + options.startRule + \"\\\".\");\n }\n\n peg$startRuleFunction = peg$startRuleFunctions[options.startRule];\n }\n\n function text() {\n return input.substring(peg$savedPos, peg$currPos);\n }\n\n function offset() {\n return peg$savedPos;\n }\n\n function range() {\n return {\n source: peg$source,\n start: peg$savedPos,\n end: peg$currPos\n };\n }\n\n function location() {\n return peg$computeLocation(peg$savedPos, peg$currPos);\n }\n\n function expected(description, location) {\n location = location !== undefined\n ? location\n : peg$computeLocation(peg$savedPos, peg$currPos);\n\n throw peg$buildStructuredError(\n [peg$otherExpectation(description)],\n input.substring(peg$savedPos, peg$currPos),\n location\n );\n }\n\n function error(message, location) {\n location = location !== undefined\n ? location\n : peg$computeLocation(peg$savedPos, peg$currPos);\n\n throw peg$buildSimpleError(message, location);\n }\n\n function peg$literalExpectation(text, ignoreCase) {\n return { type: \"literal\", text: text, ignoreCase: ignoreCase };\n }\n\n function peg$classExpectation(parts, inverted, ignoreCase) {\n return { type: \"class\", parts: parts, inverted: inverted, ignoreCase: ignoreCase };\n }\n\n function peg$anyExpectation() {\n return { type: \"any\" };\n }\n\n function peg$endExpectation() {\n return { type: \"end\" };\n }\n\n function peg$otherExpectation(description) {\n return { type: \"other\", description: description };\n }\n\n function peg$computePosDetails(pos) {\n var details = peg$posDetailsCache[pos];\n var p;\n\n if (details) {\n return details;\n } else {\n p = pos - 1;\n while (!peg$posDetailsCache[p]) {\n p--;\n }\n\n details = peg$posDetailsCache[p];\n details = {\n line: details.line,\n column: details.column\n };\n\n while (p < pos) {\n if (input.charCodeAt(p) === 10) {\n details.line++;\n details.column = 1;\n } else {\n details.column++;\n }\n\n p++;\n }\n\n peg$posDetailsCache[pos] = details;\n\n return details;\n }\n }\n\n function peg$computeLocation(startPos, endPos) {\n var startPosDetails = peg$computePosDetails(startPos);\n var endPosDetails = peg$computePosDetails(endPos);\n\n return {\n source: peg$source,\n start: {\n offset: startPos,\n line: startPosDetails.line,\n column: startPosDetails.column\n },\n end: {\n offset: endPos,\n line: endPosDetails.line,\n column: endPosDetails.column\n }\n };\n }\n\n function peg$fail(expected) {\n if (peg$currPos < peg$maxFailPos) { return; }\n\n if (peg$currPos > peg$maxFailPos) {\n peg$maxFailPos = peg$currPos;\n peg$maxFailExpected = [];\n }\n\n peg$maxFailExpected.push(expected);\n }\n\n function peg$buildSimpleError(message, location) {\n return new peg$SyntaxError(message, null, null, location);\n }\n\n function peg$buildStructuredError(expected, found, location) {\n return new peg$SyntaxError(\n peg$SyntaxError.buildMessage(expected, found),\n expected,\n found,\n location\n );\n }\n\n function peg$parsedocument() {\n var s0, s1, s2;\n\n peg$silentFails++;\n s0 = peg$currPos;\n s1 = [];\n s2 = peg$parsetoken();\n while (s2 !== peg$FAILED) {\n s1.push(s2);\n s2 = peg$parsetoken();\n }\n peg$savedPos = s0;\n s1 = peg$f0(s1);\n s0 = s1;\n peg$silentFails--;\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e0); }\n\n return s0;\n }\n\n function peg$parsemath() {\n var s0, s1;\n\n peg$silentFails++;\n s0 = [];\n s1 = peg$parsemath_token();\n while (s1 !== peg$FAILED) {\n s0.push(s1);\n s1 = peg$parsemath_token();\n }\n peg$silentFails--;\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e1); }\n\n return s0;\n }\n\n function peg$parsetoken() {\n var s0, s1, s2, s3, s4, s5;\n\n peg$silentFails++;\n s0 = peg$parsespecial_macro();\n if (s0 === peg$FAILED) {\n s0 = peg$parsemacro();\n if (s0 === peg$FAILED) {\n s0 = peg$parsefull_comment();\n if (s0 === peg$FAILED) {\n s0 = peg$parsegroup();\n if (s0 === peg$FAILED) {\n s0 = peg$currPos;\n s1 = peg$parsemath_shift();\n if (s1 !== peg$FAILED) {\n s2 = [];\n s3 = peg$currPos;\n s4 = peg$currPos;\n peg$silentFails++;\n s5 = peg$parsemath_shift();\n peg$silentFails--;\n if (s5 === peg$FAILED) {\n s4 = undefined;\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n if (s4 !== peg$FAILED) {\n s5 = peg$parsemath_token();\n if (s5 !== peg$FAILED) {\n peg$savedPos = s3;\n s3 = peg$f1(s5);\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n if (s3 !== peg$FAILED) {\n while (s3 !== peg$FAILED) {\n s2.push(s3);\n s3 = peg$currPos;\n s4 = peg$currPos;\n peg$silentFails++;\n s5 = peg$parsemath_shift();\n peg$silentFails--;\n if (s5 === peg$FAILED) {\n s4 = undefined;\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n if (s4 !== peg$FAILED) {\n s5 = peg$parsemath_token();\n if (s5 !== peg$FAILED) {\n peg$savedPos = s3;\n s3 = peg$f1(s5);\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n }\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n s3 = peg$parsemath_shift();\n if (s3 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f2(s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n if (s0 === peg$FAILED) {\n s0 = peg$parsealignment_tab();\n if (s0 === peg$FAILED) {\n s0 = peg$parseparbreak();\n if (s0 === peg$FAILED) {\n s0 = peg$parsemacro_parameter();\n if (s0 === peg$FAILED) {\n s0 = peg$parseignore();\n if (s0 === peg$FAILED) {\n s0 = peg$parsenumber();\n if (s0 === peg$FAILED) {\n s0 = peg$parsewhitespace();\n if (s0 === peg$FAILED) {\n s0 = peg$parsepunctuation();\n if (s0 === peg$FAILED) {\n s0 = peg$currPos;\n s1 = peg$currPos;\n s2 = [];\n s3 = peg$currPos;\n s4 = peg$currPos;\n peg$silentFails++;\n s5 = peg$parsenonchar_token();\n peg$silentFails--;\n if (s5 === peg$FAILED) {\n s4 = undefined;\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n if (s4 !== peg$FAILED) {\n if (input.length > peg$currPos) {\n s5 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s5 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e3); }\n }\n if (s5 !== peg$FAILED) {\n s4 = [s4, s5];\n s3 = s4;\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n if (s3 !== peg$FAILED) {\n while (s3 !== peg$FAILED) {\n s2.push(s3);\n s3 = peg$currPos;\n s4 = peg$currPos;\n peg$silentFails++;\n s5 = peg$parsenonchar_token();\n peg$silentFails--;\n if (s5 === peg$FAILED) {\n s4 = undefined;\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n if (s4 !== peg$FAILED) {\n if (input.length > peg$currPos) {\n s5 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s5 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e3); }\n }\n if (s5 !== peg$FAILED) {\n s4 = [s4, s5];\n s3 = s4;\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n }\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n s1 = input.substring(s1, peg$currPos);\n } else {\n s1 = s2;\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = s0;\n s1 = peg$f3(s1);\n }\n s0 = s1;\n if (s0 === peg$FAILED) {\n s0 = peg$parsebegin_group();\n if (s0 === peg$FAILED) {\n s0 = peg$parseend_group();\n if (s0 === peg$FAILED) {\n s0 = peg$parsemath_shift();\n if (s0 === peg$FAILED) {\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e3); }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = s0;\n s1 = peg$f4(s1);\n }\n s0 = s1;\n }\n }\n }\n }\n }\n }\n }\n }\n }\n }\n }\n }\n }\n }\n }\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e2); }\n }\n\n return s0;\n }\n\n function peg$parseparbreak() {\n var s0, s1, s2, s3, s4, s5, s6, s7;\n\n peg$silentFails++;\n s0 = peg$currPos;\n s1 = peg$currPos;\n s2 = [];\n s3 = peg$parsesp();\n while (s3 !== peg$FAILED) {\n s2.push(s3);\n s3 = peg$parsesp();\n }\n s3 = peg$parsenl();\n if (s3 !== peg$FAILED) {\n s4 = [];\n s5 = peg$currPos;\n s6 = [];\n s7 = peg$parsesp();\n while (s7 !== peg$FAILED) {\n s6.push(s7);\n s7 = peg$parsesp();\n }\n s7 = peg$parsenl();\n if (s7 !== peg$FAILED) {\n s6 = [s6, s7];\n s5 = s6;\n } else {\n peg$currPos = s5;\n s5 = peg$FAILED;\n }\n if (s5 !== peg$FAILED) {\n while (s5 !== peg$FAILED) {\n s4.push(s5);\n s5 = peg$currPos;\n s6 = [];\n s7 = peg$parsesp();\n while (s7 !== peg$FAILED) {\n s6.push(s7);\n s7 = peg$parsesp();\n }\n s7 = peg$parsenl();\n if (s7 !== peg$FAILED) {\n s6 = [s6, s7];\n s5 = s6;\n } else {\n peg$currPos = s5;\n s5 = peg$FAILED;\n }\n }\n } else {\n s4 = peg$FAILED;\n }\n if (s4 !== peg$FAILED) {\n s5 = [];\n s6 = peg$parsesp();\n while (s6 !== peg$FAILED) {\n s5.push(s6);\n s6 = peg$parsesp();\n }\n s6 = peg$currPos;\n peg$silentFails++;\n s7 = peg$parsecomment_start();\n peg$silentFails--;\n if (s7 === peg$FAILED) {\n s6 = undefined;\n } else {\n peg$currPos = s6;\n s6 = peg$FAILED;\n }\n if (s6 !== peg$FAILED) {\n s2 = [s2, s3, s4, s5, s6];\n s1 = s2;\n } else {\n peg$currPos = s1;\n s1 = peg$FAILED;\n }\n } else {\n peg$currPos = s1;\n s1 = peg$FAILED;\n }\n } else {\n peg$currPos = s1;\n s1 = peg$FAILED;\n }\n if (s1 === peg$FAILED) {\n s1 = peg$currPos;\n s2 = [];\n s3 = peg$parsesp();\n while (s3 !== peg$FAILED) {\n s2.push(s3);\n s3 = peg$parsesp();\n }\n s3 = peg$parsenl();\n if (s3 !== peg$FAILED) {\n s4 = [];\n s5 = peg$currPos;\n s6 = [];\n s7 = peg$parsesp();\n while (s7 !== peg$FAILED) {\n s6.push(s7);\n s7 = peg$parsesp();\n }\n s7 = peg$parsenl();\n if (s7 !== peg$FAILED) {\n s6 = [s6, s7];\n s5 = s6;\n } else {\n peg$currPos = s5;\n s5 = peg$FAILED;\n }\n if (s5 !== peg$FAILED) {\n while (s5 !== peg$FAILED) {\n s4.push(s5);\n s5 = peg$currPos;\n s6 = [];\n s7 = peg$parsesp();\n while (s7 !== peg$FAILED) {\n s6.push(s7);\n s7 = peg$parsesp();\n }\n s7 = peg$parsenl();\n if (s7 !== peg$FAILED) {\n s6 = [s6, s7];\n s5 = s6;\n } else {\n peg$currPos = s5;\n s5 = peg$FAILED;\n }\n }\n } else {\n s4 = peg$FAILED;\n }\n if (s4 !== peg$FAILED) {\n s2 = [s2, s3, s4];\n s1 = s2;\n } else {\n peg$currPos = s1;\n s1 = peg$FAILED;\n }\n } else {\n peg$currPos = s1;\n s1 = peg$FAILED;\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = s0;\n s1 = peg$f5();\n }\n s0 = s1;\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e4); }\n }\n\n return s0;\n }\n\n function peg$parsemath_token() {\n var s0, s1, s2, s3, s4;\n\n peg$silentFails++;\n s0 = peg$parsespecial_macro();\n if (s0 === peg$FAILED) {\n s0 = peg$parsemacro();\n if (s0 === peg$FAILED) {\n s0 = peg$parsefull_comment();\n if (s0 === peg$FAILED) {\n s0 = peg$currPos;\n s1 = [];\n s2 = peg$parsewhitespace();\n while (s2 !== peg$FAILED) {\n s1.push(s2);\n s2 = peg$parsewhitespace();\n }\n s2 = peg$parsegroup();\n if (s2 !== peg$FAILED) {\n s3 = [];\n s4 = peg$parsewhitespace();\n while (s4 !== peg$FAILED) {\n s3.push(s4);\n s4 = peg$parsewhitespace();\n }\n peg$savedPos = s0;\n s0 = peg$f6(s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n if (s0 === peg$FAILED) {\n s0 = peg$currPos;\n s1 = [];\n s2 = peg$parsewhitespace();\n while (s2 !== peg$FAILED) {\n s1.push(s2);\n s2 = peg$parsewhitespace();\n }\n s2 = peg$parsealignment_tab();\n if (s2 !== peg$FAILED) {\n s3 = [];\n s4 = peg$parsewhitespace();\n while (s4 !== peg$FAILED) {\n s3.push(s4);\n s4 = peg$parsewhitespace();\n }\n peg$savedPos = s0;\n s0 = peg$f7(s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n if (s0 === peg$FAILED) {\n s0 = peg$parsemacro_parameter();\n if (s0 === peg$FAILED) {\n s0 = peg$currPos;\n s1 = [];\n s2 = peg$parsewhitespace();\n while (s2 !== peg$FAILED) {\n s1.push(s2);\n s2 = peg$parsewhitespace();\n }\n s2 = peg$parsesuperscript();\n if (s2 !== peg$FAILED) {\n s3 = [];\n s4 = peg$parsewhitespace();\n while (s4 !== peg$FAILED) {\n s3.push(s4);\n s4 = peg$parsewhitespace();\n }\n peg$savedPos = s0;\n s0 = peg$f8();\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n if (s0 === peg$FAILED) {\n s0 = peg$currPos;\n s1 = [];\n s2 = peg$parsewhitespace();\n while (s2 !== peg$FAILED) {\n s1.push(s2);\n s2 = peg$parsewhitespace();\n }\n s2 = peg$parsesubscript();\n if (s2 !== peg$FAILED) {\n s3 = [];\n s4 = peg$parsewhitespace();\n while (s4 !== peg$FAILED) {\n s3.push(s4);\n s4 = peg$parsewhitespace();\n }\n peg$savedPos = s0;\n s0 = peg$f9();\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n if (s0 === peg$FAILED) {\n s0 = peg$parseignore();\n if (s0 === peg$FAILED) {\n s0 = peg$parsewhitespace();\n if (s0 === peg$FAILED) {\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e3); }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = s0;\n s1 = peg$f10(s1);\n }\n s0 = s1;\n }\n }\n }\n }\n }\n }\n }\n }\n }\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e5); }\n }\n\n return s0;\n }\n\n function peg$parsenonchar_token() {\n var s0, s1;\n\n peg$silentFails++;\n s0 = peg$parseescape();\n if (s0 === peg$FAILED) {\n if (input.charCodeAt(peg$currPos) === 37) {\n s0 = peg$c0;\n peg$currPos++;\n } else {\n s0 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e7); }\n }\n if (s0 === peg$FAILED) {\n s0 = peg$parsebegin_group();\n if (s0 === peg$FAILED) {\n s0 = peg$parseend_group();\n if (s0 === peg$FAILED) {\n s0 = peg$parsemath_shift();\n if (s0 === peg$FAILED) {\n s0 = peg$parsealignment_tab();\n if (s0 === peg$FAILED) {\n s0 = peg$parsenl();\n if (s0 === peg$FAILED) {\n s0 = peg$parsemacro_parameter();\n if (s0 === peg$FAILED) {\n s0 = peg$parseignore();\n if (s0 === peg$FAILED) {\n s0 = peg$parsesp();\n if (s0 === peg$FAILED) {\n s0 = peg$parsepunctuation();\n if (s0 === peg$FAILED) {\n s0 = peg$parseEOF();\n }\n }\n }\n }\n }\n }\n }\n }\n }\n }\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e6); }\n }\n\n return s0;\n }\n\n function peg$parsewhitespace() {\n var s0, s1, s2, s3, s4, s5, s6, s7;\n\n peg$silentFails++;\n s0 = peg$currPos;\n s1 = peg$currPos;\n s2 = peg$parsenl();\n if (s2 !== peg$FAILED) {\n s3 = [];\n s4 = peg$parsesp();\n while (s4 !== peg$FAILED) {\n s3.push(s4);\n s4 = peg$parsesp();\n }\n s2 = [s2, s3];\n s1 = s2;\n } else {\n peg$currPos = s1;\n s1 = peg$FAILED;\n }\n if (s1 === peg$FAILED) {\n s1 = peg$currPos;\n s2 = [];\n s3 = peg$parsesp();\n if (s3 !== peg$FAILED) {\n while (s3 !== peg$FAILED) {\n s2.push(s3);\n s3 = peg$parsesp();\n }\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n s3 = peg$parsenl();\n if (s3 !== peg$FAILED) {\n s4 = peg$currPos;\n peg$silentFails++;\n s5 = peg$parsecomment_start();\n peg$silentFails--;\n if (s5 === peg$FAILED) {\n s4 = undefined;\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n if (s4 !== peg$FAILED) {\n s5 = [];\n s6 = peg$parsesp();\n while (s6 !== peg$FAILED) {\n s5.push(s6);\n s6 = peg$parsesp();\n }\n s6 = peg$currPos;\n peg$silentFails++;\n s7 = peg$parsenl();\n peg$silentFails--;\n if (s7 === peg$FAILED) {\n s6 = undefined;\n } else {\n peg$currPos = s6;\n s6 = peg$FAILED;\n }\n if (s6 !== peg$FAILED) {\n s2 = [s2, s3, s4, s5, s6];\n s1 = s2;\n } else {\n peg$currPos = s1;\n s1 = peg$FAILED;\n }\n } else {\n peg$currPos = s1;\n s1 = peg$FAILED;\n }\n } else {\n peg$currPos = s1;\n s1 = peg$FAILED;\n }\n } else {\n peg$currPos = s1;\n s1 = peg$FAILED;\n }\n if (s1 === peg$FAILED) {\n s1 = [];\n s2 = peg$parsesp();\n if (s2 !== peg$FAILED) {\n while (s2 !== peg$FAILED) {\n s1.push(s2);\n s2 = peg$parsesp();\n }\n } else {\n s1 = peg$FAILED;\n }\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = s0;\n s1 = peg$f11();\n }\n s0 = s1;\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e8); }\n }\n\n return s0;\n }\n\n function peg$parsenumber() {\n var s0, s1, s2, s3, s4, s5;\n\n peg$silentFails++;\n s0 = peg$currPos;\n s1 = peg$currPos;\n s2 = [];\n s3 = peg$parsenum();\n if (s3 !== peg$FAILED) {\n while (s3 !== peg$FAILED) {\n s2.push(s3);\n s3 = peg$parsenum();\n }\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n if (input.charCodeAt(peg$currPos) === 46) {\n s3 = peg$c1;\n peg$currPos++;\n } else {\n s3 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e10); }\n }\n if (s3 !== peg$FAILED) {\n s4 = [];\n s5 = peg$parsenum();\n if (s5 !== peg$FAILED) {\n while (s5 !== peg$FAILED) {\n s4.push(s5);\n s5 = peg$parsenum();\n }\n } else {\n s4 = peg$FAILED;\n }\n if (s4 !== peg$FAILED) {\n peg$savedPos = s1;\n s1 = peg$f12(s2, s4);\n } else {\n peg$currPos = s1;\n s1 = peg$FAILED;\n }\n } else {\n peg$currPos = s1;\n s1 = peg$FAILED;\n }\n } else {\n peg$currPos = s1;\n s1 = peg$FAILED;\n }\n if (s1 === peg$FAILED) {\n s1 = peg$currPos;\n if (input.charCodeAt(peg$currPos) === 46) {\n s2 = peg$c1;\n peg$currPos++;\n } else {\n s2 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e10); }\n }\n if (s2 !== peg$FAILED) {\n s3 = [];\n s4 = peg$parsenum();\n if (s4 !== peg$FAILED) {\n while (s4 !== peg$FAILED) {\n s3.push(s4);\n s4 = peg$parsenum();\n }\n } else {\n s3 = peg$FAILED;\n }\n if (s3 !== peg$FAILED) {\n peg$savedPos = s1;\n s1 = peg$f13(s3);\n } else {\n peg$currPos = s1;\n s1 = peg$FAILED;\n }\n } else {\n peg$currPos = s1;\n s1 = peg$FAILED;\n }\n if (s1 === peg$FAILED) {\n s1 = peg$currPos;\n s2 = [];\n s3 = peg$parsenum();\n if (s3 !== peg$FAILED) {\n while (s3 !== peg$FAILED) {\n s2.push(s3);\n s3 = peg$parsenum();\n }\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n if (input.charCodeAt(peg$currPos) === 46) {\n s3 = peg$c1;\n peg$currPos++;\n } else {\n s3 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e10); }\n }\n if (s3 !== peg$FAILED) {\n peg$savedPos = s1;\n s1 = peg$f14(s2);\n } else {\n peg$currPos = s1;\n s1 = peg$FAILED;\n }\n } else {\n peg$currPos = s1;\n s1 = peg$FAILED;\n }\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = s0;\n s1 = peg$f15(s1);\n }\n s0 = s1;\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e9); }\n }\n\n return s0;\n }\n\n function peg$parsespecial_macro() {\n var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;\n\n peg$silentFails++;\n s0 = peg$currPos;\n s1 = peg$parseescape();\n if (s1 !== peg$FAILED) {\n if (input.substr(peg$currPos, 5) === peg$c2) {\n s2 = peg$c2;\n peg$currPos += 5;\n } else {\n s2 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e12); }\n }\n if (s2 === peg$FAILED) {\n if (input.substr(peg$currPos, 4) === peg$c3) {\n s2 = peg$c3;\n peg$currPos += 4;\n } else {\n s2 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e13); }\n }\n }\n if (s2 !== peg$FAILED) {\n if (input.length > peg$currPos) {\n s3 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s3 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e3); }\n }\n if (s3 !== peg$FAILED) {\n s4 = [];\n s5 = peg$currPos;\n s6 = peg$currPos;\n peg$silentFails++;\n s7 = peg$currPos;\n if (input.length > peg$currPos) {\n s8 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s8 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e3); }\n }\n if (s8 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s9 = peg$f16(s2, s3, s8);\n if (s9) {\n s9 = undefined;\n } else {\n s9 = peg$FAILED;\n }\n if (s9 !== peg$FAILED) {\n s8 = [s8, s9];\n s7 = s8;\n } else {\n peg$currPos = s7;\n s7 = peg$FAILED;\n }\n } else {\n peg$currPos = s7;\n s7 = peg$FAILED;\n }\n peg$silentFails--;\n if (s7 === peg$FAILED) {\n s6 = undefined;\n } else {\n peg$currPos = s6;\n s6 = peg$FAILED;\n }\n if (s6 !== peg$FAILED) {\n if (input.length > peg$currPos) {\n s7 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s7 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e3); }\n }\n if (s7 !== peg$FAILED) {\n peg$savedPos = s5;\n s5 = peg$f17(s2, s3, s7);\n } else {\n peg$currPos = s5;\n s5 = peg$FAILED;\n }\n } else {\n peg$currPos = s5;\n s5 = peg$FAILED;\n }\n while (s5 !== peg$FAILED) {\n s4.push(s5);\n s5 = peg$currPos;\n s6 = peg$currPos;\n peg$silentFails++;\n s7 = peg$currPos;\n if (input.length > peg$currPos) {\n s8 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s8 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e3); }\n }\n if (s8 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s9 = peg$f16(s2, s3, s8);\n if (s9) {\n s9 = undefined;\n } else {\n s9 = peg$FAILED;\n }\n if (s9 !== peg$FAILED) {\n s8 = [s8, s9];\n s7 = s8;\n } else {\n peg$currPos = s7;\n s7 = peg$FAILED;\n }\n } else {\n peg$currPos = s7;\n s7 = peg$FAILED;\n }\n peg$silentFails--;\n if (s7 === peg$FAILED) {\n s6 = undefined;\n } else {\n peg$currPos = s6;\n s6 = peg$FAILED;\n }\n if (s6 !== peg$FAILED) {\n if (input.length > peg$currPos) {\n s7 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s7 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e3); }\n }\n if (s7 !== peg$FAILED) {\n peg$savedPos = s5;\n s5 = peg$f17(s2, s3, s7);\n } else {\n peg$currPos = s5;\n s5 = peg$FAILED;\n }\n } else {\n peg$currPos = s5;\n s5 = peg$FAILED;\n }\n }\n s5 = peg$currPos;\n if (input.length > peg$currPos) {\n s6 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s6 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e3); }\n }\n if (s6 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s7 = peg$f18(s2, s3, s4, s6);\n if (s7) {\n s7 = undefined;\n } else {\n s7 = peg$FAILED;\n }\n if (s7 !== peg$FAILED) {\n s6 = [s6, s7];\n s5 = s6;\n } else {\n peg$currPos = s5;\n s5 = peg$FAILED;\n }\n } else {\n peg$currPos = s5;\n s5 = peg$FAILED;\n }\n if (s5 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f19(s2, s3, s4);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n if (s0 === peg$FAILED) {\n s0 = peg$parseverbatim_listings();\n if (s0 === peg$FAILED) {\n s0 = peg$parseverbatim_minted();\n if (s0 === peg$FAILED) {\n s0 = peg$parseverbatim_environment();\n if (s0 === peg$FAILED) {\n s0 = peg$currPos;\n s1 = peg$parsebegin_display_math();\n if (s1 !== peg$FAILED) {\n s2 = [];\n s3 = peg$currPos;\n s4 = peg$currPos;\n peg$silentFails++;\n s5 = peg$parseend_display_math();\n peg$silentFails--;\n if (s5 === peg$FAILED) {\n s4 = undefined;\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n if (s4 !== peg$FAILED) {\n s5 = peg$parsemath_token();\n if (s5 !== peg$FAILED) {\n peg$savedPos = s3;\n s3 = peg$f20(s5);\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n while (s3 !== peg$FAILED) {\n s2.push(s3);\n s3 = peg$currPos;\n s4 = peg$currPos;\n peg$silentFails++;\n s5 = peg$parseend_display_math();\n peg$silentFails--;\n if (s5 === peg$FAILED) {\n s4 = undefined;\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n if (s4 !== peg$FAILED) {\n s5 = peg$parsemath_token();\n if (s5 !== peg$FAILED) {\n peg$savedPos = s3;\n s3 = peg$f20(s5);\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n }\n s3 = peg$parseend_display_math();\n if (s3 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f21(s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n if (s0 === peg$FAILED) {\n s0 = peg$currPos;\n s1 = peg$parsebegin_inline_math();\n if (s1 !== peg$FAILED) {\n s2 = [];\n s3 = peg$currPos;\n s4 = peg$currPos;\n peg$silentFails++;\n s5 = peg$parseend_inline_math();\n peg$silentFails--;\n if (s5 === peg$FAILED) {\n s4 = undefined;\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n if (s4 !== peg$FAILED) {\n s5 = peg$parsemath_token();\n if (s5 !== peg$FAILED) {\n peg$savedPos = s3;\n s3 = peg$f22(s5);\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n while (s3 !== peg$FAILED) {\n s2.push(s3);\n s3 = peg$currPos;\n s4 = peg$currPos;\n peg$silentFails++;\n s5 = peg$parseend_inline_math();\n peg$silentFails--;\n if (s5 === peg$FAILED) {\n s4 = undefined;\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n if (s4 !== peg$FAILED) {\n s5 = peg$parsemath_token();\n if (s5 !== peg$FAILED) {\n peg$savedPos = s3;\n s3 = peg$f22(s5);\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n }\n s3 = peg$parseend_inline_math();\n if (s3 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f23(s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n if (s0 === peg$FAILED) {\n s0 = peg$currPos;\n s1 = peg$parsemath_shift();\n if (s1 !== peg$FAILED) {\n s2 = peg$parsemath_shift();\n if (s2 !== peg$FAILED) {\n s3 = [];\n s4 = peg$currPos;\n s5 = peg$currPos;\n peg$silentFails++;\n s6 = peg$currPos;\n s7 = peg$parsemath_shift();\n if (s7 !== peg$FAILED) {\n s8 = peg$parsemath_shift();\n if (s8 !== peg$FAILED) {\n s7 = [s7, s8];\n s6 = s7;\n } else {\n peg$currPos = s6;\n s6 = peg$FAILED;\n }\n } else {\n peg$currPos = s6;\n s6 = peg$FAILED;\n }\n peg$silentFails--;\n if (s6 === peg$FAILED) {\n s5 = undefined;\n } else {\n peg$currPos = s5;\n s5 = peg$FAILED;\n }\n if (s5 !== peg$FAILED) {\n s6 = peg$parsemath_token();\n if (s6 !== peg$FAILED) {\n peg$savedPos = s4;\n s4 = peg$f24(s6);\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n while (s4 !== peg$FAILED) {\n s3.push(s4);\n s4 = peg$currPos;\n s5 = peg$currPos;\n peg$silentFails++;\n s6 = peg$currPos;\n s7 = peg$parsemath_shift();\n if (s7 !== peg$FAILED) {\n s8 = peg$parsemath_shift();\n if (s8 !== peg$FAILED) {\n s7 = [s7, s8];\n s6 = s7;\n } else {\n peg$currPos = s6;\n s6 = peg$FAILED;\n }\n } else {\n peg$currPos = s6;\n s6 = peg$FAILED;\n }\n peg$silentFails--;\n if (s6 === peg$FAILED) {\n s5 = undefined;\n } else {\n peg$currPos = s5;\n s5 = peg$FAILED;\n }\n if (s5 !== peg$FAILED) {\n s6 = peg$parsemath_token();\n if (s6 !== peg$FAILED) {\n peg$savedPos = s4;\n s4 = peg$f24(s6);\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n }\n s4 = peg$parsemath_shift();\n if (s4 !== peg$FAILED) {\n s5 = peg$parsemath_shift();\n if (s5 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f25(s3);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n if (s0 === peg$FAILED) {\n s0 = peg$parsemath_environment();\n if (s0 === peg$FAILED) {\n s0 = peg$parseenvironment();\n }\n }\n }\n }\n }\n }\n }\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e11); }\n }\n\n return s0;\n }\n\n function peg$parsesquare_bracket_argument() {\n var s0, s1, s2, s3, s4, s5, s6, s7;\n\n s0 = peg$currPos;\n if (input.charCodeAt(peg$currPos) === 91) {\n s1 = peg$c4;\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e14); }\n }\n if (s1 !== peg$FAILED) {\n s2 = [];\n s3 = peg$currPos;\n s4 = peg$currPos;\n peg$silentFails++;\n s5 = peg$currPos;\n s6 = peg$parsetoken();\n if (s6 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s7 = peg$f26(s6);\n if (s7) {\n s7 = undefined;\n } else {\n s7 = peg$FAILED;\n }\n if (s7 !== peg$FAILED) {\n s6 = [s6, s7];\n s5 = s6;\n } else {\n peg$currPos = s5;\n s5 = peg$FAILED;\n }\n } else {\n peg$currPos = s5;\n s5 = peg$FAILED;\n }\n peg$silentFails--;\n if (s5 === peg$FAILED) {\n s4 = undefined;\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n if (s4 !== peg$FAILED) {\n s5 = peg$parsetoken();\n if (s5 !== peg$FAILED) {\n peg$savedPos = s3;\n s3 = peg$f27(s5);\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n while (s3 !== peg$FAILED) {\n s2.push(s3);\n s3 = peg$currPos;\n s4 = peg$currPos;\n peg$silentFails++;\n s5 = peg$currPos;\n s6 = peg$parsetoken();\n if (s6 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s7 = peg$f26(s6);\n if (s7) {\n s7 = undefined;\n } else {\n s7 = peg$FAILED;\n }\n if (s7 !== peg$FAILED) {\n s6 = [s6, s7];\n s5 = s6;\n } else {\n peg$currPos = s5;\n s5 = peg$FAILED;\n }\n } else {\n peg$currPos = s5;\n s5 = peg$FAILED;\n }\n peg$silentFails--;\n if (s5 === peg$FAILED) {\n s4 = undefined;\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n if (s4 !== peg$FAILED) {\n s5 = peg$parsetoken();\n if (s5 !== peg$FAILED) {\n peg$savedPos = s3;\n s3 = peg$f27(s5);\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n }\n if (input.charCodeAt(peg$currPos) === 93) {\n s3 = peg$c5;\n peg$currPos++;\n } else {\n s3 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e15); }\n }\n if (s3 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f28(s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n\n return s0;\n }\n\n function peg$parseverbatim_group() {\n var s0, s1, s2, s3, s4, s5;\n\n s0 = peg$currPos;\n s1 = peg$parsebegin_group();\n if (s1 !== peg$FAILED) {\n s2 = [];\n s3 = peg$currPos;\n s4 = peg$currPos;\n peg$silentFails++;\n s5 = peg$parseend_group();\n peg$silentFails--;\n if (s5 === peg$FAILED) {\n s4 = undefined;\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n if (s4 !== peg$FAILED) {\n if (input.length > peg$currPos) {\n s5 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s5 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e3); }\n }\n if (s5 !== peg$FAILED) {\n peg$savedPos = s3;\n s3 = peg$f29(s5);\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n while (s3 !== peg$FAILED) {\n s2.push(s3);\n s3 = peg$currPos;\n s4 = peg$currPos;\n peg$silentFails++;\n s5 = peg$parseend_group();\n peg$silentFails--;\n if (s5 === peg$FAILED) {\n s4 = undefined;\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n if (s4 !== peg$FAILED) {\n if (input.length > peg$currPos) {\n s5 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s5 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e3); }\n }\n if (s5 !== peg$FAILED) {\n peg$savedPos = s3;\n s3 = peg$f29(s5);\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n }\n s3 = peg$parseend_group();\n if (s3 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f30(s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n\n return s0;\n }\n\n function peg$parseverbatim_delimited_by_char() {\n var s0, s1, s2, s3, s4, s5, s6, s7;\n\n s0 = peg$currPos;\n if (peg$r0.test(input.charAt(peg$currPos))) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e16); }\n }\n if (s1 !== peg$FAILED) {\n s2 = [];\n s3 = peg$currPos;\n s4 = peg$currPos;\n peg$silentFails++;\n s5 = peg$currPos;\n if (input.length > peg$currPos) {\n s6 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s6 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e3); }\n }\n if (s6 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s7 = peg$f31(s1, s6);\n if (s7) {\n s7 = undefined;\n } else {\n s7 = peg$FAILED;\n }\n if (s7 !== peg$FAILED) {\n s6 = [s6, s7];\n s5 = s6;\n } else {\n peg$currPos = s5;\n s5 = peg$FAILED;\n }\n } else {\n peg$currPos = s5;\n s5 = peg$FAILED;\n }\n peg$silentFails--;\n if (s5 === peg$FAILED) {\n s4 = undefined;\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n if (s4 !== peg$FAILED) {\n if (input.length > peg$currPos) {\n s5 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s5 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e3); }\n }\n if (s5 !== peg$FAILED) {\n peg$savedPos = s3;\n s3 = peg$f32(s1, s5);\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n while (s3 !== peg$FAILED) {\n s2.push(s3);\n s3 = peg$currPos;\n s4 = peg$currPos;\n peg$silentFails++;\n s5 = peg$currPos;\n if (input.length > peg$currPos) {\n s6 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s6 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e3); }\n }\n if (s6 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s7 = peg$f31(s1, s6);\n if (s7) {\n s7 = undefined;\n } else {\n s7 = peg$FAILED;\n }\n if (s7 !== peg$FAILED) {\n s6 = [s6, s7];\n s5 = s6;\n } else {\n peg$currPos = s5;\n s5 = peg$FAILED;\n }\n } else {\n peg$currPos = s5;\n s5 = peg$FAILED;\n }\n peg$silentFails--;\n if (s5 === peg$FAILED) {\n s4 = undefined;\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n if (s4 !== peg$FAILED) {\n if (input.length > peg$currPos) {\n s5 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s5 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e3); }\n }\n if (s5 !== peg$FAILED) {\n peg$savedPos = s3;\n s3 = peg$f32(s1, s5);\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n }\n s3 = peg$currPos;\n if (input.length > peg$currPos) {\n s4 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s4 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e3); }\n }\n if (s4 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s5 = peg$f33(s1, s2, s4);\n if (s5) {\n s5 = undefined;\n } else {\n s5 = peg$FAILED;\n }\n if (s5 !== peg$FAILED) {\n s4 = [s4, s5];\n s3 = s4;\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n if (s3 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f34(s1, s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n\n return s0;\n }\n\n function peg$parseverbatim_listings() {\n var s0, s1, s2, s3, s4;\n\n peg$silentFails++;\n s0 = peg$currPos;\n s1 = peg$parseescape();\n if (s1 !== peg$FAILED) {\n if (input.substr(peg$currPos, 9) === peg$c6) {\n s2 = peg$c6;\n peg$currPos += 9;\n } else {\n s2 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e18); }\n }\n if (s2 !== peg$FAILED) {\n s3 = peg$parsesquare_bracket_argument();\n if (s3 === peg$FAILED) {\n s3 = null;\n }\n s4 = peg$parseverbatim_group();\n if (s4 === peg$FAILED) {\n s4 = peg$parseverbatim_delimited_by_char();\n }\n if (s4 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f35(s2, s3, s4);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e17); }\n }\n\n return s0;\n }\n\n function peg$parseverbatim_minted() {\n var s0, s1, s2, s3, s4, s5;\n\n peg$silentFails++;\n s0 = peg$currPos;\n s1 = peg$parseescape();\n if (s1 !== peg$FAILED) {\n if (input.substr(peg$currPos, 10) === peg$c7) {\n s2 = peg$c7;\n peg$currPos += 10;\n } else {\n s2 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e20); }\n }\n if (s2 === peg$FAILED) {\n if (input.substr(peg$currPos, 4) === peg$c8) {\n s2 = peg$c8;\n peg$currPos += 4;\n } else {\n s2 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e21); }\n }\n }\n if (s2 !== peg$FAILED) {\n s3 = peg$parsesquare_bracket_argument();\n if (s3 === peg$FAILED) {\n s3 = null;\n }\n s4 = peg$parsegroup();\n if (s4 !== peg$FAILED) {\n s5 = peg$parseverbatim_group();\n if (s5 === peg$FAILED) {\n s5 = peg$parseverbatim_delimited_by_char();\n }\n if (s5 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f36(s2, s3, s4, s5);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e19); }\n }\n\n return s0;\n }\n\n function peg$parseverbatim_minted_environment() {\n var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12;\n\n peg$silentFails++;\n s0 = peg$currPos;\n s1 = peg$parsebegin_env();\n if (s1 !== peg$FAILED) {\n s2 = peg$parsebegin_group();\n if (s2 !== peg$FAILED) {\n if (input.substr(peg$currPos, 6) === peg$c9) {\n s3 = peg$c9;\n peg$currPos += 6;\n } else {\n s3 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e23); }\n }\n if (s3 !== peg$FAILED) {\n s4 = peg$parseend_group();\n if (s4 !== peg$FAILED) {\n s5 = peg$parsegroup();\n if (s5 !== peg$FAILED) {\n s6 = [];\n s7 = peg$currPos;\n s8 = peg$currPos;\n peg$silentFails++;\n s9 = peg$currPos;\n s10 = peg$parseend_env();\n if (s10 !== peg$FAILED) {\n s11 = peg$parsegroup();\n if (s11 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s12 = peg$f37(s3, s5, s11);\n if (s12) {\n s12 = undefined;\n } else {\n s12 = peg$FAILED;\n }\n if (s12 !== peg$FAILED) {\n s10 = [s10, s11, s12];\n s9 = s10;\n } else {\n peg$currPos = s9;\n s9 = peg$FAILED;\n }\n } else {\n peg$currPos = s9;\n s9 = peg$FAILED;\n }\n } else {\n peg$currPos = s9;\n s9 = peg$FAILED;\n }\n peg$silentFails--;\n if (s9 === peg$FAILED) {\n s8 = undefined;\n } else {\n peg$currPos = s8;\n s8 = peg$FAILED;\n }\n if (s8 !== peg$FAILED) {\n if (input.length > peg$currPos) {\n s9 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s9 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e3); }\n }\n if (s9 !== peg$FAILED) {\n peg$savedPos = s7;\n s7 = peg$f38(s3, s5, s9);\n } else {\n peg$currPos = s7;\n s7 = peg$FAILED;\n }\n } else {\n peg$currPos = s7;\n s7 = peg$FAILED;\n }\n while (s7 !== peg$FAILED) {\n s6.push(s7);\n s7 = peg$currPos;\n s8 = peg$currPos;\n peg$silentFails++;\n s9 = peg$currPos;\n s10 = peg$parseend_env();\n if (s10 !== peg$FAILED) {\n s11 = peg$parsegroup();\n if (s11 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s12 = peg$f37(s3, s5, s11);\n if (s12) {\n s12 = undefined;\n } else {\n s12 = peg$FAILED;\n }\n if (s12 !== peg$FAILED) {\n s10 = [s10, s11, s12];\n s9 = s10;\n } else {\n peg$currPos = s9;\n s9 = peg$FAILED;\n }\n } else {\n peg$currPos = s9;\n s9 = peg$FAILED;\n }\n } else {\n peg$currPos = s9;\n s9 = peg$FAILED;\n }\n peg$silentFails--;\n if (s9 === peg$FAILED) {\n s8 = undefined;\n } else {\n peg$currPos = s8;\n s8 = peg$FAILED;\n }\n if (s8 !== peg$FAILED) {\n if (input.length > peg$currPos) {\n s9 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s9 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e3); }\n }\n if (s9 !== peg$FAILED) {\n peg$savedPos = s7;\n s7 = peg$f38(s3, s5, s9);\n } else {\n peg$currPos = s7;\n s7 = peg$FAILED;\n }\n } else {\n peg$currPos = s7;\n s7 = peg$FAILED;\n }\n }\n s7 = peg$parseend_env();\n if (s7 !== peg$FAILED) {\n s8 = peg$parsebegin_group();\n if (s8 !== peg$FAILED) {\n s9 = peg$parseverbatim_env_name();\n if (s9 !== peg$FAILED) {\n s10 = peg$parseend_group();\n if (s10 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f39(s3, s5, s6);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e22); }\n }\n\n return s0;\n }\n\n function peg$parseverbatim_environment() {\n var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11;\n\n peg$silentFails++;\n s0 = peg$currPos;\n s1 = peg$parsebegin_env();\n if (s1 !== peg$FAILED) {\n s2 = peg$parsebegin_group();\n if (s2 !== peg$FAILED) {\n s3 = peg$parseverbatim_env_name();\n if (s3 !== peg$FAILED) {\n s4 = peg$parseend_group();\n if (s4 !== peg$FAILED) {\n s5 = [];\n s6 = peg$currPos;\n s7 = peg$currPos;\n peg$silentFails++;\n s8 = peg$currPos;\n s9 = peg$parseend_env();\n if (s9 !== peg$FAILED) {\n s10 = peg$parsegroup();\n if (s10 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s11 = peg$f40(s3, s10);\n if (s11) {\n s11 = undefined;\n } else {\n s11 = peg$FAILED;\n }\n if (s11 !== peg$FAILED) {\n s9 = [s9, s10, s11];\n s8 = s9;\n } else {\n peg$currPos = s8;\n s8 = peg$FAILED;\n }\n } else {\n peg$currPos = s8;\n s8 = peg$FAILED;\n }\n } else {\n peg$currPos = s8;\n s8 = peg$FAILED;\n }\n peg$silentFails--;\n if (s8 === peg$FAILED) {\n s7 = undefined;\n } else {\n peg$currPos = s7;\n s7 = peg$FAILED;\n }\n if (s7 !== peg$FAILED) {\n if (input.length > peg$currPos) {\n s8 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s8 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e3); }\n }\n if (s8 !== peg$FAILED) {\n peg$savedPos = s6;\n s6 = peg$f41(s3, s8);\n } else {\n peg$currPos = s6;\n s6 = peg$FAILED;\n }\n } else {\n peg$currPos = s6;\n s6 = peg$FAILED;\n }\n while (s6 !== peg$FAILED) {\n s5.push(s6);\n s6 = peg$currPos;\n s7 = peg$currPos;\n peg$silentFails++;\n s8 = peg$currPos;\n s9 = peg$parseend_env();\n if (s9 !== peg$FAILED) {\n s10 = peg$parsegroup();\n if (s10 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s11 = peg$f40(s3, s10);\n if (s11) {\n s11 = undefined;\n } else {\n s11 = peg$FAILED;\n }\n if (s11 !== peg$FAILED) {\n s9 = [s9, s10, s11];\n s8 = s9;\n } else {\n peg$currPos = s8;\n s8 = peg$FAILED;\n }\n } else {\n peg$currPos = s8;\n s8 = peg$FAILED;\n }\n } else {\n peg$currPos = s8;\n s8 = peg$FAILED;\n }\n peg$silentFails--;\n if (s8 === peg$FAILED) {\n s7 = undefined;\n } else {\n peg$currPos = s7;\n s7 = peg$FAILED;\n }\n if (s7 !== peg$FAILED) {\n if (input.length > peg$currPos) {\n s8 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s8 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e3); }\n }\n if (s8 !== peg$FAILED) {\n peg$savedPos = s6;\n s6 = peg$f41(s3, s8);\n } else {\n peg$currPos = s6;\n s6 = peg$FAILED;\n }\n } else {\n peg$currPos = s6;\n s6 = peg$FAILED;\n }\n }\n s6 = peg$parseend_env();\n if (s6 !== peg$FAILED) {\n s7 = peg$parsebegin_group();\n if (s7 !== peg$FAILED) {\n s8 = peg$parseverbatim_env_name();\n if (s8 !== peg$FAILED) {\n s9 = peg$parseend_group();\n if (s9 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f42(s3, s5);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e24); }\n }\n\n return s0;\n }\n\n function peg$parseverbatim_env_name() {\n var s0;\n\n if (input.substr(peg$currPos, 9) === peg$c10) {\n s0 = peg$c10;\n peg$currPos += 9;\n } else {\n s0 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e25); }\n }\n if (s0 === peg$FAILED) {\n if (input.substr(peg$currPos, 8) === peg$c11) {\n s0 = peg$c11;\n peg$currPos += 8;\n } else {\n s0 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e26); }\n }\n if (s0 === peg$FAILED) {\n if (input.substr(peg$currPos, 13) === peg$c12) {\n s0 = peg$c12;\n peg$currPos += 13;\n } else {\n s0 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e27); }\n }\n if (s0 === peg$FAILED) {\n if (input.substr(peg$currPos, 12) === peg$c13) {\n s0 = peg$c13;\n peg$currPos += 12;\n } else {\n s0 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e28); }\n }\n if (s0 === peg$FAILED) {\n if (input.substr(peg$currPos, 7) === peg$c14) {\n s0 = peg$c14;\n peg$currPos += 7;\n } else {\n s0 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e29); }\n }\n if (s0 === peg$FAILED) {\n if (input.substr(peg$currPos, 10) === peg$c15) {\n s0 = peg$c15;\n peg$currPos += 10;\n } else {\n s0 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e30); }\n }\n }\n }\n }\n }\n }\n\n return s0;\n }\n\n function peg$parsemacro() {\n var s0, s1, s2, s3, s4;\n\n peg$silentFails++;\n s0 = peg$currPos;\n s1 = peg$currPos;\n s2 = peg$parseescape();\n if (s2 !== peg$FAILED) {\n s3 = [];\n s4 = peg$parsechar();\n if (s4 !== peg$FAILED) {\n while (s4 !== peg$FAILED) {\n s3.push(s4);\n s4 = peg$parsechar();\n }\n } else {\n s3 = peg$FAILED;\n }\n if (s3 !== peg$FAILED) {\n peg$savedPos = s1;\n s1 = peg$f43(s3);\n } else {\n peg$currPos = s1;\n s1 = peg$FAILED;\n }\n } else {\n peg$currPos = s1;\n s1 = peg$FAILED;\n }\n if (s1 === peg$FAILED) {\n s1 = peg$currPos;\n s2 = peg$parseescape();\n if (s2 !== peg$FAILED) {\n if (input.length > peg$currPos) {\n s3 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s3 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e3); }\n }\n if (s3 !== peg$FAILED) {\n peg$savedPos = s1;\n s1 = peg$f44(s3);\n } else {\n peg$currPos = s1;\n s1 = peg$FAILED;\n }\n } else {\n peg$currPos = s1;\n s1 = peg$FAILED;\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = s0;\n s1 = peg$f45(s1);\n }\n s0 = s1;\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e31); }\n }\n\n return s0;\n }\n\n function peg$parsegroup() {\n var s0, s1, s2, s3, s4, s5;\n\n peg$silentFails++;\n s0 = peg$currPos;\n s1 = peg$parsebegin_group();\n if (s1 !== peg$FAILED) {\n s2 = [];\n s3 = peg$currPos;\n s4 = peg$currPos;\n peg$silentFails++;\n s5 = peg$parseend_group();\n peg$silentFails--;\n if (s5 === peg$FAILED) {\n s4 = undefined;\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n if (s4 !== peg$FAILED) {\n s5 = peg$parsetoken();\n if (s5 !== peg$FAILED) {\n peg$savedPos = s3;\n s3 = peg$f46(s5);\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n while (s3 !== peg$FAILED) {\n s2.push(s3);\n s3 = peg$currPos;\n s4 = peg$currPos;\n peg$silentFails++;\n s5 = peg$parseend_group();\n peg$silentFails--;\n if (s5 === peg$FAILED) {\n s4 = undefined;\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n if (s4 !== peg$FAILED) {\n s5 = peg$parsetoken();\n if (s5 !== peg$FAILED) {\n peg$savedPos = s3;\n s3 = peg$f46(s5);\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n }\n s3 = peg$parseend_group();\n if (s3 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f47(s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e32); }\n }\n\n return s0;\n }\n\n function peg$parsegroup_contents_as_string() {\n var s0, s1;\n\n s0 = peg$currPos;\n s1 = peg$parsegroup();\n if (s1 !== peg$FAILED) {\n peg$savedPos = s0;\n s1 = peg$f48(s1);\n }\n s0 = s1;\n\n return s0;\n }\n\n function peg$parseenvironment() {\n var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10;\n\n peg$silentFails++;\n s0 = peg$currPos;\n s1 = peg$parsebegin_env();\n if (s1 !== peg$FAILED) {\n s2 = peg$parsegroup_contents_as_string();\n if (s2 !== peg$FAILED) {\n s3 = peg$parsesameline_comment();\n if (s3 === peg$FAILED) {\n s3 = null;\n }\n s4 = [];\n s5 = peg$currPos;\n s6 = peg$currPos;\n peg$silentFails++;\n s7 = peg$currPos;\n s8 = peg$parseend_env();\n if (s8 !== peg$FAILED) {\n s9 = peg$parsegroup_contents_as_string();\n if (s9 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s10 = peg$f49(s2, s3, s9);\n if (s10) {\n s10 = undefined;\n } else {\n s10 = peg$FAILED;\n }\n if (s10 !== peg$FAILED) {\n s8 = [s8, s9, s10];\n s7 = s8;\n } else {\n peg$currPos = s7;\n s7 = peg$FAILED;\n }\n } else {\n peg$currPos = s7;\n s7 = peg$FAILED;\n }\n } else {\n peg$currPos = s7;\n s7 = peg$FAILED;\n }\n peg$silentFails--;\n if (s7 === peg$FAILED) {\n s6 = undefined;\n } else {\n peg$currPos = s6;\n s6 = peg$FAILED;\n }\n if (s6 !== peg$FAILED) {\n s7 = peg$parsetoken();\n if (s7 !== peg$FAILED) {\n peg$savedPos = s5;\n s5 = peg$f50(s2, s3, s7);\n } else {\n peg$currPos = s5;\n s5 = peg$FAILED;\n }\n } else {\n peg$currPos = s5;\n s5 = peg$FAILED;\n }\n while (s5 !== peg$FAILED) {\n s4.push(s5);\n s5 = peg$currPos;\n s6 = peg$currPos;\n peg$silentFails++;\n s7 = peg$currPos;\n s8 = peg$parseend_env();\n if (s8 !== peg$FAILED) {\n s9 = peg$parsegroup_contents_as_string();\n if (s9 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s10 = peg$f49(s2, s3, s9);\n if (s10) {\n s10 = undefined;\n } else {\n s10 = peg$FAILED;\n }\n if (s10 !== peg$FAILED) {\n s8 = [s8, s9, s10];\n s7 = s8;\n } else {\n peg$currPos = s7;\n s7 = peg$FAILED;\n }\n } else {\n peg$currPos = s7;\n s7 = peg$FAILED;\n }\n } else {\n peg$currPos = s7;\n s7 = peg$FAILED;\n }\n peg$silentFails--;\n if (s7 === peg$FAILED) {\n s6 = undefined;\n } else {\n peg$currPos = s6;\n s6 = peg$FAILED;\n }\n if (s6 !== peg$FAILED) {\n s7 = peg$parsetoken();\n if (s7 !== peg$FAILED) {\n peg$savedPos = s5;\n s5 = peg$f50(s2, s3, s7);\n } else {\n peg$currPos = s5;\n s5 = peg$FAILED;\n }\n } else {\n peg$currPos = s5;\n s5 = peg$FAILED;\n }\n }\n s5 = peg$parseend_env();\n if (s5 !== peg$FAILED) {\n s6 = peg$parsegroup_contents_as_string();\n if (s6 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f51(s2, s3, s4);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e33); }\n }\n\n return s0;\n }\n\n function peg$parsemath_environment() {\n var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12;\n\n peg$silentFails++;\n s0 = peg$currPos;\n s1 = peg$parsebegin_env();\n if (s1 !== peg$FAILED) {\n s2 = peg$parsebegin_group();\n if (s2 !== peg$FAILED) {\n s3 = peg$parsemath_env_name();\n if (s3 !== peg$FAILED) {\n s4 = peg$parseend_group();\n if (s4 !== peg$FAILED) {\n s5 = peg$parsesameline_comment();\n if (s5 === peg$FAILED) {\n s5 = null;\n }\n s6 = [];\n s7 = peg$currPos;\n s8 = peg$currPos;\n peg$silentFails++;\n s9 = peg$currPos;\n s10 = peg$parseend_env();\n if (s10 !== peg$FAILED) {\n s11 = peg$parsegroup();\n if (s11 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s12 = peg$f52(s3, s5, s11);\n if (s12) {\n s12 = undefined;\n } else {\n s12 = peg$FAILED;\n }\n if (s12 !== peg$FAILED) {\n s10 = [s10, s11, s12];\n s9 = s10;\n } else {\n peg$currPos = s9;\n s9 = peg$FAILED;\n }\n } else {\n peg$currPos = s9;\n s9 = peg$FAILED;\n }\n } else {\n peg$currPos = s9;\n s9 = peg$FAILED;\n }\n peg$silentFails--;\n if (s9 === peg$FAILED) {\n s8 = undefined;\n } else {\n peg$currPos = s8;\n s8 = peg$FAILED;\n }\n if (s8 !== peg$FAILED) {\n s9 = peg$parsemath_token();\n if (s9 !== peg$FAILED) {\n peg$savedPos = s7;\n s7 = peg$f53(s3, s5, s9);\n } else {\n peg$currPos = s7;\n s7 = peg$FAILED;\n }\n } else {\n peg$currPos = s7;\n s7 = peg$FAILED;\n }\n while (s7 !== peg$FAILED) {\n s6.push(s7);\n s7 = peg$currPos;\n s8 = peg$currPos;\n peg$silentFails++;\n s9 = peg$currPos;\n s10 = peg$parseend_env();\n if (s10 !== peg$FAILED) {\n s11 = peg$parsegroup();\n if (s11 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s12 = peg$f52(s3, s5, s11);\n if (s12) {\n s12 = undefined;\n } else {\n s12 = peg$FAILED;\n }\n if (s12 !== peg$FAILED) {\n s10 = [s10, s11, s12];\n s9 = s10;\n } else {\n peg$currPos = s9;\n s9 = peg$FAILED;\n }\n } else {\n peg$currPos = s9;\n s9 = peg$FAILED;\n }\n } else {\n peg$currPos = s9;\n s9 = peg$FAILED;\n }\n peg$silentFails--;\n if (s9 === peg$FAILED) {\n s8 = undefined;\n } else {\n peg$currPos = s8;\n s8 = peg$FAILED;\n }\n if (s8 !== peg$FAILED) {\n s9 = peg$parsemath_token();\n if (s9 !== peg$FAILED) {\n peg$savedPos = s7;\n s7 = peg$f53(s3, s5, s9);\n } else {\n peg$currPos = s7;\n s7 = peg$FAILED;\n }\n } else {\n peg$currPos = s7;\n s7 = peg$FAILED;\n }\n }\n s7 = peg$parseend_env();\n if (s7 !== peg$FAILED) {\n s8 = peg$parsebegin_group();\n if (s8 !== peg$FAILED) {\n s9 = peg$parsemath_env_name();\n if (s9 !== peg$FAILED) {\n s10 = peg$parseend_group();\n if (s10 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f54(s3, s5, s6);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e34); }\n }\n\n return s0;\n }\n\n function peg$parsemath_group() {\n var s0, s1, s2, s3, s4, s5;\n\n peg$silentFails++;\n s0 = peg$currPos;\n s1 = peg$parsebegin_group();\n if (s1 !== peg$FAILED) {\n s2 = [];\n s3 = peg$currPos;\n s4 = peg$currPos;\n peg$silentFails++;\n s5 = peg$parseend_group();\n peg$silentFails--;\n if (s5 === peg$FAILED) {\n s4 = undefined;\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n if (s4 !== peg$FAILED) {\n s5 = peg$parsemath_token();\n if (s5 !== peg$FAILED) {\n peg$savedPos = s3;\n s3 = peg$f55(s5);\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n while (s3 !== peg$FAILED) {\n s2.push(s3);\n s3 = peg$currPos;\n s4 = peg$currPos;\n peg$silentFails++;\n s5 = peg$parseend_group();\n peg$silentFails--;\n if (s5 === peg$FAILED) {\n s4 = undefined;\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n if (s4 !== peg$FAILED) {\n s5 = peg$parsemath_token();\n if (s5 !== peg$FAILED) {\n peg$savedPos = s3;\n s3 = peg$f55(s5);\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n }\n s3 = peg$parseend_group();\n if (s3 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f56(s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e35); }\n }\n\n return s0;\n }\n\n function peg$parsebegin_display_math() {\n var s0, s1, s2;\n\n s0 = peg$currPos;\n s1 = peg$parseescape();\n if (s1 !== peg$FAILED) {\n if (input.charCodeAt(peg$currPos) === 91) {\n s2 = peg$c4;\n peg$currPos++;\n } else {\n s2 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e14); }\n }\n if (s2 !== peg$FAILED) {\n s1 = [s1, s2];\n s0 = s1;\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n\n return s0;\n }\n\n function peg$parseend_display_math() {\n var s0, s1, s2;\n\n s0 = peg$currPos;\n s1 = peg$parseescape();\n if (s1 !== peg$FAILED) {\n if (input.charCodeAt(peg$currPos) === 93) {\n s2 = peg$c5;\n peg$currPos++;\n } else {\n s2 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e15); }\n }\n if (s2 !== peg$FAILED) {\n s1 = [s1, s2];\n s0 = s1;\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n\n return s0;\n }\n\n function peg$parsebegin_inline_math() {\n var s0, s1, s2;\n\n s0 = peg$currPos;\n s1 = peg$parseescape();\n if (s1 !== peg$FAILED) {\n if (input.charCodeAt(peg$currPos) === 40) {\n s2 = peg$c16;\n peg$currPos++;\n } else {\n s2 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e36); }\n }\n if (s2 !== peg$FAILED) {\n s1 = [s1, s2];\n s0 = s1;\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n\n return s0;\n }\n\n function peg$parseend_inline_math() {\n var s0, s1, s2;\n\n s0 = peg$currPos;\n s1 = peg$parseescape();\n if (s1 !== peg$FAILED) {\n if (input.charCodeAt(peg$currPos) === 41) {\n s2 = peg$c17;\n peg$currPos++;\n } else {\n s2 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e37); }\n }\n if (s2 !== peg$FAILED) {\n s1 = [s1, s2];\n s0 = s1;\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n\n return s0;\n }\n\n function peg$parsebegin_env() {\n var s0, s1, s2;\n\n s0 = peg$currPos;\n s1 = peg$parseescape();\n if (s1 !== peg$FAILED) {\n if (input.substr(peg$currPos, 5) === peg$c18) {\n s2 = peg$c18;\n peg$currPos += 5;\n } else {\n s2 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e38); }\n }\n if (s2 !== peg$FAILED) {\n s1 = [s1, s2];\n s0 = s1;\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n\n return s0;\n }\n\n function peg$parseend_env() {\n var s0, s1, s2;\n\n s0 = peg$currPos;\n s1 = peg$parseescape();\n if (s1 !== peg$FAILED) {\n if (input.substr(peg$currPos, 3) === peg$c19) {\n s2 = peg$c19;\n peg$currPos += 3;\n } else {\n s2 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e39); }\n }\n if (s2 !== peg$FAILED) {\n s1 = [s1, s2];\n s0 = s1;\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n\n return s0;\n }\n\n function peg$parsemath_env_name() {\n var s0, s1;\n\n s0 = peg$currPos;\n if (input.substr(peg$currPos, 9) === peg$c20) {\n s1 = peg$c20;\n peg$currPos += 9;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e40); }\n }\n if (s1 === peg$FAILED) {\n if (input.substr(peg$currPos, 8) === peg$c21) {\n s1 = peg$c21;\n peg$currPos += 8;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e41); }\n }\n if (s1 === peg$FAILED) {\n if (input.substr(peg$currPos, 6) === peg$c22) {\n s1 = peg$c22;\n peg$currPos += 6;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e42); }\n }\n if (s1 === peg$FAILED) {\n if (input.substr(peg$currPos, 5) === peg$c23) {\n s1 = peg$c23;\n peg$currPos += 5;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e43); }\n }\n if (s1 === peg$FAILED) {\n if (input.substr(peg$currPos, 8) === peg$c24) {\n s1 = peg$c24;\n peg$currPos += 8;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e44); }\n }\n if (s1 === peg$FAILED) {\n if (input.substr(peg$currPos, 7) === peg$c25) {\n s1 = peg$c25;\n peg$currPos += 7;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e45); }\n }\n if (s1 === peg$FAILED) {\n if (input.substr(peg$currPos, 7) === peg$c26) {\n s1 = peg$c26;\n peg$currPos += 7;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e46); }\n }\n if (s1 === peg$FAILED) {\n if (input.substr(peg$currPos, 6) === peg$c27) {\n s1 = peg$c27;\n peg$currPos += 6;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e47); }\n }\n if (s1 === peg$FAILED) {\n if (input.substr(peg$currPos, 9) === peg$c28) {\n s1 = peg$c28;\n peg$currPos += 9;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e48); }\n }\n if (s1 === peg$FAILED) {\n if (input.substr(peg$currPos, 8) === peg$c29) {\n s1 = peg$c29;\n peg$currPos += 8;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e49); }\n }\n if (s1 === peg$FAILED) {\n if (input.substr(peg$currPos, 8) === peg$c30) {\n s1 = peg$c30;\n peg$currPos += 8;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e50); }\n }\n if (s1 === peg$FAILED) {\n if (input.substr(peg$currPos, 7) === peg$c31) {\n s1 = peg$c31;\n peg$currPos += 7;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e51); }\n }\n if (s1 === peg$FAILED) {\n if (input.substr(peg$currPos, 5) === peg$c32) {\n s1 = peg$c32;\n peg$currPos += 5;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e52); }\n }\n if (s1 === peg$FAILED) {\n if (input.substr(peg$currPos, 4) === peg$c33) {\n s1 = peg$c33;\n peg$currPos += 4;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e53); }\n }\n if (s1 === peg$FAILED) {\n if (input.substr(peg$currPos, 11) === peg$c34) {\n s1 = peg$c34;\n peg$currPos += 11;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e54); }\n }\n }\n }\n }\n }\n }\n }\n }\n }\n }\n }\n }\n }\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = s0;\n s1 = peg$f57(s1);\n }\n s0 = s1;\n\n return s0;\n }\n\n function peg$parseescape() {\n var s0, s1;\n\n peg$silentFails++;\n s0 = peg$currPos;\n if (input.charCodeAt(peg$currPos) === 92) {\n s1 = peg$c35;\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e56); }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = s0;\n s1 = peg$f58();\n }\n s0 = s1;\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e55); }\n }\n\n return s0;\n }\n\n function peg$parsebegin_group() {\n var s0, s1;\n\n s0 = peg$currPos;\n if (input.charCodeAt(peg$currPos) === 123) {\n s1 = peg$c36;\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e57); }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = s0;\n s1 = peg$f59(s1);\n }\n s0 = s1;\n\n return s0;\n }\n\n function peg$parseend_group() {\n var s0, s1;\n\n s0 = peg$currPos;\n if (input.charCodeAt(peg$currPos) === 125) {\n s1 = peg$c37;\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e58); }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = s0;\n s1 = peg$f60(s1);\n }\n s0 = s1;\n\n return s0;\n }\n\n function peg$parsemath_shift() {\n var s0, s1;\n\n s0 = peg$currPos;\n if (input.charCodeAt(peg$currPos) === 36) {\n s1 = peg$c38;\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e59); }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = s0;\n s1 = peg$f61(s1);\n }\n s0 = s1;\n\n return s0;\n }\n\n function peg$parsealignment_tab() {\n var s0, s1;\n\n s0 = peg$currPos;\n if (input.charCodeAt(peg$currPos) === 38) {\n s1 = peg$c39;\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e60); }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = s0;\n s1 = peg$f62(s1);\n }\n s0 = s1;\n\n return s0;\n }\n\n function peg$parsenl() {\n var s0, s1, s2;\n\n peg$silentFails++;\n s0 = peg$currPos;\n s1 = peg$currPos;\n peg$silentFails++;\n if (input.charCodeAt(peg$currPos) === 13) {\n s2 = peg$c40;\n peg$currPos++;\n } else {\n s2 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e62); }\n }\n peg$silentFails--;\n if (s2 === peg$FAILED) {\n s1 = undefined;\n } else {\n peg$currPos = s1;\n s1 = peg$FAILED;\n }\n if (s1 !== peg$FAILED) {\n if (input.charCodeAt(peg$currPos) === 10) {\n s2 = peg$c41;\n peg$currPos++;\n } else {\n s2 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e63); }\n }\n if (s2 !== peg$FAILED) {\n s1 = [s1, s2];\n s0 = s1;\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n if (s0 === peg$FAILED) {\n if (input.charCodeAt(peg$currPos) === 13) {\n s0 = peg$c40;\n peg$currPos++;\n } else {\n s0 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e62); }\n }\n if (s0 === peg$FAILED) {\n if (input.substr(peg$currPos, 2) === peg$c42) {\n s0 = peg$c42;\n peg$currPos += 2;\n } else {\n s0 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e64); }\n }\n }\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e61); }\n }\n\n return s0;\n }\n\n function peg$parsemacro_parameter() {\n var s0, s1;\n\n s0 = peg$currPos;\n if (input.charCodeAt(peg$currPos) === 35) {\n s1 = peg$c43;\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e65); }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = s0;\n s1 = peg$f63(s1);\n }\n s0 = s1;\n\n return s0;\n }\n\n function peg$parsesuperscript() {\n var s0, s1;\n\n s0 = peg$currPos;\n if (input.charCodeAt(peg$currPos) === 94) {\n s1 = peg$c44;\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e66); }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = s0;\n s1 = peg$f64(s1);\n }\n s0 = s1;\n\n return s0;\n }\n\n function peg$parsesubscript() {\n var s0, s1;\n\n s0 = peg$currPos;\n if (input.charCodeAt(peg$currPos) === 95) {\n s1 = peg$c45;\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e67); }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = s0;\n s1 = peg$f65(s1);\n }\n s0 = s1;\n\n return s0;\n }\n\n function peg$parseignore() {\n var s0;\n\n if (input.charCodeAt(peg$currPos) === 0) {\n s0 = peg$c46;\n peg$currPos++;\n } else {\n s0 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e68); }\n }\n\n return s0;\n }\n\n function peg$parsesp() {\n var s0, s1, s2;\n\n peg$silentFails++;\n s0 = peg$currPos;\n s1 = [];\n if (peg$r1.test(input.charAt(peg$currPos))) {\n s2 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s2 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e69); }\n }\n if (s2 !== peg$FAILED) {\n while (s2 !== peg$FAILED) {\n s1.push(s2);\n if (peg$r1.test(input.charAt(peg$currPos))) {\n s2 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s2 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e69); }\n }\n }\n } else {\n s1 = peg$FAILED;\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = s0;\n s1 = peg$f66();\n }\n s0 = s1;\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e8); }\n }\n\n return s0;\n }\n\n function peg$parsechar() {\n var s0, s1;\n\n peg$silentFails++;\n if (peg$r2.test(input.charAt(peg$currPos))) {\n s0 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s0 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e71); }\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e70); }\n }\n\n return s0;\n }\n\n function peg$parsenum() {\n var s0, s1;\n\n peg$silentFails++;\n if (peg$r3.test(input.charAt(peg$currPos))) {\n s0 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s0 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e73); }\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e72); }\n }\n\n return s0;\n }\n\n function peg$parsepunctuation() {\n var s0, s1;\n\n peg$silentFails++;\n s0 = peg$currPos;\n if (peg$r4.test(input.charAt(peg$currPos))) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e75); }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = s0;\n s1 = peg$f67(s1);\n }\n s0 = s1;\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e74); }\n }\n\n return s0;\n }\n\n function peg$parsecomment_start() {\n var s0;\n\n if (input.charCodeAt(peg$currPos) === 37) {\n s0 = peg$c0;\n peg$currPos++;\n } else {\n s0 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e7); }\n }\n\n return s0;\n }\n\n function peg$parsefull_comment() {\n var s0, s1;\n\n peg$silentFails++;\n s0 = peg$parseownline_comment();\n if (s0 === peg$FAILED) {\n s0 = peg$parsesameline_comment();\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e76); }\n }\n\n return s0;\n }\n\n function peg$parseownline_comment() {\n var s0, s1, s2, s3;\n\n s0 = peg$currPos;\n s1 = peg$currPos;\n s2 = [];\n s3 = peg$parsesp();\n while (s3 !== peg$FAILED) {\n s2.push(s3);\n s3 = peg$parsesp();\n }\n s3 = peg$parsenl();\n if (s3 !== peg$FAILED) {\n s2 = [s2, s3];\n s1 = s2;\n } else {\n peg$currPos = s1;\n s1 = peg$FAILED;\n }\n if (s1 === peg$FAILED) {\n s1 = null;\n }\n s2 = peg$parseleading_sp();\n if (s2 !== peg$FAILED) {\n s3 = peg$parsecomment();\n if (s3 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f68(s2, s3);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n\n return s0;\n }\n\n function peg$parsesameline_comment() {\n var s0, s1, s2;\n\n s0 = peg$currPos;\n s1 = [];\n s2 = peg$parsesp();\n while (s2 !== peg$FAILED) {\n s1.push(s2);\n s2 = peg$parsesp();\n }\n s2 = peg$parsecomment();\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f69(s1, s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n\n return s0;\n }\n\n function peg$parsecomment() {\n var s0, s1, s2, s3, s4, s5, s6, s7;\n\n peg$silentFails++;\n s0 = peg$currPos;\n s1 = peg$parsecomment_start();\n if (s1 !== peg$FAILED) {\n s2 = [];\n s3 = peg$currPos;\n s4 = peg$currPos;\n peg$silentFails++;\n s5 = peg$parsenl();\n peg$silentFails--;\n if (s5 === peg$FAILED) {\n s4 = undefined;\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n if (s4 !== peg$FAILED) {\n if (input.length > peg$currPos) {\n s5 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s5 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e3); }\n }\n if (s5 !== peg$FAILED) {\n peg$savedPos = s3;\n s3 = peg$f70(s5);\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n while (s3 !== peg$FAILED) {\n s2.push(s3);\n s3 = peg$currPos;\n s4 = peg$currPos;\n peg$silentFails++;\n s5 = peg$parsenl();\n peg$silentFails--;\n if (s5 === peg$FAILED) {\n s4 = undefined;\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n if (s4 !== peg$FAILED) {\n if (input.length > peg$currPos) {\n s5 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s5 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e3); }\n }\n if (s5 !== peg$FAILED) {\n peg$savedPos = s3;\n s3 = peg$f70(s5);\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n }\n s3 = peg$currPos;\n peg$silentFails++;\n s4 = peg$parseparbreak();\n peg$silentFails--;\n if (s4 !== peg$FAILED) {\n peg$currPos = s3;\n s3 = undefined;\n } else {\n s3 = peg$FAILED;\n }\n if (s3 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f71(s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n if (s0 === peg$FAILED) {\n s0 = peg$currPos;\n s1 = peg$parsecomment_start();\n if (s1 !== peg$FAILED) {\n s2 = [];\n s3 = peg$currPos;\n s4 = peg$currPos;\n peg$silentFails++;\n s5 = peg$parsenl();\n peg$silentFails--;\n if (s5 === peg$FAILED) {\n s4 = undefined;\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n if (s4 !== peg$FAILED) {\n if (input.length > peg$currPos) {\n s5 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s5 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e3); }\n }\n if (s5 !== peg$FAILED) {\n peg$savedPos = s3;\n s3 = peg$f72(s5);\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n while (s3 !== peg$FAILED) {\n s2.push(s3);\n s3 = peg$currPos;\n s4 = peg$currPos;\n peg$silentFails++;\n s5 = peg$parsenl();\n peg$silentFails--;\n if (s5 === peg$FAILED) {\n s4 = undefined;\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n if (s4 !== peg$FAILED) {\n if (input.length > peg$currPos) {\n s5 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s5 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e3); }\n }\n if (s5 !== peg$FAILED) {\n peg$savedPos = s3;\n s3 = peg$f72(s5);\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n }\n s3 = peg$currPos;\n s4 = peg$parsenl();\n if (s4 !== peg$FAILED) {\n s5 = [];\n s6 = peg$parsesp();\n while (s6 !== peg$FAILED) {\n s5.push(s6);\n s6 = peg$parsesp();\n }\n s6 = peg$currPos;\n peg$silentFails++;\n s7 = peg$parsecomment_start();\n peg$silentFails--;\n if (s7 === peg$FAILED) {\n s6 = undefined;\n } else {\n peg$currPos = s6;\n s6 = peg$FAILED;\n }\n if (s6 !== peg$FAILED) {\n s4 = [s4, s5, s6];\n s3 = s4;\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n if (s3 === peg$FAILED) {\n s3 = peg$parsenl();\n if (s3 === peg$FAILED) {\n s3 = peg$parseEOF();\n }\n }\n if (s3 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f73(s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e77); }\n }\n\n return s0;\n }\n\n function peg$parseleading_sp() {\n var s0, s1, s2, s3, s4;\n\n s0 = peg$currPos;\n s1 = peg$currPos;\n s2 = peg$parsestart_of_line();\n if (s2 !== peg$FAILED) {\n s3 = [];\n s4 = peg$parsesp();\n while (s4 !== peg$FAILED) {\n s3.push(s4);\n s4 = peg$parsesp();\n }\n s2 = [s2, s3];\n s1 = s2;\n } else {\n peg$currPos = s1;\n s1 = peg$FAILED;\n }\n if (s1 !== peg$FAILED) {\n s0 = input.substring(s0, peg$currPos);\n } else {\n s0 = s1;\n }\n\n return s0;\n }\n\n function peg$parsestart_of_line() {\n var s0;\n\n peg$savedPos = peg$currPos;\n s0 = peg$f74();\n if (s0) {\n s0 = undefined;\n } else {\n s0 = peg$FAILED;\n }\n\n return s0;\n }\n\n function peg$parseEOF() {\n var s0, s1;\n\n s0 = peg$currPos;\n peg$silentFails++;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e3); }\n }\n peg$silentFails--;\n if (s1 === peg$FAILED) {\n s0 = undefined;\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n\n return s0;\n }\n\n\n function toString(e) {\n if (typeof e === \"string\") {\n return e;\n }\n if (typeof e.content === \"string\") {\n return e.content;\n }\n if (e && e.type === \"whitespace\") {\n return \" \";\n }\n return e;\n }\n\n function compare_env(g1, g2) {\n const g1Name =\n typeof g1 === \"string\" ? g1 : g1.content.map(toString).join(\"\");\n const g2Name =\n typeof g2 === \"string\" ? g2 : g2.content.map(toString).join(\"\");\n return g1Name === g2Name;\n }\n\n function createNode(type, extra = {}) {\n return { type, ...extra, position: location() };\n }\n\n peg$result = peg$startRuleFunction();\n\n if (peg$result !== peg$FAILED && peg$currPos === input.length) {\n return peg$result;\n } else {\n if (peg$result !== peg$FAILED && peg$currPos < input.length) {\n peg$fail(peg$endExpectation());\n }\n\n throw peg$buildStructuredError(\n peg$maxFailExpected,\n peg$maxFailPos < input.length ? input.charAt(peg$maxFailPos) : null,\n peg$maxFailPos < input.length\n ? peg$computeLocation(peg$maxFailPos, peg$maxFailPos + 1)\n : peg$computeLocation(peg$maxFailPos, peg$maxFailPos)\n );\n }\n}\n\n return {\n SyntaxError: peg$SyntaxError,\n parse: peg$parse\n };\n})()\n", "export default // Generated by Peggy 2.0.1.\n//\n// https://peggyjs.org/\n(function() {\n \"use strict\";\n\nfunction peg$subclass(child, parent) {\n function C() { this.constructor = child; }\n C.prototype = parent.prototype;\n child.prototype = new C();\n}\n\nfunction peg$SyntaxError(message, expected, found, location) {\n var self = Error.call(this, message);\n // istanbul ignore next Check is a necessary evil to support older environments\n if (Object.setPrototypeOf) {\n Object.setPrototypeOf(self, peg$SyntaxError.prototype);\n }\n self.expected = expected;\n self.found = found;\n self.location = location;\n self.name = \"SyntaxError\";\n return self;\n}\n\npeg$subclass(peg$SyntaxError, Error);\n\nfunction peg$padEnd(str, targetLength, padString) {\n padString = padString || \" \";\n if (str.length > targetLength) { return str; }\n targetLength -= str.length;\n padString += padString.repeat(targetLength);\n return str + padString.slice(0, targetLength);\n}\n\npeg$SyntaxError.prototype.format = function(sources) {\n var str = \"Error: \" + this.message;\n if (this.location) {\n var src = null;\n var k;\n for (k = 0; k < sources.length; k++) {\n if (sources[k].source === this.location.source) {\n src = sources[k].text.split(/\\r\\n|\\n|\\r/g);\n break;\n }\n }\n var s = this.location.start;\n var loc = this.location.source + \":\" + s.line + \":\" + s.column;\n if (src) {\n var e = this.location.end;\n var filler = peg$padEnd(\"\", s.line.toString().length, ' ');\n var line = src[s.line - 1];\n var last = s.line === e.line ? e.column : line.length + 1;\n var hatLen = (last - s.column) || 1;\n str += \"\\n --> \" + loc + \"\\n\"\n + filler + \" |\\n\"\n + s.line + \" | \" + line + \"\\n\"\n + filler + \" | \" + peg$padEnd(\"\", s.column - 1, ' ')\n + peg$padEnd(\"\", hatLen, \"^\");\n } else {\n str += \"\\n at \" + loc;\n }\n }\n return str;\n};\n\npeg$SyntaxError.buildMessage = function(expected, found) {\n var DESCRIBE_EXPECTATION_FNS = {\n literal: function(expectation) {\n return \"\\\"\" + literalEscape(expectation.text) + \"\\\"\";\n },\n\n class: function(expectation) {\n var escapedParts = expectation.parts.map(function(part) {\n return Array.isArray(part)\n ? classEscape(part[0]) + \"-\" + classEscape(part[1])\n : classEscape(part);\n });\n\n return \"[\" + (expectation.inverted ? \"^\" : \"\") + escapedParts.join(\"\") + \"]\";\n },\n\n any: function() {\n return \"any character\";\n },\n\n end: function() {\n return \"end of input\";\n },\n\n other: function(expectation) {\n return expectation.description;\n }\n };\n\n function hex(ch) {\n return ch.charCodeAt(0).toString(16).toUpperCase();\n }\n\n function literalEscape(s) {\n return s\n .replace(/\\\\/g, \"\\\\\\\\\")\n .replace(/\"/g, \"\\\\\\\"\")\n .replace(/\\0/g, \"\\\\0\")\n .replace(/\\t/g, \"\\\\t\")\n .replace(/\\n/g, \"\\\\n\")\n .replace(/\\r/g, \"\\\\r\")\n .replace(/[\\x00-\\x0F]/g, function(ch) { return \"\\\\x0\" + hex(ch); })\n .replace(/[\\x10-\\x1F\\x7F-\\x9F]/g, function(ch) { return \"\\\\x\" + hex(ch); });\n }\n\n function classEscape(s) {\n return s\n .replace(/\\\\/g, \"\\\\\\\\\")\n .replace(/\\]/g, \"\\\\]\")\n .replace(/\\^/g, \"\\\\^\")\n .replace(/-/g, \"\\\\-\")\n .replace(/\\0/g, \"\\\\0\")\n .replace(/\\t/g, \"\\\\t\")\n .replace(/\\n/g, \"\\\\n\")\n .replace(/\\r/g, \"\\\\r\")\n .replace(/[\\x00-\\x0F]/g, function(ch) { return \"\\\\x0\" + hex(ch); })\n .replace(/[\\x10-\\x1F\\x7F-\\x9F]/g, function(ch) { return \"\\\\x\" + hex(ch); });\n }\n\n function describeExpectation(expectation) {\n return DESCRIBE_EXPECTATION_FNS[expectation.type](expectation);\n }\n\n function describeExpected(expected) {\n var descriptions = expected.map(describeExpectation);\n var i, j;\n\n descriptions.sort();\n\n if (descriptions.length > 0) {\n for (i = 1, j = 1; i < descriptions.length; i++) {\n if (descriptions[i - 1] !== descriptions[i]) {\n descriptions[j] = descriptions[i];\n j++;\n }\n }\n descriptions.length = j;\n }\n\n switch (descriptions.length) {\n case 1:\n return descriptions[0];\n\n case 2:\n return descriptions[0] + \" or \" + descriptions[1];\n\n default:\n return descriptions.slice(0, -1).join(\", \")\n + \", or \"\n + descriptions[descriptions.length - 1];\n }\n }\n\n function describeFound(found) {\n return found ? \"\\\"\" + literalEscape(found) + \"\\\"\" : \"end of input\";\n }\n\n return \"Expected \" + describeExpected(expected) + \" but \" + describeFound(found) + \" found.\";\n};\n\nfunction peg$parse(input, options) {\n options = options !== undefined ? options : {};\n\n var peg$FAILED = {};\n var peg$source = options.grammarSource;\n\n var peg$startRuleFunctions = { body: peg$parsebody };\n var peg$startRuleFunction = peg$parsebody;\n\n\n\n var peg$e0 = peg$anyExpectation();\n\n var peg$f0 = function() { return []; };\n var peg$f1 = function(x) { return { cells: [], colSeps: [], ...x }; };\n var peg$f2 = function(rowItems, rowSep, trailingComment) {\n return { ...rowItems, rowSep, trailingComment };\n };\n var peg$f3 = function(rowItems, trailingComment) {\n return { ...rowItems, rowSep: null, trailingComment };\n };\n var peg$f4 = function(x) { return x; };\n var peg$f5 = function(x) {\n return {\n cells: [],\n colSeps: [],\n rowSep: null,\n trailingComment: x,\n };\n };\n var peg$f6 = function(x) {\n return x;\n };\n var peg$f7 = function(colSep, cell) { return { colSep, cell }; };\n var peg$f8 = function(colSep) { return { colSep }; };\n var peg$f9 = function(a, b) { return processRow(a, b); };\n var peg$f10 = function(b) { return processRow(null, b); };\n var peg$f11 = function(tok) { return options.isSameLineComment(tok); };\n var peg$f12 = function(tok) { return tok; };\n var peg$f13 = function(tok) { return options.isOwnLineComment(tok); };\n var peg$f14 = function(tok) { return tok; };\n var peg$f15 = function(tok) { return options.isWhitespace(tok); };\n var peg$f16 = function(tok) { return tok; };\n var peg$f17 = function(tok) { return options.isRowSep(tok); };\n var peg$f18 = function(tok) { return tok; };\n var peg$f19 = function(tok) { return options.isColSep(tok); };\n var peg$f20 = function(tok) { return tok; };\n var peg$currPos = 0;\n var peg$savedPos = 0;\n var peg$posDetailsCache = [{ line: 1, column: 1 }];\n var peg$maxFailPos = 0;\n var peg$maxFailExpected = [];\n var peg$silentFails = 0;\n\n var peg$result;\n\n if (\"startRule\" in options) {\n if (!(options.startRule in peg$startRuleFunctions)) {\n throw new Error(\"Can't start parsing from rule \\\"\" + options.startRule + \"\\\".\");\n }\n\n peg$startRuleFunction = peg$startRuleFunctions[options.startRule];\n }\n\n function text() {\n return input.substring(peg$savedPos, peg$currPos);\n }\n\n function offset() {\n return peg$savedPos;\n }\n\n function range() {\n return {\n source: peg$source,\n start: peg$savedPos,\n end: peg$currPos\n };\n }\n\n function location() {\n return peg$computeLocation(peg$savedPos, peg$currPos);\n }\n\n function expected(description, location) {\n location = location !== undefined\n ? location\n : peg$computeLocation(peg$savedPos, peg$currPos);\n\n throw peg$buildStructuredError(\n [peg$otherExpectation(description)],\n input.substring(peg$savedPos, peg$currPos),\n location\n );\n }\n\n function error(message, location) {\n location = location !== undefined\n ? location\n : peg$computeLocation(peg$savedPos, peg$currPos);\n\n throw peg$buildSimpleError(message, location);\n }\n\n function peg$literalExpectation(text, ignoreCase) {\n return { type: \"literal\", text: text, ignoreCase: ignoreCase };\n }\n\n function peg$classExpectation(parts, inverted, ignoreCase) {\n return { type: \"class\", parts: parts, inverted: inverted, ignoreCase: ignoreCase };\n }\n\n function peg$anyExpectation() {\n return { type: \"any\" };\n }\n\n function peg$endExpectation() {\n return { type: \"end\" };\n }\n\n function peg$otherExpectation(description) {\n return { type: \"other\", description: description };\n }\n\n function peg$computePosDetails(pos) {\n var details = peg$posDetailsCache[pos];\n var p;\n\n if (details) {\n return details;\n } else {\n p = pos - 1;\n while (!peg$posDetailsCache[p]) {\n p--;\n }\n\n details = peg$posDetailsCache[p];\n details = {\n line: details.line,\n column: details.column\n };\n\n while (p < pos) {\n if (input.charCodeAt(p) === 10) {\n details.line++;\n details.column = 1;\n } else {\n details.column++;\n }\n\n p++;\n }\n\n peg$posDetailsCache[pos] = details;\n\n return details;\n }\n }\n\n function peg$computeLocation(startPos, endPos) {\n var startPosDetails = peg$computePosDetails(startPos);\n var endPosDetails = peg$computePosDetails(endPos);\n\n return {\n source: peg$source,\n start: {\n offset: startPos,\n line: startPosDetails.line,\n column: startPosDetails.column\n },\n end: {\n offset: endPos,\n line: endPosDetails.line,\n column: endPosDetails.column\n }\n };\n }\n\n function peg$fail(expected) {\n if (peg$currPos < peg$maxFailPos) { return; }\n\n if (peg$currPos > peg$maxFailPos) {\n peg$maxFailPos = peg$currPos;\n peg$maxFailExpected = [];\n }\n\n peg$maxFailExpected.push(expected);\n }\n\n function peg$buildSimpleError(message, location) {\n return new peg$SyntaxError(message, null, null, location);\n }\n\n function peg$buildStructuredError(expected, found, location) {\n return new peg$SyntaxError(\n peg$SyntaxError.buildMessage(expected, found),\n expected,\n found,\n location\n );\n }\n\n function peg$parsebody() {\n var s0, s1;\n\n s0 = [];\n s1 = peg$parsecomment_only_line();\n if (s1 === peg$FAILED) {\n s1 = peg$parserow_with_end();\n if (s1 === peg$FAILED) {\n s1 = peg$parserow_without_end();\n }\n }\n if (s1 !== peg$FAILED) {\n while (s1 !== peg$FAILED) {\n s0.push(s1);\n s1 = peg$parsecomment_only_line();\n if (s1 === peg$FAILED) {\n s1 = peg$parserow_with_end();\n if (s1 === peg$FAILED) {\n s1 = peg$parserow_without_end();\n }\n }\n }\n } else {\n s0 = peg$FAILED;\n }\n if (s0 === peg$FAILED) {\n s0 = peg$currPos;\n s1 = peg$parseEOL();\n if (s1 !== peg$FAILED) {\n peg$savedPos = s0;\n s1 = peg$f0();\n }\n s0 = s1;\n }\n\n return s0;\n }\n\n function peg$parserow_with_end() {\n var s0, s1, s2, s3;\n\n s0 = peg$currPos;\n s1 = peg$currPos;\n s2 = peg$parserow_items();\n if (s2 === peg$FAILED) {\n s2 = null;\n }\n peg$savedPos = s1;\n s2 = peg$f1(s2);\n s1 = s2;\n s2 = peg$parserow_sep();\n if (s2 !== peg$FAILED) {\n s3 = peg$parsetrailing_comment();\n if (s3 === peg$FAILED) {\n s3 = null;\n }\n peg$savedPos = s0;\n s0 = peg$f2(s1, s2, s3);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n\n return s0;\n }\n\n function peg$parserow_without_end() {\n var s0, s1, s2;\n\n s0 = peg$currPos;\n s1 = peg$parserow_items();\n if (s1 !== peg$FAILED) {\n s2 = peg$parsetrailing_comment();\n if (s2 === peg$FAILED) {\n s2 = null;\n }\n peg$savedPos = s0;\n s0 = peg$f3(s1, s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n\n return s0;\n }\n\n function peg$parsetrailing_comment() {\n var s0, s1, s2;\n\n s0 = peg$currPos;\n s1 = [];\n s2 = peg$parsewhitespace();\n while (s2 !== peg$FAILED) {\n s1.push(s2);\n s2 = peg$parsewhitespace();\n }\n s2 = peg$parsesame_line_comment();\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f4(s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n\n return s0;\n }\n\n function peg$parsecomment_only_line() {\n var s0, s1, s2;\n\n s0 = peg$currPos;\n s1 = [];\n s2 = peg$parsewhitespace();\n while (s2 !== peg$FAILED) {\n s1.push(s2);\n s2 = peg$parsewhitespace();\n }\n s2 = peg$parseown_line_comment();\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f5(s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n\n return s0;\n }\n\n function peg$parsetoken() {\n var s0, s1, s2;\n\n s0 = peg$currPos;\n s1 = peg$currPos;\n peg$silentFails++;\n s2 = peg$parserow_sep();\n if (s2 === peg$FAILED) {\n s2 = peg$parsecol_sep();\n if (s2 === peg$FAILED) {\n s2 = peg$parsetrailing_comment();\n if (s2 === peg$FAILED) {\n s2 = peg$parseown_line_comment();\n }\n }\n }\n peg$silentFails--;\n if (s2 === peg$FAILED) {\n s1 = undefined;\n } else {\n peg$currPos = s1;\n s1 = peg$FAILED;\n }\n if (s1 !== peg$FAILED) {\n if (input.length > peg$currPos) {\n s2 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s2 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e0); }\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f6(s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n\n return s0;\n }\n\n function peg$parsecell() {\n var s0, s1, s2;\n\n s0 = peg$currPos;\n s1 = [];\n s2 = peg$parsetoken();\n if (s2 !== peg$FAILED) {\n while (s2 !== peg$FAILED) {\n s1.push(s2);\n s2 = peg$parsetoken();\n }\n } else {\n s1 = peg$FAILED;\n }\n if (s1 !== peg$FAILED) {\n s0 = input.substring(s0, peg$currPos);\n } else {\n s0 = s1;\n }\n\n return s0;\n }\n\n function peg$parseseparated_cell() {\n var s0, s1, s2;\n\n s0 = peg$currPos;\n s1 = peg$parsecol_sep();\n if (s1 !== peg$FAILED) {\n s2 = peg$parsecell();\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f7(s1, s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n if (s0 === peg$FAILED) {\n s0 = peg$currPos;\n s1 = peg$parsecol_sep();\n if (s1 !== peg$FAILED) {\n peg$savedPos = s0;\n s1 = peg$f8(s1);\n }\n s0 = s1;\n }\n\n return s0;\n }\n\n function peg$parserow_items() {\n var s0, s1, s2, s3;\n\n s0 = peg$currPos;\n s1 = peg$parsecell();\n if (s1 !== peg$FAILED) {\n s2 = [];\n s3 = peg$parseseparated_cell();\n while (s3 !== peg$FAILED) {\n s2.push(s3);\n s3 = peg$parseseparated_cell();\n }\n peg$savedPos = s0;\n s0 = peg$f9(s1, s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n if (s0 === peg$FAILED) {\n s0 = peg$currPos;\n s1 = [];\n s2 = peg$parseseparated_cell();\n if (s2 !== peg$FAILED) {\n while (s2 !== peg$FAILED) {\n s1.push(s2);\n s2 = peg$parseseparated_cell();\n }\n } else {\n s1 = peg$FAILED;\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = s0;\n s1 = peg$f10(s1);\n }\n s0 = s1;\n }\n\n return s0;\n }\n\n function peg$parsesame_line_comment() {\n var s0, s1, s2;\n\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e0); }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f11(s1);\n if (s2) {\n s2 = undefined;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f12(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n\n return s0;\n }\n\n function peg$parseown_line_comment() {\n var s0, s1, s2;\n\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e0); }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f13(s1);\n if (s2) {\n s2 = undefined;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f14(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n\n return s0;\n }\n\n function peg$parsewhitespace() {\n var s0, s1, s2;\n\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e0); }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f15(s1);\n if (s2) {\n s2 = undefined;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f16(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n\n return s0;\n }\n\n function peg$parserow_sep() {\n var s0, s1, s2;\n\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e0); }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f17(s1);\n if (s2) {\n s2 = undefined;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f18(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n\n return s0;\n }\n\n function peg$parsecol_sep() {\n var s0, s1, s2;\n\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e0); }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f19(s1);\n if (s2) {\n s2 = undefined;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f20(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n\n return s0;\n }\n\n function peg$parseEOL() {\n var s0, s1;\n\n s0 = peg$currPos;\n peg$silentFails++;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e0); }\n }\n peg$silentFails--;\n if (s1 === peg$FAILED) {\n s0 = undefined;\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n\n return s0;\n }\n\n\n function processRow(leadCell, otherCells) {\n const cells = [leadCell || []];\n const seps = [];\n for (const x of otherCells) {\n cells.push(x.cell || []);\n seps.push(x.colSep);\n }\n return { cells, colSeps: seps };\n }\n\n //\n // These are compatability functions used when running in the browser\n //\n // Check if the `options` object has the functions that we need.\n // If not, try to add them\n if (!options.isWhitespace) {\n try {\n Object.assign(\n options,\n createMatchers([\"\\\\\", \"hline\", \"cr\"], [\"&\"])\n );\n } catch (e) {\n console.warn(\"Error when initializing parser\", e);\n }\n }\n\n peg$result = peg$startRuleFunction();\n\n if (peg$result !== peg$FAILED && peg$currPos === input.length) {\n return peg$result;\n } else {\n if (peg$result !== peg$FAILED && peg$currPos < input.length) {\n peg$fail(peg$endExpectation());\n }\n\n throw peg$buildStructuredError(\n peg$maxFailExpected,\n peg$maxFailPos < input.length ? input.charAt(peg$maxFailPos) : null,\n peg$maxFailPos < input.length\n ? peg$computeLocation(peg$maxFailPos, peg$maxFailPos + 1)\n : peg$computeLocation(peg$maxFailPos, peg$maxFailPos)\n );\n }\n}\n\n return {\n SyntaxError: peg$SyntaxError,\n parse: peg$parse\n };\n})()\n", "export default // Generated by Peggy 2.0.1.\n//\n// https://peggyjs.org/\n(function() {\n \"use strict\";\n\nfunction peg$subclass(child, parent) {\n function C() { this.constructor = child; }\n C.prototype = parent.prototype;\n child.prototype = new C();\n}\n\nfunction peg$SyntaxError(message, expected, found, location) {\n var self = Error.call(this, message);\n // istanbul ignore next Check is a necessary evil to support older environments\n if (Object.setPrototypeOf) {\n Object.setPrototypeOf(self, peg$SyntaxError.prototype);\n }\n self.expected = expected;\n self.found = found;\n self.location = location;\n self.name = \"SyntaxError\";\n return self;\n}\n\npeg$subclass(peg$SyntaxError, Error);\n\nfunction peg$padEnd(str, targetLength, padString) {\n padString = padString || \" \";\n if (str.length > targetLength) { return str; }\n targetLength -= str.length;\n padString += padString.repeat(targetLength);\n return str + padString.slice(0, targetLength);\n}\n\npeg$SyntaxError.prototype.format = function(sources) {\n var str = \"Error: \" + this.message;\n if (this.location) {\n var src = null;\n var k;\n for (k = 0; k < sources.length; k++) {\n if (sources[k].source === this.location.source) {\n src = sources[k].text.split(/\\r\\n|\\n|\\r/g);\n break;\n }\n }\n var s = this.location.start;\n var loc = this.location.source + \":\" + s.line + \":\" + s.column;\n if (src) {\n var e = this.location.end;\n var filler = peg$padEnd(\"\", s.line.toString().length, ' ');\n var line = src[s.line - 1];\n var last = s.line === e.line ? e.column : line.length + 1;\n var hatLen = (last - s.column) || 1;\n str += \"\\n --> \" + loc + \"\\n\"\n + filler + \" |\\n\"\n + s.line + \" | \" + line + \"\\n\"\n + filler + \" | \" + peg$padEnd(\"\", s.column - 1, ' ')\n + peg$padEnd(\"\", hatLen, \"^\");\n } else {\n str += \"\\n at \" + loc;\n }\n }\n return str;\n};\n\npeg$SyntaxError.buildMessage = function(expected, found) {\n var DESCRIBE_EXPECTATION_FNS = {\n literal: function(expectation) {\n return \"\\\"\" + literalEscape(expectation.text) + \"\\\"\";\n },\n\n class: function(expectation) {\n var escapedParts = expectation.parts.map(function(part) {\n return Array.isArray(part)\n ? classEscape(part[0]) + \"-\" + classEscape(part[1])\n : classEscape(part);\n });\n\n return \"[\" + (expectation.inverted ? \"^\" : \"\") + escapedParts.join(\"\") + \"]\";\n },\n\n any: function() {\n return \"any character\";\n },\n\n end: function() {\n return \"end of input\";\n },\n\n other: function(expectation) {\n return expectation.description;\n }\n };\n\n function hex(ch) {\n return ch.charCodeAt(0).toString(16).toUpperCase();\n }\n\n function literalEscape(s) {\n return s\n .replace(/\\\\/g, \"\\\\\\\\\")\n .replace(/\"/g, \"\\\\\\\"\")\n .replace(/\\0/g, \"\\\\0\")\n .replace(/\\t/g, \"\\\\t\")\n .replace(/\\n/g, \"\\\\n\")\n .replace(/\\r/g, \"\\\\r\")\n .replace(/[\\x00-\\x0F]/g, function(ch) { return \"\\\\x0\" + hex(ch); })\n .replace(/[\\x10-\\x1F\\x7F-\\x9F]/g, function(ch) { return \"\\\\x\" + hex(ch); });\n }\n\n function classEscape(s) {\n return s\n .replace(/\\\\/g, \"\\\\\\\\\")\n .replace(/\\]/g, \"\\\\]\")\n .replace(/\\^/g, \"\\\\^\")\n .replace(/-/g, \"\\\\-\")\n .replace(/\\0/g, \"\\\\0\")\n .replace(/\\t/g, \"\\\\t\")\n .replace(/\\n/g, \"\\\\n\")\n .replace(/\\r/g, \"\\\\r\")\n .replace(/[\\x00-\\x0F]/g, function(ch) { return \"\\\\x0\" + hex(ch); })\n .replace(/[\\x10-\\x1F\\x7F-\\x9F]/g, function(ch) { return \"\\\\x\" + hex(ch); });\n }\n\n function describeExpectation(expectation) {\n return DESCRIBE_EXPECTATION_FNS[expectation.type](expectation);\n }\n\n function describeExpected(expected) {\n var descriptions = expected.map(describeExpectation);\n var i, j;\n\n descriptions.sort();\n\n if (descriptions.length > 0) {\n for (i = 1, j = 1; i < descriptions.length; i++) {\n if (descriptions[i - 1] !== descriptions[i]) {\n descriptions[j] = descriptions[i];\n j++;\n }\n }\n descriptions.length = j;\n }\n\n switch (descriptions.length) {\n case 1:\n return descriptions[0];\n\n case 2:\n return descriptions[0] + \" or \" + descriptions[1];\n\n default:\n return descriptions.slice(0, -1).join(\", \")\n + \", or \"\n + descriptions[descriptions.length - 1];\n }\n }\n\n function describeFound(found) {\n return found ? \"\\\"\" + literalEscape(found) + \"\\\"\" : \"end of input\";\n }\n\n return \"Expected \" + describeExpected(expected) + \" but \" + describeFound(found) + \" found.\";\n};\n\nfunction peg$parse(input, options) {\n options = options !== undefined ? options : {};\n\n var peg$FAILED = {};\n var peg$source = options.grammarSource;\n\n var peg$startRuleFunctions = { args_spec_list: peg$parseargs_spec_list };\n var peg$startRuleFunction = peg$parseargs_spec_list;\n\n var peg$c0 = \"+\";\n var peg$c1 = \"v\";\n var peg$c2 = \"b\";\n var peg$c3 = \"!\";\n var peg$c4 = \"D\";\n var peg$c5 = \"d\";\n var peg$c6 = \"s\";\n var peg$c7 = \"O\";\n var peg$c8 = \"o\";\n var peg$c9 = \"e\";\n var peg$c10 = \"E\";\n var peg$c11 = \"t\";\n var peg$c12 = \"R\";\n var peg$c13 = \"r\";\n var peg$c14 = \"u\";\n var peg$c15 = \"m\";\n var peg$c16 = \"{\";\n var peg$c17 = \"}\";\n var peg$c18 = \" \";\n var peg$c19 = \"\\n\";\n var peg$c20 = \"\\r\";\n\n var peg$r0 = /^[{ ]/;\n\n var peg$e0 = peg$literalExpectation(\"+\", false);\n var peg$e1 = peg$literalExpectation(\"v\", false);\n var peg$e2 = peg$anyExpectation();\n var peg$e3 = peg$literalExpectation(\"b\", false);\n var peg$e4 = peg$literalExpectation(\"!\", false);\n var peg$e5 = peg$literalExpectation(\"D\", false);\n var peg$e6 = peg$literalExpectation(\"d\", false);\n var peg$e7 = peg$literalExpectation(\"s\", false);\n var peg$e8 = peg$literalExpectation(\"O\", false);\n var peg$e9 = peg$literalExpectation(\"o\", false);\n var peg$e10 = peg$literalExpectation(\"e\", false);\n var peg$e11 = peg$literalExpectation(\"E\", false);\n var peg$e12 = peg$literalExpectation(\"t\", false);\n var peg$e13 = peg$literalExpectation(\"R\", false);\n var peg$e14 = peg$literalExpectation(\"r\", false);\n var peg$e15 = peg$literalExpectation(\"u\", false);\n var peg$e16 = peg$classExpectation([\"{\", \" \"], false, false);\n var peg$e17 = peg$literalExpectation(\"m\", false);\n var peg$e18 = peg$literalExpectation(\"{\", false);\n var peg$e19 = peg$literalExpectation(\"}\", false);\n var peg$e20 = peg$literalExpectation(\" \", false);\n var peg$e21 = peg$literalExpectation(\"\\n\", false);\n var peg$e22 = peg$literalExpectation(\"\\r\", false);\n\n var peg$f0 = function(x) { return x; };\n var peg$f1 = function(spec) { return spec; };\n var peg$f2 = function(spec) {\n return spec;\n };\n var peg$f3 = function(openBrace) {\n return createNode(\"verbatim\", { openBrace, closeBrace: openBrace });\n };\n var peg$f4 = function() { return createNode(\"body\"); };\n var peg$f5 = function(leading_bang, spec) {\n return leading_bang ? { ...spec, noLeadingWhitespace: true } : spec;\n };\n var peg$f6 = function(braceSpec, defaultArg) {\n return createNode(\"optional\", { ...braceSpec, defaultArg });\n };\n var peg$f7 = function(braceSpec) { return createNode(\"optional\", braceSpec); };\n var peg$f8 = function() { return createNode(\"optionalStar\"); };\n var peg$f9 = function(g) { return createNode(\"optional\", { defaultArg: g }); };\n var peg$f10 = function() { return createNode(\"optional\"); };\n var peg$f11 = function(args) {\n return createNode(\"embellishment\", {\n embellishmentTokens: args.content,\n });\n };\n var peg$f12 = function(args, g) {\n return createNode(\"embellishment\", {\n embellishmentTokens: args.content,\n defaultArg: g,\n });\n };\n var peg$f13 = function(tok) { return createNode(\"optionalToken\", { token: tok }); };\n var peg$f14 = function(braceSpec, defaultArg) {\n return createNode(\"mandatory\", { ...braceSpec, defaultArg });\n };\n var peg$f15 = function(braceSpec) { return createNode(\"mandatory\", braceSpec); };\n var peg$f16 = function(stopTokens) {\n return createNode(\"until\", { stopTokens });\n };\n var peg$f17 = function(x) { return [x]; };\n var peg$f18 = function(g) { return g.content; };\n var peg$f19 = function() { return createNode(\"mandatory\"); };\n var peg$f20 = function(openBrace, closeBrace) {\n return { openBrace, closeBrace };\n };\n var peg$f21 = function(content) {\n return { type: \"group\", content: content };\n };\n var peg$f22 = function() { return \"\"; };\n var peg$currPos = 0;\n var peg$savedPos = 0;\n var peg$posDetailsCache = [{ line: 1, column: 1 }];\n var peg$maxFailPos = 0;\n var peg$maxFailExpected = [];\n var peg$silentFails = 0;\n\n var peg$result;\n\n if (\"startRule\" in options) {\n if (!(options.startRule in peg$startRuleFunctions)) {\n throw new Error(\"Can't start parsing from rule \\\"\" + options.startRule + \"\\\".\");\n }\n\n peg$startRuleFunction = peg$startRuleFunctions[options.startRule];\n }\n\n function text() {\n return input.substring(peg$savedPos, peg$currPos);\n }\n\n function offset() {\n return peg$savedPos;\n }\n\n function range() {\n return {\n source: peg$source,\n start: peg$savedPos,\n end: peg$currPos\n };\n }\n\n function location() {\n return peg$computeLocation(peg$savedPos, peg$currPos);\n }\n\n function expected(description, location) {\n location = location !== undefined\n ? location\n : peg$computeLocation(peg$savedPos, peg$currPos);\n\n throw peg$buildStructuredError(\n [peg$otherExpectation(description)],\n input.substring(peg$savedPos, peg$currPos),\n location\n );\n }\n\n function error(message, location) {\n location = location !== undefined\n ? location\n : peg$computeLocation(peg$savedPos, peg$currPos);\n\n throw peg$buildSimpleError(message, location);\n }\n\n function peg$literalExpectation(text, ignoreCase) {\n return { type: \"literal\", text: text, ignoreCase: ignoreCase };\n }\n\n function peg$classExpectation(parts, inverted, ignoreCase) {\n return { type: \"class\", parts: parts, inverted: inverted, ignoreCase: ignoreCase };\n }\n\n function peg$anyExpectation() {\n return { type: \"any\" };\n }\n\n function peg$endExpectation() {\n return { type: \"end\" };\n }\n\n function peg$otherExpectation(description) {\n return { type: \"other\", description: description };\n }\n\n function peg$computePosDetails(pos) {\n var details = peg$posDetailsCache[pos];\n var p;\n\n if (details) {\n return details;\n } else {\n p = pos - 1;\n while (!peg$posDetailsCache[p]) {\n p--;\n }\n\n details = peg$posDetailsCache[p];\n details = {\n line: details.line,\n column: details.column\n };\n\n while (p < pos) {\n if (input.charCodeAt(p) === 10) {\n details.line++;\n details.column = 1;\n } else {\n details.column++;\n }\n\n p++;\n }\n\n peg$posDetailsCache[pos] = details;\n\n return details;\n }\n }\n\n function peg$computeLocation(startPos, endPos) {\n var startPosDetails = peg$computePosDetails(startPos);\n var endPosDetails = peg$computePosDetails(endPos);\n\n return {\n source: peg$source,\n start: {\n offset: startPos,\n line: startPosDetails.line,\n column: startPosDetails.column\n },\n end: {\n offset: endPos,\n line: endPosDetails.line,\n column: endPosDetails.column\n }\n };\n }\n\n function peg$fail(expected) {\n if (peg$currPos < peg$maxFailPos) { return; }\n\n if (peg$currPos > peg$maxFailPos) {\n peg$maxFailPos = peg$currPos;\n peg$maxFailExpected = [];\n }\n\n peg$maxFailExpected.push(expected);\n }\n\n function peg$buildSimpleError(message, location) {\n return new peg$SyntaxError(message, null, null, location);\n }\n\n function peg$buildStructuredError(expected, found, location) {\n return new peg$SyntaxError(\n peg$SyntaxError.buildMessage(expected, found),\n expected,\n found,\n location\n );\n }\n\n function peg$parseargs_spec_list() {\n var s0, s1, s2, s3, s4;\n\n s0 = peg$currPos;\n s1 = [];\n s2 = peg$currPos;\n s3 = peg$parsewhitespace();\n s4 = peg$parsearg_spec();\n if (s4 !== peg$FAILED) {\n peg$savedPos = s2;\n s2 = peg$f0(s4);\n } else {\n peg$currPos = s2;\n s2 = peg$FAILED;\n }\n while (s2 !== peg$FAILED) {\n s1.push(s2);\n s2 = peg$currPos;\n s3 = peg$parsewhitespace();\n s4 = peg$parsearg_spec();\n if (s4 !== peg$FAILED) {\n peg$savedPos = s2;\n s2 = peg$f0(s4);\n } else {\n peg$currPos = s2;\n s2 = peg$FAILED;\n }\n }\n s2 = peg$parsewhitespace();\n peg$savedPos = s0;\n s0 = peg$f1(s1);\n\n return s0;\n }\n\n function peg$parsearg_spec() {\n var s0, s1, s2;\n\n s0 = peg$currPos;\n if (input.charCodeAt(peg$currPos) === 43) {\n s1 = peg$c0;\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e0); }\n }\n if (s1 === peg$FAILED) {\n s1 = null;\n }\n s2 = peg$parseoptional();\n if (s2 === peg$FAILED) {\n s2 = peg$parsemandatory();\n if (s2 === peg$FAILED) {\n s2 = peg$parseverbatim();\n if (s2 === peg$FAILED) {\n s2 = peg$parserequired();\n if (s2 === peg$FAILED) {\n s2 = peg$parsebody();\n if (s2 === peg$FAILED) {\n s2 = peg$parseuntil();\n }\n }\n }\n }\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f2(s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n\n return s0;\n }\n\n function peg$parseverbatim() {\n var s0, s1, s2;\n\n s0 = peg$currPos;\n if (input.charCodeAt(peg$currPos) === 118) {\n s1 = peg$c1;\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e1); }\n }\n if (s1 !== peg$FAILED) {\n if (input.length > peg$currPos) {\n s2 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s2 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e2); }\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f3(s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n\n return s0;\n }\n\n function peg$parsebody() {\n var s0, s1;\n\n s0 = peg$currPos;\n if (input.charCodeAt(peg$currPos) === 98) {\n s1 = peg$c2;\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e3); }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = s0;\n s1 = peg$f4();\n }\n s0 = s1;\n\n return s0;\n }\n\n function peg$parseoptional() {\n var s0, s1, s2;\n\n s0 = peg$currPos;\n if (input.charCodeAt(peg$currPos) === 33) {\n s1 = peg$c3;\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e4); }\n }\n if (s1 === peg$FAILED) {\n s1 = null;\n }\n s2 = peg$parseoptional_star();\n if (s2 === peg$FAILED) {\n s2 = peg$parseoptional_standard();\n if (s2 === peg$FAILED) {\n s2 = peg$parseoptional_delimited();\n if (s2 === peg$FAILED) {\n s2 = peg$parseoptional_embellishment();\n if (s2 === peg$FAILED) {\n s2 = peg$parseoptional_token();\n }\n }\n }\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f5(s1, s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n\n return s0;\n }\n\n function peg$parseoptional_delimited() {\n var s0, s1, s2, s3;\n\n s0 = peg$currPos;\n if (input.charCodeAt(peg$currPos) === 68) {\n s1 = peg$c4;\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e5); }\n }\n if (s1 !== peg$FAILED) {\n s2 = peg$parsebrace_spec();\n s3 = peg$parsebraced_group();\n if (s3 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f6(s2, s3);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n if (s0 === peg$FAILED) {\n s0 = peg$currPos;\n if (input.charCodeAt(peg$currPos) === 100) {\n s1 = peg$c5;\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e6); }\n }\n if (s1 !== peg$FAILED) {\n s2 = peg$parsebrace_spec();\n peg$savedPos = s0;\n s0 = peg$f7(s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n }\n\n return s0;\n }\n\n function peg$parseoptional_star() {\n var s0, s1;\n\n s0 = peg$currPos;\n if (input.charCodeAt(peg$currPos) === 115) {\n s1 = peg$c6;\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e7); }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = s0;\n s1 = peg$f8();\n }\n s0 = s1;\n\n return s0;\n }\n\n function peg$parseoptional_standard() {\n var s0, s1, s2;\n\n s0 = peg$currPos;\n if (input.charCodeAt(peg$currPos) === 79) {\n s1 = peg$c7;\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e8); }\n }\n if (s1 !== peg$FAILED) {\n s2 = peg$parsebraced_group();\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f9(s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n if (s0 === peg$FAILED) {\n s0 = peg$currPos;\n if (input.charCodeAt(peg$currPos) === 111) {\n s1 = peg$c8;\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e9); }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = s0;\n s1 = peg$f10();\n }\n s0 = s1;\n }\n\n return s0;\n }\n\n function peg$parseoptional_embellishment() {\n var s0, s1, s2, s3;\n\n s0 = peg$currPos;\n if (input.charCodeAt(peg$currPos) === 101) {\n s1 = peg$c9;\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e10); }\n }\n if (s1 !== peg$FAILED) {\n s2 = peg$parsebraced_group();\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f11(s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n if (s0 === peg$FAILED) {\n s0 = peg$currPos;\n if (input.charCodeAt(peg$currPos) === 69) {\n s1 = peg$c10;\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e11); }\n }\n if (s1 !== peg$FAILED) {\n s2 = peg$parsebraced_group();\n if (s2 !== peg$FAILED) {\n s3 = peg$parsebraced_group();\n if (s3 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f12(s2, s3);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n }\n\n return s0;\n }\n\n function peg$parseoptional_token() {\n var s0, s1, s2;\n\n s0 = peg$currPos;\n if (input.charCodeAt(peg$currPos) === 116) {\n s1 = peg$c11;\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e12); }\n }\n if (s1 !== peg$FAILED) {\n if (input.length > peg$currPos) {\n s2 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s2 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e2); }\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f13(s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n\n return s0;\n }\n\n function peg$parserequired() {\n var s0, s1, s2, s3;\n\n s0 = peg$currPos;\n if (input.charCodeAt(peg$currPos) === 82) {\n s1 = peg$c12;\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e13); }\n }\n if (s1 !== peg$FAILED) {\n s2 = peg$parsebrace_spec();\n s3 = peg$parsebraced_group();\n if (s3 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f14(s2, s3);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n if (s0 === peg$FAILED) {\n s0 = peg$currPos;\n if (input.charCodeAt(peg$currPos) === 114) {\n s1 = peg$c13;\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e14); }\n }\n if (s1 !== peg$FAILED) {\n s2 = peg$parsebrace_spec();\n peg$savedPos = s0;\n s0 = peg$f15(s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n }\n\n return s0;\n }\n\n function peg$parseuntil() {\n var s0, s1, s2;\n\n s0 = peg$currPos;\n if (input.charCodeAt(peg$currPos) === 117) {\n s1 = peg$c14;\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e15); }\n }\n if (s1 !== peg$FAILED) {\n s2 = peg$parseuntil_stop_token();\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f16(s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n\n return s0;\n }\n\n function peg$parseuntil_stop_token() {\n var s0, s1, s2;\n\n s0 = peg$currPos;\n s1 = peg$currPos;\n peg$silentFails++;\n if (peg$r0.test(input.charAt(peg$currPos))) {\n s2 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s2 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e16); }\n }\n peg$silentFails--;\n if (s2 === peg$FAILED) {\n s1 = undefined;\n } else {\n peg$currPos = s1;\n s1 = peg$FAILED;\n }\n if (s1 !== peg$FAILED) {\n if (input.length > peg$currPos) {\n s2 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s2 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e2); }\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f17(s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n if (s0 === peg$FAILED) {\n s0 = peg$currPos;\n s1 = peg$parsebraced_group();\n if (s1 !== peg$FAILED) {\n peg$savedPos = s0;\n s1 = peg$f18(s1);\n }\n s0 = s1;\n }\n\n return s0;\n }\n\n function peg$parsemandatory() {\n var s0, s1;\n\n s0 = peg$currPos;\n if (input.charCodeAt(peg$currPos) === 109) {\n s1 = peg$c15;\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e17); }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = s0;\n s1 = peg$f19();\n }\n s0 = s1;\n\n return s0;\n }\n\n function peg$parsebrace_spec() {\n var s0, s1, s2, s3, s4, s5;\n\n s0 = peg$currPos;\n s1 = peg$currPos;\n s2 = peg$currPos;\n s3 = peg$currPos;\n peg$silentFails++;\n s4 = peg$parsewhitespace_token();\n peg$silentFails--;\n if (s4 === peg$FAILED) {\n s3 = undefined;\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n if (s3 !== peg$FAILED) {\n if (input.length > peg$currPos) {\n s4 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s4 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e2); }\n }\n if (s4 !== peg$FAILED) {\n s3 = [s3, s4];\n s2 = s3;\n } else {\n peg$currPos = s2;\n s2 = peg$FAILED;\n }\n } else {\n peg$currPos = s2;\n s2 = peg$FAILED;\n }\n if (s2 === peg$FAILED) {\n s2 = null;\n }\n s1 = input.substring(s1, peg$currPos);\n s2 = peg$currPos;\n s3 = peg$currPos;\n s4 = peg$currPos;\n peg$silentFails++;\n s5 = peg$parsewhitespace_token();\n peg$silentFails--;\n if (s5 === peg$FAILED) {\n s4 = undefined;\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n if (s4 !== peg$FAILED) {\n if (input.length > peg$currPos) {\n s5 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s5 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e2); }\n }\n if (s5 !== peg$FAILED) {\n s4 = [s4, s5];\n s3 = s4;\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n if (s3 === peg$FAILED) {\n s3 = null;\n }\n s2 = input.substring(s2, peg$currPos);\n peg$savedPos = s0;\n s0 = peg$f20(s1, s2);\n\n return s0;\n }\n\n function peg$parsebraced_group() {\n var s0, s1, s2, s3, s4, s5, s6, s7;\n\n s0 = peg$currPos;\n if (input.charCodeAt(peg$currPos) === 123) {\n s1 = peg$c16;\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e18); }\n }\n if (s1 !== peg$FAILED) {\n s2 = [];\n s3 = peg$currPos;\n s4 = peg$currPos;\n s5 = peg$currPos;\n peg$silentFails++;\n if (input.charCodeAt(peg$currPos) === 125) {\n s6 = peg$c17;\n peg$currPos++;\n } else {\n s6 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e19); }\n }\n peg$silentFails--;\n if (s6 === peg$FAILED) {\n s5 = undefined;\n } else {\n peg$currPos = s5;\n s5 = peg$FAILED;\n }\n if (s5 !== peg$FAILED) {\n s6 = peg$currPos;\n peg$silentFails++;\n s7 = peg$parsebraced_group();\n peg$silentFails--;\n if (s7 === peg$FAILED) {\n s6 = undefined;\n } else {\n peg$currPos = s6;\n s6 = peg$FAILED;\n }\n if (s6 !== peg$FAILED) {\n if (input.length > peg$currPos) {\n s7 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s7 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e2); }\n }\n if (s7 !== peg$FAILED) {\n s5 = [s5, s6, s7];\n s4 = s5;\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n if (s4 !== peg$FAILED) {\n s3 = input.substring(s3, peg$currPos);\n } else {\n s3 = s4;\n }\n if (s3 === peg$FAILED) {\n s3 = peg$parsebraced_group();\n }\n while (s3 !== peg$FAILED) {\n s2.push(s3);\n s3 = peg$currPos;\n s4 = peg$currPos;\n s5 = peg$currPos;\n peg$silentFails++;\n if (input.charCodeAt(peg$currPos) === 125) {\n s6 = peg$c17;\n peg$currPos++;\n } else {\n s6 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e19); }\n }\n peg$silentFails--;\n if (s6 === peg$FAILED) {\n s5 = undefined;\n } else {\n peg$currPos = s5;\n s5 = peg$FAILED;\n }\n if (s5 !== peg$FAILED) {\n s6 = peg$currPos;\n peg$silentFails++;\n s7 = peg$parsebraced_group();\n peg$silentFails--;\n if (s7 === peg$FAILED) {\n s6 = undefined;\n } else {\n peg$currPos = s6;\n s6 = peg$FAILED;\n }\n if (s6 !== peg$FAILED) {\n if (input.length > peg$currPos) {\n s7 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s7 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e2); }\n }\n if (s7 !== peg$FAILED) {\n s5 = [s5, s6, s7];\n s4 = s5;\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n if (s4 !== peg$FAILED) {\n s3 = input.substring(s3, peg$currPos);\n } else {\n s3 = s4;\n }\n if (s3 === peg$FAILED) {\n s3 = peg$parsebraced_group();\n }\n }\n if (input.charCodeAt(peg$currPos) === 125) {\n s3 = peg$c17;\n peg$currPos++;\n } else {\n s3 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e19); }\n }\n if (s3 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f21(s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n\n return s0;\n }\n\n function peg$parsewhitespace() {\n var s0, s1, s2;\n\n s0 = peg$currPos;\n s1 = [];\n s2 = peg$parsewhitespace_token();\n while (s2 !== peg$FAILED) {\n s1.push(s2);\n s2 = peg$parsewhitespace_token();\n }\n peg$savedPos = s0;\n s1 = peg$f22();\n s0 = s1;\n\n return s0;\n }\n\n function peg$parsewhitespace_token() {\n var s0;\n\n if (input.charCodeAt(peg$currPos) === 32) {\n s0 = peg$c18;\n peg$currPos++;\n } else {\n s0 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e20); }\n }\n if (s0 === peg$FAILED) {\n if (input.charCodeAt(peg$currPos) === 10) {\n s0 = peg$c19;\n peg$currPos++;\n } else {\n s0 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e21); }\n }\n if (s0 === peg$FAILED) {\n if (input.charCodeAt(peg$currPos) === 13) {\n s0 = peg$c20;\n peg$currPos++;\n } else {\n s0 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e22); }\n }\n }\n }\n\n return s0;\n }\n\n\n const DEFAULT_OPTIONS = {\n optional: { openBrace: \"[\", closeBrace: \"]\" },\n mandatory: { openBrace: \"{\", closeBrace: \"}\" },\n };\n function createNode(type, options) {\n const computedOptions = DEFAULT_OPTIONS[type] || {};\n return { type, ...computedOptions, ...options };\n }\n\n peg$result = peg$startRuleFunction();\n\n if (peg$result !== peg$FAILED && peg$currPos === input.length) {\n return peg$result;\n } else {\n if (peg$result !== peg$FAILED && peg$currPos < input.length) {\n peg$fail(peg$endExpectation());\n }\n\n throw peg$buildStructuredError(\n peg$maxFailExpected,\n peg$maxFailPos < input.length ? input.charAt(peg$maxFailPos) : null,\n peg$maxFailPos < input.length\n ? peg$computeLocation(peg$maxFailPos, peg$maxFailPos + 1)\n : peg$computeLocation(peg$maxFailPos, peg$maxFailPos)\n );\n }\n}\n\n return {\n SyntaxError: peg$SyntaxError,\n parse: peg$parse\n };\n})()\n", "export default // Generated by Peggy 2.0.1.\n//\n// https://peggyjs.org/\n(function() {\n \"use strict\";\n\nfunction peg$subclass(child, parent) {\n function C() { this.constructor = child; }\n C.prototype = parent.prototype;\n child.prototype = new C();\n}\n\nfunction peg$SyntaxError(message, expected, found, location) {\n var self = Error.call(this, message);\n // istanbul ignore next Check is a necessary evil to support older environments\n if (Object.setPrototypeOf) {\n Object.setPrototypeOf(self, peg$SyntaxError.prototype);\n }\n self.expected = expected;\n self.found = found;\n self.location = location;\n self.name = \"SyntaxError\";\n return self;\n}\n\npeg$subclass(peg$SyntaxError, Error);\n\nfunction peg$padEnd(str, targetLength, padString) {\n padString = padString || \" \";\n if (str.length > targetLength) { return str; }\n targetLength -= str.length;\n padString += padString.repeat(targetLength);\n return str + padString.slice(0, targetLength);\n}\n\npeg$SyntaxError.prototype.format = function(sources) {\n var str = \"Error: \" + this.message;\n if (this.location) {\n var src = null;\n var k;\n for (k = 0; k < sources.length; k++) {\n if (sources[k].source === this.location.source) {\n src = sources[k].text.split(/\\r\\n|\\n|\\r/g);\n break;\n }\n }\n var s = this.location.start;\n var loc = this.location.source + \":\" + s.line + \":\" + s.column;\n if (src) {\n var e = this.location.end;\n var filler = peg$padEnd(\"\", s.line.toString().length, ' ');\n var line = src[s.line - 1];\n var last = s.line === e.line ? e.column : line.length + 1;\n var hatLen = (last - s.column) || 1;\n str += \"\\n --> \" + loc + \"\\n\"\n + filler + \" |\\n\"\n + s.line + \" | \" + line + \"\\n\"\n + filler + \" | \" + peg$padEnd(\"\", s.column - 1, ' ')\n + peg$padEnd(\"\", hatLen, \"^\");\n } else {\n str += \"\\n at \" + loc;\n }\n }\n return str;\n};\n\npeg$SyntaxError.buildMessage = function(expected, found) {\n var DESCRIBE_EXPECTATION_FNS = {\n literal: function(expectation) {\n return \"\\\"\" + literalEscape(expectation.text) + \"\\\"\";\n },\n\n class: function(expectation) {\n var escapedParts = expectation.parts.map(function(part) {\n return Array.isArray(part)\n ? classEscape(part[0]) + \"-\" + classEscape(part[1])\n : classEscape(part);\n });\n\n return \"[\" + (expectation.inverted ? \"^\" : \"\") + escapedParts.join(\"\") + \"]\";\n },\n\n any: function() {\n return \"any character\";\n },\n\n end: function() {\n return \"end of input\";\n },\n\n other: function(expectation) {\n return expectation.description;\n }\n };\n\n function hex(ch) {\n return ch.charCodeAt(0).toString(16).toUpperCase();\n }\n\n function literalEscape(s) {\n return s\n .replace(/\\\\/g, \"\\\\\\\\\")\n .replace(/\"/g, \"\\\\\\\"\")\n .replace(/\\0/g, \"\\\\0\")\n .replace(/\\t/g, \"\\\\t\")\n .replace(/\\n/g, \"\\\\n\")\n .replace(/\\r/g, \"\\\\r\")\n .replace(/[\\x00-\\x0F]/g, function(ch) { return \"\\\\x0\" + hex(ch); })\n .replace(/[\\x10-\\x1F\\x7F-\\x9F]/g, function(ch) { return \"\\\\x\" + hex(ch); });\n }\n\n function classEscape(s) {\n return s\n .replace(/\\\\/g, \"\\\\\\\\\")\n .replace(/\\]/g, \"\\\\]\")\n .replace(/\\^/g, \"\\\\^\")\n .replace(/-/g, \"\\\\-\")\n .replace(/\\0/g, \"\\\\0\")\n .replace(/\\t/g, \"\\\\t\")\n .replace(/\\n/g, \"\\\\n\")\n .replace(/\\r/g, \"\\\\r\")\n .replace(/[\\x00-\\x0F]/g, function(ch) { return \"\\\\x0\" + hex(ch); })\n .replace(/[\\x10-\\x1F\\x7F-\\x9F]/g, function(ch) { return \"\\\\x\" + hex(ch); });\n }\n\n function describeExpectation(expectation) {\n return DESCRIBE_EXPECTATION_FNS[expectation.type](expectation);\n }\n\n function describeExpected(expected) {\n var descriptions = expected.map(describeExpectation);\n var i, j;\n\n descriptions.sort();\n\n if (descriptions.length > 0) {\n for (i = 1, j = 1; i < descriptions.length; i++) {\n if (descriptions[i - 1] !== descriptions[i]) {\n descriptions[j] = descriptions[i];\n j++;\n }\n }\n descriptions.length = j;\n }\n\n switch (descriptions.length) {\n case 1:\n return descriptions[0];\n\n case 2:\n return descriptions[0] + \" or \" + descriptions[1];\n\n default:\n return descriptions.slice(0, -1).join(\", \")\n + \", or \"\n + descriptions[descriptions.length - 1];\n }\n }\n\n function describeFound(found) {\n return found ? \"\\\"\" + literalEscape(found) + \"\\\"\" : \"end of input\";\n }\n\n return \"Expected \" + describeExpected(expected) + \" but \" + describeFound(found) + \" found.\";\n};\n\nfunction peg$parse(input, options) {\n options = options !== undefined ? options : {};\n\n var peg$FAILED = {};\n var peg$source = options.grammarSource;\n\n var peg$startRuleFunctions = { body: peg$parsebody };\n var peg$startRuleFunction = peg$parsebody;\n\n\n\n var peg$e0 = peg$anyExpectation();\n\n var peg$f0 = function() { return []; };\n var peg$f1 = function(rowItems, trailingComment) {\n return {\n itemParts: [],\n ...rowItems,\n trailingComment,\n trailingComma: true,\n };\n };\n var peg$f2 = function(rowItems, trailingComment) {\n return { ...rowItems, trailingComment };\n };\n var peg$f3 = function(a, b) { return processItem(a, b); };\n var peg$f4 = function(b) { return processItem(null, b); };\n var peg$f5 = function(cell) { return { cell }; };\n var peg$f6 = function() { return {}; };\n var peg$f7 = function(part) { return part; };\n var peg$f8 = function(x) { return x; };\n var peg$f9 = function(space, x) {\n return {\n trailingComment: x,\n leadingParbreak: space.parbreak > 0,\n };\n };\n var peg$f10 = function(list) {\n return {\n whitespace: list.filter((x) => options.isWhitespace(x)).length,\n parbreak: list.filter((x) => options.isParbreak(x)).length,\n };\n };\n var peg$f11 = function() { return !options.allowParenGroups; };\n var peg$f12 = function(tok) { return options.isSameLineComment(tok); };\n var peg$f13 = function(tok) { return tok; };\n var peg$f14 = function(tok) { return options.isOwnLineComment(tok); };\n var peg$f15 = function(tok) { return tok; };\n var peg$f16 = function(tok) { return options.isWhitespace(tok); };\n var peg$f17 = function(tok) { return tok; };\n var peg$f18 = function(tok) { return options.isParbreak(tok); };\n var peg$f19 = function(tok) { return tok; };\n var peg$f20 = function(tok) { return options.isComma(tok); };\n var peg$f21 = function(tok) { return tok; };\n var peg$f22 = function(tok) { return options.isEquals(tok); };\n var peg$f23 = function(tok) { return tok; };\n var peg$f24 = function(tok) { return options.isChar(tok, \"(\"); };\n var peg$f25 = function(tok) { return tok; };\n var peg$f26 = function(tok) { return options.isChar(tok, \")\"); };\n var peg$f27 = function(tok) { return tok; };\n var peg$currPos = 0;\n var peg$savedPos = 0;\n var peg$posDetailsCache = [{ line: 1, column: 1 }];\n var peg$maxFailPos = 0;\n var peg$maxFailExpected = [];\n var peg$silentFails = 0;\n\n var peg$result;\n\n if (\"startRule\" in options) {\n if (!(options.startRule in peg$startRuleFunctions)) {\n throw new Error(\"Can't start parsing from rule \\\"\" + options.startRule + \"\\\".\");\n }\n\n peg$startRuleFunction = peg$startRuleFunctions[options.startRule];\n }\n\n function text() {\n return input.substring(peg$savedPos, peg$currPos);\n }\n\n function offset() {\n return peg$savedPos;\n }\n\n function range() {\n return {\n source: peg$source,\n start: peg$savedPos,\n end: peg$currPos\n };\n }\n\n function location() {\n return peg$computeLocation(peg$savedPos, peg$currPos);\n }\n\n function expected(description, location) {\n location = location !== undefined\n ? location\n : peg$computeLocation(peg$savedPos, peg$currPos);\n\n throw peg$buildStructuredError(\n [peg$otherExpectation(description)],\n input.substring(peg$savedPos, peg$currPos),\n location\n );\n }\n\n function error(message, location) {\n location = location !== undefined\n ? location\n : peg$computeLocation(peg$savedPos, peg$currPos);\n\n throw peg$buildSimpleError(message, location);\n }\n\n function peg$literalExpectation(text, ignoreCase) {\n return { type: \"literal\", text: text, ignoreCase: ignoreCase };\n }\n\n function peg$classExpectation(parts, inverted, ignoreCase) {\n return { type: \"class\", parts: parts, inverted: inverted, ignoreCase: ignoreCase };\n }\n\n function peg$anyExpectation() {\n return { type: \"any\" };\n }\n\n function peg$endExpectation() {\n return { type: \"end\" };\n }\n\n function peg$otherExpectation(description) {\n return { type: \"other\", description: description };\n }\n\n function peg$computePosDetails(pos) {\n var details = peg$posDetailsCache[pos];\n var p;\n\n if (details) {\n return details;\n } else {\n p = pos - 1;\n while (!peg$posDetailsCache[p]) {\n p--;\n }\n\n details = peg$posDetailsCache[p];\n details = {\n line: details.line,\n column: details.column\n };\n\n while (p < pos) {\n if (input.charCodeAt(p) === 10) {\n details.line++;\n details.column = 1;\n } else {\n details.column++;\n }\n\n p++;\n }\n\n peg$posDetailsCache[pos] = details;\n\n return details;\n }\n }\n\n function peg$computeLocation(startPos, endPos) {\n var startPosDetails = peg$computePosDetails(startPos);\n var endPosDetails = peg$computePosDetails(endPos);\n\n return {\n source: peg$source,\n start: {\n offset: startPos,\n line: startPosDetails.line,\n column: startPosDetails.column\n },\n end: {\n offset: endPos,\n line: endPosDetails.line,\n column: endPosDetails.column\n }\n };\n }\n\n function peg$fail(expected) {\n if (peg$currPos < peg$maxFailPos) { return; }\n\n if (peg$currPos > peg$maxFailPos) {\n peg$maxFailPos = peg$currPos;\n peg$maxFailExpected = [];\n }\n\n peg$maxFailExpected.push(expected);\n }\n\n function peg$buildSimpleError(message, location) {\n return new peg$SyntaxError(message, null, null, location);\n }\n\n function peg$buildStructuredError(expected, found, location) {\n return new peg$SyntaxError(\n peg$SyntaxError.buildMessage(expected, found),\n expected,\n found,\n location\n );\n }\n\n function peg$parsebody() {\n var s0, s1, s2;\n\n s0 = [];\n s1 = peg$parsecomment_only_line();\n if (s1 === peg$FAILED) {\n s1 = peg$parseitem_with_end();\n if (s1 === peg$FAILED) {\n s1 = peg$parseitem_without_end();\n }\n }\n if (s1 !== peg$FAILED) {\n while (s1 !== peg$FAILED) {\n s0.push(s1);\n s1 = peg$parsecomment_only_line();\n if (s1 === peg$FAILED) {\n s1 = peg$parseitem_with_end();\n if (s1 === peg$FAILED) {\n s1 = peg$parseitem_without_end();\n }\n }\n }\n } else {\n s0 = peg$FAILED;\n }\n if (s0 === peg$FAILED) {\n s0 = peg$currPos;\n s1 = [];\n s2 = peg$parsewhitespace();\n while (s2 !== peg$FAILED) {\n s1.push(s2);\n s2 = peg$parsewhitespace();\n }\n s2 = peg$parseEOL();\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f0();\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n }\n\n return s0;\n }\n\n function peg$parseitem_with_end() {\n var s0, s1, s2, s3, s4, s5, s6, s7, s8;\n\n s0 = peg$currPos;\n s1 = peg$parsewhitespace_or_parbreaks();\n s2 = peg$parserow_items();\n if (s2 === peg$FAILED) {\n s2 = null;\n }\n s3 = peg$parsewhitespace_or_parbreaks();\n s4 = peg$parseitem_sep();\n if (s4 !== peg$FAILED) {\n s5 = [];\n s6 = peg$parsewhitespace();\n while (s6 !== peg$FAILED) {\n s5.push(s6);\n s6 = peg$parsewhitespace();\n }\n s6 = peg$parsetrailing_comment();\n if (s6 === peg$FAILED) {\n s6 = null;\n }\n s7 = [];\n s8 = peg$parsewhitespace();\n while (s8 !== peg$FAILED) {\n s7.push(s8);\n s8 = peg$parsewhitespace();\n }\n peg$savedPos = s0;\n s0 = peg$f1(s2, s6);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n\n return s0;\n }\n\n function peg$parseitem_without_end() {\n var s0, s1, s2, s3;\n\n s0 = peg$currPos;\n s1 = peg$parsewhitespace_or_parbreaks();\n s2 = peg$parserow_items();\n if (s2 !== peg$FAILED) {\n s3 = peg$parsetrailing_comment();\n if (s3 === peg$FAILED) {\n s3 = null;\n }\n peg$savedPos = s0;\n s0 = peg$f2(s2, s3);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n\n return s0;\n }\n\n function peg$parserow_items() {\n var s0, s1, s2, s3;\n\n s0 = peg$currPos;\n s1 = peg$parseitem_part();\n if (s1 !== peg$FAILED) {\n s2 = [];\n s3 = peg$parseseparated_part();\n while (s3 !== peg$FAILED) {\n s2.push(s3);\n s3 = peg$parseseparated_part();\n }\n peg$savedPos = s0;\n s0 = peg$f3(s1, s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n if (s0 === peg$FAILED) {\n s0 = peg$currPos;\n s1 = [];\n s2 = peg$parseseparated_part();\n if (s2 !== peg$FAILED) {\n while (s2 !== peg$FAILED) {\n s1.push(s2);\n s2 = peg$parseseparated_part();\n }\n } else {\n s1 = peg$FAILED;\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = s0;\n s1 = peg$f4(s1);\n }\n s0 = s1;\n }\n\n return s0;\n }\n\n function peg$parseseparated_part() {\n var s0, s1, s2, s3, s4;\n\n s0 = peg$currPos;\n s1 = [];\n s2 = peg$parseparbreak();\n while (s2 !== peg$FAILED) {\n s1.push(s2);\n s2 = peg$parseparbreak();\n }\n s2 = peg$parseequals();\n if (s2 !== peg$FAILED) {\n s3 = [];\n s4 = peg$parseparbreak();\n while (s4 !== peg$FAILED) {\n s3.push(s4);\n s4 = peg$parseparbreak();\n }\n s4 = peg$parseitem_part();\n if (s4 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f5(s4);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n if (s0 === peg$FAILED) {\n s0 = peg$currPos;\n s1 = [];\n s2 = peg$parseparbreak();\n while (s2 !== peg$FAILED) {\n s1.push(s2);\n s2 = peg$parseparbreak();\n }\n s2 = peg$parseequals();\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f6();\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n }\n\n return s0;\n }\n\n function peg$parseitem_part() {\n var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;\n\n s0 = peg$currPos;\n s1 = [];\n s2 = peg$parsewhitespace();\n while (s2 !== peg$FAILED) {\n s1.push(s2);\n s2 = peg$parsewhitespace();\n }\n s2 = peg$currPos;\n s3 = [];\n s4 = peg$parsenon_whitespace_non_parbreak_token();\n if (s4 === peg$FAILED) {\n s4 = peg$currPos;\n s5 = peg$parsewhitespace();\n if (s5 === peg$FAILED) {\n s5 = peg$parseparbreak();\n }\n if (s5 !== peg$FAILED) {\n s6 = peg$currPos;\n peg$silentFails++;\n s7 = peg$currPos;\n s8 = [];\n s9 = peg$parsewhitespace();\n if (s9 === peg$FAILED) {\n s9 = peg$parseparbreak();\n }\n while (s9 !== peg$FAILED) {\n s8.push(s9);\n s9 = peg$parsewhitespace();\n if (s9 === peg$FAILED) {\n s9 = peg$parseparbreak();\n }\n }\n s9 = peg$parsenon_whitespace_non_parbreak_token();\n if (s9 !== peg$FAILED) {\n s8 = [s8, s9];\n s7 = s8;\n } else {\n peg$currPos = s7;\n s7 = peg$FAILED;\n }\n peg$silentFails--;\n if (s7 !== peg$FAILED) {\n peg$currPos = s6;\n s6 = undefined;\n } else {\n s6 = peg$FAILED;\n }\n if (s6 !== peg$FAILED) {\n s5 = [s5, s6];\n s4 = s5;\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n }\n if (s4 !== peg$FAILED) {\n while (s4 !== peg$FAILED) {\n s3.push(s4);\n s4 = peg$parsenon_whitespace_non_parbreak_token();\n if (s4 === peg$FAILED) {\n s4 = peg$currPos;\n s5 = peg$parsewhitespace();\n if (s5 === peg$FAILED) {\n s5 = peg$parseparbreak();\n }\n if (s5 !== peg$FAILED) {\n s6 = peg$currPos;\n peg$silentFails++;\n s7 = peg$currPos;\n s8 = [];\n s9 = peg$parsewhitespace();\n if (s9 === peg$FAILED) {\n s9 = peg$parseparbreak();\n }\n while (s9 !== peg$FAILED) {\n s8.push(s9);\n s9 = peg$parsewhitespace();\n if (s9 === peg$FAILED) {\n s9 = peg$parseparbreak();\n }\n }\n s9 = peg$parsenon_whitespace_non_parbreak_token();\n if (s9 !== peg$FAILED) {\n s8 = [s8, s9];\n s7 = s8;\n } else {\n peg$currPos = s7;\n s7 = peg$FAILED;\n }\n peg$silentFails--;\n if (s7 !== peg$FAILED) {\n peg$currPos = s6;\n s6 = undefined;\n } else {\n s6 = peg$FAILED;\n }\n if (s6 !== peg$FAILED) {\n s5 = [s5, s6];\n s4 = s5;\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n }\n }\n } else {\n s3 = peg$FAILED;\n }\n if (s3 !== peg$FAILED) {\n s2 = input.substring(s2, peg$currPos);\n } else {\n s2 = s3;\n }\n if (s2 !== peg$FAILED) {\n s3 = [];\n s4 = peg$parsewhitespace();\n while (s4 !== peg$FAILED) {\n s3.push(s4);\n s4 = peg$parsewhitespace();\n }\n peg$savedPos = s0;\n s0 = peg$f7(s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n\n return s0;\n }\n\n function peg$parsetrailing_comment() {\n var s0, s1, s2;\n\n s0 = peg$currPos;\n s1 = [];\n s2 = peg$parsewhitespace();\n while (s2 !== peg$FAILED) {\n s1.push(s2);\n s2 = peg$parsewhitespace();\n }\n s2 = peg$parsesame_line_comment();\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f8(s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n\n return s0;\n }\n\n function peg$parsecomment_only_line() {\n var s0, s1, s2;\n\n s0 = peg$currPos;\n s1 = peg$parsewhitespace_or_parbreaks();\n s2 = peg$parseown_line_comment();\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f9(s1, s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n\n return s0;\n }\n\n function peg$parsetoken() {\n var s0, s1, s2, s3;\n\n s0 = peg$currPos;\n s1 = peg$currPos;\n s2 = peg$currPos;\n peg$silentFails++;\n s3 = peg$parsenon_token();\n peg$silentFails--;\n if (s3 === peg$FAILED) {\n s2 = undefined;\n } else {\n peg$currPos = s2;\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n if (input.length > peg$currPos) {\n s3 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s3 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e0); }\n }\n if (s3 !== peg$FAILED) {\n s2 = [s2, s3];\n s1 = s2;\n } else {\n peg$currPos = s1;\n s1 = peg$FAILED;\n }\n } else {\n peg$currPos = s1;\n s1 = peg$FAILED;\n }\n if (s1 !== peg$FAILED) {\n s0 = input.substring(s0, peg$currPos);\n } else {\n s0 = s1;\n }\n\n return s0;\n }\n\n function peg$parsenon_whitespace_non_parbreak_token() {\n var s0, s1, s2, s3;\n\n s0 = peg$currPos;\n s1 = peg$currPos;\n s2 = peg$currPos;\n peg$silentFails++;\n s3 = peg$parsewhitespace();\n if (s3 === peg$FAILED) {\n s3 = peg$parseparbreak();\n }\n peg$silentFails--;\n if (s3 === peg$FAILED) {\n s2 = undefined;\n } else {\n peg$currPos = s2;\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n s3 = peg$parseparen_block();\n if (s3 === peg$FAILED) {\n s3 = peg$parsetoken();\n }\n if (s3 !== peg$FAILED) {\n s2 = [s2, s3];\n s1 = s2;\n } else {\n peg$currPos = s1;\n s1 = peg$FAILED;\n }\n } else {\n peg$currPos = s1;\n s1 = peg$FAILED;\n }\n if (s1 !== peg$FAILED) {\n s0 = input.substring(s0, peg$currPos);\n } else {\n s0 = s1;\n }\n\n return s0;\n }\n\n function peg$parsenon_token() {\n var s0;\n\n s0 = peg$parseitem_sep();\n if (s0 === peg$FAILED) {\n s0 = peg$parseequals();\n if (s0 === peg$FAILED) {\n s0 = peg$parsetrailing_comment();\n if (s0 === peg$FAILED) {\n s0 = peg$parseown_line_comment();\n }\n }\n }\n\n return s0;\n }\n\n function peg$parsewhitespace_or_parbreaks() {\n var s0, s1, s2;\n\n s0 = peg$currPos;\n s1 = [];\n s2 = peg$parsewhitespace();\n if (s2 === peg$FAILED) {\n s2 = peg$parseparbreak();\n }\n while (s2 !== peg$FAILED) {\n s1.push(s2);\n s2 = peg$parsewhitespace();\n if (s2 === peg$FAILED) {\n s2 = peg$parseparbreak();\n }\n }\n peg$savedPos = s0;\n s1 = peg$f10(s1);\n s0 = s1;\n\n return s0;\n }\n\n function peg$parseparen_block() {\n var s0, s1, s2, s3, s4, s5, s6, s7, s8;\n\n s0 = peg$currPos;\n peg$savedPos = peg$currPos;\n s1 = peg$f11();\n if (s1) {\n s1 = peg$FAILED;\n } else {\n s1 = undefined;\n }\n if (s1 !== peg$FAILED) {\n s2 = peg$currPos;\n s3 = peg$currPos;\n s4 = peg$parseopen_paren();\n if (s4 !== peg$FAILED) {\n s5 = [];\n s6 = peg$currPos;\n s7 = peg$currPos;\n peg$silentFails++;\n s8 = peg$parseclose_paren();\n peg$silentFails--;\n if (s8 === peg$FAILED) {\n s7 = undefined;\n } else {\n peg$currPos = s7;\n s7 = peg$FAILED;\n }\n if (s7 !== peg$FAILED) {\n if (input.length > peg$currPos) {\n s8 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s8 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e0); }\n }\n if (s8 !== peg$FAILED) {\n s7 = [s7, s8];\n s6 = s7;\n } else {\n peg$currPos = s6;\n s6 = peg$FAILED;\n }\n } else {\n peg$currPos = s6;\n s6 = peg$FAILED;\n }\n while (s6 !== peg$FAILED) {\n s5.push(s6);\n s6 = peg$currPos;\n s7 = peg$currPos;\n peg$silentFails++;\n s8 = peg$parseclose_paren();\n peg$silentFails--;\n if (s8 === peg$FAILED) {\n s7 = undefined;\n } else {\n peg$currPos = s7;\n s7 = peg$FAILED;\n }\n if (s7 !== peg$FAILED) {\n if (input.length > peg$currPos) {\n s8 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s8 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e0); }\n }\n if (s8 !== peg$FAILED) {\n s7 = [s7, s8];\n s6 = s7;\n } else {\n peg$currPos = s6;\n s6 = peg$FAILED;\n }\n } else {\n peg$currPos = s6;\n s6 = peg$FAILED;\n }\n }\n s6 = peg$parseclose_paren();\n if (s6 !== peg$FAILED) {\n s4 = [s4, s5, s6];\n s3 = s4;\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n if (s3 !== peg$FAILED) {\n s2 = input.substring(s2, peg$currPos);\n } else {\n s2 = s3;\n }\n if (s2 !== peg$FAILED) {\n s1 = [s1, s2];\n s0 = s1;\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n\n return s0;\n }\n\n function peg$parsesame_line_comment() {\n var s0, s1, s2;\n\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e0); }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f12(s1);\n if (s2) {\n s2 = undefined;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f13(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n\n return s0;\n }\n\n function peg$parseown_line_comment() {\n var s0, s1, s2;\n\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e0); }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f14(s1);\n if (s2) {\n s2 = undefined;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f15(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n\n return s0;\n }\n\n function peg$parsewhitespace() {\n var s0, s1, s2;\n\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e0); }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f16(s1);\n if (s2) {\n s2 = undefined;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f17(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n\n return s0;\n }\n\n function peg$parseparbreak() {\n var s0, s1, s2;\n\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e0); }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f18(s1);\n if (s2) {\n s2 = undefined;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f19(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n\n return s0;\n }\n\n function peg$parseitem_sep() {\n var s0, s1, s2;\n\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e0); }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f20(s1);\n if (s2) {\n s2 = undefined;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f21(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n\n return s0;\n }\n\n function peg$parseequals() {\n var s0, s1, s2;\n\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e0); }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f22(s1);\n if (s2) {\n s2 = undefined;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f23(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n\n return s0;\n }\n\n function peg$parseopen_paren() {\n var s0, s1, s2;\n\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e0); }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f24(s1);\n if (s2) {\n s2 = undefined;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f25(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n\n return s0;\n }\n\n function peg$parseclose_paren() {\n var s0, s1, s2;\n\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e0); }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f26(s1);\n if (s2) {\n s2 = undefined;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f27(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n\n return s0;\n }\n\n function peg$parseEOL() {\n var s0, s1;\n\n s0 = peg$currPos;\n peg$silentFails++;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e0); }\n }\n peg$silentFails--;\n if (s1 === peg$FAILED) {\n s0 = undefined;\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n\n return s0;\n }\n\n\n function processItem(leadCell, otherCells) {\n const cells = [leadCell || []];\n for (const x of otherCells) {\n cells.push(x.cell || []);\n }\n return { itemParts: cells };\n }\n\n //\n // These are compatability functions used when running in the browser\n //\n // Check if the `options` object has the functions that we need.\n // If not, try to add them\n if (!options.isWhitespace) {\n try {\n Object.assign(options, {\n isChar: (node, char) =>\n node.type === \"string\" && node.content === char,\n isComma(node) {\n return node.type === \"string\" && node.content === \",\";\n },\n isEquals(node) {\n return node.type === \"string\" && node.content === \"=\";\n },\n isParbreak(node) {\n return node.type === \"parbreak\";\n },\n isWhitespace(node) {\n return node.type === \"whitespace\";\n },\n isSameLineComment: (node) =>\n node.type === \"comment\" && node.sameline,\n isOwnLineComment: (node) =>\n node.type === \"comment\" && !node.sameline,\n isComment: (node) => node.type === \"comment\",\n allowParenGroups: true,\n });\n } catch (e) {\n console.warn(\"Error when initializing parser\", e);\n }\n }\n\n peg$result = peg$startRuleFunction();\n\n if (peg$result !== peg$FAILED && peg$currPos === input.length) {\n return peg$result;\n } else {\n if (peg$result !== peg$FAILED && peg$currPos < input.length) {\n peg$fail(peg$endExpectation());\n }\n\n throw peg$buildStructuredError(\n peg$maxFailExpected,\n peg$maxFailPos < input.length ? input.charAt(peg$maxFailPos) : null,\n peg$maxFailPos < input.length\n ? peg$computeLocation(peg$maxFailPos, peg$maxFailPos + 1)\n : peg$computeLocation(peg$maxFailPos, peg$maxFailPos)\n );\n }\n}\n\n return {\n SyntaxError: peg$SyntaxError,\n parse: peg$parse\n };\n})()\n", "export default // Generated by Peggy 2.0.1.\n//\n// https://peggyjs.org/\n(function() {\n \"use strict\";\n\nfunction peg$subclass(child, parent) {\n function C() { this.constructor = child; }\n C.prototype = parent.prototype;\n child.prototype = new C();\n}\n\nfunction peg$SyntaxError(message, expected, found, location) {\n var self = Error.call(this, message);\n // istanbul ignore next Check is a necessary evil to support older environments\n if (Object.setPrototypeOf) {\n Object.setPrototypeOf(self, peg$SyntaxError.prototype);\n }\n self.expected = expected;\n self.found = found;\n self.location = location;\n self.name = \"SyntaxError\";\n return self;\n}\n\npeg$subclass(peg$SyntaxError, Error);\n\nfunction peg$padEnd(str, targetLength, padString) {\n padString = padString || \" \";\n if (str.length > targetLength) { return str; }\n targetLength -= str.length;\n padString += padString.repeat(targetLength);\n return str + padString.slice(0, targetLength);\n}\n\npeg$SyntaxError.prototype.format = function(sources) {\n var str = \"Error: \" + this.message;\n if (this.location) {\n var src = null;\n var k;\n for (k = 0; k < sources.length; k++) {\n if (sources[k].source === this.location.source) {\n src = sources[k].text.split(/\\r\\n|\\n|\\r/g);\n break;\n }\n }\n var s = this.location.start;\n var loc = this.location.source + \":\" + s.line + \":\" + s.column;\n if (src) {\n var e = this.location.end;\n var filler = peg$padEnd(\"\", s.line.toString().length, ' ');\n var line = src[s.line - 1];\n var last = s.line === e.line ? e.column : line.length + 1;\n var hatLen = (last - s.column) || 1;\n str += \"\\n --> \" + loc + \"\\n\"\n + filler + \" |\\n\"\n + s.line + \" | \" + line + \"\\n\"\n + filler + \" | \" + peg$padEnd(\"\", s.column - 1, ' ')\n + peg$padEnd(\"\", hatLen, \"^\");\n } else {\n str += \"\\n at \" + loc;\n }\n }\n return str;\n};\n\npeg$SyntaxError.buildMessage = function(expected, found) {\n var DESCRIBE_EXPECTATION_FNS = {\n literal: function(expectation) {\n return \"\\\"\" + literalEscape(expectation.text) + \"\\\"\";\n },\n\n class: function(expectation) {\n var escapedParts = expectation.parts.map(function(part) {\n return Array.isArray(part)\n ? classEscape(part[0]) + \"-\" + classEscape(part[1])\n : classEscape(part);\n });\n\n return \"[\" + (expectation.inverted ? \"^\" : \"\") + escapedParts.join(\"\") + \"]\";\n },\n\n any: function() {\n return \"any character\";\n },\n\n end: function() {\n return \"end of input\";\n },\n\n other: function(expectation) {\n return expectation.description;\n }\n };\n\n function hex(ch) {\n return ch.charCodeAt(0).toString(16).toUpperCase();\n }\n\n function literalEscape(s) {\n return s\n .replace(/\\\\/g, \"\\\\\\\\\")\n .replace(/\"/g, \"\\\\\\\"\")\n .replace(/\\0/g, \"\\\\0\")\n .replace(/\\t/g, \"\\\\t\")\n .replace(/\\n/g, \"\\\\n\")\n .replace(/\\r/g, \"\\\\r\")\n .replace(/[\\x00-\\x0F]/g, function(ch) { return \"\\\\x0\" + hex(ch); })\n .replace(/[\\x10-\\x1F\\x7F-\\x9F]/g, function(ch) { return \"\\\\x\" + hex(ch); });\n }\n\n function classEscape(s) {\n return s\n .replace(/\\\\/g, \"\\\\\\\\\")\n .replace(/\\]/g, \"\\\\]\")\n .replace(/\\^/g, \"\\\\^\")\n .replace(/-/g, \"\\\\-\")\n .replace(/\\0/g, \"\\\\0\")\n .replace(/\\t/g, \"\\\\t\")\n .replace(/\\n/g, \"\\\\n\")\n .replace(/\\r/g, \"\\\\r\")\n .replace(/[\\x00-\\x0F]/g, function(ch) { return \"\\\\x0\" + hex(ch); })\n .replace(/[\\x10-\\x1F\\x7F-\\x9F]/g, function(ch) { return \"\\\\x\" + hex(ch); });\n }\n\n function describeExpectation(expectation) {\n return DESCRIBE_EXPECTATION_FNS[expectation.type](expectation);\n }\n\n function describeExpected(expected) {\n var descriptions = expected.map(describeExpectation);\n var i, j;\n\n descriptions.sort();\n\n if (descriptions.length > 0) {\n for (i = 1, j = 1; i < descriptions.length; i++) {\n if (descriptions[i - 1] !== descriptions[i]) {\n descriptions[j] = descriptions[i];\n j++;\n }\n }\n descriptions.length = j;\n }\n\n switch (descriptions.length) {\n case 1:\n return descriptions[0];\n\n case 2:\n return descriptions[0] + \" or \" + descriptions[1];\n\n default:\n return descriptions.slice(0, -1).join(\", \")\n + \", or \"\n + descriptions[descriptions.length - 1];\n }\n }\n\n function describeFound(found) {\n return found ? \"\\\"\" + literalEscape(found) + \"\\\"\" : \"end of input\";\n }\n\n return \"Expected \" + describeExpected(expected) + \" but \" + describeFound(found) + \" found.\";\n};\n\nfunction peg$parse(input, options) {\n options = options !== undefined ? options : {};\n\n var peg$FAILED = {};\n var peg$source = options.grammarSource;\n\n var peg$startRuleFunctions = { body: peg$parsebody };\n var peg$startRuleFunction = peg$parsebody;\n\n\n\n var peg$e0 = peg$anyExpectation();\n\n var peg$f0 = function(e) {\n // We may have inserted nested arrays.\n // Flatten everything before we're done and remove any\n // resitual `null`s\n return [].concat(...e).filter((n) => !!n);\n };\n var peg$f1 = function() { return []; };\n var peg$f2 = function(tok) { return options.isHash(tok); };\n var peg$f3 = function(tok) { return tok; };\n var peg$f4 = function(tok) { return options.isNumber(tok); };\n var peg$f5 = function(tok) { return tok; };\n var peg$f6 = function() { return { type: \"string\", content: \"#\" }; };\n var peg$f7 = function(num) {\n const split = options.splitNumber(num);\n return [{ type: \"hash_number\", number: split.number }, split.rest];\n };\n var peg$currPos = 0;\n var peg$savedPos = 0;\n var peg$posDetailsCache = [{ line: 1, column: 1 }];\n var peg$maxFailPos = 0;\n var peg$maxFailExpected = [];\n var peg$silentFails = 0;\n\n var peg$result;\n\n if (\"startRule\" in options) {\n if (!(options.startRule in peg$startRuleFunctions)) {\n throw new Error(\"Can't start parsing from rule \\\"\" + options.startRule + \"\\\".\");\n }\n\n peg$startRuleFunction = peg$startRuleFunctions[options.startRule];\n }\n\n function text() {\n return input.substring(peg$savedPos, peg$currPos);\n }\n\n function offset() {\n return peg$savedPos;\n }\n\n function range() {\n return {\n source: peg$source,\n start: peg$savedPos,\n end: peg$currPos\n };\n }\n\n function location() {\n return peg$computeLocation(peg$savedPos, peg$currPos);\n }\n\n function expected(description, location) {\n location = location !== undefined\n ? location\n : peg$computeLocation(peg$savedPos, peg$currPos);\n\n throw peg$buildStructuredError(\n [peg$otherExpectation(description)],\n input.substring(peg$savedPos, peg$currPos),\n location\n );\n }\n\n function error(message, location) {\n location = location !== undefined\n ? location\n : peg$computeLocation(peg$savedPos, peg$currPos);\n\n throw peg$buildSimpleError(message, location);\n }\n\n function peg$literalExpectation(text, ignoreCase) {\n return { type: \"literal\", text: text, ignoreCase: ignoreCase };\n }\n\n function peg$classExpectation(parts, inverted, ignoreCase) {\n return { type: \"class\", parts: parts, inverted: inverted, ignoreCase: ignoreCase };\n }\n\n function peg$anyExpectation() {\n return { type: \"any\" };\n }\n\n function peg$endExpectation() {\n return { type: \"end\" };\n }\n\n function peg$otherExpectation(description) {\n return { type: \"other\", description: description };\n }\n\n function peg$computePosDetails(pos) {\n var details = peg$posDetailsCache[pos];\n var p;\n\n if (details) {\n return details;\n } else {\n p = pos - 1;\n while (!peg$posDetailsCache[p]) {\n p--;\n }\n\n details = peg$posDetailsCache[p];\n details = {\n line: details.line,\n column: details.column\n };\n\n while (p < pos) {\n if (input.charCodeAt(p) === 10) {\n details.line++;\n details.column = 1;\n } else {\n details.column++;\n }\n\n p++;\n }\n\n peg$posDetailsCache[pos] = details;\n\n return details;\n }\n }\n\n function peg$computeLocation(startPos, endPos) {\n var startPosDetails = peg$computePosDetails(startPos);\n var endPosDetails = peg$computePosDetails(endPos);\n\n return {\n source: peg$source,\n start: {\n offset: startPos,\n line: startPosDetails.line,\n column: startPosDetails.column\n },\n end: {\n offset: endPos,\n line: endPosDetails.line,\n column: endPosDetails.column\n }\n };\n }\n\n function peg$fail(expected) {\n if (peg$currPos < peg$maxFailPos) { return; }\n\n if (peg$currPos > peg$maxFailPos) {\n peg$maxFailPos = peg$currPos;\n peg$maxFailExpected = [];\n }\n\n peg$maxFailExpected.push(expected);\n }\n\n function peg$buildSimpleError(message, location) {\n return new peg$SyntaxError(message, null, null, location);\n }\n\n function peg$buildStructuredError(expected, found, location) {\n return new peg$SyntaxError(\n peg$SyntaxError.buildMessage(expected, found),\n expected,\n found,\n location\n );\n }\n\n function peg$parsebody() {\n var s0, s1, s2;\n\n s0 = peg$currPos;\n s1 = [];\n s2 = peg$parsedouble_hash();\n if (s2 === peg$FAILED) {\n s2 = peg$parsehash_number();\n if (s2 === peg$FAILED) {\n if (input.length > peg$currPos) {\n s2 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s2 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e0); }\n }\n }\n }\n if (s2 !== peg$FAILED) {\n while (s2 !== peg$FAILED) {\n s1.push(s2);\n s2 = peg$parsedouble_hash();\n if (s2 === peg$FAILED) {\n s2 = peg$parsehash_number();\n if (s2 === peg$FAILED) {\n if (input.length > peg$currPos) {\n s2 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s2 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e0); }\n }\n }\n }\n }\n } else {\n s1 = peg$FAILED;\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = s0;\n s1 = peg$f0(s1);\n }\n s0 = s1;\n if (s0 === peg$FAILED) {\n s0 = peg$currPos;\n s1 = peg$parseEOL();\n if (s1 !== peg$FAILED) {\n peg$savedPos = s0;\n s1 = peg$f1();\n }\n s0 = s1;\n }\n\n return s0;\n }\n\n function peg$parsehash() {\n var s0, s1, s2;\n\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e0); }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f2(s1);\n if (s2) {\n s2 = undefined;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f3(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n\n return s0;\n }\n\n function peg$parsenumber() {\n var s0, s1, s2;\n\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e0); }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f4(s1);\n if (s2) {\n s2 = undefined;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f5(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n\n return s0;\n }\n\n function peg$parsedouble_hash() {\n var s0, s1, s2;\n\n s0 = peg$currPos;\n s1 = peg$parsehash();\n if (s1 !== peg$FAILED) {\n s2 = peg$parsehash();\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f6();\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n\n return s0;\n }\n\n function peg$parsehash_number() {\n var s0, s1, s2;\n\n s0 = peg$currPos;\n s1 = peg$parsehash();\n if (s1 !== peg$FAILED) {\n s2 = peg$parsenumber();\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f7(s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n\n return s0;\n }\n\n function peg$parseEOL() {\n var s0, s1;\n\n s0 = peg$currPos;\n peg$silentFails++;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e0); }\n }\n peg$silentFails--;\n if (s1 === peg$FAILED) {\n s0 = undefined;\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n\n return s0;\n }\n\n\n //\n // These are compatability functions used when running in the browser\n //\n // Check if the `options` object has the functions that we need.\n // If not, try to add them\n if (!options.isHash) {\n try {\n Object.assign(options, {\n isHash: (node) =>\n node.type === \"string\" && node.content === \"#\",\n isNumber: (node) =>\n node.type === \"string\" && 0 < +node.content.charAt(0),\n splitNumber: (node) => {\n const number = +node.content.charAt(0);\n if (node.content.length > 1) {\n return {\n number,\n rest: {\n type: \"string\",\n content: node.content.slice(1),\n },\n };\n }\n return { number };\n },\n });\n } catch (e) {\n console.warn(\"Error when initializing parser\", e);\n }\n }\n\n peg$result = peg$startRuleFunction();\n\n if (peg$result !== peg$FAILED && peg$currPos === input.length) {\n return peg$result;\n } else {\n if (peg$result !== peg$FAILED && peg$currPos < input.length) {\n peg$fail(peg$endExpectation());\n }\n\n throw peg$buildStructuredError(\n peg$maxFailExpected,\n peg$maxFailPos < input.length ? input.charAt(peg$maxFailPos) : null,\n peg$maxFailPos < input.length\n ? peg$computeLocation(peg$maxFailPos, peg$maxFailPos + 1)\n : peg$computeLocation(peg$maxFailPos, peg$maxFailPos)\n );\n }\n}\n\n return {\n SyntaxError: peg$SyntaxError,\n parse: peg$parse\n };\n})()\n", "export default // Generated by Peggy 2.0.1.\n//\n// https://peggyjs.org/\n(function() {\n \"use strict\";\n\nfunction peg$subclass(child, parent) {\n function C() { this.constructor = child; }\n C.prototype = parent.prototype;\n child.prototype = new C();\n}\n\nfunction peg$SyntaxError(message, expected, found, location) {\n var self = Error.call(this, message);\n // istanbul ignore next Check is a necessary evil to support older environments\n if (Object.setPrototypeOf) {\n Object.setPrototypeOf(self, peg$SyntaxError.prototype);\n }\n self.expected = expected;\n self.found = found;\n self.location = location;\n self.name = \"SyntaxError\";\n return self;\n}\n\npeg$subclass(peg$SyntaxError, Error);\n\nfunction peg$padEnd(str, targetLength, padString) {\n padString = padString || \" \";\n if (str.length > targetLength) { return str; }\n targetLength -= str.length;\n padString += padString.repeat(targetLength);\n return str + padString.slice(0, targetLength);\n}\n\npeg$SyntaxError.prototype.format = function(sources) {\n var str = \"Error: \" + this.message;\n if (this.location) {\n var src = null;\n var k;\n for (k = 0; k < sources.length; k++) {\n if (sources[k].source === this.location.source) {\n src = sources[k].text.split(/\\r\\n|\\n|\\r/g);\n break;\n }\n }\n var s = this.location.start;\n var loc = this.location.source + \":\" + s.line + \":\" + s.column;\n if (src) {\n var e = this.location.end;\n var filler = peg$padEnd(\"\", s.line.toString().length, ' ');\n var line = src[s.line - 1];\n var last = s.line === e.line ? e.column : line.length + 1;\n var hatLen = (last - s.column) || 1;\n str += \"\\n --> \" + loc + \"\\n\"\n + filler + \" |\\n\"\n + s.line + \" | \" + line + \"\\n\"\n + filler + \" | \" + peg$padEnd(\"\", s.column - 1, ' ')\n + peg$padEnd(\"\", hatLen, \"^\");\n } else {\n str += \"\\n at \" + loc;\n }\n }\n return str;\n};\n\npeg$SyntaxError.buildMessage = function(expected, found) {\n var DESCRIBE_EXPECTATION_FNS = {\n literal: function(expectation) {\n return \"\\\"\" + literalEscape(expectation.text) + \"\\\"\";\n },\n\n class: function(expectation) {\n var escapedParts = expectation.parts.map(function(part) {\n return Array.isArray(part)\n ? classEscape(part[0]) + \"-\" + classEscape(part[1])\n : classEscape(part);\n });\n\n return \"[\" + (expectation.inverted ? \"^\" : \"\") + escapedParts.join(\"\") + \"]\";\n },\n\n any: function() {\n return \"any character\";\n },\n\n end: function() {\n return \"end of input\";\n },\n\n other: function(expectation) {\n return expectation.description;\n }\n };\n\n function hex(ch) {\n return ch.charCodeAt(0).toString(16).toUpperCase();\n }\n\n function literalEscape(s) {\n return s\n .replace(/\\\\/g, \"\\\\\\\\\")\n .replace(/\"/g, \"\\\\\\\"\")\n .replace(/\\0/g, \"\\\\0\")\n .replace(/\\t/g, \"\\\\t\")\n .replace(/\\n/g, \"\\\\n\")\n .replace(/\\r/g, \"\\\\r\")\n .replace(/[\\x00-\\x0F]/g, function(ch) { return \"\\\\x0\" + hex(ch); })\n .replace(/[\\x10-\\x1F\\x7F-\\x9F]/g, function(ch) { return \"\\\\x\" + hex(ch); });\n }\n\n function classEscape(s) {\n return s\n .replace(/\\\\/g, \"\\\\\\\\\")\n .replace(/\\]/g, \"\\\\]\")\n .replace(/\\^/g, \"\\\\^\")\n .replace(/-/g, \"\\\\-\")\n .replace(/\\0/g, \"\\\\0\")\n .replace(/\\t/g, \"\\\\t\")\n .replace(/\\n/g, \"\\\\n\")\n .replace(/\\r/g, \"\\\\r\")\n .replace(/[\\x00-\\x0F]/g, function(ch) { return \"\\\\x0\" + hex(ch); })\n .replace(/[\\x10-\\x1F\\x7F-\\x9F]/g, function(ch) { return \"\\\\x\" + hex(ch); });\n }\n\n function describeExpectation(expectation) {\n return DESCRIBE_EXPECTATION_FNS[expectation.type](expectation);\n }\n\n function describeExpected(expected) {\n var descriptions = expected.map(describeExpectation);\n var i, j;\n\n descriptions.sort();\n\n if (descriptions.length > 0) {\n for (i = 1, j = 1; i < descriptions.length; i++) {\n if (descriptions[i - 1] !== descriptions[i]) {\n descriptions[j] = descriptions[i];\n j++;\n }\n }\n descriptions.length = j;\n }\n\n switch (descriptions.length) {\n case 1:\n return descriptions[0];\n\n case 2:\n return descriptions[0] + \" or \" + descriptions[1];\n\n default:\n return descriptions.slice(0, -1).join(\", \")\n + \", or \"\n + descriptions[descriptions.length - 1];\n }\n }\n\n function describeFound(found) {\n return found ? \"\\\"\" + literalEscape(found) + \"\\\"\" : \"end of input\";\n }\n\n return \"Expected \" + describeExpected(expected) + \" but \" + describeFound(found) + \" found.\";\n};\n\nfunction peg$parse(input, options) {\n options = options !== undefined ? options : {};\n\n var peg$FAILED = {};\n var peg$source = options.grammarSource;\n\n var peg$startRuleFunctions = { body: peg$parsebody };\n var peg$startRuleFunction = peg$parsebody;\n\n\n\n var peg$e0 = peg$anyExpectation();\n\n var peg$f0 = function(e) {\n // We may have inserted nested arrays.\n // Flatten everything before we're done and remove any\n // resitual `null`s\n return [].concat(...e).filter((n) => !!n);\n };\n var peg$f1 = function() { return []; };\n var peg$f2 = function(toks) { return options.isRecognized(toks); };\n var peg$f3 = function(toks) {\n return options.isRecognized(toks);\n };\n var peg$f4 = function(tok1, tok2) {\n const split = options.split(tok2);\n return options.isRecognized([tok1, split[0]]);\n };\n var peg$f5 = function(tok1, tok2) {\n const split = options.split(tok2);\n return [options.isRecognized([tok1, split[0]]), split[1]];\n };\n var peg$f6 = function(tok1, tok2) { return options.isRecognized([tok1, tok2]); };\n var peg$f7 = function(tok1, tok2) {\n return options.isRecognized([tok1, tok2]);\n };\n var peg$f8 = function(toks) { return options.isRecognized(toks); };\n var peg$f9 = function(toks) {\n return options.isRecognized(toks);\n };\n var peg$f10 = function(tok) { return options.isRecognized([tok]); };\n var peg$f11 = function(tok) {\n return options.isRecognized([tok]);\n };\n var peg$f12 = function(tok) { return options.isMacro(tok); };\n var peg$f13 = function(tok) { return tok; };\n var peg$f14 = function(tok) { return options.isWhitespace(tok); };\n var peg$f15 = function(tok) { return tok; };\n var peg$f16 = function(tok) { return options.isSplitable(tok); };\n var peg$f17 = function(tok) { return tok; };\n var peg$currPos = 0;\n var peg$savedPos = 0;\n var peg$posDetailsCache = [{ line: 1, column: 1 }];\n var peg$maxFailPos = 0;\n var peg$maxFailExpected = [];\n var peg$silentFails = 0;\n\n var peg$result;\n\n if (\"startRule\" in options) {\n if (!(options.startRule in peg$startRuleFunctions)) {\n throw new Error(\"Can't start parsing from rule \\\"\" + options.startRule + \"\\\".\");\n }\n\n peg$startRuleFunction = peg$startRuleFunctions[options.startRule];\n }\n\n function text() {\n return input.substring(peg$savedPos, peg$currPos);\n }\n\n function offset() {\n return peg$savedPos;\n }\n\n function range() {\n return {\n source: peg$source,\n start: peg$savedPos,\n end: peg$currPos\n };\n }\n\n function location() {\n return peg$computeLocation(peg$savedPos, peg$currPos);\n }\n\n function expected(description, location) {\n location = location !== undefined\n ? location\n : peg$computeLocation(peg$savedPos, peg$currPos);\n\n throw peg$buildStructuredError(\n [peg$otherExpectation(description)],\n input.substring(peg$savedPos, peg$currPos),\n location\n );\n }\n\n function error(message, location) {\n location = location !== undefined\n ? location\n : peg$computeLocation(peg$savedPos, peg$currPos);\n\n throw peg$buildSimpleError(message, location);\n }\n\n function peg$literalExpectation(text, ignoreCase) {\n return { type: \"literal\", text: text, ignoreCase: ignoreCase };\n }\n\n function peg$classExpectation(parts, inverted, ignoreCase) {\n return { type: \"class\", parts: parts, inverted: inverted, ignoreCase: ignoreCase };\n }\n\n function peg$anyExpectation() {\n return { type: \"any\" };\n }\n\n function peg$endExpectation() {\n return { type: \"end\" };\n }\n\n function peg$otherExpectation(description) {\n return { type: \"other\", description: description };\n }\n\n function peg$computePosDetails(pos) {\n var details = peg$posDetailsCache[pos];\n var p;\n\n if (details) {\n return details;\n } else {\n p = pos - 1;\n while (!peg$posDetailsCache[p]) {\n p--;\n }\n\n details = peg$posDetailsCache[p];\n details = {\n line: details.line,\n column: details.column\n };\n\n while (p < pos) {\n if (input.charCodeAt(p) === 10) {\n details.line++;\n details.column = 1;\n } else {\n details.column++;\n }\n\n p++;\n }\n\n peg$posDetailsCache[pos] = details;\n\n return details;\n }\n }\n\n function peg$computeLocation(startPos, endPos) {\n var startPosDetails = peg$computePosDetails(startPos);\n var endPosDetails = peg$computePosDetails(endPos);\n\n return {\n source: peg$source,\n start: {\n offset: startPos,\n line: startPosDetails.line,\n column: startPosDetails.column\n },\n end: {\n offset: endPos,\n line: endPosDetails.line,\n column: endPosDetails.column\n }\n };\n }\n\n function peg$fail(expected) {\n if (peg$currPos < peg$maxFailPos) { return; }\n\n if (peg$currPos > peg$maxFailPos) {\n peg$maxFailPos = peg$currPos;\n peg$maxFailExpected = [];\n }\n\n peg$maxFailExpected.push(expected);\n }\n\n function peg$buildSimpleError(message, location) {\n return new peg$SyntaxError(message, null, null, location);\n }\n\n function peg$buildStructuredError(expected, found, location) {\n return new peg$SyntaxError(\n peg$SyntaxError.buildMessage(expected, found),\n expected,\n found,\n location\n );\n }\n\n function peg$parsebody() {\n var s0, s1, s2;\n\n s0 = peg$currPos;\n s1 = [];\n s2 = peg$parsetriple_ligature();\n if (s2 === peg$FAILED) {\n s2 = peg$parsedouble_ligature();\n if (s2 === peg$FAILED) {\n s2 = peg$parsemono_ligature();\n if (s2 === peg$FAILED) {\n if (input.length > peg$currPos) {\n s2 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s2 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e0); }\n }\n }\n }\n }\n if (s2 !== peg$FAILED) {\n while (s2 !== peg$FAILED) {\n s1.push(s2);\n s2 = peg$parsetriple_ligature();\n if (s2 === peg$FAILED) {\n s2 = peg$parsedouble_ligature();\n if (s2 === peg$FAILED) {\n s2 = peg$parsemono_ligature();\n if (s2 === peg$FAILED) {\n if (input.length > peg$currPos) {\n s2 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s2 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e0); }\n }\n }\n }\n }\n }\n } else {\n s1 = peg$FAILED;\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = s0;\n s1 = peg$f0(s1);\n }\n s0 = s1;\n if (s0 === peg$FAILED) {\n s0 = peg$currPos;\n s1 = peg$parseEOL();\n if (s1 !== peg$FAILED) {\n peg$savedPos = s0;\n s1 = peg$f1();\n }\n s0 = s1;\n }\n\n return s0;\n }\n\n function peg$parsetriple_ligature() {\n var s0, s1, s2, s3, s4;\n\n s0 = peg$currPos;\n s1 = peg$currPos;\n if (input.length > peg$currPos) {\n s2 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s2 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e0); }\n }\n if (s2 !== peg$FAILED) {\n if (input.length > peg$currPos) {\n s3 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s3 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e0); }\n }\n if (s3 !== peg$FAILED) {\n if (input.length > peg$currPos) {\n s4 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s4 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e0); }\n }\n if (s4 !== peg$FAILED) {\n s2 = [s2, s3, s4];\n s1 = s2;\n } else {\n peg$currPos = s1;\n s1 = peg$FAILED;\n }\n } else {\n peg$currPos = s1;\n s1 = peg$FAILED;\n }\n } else {\n peg$currPos = s1;\n s1 = peg$FAILED;\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f2(s1);\n if (s2) {\n s2 = undefined;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f3(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n\n return s0;\n }\n\n function peg$parsedouble_ligature() {\n var s0;\n\n s0 = peg$parsedouble_macro_ligature();\n if (s0 === peg$FAILED) {\n s0 = peg$parsedouble_macro_ligature_extracted();\n if (s0 === peg$FAILED) {\n s0 = peg$parsedouble_char_ligature();\n }\n }\n\n return s0;\n }\n\n function peg$parsedouble_macro_ligature_extracted() {\n var s0, s1, s2, s3, s4;\n\n s0 = peg$currPos;\n s1 = peg$parsemacro();\n if (s1 !== peg$FAILED) {\n s2 = [];\n s3 = peg$parsewhitespace();\n while (s3 !== peg$FAILED) {\n s2.push(s3);\n s3 = peg$parsewhitespace();\n }\n s3 = peg$parsesplitable();\n if (s3 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s4 = peg$f4(s1, s3);\n if (s4) {\n s4 = undefined;\n } else {\n s4 = peg$FAILED;\n }\n if (s4 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f5(s1, s3);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n\n return s0;\n }\n\n function peg$parsedouble_macro_ligature() {\n var s0, s1, s2, s3, s4;\n\n s0 = peg$currPos;\n s1 = peg$parsemacro();\n if (s1 !== peg$FAILED) {\n s2 = [];\n s3 = peg$parsewhitespace();\n while (s3 !== peg$FAILED) {\n s2.push(s3);\n s3 = peg$parsewhitespace();\n }\n if (input.length > peg$currPos) {\n s3 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s3 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e0); }\n }\n if (s3 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s4 = peg$f6(s1, s3);\n if (s4) {\n s4 = undefined;\n } else {\n s4 = peg$FAILED;\n }\n if (s4 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f7(s1, s3);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n\n return s0;\n }\n\n function peg$parsedouble_char_ligature() {\n var s0, s1, s2, s3;\n\n s0 = peg$currPos;\n s1 = peg$currPos;\n if (input.length > peg$currPos) {\n s2 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s2 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e0); }\n }\n if (s2 !== peg$FAILED) {\n if (input.length > peg$currPos) {\n s3 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s3 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e0); }\n }\n if (s3 !== peg$FAILED) {\n s2 = [s2, s3];\n s1 = s2;\n } else {\n peg$currPos = s1;\n s1 = peg$FAILED;\n }\n } else {\n peg$currPos = s1;\n s1 = peg$FAILED;\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f8(s1);\n if (s2) {\n s2 = undefined;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f9(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n\n return s0;\n }\n\n function peg$parsemono_ligature() {\n var s0, s1, s2;\n\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e0); }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f10(s1);\n if (s2) {\n s2 = undefined;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f11(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n\n return s0;\n }\n\n function peg$parsemacro() {\n var s0, s1, s2;\n\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e0); }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f12(s1);\n if (s2) {\n s2 = undefined;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f13(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n\n return s0;\n }\n\n function peg$parsewhitespace() {\n var s0, s1, s2;\n\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e0); }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f14(s1);\n if (s2) {\n s2 = undefined;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f15(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n\n return s0;\n }\n\n function peg$parsesplitable() {\n var s0, s1, s2;\n\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e0); }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f16(s1);\n if (s2) {\n s2 = undefined;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f17(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n\n return s0;\n }\n\n function peg$parseEOL() {\n var s0, s1;\n\n s0 = peg$currPos;\n peg$silentFails++;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e0); }\n }\n peg$silentFails--;\n if (s1 === peg$FAILED) {\n s0 = undefined;\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n\n return s0;\n }\n\n\n //\n // These are compatability functions used when running in the browser\n //\n // Check if the `options` object has the functions that we need.\n // If not, try to add them\n if (!options.isWhitespace) {\n try {\n Object.assign(options, {\n isMacro: (node) => node.type === \"macro\",\n isWhitespace: (node) => node.type === \"whitespace\",\n isRecognized: (nodes) => {\n if (\n nodes.length == 2 &&\n nodes[0].content === \"^\" &&\n nodes[1].content === \"o\"\n ) {\n return { type: \"string\", content: \"\u00F4\" };\n }\n\n return null;\n },\n isSplitable: (node) =>\n node.type === \"string\" && node.content.length > 1,\n split: (node) => [\n { type: \"string\", content: node.content.charAt(0) },\n { type: \"string\", content: node.content.slice(1) },\n ],\n });\n } catch (e) {\n console.warn(\"Error when initializing parser\", e);\n }\n }\n\n peg$result = peg$startRuleFunction();\n\n if (peg$result !== peg$FAILED && peg$currPos === input.length) {\n return peg$result;\n } else {\n if (peg$result !== peg$FAILED && peg$currPos < input.length) {\n peg$fail(peg$endExpectation());\n }\n\n throw peg$buildStructuredError(\n peg$maxFailExpected,\n peg$maxFailPos < input.length ? input.charAt(peg$maxFailPos) : null,\n peg$maxFailPos < input.length\n ? peg$computeLocation(peg$maxFailPos, peg$maxFailPos + 1)\n : peg$computeLocation(peg$maxFailPos, peg$maxFailPos)\n );\n }\n}\n\n return {\n SyntaxError: peg$SyntaxError,\n parse: peg$parse\n };\n})()\n", "export default // Generated by Peggy 2.0.1.\n//\n// https://peggyjs.org/\n(function() {\n \"use strict\";\n\nfunction peg$subclass(child, parent) {\n function C() { this.constructor = child; }\n C.prototype = parent.prototype;\n child.prototype = new C();\n}\n\nfunction peg$SyntaxError(message, expected, found, location) {\n var self = Error.call(this, message);\n // istanbul ignore next Check is a necessary evil to support older environments\n if (Object.setPrototypeOf) {\n Object.setPrototypeOf(self, peg$SyntaxError.prototype);\n }\n self.expected = expected;\n self.found = found;\n self.location = location;\n self.name = \"SyntaxError\";\n return self;\n}\n\npeg$subclass(peg$SyntaxError, Error);\n\nfunction peg$padEnd(str, targetLength, padString) {\n padString = padString || \" \";\n if (str.length > targetLength) { return str; }\n targetLength -= str.length;\n padString += padString.repeat(targetLength);\n return str + padString.slice(0, targetLength);\n}\n\npeg$SyntaxError.prototype.format = function(sources) {\n var str = \"Error: \" + this.message;\n if (this.location) {\n var src = null;\n var k;\n for (k = 0; k < sources.length; k++) {\n if (sources[k].source === this.location.source) {\n src = sources[k].text.split(/\\r\\n|\\n|\\r/g);\n break;\n }\n }\n var s = this.location.start;\n var loc = this.location.source + \":\" + s.line + \":\" + s.column;\n if (src) {\n var e = this.location.end;\n var filler = peg$padEnd(\"\", s.line.toString().length, ' ');\n var line = src[s.line - 1];\n var last = s.line === e.line ? e.column : line.length + 1;\n var hatLen = (last - s.column) || 1;\n str += \"\\n --> \" + loc + \"\\n\"\n + filler + \" |\\n\"\n + s.line + \" | \" + line + \"\\n\"\n + filler + \" | \" + peg$padEnd(\"\", s.column - 1, ' ')\n + peg$padEnd(\"\", hatLen, \"^\");\n } else {\n str += \"\\n at \" + loc;\n }\n }\n return str;\n};\n\npeg$SyntaxError.buildMessage = function(expected, found) {\n var DESCRIBE_EXPECTATION_FNS = {\n literal: function(expectation) {\n return \"\\\"\" + literalEscape(expectation.text) + \"\\\"\";\n },\n\n class: function(expectation) {\n var escapedParts = expectation.parts.map(function(part) {\n return Array.isArray(part)\n ? classEscape(part[0]) + \"-\" + classEscape(part[1])\n : classEscape(part);\n });\n\n return \"[\" + (expectation.inverted ? \"^\" : \"\") + escapedParts.join(\"\") + \"]\";\n },\n\n any: function() {\n return \"any character\";\n },\n\n end: function() {\n return \"end of input\";\n },\n\n other: function(expectation) {\n return expectation.description;\n }\n };\n\n function hex(ch) {\n return ch.charCodeAt(0).toString(16).toUpperCase();\n }\n\n function literalEscape(s) {\n return s\n .replace(/\\\\/g, \"\\\\\\\\\")\n .replace(/\"/g, \"\\\\\\\"\")\n .replace(/\\0/g, \"\\\\0\")\n .replace(/\\t/g, \"\\\\t\")\n .replace(/\\n/g, \"\\\\n\")\n .replace(/\\r/g, \"\\\\r\")\n .replace(/[\\x00-\\x0F]/g, function(ch) { return \"\\\\x0\" + hex(ch); })\n .replace(/[\\x10-\\x1F\\x7F-\\x9F]/g, function(ch) { return \"\\\\x\" + hex(ch); });\n }\n\n function classEscape(s) {\n return s\n .replace(/\\\\/g, \"\\\\\\\\\")\n .replace(/\\]/g, \"\\\\]\")\n .replace(/\\^/g, \"\\\\^\")\n .replace(/-/g, \"\\\\-\")\n .replace(/\\0/g, \"\\\\0\")\n .replace(/\\t/g, \"\\\\t\")\n .replace(/\\n/g, \"\\\\n\")\n .replace(/\\r/g, \"\\\\r\")\n .replace(/[\\x00-\\x0F]/g, function(ch) { return \"\\\\x0\" + hex(ch); })\n .replace(/[\\x10-\\x1F\\x7F-\\x9F]/g, function(ch) { return \"\\\\x\" + hex(ch); });\n }\n\n function describeExpectation(expectation) {\n return DESCRIBE_EXPECTATION_FNS[expectation.type](expectation);\n }\n\n function describeExpected(expected) {\n var descriptions = expected.map(describeExpectation);\n var i, j;\n\n descriptions.sort();\n\n if (descriptions.length > 0) {\n for (i = 1, j = 1; i < descriptions.length; i++) {\n if (descriptions[i - 1] !== descriptions[i]) {\n descriptions[j] = descriptions[i];\n j++;\n }\n }\n descriptions.length = j;\n }\n\n switch (descriptions.length) {\n case 1:\n return descriptions[0];\n\n case 2:\n return descriptions[0] + \" or \" + descriptions[1];\n\n default:\n return descriptions.slice(0, -1).join(\", \")\n + \", or \"\n + descriptions[descriptions.length - 1];\n }\n }\n\n function describeFound(found) {\n return found ? \"\\\"\" + literalEscape(found) + \"\\\"\" : \"end of input\";\n }\n\n return \"Expected \" + describeExpected(expected) + \" but \" + describeFound(found) + \" found.\";\n};\n\nfunction peg$parse(input, options) {\n options = options !== undefined ? options : {};\n\n var peg$FAILED = {};\n var peg$source = options.grammarSource;\n\n var peg$startRuleFunctions = { start: peg$parsestart };\n var peg$startRuleFunction = peg$parsestart;\n\n var peg$c0 = \";\";\n var peg$c1 = \",\";\n var peg$c2 = \":\";\n var peg$c3 = \"/\";\n var peg$c4 = \">\";\n var peg$c5 = \"!\";\n var peg$c6 = \".\";\n var peg$c7 = \"!![\";\n var peg$c8 = \"]\";\n var peg$c9 = \"!!\";\n var peg$c10 = \"+\";\n var peg$c11 = \"-\";\n\n var peg$r0 = /^[a-zA-Z0-9]/;\n var peg$r1 = /^[0-9]/;\n var peg$r2 = /^[ \\t\\n\\r]/;\n var peg$r3 = /^[0-9a-fA-F]/;\n\n var peg$e0 = peg$anyExpectation();\n var peg$e1 = peg$literalExpectation(\";\", false);\n var peg$e2 = peg$literalExpectation(\",\", false);\n var peg$e3 = peg$otherExpectation(\"model list\");\n var peg$e4 = peg$literalExpectation(\":\", false);\n var peg$e5 = peg$literalExpectation(\"/\", false);\n var peg$e6 = peg$otherExpectation(\"model\");\n var peg$e7 = peg$otherExpectation(\"color spec list\");\n var peg$e8 = peg$otherExpectation(\"color spec\");\n var peg$e9 = peg$otherExpectation(\"color\");\n var peg$e10 = peg$otherExpectation(\"function expression\");\n var peg$e11 = peg$literalExpectation(\">\", false);\n var peg$e12 = peg$otherExpectation(\"function\");\n var peg$e13 = peg$otherExpectation(\"extended expression\");\n var peg$e14 = peg$otherExpectation(\"core model\");\n var peg$e15 = peg$otherExpectation(\"expr\");\n var peg$e16 = peg$literalExpectation(\"!\", false);\n var peg$e17 = peg$otherExpectation(\"mix expr\");\n var peg$e18 = peg$otherExpectation(\"name\");\n var peg$e19 = peg$literalExpectation(\".\", false);\n var peg$e20 = peg$classExpectation([[\"a\", \"z\"], [\"A\", \"Z\"], [\"0\", \"9\"]], false, false);\n var peg$e21 = peg$otherExpectation(\"postfix\");\n var peg$e22 = peg$literalExpectation(\"!![\", false);\n var peg$e23 = peg$literalExpectation(\"]\", false);\n var peg$e24 = peg$literalExpectation(\"!!\", false);\n var peg$e25 = peg$otherExpectation(\"prefix\");\n var peg$e26 = peg$otherExpectation(\"plus\");\n var peg$e27 = peg$literalExpectation(\"+\", false);\n var peg$e28 = peg$otherExpectation(\"minus\");\n var peg$e29 = peg$literalExpectation(\"-\", false);\n var peg$e30 = peg$otherExpectation(\"num\");\n var peg$e31 = peg$classExpectation([[\"0\", \"9\"]], false, false);\n var peg$e32 = peg$otherExpectation(\"positive float\");\n var peg$e33 = peg$otherExpectation(\"divisor\");\n var peg$e34 = peg$otherExpectation(\"int\");\n var peg$e35 = peg$otherExpectation(\"whitespace\");\n var peg$e36 = peg$classExpectation([\" \", \"\\t\", \"\\n\", \"\\r\"], false, false);\n var peg$e37 = peg$classExpectation([[\"0\", \"9\"], [\"a\", \"f\"], [\"A\", \"F\"]], false, false);\n\n var peg$f0 = function(m) { return m; };\n var peg$f1 = function(m) { return m; };\n var peg$f2 = function(m) { return m; };\n var peg$f3 = function(m) { return m; };\n var peg$f4 = function(m) { return m; };\n var peg$f5 = function(a) { return { type: \"invalid_spec\", content: a }; };\n var peg$f6 = function(f, c) { return c; };\n var peg$f7 = function(f, r) {\n return { type: \"color_set\", content: [f].concat(r) };\n };\n var peg$f8 = function(n, s) {\n return { type: \"color_set_item\", name: n, spec_list: s };\n };\n var peg$f9 = function(c, m) {\n return { type: \"model_list\", contents: m, core_model: c };\n };\n var peg$f10 = function(m) {\n return { type: \"model_list\", contents: m, core_model: null };\n };\n var peg$f11 = function(m, a) { return a; };\n var peg$f12 = function(m, r) { return [m].concat(r); };\n var peg$f13 = function(s, a) { return a; };\n var peg$f14 = function(s, r) {\n return { type: \"spec_list\", content: [s].concat(r) };\n };\n var peg$f15 = function(c) {\n return { type: \"hex_spec\", content: [c] };\n };\n var peg$f16 = function(c, d) { return d; };\n var peg$f17 = function(c, d) { return d; };\n var peg$f18 = function(c, r) {\n return { type: \"num_spec\", content: r ? [c].concat(r) : [c] };\n };\n var peg$f19 = function(c, fs) {\n return { type: \"color\", color: c, functions: fs };\n };\n var peg$f20 = function(f, n) { return n; };\n var peg$f21 = function(f, args) {\n return { type: \"function\", name: f, args };\n };\n var peg$f22 = function(core, d, e, es) {\n return {\n type: \"extended_expr\",\n core_model: core,\n div: d,\n expressions: [e].concat(es),\n };\n };\n var peg$f23 = function(core, e, es) {\n return {\n type: \"extended_expr\",\n core_model: core,\n div: null,\n expressions: [e].concat(es),\n };\n };\n var peg$f24 = function(e, d) {\n return { type: \"weighted_expr\", color: e, weight: d };\n };\n var peg$f25 = function(e) { return e; };\n var peg$f26 = function(p, n, e, po) {\n return {\n type: \"expr\",\n prefix: p,\n name: n,\n mix_expr: e,\n postfix: po,\n };\n };\n var peg$f27 = function(p, n) {\n return { type: \"complete_mix\", mix_percent: p, name: n };\n };\n var peg$f28 = function(p) { return { type: \"partial_mix\", mix_percent: p }; };\n var peg$f29 = function(c, p) { return c.concat(p || []); };\n var peg$f30 = function(n) { return { type: \"postfix\", num: n }; };\n var peg$f31 = function(p) { return { type: \"postfix\", plusses: p }; };\n var peg$f32 = function(n) { return parseInt(n, 10); };\n var peg$f33 = function(n) { return parseFloat(n); };\n var peg$f34 = function(n) { return n; };\n var peg$f35 = function(n) { return -n; };\n var peg$f36 = function(m, n) { return m ? -n : n; };\n var peg$f37 = function(h) { return h.toUpperCase(); };\n var peg$currPos = 0;\n var peg$savedPos = 0;\n var peg$posDetailsCache = [{ line: 1, column: 1 }];\n var peg$maxFailPos = 0;\n var peg$maxFailExpected = [];\n var peg$silentFails = 0;\n\n var peg$result;\n\n if (\"startRule\" in options) {\n if (!(options.startRule in peg$startRuleFunctions)) {\n throw new Error(\"Can't start parsing from rule \\\"\" + options.startRule + \"\\\".\");\n }\n\n peg$startRuleFunction = peg$startRuleFunctions[options.startRule];\n }\n\n function text() {\n return input.substring(peg$savedPos, peg$currPos);\n }\n\n function offset() {\n return peg$savedPos;\n }\n\n function range() {\n return {\n source: peg$source,\n start: peg$savedPos,\n end: peg$currPos\n };\n }\n\n function location() {\n return peg$computeLocation(peg$savedPos, peg$currPos);\n }\n\n function expected(description, location) {\n location = location !== undefined\n ? location\n : peg$computeLocation(peg$savedPos, peg$currPos);\n\n throw peg$buildStructuredError(\n [peg$otherExpectation(description)],\n input.substring(peg$savedPos, peg$currPos),\n location\n );\n }\n\n function error(message, location) {\n location = location !== undefined\n ? location\n : peg$computeLocation(peg$savedPos, peg$currPos);\n\n throw peg$buildSimpleError(message, location);\n }\n\n function peg$literalExpectation(text, ignoreCase) {\n return { type: \"literal\", text: text, ignoreCase: ignoreCase };\n }\n\n function peg$classExpectation(parts, inverted, ignoreCase) {\n return { type: \"class\", parts: parts, inverted: inverted, ignoreCase: ignoreCase };\n }\n\n function peg$anyExpectation() {\n return { type: \"any\" };\n }\n\n function peg$endExpectation() {\n return { type: \"end\" };\n }\n\n function peg$otherExpectation(description) {\n return { type: \"other\", description: description };\n }\n\n function peg$computePosDetails(pos) {\n var details = peg$posDetailsCache[pos];\n var p;\n\n if (details) {\n return details;\n } else {\n p = pos - 1;\n while (!peg$posDetailsCache[p]) {\n p--;\n }\n\n details = peg$posDetailsCache[p];\n details = {\n line: details.line,\n column: details.column\n };\n\n while (p < pos) {\n if (input.charCodeAt(p) === 10) {\n details.line++;\n details.column = 1;\n } else {\n details.column++;\n }\n\n p++;\n }\n\n peg$posDetailsCache[pos] = details;\n\n return details;\n }\n }\n\n function peg$computeLocation(startPos, endPos) {\n var startPosDetails = peg$computePosDetails(startPos);\n var endPosDetails = peg$computePosDetails(endPos);\n\n return {\n source: peg$source,\n start: {\n offset: startPos,\n line: startPosDetails.line,\n column: startPosDetails.column\n },\n end: {\n offset: endPos,\n line: endPosDetails.line,\n column: endPosDetails.column\n }\n };\n }\n\n function peg$fail(expected) {\n if (peg$currPos < peg$maxFailPos) { return; }\n\n if (peg$currPos > peg$maxFailPos) {\n peg$maxFailPos = peg$currPos;\n peg$maxFailExpected = [];\n }\n\n peg$maxFailExpected.push(expected);\n }\n\n function peg$buildSimpleError(message, location) {\n return new peg$SyntaxError(message, null, null, location);\n }\n\n function peg$buildStructuredError(expected, found, location) {\n return new peg$SyntaxError(\n peg$SyntaxError.buildMessage(expected, found),\n expected,\n found,\n location\n );\n }\n\n function peg$parsestart() {\n var s0, s1, s2, s3;\n\n s0 = peg$currPos;\n s1 = peg$parsespec();\n if (s1 !== peg$FAILED) {\n s2 = peg$parseEOL();\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f0(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n if (s0 === peg$FAILED) {\n s0 = peg$currPos;\n s1 = peg$parsespec_list();\n if (s1 !== peg$FAILED) {\n s2 = peg$parseEOL();\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f1(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n if (s0 === peg$FAILED) {\n s0 = peg$currPos;\n s1 = peg$parsecolor();\n if (s1 !== peg$FAILED) {\n s2 = peg$parseEOL();\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f2(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n if (s0 === peg$FAILED) {\n s0 = peg$currPos;\n s1 = peg$parsemodel_list();\n if (s1 !== peg$FAILED) {\n s2 = peg$parseEOL();\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f3(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n if (s0 === peg$FAILED) {\n s0 = peg$currPos;\n s1 = peg$parsecolor_set_spec();\n if (s1 !== peg$FAILED) {\n s2 = peg$parseEOL();\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f4(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n if (s0 === peg$FAILED) {\n s0 = peg$currPos;\n s1 = peg$currPos;\n s2 = [];\n if (input.length > peg$currPos) {\n s3 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s3 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e0); }\n }\n while (s3 !== peg$FAILED) {\n s2.push(s3);\n if (input.length > peg$currPos) {\n s3 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s3 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e0); }\n }\n }\n s1 = input.substring(s1, peg$currPos);\n peg$savedPos = s0;\n s1 = peg$f5(s1);\n s0 = s1;\n }\n }\n }\n }\n }\n\n return s0;\n }\n\n function peg$parsecolor_set_spec() {\n var s0, s1, s2, s3, s4, s5;\n\n s0 = peg$currPos;\n s1 = peg$parsecolor_set_item();\n if (s1 !== peg$FAILED) {\n s2 = [];\n s3 = peg$currPos;\n if (input.charCodeAt(peg$currPos) === 59) {\n s4 = peg$c0;\n peg$currPos++;\n } else {\n s4 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e1); }\n }\n if (s4 !== peg$FAILED) {\n s5 = peg$parsecolor_set_item();\n if (s5 !== peg$FAILED) {\n peg$savedPos = s3;\n s3 = peg$f6(s1, s5);\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n while (s3 !== peg$FAILED) {\n s2.push(s3);\n s3 = peg$currPos;\n if (input.charCodeAt(peg$currPos) === 59) {\n s4 = peg$c0;\n peg$currPos++;\n } else {\n s4 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e1); }\n }\n if (s4 !== peg$FAILED) {\n s5 = peg$parsecolor_set_item();\n if (s5 !== peg$FAILED) {\n peg$savedPos = s3;\n s3 = peg$f6(s1, s5);\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n }\n peg$savedPos = s0;\n s0 = peg$f7(s1, s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n\n return s0;\n }\n\n function peg$parsecolor_set_item() {\n var s0, s1, s2, s3;\n\n s0 = peg$currPos;\n s1 = peg$parsename();\n if (s1 !== peg$FAILED) {\n if (input.charCodeAt(peg$currPos) === 44) {\n s2 = peg$c1;\n peg$currPos++;\n } else {\n s2 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e2); }\n }\n if (s2 !== peg$FAILED) {\n s3 = peg$parsespec_list();\n if (s3 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f8(s1, s3);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n\n return s0;\n }\n\n function peg$parsemodel_list() {\n var s0, s1, s2, s3;\n\n peg$silentFails++;\n s0 = peg$currPos;\n s1 = peg$parsecore_model();\n if (s1 !== peg$FAILED) {\n if (input.charCodeAt(peg$currPos) === 58) {\n s2 = peg$c2;\n peg$currPos++;\n } else {\n s2 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e4); }\n }\n if (s2 !== peg$FAILED) {\n s3 = peg$parsemodel_list_tail();\n if (s3 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f9(s1, s3);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n if (s0 === peg$FAILED) {\n s0 = peg$currPos;\n s1 = peg$parsemodel_list_tail();\n if (s1 !== peg$FAILED) {\n peg$savedPos = s0;\n s1 = peg$f10(s1);\n }\n s0 = s1;\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e3); }\n }\n\n return s0;\n }\n\n function peg$parsemodel_list_tail() {\n var s0, s1, s2, s3, s4, s5;\n\n s0 = peg$currPos;\n s1 = peg$parsemodel();\n if (s1 !== peg$FAILED) {\n s2 = [];\n s3 = peg$currPos;\n if (input.charCodeAt(peg$currPos) === 47) {\n s4 = peg$c3;\n peg$currPos++;\n } else {\n s4 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e5); }\n }\n if (s4 !== peg$FAILED) {\n s5 = peg$parsemodel();\n if (s5 !== peg$FAILED) {\n peg$savedPos = s3;\n s3 = peg$f11(s1, s5);\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n while (s3 !== peg$FAILED) {\n s2.push(s3);\n s3 = peg$currPos;\n if (input.charCodeAt(peg$currPos) === 47) {\n s4 = peg$c3;\n peg$currPos++;\n } else {\n s4 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e5); }\n }\n if (s4 !== peg$FAILED) {\n s5 = peg$parsemodel();\n if (s5 !== peg$FAILED) {\n peg$savedPos = s3;\n s3 = peg$f11(s1, s5);\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n }\n peg$savedPos = s0;\n s0 = peg$f12(s1, s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n\n return s0;\n }\n\n function peg$parsemodel() {\n var s0, s1;\n\n peg$silentFails++;\n s0 = peg$parsecore_model();\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e6); }\n }\n\n return s0;\n }\n\n function peg$parsespec_list() {\n var s0, s1, s2, s3, s4, s5;\n\n peg$silentFails++;\n s0 = peg$currPos;\n s1 = peg$parsespec();\n if (s1 !== peg$FAILED) {\n s2 = [];\n s3 = peg$currPos;\n if (input.charCodeAt(peg$currPos) === 47) {\n s4 = peg$c3;\n peg$currPos++;\n } else {\n s4 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e5); }\n }\n if (s4 !== peg$FAILED) {\n s5 = peg$parsespec();\n if (s5 !== peg$FAILED) {\n peg$savedPos = s3;\n s3 = peg$f13(s1, s5);\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n while (s3 !== peg$FAILED) {\n s2.push(s3);\n s3 = peg$currPos;\n if (input.charCodeAt(peg$currPos) === 47) {\n s4 = peg$c3;\n peg$currPos++;\n } else {\n s4 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e5); }\n }\n if (s4 !== peg$FAILED) {\n s5 = peg$parsespec();\n if (s5 !== peg$FAILED) {\n peg$savedPos = s3;\n s3 = peg$f13(s1, s5);\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n }\n peg$savedPos = s0;\n s0 = peg$f14(s1, s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e7); }\n }\n\n return s0;\n }\n\n function peg$parsespec() {\n var s0, s1, s2, s3, s4, s5, s6, s7, s8;\n\n peg$silentFails++;\n s0 = peg$currPos;\n s1 = peg$currPos;\n s2 = peg$currPos;\n s3 = peg$parsehex();\n if (s3 !== peg$FAILED) {\n s4 = peg$parsehex();\n if (s4 !== peg$FAILED) {\n s5 = peg$parsehex();\n if (s5 !== peg$FAILED) {\n s6 = peg$parsehex();\n if (s6 !== peg$FAILED) {\n s7 = peg$parsehex();\n if (s7 !== peg$FAILED) {\n s8 = peg$parsehex();\n if (s8 !== peg$FAILED) {\n s3 = [s3, s4, s5, s6, s7, s8];\n s2 = s3;\n } else {\n peg$currPos = s2;\n s2 = peg$FAILED;\n }\n } else {\n peg$currPos = s2;\n s2 = peg$FAILED;\n }\n } else {\n peg$currPos = s2;\n s2 = peg$FAILED;\n }\n } else {\n peg$currPos = s2;\n s2 = peg$FAILED;\n }\n } else {\n peg$currPos = s2;\n s2 = peg$FAILED;\n }\n } else {\n peg$currPos = s2;\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n s1 = input.substring(s1, peg$currPos);\n } else {\n s1 = s2;\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = s0;\n s1 = peg$f15(s1);\n }\n s0 = s1;\n if (s0 === peg$FAILED) {\n s0 = peg$currPos;\n s1 = peg$parsedec();\n if (s1 !== peg$FAILED) {\n s2 = [];\n s3 = peg$currPos;\n if (input.charCodeAt(peg$currPos) === 44) {\n s4 = peg$c1;\n peg$currPos++;\n } else {\n s4 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e2); }\n }\n if (s4 !== peg$FAILED) {\n s5 = peg$parsedec();\n if (s5 !== peg$FAILED) {\n peg$savedPos = s3;\n s3 = peg$f16(s1, s5);\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n if (s3 !== peg$FAILED) {\n while (s3 !== peg$FAILED) {\n s2.push(s3);\n s3 = peg$currPos;\n if (input.charCodeAt(peg$currPos) === 44) {\n s4 = peg$c1;\n peg$currPos++;\n } else {\n s4 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e2); }\n }\n if (s4 !== peg$FAILED) {\n s5 = peg$parsedec();\n if (s5 !== peg$FAILED) {\n peg$savedPos = s3;\n s3 = peg$f16(s1, s5);\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n }\n } else {\n s2 = peg$FAILED;\n }\n if (s2 === peg$FAILED) {\n s2 = [];\n s3 = peg$currPos;\n s4 = peg$parsesp();\n if (s4 !== peg$FAILED) {\n s5 = peg$parsedec();\n if (s5 !== peg$FAILED) {\n peg$savedPos = s3;\n s3 = peg$f17(s1, s5);\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n if (s3 !== peg$FAILED) {\n while (s3 !== peg$FAILED) {\n s2.push(s3);\n s3 = peg$currPos;\n s4 = peg$parsesp();\n if (s4 !== peg$FAILED) {\n s5 = peg$parsedec();\n if (s5 !== peg$FAILED) {\n peg$savedPos = s3;\n s3 = peg$f17(s1, s5);\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n }\n } else {\n s2 = peg$FAILED;\n }\n }\n if (s2 === peg$FAILED) {\n s2 = null;\n }\n peg$savedPos = s0;\n s0 = peg$f18(s1, s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e8); }\n }\n\n return s0;\n }\n\n function peg$parsecolor() {\n var s0, s1, s2, s3;\n\n peg$silentFails++;\n s0 = peg$currPos;\n s1 = peg$parsecolor_expr();\n if (s1 !== peg$FAILED) {\n s2 = [];\n s3 = peg$parsefunc_expr();\n while (s3 !== peg$FAILED) {\n s2.push(s3);\n s3 = peg$parsefunc_expr();\n }\n peg$savedPos = s0;\n s0 = peg$f19(s1, s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e9); }\n }\n\n return s0;\n }\n\n function peg$parsecolor_expr() {\n var s0;\n\n s0 = peg$parseext_expr();\n if (s0 === peg$FAILED) {\n s0 = peg$parseexpr();\n if (s0 === peg$FAILED) {\n s0 = peg$parsename();\n }\n }\n\n return s0;\n }\n\n function peg$parsefunc_expr() {\n var s0, s1, s2, s3, s4, s5, s6;\n\n peg$silentFails++;\n s0 = peg$currPos;\n if (input.charCodeAt(peg$currPos) === 62) {\n s1 = peg$c4;\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e11); }\n }\n if (s1 !== peg$FAILED) {\n s2 = peg$parsefunction();\n if (s2 !== peg$FAILED) {\n s3 = [];\n s4 = peg$currPos;\n if (input.charCodeAt(peg$currPos) === 44) {\n s5 = peg$c1;\n peg$currPos++;\n } else {\n s5 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e2); }\n }\n if (s5 !== peg$FAILED) {\n s6 = peg$parseint();\n if (s6 !== peg$FAILED) {\n peg$savedPos = s4;\n s4 = peg$f20(s2, s6);\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n while (s4 !== peg$FAILED) {\n s3.push(s4);\n s4 = peg$currPos;\n if (input.charCodeAt(peg$currPos) === 44) {\n s5 = peg$c1;\n peg$currPos++;\n } else {\n s5 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e2); }\n }\n if (s5 !== peg$FAILED) {\n s6 = peg$parseint();\n if (s6 !== peg$FAILED) {\n peg$savedPos = s4;\n s4 = peg$f20(s2, s6);\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n }\n peg$savedPos = s0;\n s0 = peg$f21(s2, s3);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e10); }\n }\n\n return s0;\n }\n\n function peg$parsefunction() {\n var s0, s1;\n\n peg$silentFails++;\n s0 = peg$parsename();\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e12); }\n }\n\n return s0;\n }\n\n function peg$parseext_expr() {\n var s0, s1, s2, s3, s4, s5, s6, s7;\n\n peg$silentFails++;\n s0 = peg$currPos;\n s1 = peg$parsecore_model();\n if (s1 !== peg$FAILED) {\n if (input.charCodeAt(peg$currPos) === 44) {\n s2 = peg$c1;\n peg$currPos++;\n } else {\n s2 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e2); }\n }\n if (s2 !== peg$FAILED) {\n s3 = peg$parsediv();\n if (s3 !== peg$FAILED) {\n if (input.charCodeAt(peg$currPos) === 58) {\n s4 = peg$c2;\n peg$currPos++;\n } else {\n s4 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e4); }\n }\n if (s4 !== peg$FAILED) {\n s5 = peg$parseweighted_expr();\n if (s5 !== peg$FAILED) {\n s6 = [];\n s7 = peg$parseadditional_weighted_expr();\n while (s7 !== peg$FAILED) {\n s6.push(s7);\n s7 = peg$parseadditional_weighted_expr();\n }\n peg$savedPos = s0;\n s0 = peg$f22(s1, s3, s5, s6);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n if (s0 === peg$FAILED) {\n s0 = peg$currPos;\n s1 = peg$parsecore_model();\n if (s1 !== peg$FAILED) {\n if (input.charCodeAt(peg$currPos) === 58) {\n s2 = peg$c2;\n peg$currPos++;\n } else {\n s2 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e4); }\n }\n if (s2 !== peg$FAILED) {\n s3 = peg$parseweighted_expr();\n if (s3 !== peg$FAILED) {\n s4 = [];\n s5 = peg$parseadditional_weighted_expr();\n while (s5 !== peg$FAILED) {\n s4.push(s5);\n s5 = peg$parseadditional_weighted_expr();\n }\n peg$savedPos = s0;\n s0 = peg$f23(s1, s3, s4);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e13); }\n }\n\n return s0;\n }\n\n function peg$parseweighted_expr() {\n var s0, s1, s2, s3;\n\n s0 = peg$currPos;\n s1 = peg$parseexpr();\n if (s1 !== peg$FAILED) {\n if (input.charCodeAt(peg$currPos) === 44) {\n s2 = peg$c1;\n peg$currPos++;\n } else {\n s2 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e2); }\n }\n if (s2 !== peg$FAILED) {\n s3 = peg$parsedec();\n if (s3 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f24(s1, s3);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n\n return s0;\n }\n\n function peg$parseadditional_weighted_expr() {\n var s0, s1, s2;\n\n s0 = peg$currPos;\n if (input.charCodeAt(peg$currPos) === 59) {\n s1 = peg$c0;\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e1); }\n }\n if (s1 !== peg$FAILED) {\n s2 = peg$parseweighted_expr();\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f25(s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n\n return s0;\n }\n\n function peg$parsecore_model() {\n var s0, s1;\n\n peg$silentFails++;\n s0 = peg$parsename();\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e14); }\n }\n\n return s0;\n }\n\n function peg$parseexpr() {\n var s0, s1, s2, s3, s4;\n\n peg$silentFails++;\n s0 = peg$currPos;\n s1 = peg$parseprefix();\n s2 = peg$parsename();\n if (s2 !== peg$FAILED) {\n s3 = peg$parsemix_expr();\n s4 = peg$parsepostfix();\n if (s4 === peg$FAILED) {\n s4 = null;\n }\n peg$savedPos = s0;\n s0 = peg$f26(s1, s2, s3, s4);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e15); }\n }\n\n return s0;\n }\n\n function peg$parsecomplete_mix() {\n var s0, s1, s2, s3, s4;\n\n s0 = peg$currPos;\n if (input.charCodeAt(peg$currPos) === 33) {\n s1 = peg$c5;\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e16); }\n }\n if (s1 !== peg$FAILED) {\n s2 = peg$parsepct();\n if (s2 !== peg$FAILED) {\n if (input.charCodeAt(peg$currPos) === 33) {\n s3 = peg$c5;\n peg$currPos++;\n } else {\n s3 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e16); }\n }\n if (s3 !== peg$FAILED) {\n s4 = peg$parsename();\n if (s4 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f27(s2, s4);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n\n return s0;\n }\n\n function peg$parsepartial_mix() {\n var s0, s1, s2;\n\n s0 = peg$currPos;\n if (input.charCodeAt(peg$currPos) === 33) {\n s1 = peg$c5;\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e16); }\n }\n if (s1 !== peg$FAILED) {\n s2 = peg$parsepct();\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f28(s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n\n return s0;\n }\n\n function peg$parsemix_expr() {\n var s0, s1, s2;\n\n peg$silentFails++;\n s0 = peg$currPos;\n s1 = [];\n s2 = peg$parsecomplete_mix();\n while (s2 !== peg$FAILED) {\n s1.push(s2);\n s2 = peg$parsecomplete_mix();\n }\n s2 = peg$parsepartial_mix();\n if (s2 === peg$FAILED) {\n s2 = null;\n }\n peg$savedPos = s0;\n s0 = peg$f29(s1, s2);\n peg$silentFails--;\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e17); }\n\n return s0;\n }\n\n function peg$parsename() {\n var s0, s1, s2;\n\n peg$silentFails++;\n if (input.charCodeAt(peg$currPos) === 46) {\n s0 = peg$c6;\n peg$currPos++;\n } else {\n s0 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e19); }\n }\n if (s0 === peg$FAILED) {\n s0 = peg$currPos;\n s1 = [];\n if (peg$r0.test(input.charAt(peg$currPos))) {\n s2 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s2 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e20); }\n }\n if (s2 !== peg$FAILED) {\n while (s2 !== peg$FAILED) {\n s1.push(s2);\n if (peg$r0.test(input.charAt(peg$currPos))) {\n s2 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s2 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e20); }\n }\n }\n } else {\n s1 = peg$FAILED;\n }\n if (s1 !== peg$FAILED) {\n s0 = input.substring(s0, peg$currPos);\n } else {\n s0 = s1;\n }\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e18); }\n }\n\n return s0;\n }\n\n function peg$parsepostfix() {\n var s0, s1, s2, s3, s4;\n\n peg$silentFails++;\n s0 = peg$currPos;\n if (input.substr(peg$currPos, 3) === peg$c7) {\n s1 = peg$c7;\n peg$currPos += 3;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e22); }\n }\n if (s1 !== peg$FAILED) {\n s2 = peg$parsenum();\n if (s2 !== peg$FAILED) {\n if (input.charCodeAt(peg$currPos) === 93) {\n s3 = peg$c8;\n peg$currPos++;\n } else {\n s3 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e23); }\n }\n if (s3 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f30(s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n if (s0 === peg$FAILED) {\n s0 = peg$currPos;\n if (input.substr(peg$currPos, 2) === peg$c9) {\n s1 = peg$c9;\n peg$currPos += 2;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e24); }\n }\n if (s1 !== peg$FAILED) {\n s2 = peg$currPos;\n s3 = [];\n s4 = peg$parseplus();\n if (s4 !== peg$FAILED) {\n while (s4 !== peg$FAILED) {\n s3.push(s4);\n s4 = peg$parseplus();\n }\n } else {\n s3 = peg$FAILED;\n }\n if (s3 !== peg$FAILED) {\n s2 = input.substring(s2, peg$currPos);\n } else {\n s2 = s3;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f31(s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e21); }\n }\n\n return s0;\n }\n\n function peg$parseprefix() {\n var s0, s1;\n\n peg$silentFails++;\n s0 = peg$parseminus();\n if (s0 === peg$FAILED) {\n s0 = null;\n }\n peg$silentFails--;\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e25); }\n\n return s0;\n }\n\n function peg$parseplus() {\n var s0, s1, s2;\n\n peg$silentFails++;\n s0 = peg$currPos;\n s1 = [];\n if (input.charCodeAt(peg$currPos) === 43) {\n s2 = peg$c10;\n peg$currPos++;\n } else {\n s2 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e27); }\n }\n if (s2 !== peg$FAILED) {\n while (s2 !== peg$FAILED) {\n s1.push(s2);\n if (input.charCodeAt(peg$currPos) === 43) {\n s2 = peg$c10;\n peg$currPos++;\n } else {\n s2 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e27); }\n }\n }\n } else {\n s1 = peg$FAILED;\n }\n if (s1 !== peg$FAILED) {\n s0 = input.substring(s0, peg$currPos);\n } else {\n s0 = s1;\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e26); }\n }\n\n return s0;\n }\n\n function peg$parseminus() {\n var s0, s1, s2;\n\n peg$silentFails++;\n s0 = peg$currPos;\n s1 = [];\n if (input.charCodeAt(peg$currPos) === 45) {\n s2 = peg$c11;\n peg$currPos++;\n } else {\n s2 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e29); }\n }\n if (s2 !== peg$FAILED) {\n while (s2 !== peg$FAILED) {\n s1.push(s2);\n if (input.charCodeAt(peg$currPos) === 45) {\n s2 = peg$c11;\n peg$currPos++;\n } else {\n s2 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e29); }\n }\n }\n } else {\n s1 = peg$FAILED;\n }\n if (s1 !== peg$FAILED) {\n s0 = input.substring(s0, peg$currPos);\n } else {\n s0 = s1;\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e28); }\n }\n\n return s0;\n }\n\n function peg$parsenum() {\n var s0, s1, s2, s3;\n\n peg$silentFails++;\n s0 = peg$currPos;\n s1 = peg$currPos;\n s2 = [];\n if (peg$r1.test(input.charAt(peg$currPos))) {\n s3 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s3 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e31); }\n }\n if (s3 !== peg$FAILED) {\n while (s3 !== peg$FAILED) {\n s2.push(s3);\n if (peg$r1.test(input.charAt(peg$currPos))) {\n s3 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s3 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e31); }\n }\n }\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n s1 = input.substring(s1, peg$currPos);\n } else {\n s1 = s2;\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = s0;\n s1 = peg$f32(s1);\n }\n s0 = s1;\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e30); }\n }\n\n return s0;\n }\n\n function peg$parsepct() {\n var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;\n\n peg$silentFails++;\n s0 = peg$currPos;\n s1 = peg$currPos;\n s2 = peg$currPos;\n s3 = peg$currPos;\n s4 = [];\n if (peg$r1.test(input.charAt(peg$currPos))) {\n s5 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s5 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e31); }\n }\n if (s5 !== peg$FAILED) {\n while (s5 !== peg$FAILED) {\n s4.push(s5);\n if (peg$r1.test(input.charAt(peg$currPos))) {\n s5 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s5 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e31); }\n }\n }\n } else {\n s4 = peg$FAILED;\n }\n if (s4 !== peg$FAILED) {\n s3 = input.substring(s3, peg$currPos);\n } else {\n s3 = s4;\n }\n if (s3 !== peg$FAILED) {\n s4 = peg$currPos;\n s5 = peg$currPos;\n if (input.charCodeAt(peg$currPos) === 46) {\n s6 = peg$c6;\n peg$currPos++;\n } else {\n s6 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e19); }\n }\n if (s6 !== peg$FAILED) {\n s7 = peg$currPos;\n s8 = [];\n if (peg$r1.test(input.charAt(peg$currPos))) {\n s9 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s9 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e31); }\n }\n while (s9 !== peg$FAILED) {\n s8.push(s9);\n if (peg$r1.test(input.charAt(peg$currPos))) {\n s9 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s9 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e31); }\n }\n }\n s7 = input.substring(s7, peg$currPos);\n s6 = [s6, s7];\n s5 = s6;\n } else {\n peg$currPos = s5;\n s5 = peg$FAILED;\n }\n if (s5 === peg$FAILED) {\n s5 = null;\n }\n s4 = input.substring(s4, peg$currPos);\n s3 = [s3, s4];\n s2 = s3;\n } else {\n peg$currPos = s2;\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n s1 = input.substring(s1, peg$currPos);\n } else {\n s1 = s2;\n }\n if (s1 === peg$FAILED) {\n s1 = peg$currPos;\n s2 = peg$currPos;\n if (input.charCodeAt(peg$currPos) === 46) {\n s3 = peg$c6;\n peg$currPos++;\n } else {\n s3 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e19); }\n }\n if (s3 !== peg$FAILED) {\n s4 = peg$currPos;\n s5 = [];\n if (peg$r1.test(input.charAt(peg$currPos))) {\n s6 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s6 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e31); }\n }\n if (s6 !== peg$FAILED) {\n while (s6 !== peg$FAILED) {\n s5.push(s6);\n if (peg$r1.test(input.charAt(peg$currPos))) {\n s6 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s6 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e31); }\n }\n }\n } else {\n s5 = peg$FAILED;\n }\n if (s5 !== peg$FAILED) {\n s4 = input.substring(s4, peg$currPos);\n } else {\n s4 = s5;\n }\n if (s4 !== peg$FAILED) {\n s3 = [s3, s4];\n s2 = s3;\n } else {\n peg$currPos = s2;\n s2 = peg$FAILED;\n }\n } else {\n peg$currPos = s2;\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n s1 = input.substring(s1, peg$currPos);\n } else {\n s1 = s2;\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = s0;\n s1 = peg$f33(s1);\n }\n s0 = s1;\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e32); }\n }\n\n return s0;\n }\n\n function peg$parsediv() {\n var s0, s1;\n\n peg$silentFails++;\n s0 = peg$parsepct();\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e33); }\n }\n\n return s0;\n }\n\n function peg$parsedec() {\n var s0, s1, s2;\n\n s0 = peg$parsepct();\n if (s0 === peg$FAILED) {\n s0 = peg$currPos;\n if (input.charCodeAt(peg$currPos) === 43) {\n s1 = peg$c10;\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e27); }\n }\n if (s1 !== peg$FAILED) {\n s2 = peg$parsepct();\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f34(s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n if (s0 === peg$FAILED) {\n s0 = peg$currPos;\n if (input.charCodeAt(peg$currPos) === 45) {\n s1 = peg$c11;\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e29); }\n }\n if (s1 !== peg$FAILED) {\n s2 = peg$parsepct();\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f35(s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n }\n }\n\n return s0;\n }\n\n function peg$parseint() {\n var s0, s1, s2;\n\n peg$silentFails++;\n s0 = peg$currPos;\n s1 = peg$parseminus();\n if (s1 === peg$FAILED) {\n s1 = null;\n }\n s2 = peg$parsenum();\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f36(s1, s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e34); }\n }\n\n return s0;\n }\n\n function peg$parse_() {\n var s0, s1;\n\n peg$silentFails++;\n s0 = [];\n if (peg$r2.test(input.charAt(peg$currPos))) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e36); }\n }\n while (s1 !== peg$FAILED) {\n s0.push(s1);\n if (peg$r2.test(input.charAt(peg$currPos))) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e36); }\n }\n }\n peg$silentFails--;\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e35); }\n\n return s0;\n }\n\n function peg$parsesp() {\n var s0, s1;\n\n s0 = [];\n if (peg$r2.test(input.charAt(peg$currPos))) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e36); }\n }\n if (s1 !== peg$FAILED) {\n while (s1 !== peg$FAILED) {\n s0.push(s1);\n if (peg$r2.test(input.charAt(peg$currPos))) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e36); }\n }\n }\n } else {\n s0 = peg$FAILED;\n }\n\n return s0;\n }\n\n function peg$parsehex() {\n var s0, s1;\n\n s0 = peg$currPos;\n if (peg$r3.test(input.charAt(peg$currPos))) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e37); }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = s0;\n s1 = peg$f37(s1);\n }\n s0 = s1;\n\n return s0;\n }\n\n function peg$parseEOL() {\n var s0, s1;\n\n s0 = peg$currPos;\n peg$silentFails++;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e0); }\n }\n peg$silentFails--;\n if (s1 === peg$FAILED) {\n s0 = undefined;\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n\n return s0;\n }\n\n peg$result = peg$startRuleFunction();\n\n if (peg$result !== peg$FAILED && peg$currPos === input.length) {\n return peg$result;\n } else {\n if (peg$result !== peg$FAILED && peg$currPos < input.length) {\n peg$fail(peg$endExpectation());\n }\n\n throw peg$buildStructuredError(\n peg$maxFailExpected,\n peg$maxFailPos < input.length ? input.charAt(peg$maxFailPos) : null,\n peg$maxFailPos < input.length\n ? peg$computeLocation(peg$maxFailPos, peg$maxFailPos + 1)\n : peg$computeLocation(peg$maxFailPos, peg$maxFailPos)\n );\n }\n}\n\n return {\n SyntaxError: peg$SyntaxError,\n parse: peg$parse\n };\n})()\n", "export default // Generated by Peggy 2.0.1.\n//\n// https://peggyjs.org/\n(function() {\n \"use strict\";\n\nfunction peg$subclass(child, parent) {\n function C() { this.constructor = child; }\n C.prototype = parent.prototype;\n child.prototype = new C();\n}\n\nfunction peg$SyntaxError(message, expected, found, location) {\n var self = Error.call(this, message);\n // istanbul ignore next Check is a necessary evil to support older environments\n if (Object.setPrototypeOf) {\n Object.setPrototypeOf(self, peg$SyntaxError.prototype);\n }\n self.expected = expected;\n self.found = found;\n self.location = location;\n self.name = \"SyntaxError\";\n return self;\n}\n\npeg$subclass(peg$SyntaxError, Error);\n\nfunction peg$padEnd(str, targetLength, padString) {\n padString = padString || \" \";\n if (str.length > targetLength) { return str; }\n targetLength -= str.length;\n padString += padString.repeat(targetLength);\n return str + padString.slice(0, targetLength);\n}\n\npeg$SyntaxError.prototype.format = function(sources) {\n var str = \"Error: \" + this.message;\n if (this.location) {\n var src = null;\n var k;\n for (k = 0; k < sources.length; k++) {\n if (sources[k].source === this.location.source) {\n src = sources[k].text.split(/\\r\\n|\\n|\\r/g);\n break;\n }\n }\n var s = this.location.start;\n var loc = this.location.source + \":\" + s.line + \":\" + s.column;\n if (src) {\n var e = this.location.end;\n var filler = peg$padEnd(\"\", s.line.toString().length, ' ');\n var line = src[s.line - 1];\n var last = s.line === e.line ? e.column : line.length + 1;\n var hatLen = (last - s.column) || 1;\n str += \"\\n --> \" + loc + \"\\n\"\n + filler + \" |\\n\"\n + s.line + \" | \" + line + \"\\n\"\n + filler + \" | \" + peg$padEnd(\"\", s.column - 1, ' ')\n + peg$padEnd(\"\", hatLen, \"^\");\n } else {\n str += \"\\n at \" + loc;\n }\n }\n return str;\n};\n\npeg$SyntaxError.buildMessage = function(expected, found) {\n var DESCRIBE_EXPECTATION_FNS = {\n literal: function(expectation) {\n return \"\\\"\" + literalEscape(expectation.text) + \"\\\"\";\n },\n\n class: function(expectation) {\n var escapedParts = expectation.parts.map(function(part) {\n return Array.isArray(part)\n ? classEscape(part[0]) + \"-\" + classEscape(part[1])\n : classEscape(part);\n });\n\n return \"[\" + (expectation.inverted ? \"^\" : \"\") + escapedParts.join(\"\") + \"]\";\n },\n\n any: function() {\n return \"any character\";\n },\n\n end: function() {\n return \"end of input\";\n },\n\n other: function(expectation) {\n return expectation.description;\n }\n };\n\n function hex(ch) {\n return ch.charCodeAt(0).toString(16).toUpperCase();\n }\n\n function literalEscape(s) {\n return s\n .replace(/\\\\/g, \"\\\\\\\\\")\n .replace(/\"/g, \"\\\\\\\"\")\n .replace(/\\0/g, \"\\\\0\")\n .replace(/\\t/g, \"\\\\t\")\n .replace(/\\n/g, \"\\\\n\")\n .replace(/\\r/g, \"\\\\r\")\n .replace(/[\\x00-\\x0F]/g, function(ch) { return \"\\\\x0\" + hex(ch); })\n .replace(/[\\x10-\\x1F\\x7F-\\x9F]/g, function(ch) { return \"\\\\x\" + hex(ch); });\n }\n\n function classEscape(s) {\n return s\n .replace(/\\\\/g, \"\\\\\\\\\")\n .replace(/\\]/g, \"\\\\]\")\n .replace(/\\^/g, \"\\\\^\")\n .replace(/-/g, \"\\\\-\")\n .replace(/\\0/g, \"\\\\0\")\n .replace(/\\t/g, \"\\\\t\")\n .replace(/\\n/g, \"\\\\n\")\n .replace(/\\r/g, \"\\\\r\")\n .replace(/[\\x00-\\x0F]/g, function(ch) { return \"\\\\x0\" + hex(ch); })\n .replace(/[\\x10-\\x1F\\x7F-\\x9F]/g, function(ch) { return \"\\\\x\" + hex(ch); });\n }\n\n function describeExpectation(expectation) {\n return DESCRIBE_EXPECTATION_FNS[expectation.type](expectation);\n }\n\n function describeExpected(expected) {\n var descriptions = expected.map(describeExpectation);\n var i, j;\n\n descriptions.sort();\n\n if (descriptions.length > 0) {\n for (i = 1, j = 1; i < descriptions.length; i++) {\n if (descriptions[i - 1] !== descriptions[i]) {\n descriptions[j] = descriptions[i];\n j++;\n }\n }\n descriptions.length = j;\n }\n\n switch (descriptions.length) {\n case 1:\n return descriptions[0];\n\n case 2:\n return descriptions[0] + \" or \" + descriptions[1];\n\n default:\n return descriptions.slice(0, -1).join(\", \")\n + \", or \"\n + descriptions[descriptions.length - 1];\n }\n }\n\n function describeFound(found) {\n return found ? \"\\\"\" + literalEscape(found) + \"\\\"\" : \"end of input\";\n }\n\n return \"Expected \" + describeExpected(expected) + \" but \" + describeFound(found) + \" found.\";\n};\n\nfunction peg$parse(input, options) {\n options = options !== undefined ? options : {};\n\n var peg$FAILED = {};\n var peg$source = options.grammarSource;\n\n var peg$startRuleFunctions = { body: peg$parsebody };\n var peg$startRuleFunction = peg$parsebody;\n\n\n\n var peg$e0 = peg$otherExpectation(\"decl_start\");\n var peg$e1 = peg$otherExpectation(\"decl_end\");\n var peg$e2 = peg$otherExpectation(\"vert\");\n var peg$e3 = peg$anyExpectation();\n var peg$e4 = peg$otherExpectation(\"l\");\n var peg$e5 = peg$otherExpectation(\"r\");\n var peg$e6 = peg$otherExpectation(\"c\");\n var peg$e7 = peg$otherExpectation(\"p\");\n var peg$e8 = peg$otherExpectation(\"m\");\n var peg$e9 = peg$otherExpectation(\"b\");\n var peg$e10 = peg$otherExpectation(\"w\");\n var peg$e11 = peg$otherExpectation(\"W\");\n var peg$e12 = peg$otherExpectation(\"X\");\n var peg$e13 = peg$otherExpectation(\"!\");\n var peg$e14 = peg$otherExpectation(\"@\");\n var peg$e15 = peg$otherExpectation(\"<\");\n var peg$e16 = peg$otherExpectation(\">\");\n var peg$e17 = peg$otherExpectation(\"group\");\n var peg$e18 = peg$otherExpectation(\"whitespace\");\n\n var peg$f0 = function(c) { return c; };\n var peg$f1 = function(cols) { return cols; };\n var peg$f2 = function() { return []; };\n var peg$f3 = function(divs1, start, a, end, divs2) {\n return {\n type: \"column\",\n pre_dividers: divs1,\n post_dividers: divs2,\n before_start_code: start,\n before_end_code: end,\n alignment: a,\n };\n };\n var peg$f4 = function() {\n return {\n type: \"vert_divider\",\n };\n };\n var peg$f5 = function(b, g) {\n return {\n type: \"bang_divider\",\n content: g[0].content,\n };\n };\n var peg$f6 = function(g) {\n return {\n type: \"at_divider\",\n content: g[0].content,\n };\n };\n var peg$f7 = function(div) { return div; };\n var peg$f8 = function(g) { return { type: \"decl_code\", code: g[0].content }; };\n var peg$f9 = function(g) { return { type: \"decl_code\", code: g[0].content }; };\n var peg$f10 = function() { return { type: \"alignment\", alignment: \"left\" }; };\n var peg$f11 = function() { return { type: \"alignment\", alignment: \"center\" }; };\n var peg$f12 = function() { return { type: \"alignment\", alignment: \"right\" }; };\n var peg$f13 = function() { return { type: \"alignment\", alignment: \"X\" }; };\n var peg$f14 = function() { return \"top\"; };\n var peg$f15 = function() { return \"default\"; };\n var peg$f16 = function() { return \"bottom\"; };\n var peg$f17 = function(a, g) {\n return {\n type: \"alignment\",\n alignment: \"parbox\",\n baseline: a,\n size: g[0].content,\n };\n };\n var peg$f18 = function(g1, g2) {\n return {\n type: \"alignment\",\n alignment: \"parbox\",\n baseline: g1[0].content,\n size: g2[0].content,\n };\n };\n var peg$f19 = function(tok) { return options.matchChar(tok, \"|\"); };\n var peg$f20 = function(tok) { return options.matchChar(tok, \"l\"); };\n var peg$f21 = function(tok) { return options.matchChar(tok, \"r\"); };\n var peg$f22 = function(tok) { return options.matchChar(tok, \"c\"); };\n var peg$f23 = function(tok) { return options.matchChar(tok, \"p\"); };\n var peg$f24 = function(tok) { return options.matchChar(tok, \"m\"); };\n var peg$f25 = function(tok) { return options.matchChar(tok, \"b\"); };\n var peg$f26 = function(tok) { return options.matchChar(tok, \"w\"); };\n var peg$f27 = function(tok) { return options.matchChar(tok, \"W\"); };\n var peg$f28 = function(tok) { return options.matchChar(tok, \"X\"); };\n var peg$f29 = function(tok) { return options.matchChar(tok, \"!\"); };\n var peg$f30 = function(tok) { return options.matchChar(tok, \"@\"); };\n var peg$f31 = function(tok) { return options.matchChar(tok, \"<\"); };\n var peg$f32 = function(tok) { return options.matchChar(tok, \">\"); };\n var peg$f33 = function(tok) { return options.isGroup(tok); };\n var peg$f34 = function(tok) { return options.isWhitespace(tok); };\n var peg$currPos = 0;\n var peg$savedPos = 0;\n var peg$posDetailsCache = [{ line: 1, column: 1 }];\n var peg$maxFailPos = 0;\n var peg$maxFailExpected = [];\n var peg$silentFails = 0;\n\n var peg$result;\n\n if (\"startRule\" in options) {\n if (!(options.startRule in peg$startRuleFunctions)) {\n throw new Error(\"Can't start parsing from rule \\\"\" + options.startRule + \"\\\".\");\n }\n\n peg$startRuleFunction = peg$startRuleFunctions[options.startRule];\n }\n\n function text() {\n return input.substring(peg$savedPos, peg$currPos);\n }\n\n function offset() {\n return peg$savedPos;\n }\n\n function range() {\n return {\n source: peg$source,\n start: peg$savedPos,\n end: peg$currPos\n };\n }\n\n function location() {\n return peg$computeLocation(peg$savedPos, peg$currPos);\n }\n\n function expected(description, location) {\n location = location !== undefined\n ? location\n : peg$computeLocation(peg$savedPos, peg$currPos);\n\n throw peg$buildStructuredError(\n [peg$otherExpectation(description)],\n input.substring(peg$savedPos, peg$currPos),\n location\n );\n }\n\n function error(message, location) {\n location = location !== undefined\n ? location\n : peg$computeLocation(peg$savedPos, peg$currPos);\n\n throw peg$buildSimpleError(message, location);\n }\n\n function peg$literalExpectation(text, ignoreCase) {\n return { type: \"literal\", text: text, ignoreCase: ignoreCase };\n }\n\n function peg$classExpectation(parts, inverted, ignoreCase) {\n return { type: \"class\", parts: parts, inverted: inverted, ignoreCase: ignoreCase };\n }\n\n function peg$anyExpectation() {\n return { type: \"any\" };\n }\n\n function peg$endExpectation() {\n return { type: \"end\" };\n }\n\n function peg$otherExpectation(description) {\n return { type: \"other\", description: description };\n }\n\n function peg$computePosDetails(pos) {\n var details = peg$posDetailsCache[pos];\n var p;\n\n if (details) {\n return details;\n } else {\n p = pos - 1;\n while (!peg$posDetailsCache[p]) {\n p--;\n }\n\n details = peg$posDetailsCache[p];\n details = {\n line: details.line,\n column: details.column\n };\n\n while (p < pos) {\n if (input.charCodeAt(p) === 10) {\n details.line++;\n details.column = 1;\n } else {\n details.column++;\n }\n\n p++;\n }\n\n peg$posDetailsCache[pos] = details;\n\n return details;\n }\n }\n\n function peg$computeLocation(startPos, endPos) {\n var startPosDetails = peg$computePosDetails(startPos);\n var endPosDetails = peg$computePosDetails(endPos);\n\n return {\n source: peg$source,\n start: {\n offset: startPos,\n line: startPosDetails.line,\n column: startPosDetails.column\n },\n end: {\n offset: endPos,\n line: endPosDetails.line,\n column: endPosDetails.column\n }\n };\n }\n\n function peg$fail(expected) {\n if (peg$currPos < peg$maxFailPos) { return; }\n\n if (peg$currPos > peg$maxFailPos) {\n peg$maxFailPos = peg$currPos;\n peg$maxFailExpected = [];\n }\n\n peg$maxFailExpected.push(expected);\n }\n\n function peg$buildSimpleError(message, location) {\n return new peg$SyntaxError(message, null, null, location);\n }\n\n function peg$buildStructuredError(expected, found, location) {\n return new peg$SyntaxError(\n peg$SyntaxError.buildMessage(expected, found),\n expected,\n found,\n location\n );\n }\n\n function peg$parsebody() {\n var s0, s1, s2, s3, s4, s5;\n\n s0 = peg$currPos;\n s1 = [];\n s2 = peg$currPos;\n s3 = peg$parsecolumn();\n if (s3 !== peg$FAILED) {\n s4 = [];\n s5 = peg$parse_();\n while (s5 !== peg$FAILED) {\n s4.push(s5);\n s5 = peg$parse_();\n }\n peg$savedPos = s2;\n s2 = peg$f0(s3);\n } else {\n peg$currPos = s2;\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n while (s2 !== peg$FAILED) {\n s1.push(s2);\n s2 = peg$currPos;\n s3 = peg$parsecolumn();\n if (s3 !== peg$FAILED) {\n s4 = [];\n s5 = peg$parse_();\n while (s5 !== peg$FAILED) {\n s4.push(s5);\n s5 = peg$parse_();\n }\n peg$savedPos = s2;\n s2 = peg$f0(s3);\n } else {\n peg$currPos = s2;\n s2 = peg$FAILED;\n }\n }\n } else {\n s1 = peg$FAILED;\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = s0;\n s1 = peg$f1(s1);\n }\n s0 = s1;\n if (s0 === peg$FAILED) {\n s0 = peg$currPos;\n s1 = peg$parseEOL();\n if (s1 !== peg$FAILED) {\n peg$savedPos = s0;\n s1 = peg$f2();\n }\n s0 = s1;\n }\n\n return s0;\n }\n\n function peg$parsecolumn() {\n var s0, s1, s2, s3, s4, s5, s6;\n\n s0 = peg$currPos;\n s1 = [];\n s2 = peg$parsecolumn_divider();\n while (s2 !== peg$FAILED) {\n s1.push(s2);\n s2 = peg$parsecolumn_divider();\n }\n s2 = peg$parsedecl_start();\n if (s2 === peg$FAILED) {\n s2 = null;\n }\n s3 = peg$parsealignment();\n if (s3 !== peg$FAILED) {\n s4 = peg$parsedecl_end();\n if (s4 === peg$FAILED) {\n s4 = null;\n }\n s5 = [];\n s6 = peg$parsecolumn_divider();\n while (s6 !== peg$FAILED) {\n s5.push(s6);\n s6 = peg$parsecolumn_divider();\n }\n peg$savedPos = s0;\n s0 = peg$f3(s1, s2, s3, s4, s5);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n\n return s0;\n }\n\n function peg$parsecolumn_divider() {\n var s0, s1, s2, s3, s4;\n\n s0 = peg$currPos;\n s1 = [];\n s2 = peg$parse_();\n while (s2 !== peg$FAILED) {\n s1.push(s2);\n s2 = peg$parse_();\n }\n s2 = peg$currPos;\n s3 = peg$parsevert();\n if (s3 !== peg$FAILED) {\n peg$savedPos = s2;\n s3 = peg$f4();\n }\n s2 = s3;\n if (s2 === peg$FAILED) {\n s2 = peg$currPos;\n s3 = peg$parsebang();\n if (s3 !== peg$FAILED) {\n s4 = peg$parsegroup();\n if (s4 !== peg$FAILED) {\n peg$savedPos = s2;\n s2 = peg$f5(s3, s4);\n } else {\n peg$currPos = s2;\n s2 = peg$FAILED;\n }\n } else {\n peg$currPos = s2;\n s2 = peg$FAILED;\n }\n if (s2 === peg$FAILED) {\n s2 = peg$currPos;\n s3 = peg$parseat();\n if (s3 !== peg$FAILED) {\n s4 = peg$parsegroup();\n if (s4 !== peg$FAILED) {\n peg$savedPos = s2;\n s2 = peg$f6(s4);\n } else {\n peg$currPos = s2;\n s2 = peg$FAILED;\n }\n } else {\n peg$currPos = s2;\n s2 = peg$FAILED;\n }\n }\n }\n if (s2 !== peg$FAILED) {\n s3 = [];\n s4 = peg$parse_();\n while (s4 !== peg$FAILED) {\n s3.push(s4);\n s4 = peg$parse_();\n }\n peg$savedPos = s0;\n s0 = peg$f7(s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n\n return s0;\n }\n\n function peg$parsedecl_start() {\n var s0, s1, s2;\n\n peg$silentFails++;\n s0 = peg$currPos;\n s1 = peg$parsegreater();\n if (s1 !== peg$FAILED) {\n s2 = peg$parsegroup();\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f8(s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e0); }\n }\n\n return s0;\n }\n\n function peg$parsedecl_end() {\n var s0, s1, s2;\n\n peg$silentFails++;\n s0 = peg$currPos;\n s1 = peg$parseless();\n if (s1 !== peg$FAILED) {\n s2 = peg$parsegroup();\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f9(s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e1); }\n }\n\n return s0;\n }\n\n function peg$parsealignment() {\n var s0, s1, s2, s3, s4, s5;\n\n s0 = peg$currPos;\n s1 = peg$parsel();\n if (s1 !== peg$FAILED) {\n peg$savedPos = s0;\n s1 = peg$f10();\n }\n s0 = s1;\n if (s0 === peg$FAILED) {\n s0 = peg$currPos;\n s1 = peg$parsec();\n if (s1 !== peg$FAILED) {\n peg$savedPos = s0;\n s1 = peg$f11();\n }\n s0 = s1;\n if (s0 === peg$FAILED) {\n s0 = peg$currPos;\n s1 = peg$parser();\n if (s1 !== peg$FAILED) {\n peg$savedPos = s0;\n s1 = peg$f12();\n }\n s0 = s1;\n if (s0 === peg$FAILED) {\n s0 = peg$currPos;\n s1 = peg$parseX();\n if (s1 !== peg$FAILED) {\n peg$savedPos = s0;\n s1 = peg$f13();\n }\n s0 = s1;\n if (s0 === peg$FAILED) {\n s0 = peg$currPos;\n s1 = peg$currPos;\n s2 = peg$parsep();\n if (s2 !== peg$FAILED) {\n peg$savedPos = s1;\n s2 = peg$f14();\n }\n s1 = s2;\n if (s1 === peg$FAILED) {\n s1 = peg$currPos;\n s2 = peg$parsem();\n if (s2 !== peg$FAILED) {\n peg$savedPos = s1;\n s2 = peg$f15();\n }\n s1 = s2;\n if (s1 === peg$FAILED) {\n s1 = peg$currPos;\n s2 = peg$parseb();\n if (s2 !== peg$FAILED) {\n peg$savedPos = s1;\n s2 = peg$f16();\n }\n s1 = s2;\n }\n }\n if (s1 !== peg$FAILED) {\n s2 = [];\n s3 = peg$parse_();\n while (s3 !== peg$FAILED) {\n s2.push(s3);\n s3 = peg$parse_();\n }\n s3 = peg$parsegroup();\n if (s3 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f17(s1, s3);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n if (s0 === peg$FAILED) {\n s0 = peg$currPos;\n s1 = peg$parsew();\n if (s1 === peg$FAILED) {\n s1 = peg$parseW();\n }\n if (s1 !== peg$FAILED) {\n s2 = [];\n s3 = peg$parse_();\n while (s3 !== peg$FAILED) {\n s2.push(s3);\n s3 = peg$parse_();\n }\n s3 = peg$parsegroup();\n if (s3 !== peg$FAILED) {\n s4 = [];\n s5 = peg$parse_();\n while (s5 !== peg$FAILED) {\n s4.push(s5);\n s5 = peg$parse_();\n }\n s5 = peg$parsegroup();\n if (s5 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f18(s3, s5);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n }\n }\n }\n }\n }\n\n return s0;\n }\n\n function peg$parsevert() {\n var s0, s1, s2;\n\n peg$silentFails++;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e3); }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f19(s1);\n if (s2) {\n s2 = undefined;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n s1 = [s1, s2];\n s0 = s1;\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e2); }\n }\n\n return s0;\n }\n\n function peg$parsel() {\n var s0, s1, s2;\n\n peg$silentFails++;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e3); }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f20(s1);\n if (s2) {\n s2 = undefined;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n s1 = [s1, s2];\n s0 = s1;\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e4); }\n }\n\n return s0;\n }\n\n function peg$parser() {\n var s0, s1, s2;\n\n peg$silentFails++;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e3); }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f21(s1);\n if (s2) {\n s2 = undefined;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n s1 = [s1, s2];\n s0 = s1;\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e5); }\n }\n\n return s0;\n }\n\n function peg$parsec() {\n var s0, s1, s2;\n\n peg$silentFails++;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e3); }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f22(s1);\n if (s2) {\n s2 = undefined;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n s1 = [s1, s2];\n s0 = s1;\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e6); }\n }\n\n return s0;\n }\n\n function peg$parsep() {\n var s0, s1, s2;\n\n peg$silentFails++;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e3); }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f23(s1);\n if (s2) {\n s2 = undefined;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n s1 = [s1, s2];\n s0 = s1;\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e7); }\n }\n\n return s0;\n }\n\n function peg$parsem() {\n var s0, s1, s2;\n\n peg$silentFails++;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e3); }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f24(s1);\n if (s2) {\n s2 = undefined;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n s1 = [s1, s2];\n s0 = s1;\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e8); }\n }\n\n return s0;\n }\n\n function peg$parseb() {\n var s0, s1, s2;\n\n peg$silentFails++;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e3); }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f25(s1);\n if (s2) {\n s2 = undefined;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n s1 = [s1, s2];\n s0 = s1;\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e9); }\n }\n\n return s0;\n }\n\n function peg$parsew() {\n var s0, s1, s2;\n\n peg$silentFails++;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e3); }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f26(s1);\n if (s2) {\n s2 = undefined;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n s1 = [s1, s2];\n s0 = s1;\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e10); }\n }\n\n return s0;\n }\n\n function peg$parseW() {\n var s0, s1, s2;\n\n peg$silentFails++;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e3); }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f27(s1);\n if (s2) {\n s2 = undefined;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n s1 = [s1, s2];\n s0 = s1;\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e11); }\n }\n\n return s0;\n }\n\n function peg$parseX() {\n var s0, s1, s2;\n\n peg$silentFails++;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e3); }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f28(s1);\n if (s2) {\n s2 = undefined;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n s1 = [s1, s2];\n s0 = s1;\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e12); }\n }\n\n return s0;\n }\n\n function peg$parsebang() {\n var s0, s1, s2;\n\n peg$silentFails++;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e3); }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f29(s1);\n if (s2) {\n s2 = undefined;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n s1 = [s1, s2];\n s0 = s1;\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e13); }\n }\n\n return s0;\n }\n\n function peg$parseat() {\n var s0, s1, s2;\n\n peg$silentFails++;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e3); }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f30(s1);\n if (s2) {\n s2 = undefined;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n s1 = [s1, s2];\n s0 = s1;\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e14); }\n }\n\n return s0;\n }\n\n function peg$parseless() {\n var s0, s1, s2;\n\n peg$silentFails++;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e3); }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f31(s1);\n if (s2) {\n s2 = undefined;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n s1 = [s1, s2];\n s0 = s1;\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e15); }\n }\n\n return s0;\n }\n\n function peg$parsegreater() {\n var s0, s1, s2;\n\n peg$silentFails++;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e3); }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f32(s1);\n if (s2) {\n s2 = undefined;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n s1 = [s1, s2];\n s0 = s1;\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e16); }\n }\n\n return s0;\n }\n\n function peg$parsegroup() {\n var s0, s1, s2;\n\n peg$silentFails++;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e3); }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f33(s1);\n if (s2) {\n s2 = undefined;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n s1 = [s1, s2];\n s0 = s1;\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e17); }\n }\n\n return s0;\n }\n\n function peg$parse_() {\n var s0, s1, s2;\n\n peg$silentFails++;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e3); }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f34(s1);\n if (s2) {\n s2 = undefined;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n s1 = [s1, s2];\n s0 = s1;\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e18); }\n }\n\n return s0;\n }\n\n function peg$parseEOL() {\n var s0, s1;\n\n s0 = peg$currPos;\n peg$silentFails++;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e3); }\n }\n peg$silentFails--;\n if (s1 === peg$FAILED) {\n s0 = undefined;\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n\n return s0;\n }\n\n\n //\n // These are compatability functions used when running in the browser\n //\n // Check if the `options` object has the functions that we need.\n // If not, try to add them\n if (!options.isHash) {\n try {\n Object.assign(options, {\n matchChar: (node, char) =>\n node.type === \"string\" && node.content === char,\n isGroup: (node) => node.type === \"group\",\n isWhitespace: (node) => node.type === \"whitespace\",\n });\n } catch (e) {\n console.warn(\"Error when initializing parser\", e);\n }\n }\n\n peg$result = peg$startRuleFunction();\n\n if (peg$result !== peg$FAILED && peg$currPos === input.length) {\n return peg$result;\n } else {\n if (peg$result !== peg$FAILED && peg$currPos < input.length) {\n peg$fail(peg$endExpectation());\n }\n\n throw peg$buildStructuredError(\n peg$maxFailExpected,\n peg$maxFailPos < input.length ? input.charAt(peg$maxFailPos) : null,\n peg$maxFailPos < input.length\n ? peg$computeLocation(peg$maxFailPos, peg$maxFailPos + 1)\n : peg$computeLocation(peg$maxFailPos, peg$maxFailPos)\n );\n }\n}\n\n return {\n SyntaxError: peg$SyntaxError,\n parse: peg$parse\n };\n})()\n", "export default // Generated by Peggy 2.0.1.\n//\n// https://peggyjs.org/\n(function() {\n \"use strict\";\n\nfunction peg$subclass(child, parent) {\n function C() { this.constructor = child; }\n C.prototype = parent.prototype;\n child.prototype = new C();\n}\n\nfunction peg$SyntaxError(message, expected, found, location) {\n var self = Error.call(this, message);\n // istanbul ignore next Check is a necessary evil to support older environments\n if (Object.setPrototypeOf) {\n Object.setPrototypeOf(self, peg$SyntaxError.prototype);\n }\n self.expected = expected;\n self.found = found;\n self.location = location;\n self.name = \"SyntaxError\";\n return self;\n}\n\npeg$subclass(peg$SyntaxError, Error);\n\nfunction peg$padEnd(str, targetLength, padString) {\n padString = padString || \" \";\n if (str.length > targetLength) { return str; }\n targetLength -= str.length;\n padString += padString.repeat(targetLength);\n return str + padString.slice(0, targetLength);\n}\n\npeg$SyntaxError.prototype.format = function(sources) {\n var str = \"Error: \" + this.message;\n if (this.location) {\n var src = null;\n var k;\n for (k = 0; k < sources.length; k++) {\n if (sources[k].source === this.location.source) {\n src = sources[k].text.split(/\\r\\n|\\n|\\r/g);\n break;\n }\n }\n var s = this.location.start;\n var loc = this.location.source + \":\" + s.line + \":\" + s.column;\n if (src) {\n var e = this.location.end;\n var filler = peg$padEnd(\"\", s.line.toString().length, ' ');\n var line = src[s.line - 1];\n var last = s.line === e.line ? e.column : line.length + 1;\n var hatLen = (last - s.column) || 1;\n str += \"\\n --> \" + loc + \"\\n\"\n + filler + \" |\\n\"\n + s.line + \" | \" + line + \"\\n\"\n + filler + \" | \" + peg$padEnd(\"\", s.column - 1, ' ')\n + peg$padEnd(\"\", hatLen, \"^\");\n } else {\n str += \"\\n at \" + loc;\n }\n }\n return str;\n};\n\npeg$SyntaxError.buildMessage = function(expected, found) {\n var DESCRIBE_EXPECTATION_FNS = {\n literal: function(expectation) {\n return \"\\\"\" + literalEscape(expectation.text) + \"\\\"\";\n },\n\n class: function(expectation) {\n var escapedParts = expectation.parts.map(function(part) {\n return Array.isArray(part)\n ? classEscape(part[0]) + \"-\" + classEscape(part[1])\n : classEscape(part);\n });\n\n return \"[\" + (expectation.inverted ? \"^\" : \"\") + escapedParts.join(\"\") + \"]\";\n },\n\n any: function() {\n return \"any character\";\n },\n\n end: function() {\n return \"end of input\";\n },\n\n other: function(expectation) {\n return expectation.description;\n }\n };\n\n function hex(ch) {\n return ch.charCodeAt(0).toString(16).toUpperCase();\n }\n\n function literalEscape(s) {\n return s\n .replace(/\\\\/g, \"\\\\\\\\\")\n .replace(/\"/g, \"\\\\\\\"\")\n .replace(/\\0/g, \"\\\\0\")\n .replace(/\\t/g, \"\\\\t\")\n .replace(/\\n/g, \"\\\\n\")\n .replace(/\\r/g, \"\\\\r\")\n .replace(/[\\x00-\\x0F]/g, function(ch) { return \"\\\\x0\" + hex(ch); })\n .replace(/[\\x10-\\x1F\\x7F-\\x9F]/g, function(ch) { return \"\\\\x\" + hex(ch); });\n }\n\n function classEscape(s) {\n return s\n .replace(/\\\\/g, \"\\\\\\\\\")\n .replace(/\\]/g, \"\\\\]\")\n .replace(/\\^/g, \"\\\\^\")\n .replace(/-/g, \"\\\\-\")\n .replace(/\\0/g, \"\\\\0\")\n .replace(/\\t/g, \"\\\\t\")\n .replace(/\\n/g, \"\\\\n\")\n .replace(/\\r/g, \"\\\\r\")\n .replace(/[\\x00-\\x0F]/g, function(ch) { return \"\\\\x0\" + hex(ch); })\n .replace(/[\\x10-\\x1F\\x7F-\\x9F]/g, function(ch) { return \"\\\\x\" + hex(ch); });\n }\n\n function describeExpectation(expectation) {\n return DESCRIBE_EXPECTATION_FNS[expectation.type](expectation);\n }\n\n function describeExpected(expected) {\n var descriptions = expected.map(describeExpectation);\n var i, j;\n\n descriptions.sort();\n\n if (descriptions.length > 0) {\n for (i = 1, j = 1; i < descriptions.length; i++) {\n if (descriptions[i - 1] !== descriptions[i]) {\n descriptions[j] = descriptions[i];\n j++;\n }\n }\n descriptions.length = j;\n }\n\n switch (descriptions.length) {\n case 1:\n return descriptions[0];\n\n case 2:\n return descriptions[0] + \" or \" + descriptions[1];\n\n default:\n return descriptions.slice(0, -1).join(\", \")\n + \", or \"\n + descriptions[descriptions.length - 1];\n }\n }\n\n function describeFound(found) {\n return found ? \"\\\"\" + literalEscape(found) + \"\\\"\" : \"end of input\";\n }\n\n return \"Expected \" + describeExpected(expected) + \" but \" + describeFound(found) + \" found.\";\n};\n\nfunction peg$parse(input, options) {\n options = options !== undefined ? options : {};\n\n var peg$FAILED = {};\n var peg$source = options.grammarSource;\n\n var peg$startRuleFunctions = { body: peg$parsebody };\n var peg$startRuleFunction = peg$parsebody;\n\n\n\n var peg$e0 = peg$otherExpectation(\"partial item\");\n var peg$e1 = peg$otherExpectation(\"item\");\n var peg$e2 = peg$anyExpectation();\n var peg$e3 = peg$otherExpectation(\"equation\");\n var peg$e4 = peg$otherExpectation(\"trailing comment\");\n var peg$e5 = peg$otherExpectation(\"comment only line\");\n var peg$e6 = peg$otherExpectation(\"non-var token\");\n var peg$e7 = peg$otherExpectation(\"token\");\n var peg$e8 = peg$otherExpectation(\"same line comment\");\n var peg$e9 = peg$otherExpectation(\"own line comment\");\n var peg$e10 = peg$otherExpectation(\",\");\n var peg$e11 = peg$otherExpectation(\"@\");\n var peg$e12 = peg$otherExpectation(\"variable token\");\n var peg$e13 = peg$otherExpectation(\"+/-\");\n var peg$e14 = peg$otherExpectation(\"=\");\n\n var peg$f0 = function(a, b) { return a.concat(b ? b : []); };\n var peg$f1 = function() { return []; };\n var peg$f2 = function(a, b, c) { return a.concat(b, c); };\n var peg$f3 = function(op, a, b, c) {\n return { type: \"item\", op, variable: b, content: a.concat(b, c) };\n };\n var peg$f4 = function(op, a) {\n return { type: \"item\", op, variable: null, content: a };\n };\n var peg$f5 = function(line, sep, comment) {\n return { ...line, sep: [].concat(sep), trailingComment: comment };\n };\n var peg$f6 = function(line, comment) {\n return { ...line, trailingComment: comment };\n };\n var peg$f7 = function(eq, ann) {\n return {\n type: \"line\",\n equation: eq,\n annotation: ann,\n sep: null,\n };\n };\n var peg$f8 = function(at, ann) {\n return at ? { type: \"annotation\", marker: at, content: ann } : null;\n };\n var peg$f9 = function(left, eq, right) {\n return { type: \"equation\", left, right, equals: eq };\n };\n var peg$f10 = function(x) { return x; };\n var peg$f11 = function(x) {\n return {\n type: \"line\",\n trailingComment: x,\n };\n };\n var peg$f12 = function(v, s) { return [v].concat(s ? s : []); };\n var peg$f13 = function(t) { return t; };\n var peg$f14 = function(x) { return x; };\n var peg$f15 = function(x) { return x; };\n var peg$f16 = function(tok) { return options.isSameLineComment(tok); };\n var peg$f17 = function(tok) { return tok; };\n var peg$f18 = function(tok) { return options.isOwnLineComment(tok); };\n var peg$f19 = function(tok) { return tok; };\n var peg$f20 = function(tok) { return options.isWhitespace(tok); };\n var peg$f21 = function(tok) { return tok; };\n var peg$f22 = function(tok) { return options.isSep(tok); };\n var peg$f23 = function(tok) { return tok; };\n var peg$f24 = function(tok) { return options.isAt(tok); };\n var peg$f25 = function(tok) { return tok; };\n var peg$f26 = function(tok) { return options.isVar(tok); };\n var peg$f27 = function(tok) { return tok; };\n var peg$f28 = function(tok) { return options.isOperation(tok); };\n var peg$f29 = function(tok) { return tok; };\n var peg$f30 = function(tok) { return options.isEquals(tok); };\n var peg$f31 = function(tok) { return tok; };\n var peg$f32 = function(tok) { return options.isSubscript(tok); };\n var peg$f33 = function(tok) { return tok; };\n var peg$currPos = 0;\n var peg$savedPos = 0;\n var peg$posDetailsCache = [{ line: 1, column: 1 }];\n var peg$maxFailPos = 0;\n var peg$maxFailExpected = [];\n var peg$silentFails = 0;\n\n var peg$result;\n\n if (\"startRule\" in options) {\n if (!(options.startRule in peg$startRuleFunctions)) {\n throw new Error(\"Can't start parsing from rule \\\"\" + options.startRule + \"\\\".\");\n }\n\n peg$startRuleFunction = peg$startRuleFunctions[options.startRule];\n }\n\n function text() {\n return input.substring(peg$savedPos, peg$currPos);\n }\n\n function offset() {\n return peg$savedPos;\n }\n\n function range() {\n return {\n source: peg$source,\n start: peg$savedPos,\n end: peg$currPos\n };\n }\n\n function location() {\n return peg$computeLocation(peg$savedPos, peg$currPos);\n }\n\n function expected(description, location) {\n location = location !== undefined\n ? location\n : peg$computeLocation(peg$savedPos, peg$currPos);\n\n throw peg$buildStructuredError(\n [peg$otherExpectation(description)],\n input.substring(peg$savedPos, peg$currPos),\n location\n );\n }\n\n function error(message, location) {\n location = location !== undefined\n ? location\n : peg$computeLocation(peg$savedPos, peg$currPos);\n\n throw peg$buildSimpleError(message, location);\n }\n\n function peg$literalExpectation(text, ignoreCase) {\n return { type: \"literal\", text: text, ignoreCase: ignoreCase };\n }\n\n function peg$classExpectation(parts, inverted, ignoreCase) {\n return { type: \"class\", parts: parts, inverted: inverted, ignoreCase: ignoreCase };\n }\n\n function peg$anyExpectation() {\n return { type: \"any\" };\n }\n\n function peg$endExpectation() {\n return { type: \"end\" };\n }\n\n function peg$otherExpectation(description) {\n return { type: \"other\", description: description };\n }\n\n function peg$computePosDetails(pos) {\n var details = peg$posDetailsCache[pos];\n var p;\n\n if (details) {\n return details;\n } else {\n p = pos - 1;\n while (!peg$posDetailsCache[p]) {\n p--;\n }\n\n details = peg$posDetailsCache[p];\n details = {\n line: details.line,\n column: details.column\n };\n\n while (p < pos) {\n if (input.charCodeAt(p) === 10) {\n details.line++;\n details.column = 1;\n } else {\n details.column++;\n }\n\n p++;\n }\n\n peg$posDetailsCache[pos] = details;\n\n return details;\n }\n }\n\n function peg$computeLocation(startPos, endPos) {\n var startPosDetails = peg$computePosDetails(startPos);\n var endPosDetails = peg$computePosDetails(endPos);\n\n return {\n source: peg$source,\n start: {\n offset: startPos,\n line: startPosDetails.line,\n column: startPosDetails.column\n },\n end: {\n offset: endPos,\n line: endPosDetails.line,\n column: endPosDetails.column\n }\n };\n }\n\n function peg$fail(expected) {\n if (peg$currPos < peg$maxFailPos) { return; }\n\n if (peg$currPos > peg$maxFailPos) {\n peg$maxFailPos = peg$currPos;\n peg$maxFailExpected = [];\n }\n\n peg$maxFailExpected.push(expected);\n }\n\n function peg$buildSimpleError(message, location) {\n return new peg$SyntaxError(message, null, null, location);\n }\n\n function peg$buildStructuredError(expected, found, location) {\n return new peg$SyntaxError(\n peg$SyntaxError.buildMessage(expected, found),\n expected,\n found,\n location\n );\n }\n\n function peg$parsebody() {\n var s0, s1, s2;\n\n s0 = peg$currPos;\n s1 = [];\n s2 = peg$parsecomment_only_line();\n if (s2 === peg$FAILED) {\n s2 = peg$parseline_with_sep();\n if (s2 === peg$FAILED) {\n s2 = peg$parsepartial_line_with_comment();\n }\n }\n while (s2 !== peg$FAILED) {\n s1.push(s2);\n s2 = peg$parsecomment_only_line();\n if (s2 === peg$FAILED) {\n s2 = peg$parseline_with_sep();\n if (s2 === peg$FAILED) {\n s2 = peg$parsepartial_line_with_comment();\n }\n }\n }\n s2 = peg$parseline_without_sep();\n if (s2 === peg$FAILED) {\n s2 = peg$parseEOL();\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f0(s1, s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n if (s0 === peg$FAILED) {\n s0 = peg$currPos;\n s1 = peg$parseEOL();\n if (s1 !== peg$FAILED) {\n peg$savedPos = s0;\n s1 = peg$f1();\n }\n s0 = s1;\n }\n\n return s0;\n }\n\n function peg$parsepartial_item() {\n var s0, s1, s2, s3, s4, s5, s6, s7, s8;\n\n peg$silentFails++;\n s0 = peg$currPos;\n s1 = [];\n s2 = peg$parse_();\n while (s2 !== peg$FAILED) {\n s1.push(s2);\n s2 = peg$parse_();\n }\n s2 = [];\n s3 = peg$parsenon_var_token();\n while (s3 !== peg$FAILED) {\n s2.push(s3);\n s3 = peg$parsenon_var_token();\n }\n s3 = [];\n s4 = peg$parse_();\n while (s4 !== peg$FAILED) {\n s3.push(s4);\n s4 = peg$parse_();\n }\n s4 = peg$parsevar();\n if (s4 !== peg$FAILED) {\n s5 = [];\n s6 = peg$parse_();\n while (s6 !== peg$FAILED) {\n s5.push(s6);\n s6 = peg$parse_();\n }\n s6 = [];\n s7 = peg$parsetoken();\n while (s7 !== peg$FAILED) {\n s6.push(s7);\n s7 = peg$parsetoken();\n }\n s7 = [];\n s8 = peg$parse_();\n while (s8 !== peg$FAILED) {\n s7.push(s8);\n s8 = peg$parse_();\n }\n peg$savedPos = s0;\n s0 = peg$f2(s2, s4, s6);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e0); }\n }\n\n return s0;\n }\n\n function peg$parseitem() {\n var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;\n\n peg$silentFails++;\n s0 = peg$currPos;\n s1 = peg$parseoperation();\n if (s1 === peg$FAILED) {\n s1 = null;\n }\n s2 = [];\n s3 = peg$parse_();\n while (s3 !== peg$FAILED) {\n s2.push(s3);\n s3 = peg$parse_();\n }\n s3 = [];\n s4 = peg$parsenon_var_token();\n while (s4 !== peg$FAILED) {\n s3.push(s4);\n s4 = peg$parsenon_var_token();\n }\n s4 = [];\n s5 = peg$parse_();\n while (s5 !== peg$FAILED) {\n s4.push(s5);\n s5 = peg$parse_();\n }\n s5 = peg$parsevar();\n if (s5 !== peg$FAILED) {\n s6 = [];\n s7 = peg$parse_();\n while (s7 !== peg$FAILED) {\n s6.push(s7);\n s7 = peg$parse_();\n }\n s7 = [];\n s8 = peg$parsetoken();\n while (s8 !== peg$FAILED) {\n s7.push(s8);\n s8 = peg$parsetoken();\n }\n s8 = [];\n s9 = peg$parse_();\n while (s9 !== peg$FAILED) {\n s8.push(s9);\n s9 = peg$parse_();\n }\n peg$savedPos = s0;\n s0 = peg$f3(s1, s3, s5, s7);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n if (s0 === peg$FAILED) {\n s0 = peg$currPos;\n s1 = peg$parseoperation();\n if (s1 === peg$FAILED) {\n s1 = null;\n }\n s2 = [];\n s3 = peg$parse_();\n while (s3 !== peg$FAILED) {\n s2.push(s3);\n s3 = peg$parse_();\n }\n s3 = [];\n s4 = peg$parsenon_var_token();\n if (s4 !== peg$FAILED) {\n while (s4 !== peg$FAILED) {\n s3.push(s4);\n s4 = peg$parsenon_var_token();\n }\n } else {\n s3 = peg$FAILED;\n }\n if (s3 !== peg$FAILED) {\n s4 = [];\n s5 = peg$parse_();\n while (s5 !== peg$FAILED) {\n s4.push(s5);\n s5 = peg$parse_();\n }\n peg$savedPos = s0;\n s0 = peg$f4(s1, s3);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e1); }\n }\n\n return s0;\n }\n\n function peg$parseline_with_sep() {\n var s0, s1, s2, s3;\n\n s0 = peg$currPos;\n s1 = peg$parseline_without_sep();\n if (s1 !== peg$FAILED) {\n s2 = peg$parsesep();\n if (s2 !== peg$FAILED) {\n s3 = peg$parsetrailing_comment();\n if (s3 === peg$FAILED) {\n s3 = null;\n }\n peg$savedPos = s0;\n s0 = peg$f5(s1, s2, s3);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n\n return s0;\n }\n\n function peg$parsepartial_line_with_comment() {\n var s0, s1, s2;\n\n s0 = peg$currPos;\n s1 = peg$parseline_without_sep();\n if (s1 !== peg$FAILED) {\n s2 = peg$parsetrailing_comment();\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f6(s1, s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n\n return s0;\n }\n\n function peg$parseline_without_sep() {\n var s0, s1, s2, s3;\n\n s0 = peg$currPos;\n s1 = peg$currPos;\n peg$silentFails++;\n if (input.length > peg$currPos) {\n s2 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s2 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e2); }\n }\n peg$silentFails--;\n if (s2 !== peg$FAILED) {\n peg$currPos = s1;\n s1 = undefined;\n } else {\n s1 = peg$FAILED;\n }\n if (s1 !== peg$FAILED) {\n s2 = peg$parseequation();\n s3 = peg$parseannotation();\n if (s3 === peg$FAILED) {\n s3 = null;\n }\n peg$savedPos = s0;\n s0 = peg$f7(s2, s3);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n\n return s0;\n }\n\n function peg$parseannotation() {\n var s0, s1, s2, s3;\n\n s0 = peg$currPos;\n s1 = peg$parseat();\n if (s1 !== peg$FAILED) {\n s2 = [];\n s3 = peg$parsenon_sep_token();\n while (s3 !== peg$FAILED) {\n s2.push(s3);\n s3 = peg$parsenon_sep_token();\n }\n peg$savedPos = s0;\n s0 = peg$f8(s1, s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n\n return s0;\n }\n\n function peg$parseequation() {\n var s0, s1, s2, s3, s4;\n\n peg$silentFails++;\n s0 = peg$currPos;\n s1 = [];\n s2 = peg$parseitem();\n while (s2 !== peg$FAILED) {\n s1.push(s2);\n s2 = peg$parseitem();\n }\n s2 = peg$parseequals();\n if (s2 === peg$FAILED) {\n s2 = null;\n }\n s3 = [];\n s4 = peg$parsetoken();\n if (s4 === peg$FAILED) {\n s4 = peg$parseoperation();\n }\n while (s4 !== peg$FAILED) {\n s3.push(s4);\n s4 = peg$parsetoken();\n if (s4 === peg$FAILED) {\n s4 = peg$parseoperation();\n }\n }\n peg$savedPos = s0;\n s0 = peg$f9(s1, s2, s3);\n peg$silentFails--;\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e3); }\n\n return s0;\n }\n\n function peg$parsetrailing_comment() {\n var s0, s1, s2;\n\n peg$silentFails++;\n s0 = peg$currPos;\n s1 = [];\n s2 = peg$parse_();\n while (s2 !== peg$FAILED) {\n s1.push(s2);\n s2 = peg$parse_();\n }\n s2 = peg$parsesame_line_comment();\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f10(s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e4); }\n }\n\n return s0;\n }\n\n function peg$parsecomment_only_line() {\n var s0, s1, s2;\n\n peg$silentFails++;\n s0 = peg$currPos;\n s1 = [];\n s2 = peg$parse_();\n while (s2 !== peg$FAILED) {\n s1.push(s2);\n s2 = peg$parse_();\n }\n s2 = peg$parseown_line_comment();\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f11(s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e5); }\n }\n\n return s0;\n }\n\n function peg$parsevar() {\n var s0, s1, s2, s3;\n\n s0 = peg$currPos;\n s1 = peg$parsevar_token();\n if (s1 !== peg$FAILED) {\n s2 = [];\n s3 = peg$parse_();\n while (s3 !== peg$FAILED) {\n s2.push(s3);\n s3 = peg$parse_();\n }\n s3 = peg$parsesubscript();\n if (s3 === peg$FAILED) {\n s3 = null;\n }\n peg$savedPos = s0;\n s0 = peg$f12(s1, s3);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n\n return s0;\n }\n\n function peg$parsenon_var_token() {\n var s0, s1, s2;\n\n peg$silentFails++;\n s0 = peg$currPos;\n s1 = peg$currPos;\n peg$silentFails++;\n s2 = peg$parsevar();\n peg$silentFails--;\n if (s2 === peg$FAILED) {\n s1 = undefined;\n } else {\n peg$currPos = s1;\n s1 = peg$FAILED;\n }\n if (s1 !== peg$FAILED) {\n s2 = peg$parsetoken();\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f13(s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e6); }\n }\n\n return s0;\n }\n\n function peg$parsenon_sep_token() {\n var s0, s1, s2;\n\n s0 = peg$currPos;\n s1 = peg$currPos;\n peg$silentFails++;\n s2 = peg$parsesep();\n if (s2 === peg$FAILED) {\n s2 = peg$parsetrailing_comment();\n if (s2 === peg$FAILED) {\n s2 = peg$parseown_line_comment();\n }\n }\n peg$silentFails--;\n if (s2 === peg$FAILED) {\n s1 = undefined;\n } else {\n peg$currPos = s1;\n s1 = peg$FAILED;\n }\n if (s1 !== peg$FAILED) {\n if (input.length > peg$currPos) {\n s2 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s2 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e2); }\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f14(s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n\n return s0;\n }\n\n function peg$parsetoken() {\n var s0, s1, s2;\n\n peg$silentFails++;\n s0 = peg$currPos;\n s1 = peg$currPos;\n peg$silentFails++;\n s2 = peg$parsesep();\n if (s2 === peg$FAILED) {\n s2 = peg$parseat();\n if (s2 === peg$FAILED) {\n s2 = peg$parseoperation();\n if (s2 === peg$FAILED) {\n s2 = peg$parseequals();\n if (s2 === peg$FAILED) {\n s2 = peg$parsetrailing_comment();\n if (s2 === peg$FAILED) {\n s2 = peg$parseown_line_comment();\n }\n }\n }\n }\n }\n peg$silentFails--;\n if (s2 === peg$FAILED) {\n s1 = undefined;\n } else {\n peg$currPos = s1;\n s1 = peg$FAILED;\n }\n if (s1 !== peg$FAILED) {\n if (input.length > peg$currPos) {\n s2 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s2 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e2); }\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f15(s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e7); }\n }\n\n return s0;\n }\n\n function peg$parsesame_line_comment() {\n var s0, s1, s2;\n\n peg$silentFails++;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e2); }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f16(s1);\n if (s2) {\n s2 = undefined;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f17(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e8); }\n }\n\n return s0;\n }\n\n function peg$parseown_line_comment() {\n var s0, s1, s2;\n\n peg$silentFails++;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e2); }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f18(s1);\n if (s2) {\n s2 = undefined;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f19(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e9); }\n }\n\n return s0;\n }\n\n function peg$parse_() {\n var s0, s1, s2;\n\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e2); }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f20(s1);\n if (s2) {\n s2 = undefined;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f21(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n\n return s0;\n }\n\n function peg$parsesep() {\n var s0, s1, s2;\n\n peg$silentFails++;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e2); }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f22(s1);\n if (s2) {\n s2 = undefined;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f23(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e10); }\n }\n\n return s0;\n }\n\n function peg$parseat() {\n var s0, s1, s2;\n\n peg$silentFails++;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e2); }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f24(s1);\n if (s2) {\n s2 = undefined;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f25(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e11); }\n }\n\n return s0;\n }\n\n function peg$parsevar_token() {\n var s0, s1, s2;\n\n peg$silentFails++;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e2); }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f26(s1);\n if (s2) {\n s2 = undefined;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f27(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e12); }\n }\n\n return s0;\n }\n\n function peg$parseoperation() {\n var s0, s1, s2, s3, s4;\n\n peg$silentFails++;\n s0 = peg$currPos;\n s1 = [];\n s2 = peg$parse_();\n while (s2 !== peg$FAILED) {\n s1.push(s2);\n s2 = peg$parse_();\n }\n if (input.length > peg$currPos) {\n s2 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s2 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e2); }\n }\n if (s2 !== peg$FAILED) {\n s3 = [];\n s4 = peg$parse_();\n while (s4 !== peg$FAILED) {\n s3.push(s4);\n s4 = peg$parse_();\n }\n peg$savedPos = peg$currPos;\n s4 = peg$f28(s2);\n if (s4) {\n s4 = undefined;\n } else {\n s4 = peg$FAILED;\n }\n if (s4 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f29(s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e13); }\n }\n\n return s0;\n }\n\n function peg$parseequals() {\n var s0, s1, s2;\n\n peg$silentFails++;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e2); }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f30(s1);\n if (s2) {\n s2 = undefined;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f31(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e14); }\n }\n\n return s0;\n }\n\n function peg$parsesubscript() {\n var s0, s1, s2;\n\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e2); }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f32(s1);\n if (s2) {\n s2 = undefined;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f33(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n\n return s0;\n }\n\n function peg$parseEOL() {\n var s0, s1;\n\n s0 = peg$currPos;\n peg$silentFails++;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e2); }\n }\n peg$silentFails--;\n if (s1 === peg$FAILED) {\n s0 = undefined;\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n\n return s0;\n }\n\n\n //\n // These are compatability functions used when running in the browser\n //\n // Check if the `options` object has the functions that we need.\n // If not, try to add them\n if (!options.isWhitespace) {\n try {\n Object.assign(options, {\n isSep: (node) => node.type === \"string\" && node.content === \",\",\n isVar: (node) =>\n node.type === \"string\" && node.content.match(/[a-zA-Z]/),\n isOperation: (node) =>\n node.type === \"string\" && node.content.match(/[+-]/),\n isEquals: (node) =>\n node.type === \"string\" && node.content === \"=\",\n isAt: (node) => node.type === \"string\" && node.content === \"@\",\n isSubscript: (node) => node.content === \"_\",\n isWhitespace: (node) => node.type === \"whitespace\",\n isSameLineComment: (node) =>\n node.type === \"comment\" && node.sameline,\n isOwnLineComment: (node) =>\n node.type === \"comment\" && !node.sameline,\n });\n } catch (e) {\n console.warn(\"Error when initializing parser\", e);\n }\n }\n\n peg$result = peg$startRuleFunction();\n\n if (peg$result !== peg$FAILED && peg$currPos === input.length) {\n return peg$result;\n } else {\n if (peg$result !== peg$FAILED && peg$currPos < input.length) {\n peg$fail(peg$endExpectation());\n }\n\n throw peg$buildStructuredError(\n peg$maxFailExpected,\n peg$maxFailPos < input.length ? input.charAt(peg$maxFailPos) : null,\n peg$maxFailPos < input.length\n ? peg$computeLocation(peg$maxFailPos, peg$maxFailPos + 1)\n : peg$computeLocation(peg$maxFailPos, peg$maxFailPos)\n );\n }\n}\n\n return {\n SyntaxError: peg$SyntaxError,\n parse: peg$parse\n };\n})()\n", "export default // Generated by Peggy 2.0.1.\n//\n// https://peggyjs.org/\n(function() {\n \"use strict\";\n\nfunction peg$subclass(child, parent) {\n function C() { this.constructor = child; }\n C.prototype = parent.prototype;\n child.prototype = new C();\n}\n\nfunction peg$SyntaxError(message, expected, found, location) {\n var self = Error.call(this, message);\n // istanbul ignore next Check is a necessary evil to support older environments\n if (Object.setPrototypeOf) {\n Object.setPrototypeOf(self, peg$SyntaxError.prototype);\n }\n self.expected = expected;\n self.found = found;\n self.location = location;\n self.name = \"SyntaxError\";\n return self;\n}\n\npeg$subclass(peg$SyntaxError, Error);\n\nfunction peg$padEnd(str, targetLength, padString) {\n padString = padString || \" \";\n if (str.length > targetLength) { return str; }\n targetLength -= str.length;\n padString += padString.repeat(targetLength);\n return str + padString.slice(0, targetLength);\n}\n\npeg$SyntaxError.prototype.format = function(sources) {\n var str = \"Error: \" + this.message;\n if (this.location) {\n var src = null;\n var k;\n for (k = 0; k < sources.length; k++) {\n if (sources[k].source === this.location.source) {\n src = sources[k].text.split(/\\r\\n|\\n|\\r/g);\n break;\n }\n }\n var s = this.location.start;\n var loc = this.location.source + \":\" + s.line + \":\" + s.column;\n if (src) {\n var e = this.location.end;\n var filler = peg$padEnd(\"\", s.line.toString().length, ' ');\n var line = src[s.line - 1];\n var last = s.line === e.line ? e.column : line.length + 1;\n var hatLen = (last - s.column) || 1;\n str += \"\\n --> \" + loc + \"\\n\"\n + filler + \" |\\n\"\n + s.line + \" | \" + line + \"\\n\"\n + filler + \" | \" + peg$padEnd(\"\", s.column - 1, ' ')\n + peg$padEnd(\"\", hatLen, \"^\");\n } else {\n str += \"\\n at \" + loc;\n }\n }\n return str;\n};\n\npeg$SyntaxError.buildMessage = function(expected, found) {\n var DESCRIBE_EXPECTATION_FNS = {\n literal: function(expectation) {\n return \"\\\"\" + literalEscape(expectation.text) + \"\\\"\";\n },\n\n class: function(expectation) {\n var escapedParts = expectation.parts.map(function(part) {\n return Array.isArray(part)\n ? classEscape(part[0]) + \"-\" + classEscape(part[1])\n : classEscape(part);\n });\n\n return \"[\" + (expectation.inverted ? \"^\" : \"\") + escapedParts.join(\"\") + \"]\";\n },\n\n any: function() {\n return \"any character\";\n },\n\n end: function() {\n return \"end of input\";\n },\n\n other: function(expectation) {\n return expectation.description;\n }\n };\n\n function hex(ch) {\n return ch.charCodeAt(0).toString(16).toUpperCase();\n }\n\n function literalEscape(s) {\n return s\n .replace(/\\\\/g, \"\\\\\\\\\")\n .replace(/\"/g, \"\\\\\\\"\")\n .replace(/\\0/g, \"\\\\0\")\n .replace(/\\t/g, \"\\\\t\")\n .replace(/\\n/g, \"\\\\n\")\n .replace(/\\r/g, \"\\\\r\")\n .replace(/[\\x00-\\x0F]/g, function(ch) { return \"\\\\x0\" + hex(ch); })\n .replace(/[\\x10-\\x1F\\x7F-\\x9F]/g, function(ch) { return \"\\\\x\" + hex(ch); });\n }\n\n function classEscape(s) {\n return s\n .replace(/\\\\/g, \"\\\\\\\\\")\n .replace(/\\]/g, \"\\\\]\")\n .replace(/\\^/g, \"\\\\^\")\n .replace(/-/g, \"\\\\-\")\n .replace(/\\0/g, \"\\\\0\")\n .replace(/\\t/g, \"\\\\t\")\n .replace(/\\n/g, \"\\\\n\")\n .replace(/\\r/g, \"\\\\r\")\n .replace(/[\\x00-\\x0F]/g, function(ch) { return \"\\\\x0\" + hex(ch); })\n .replace(/[\\x10-\\x1F\\x7F-\\x9F]/g, function(ch) { return \"\\\\x\" + hex(ch); });\n }\n\n function describeExpectation(expectation) {\n return DESCRIBE_EXPECTATION_FNS[expectation.type](expectation);\n }\n\n function describeExpected(expected) {\n var descriptions = expected.map(describeExpectation);\n var i, j;\n\n descriptions.sort();\n\n if (descriptions.length > 0) {\n for (i = 1, j = 1; i < descriptions.length; i++) {\n if (descriptions[i - 1] !== descriptions[i]) {\n descriptions[j] = descriptions[i];\n j++;\n }\n }\n descriptions.length = j;\n }\n\n switch (descriptions.length) {\n case 1:\n return descriptions[0];\n\n case 2:\n return descriptions[0] + \" or \" + descriptions[1];\n\n default:\n return descriptions.slice(0, -1).join(\", \")\n + \", or \"\n + descriptions[descriptions.length - 1];\n }\n }\n\n function describeFound(found) {\n return found ? \"\\\"\" + literalEscape(found) + \"\\\"\" : \"end of input\";\n }\n\n return \"Expected \" + describeExpected(expected) + \" but \" + describeFound(found) + \" found.\";\n};\n\nfunction peg$parse(input, options) {\n options = options !== undefined ? options : {};\n\n var peg$FAILED = {};\n var peg$source = options.grammarSource;\n\n var peg$startRuleFunctions = { root: peg$parseroot };\n var peg$startRuleFunction = peg$parseroot;\n\n var peg$c0 = \"plus\";\n var peg$c1 = \"minus\";\n var peg$c2 = \"pt\";\n var peg$c3 = \"mm\";\n var peg$c4 = \"cm\";\n var peg$c5 = \"in\";\n var peg$c6 = \"ex\";\n var peg$c7 = \"em\";\n var peg$c8 = \"bp\";\n var peg$c9 = \"pc\";\n var peg$c10 = \"dd\";\n var peg$c11 = \"cc\";\n var peg$c12 = \"nd\";\n var peg$c13 = \"nc\";\n var peg$c14 = \"sp\";\n var peg$c15 = \"filll\";\n var peg$c16 = \"fill\";\n var peg$c17 = \"fil\";\n var peg$c18 = \".\";\n var peg$c19 = \"+\";\n var peg$c20 = \"-\";\n\n var peg$r0 = /^[0-9]/;\n\n var peg$e0 = peg$anyExpectation();\n var peg$e1 = peg$literalExpectation(\"plus\", false);\n var peg$e2 = peg$literalExpectation(\"minus\", false);\n var peg$e3 = peg$literalExpectation(\"pt\", false);\n var peg$e4 = peg$literalExpectation(\"mm\", false);\n var peg$e5 = peg$literalExpectation(\"cm\", false);\n var peg$e6 = peg$literalExpectation(\"in\", false);\n var peg$e7 = peg$literalExpectation(\"ex\", false);\n var peg$e8 = peg$literalExpectation(\"em\", false);\n var peg$e9 = peg$literalExpectation(\"bp\", false);\n var peg$e10 = peg$literalExpectation(\"pc\", false);\n var peg$e11 = peg$literalExpectation(\"dd\", false);\n var peg$e12 = peg$literalExpectation(\"cc\", false);\n var peg$e13 = peg$literalExpectation(\"nd\", false);\n var peg$e14 = peg$literalExpectation(\"nc\", false);\n var peg$e15 = peg$literalExpectation(\"sp\", false);\n var peg$e16 = peg$literalExpectation(\"filll\", false);\n var peg$e17 = peg$literalExpectation(\"fill\", false);\n var peg$e18 = peg$literalExpectation(\"fil\", false);\n var peg$e19 = peg$otherExpectation(\"number\");\n var peg$e20 = peg$classExpectation([[\"0\", \"9\"]], false, false);\n var peg$e21 = peg$literalExpectation(\".\", false);\n var peg$e22 = peg$literalExpectation(\"+\", false);\n var peg$e23 = peg$literalExpectation(\"-\", false);\n\n var peg$f0 = function(b, st, sh) {\n // Only return the non-null glue items\n return {\n type: \"glue\",\n fixed: b,\n stretchable: st,\n shrinkable: sh,\n position: location(),\n };\n };\n var peg$f1 = function(glue) { return glue; };\n var peg$f2 = function(n, u) { return { type: \"dim\", value: n, unit: u }; };\n var peg$f3 = function(n, u) {\n return { type: \"dim\", value: n, unit: u };\n };\n var peg$f4 = function(n, u) {\n return { type: \"dim\", value: n, unit: u };\n };\n var peg$f5 = function(n) { return parseFloat(n); };\n var peg$currPos = 0;\n var peg$savedPos = 0;\n var peg$posDetailsCache = [{ line: 1, column: 1 }];\n var peg$maxFailPos = 0;\n var peg$maxFailExpected = [];\n var peg$silentFails = 0;\n\n var peg$result;\n\n if (\"startRule\" in options) {\n if (!(options.startRule in peg$startRuleFunctions)) {\n throw new Error(\"Can't start parsing from rule \\\"\" + options.startRule + \"\\\".\");\n }\n\n peg$startRuleFunction = peg$startRuleFunctions[options.startRule];\n }\n\n function text() {\n return input.substring(peg$savedPos, peg$currPos);\n }\n\n function offset() {\n return peg$savedPos;\n }\n\n function range() {\n return {\n source: peg$source,\n start: peg$savedPos,\n end: peg$currPos\n };\n }\n\n function location() {\n return peg$computeLocation(peg$savedPos, peg$currPos);\n }\n\n function expected(description, location) {\n location = location !== undefined\n ? location\n : peg$computeLocation(peg$savedPos, peg$currPos);\n\n throw peg$buildStructuredError(\n [peg$otherExpectation(description)],\n input.substring(peg$savedPos, peg$currPos),\n location\n );\n }\n\n function error(message, location) {\n location = location !== undefined\n ? location\n : peg$computeLocation(peg$savedPos, peg$currPos);\n\n throw peg$buildSimpleError(message, location);\n }\n\n function peg$literalExpectation(text, ignoreCase) {\n return { type: \"literal\", text: text, ignoreCase: ignoreCase };\n }\n\n function peg$classExpectation(parts, inverted, ignoreCase) {\n return { type: \"class\", parts: parts, inverted: inverted, ignoreCase: ignoreCase };\n }\n\n function peg$anyExpectation() {\n return { type: \"any\" };\n }\n\n function peg$endExpectation() {\n return { type: \"end\" };\n }\n\n function peg$otherExpectation(description) {\n return { type: \"other\", description: description };\n }\n\n function peg$computePosDetails(pos) {\n var details = peg$posDetailsCache[pos];\n var p;\n\n if (details) {\n return details;\n } else {\n p = pos - 1;\n while (!peg$posDetailsCache[p]) {\n p--;\n }\n\n details = peg$posDetailsCache[p];\n details = {\n line: details.line,\n column: details.column\n };\n\n while (p < pos) {\n if (input.charCodeAt(p) === 10) {\n details.line++;\n details.column = 1;\n } else {\n details.column++;\n }\n\n p++;\n }\n\n peg$posDetailsCache[pos] = details;\n\n return details;\n }\n }\n\n function peg$computeLocation(startPos, endPos) {\n var startPosDetails = peg$computePosDetails(startPos);\n var endPosDetails = peg$computePosDetails(endPos);\n\n return {\n source: peg$source,\n start: {\n offset: startPos,\n line: startPosDetails.line,\n column: startPosDetails.column\n },\n end: {\n offset: endPos,\n line: endPosDetails.line,\n column: endPosDetails.column\n }\n };\n }\n\n function peg$fail(expected) {\n if (peg$currPos < peg$maxFailPos) { return; }\n\n if (peg$currPos > peg$maxFailPos) {\n peg$maxFailPos = peg$currPos;\n peg$maxFailExpected = [];\n }\n\n peg$maxFailExpected.push(expected);\n }\n\n function peg$buildSimpleError(message, location) {\n return new peg$SyntaxError(message, null, null, location);\n }\n\n function peg$buildStructuredError(expected, found, location) {\n return new peg$SyntaxError(\n peg$SyntaxError.buildMessage(expected, found),\n expected,\n found,\n location\n );\n }\n\n function peg$parseroot() {\n var s0, s1, s2, s3, s4;\n\n s0 = peg$currPos;\n s1 = peg$currPos;\n s2 = peg$parsebase();\n if (s2 !== peg$FAILED) {\n s3 = peg$parsestretchable();\n if (s3 === peg$FAILED) {\n s3 = null;\n }\n s4 = peg$parseshrinkable();\n if (s4 === peg$FAILED) {\n s4 = null;\n }\n peg$savedPos = s1;\n s1 = peg$f0(s2, s3, s4);\n } else {\n peg$currPos = s1;\n s1 = peg$FAILED;\n }\n if (s1 !== peg$FAILED) {\n s2 = [];\n if (input.length > peg$currPos) {\n s3 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s3 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e0); }\n }\n while (s3 !== peg$FAILED) {\n s2.push(s3);\n if (input.length > peg$currPos) {\n s3 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s3 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e0); }\n }\n }\n peg$savedPos = s0;\n s0 = peg$f1(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n\n return s0;\n }\n\n function peg$parsebase() {\n var s0, s1, s2;\n\n s0 = peg$currPos;\n s1 = peg$parsenumber();\n if (s1 !== peg$FAILED) {\n s2 = peg$parseunit();\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f2(s1, s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n\n return s0;\n }\n\n function peg$parsestretchable() {\n var s0, s1, s2, s3;\n\n s0 = peg$currPos;\n if (input.substr(peg$currPos, 4) === peg$c0) {\n s1 = peg$c0;\n peg$currPos += 4;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e1); }\n }\n if (s1 !== peg$FAILED) {\n s2 = peg$parsenumber();\n if (s2 !== peg$FAILED) {\n s3 = peg$parserubber_unit();\n if (s3 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f3(s2, s3);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n\n return s0;\n }\n\n function peg$parseshrinkable() {\n var s0, s1, s2, s3;\n\n s0 = peg$currPos;\n if (input.substr(peg$currPos, 5) === peg$c1) {\n s1 = peg$c1;\n peg$currPos += 5;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e2); }\n }\n if (s1 !== peg$FAILED) {\n s2 = peg$parsenumber();\n if (s2 !== peg$FAILED) {\n s3 = peg$parserubber_unit();\n if (s3 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f4(s2, s3);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n\n return s0;\n }\n\n function peg$parseunit() {\n var s0;\n\n if (input.substr(peg$currPos, 2) === peg$c2) {\n s0 = peg$c2;\n peg$currPos += 2;\n } else {\n s0 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e3); }\n }\n if (s0 === peg$FAILED) {\n if (input.substr(peg$currPos, 2) === peg$c3) {\n s0 = peg$c3;\n peg$currPos += 2;\n } else {\n s0 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e4); }\n }\n if (s0 === peg$FAILED) {\n if (input.substr(peg$currPos, 2) === peg$c4) {\n s0 = peg$c4;\n peg$currPos += 2;\n } else {\n s0 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e5); }\n }\n if (s0 === peg$FAILED) {\n if (input.substr(peg$currPos, 2) === peg$c5) {\n s0 = peg$c5;\n peg$currPos += 2;\n } else {\n s0 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e6); }\n }\n if (s0 === peg$FAILED) {\n if (input.substr(peg$currPos, 2) === peg$c6) {\n s0 = peg$c6;\n peg$currPos += 2;\n } else {\n s0 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e7); }\n }\n if (s0 === peg$FAILED) {\n if (input.substr(peg$currPos, 2) === peg$c7) {\n s0 = peg$c7;\n peg$currPos += 2;\n } else {\n s0 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e8); }\n }\n if (s0 === peg$FAILED) {\n if (input.substr(peg$currPos, 2) === peg$c8) {\n s0 = peg$c8;\n peg$currPos += 2;\n } else {\n s0 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e9); }\n }\n if (s0 === peg$FAILED) {\n if (input.substr(peg$currPos, 2) === peg$c9) {\n s0 = peg$c9;\n peg$currPos += 2;\n } else {\n s0 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e10); }\n }\n if (s0 === peg$FAILED) {\n if (input.substr(peg$currPos, 2) === peg$c10) {\n s0 = peg$c10;\n peg$currPos += 2;\n } else {\n s0 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e11); }\n }\n if (s0 === peg$FAILED) {\n if (input.substr(peg$currPos, 2) === peg$c11) {\n s0 = peg$c11;\n peg$currPos += 2;\n } else {\n s0 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e12); }\n }\n if (s0 === peg$FAILED) {\n if (input.substr(peg$currPos, 2) === peg$c12) {\n s0 = peg$c12;\n peg$currPos += 2;\n } else {\n s0 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e13); }\n }\n if (s0 === peg$FAILED) {\n if (input.substr(peg$currPos, 2) === peg$c13) {\n s0 = peg$c13;\n peg$currPos += 2;\n } else {\n s0 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e14); }\n }\n if (s0 === peg$FAILED) {\n if (input.substr(peg$currPos, 2) === peg$c14) {\n s0 = peg$c14;\n peg$currPos += 2;\n } else {\n s0 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e15); }\n }\n }\n }\n }\n }\n }\n }\n }\n }\n }\n }\n }\n }\n\n return s0;\n }\n\n function peg$parserubber_unit() {\n var s0;\n\n s0 = peg$parseunit();\n if (s0 === peg$FAILED) {\n if (input.substr(peg$currPos, 5) === peg$c15) {\n s0 = peg$c15;\n peg$currPos += 5;\n } else {\n s0 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e16); }\n }\n if (s0 === peg$FAILED) {\n if (input.substr(peg$currPos, 4) === peg$c16) {\n s0 = peg$c16;\n peg$currPos += 4;\n } else {\n s0 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e17); }\n }\n if (s0 === peg$FAILED) {\n if (input.substr(peg$currPos, 3) === peg$c17) {\n s0 = peg$c17;\n peg$currPos += 3;\n } else {\n s0 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e18); }\n }\n }\n }\n }\n\n return s0;\n }\n\n function peg$parsenumber() {\n var s0, s1, s2, s3, s4, s5, s6, s7, s8;\n\n peg$silentFails++;\n s0 = peg$currPos;\n s1 = peg$currPos;\n s2 = peg$currPos;\n s3 = peg$parsesign();\n if (s3 === peg$FAILED) {\n s3 = null;\n }\n s4 = peg$currPos;\n s5 = [];\n if (peg$r0.test(input.charAt(peg$currPos))) {\n s6 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s6 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e20); }\n }\n while (s6 !== peg$FAILED) {\n s5.push(s6);\n if (peg$r0.test(input.charAt(peg$currPos))) {\n s6 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s6 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e20); }\n }\n }\n if (input.charCodeAt(peg$currPos) === 46) {\n s6 = peg$c18;\n peg$currPos++;\n } else {\n s6 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e21); }\n }\n if (s6 !== peg$FAILED) {\n s7 = [];\n if (peg$r0.test(input.charAt(peg$currPos))) {\n s8 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s8 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e20); }\n }\n if (s8 !== peg$FAILED) {\n while (s8 !== peg$FAILED) {\n s7.push(s8);\n if (peg$r0.test(input.charAt(peg$currPos))) {\n s8 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s8 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e20); }\n }\n }\n } else {\n s7 = peg$FAILED;\n }\n if (s7 !== peg$FAILED) {\n s5 = [s5, s6, s7];\n s4 = s5;\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n if (s4 === peg$FAILED) {\n s4 = [];\n if (peg$r0.test(input.charAt(peg$currPos))) {\n s5 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s5 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e20); }\n }\n if (s5 !== peg$FAILED) {\n while (s5 !== peg$FAILED) {\n s4.push(s5);\n if (peg$r0.test(input.charAt(peg$currPos))) {\n s5 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s5 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e20); }\n }\n }\n } else {\n s4 = peg$FAILED;\n }\n }\n if (s4 !== peg$FAILED) {\n s3 = [s3, s4];\n s2 = s3;\n } else {\n peg$currPos = s2;\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n s1 = input.substring(s1, peg$currPos);\n } else {\n s1 = s2;\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = s0;\n s1 = peg$f5(s1);\n }\n s0 = s1;\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e19); }\n }\n\n return s0;\n }\n\n function peg$parsesign() {\n var s0;\n\n if (input.charCodeAt(peg$currPos) === 43) {\n s0 = peg$c19;\n peg$currPos++;\n } else {\n s0 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e22); }\n }\n if (s0 === peg$FAILED) {\n if (input.charCodeAt(peg$currPos) === 45) {\n s0 = peg$c20;\n peg$currPos++;\n } else {\n s0 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e23); }\n }\n }\n\n return s0;\n }\n\n function peg$parseEOL() {\n var s0, s1;\n\n s0 = peg$currPos;\n peg$silentFails++;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e0); }\n }\n peg$silentFails--;\n if (s1 === peg$FAILED) {\n s0 = undefined;\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n\n return s0;\n }\n\n peg$result = peg$startRuleFunction();\n\n if (peg$result !== peg$FAILED && peg$currPos === input.length) {\n return peg$result;\n } else {\n if (peg$result !== peg$FAILED && peg$currPos < input.length) {\n peg$fail(peg$endExpectation());\n }\n\n throw peg$buildStructuredError(\n peg$maxFailExpected,\n peg$maxFailPos < input.length ? input.charAt(peg$maxFailPos) : null,\n peg$maxFailPos < input.length\n ? peg$computeLocation(peg$maxFailPos, peg$maxFailPos + 1)\n : peg$computeLocation(peg$maxFailPos, peg$maxFailPos)\n );\n }\n}\n\n return {\n SyntaxError: peg$SyntaxError,\n parse: peg$parse\n };\n})()\n", "export default // Generated by Peggy 2.0.1.\n//\n// https://peggyjs.org/\n(function() {\n \"use strict\";\n\nfunction peg$subclass(child, parent) {\n function C() { this.constructor = child; }\n C.prototype = parent.prototype;\n child.prototype = new C();\n}\n\nfunction peg$SyntaxError(message, expected, found, location) {\n var self = Error.call(this, message);\n // istanbul ignore next Check is a necessary evil to support older environments\n if (Object.setPrototypeOf) {\n Object.setPrototypeOf(self, peg$SyntaxError.prototype);\n }\n self.expected = expected;\n self.found = found;\n self.location = location;\n self.name = \"SyntaxError\";\n return self;\n}\n\npeg$subclass(peg$SyntaxError, Error);\n\nfunction peg$padEnd(str, targetLength, padString) {\n padString = padString || \" \";\n if (str.length > targetLength) { return str; }\n targetLength -= str.length;\n padString += padString.repeat(targetLength);\n return str + padString.slice(0, targetLength);\n}\n\npeg$SyntaxError.prototype.format = function(sources) {\n var str = \"Error: \" + this.message;\n if (this.location) {\n var src = null;\n var k;\n for (k = 0; k < sources.length; k++) {\n if (sources[k].source === this.location.source) {\n src = sources[k].text.split(/\\r\\n|\\n|\\r/g);\n break;\n }\n }\n var s = this.location.start;\n var loc = this.location.source + \":\" + s.line + \":\" + s.column;\n if (src) {\n var e = this.location.end;\n var filler = peg$padEnd(\"\", s.line.toString().length, ' ');\n var line = src[s.line - 1];\n var last = s.line === e.line ? e.column : line.length + 1;\n var hatLen = (last - s.column) || 1;\n str += \"\\n --> \" + loc + \"\\n\"\n + filler + \" |\\n\"\n + s.line + \" | \" + line + \"\\n\"\n + filler + \" | \" + peg$padEnd(\"\", s.column - 1, ' ')\n + peg$padEnd(\"\", hatLen, \"^\");\n } else {\n str += \"\\n at \" + loc;\n }\n }\n return str;\n};\n\npeg$SyntaxError.buildMessage = function(expected, found) {\n var DESCRIBE_EXPECTATION_FNS = {\n literal: function(expectation) {\n return \"\\\"\" + literalEscape(expectation.text) + \"\\\"\";\n },\n\n class: function(expectation) {\n var escapedParts = expectation.parts.map(function(part) {\n return Array.isArray(part)\n ? classEscape(part[0]) + \"-\" + classEscape(part[1])\n : classEscape(part);\n });\n\n return \"[\" + (expectation.inverted ? \"^\" : \"\") + escapedParts.join(\"\") + \"]\";\n },\n\n any: function() {\n return \"any character\";\n },\n\n end: function() {\n return \"end of input\";\n },\n\n other: function(expectation) {\n return expectation.description;\n }\n };\n\n function hex(ch) {\n return ch.charCodeAt(0).toString(16).toUpperCase();\n }\n\n function literalEscape(s) {\n return s\n .replace(/\\\\/g, \"\\\\\\\\\")\n .replace(/\"/g, \"\\\\\\\"\")\n .replace(/\\0/g, \"\\\\0\")\n .replace(/\\t/g, \"\\\\t\")\n .replace(/\\n/g, \"\\\\n\")\n .replace(/\\r/g, \"\\\\r\")\n .replace(/[\\x00-\\x0F]/g, function(ch) { return \"\\\\x0\" + hex(ch); })\n .replace(/[\\x10-\\x1F\\x7F-\\x9F]/g, function(ch) { return \"\\\\x\" + hex(ch); });\n }\n\n function classEscape(s) {\n return s\n .replace(/\\\\/g, \"\\\\\\\\\")\n .replace(/\\]/g, \"\\\\]\")\n .replace(/\\^/g, \"\\\\^\")\n .replace(/-/g, \"\\\\-\")\n .replace(/\\0/g, \"\\\\0\")\n .replace(/\\t/g, \"\\\\t\")\n .replace(/\\n/g, \"\\\\n\")\n .replace(/\\r/g, \"\\\\r\")\n .replace(/[\\x00-\\x0F]/g, function(ch) { return \"\\\\x0\" + hex(ch); })\n .replace(/[\\x10-\\x1F\\x7F-\\x9F]/g, function(ch) { return \"\\\\x\" + hex(ch); });\n }\n\n function describeExpectation(expectation) {\n return DESCRIBE_EXPECTATION_FNS[expectation.type](expectation);\n }\n\n function describeExpected(expected) {\n var descriptions = expected.map(describeExpectation);\n var i, j;\n\n descriptions.sort();\n\n if (descriptions.length > 0) {\n for (i = 1, j = 1; i < descriptions.length; i++) {\n if (descriptions[i - 1] !== descriptions[i]) {\n descriptions[j] = descriptions[i];\n j++;\n }\n }\n descriptions.length = j;\n }\n\n switch (descriptions.length) {\n case 1:\n return descriptions[0];\n\n case 2:\n return descriptions[0] + \" or \" + descriptions[1];\n\n default:\n return descriptions.slice(0, -1).join(\", \")\n + \", or \"\n + descriptions[descriptions.length - 1];\n }\n }\n\n function describeFound(found) {\n return found ? \"\\\"\" + literalEscape(found) + \"\\\"\" : \"end of input\";\n }\n\n return \"Expected \" + describeExpected(expected) + \" but \" + describeFound(found) + \" found.\";\n};\n\nfunction peg$parse(input, options) {\n options = options !== undefined ? options : {};\n\n var peg$FAILED = {};\n var peg$source = options.grammarSource;\n\n var peg$startRuleFunctions = { path_spec: peg$parsepath_spec, foreach_body: peg$parseforeach_body };\n var peg$startRuleFunction = peg$parsepath_spec;\n\n\n\n var peg$e0 = peg$anyExpectation();\n var peg$e1 = peg$otherExpectation(\"same line comment\");\n var peg$e2 = peg$otherExpectation(\"own line comment\");\n var peg$e3 = peg$otherExpectation(\"comment\");\n var peg$e4 = peg$otherExpectation(\"floating comment\");\n var peg$e5 = peg$otherExpectation(\"operation\");\n var peg$e6 = peg$otherExpectation(\"=\");\n\n var peg$f0 = function(v) { return v; };\n var peg$f1 = function(ops) { return { type: \"path_spec\", content: ops }; };\n var peg$f2 = function(c1, op, comment) { return { op, comment }; };\n var peg$f3 = function(c1, ops, c2, body) {\n const comments = [c1, ...ops.map((x) => x.comment), c2].filter(\n (x) => x\n );\n const attribute = ops.map((x) => x.op.content.content).join(\" \");\n return {\n type: \"animation\",\n comments,\n attribute,\n content: body.content,\n };\n };\n var peg$f4 = function(start, b) {\n return { ...b, start, type: \"foreach\" };\n };\n var peg$f5 = function(c1, variables, options, c2, c3, list, c4, command) {\n const comments = [c1, c2, c3, c4].filter((x) => x);\n return {\n type: \"foreach_body\",\n variables,\n options: options && options.content,\n list,\n command,\n comments,\n };\n };\n var peg$f6 = function(c1, options, c2, body) {\n const comments = [c1, c2].filter((x) => x);\n return {\n type: \"svg_operation\",\n options: options && options.content,\n content: body,\n comments,\n };\n };\n var peg$f7 = function(c1, c2, coord, c3, c4, x) {\n return { coord: x, comment: c4 };\n };\n var peg$f8 = function(c1, c2, coord, c3, a, c5) {\n const comments = [c1, c2, c3, a && a.comment, c5].filter((x) => x);\n return {\n type: \"curve_to\",\n controls: a ? [coord, a.coord] : [coord],\n comments,\n };\n };\n var peg$f9 = function() { return { type: \"line_to\", command: \"|-\" }; };\n var peg$f10 = function() { return { type: \"line_to\", command: \"-|\" }; };\n var peg$f11 = function() { return { type: \"line_to\", command: \"--\" }; };\n var peg$f12 = function(prefix, content) {\n return { type: \"coordinate\", content, prefix };\n };\n var peg$f13 = function(content) {\n return { type: \"square_brace_group\", content };\n };\n var peg$f14 = function(v) { return { type: \"unknown\", content: v }; };\n var peg$f15 = function(tok) { return options.isSameLineComment(tok); };\n var peg$f16 = function(tok) { return tok; };\n var peg$f17 = function(tok) { return options.isOwnLineComment(tok); };\n var peg$f18 = function(tok) { return tok; };\n var peg$f19 = function(tok) { return options.isComment(tok); };\n var peg$f20 = function(tok) { return tok; };\n var peg$f21 = function(tok) { return options.isWhitespace(tok); };\n var peg$f22 = function(tok) { return tok; };\n var peg$f23 = function(c) { return c; };\n var peg$f24 = function(tok) { return options.isOperation(tok); };\n var peg$f25 = function(tok) {\n return { type: \"operation\", content: tok };\n };\n var peg$f26 = function(tok) { return options.isChar(tok, \"=\"); };\n var peg$f27 = function(tok) { return tok; };\n var peg$f28 = function(tok) { return options.isChar(tok, \"[\"); };\n var peg$f29 = function(tok) { return tok; };\n var peg$f30 = function(tok) { return options.isChar(tok, \"]\"); };\n var peg$f31 = function(tok) { return tok; };\n var peg$f32 = function(tok) { return options.isChar(tok, \"(\"); };\n var peg$f33 = function(tok) { return tok; };\n var peg$f34 = function(tok) { return options.isChar(tok, \")\"); };\n var peg$f35 = function(tok) { return tok; };\n var peg$f36 = function(tok) { return options.isChar(tok, \"+\"); };\n var peg$f37 = function(tok) { return tok; };\n var peg$f38 = function(tok) { return options.isChar(tok, \"-\"); };\n var peg$f39 = function(tok) { return tok; };\n var peg$f40 = function(tok) { return options.isChar(tok, \"|\"); };\n var peg$f41 = function(tok) { return tok; };\n var peg$f42 = function(tok) { return options.isChar(tok, \".\"); };\n var peg$f43 = function(tok) { return tok; };\n var peg$f44 = function(tok) { return options.isChar(tok, \"controls\"); };\n var peg$f45 = function(tok) { return tok; };\n var peg$f46 = function(tok) { return options.isChar(tok, \"and\"); };\n var peg$f47 = function(tok) { return tok; };\n var peg$f48 = function(tok) { return options.isChar(tok, \"svg\"); };\n var peg$f49 = function(tok) { return tok; };\n var peg$f50 = function(tok) { return options.isGroup(tok); };\n var peg$f51 = function(tok) { return tok; };\n var peg$f52 = function(tok) { return options.isAnyMacro(tok); };\n var peg$f53 = function(tok) { return tok; };\n var peg$f54 = function(tok) { return options.isChar(tok, \"foreach\"); };\n var peg$f55 = function(tok) { return tok; };\n var peg$f56 = function(tok) { return options.isMacro(tok, \"foreach\"); };\n var peg$f57 = function(tok) { return tok; };\n var peg$f58 = function(tok) { return options.isChar(tok, \"in\"); };\n var peg$f59 = function(tok) { return tok; };\n var peg$f60 = function(tok) { return options.isChar(tok, \":\"); };\n var peg$f61 = function(tok) { return tok; };\n var peg$currPos = 0;\n var peg$savedPos = 0;\n var peg$posDetailsCache = [{ line: 1, column: 1 }];\n var peg$maxFailPos = 0;\n var peg$maxFailExpected = [];\n var peg$silentFails = 0;\n\n var peg$result;\n\n if (\"startRule\" in options) {\n if (!(options.startRule in peg$startRuleFunctions)) {\n throw new Error(\"Can't start parsing from rule \\\"\" + options.startRule + \"\\\".\");\n }\n\n peg$startRuleFunction = peg$startRuleFunctions[options.startRule];\n }\n\n function text() {\n return input.substring(peg$savedPos, peg$currPos);\n }\n\n function offset() {\n return peg$savedPos;\n }\n\n function range() {\n return {\n source: peg$source,\n start: peg$savedPos,\n end: peg$currPos\n };\n }\n\n function location() {\n return peg$computeLocation(peg$savedPos, peg$currPos);\n }\n\n function expected(description, location) {\n location = location !== undefined\n ? location\n : peg$computeLocation(peg$savedPos, peg$currPos);\n\n throw peg$buildStructuredError(\n [peg$otherExpectation(description)],\n input.substring(peg$savedPos, peg$currPos),\n location\n );\n }\n\n function error(message, location) {\n location = location !== undefined\n ? location\n : peg$computeLocation(peg$savedPos, peg$currPos);\n\n throw peg$buildSimpleError(message, location);\n }\n\n function peg$literalExpectation(text, ignoreCase) {\n return { type: \"literal\", text: text, ignoreCase: ignoreCase };\n }\n\n function peg$classExpectation(parts, inverted, ignoreCase) {\n return { type: \"class\", parts: parts, inverted: inverted, ignoreCase: ignoreCase };\n }\n\n function peg$anyExpectation() {\n return { type: \"any\" };\n }\n\n function peg$endExpectation() {\n return { type: \"end\" };\n }\n\n function peg$otherExpectation(description) {\n return { type: \"other\", description: description };\n }\n\n function peg$computePosDetails(pos) {\n var details = peg$posDetailsCache[pos];\n var p;\n\n if (details) {\n return details;\n } else {\n p = pos - 1;\n while (!peg$posDetailsCache[p]) {\n p--;\n }\n\n details = peg$posDetailsCache[p];\n details = {\n line: details.line,\n column: details.column\n };\n\n while (p < pos) {\n if (input.charCodeAt(p) === 10) {\n details.line++;\n details.column = 1;\n } else {\n details.column++;\n }\n\n p++;\n }\n\n peg$posDetailsCache[pos] = details;\n\n return details;\n }\n }\n\n function peg$computeLocation(startPos, endPos) {\n var startPosDetails = peg$computePosDetails(startPos);\n var endPosDetails = peg$computePosDetails(endPos);\n\n return {\n source: peg$source,\n start: {\n offset: startPos,\n line: startPosDetails.line,\n column: startPosDetails.column\n },\n end: {\n offset: endPos,\n line: endPosDetails.line,\n column: endPosDetails.column\n }\n };\n }\n\n function peg$fail(expected) {\n if (peg$currPos < peg$maxFailPos) { return; }\n\n if (peg$currPos > peg$maxFailPos) {\n peg$maxFailPos = peg$currPos;\n peg$maxFailExpected = [];\n }\n\n peg$maxFailExpected.push(expected);\n }\n\n function peg$buildSimpleError(message, location) {\n return new peg$SyntaxError(message, null, null, location);\n }\n\n function peg$buildStructuredError(expected, found, location) {\n return new peg$SyntaxError(\n peg$SyntaxError.buildMessage(expected, found),\n expected,\n found,\n location\n );\n }\n\n function peg$parsepath_spec() {\n var s0, s1, s2, s3, s4, s5;\n\n s0 = peg$currPos;\n s1 = [];\n s2 = peg$currPos;\n s3 = peg$parsesquare_brace_group();\n if (s3 === peg$FAILED) {\n s3 = peg$parsecoordinate();\n if (s3 === peg$FAILED) {\n s3 = peg$parsecurve_to();\n if (s3 === peg$FAILED) {\n s3 = peg$parseline_to();\n if (s3 === peg$FAILED) {\n s3 = peg$parsesvg();\n if (s3 === peg$FAILED) {\n s3 = peg$parseforeach();\n if (s3 === peg$FAILED) {\n s3 = peg$parseoperation();\n if (s3 === peg$FAILED) {\n s3 = peg$parsecomment();\n if (s3 === peg$FAILED) {\n s3 = peg$parseanimation();\n if (s3 === peg$FAILED) {\n s3 = peg$parseunknown();\n }\n }\n }\n }\n }\n }\n }\n }\n }\n if (s3 !== peg$FAILED) {\n s4 = [];\n s5 = peg$parse_();\n while (s5 !== peg$FAILED) {\n s4.push(s5);\n s5 = peg$parse_();\n }\n peg$savedPos = s2;\n s2 = peg$f0(s3);\n } else {\n peg$currPos = s2;\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n while (s2 !== peg$FAILED) {\n s1.push(s2);\n s2 = peg$currPos;\n s3 = peg$parsesquare_brace_group();\n if (s3 === peg$FAILED) {\n s3 = peg$parsecoordinate();\n if (s3 === peg$FAILED) {\n s3 = peg$parsecurve_to();\n if (s3 === peg$FAILED) {\n s3 = peg$parseline_to();\n if (s3 === peg$FAILED) {\n s3 = peg$parsesvg();\n if (s3 === peg$FAILED) {\n s3 = peg$parseforeach();\n if (s3 === peg$FAILED) {\n s3 = peg$parseoperation();\n if (s3 === peg$FAILED) {\n s3 = peg$parsecomment();\n if (s3 === peg$FAILED) {\n s3 = peg$parseanimation();\n if (s3 === peg$FAILED) {\n s3 = peg$parseunknown();\n }\n }\n }\n }\n }\n }\n }\n }\n }\n if (s3 !== peg$FAILED) {\n s4 = [];\n s5 = peg$parse_();\n while (s5 !== peg$FAILED) {\n s4.push(s5);\n s5 = peg$parse_();\n }\n peg$savedPos = s2;\n s2 = peg$f0(s3);\n } else {\n peg$currPos = s2;\n s2 = peg$FAILED;\n }\n }\n } else {\n s1 = peg$FAILED;\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = s0;\n s1 = peg$f1(s1);\n }\n s0 = s1;\n\n return s0;\n }\n\n function peg$parseanimation() {\n var s0, s1, s2, s3, s4, s5, s6;\n\n s0 = peg$currPos;\n s1 = peg$parsecolon();\n if (s1 !== peg$FAILED) {\n s2 = peg$parse_comment_();\n s3 = [];\n s4 = peg$currPos;\n s5 = peg$parseoperation();\n if (s5 !== peg$FAILED) {\n s6 = peg$parse_comment_();\n peg$savedPos = s4;\n s4 = peg$f2(s2, s5, s6);\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n if (s4 !== peg$FAILED) {\n while (s4 !== peg$FAILED) {\n s3.push(s4);\n s4 = peg$currPos;\n s5 = peg$parseoperation();\n if (s5 !== peg$FAILED) {\n s6 = peg$parse_comment_();\n peg$savedPos = s4;\n s4 = peg$f2(s2, s5, s6);\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n }\n } else {\n s3 = peg$FAILED;\n }\n if (s3 !== peg$FAILED) {\n s4 = peg$parseequals();\n if (s4 !== peg$FAILED) {\n s5 = peg$parse_comment_();\n s6 = peg$parsegroup();\n if (s6 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f3(s2, s3, s5, s6);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n\n return s0;\n }\n\n function peg$parseforeach() {\n var s0, s1, s2;\n\n s0 = peg$currPos;\n s1 = peg$parseforeach_keyword();\n if (s1 === peg$FAILED) {\n s1 = peg$parseforeach_macro();\n }\n if (s1 !== peg$FAILED) {\n s2 = peg$parseforeach_body();\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f4(s1, s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n\n return s0;\n }\n\n function peg$parseforeach_body() {\n var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;\n\n s0 = peg$currPos;\n s1 = peg$parse_comment_();\n s2 = peg$currPos;\n s3 = [];\n s4 = peg$currPos;\n s5 = peg$currPos;\n peg$silentFails++;\n s6 = peg$parsein_keyword();\n if (s6 === peg$FAILED) {\n s6 = peg$parsesquare_brace_group();\n }\n peg$silentFails--;\n if (s6 === peg$FAILED) {\n s5 = undefined;\n } else {\n peg$currPos = s5;\n s5 = peg$FAILED;\n }\n if (s5 !== peg$FAILED) {\n if (input.length > peg$currPos) {\n s6 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s6 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e0); }\n }\n if (s6 !== peg$FAILED) {\n s5 = [s5, s6];\n s4 = s5;\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n while (s4 !== peg$FAILED) {\n s3.push(s4);\n s4 = peg$currPos;\n s5 = peg$currPos;\n peg$silentFails++;\n s6 = peg$parsein_keyword();\n if (s6 === peg$FAILED) {\n s6 = peg$parsesquare_brace_group();\n }\n peg$silentFails--;\n if (s6 === peg$FAILED) {\n s5 = undefined;\n } else {\n peg$currPos = s5;\n s5 = peg$FAILED;\n }\n if (s5 !== peg$FAILED) {\n if (input.length > peg$currPos) {\n s6 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s6 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e0); }\n }\n if (s6 !== peg$FAILED) {\n s5 = [s5, s6];\n s4 = s5;\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n }\n s2 = input.substring(s2, peg$currPos);\n s3 = peg$parsesquare_brace_group();\n if (s3 === peg$FAILED) {\n s3 = null;\n }\n s4 = peg$parse_comment_();\n s5 = peg$parsein_keyword();\n if (s5 !== peg$FAILED) {\n s6 = peg$parse_comment_();\n s7 = peg$parsegroup();\n if (s7 === peg$FAILED) {\n s7 = peg$parsemacro();\n }\n if (s7 !== peg$FAILED) {\n s8 = peg$parse_comment_();\n s9 = peg$parseforeach();\n if (s9 === peg$FAILED) {\n s9 = peg$parsegroup();\n if (s9 === peg$FAILED) {\n s9 = peg$parsemacro();\n }\n }\n if (s9 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f5(s1, s2, s3, s4, s6, s7, s8, s9);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n\n return s0;\n }\n\n function peg$parsesvg() {\n var s0, s1, s2, s3, s4, s5;\n\n s0 = peg$currPos;\n s1 = peg$parsesvg_keyword();\n if (s1 !== peg$FAILED) {\n s2 = peg$parse_comment_();\n s3 = peg$parsesquare_brace_group();\n if (s3 === peg$FAILED) {\n s3 = null;\n }\n s4 = peg$parse_comment_();\n s5 = peg$parsegroup();\n if (s5 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f6(s2, s3, s4, s5);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n\n return s0;\n }\n\n function peg$parsecurve_to() {\n var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10;\n\n s0 = peg$currPos;\n s1 = peg$parsedotdot();\n if (s1 !== peg$FAILED) {\n s2 = peg$parse_comment_();\n s3 = peg$parsecontrols_keyword();\n if (s3 !== peg$FAILED) {\n s4 = peg$parse_comment_();\n s5 = peg$parsecoordinate();\n if (s5 !== peg$FAILED) {\n s6 = peg$parse_comment_();\n s7 = peg$currPos;\n s8 = peg$parseand_keyword();\n if (s8 !== peg$FAILED) {\n s9 = peg$parse_comment_();\n s10 = peg$parsecoordinate();\n if (s10 !== peg$FAILED) {\n peg$savedPos = s7;\n s7 = peg$f7(s2, s4, s5, s6, s9, s10);\n } else {\n peg$currPos = s7;\n s7 = peg$FAILED;\n }\n } else {\n peg$currPos = s7;\n s7 = peg$FAILED;\n }\n if (s7 === peg$FAILED) {\n s7 = null;\n }\n s8 = peg$parse_comment_();\n s9 = peg$parsedotdot();\n if (s9 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f8(s2, s4, s5, s6, s7, s8);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n\n return s0;\n }\n\n function peg$parseline_to() {\n var s0, s1, s2;\n\n s0 = peg$currPos;\n s1 = peg$parsepipe();\n if (s1 !== peg$FAILED) {\n s2 = peg$parseminus();\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f9();\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n if (s0 === peg$FAILED) {\n s0 = peg$currPos;\n s1 = peg$parseminus();\n if (s1 !== peg$FAILED) {\n s2 = peg$parsepipe();\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f10();\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n if (s0 === peg$FAILED) {\n s0 = peg$currPos;\n s1 = peg$parseminus();\n if (s1 !== peg$FAILED) {\n s2 = peg$parseminus();\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f11();\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n }\n }\n\n return s0;\n }\n\n function peg$parsecoordinate() {\n var s0, s1, s2, s3, s4, s5, s6, s7;\n\n s0 = peg$currPos;\n s1 = peg$currPos;\n s2 = peg$currPos;\n s3 = peg$parseplus();\n if (s3 !== peg$FAILED) {\n s4 = peg$parseplus();\n if (s4 === peg$FAILED) {\n s4 = null;\n }\n s3 = [s3, s4];\n s2 = s3;\n } else {\n peg$currPos = s2;\n s2 = peg$FAILED;\n }\n if (s2 === peg$FAILED) {\n s2 = null;\n }\n s1 = input.substring(s1, peg$currPos);\n s2 = peg$parseopen_paren();\n if (s2 !== peg$FAILED) {\n s3 = peg$currPos;\n s4 = [];\n s5 = peg$currPos;\n s6 = peg$currPos;\n peg$silentFails++;\n s7 = peg$parseclose_paren();\n peg$silentFails--;\n if (s7 === peg$FAILED) {\n s6 = undefined;\n } else {\n peg$currPos = s6;\n s6 = peg$FAILED;\n }\n if (s6 !== peg$FAILED) {\n if (input.length > peg$currPos) {\n s7 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s7 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e0); }\n }\n if (s7 !== peg$FAILED) {\n s6 = [s6, s7];\n s5 = s6;\n } else {\n peg$currPos = s5;\n s5 = peg$FAILED;\n }\n } else {\n peg$currPos = s5;\n s5 = peg$FAILED;\n }\n while (s5 !== peg$FAILED) {\n s4.push(s5);\n s5 = peg$currPos;\n s6 = peg$currPos;\n peg$silentFails++;\n s7 = peg$parseclose_paren();\n peg$silentFails--;\n if (s7 === peg$FAILED) {\n s6 = undefined;\n } else {\n peg$currPos = s6;\n s6 = peg$FAILED;\n }\n if (s6 !== peg$FAILED) {\n if (input.length > peg$currPos) {\n s7 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s7 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e0); }\n }\n if (s7 !== peg$FAILED) {\n s6 = [s6, s7];\n s5 = s6;\n } else {\n peg$currPos = s5;\n s5 = peg$FAILED;\n }\n } else {\n peg$currPos = s5;\n s5 = peg$FAILED;\n }\n }\n s3 = input.substring(s3, peg$currPos);\n s4 = peg$parseclose_paren();\n if (s4 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f12(s1, s3);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n\n return s0;\n }\n\n function peg$parsesquare_brace_group() {\n var s0, s1, s2, s3, s4, s5, s6;\n\n s0 = peg$currPos;\n s1 = peg$parseopen_square_brace();\n if (s1 !== peg$FAILED) {\n s2 = peg$currPos;\n s3 = [];\n s4 = peg$currPos;\n s5 = peg$currPos;\n peg$silentFails++;\n s6 = peg$parseclose_square_brace();\n peg$silentFails--;\n if (s6 === peg$FAILED) {\n s5 = undefined;\n } else {\n peg$currPos = s5;\n s5 = peg$FAILED;\n }\n if (s5 !== peg$FAILED) {\n if (input.length > peg$currPos) {\n s6 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s6 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e0); }\n }\n if (s6 !== peg$FAILED) {\n s5 = [s5, s6];\n s4 = s5;\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n while (s4 !== peg$FAILED) {\n s3.push(s4);\n s4 = peg$currPos;\n s5 = peg$currPos;\n peg$silentFails++;\n s6 = peg$parseclose_square_brace();\n peg$silentFails--;\n if (s6 === peg$FAILED) {\n s5 = undefined;\n } else {\n peg$currPos = s5;\n s5 = peg$FAILED;\n }\n if (s5 !== peg$FAILED) {\n if (input.length > peg$currPos) {\n s6 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s6 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e0); }\n }\n if (s6 !== peg$FAILED) {\n s5 = [s5, s6];\n s4 = s5;\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n }\n s2 = input.substring(s2, peg$currPos);\n s3 = peg$parseclose_square_brace();\n if (s3 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f13(s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n\n return s0;\n }\n\n function peg$parsedotdot() {\n var s0, s1, s2;\n\n s0 = peg$currPos;\n s1 = peg$parsedot();\n if (s1 !== peg$FAILED) {\n s2 = peg$parsedot();\n if (s2 !== peg$FAILED) {\n s1 = [s1, s2];\n s0 = s1;\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n\n return s0;\n }\n\n function peg$parseunknown() {\n var s0, s1;\n\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e0); }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = s0;\n s1 = peg$f14(s1);\n }\n s0 = s1;\n\n return s0;\n }\n\n function peg$parsesame_line_comment() {\n var s0, s1, s2;\n\n peg$silentFails++;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e0); }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f15(s1);\n if (s2) {\n s2 = undefined;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f16(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e1); }\n }\n\n return s0;\n }\n\n function peg$parseown_line_comment() {\n var s0, s1, s2;\n\n peg$silentFails++;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e0); }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f17(s1);\n if (s2) {\n s2 = undefined;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f18(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e2); }\n }\n\n return s0;\n }\n\n function peg$parsecomment() {\n var s0, s1, s2;\n\n peg$silentFails++;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e0); }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f19(s1);\n if (s2) {\n s2 = undefined;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f20(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e3); }\n }\n\n return s0;\n }\n\n function peg$parse_() {\n var s0, s1, s2;\n\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e0); }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f21(s1);\n if (s2) {\n s2 = undefined;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f22(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n\n return s0;\n }\n\n function peg$parse_comment_() {\n var s0, s1, s2, s3, s4;\n\n peg$silentFails++;\n s0 = peg$currPos;\n s1 = [];\n s2 = peg$parse_();\n while (s2 !== peg$FAILED) {\n s1.push(s2);\n s2 = peg$parse_();\n }\n s2 = peg$parsecomment();\n if (s2 === peg$FAILED) {\n s2 = null;\n }\n s3 = [];\n s4 = peg$parse_();\n while (s4 !== peg$FAILED) {\n s3.push(s4);\n s4 = peg$parse_();\n }\n peg$savedPos = s0;\n s0 = peg$f23(s2);\n peg$silentFails--;\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e4); }\n\n return s0;\n }\n\n function peg$parseoperation() {\n var s0, s1, s2;\n\n peg$silentFails++;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e0); }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f24(s1);\n if (s2) {\n s2 = undefined;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f25(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e5); }\n }\n\n return s0;\n }\n\n function peg$parseequals() {\n var s0, s1, s2;\n\n peg$silentFails++;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e0); }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f26(s1);\n if (s2) {\n s2 = undefined;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f27(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e6); }\n }\n\n return s0;\n }\n\n function peg$parseopen_square_brace() {\n var s0, s1, s2;\n\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e0); }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f28(s1);\n if (s2) {\n s2 = undefined;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f29(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n\n return s0;\n }\n\n function peg$parseclose_square_brace() {\n var s0, s1, s2;\n\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e0); }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f30(s1);\n if (s2) {\n s2 = undefined;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f31(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n\n return s0;\n }\n\n function peg$parseopen_paren() {\n var s0, s1, s2;\n\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e0); }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f32(s1);\n if (s2) {\n s2 = undefined;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f33(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n\n return s0;\n }\n\n function peg$parseclose_paren() {\n var s0, s1, s2;\n\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e0); }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f34(s1);\n if (s2) {\n s2 = undefined;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f35(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n\n return s0;\n }\n\n function peg$parseplus() {\n var s0, s1, s2;\n\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e0); }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f36(s1);\n if (s2) {\n s2 = undefined;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f37(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n\n return s0;\n }\n\n function peg$parseminus() {\n var s0, s1, s2;\n\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e0); }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f38(s1);\n if (s2) {\n s2 = undefined;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f39(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n\n return s0;\n }\n\n function peg$parsepipe() {\n var s0, s1, s2;\n\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e0); }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f40(s1);\n if (s2) {\n s2 = undefined;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f41(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n\n return s0;\n }\n\n function peg$parsedot() {\n var s0, s1, s2;\n\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e0); }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f42(s1);\n if (s2) {\n s2 = undefined;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f43(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n\n return s0;\n }\n\n function peg$parsecontrols_keyword() {\n var s0, s1, s2;\n\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e0); }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f44(s1);\n if (s2) {\n s2 = undefined;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f45(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n\n return s0;\n }\n\n function peg$parseand_keyword() {\n var s0, s1, s2;\n\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e0); }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f46(s1);\n if (s2) {\n s2 = undefined;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f47(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n\n return s0;\n }\n\n function peg$parsesvg_keyword() {\n var s0, s1, s2;\n\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e0); }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f48(s1);\n if (s2) {\n s2 = undefined;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f49(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n\n return s0;\n }\n\n function peg$parsegroup() {\n var s0, s1, s2;\n\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e0); }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f50(s1);\n if (s2) {\n s2 = undefined;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f51(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n\n return s0;\n }\n\n function peg$parsemacro() {\n var s0, s1, s2;\n\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e0); }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f52(s1);\n if (s2) {\n s2 = undefined;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f53(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n\n return s0;\n }\n\n function peg$parseforeach_keyword() {\n var s0, s1, s2;\n\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e0); }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f54(s1);\n if (s2) {\n s2 = undefined;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f55(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n\n return s0;\n }\n\n function peg$parseforeach_macro() {\n var s0, s1, s2;\n\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e0); }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f56(s1);\n if (s2) {\n s2 = undefined;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f57(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n\n return s0;\n }\n\n function peg$parsein_keyword() {\n var s0, s1, s2;\n\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e0); }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f58(s1);\n if (s2) {\n s2 = undefined;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f59(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n\n return s0;\n }\n\n function peg$parsecolon() {\n var s0, s1, s2;\n\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e0); }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f60(s1);\n if (s2) {\n s2 = undefined;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f61(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n\n return s0;\n }\n\n function peg$parseEOL() {\n var s0, s1;\n\n s0 = peg$currPos;\n peg$silentFails++;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) { peg$fail(peg$e0); }\n }\n peg$silentFails--;\n if (s1 === peg$FAILED) {\n s0 = undefined;\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n\n return s0;\n }\n\n\n //\n // These are compatability functions used when running in the browser\n //\n // Check if the `options` object has the functions that we need.\n // If not, try to add them\n if (!options.isWhitespace) {\n try {\n Object.assign(options, {\n isChar: (node, char) =>\n node.type === \"string\" && node.content === char,\n isOperation: (node) =>\n node.type === \"string\" && node.content.match(/[a-zA-Z]/),\n isWhitespace: (node) =>\n node.type === \"whitespace\" || node.type === \"parbreak\",\n isSameLineComment: (node) =>\n node.type === \"comment\" && node.sameline,\n isOwnLineComment: (node) =>\n node.type === \"comment\" && !node.sameline,\n isComment: (node) => node.type === \"comment\",\n isGroup: (node) => node.type === \"group\",\n isMacro: (node, name) =>\n node.type === \"macro\" && node.content === name,\n isAnyMacro: (node) => node.type === \"macro\",\n });\n } catch (e) {\n console.warn(\"Error when initializing parser\", e);\n }\n }\n\n peg$result = peg$startRuleFunction();\n\n if (peg$result !== peg$FAILED && peg$currPos === input.length) {\n return peg$result;\n } else {\n if (peg$result !== peg$FAILED && peg$currPos < input.length) {\n peg$fail(peg$endExpectation());\n }\n\n throw peg$buildStructuredError(\n peg$maxFailExpected,\n peg$maxFailPos < input.length ? input.charAt(peg$maxFailPos) : null,\n peg$maxFailPos < input.length\n ? peg$computeLocation(peg$maxFailPos, peg$maxFailPos + 1)\n : peg$computeLocation(peg$maxFailPos, peg$maxFailPos)\n );\n }\n}\n\n return {\n SyntaxError: peg$SyntaxError,\n parse: peg$parse\n };\n})()\n", "// This file needs to be here because typescript does not know how to use babel's transpiler\n// to directly load Pegjs grammars.\n// @ts-nocheck\nimport _LatexPegParser from \"../grammars/latex.pegjs\";\nimport _AlignEnvironmentPegParser from \"../grammars/align-environment.pegjs\";\nimport _ArgSpecPegParser from \"../grammars/xparse-argspec.pegjs\";\nimport _PgfkeysPegParser from \"../grammars/pgfkeys.pegjs\";\nimport _MacroSubstitutionPegParser from \"../grammars/macro-substitutions.pegjs\";\nimport _LigaturesPegParser from \"../grammars/ligatures.pegjs\";\nimport _XColorPegParser from \"../grammars/xcolor-expressions.pegjs\";\nimport _TabularPegParser from \"../grammars/tabular-spec.pegjs\";\nimport _SystemePegParser from \"../grammars/systeme-environment.pegjs\";\nimport _GluePegParser from \"../grammars/tex-glue.pegjs\";\nimport _TikzPegParser from \"../grammars/tikz.pegjs\";\n\ntype PegParser = {\n parse: (input: string | unknown[], options?: unknown) => any;\n SyntaxError: (\n message: string,\n expected: string,\n found: unknown,\n location: unknown\n ) => unknown;\n};\n\nconst LatexPegParser = _LatexPegParser as PegParser;\nconst AlignEnvironmentPegParser = _AlignEnvironmentPegParser as PegParser;\nconst ArgSpecPegParser = _ArgSpecPegParser as PegParser;\nconst PgfkeysPegParser = _PgfkeysPegParser as PegParser;\nconst MacroSubstitutionPegParser = _MacroSubstitutionPegParser as PegParser;\nconst LigaturesPegParser = _LigaturesPegParser as PegParser;\nconst XColorPegParser = _XColorPegParser as PegParser;\nconst TabularPegParser = _TabularPegParser as PegParser;\nconst SystemePegParser = _SystemePegParser as PegParser;\nconst GluePegParser = _GluePegParser as PegParser;\nconst TikzPegParser = _TikzPegParser as PegParser;\n\nexport {\n LatexPegParser,\n AlignEnvironmentPegParser,\n ArgSpecPegParser,\n PgfkeysPegParser,\n MacroSubstitutionPegParser,\n LigaturesPegParser,\n XColorPegParser,\n TabularPegParser,\n SystemePegParser,\n GluePegParser,\n TikzPegParser,\n};\n", "import { ArgSpecPegParser as PegParser } from \"@unified-latex/unified-latex-util-pegjs\";\nimport * as ArgSpec from \"./argspec-types\";\n\n/**\n * Produce a string containing any decorators for the argspec node.\n * For example, `!` in front of a node means \"don't accept leading whitespace\"\n */\nfunction getDecorators(node: ArgSpec.Node): string {\n let ret = \"\";\n if ((node as ArgSpec.LeadingWhitespace).noLeadingWhitespace) {\n ret += \"!\";\n }\n return ret;\n}\n\n/**\n * Print an `xparse` argument specification AST\n * to a string.\n */\nexport function printRaw(node: ArgSpec.Ast, root = false): string {\n if (typeof node === \"string\") {\n return node;\n }\n\n if (Array.isArray(node)) {\n const sepToken = root ? \" \" : \"\";\n return node.map((tok) => printRaw(tok)).join(sepToken);\n }\n\n const decorators = getDecorators(node);\n const defaultArg = (node as ArgSpec.DefaultArgument).defaultArg\n ? printRaw((node as ArgSpec.DefaultArgument).defaultArg)\n : \"\";\n let spec = decorators;\n\n const type = node.type;\n switch (type) {\n case \"body\":\n return decorators + \"b\";\n case \"optionalStar\":\n return decorators + \"s\";\n case \"optionalToken\":\n return spec + \"t\" + node.token;\n case \"optional\":\n // [...] is the default enclosure for optional arguments\n if (node.openBrace === \"[\" && node.closeBrace === \"]\") {\n spec += node.defaultArg ? \"O\" : \"o\";\n } else {\n spec += node.defaultArg ? \"D\" : \"d\";\n spec += node.openBrace + node.closeBrace;\n }\n return spec + defaultArg;\n case \"mandatory\":\n // {...} is the default enclosure for mandatory arguments\n if (node.openBrace === \"{\" && node.closeBrace === \"}\") {\n spec += \"m\";\n } else {\n spec += node.defaultArg ? \"R\" : \"r\";\n spec += node.openBrace + node.closeBrace;\n }\n return spec + defaultArg;\n case \"embellishment\":\n spec += node.defaultArg ? \"E\" : \"e\";\n return (\n spec +\n \"{\" +\n printRaw(node.embellishmentTokens) +\n \"}\" +\n defaultArg\n );\n case \"verbatim\":\n return spec + \"v\" + node.openBrace;\n case \"group\":\n return spec + \"{\" + printRaw(node.content) + \"}\";\n case \"until\": {\n const stopTokens = printRaw(node.stopTokens);\n return stopTokens.length > 1 || stopTokens[0] === \" \"\n ? `u{${stopTokens}}`\n : `u${stopTokens}`;\n }\n default:\n const neverType: never = type;\n console.warn(`Unknown node type \"${neverType}\" for node`, node);\n return \"\";\n }\n}\n\nconst parseCache: { [argStr: string]: ArgSpec.Node[] } = {};\n\n/**\n * Parse an `xparse` argument specification string to an AST.\n * This function caches results. Don't mutate the returned AST!\n *\n * @param {string} [str=\"\"] - LaTeX string input\n * @returns - AST for LaTeX string\n */\nexport function parse(str = \"\"): ArgSpec.Node[] {\n parseCache[str] = parseCache[str] || PegParser.parse(str);\n return parseCache[str];\n}\n", "export type Ast = Node[] | Node;\nexport type Node =\n | Optional\n | Mandatory\n | Verbatim\n | Body\n | Group\n | Until\n | string;\ntype Optional = OptionalArg | OptionalStar | OptionalToken | Embellishment;\ninterface AstNode {\n type: string;\n}\ninterface Arg extends AstNode {\n openBrace: string;\n closeBrace: string;\n}\nexport interface LeadingWhitespace {\n noLeadingWhitespace: boolean | undefined;\n}\nexport interface DefaultArgument {\n defaultArg: Group;\n}\ninterface Verbatim extends Arg {\n type: \"verbatim\";\n}\ninterface OptionalArg extends LeadingWhitespace, DefaultArgument, Arg {\n type: \"optional\";\n}\ninterface OptionalStar extends LeadingWhitespace, AstNode {\n type: \"optionalStar\";\n}\ninterface OptionalToken extends LeadingWhitespace, AstNode {\n type: \"optionalToken\";\n token: string;\n}\ninterface Embellishment extends DefaultArgument, AstNode {\n type: \"embellishment\";\n embellishmentTokens: string[];\n}\ninterface Mandatory extends LeadingWhitespace, DefaultArgument, Arg {\n type: \"mandatory\";\n}\ninterface Group extends AstNode {\n type: \"group\";\n content: (Group | string)[];\n}\ninterface Body extends AstNode {\n type: \"body\";\n}\ninterface Until extends AstNode {\n type: \"until\";\n stopTokens: string[];\n}\n", "import type * as Ast from \"@unified-latex/unified-latex-types\";\n\ntype CoercibleNode = string | Ast.Node;\ntype CoercibleArgument = null | CoercibleNode | Ast.Argument;\ntype MacroSpecialOptions = {\n escapeToken?: string;\n};\ntype ArgumentsSpecialOptions = {\n braces?: string;\n defaultOpenMark?: string;\n defaultCloseMark?: string;\n};\ntype ArgumentSpecialOptions = {\n braces?: string;\n openMark?: string;\n closeMark?: string;\n};\n\nfunction normalizeNode(node: CoercibleNode): Ast.Node {\n if (typeof node === \"string\") {\n return s(node);\n }\n return node;\n}\n\nfunction normalizeArgument(\n arg: CoercibleArgument,\n openMark = \"{\",\n closeMark = \"}\"\n): Ast.Argument {\n if (arg == null) {\n return { type: \"argument\", content: [], openMark: \"\", closeMark: \"\" };\n }\n if (typeof arg === \"string\") {\n return {\n type: \"argument\",\n openMark,\n closeMark,\n content: [s(arg)],\n };\n }\n if (arg.type === \"argument\") {\n return arg;\n }\n return { type: \"argument\", openMark, closeMark, content: [arg] };\n}\n\nfunction normalizeArgumentsList(\n args?: CoercibleArgument | CoercibleArgument[],\n openMark = \"{\",\n closeMark = \"}\"\n): Ast.Argument[] {\n if (args == null) {\n return [];\n }\n if (Array.isArray(args)) {\n return args.map((arg) => normalizeArgument(arg, openMark, closeMark));\n }\n return [normalizeArgument(args, openMark, closeMark)];\n}\n\ntype BracesPair = { openMark: string; closeMark: string };\nconst BRACES_MAP: Record = {\n \"*\": { openMark: \"\", closeMark: \"\" },\n \"{\": { openMark: \"{\", closeMark: \"}\" },\n \"[\": { openMark: \"[\", closeMark: \"]\" },\n \"(\": { openMark: \"(\", closeMark: \")\" },\n \"<\": { openMark: \"<\", closeMark: \">\" },\n};\nconst CLOSE_BRACES = new Set(\n Object.values(BRACES_MAP)\n .map((x) => x.closeMark)\n .filter((x) => x)\n);\n\n/**\n * Turn a braces signature into an array of braces.\n */\nfunction bracesToOpenAndCloseMarks(braces: string): BracesPair[] {\n const ret: BracesPair[] = [];\n\n for (const char of braces.split(\"\")) {\n if (CLOSE_BRACES.has(char)) {\n continue;\n }\n const braces = BRACES_MAP[char];\n if (braces == null) {\n throw new Error(`Unknown open/close mark type \"${char}\"`);\n }\n braces;\n ret.push(braces);\n }\n\n return ret;\n}\n\n/**\n * Create an Argument list. `special.braces` can optionally specify\n * the signature of the open/close marks that each argument uses. For example\n * ```\n * args([\"a\", \"b\"], { braces: \"[]{}\" });\n * ```\n * will result in arguments `[a]{b}`. Valid braces are `*`, `[`, `{`, `(`, and `<`.\n *\n * `null` may be passed as the value of an empty optional argument. If `null` is passed,\n * the `openBrace` and `closeBrace` of the argument will be set to empty strings and the\n * contents will be set to an empty array. For example,\n * ```\n * args([null, \"b\"], { braces: \"[]{}\" });\n * ```\n * will produce the same structure as if the the first \"optional argument\" were omitted in regular parsing.\n */\nexport function args(\n args: CoercibleArgument | CoercibleArgument[],\n special?: ArgumentsSpecialOptions\n): Ast.Argument[] {\n if (!Array.isArray(args)) {\n args = [args];\n }\n if (special?.braces) {\n const braces = bracesToOpenAndCloseMarks(special.braces);\n if (braces.length !== args.length) {\n throw new Error(\n `There is a difference between the number of supplied braces and the number of supplied arguments. ${args.length} supplied with braces signature ${special.braces}`\n );\n }\n return args.map((arg, i) =>\n normalizeArgument(arg, braces[i].openMark, braces[i].closeMark)\n );\n }\n\n const openMark = special?.defaultOpenMark ?? \"{\";\n const closeMark = special?.defaultCloseMark ?? \"}\";\n return normalizeArgumentsList(args, openMark, closeMark);\n}\n\n/**\n * Create an Argument. `special.braces` can optionally specify\n * the signature of the open/close marks that each argument uses. For example\n * ```\n * arg(\"a\", { braces: \"[]\" });\n * ```\n * will result in arguments `[a]`. Valid braces are `*`, `[`, `{`, `<`, and `(`.\n *\n * `null` may be passed as the value of an empty optional argument. If `null` is passed,\n * the `openBrace` and `closeBrace` of the argument will be set to empty strings and the\n * contents will be set to an empty array. For example,\n * ```\n * args([null, \"b\"], { braces: \"[]{}\" });\n * ```\n * will produce the same structure as if the the first \"optional argument\" were omitted in regular parsing.\n */\nexport function arg(\n args: CoercibleArgument | Ast.Node[],\n special?: ArgumentSpecialOptions\n): Ast.Argument {\n if (args == null) {\n return { type: \"argument\", content: [], openMark: \"\", closeMark: \"\" };\n }\n if (typeof args === \"string\") {\n args = s(args);\n }\n if (!Array.isArray(args) && args.type === \"argument\") {\n return args;\n }\n\n let openMark = special?.openMark ?? \"{\";\n let closeMark = special?.closeMark ?? \"}\";\n if (special?.braces) {\n const braces = bracesToOpenAndCloseMarks(special.braces);\n if (braces[0]) {\n openMark = braces[0].openMark;\n closeMark = braces[0].closeMark;\n }\n }\n\n if (!Array.isArray(args)) {\n args = [args];\n }\n\n return { type: \"argument\", content: args, openMark, closeMark };\n}\n\n/**\n * Create a Macro with the given `name`. The macro\n * may be followed by any number of arguments.\n */\nexport function m(\n name: string,\n marcoArgs?: CoercibleArgument | CoercibleArgument[],\n special?: MacroSpecialOptions\n): Ast.Macro {\n const args = normalizeArgumentsList(marcoArgs);\n const escapeToken = special?.escapeToken;\n const ret: Ast.Macro = { type: \"macro\", content: name };\n\n if (args.length > 0) {\n ret.args = args;\n }\n if (escapeToken != null) {\n ret.escapeToken = escapeToken;\n }\n\n return ret;\n}\n\n/**\n * Create a String node from `value`\n */\nexport function s(value: string | Ast.String): Ast.String {\n if (typeof value === \"string\") {\n return { type: \"string\", content: value };\n }\n return value;\n}\n\n/**\n * Create an Environment node.\n */\nexport function env(\n name: string,\n body: CoercibleNode | CoercibleNode[],\n envArgs?: CoercibleArgument | CoercibleArgument[],\n special?: unknown\n): Ast.Environment {\n if (!Array.isArray(body)) {\n body = [body];\n }\n const args = normalizeArgumentsList(envArgs, \"[\", \"]\");\n const ret: Ast.Environment = {\n type: \"environment\",\n env: name,\n content: body.map(normalizeNode),\n };\n if (args.length > 0) {\n ret.args = args;\n }\n\n return ret;\n}\n\n/**\n * Whitespace node.\n */\nexport const SP: Ast.Whitespace = { type: \"whitespace\" };\n", "import * as Ast from \"@unified-latex/unified-latex-types\";\nimport { match } from \"@unified-latex/unified-latex-util-match\";\nimport { printRaw } from \"@unified-latex/unified-latex-util-print-raw\";\n\n/**\n * Scan `nodes` looking for the first occurrence of `token`.\n * If `options.onlySkipWhitespaceAndComments==true`, then the scan\n * will only skip whitespace/comment nodes.\n */\nexport function scan(\n nodes: (Ast.Node | Ast.Argument)[],\n token: string | Ast.Node | Ast.Argument,\n options?: {\n /**\n * Index to start scanning.\n */\n startIndex?: number;\n /**\n * If `true`, whitespace and comments will be skilled but any other\n * node that doesn't match `token` will cause the scan to terminate.\n */\n onlySkipWhitespaceAndComments?: boolean;\n /**\n * If `true`, will look inside `Ast.String` nodes to see if the string contents\n * contain `token`.\n */\n allowSubstringMatches?: boolean;\n }\n): number | null {\n const { startIndex, onlySkipWhitespaceAndComments, allowSubstringMatches } =\n options || {};\n if (typeof token === \"string\") {\n token = { type: \"string\", content: token } as Ast.String;\n }\n\n for (let i = startIndex || 0; i < nodes.length; i++) {\n const node = nodes[i];\n if (node.type === token.type) {\n switch (node.type) {\n case \"comment\":\n case \"displaymath\":\n case \"inlinemath\":\n case \"root\":\n case \"parbreak\":\n case \"whitespace\":\n case \"verb\":\n case \"verbatim\":\n case \"group\":\n return i;\n case \"macro\":\n if (node.content === (token as Ast.Macro).content) {\n return i;\n }\n break;\n case \"environment\":\n case \"mathenv\":\n if (\n printRaw(node.env) ===\n printRaw((token as Ast.Environment).env)\n ) {\n return i;\n }\n break;\n case \"string\":\n if (node.content === (token as Ast.String).content) {\n return i;\n }\n if (\n allowSubstringMatches &&\n node.content.indexOf((token as Ast.String).content) >= 0\n ) {\n return i;\n }\n break;\n }\n }\n if (\n onlySkipWhitespaceAndComments &&\n !match.whitespace(node) &&\n !match.comment(node)\n ) {\n return null;\n }\n }\n\n return null;\n}\n", "import Trie from \"trie-prefix-tree\";\nimport * as Ast from \"@unified-latex/unified-latex-types\";\nimport { match } from \"@unified-latex/unified-latex-util-match\";\n\nexport { Trie };\n\n/**\n * Efficiently search for a large number of strings using a prefix-tree.\n * The longest match is returned.\n *\n * @param options.startIndex the index to start scanning at. Defaults to 0.\n * @param options.matchSubstrings whether to allow matching only part of a substring.\n * @param options.assumeOneCharStrings assume that all strings are one character long (for example, like they are in math mode)\n */\nexport function prefixMatch(\n nodes: Ast.Node[],\n prefixes: string | string[] | ReturnType,\n options?: {\n startIndex?: number;\n matchSubstrings?: boolean;\n assumeOneCharStrings?: boolean;\n }\n): {\n match: string;\n endNodeIndex: number;\n endNodePartialMatch: string | null;\n} | null {\n const {\n startIndex = 0,\n matchSubstrings = false,\n assumeOneCharStrings = false,\n } = options || {};\n\n if (typeof prefixes === \"string\") {\n prefixes = [prefixes];\n }\n if (Array.isArray(prefixes)) {\n prefixes = Trie(prefixes);\n }\n const prefixTree = prefixes;\n\n const history = {\n lastPrefix: \"\",\n lastWord: \"\",\n index: startIndex,\n partialMatch: \"\",\n };\n\n /**\n * Try to match the next character. If it matches,\n * record it properly in the `history` object.\n */\n function tryToMatchNextChar(char: string, index: number): boolean {\n let ret = false;\n if (prefixTree.isPrefix(history.lastPrefix + char)) {\n history.lastPrefix += char;\n history.index = index;\n ret = true;\n }\n if (prefixTree.hasWord(history.lastPrefix)) {\n history.lastWord = history.lastPrefix;\n }\n return ret;\n }\n\n // Loop through the nodes looking for the longest prefix match\n for (let i = 0; startIndex + i < nodes.length; i++) {\n const node = nodes[startIndex + i];\n if (!match.string(node)) {\n break;\n }\n if (assumeOneCharStrings && node.content.length !== 1) {\n break;\n }\n if (matchSubstrings) {\n // We need to test letter-by-letter for substring matches\n let fullMatch = true;\n history.partialMatch = \"\";\n for (let j = 0; j < node.content.length; j++) {\n const char = node.content[j];\n if (tryToMatchNextChar(char, startIndex + i)) {\n history.partialMatch += char;\n } else {\n fullMatch = false;\n break;\n }\n }\n if (fullMatch) {\n history.partialMatch = \"\";\n } else {\n break;\n }\n } else {\n if (!tryToMatchNextChar(node.content, startIndex + i)) {\n break;\n }\n }\n }\n\n return history.lastWord\n ? {\n match: history.lastWord,\n endNodeIndex: history.index,\n endNodePartialMatch: history.partialMatch\n ? history.partialMatch\n : null,\n }\n : null;\n}\n", "import * as Ast from \"@unified-latex/unified-latex-types\";\nimport { visit } from \"@unified-latex/unified-latex-util-visit\";\n\n/**\n * Updates the `._renderInfo` property on a node to include\n * whatever has been supplied to `renderInfo`. If `renderInfo`\n * is null, no update is performed.\n *\n * *This operation mutates `node`*\n */\nexport function updateRenderInfo(\n node: Ast.Node,\n renderInfo: object | null | undefined\n) {\n if (renderInfo != null) {\n node._renderInfo = { ...(node._renderInfo || {}), ...renderInfo };\n }\n return node;\n}\n\n/**\n * Removes any `_renderInfo` and `position` tags present in the AST. This\n * operation is _destructive_.\n */\nexport function trimRenderInfo(ast: T) {\n visit(ast, (node) => {\n delete node._renderInfo;\n delete node.position;\n });\n return ast;\n}\n\n// NOTE: The docstring comment must be the last item in the index.ts file!\n/**\n * ## What is this?\n *\n * Functions to help modify the `_renderInfo` of a `unified-latex` Abstract Syntax Tree (AST).\n *\n * ## When should I use this?\n *\n * If you want to compare the structure of an AST without position information or extra information\n * that is kept for pretty-printing, these functions can be used to remove/modify the `_renderInfo`\n * of an `Ast.Node`.\n */\n", "import {\n ArgSpecAst as ArgSpec,\n parse as parseArgspec,\n} from \"@unified-latex/unified-latex-util-argspec\";\nimport * as Ast from \"@unified-latex/unified-latex-types\";\nimport { arg } from \"@unified-latex/unified-latex-builder\";\nimport { gobbleSingleArgument } from \"./gobble-single-argument\";\nimport { ArgumentParser } from \"@unified-latex/unified-latex-types\";\n\n/**\n * Gobbles an argument of whose type is specified\n * by `argSpec` starting at the position `startPos`. If an argument couldn't be found,\n * `argument` will be `null`.\n */\nexport function gobbleArguments(\n nodes: Ast.Node[],\n argSpec: string | ArgSpec.Node[] | ArgumentParser,\n startPos = 0\n): {\n args: Ast.Argument[];\n nodesRemoved: number;\n} {\n if (typeof argSpec === \"function\") {\n return argSpec(nodes, startPos);\n }\n\n if (typeof argSpec === \"string\") {\n argSpec = parseArgspec(argSpec);\n }\n\n const args: Ast.Argument[] = [];\n let nodesRemoved = 0;\n for (const spec of argSpec) {\n const { argument, nodesRemoved: removed } = gobbleSingleArgument(\n nodes,\n spec,\n startPos\n );\n if (argument) {\n args.push(argument);\n nodesRemoved += removed;\n } else {\n args.push(arg([], { openMark: \"\", closeMark: \"\" }));\n }\n }\n\n return { args, nodesRemoved };\n}\n", "import { ArgSpecAst as ArgSpec } from \"@unified-latex/unified-latex-util-argspec\";\nimport * as Ast from \"@unified-latex/unified-latex-types\";\nimport { match } from \"@unified-latex/unified-latex-util-match\";\nimport { scan } from \"@unified-latex/unified-latex-util-scan\";\nimport { arg } from \"@unified-latex/unified-latex-builder\";\n\n/**\n * Gobbles an argument of whose type is specified\n * by `argSpec` starting at the position `startPos`. If an argument couldn't be found,\n * `argument` will be `null`.\n */\nexport function gobbleSingleArgument(\n nodes: Ast.Node[],\n argSpec: ArgSpec.Node,\n startPos = 0\n): {\n argument: Ast.Argument | null;\n nodesRemoved: number;\n} {\n if (typeof argSpec === \"string\" || !argSpec.type) {\n throw new Error(\n `argSpec must be an already-parsed argument specification, not \"${JSON.stringify(\n argSpec\n )}\"`\n );\n }\n\n let argument: Ast.Argument | null = null;\n\n let currPos = startPos;\n\n // Gobble whitespace from `currPos` onward, updating `currPos`.\n // If `argSpec` specifies leading whitespace is not allowed,\n // this function does nothing.\n const gobbleWhitespace = (argSpec as ArgSpec.LeadingWhitespace)\n .noLeadingWhitespace\n ? () => {}\n : () => {\n while (currPos < nodes.length) {\n if (!match.whitespace(nodes[currPos])) {\n break;\n }\n currPos++;\n }\n };\n\n const openMark: string = (argSpec as any).openBrace || \"\";\n const closeMark: string = (argSpec as any).closeBrace || \"\";\n\n // Only mandatory arguments can be wrapped in {...}.\n // Since we already parse such things as groups, we need to\n // check the open and closing symbols to see if we allow for\n // groups to be accepted as arguments\n const acceptGroup =\n (argSpec.type === \"mandatory\" || argSpec.type === \"optional\") &&\n openMark === \"{\" &&\n closeMark === \"}\";\n\n // Find the position of the open brace and the closing brace.\n // The position(s) are null if the brace isn't found.\n function findBracePositions(): [number | null, number | null] {\n let openMarkPos: number | null = null;\n if (openMark) {\n openMarkPos = nodes.findIndex(\n (node, i) => i >= currPos && match.string(node, openMark)\n );\n if (openMarkPos < currPos) {\n openMarkPos = null;\n }\n }\n let closeMarkPos: number | null = null;\n if (openMarkPos != null) {\n closeMarkPos = nodes.findIndex(\n (node, i) =>\n i >= (openMarkPos as number) + 1 &&\n match.string(node, closeMark)\n );\n if (closeMarkPos < openMarkPos + 1) {\n closeMarkPos = null;\n }\n }\n return [openMarkPos, closeMarkPos];\n }\n\n // Do the actual matching\n gobbleWhitespace();\n const currNode = nodes[currPos];\n if (\n currNode == null ||\n match.comment(currNode) ||\n match.parbreak(currNode)\n ) {\n return { argument, nodesRemoved: 0 };\n }\n\n switch (argSpec.type) {\n case \"mandatory\":\n if (acceptGroup) {\n // We have already gobbled whitespace, so at this point, `currNode`\n // is either an openMark or we don't have an optional argument.\n let content: Ast.Node[] = [currNode];\n if (match.group(currNode)) {\n // Unwrap a group if there is one.\n content = currNode.content;\n }\n argument = arg(content, {\n openMark,\n closeMark,\n });\n currPos++;\n break;\n }\n // NOTE: Fallthrough is on purpose.\n // Matching a mandatory argument and an optional argument is the same for our purposes\n // because we're not going to fail to parse because of a missing argument.\n case \"optional\":\n // It is possible that an optional argument accepts a group if its open/close braces are `{}`\n if (acceptGroup && match.group(currNode)) {\n argument = arg(currNode.content, {\n openMark,\n closeMark,\n });\n currPos++;\n break;\n }\n if (match.string(currNode, openMark)) {\n // If we're here, we have custom braces to match\n const [openMarkPos, closeMarkPos] = findBracePositions();\n if (openMarkPos != null && closeMarkPos != null) {\n argument = arg(nodes.slice(openMarkPos + 1, closeMarkPos), {\n openMark,\n closeMark,\n });\n currPos = closeMarkPos + 1;\n break;\n }\n }\n break;\n case \"optionalStar\":\n case \"optionalToken\":\n if (\n match.string(\n currNode,\n argSpec.type === \"optionalStar\" ? \"*\" : argSpec.token\n )\n ) {\n argument = arg([currNode], { openMark: \"\", closeMark: \"\" });\n currPos++;\n break;\n }\n break;\n case \"until\": {\n if (argSpec.stopTokens.length > 1) {\n console.warn(\n `\"until\" matches with multi-token stop conditions are not yet implemented`\n );\n break;\n }\n const rawToken = argSpec.stopTokens[0];\n const stopToken: Ast.String | Ast.Whitespace =\n rawToken === \" \"\n ? { type: \"whitespace\" }\n : { type: \"string\", content: argSpec.stopTokens[0] };\n let matchPos = scan(nodes, stopToken, {\n startIndex: startPos,\n allowSubstringMatches: true,\n });\n if (\n matchPos != null &&\n partialStringMatch(nodes[matchPos], stopToken)\n ) {\n console.warn(\n `\"until\" arguments that stop at non-punctuation symbols is not yet implemented`\n );\n break;\n }\n // If the corresponding token is not found, eat nothing;\n if (matchPos == null) {\n break;\n }\n argument = arg(nodes.slice(startPos, matchPos), {\n openMark: \"\",\n closeMark: rawToken,\n });\n currPos = matchPos;\n if (currPos < nodes.length) {\n currPos++;\n }\n break;\n }\n default:\n console.warn(\n `Don't know how to find an argument of argspec type \"${argSpec.type}\"`\n );\n }\n\n // `currPos` is has already stepped past any whitespace. However,\n // if we did not consume an argument, we don't want to consume the whitespace.\n const nodesRemoved = argument ? currPos - startPos : 0;\n nodes.splice(startPos, nodesRemoved);\n return { argument, nodesRemoved };\n}\n\n/**\n * Returns whether the presumed match \"node\" contains \"token\" as a strict\n * substring.\n */\nfunction partialStringMatch(node: Ast.Node, token: Ast.Node): boolean {\n return (\n match.anyString(node) &&\n match.anyString(token) &&\n node.content.length > token.content.length\n );\n}\n", "import * as Ast from \"@unified-latex/unified-latex-types\";\nimport { match } from \"@unified-latex/unified-latex-util-match\";\nimport { MacroInfoRecord } from \"@unified-latex/unified-latex-types\";\nimport { updateRenderInfo } from \"@unified-latex/unified-latex-util-render-info\";\nimport { gobbleArguments } from \"./gobble-arguments\";\nimport { visit } from \"@unified-latex/unified-latex-util-visit\";\n\n/**\n * Search (in a right-associative way) through the array for instances of\n * `macros` and attach arguments to the macro. Argument signatures are\n * specified by `macros[].signature`.\n *\n * Info stored in `macros[].renderInfo` will be attached to the node\n * with attribute `_renderInfo`.\n */\nexport function attachMacroArgsInArray(\n nodes: Ast.Node[],\n macros: MacroInfoRecord\n): void {\n // Some preliminaries that are only used if `ast` is an array.\n let currIndex: number;\n\n /**\n * Determine whether `node` matches one of the macros in `macros`.\n * Care is taken when matching because not all macros have\n * `\\` as their escape token.\n */\n const isRelevantMacro = match.createMacroMatcher(macros);\n\n function gobbleUntilMacro() {\n // Step backwards until we find the required macro\n while (currIndex >= 0 && !isRelevantMacro(nodes[currIndex])) {\n currIndex--;\n }\n }\n\n // Search for an occurrence of any of the macros `macroName` and its arguments.\n // Some macros are right-associative, so we should start searching from\n // the right\n currIndex = nodes.length - 1;\n while (currIndex >= 0) {\n gobbleUntilMacro();\n if (currIndex < 0) {\n // We didn't find an occurrence of the macro\n return;\n }\n\n // Store the currIndex, which is where the macro is. Start searching\n // for its arguments at the next index.\n const macroIndex = currIndex;\n const macro = nodes[macroIndex] as Ast.Macro;\n const macroName = macro.content;\n const macroInfo = macros[macroName];\n\n // Add `._renderInfo` if we have any\n updateRenderInfo(macro, macroInfo.renderInfo);\n\n const signatureOrParser = macroInfo.argumentParser || macroInfo.signature\n\n // If the macro has no signature, it shouldn't consume any arguments. Just move along.\n // Note: It is important that this happens *after* `updateRenderInfo` is called, since\n // we still want to update the render info even if there are no args.\n if (signatureOrParser == null) {\n currIndex--;\n continue;\n }\n\n // We don't want to search for macro arguments if we already\n // found them. If the macro has arguments, we assume that\n // they've already been attached\n if (macro.args != null) {\n currIndex = macroIndex - 1;\n continue;\n }\n\n // `currIndex` is the position of the macro. We want to start\n // looking for the arguments right after the macro\n currIndex++;\n const { args } = gobbleArguments(nodes, signatureOrParser, currIndex);\n macro.args = args;\n // After we've gobbled the arguments, set\n // ourselves one space before the macro so we can continue.\n currIndex = macroIndex - 1;\n }\n}\n\n/**\n * Recursively search for and attach the arguments for a\n * particular macro to its AST node. `macros` should\n * contain a `signature` property which specifies the arguments\n * signature in xparse syntax.\n */\nexport function attachMacroArgs(tree: Ast.Ast, macros: MacroInfoRecord) {\n visit(\n tree,\n (nodes) => {\n attachMacroArgsInArray(nodes, macros);\n },\n { includeArrays: true, test: Array.isArray }\n );\n}\n", "import { Plugin } from \"unified\";\nimport * as Ast from \"@unified-latex/unified-latex-types\";\nimport { MacroInfoRecord } from \"@unified-latex/unified-latex-types\";\nimport { visit } from \"@unified-latex/unified-latex-util-visit\";\nimport { attachMacroArgsInArray } from \"./attach-arguments\";\n\ntype PluginOptions = { macros: MacroInfoRecord } | undefined;\n\n/**\n * Unified plugin to attach macro arguments to the macros specified via the `macros`\n * option.\n *\n * @param macros An object whose keys are macro names and values contains information about the macro and its argument signature.\n */\nexport const unifiedLatexAttachMacroArguments: Plugin<\n PluginOptions[],\n Ast.Root,\n Ast.Root\n> = function unifiedLatexAttachMacroArguments(options) {\n return (tree) => {\n const { macros = {} } = options || {};\n if (Object.keys(macros).length === 0) {\n console.warn(\n \"Attempting to attach macro arguments but no macros are specified.\"\n );\n }\n visit(\n tree,\n (nodes) => {\n attachMacroArgsInArray(nodes, macros);\n },\n { includeArrays: true, test: Array.isArray }\n );\n };\n};\n", "import * as Ast from \"@unified-latex/unified-latex-types\";\n\n/**\n * Returns the content of `args` for a macro or environment as an array. If an argument\n * was omitted (e.g., because it was an optional arg that wasn't included), then `null` is returned.\n */\nexport function getArgsContent(\n node: Ast.Macro | Ast.Environment\n): (Ast.Node[] | null)[] {\n if (!Array.isArray(node.args)) {\n return [];\n }\n\n return node.args.map((arg) => {\n if (arg.openMark === \"\" && arg.content.length === 0) {\n return null;\n }\n return arg.content;\n });\n}\n\n/**\n * Returns the content of `args` for a macro or environment as an object whose keys are the \"names\"\n * of each argument. These names of the arguments must be specified in the `_renderInfo` prop. If `_renderInfo`\n * does not contain a `namedArguments` array, then an empty object will be returned.\n *\n * @namedArgumentsFallback - If `_renderInfo.namedArguments` is not provided, `namedArgumentsFallback` is ued.\n */\nexport function getNamedArgsContent(\n node: Ast.Macro | Ast.Environment,\n namedArgumentsFallback: readonly (string | null)[] = []\n): Record {\n const names = node._renderInfo?.namedArguments || namedArgumentsFallback;\n\n if (\n !Array.isArray(node.args) ||\n !Array.isArray(names) ||\n names.length === 0\n ) {\n return {};\n }\n const ret: Record = {};\n\n node.args.forEach((arg, i) => {\n const name = names[i];\n if (name == null) {\n // If a null name was given, it shouldn't be listed as a named argument.\n return;\n }\n let val: Ast.Node[] | null = arg.content;\n if (arg.openMark === \"\" && arg.content.length === 0) {\n val = null;\n }\n ret[name] = val;\n });\n\n return ret;\n}\n", "import { arg } from \"@unified-latex/unified-latex-builder\";\nimport * as Ast from \"@unified-latex/unified-latex-types\";\nimport {\n ArgSpecAst as ArgSpec,\n parse as parseArgspec,\n} from \"@unified-latex/unified-latex-util-argspec\";\nimport { ArgumentParser } from \"@unified-latex/unified-latex-types\";\nimport { gobbleSingleArgument } from \"@unified-latex/unified-latex-util-arguments\";\nimport { match } from \"@unified-latex/unified-latex-util-match\";\nimport { scan } from \"@unified-latex/unified-latex-util-scan\";\nimport { trim } from \"@unified-latex/unified-latex-util-trim\";\nimport { printRaw } from \"@unified-latex/unified-latex-util-print-raw\";\n\nconst OPTIONAL_ARGUMENT_ARG_SPEC = parseArgspec(\"o\")[0];\n\nfunction blankArg() {\n return arg([], { openMark: \"\", closeMark: \"\" });\n}\n\n/**\n * Find the arguments of a tikz command. Many tikz commands accept either\n * the a group as their only argument, or they scan their arguments until the first\n * `;` is found.\n *\n * This behavior cannot be achieved via a standard xparse spec.\n */\nexport const tikzCommandArgumentParser: ArgumentParser = (nodes, startPos) => {\n const origStartPos = startPos;\n let pos = startPos;\n let nodesRemoved = 0;\n\n const cursorPosAfterAnimations = eatAllAnimationSpecs(nodes, pos);\n let animationArg = blankArg();\n if (cursorPosAfterAnimations !== pos) {\n const argContent = nodes.splice(pos, cursorPosAfterAnimations - pos);\n trim(argContent);\n animationArg = arg(argContent, {\n openMark: \" \",\n closeMark: \" \",\n });\n }\n nodesRemoved += cursorPosAfterAnimations - pos;\n\n const {\n argument: _optionalArgument,\n nodesRemoved: optionalArgumentNodesRemoved,\n } = gobbleSingleArgument(nodes, OPTIONAL_ARGUMENT_ARG_SPEC, pos);\n nodesRemoved += optionalArgumentNodesRemoved;\n const optionalArg = _optionalArgument || blankArg();\n\n // Eat whitespace\n while (match.whitespace(nodes[pos])) {\n pos++;\n }\n const firstNode = nodes[pos];\n\n // If we're past the end of the array, give up.\n if (!firstNode) {\n return {\n args: [animationArg, optionalArg, blankArg()],\n nodesRemoved: 0,\n };\n }\n\n // If we're a group, grab the contents and call it good.\n if (match.group(firstNode)) {\n const args = [animationArg, optionalArg, arg(firstNode.content)];\n nodes.splice(origStartPos, pos - origStartPos + 1);\n return { args, nodesRemoved: pos - origStartPos + 1 + nodesRemoved };\n }\n\n // No group, so scan for a semicolon.\n const semicolonPosition = scan(nodes, \";\", { startIndex: pos });\n if (semicolonPosition != null) {\n const argNodes = nodes.splice(\n origStartPos,\n semicolonPosition - origStartPos + 1\n );\n trim(argNodes);\n const args = [animationArg, optionalArg, arg(argNodes)];\n return {\n args,\n nodesRemoved: origStartPos - semicolonPosition + 1 + nodesRemoved,\n };\n }\n\n // If there was no semicolon, give up.\n return {\n args: [animationArg, optionalArg, blankArg()],\n nodesRemoved: 0,\n };\n};\n\n/**\n * Find the next index after all animation specs. If no animation specs are present,\n * return `startPos`.\n *\n * An animation spec looks like\n * ```\n * :rotate = { 0s=\"0\", 2s=\"90\", begin on=click }\n * ```\n * Any number can be listed. They start with a colon and have an equals sign followed by a group.\n */\nfunction eatAllAnimationSpecs(nodes: Ast.Node[], startPos: number): number {\n const colonPos = scan(nodes, \":\", {\n startIndex: startPos,\n allowSubstringMatches: true,\n onlySkipWhitespaceAndComments: true,\n });\n\n if (!colonPos) {\n return startPos;\n }\n\n let lastMatchPos = startPos;\n let i = colonPos + 1;\n for (; i < nodes.length; i++) {\n const node = nodes[i];\n if (match.string(node, \"[\")) {\n // XXX As per the tikz manual, we stop scanning if we find an open square brace.\n break;\n }\n if (match.string(node, \"=\")) {\n i++;\n // Look for a group next\n while (match.whitespace(nodes[i]) || match.comment(nodes[i])) {\n i++;\n }\n if (!match.group(nodes[i])) {\n break;\n }\n // We have a match!\n lastMatchPos = i + 1;\n\n // Start the process again\n const colonPos = scan(nodes, \":\", {\n startIndex: lastMatchPos,\n allowSubstringMatches: true,\n onlySkipWhitespaceAndComments: true,\n });\n if (colonPos == null) {\n break;\n }\n i = colonPos + 1;\n }\n }\n\n return lastMatchPos;\n}\n", "import * as Ast from \"@unified-latex/unified-latex-types\";\nimport * as TikzSpec from \"./types\";\nimport { match } from \"@unified-latex/unified-latex-util-match\";\nimport { decorateArrayForPegjs } from \"@unified-latex/unified-latex-util-pegjs\";\nimport { TikzPegParser } from \"@unified-latex/unified-latex-util-pegjs\";\n\ntype TikzParseOptions = {\n startRule?: \"path_spec\" | \"foreach_body\";\n};\n\nfunction createMatchers() {\n return {\n isChar: match.string,\n isTerminal: (node: any) => match.string(node, \";\"),\n isOperation: (node: any) =>\n match.anyString(node) && node.content.match(/[a-zA-Z]/),\n isWhitespace: (node: any) =>\n match.whitespace(node) || match.parbreak(node),\n isComment: match.comment,\n isGroup: match.group,\n isMacro: match.macro,\n isAnyMacro: match.anyMacro,\n };\n}\n\nconst matchers = createMatchers();\n\n/**\n * Parse the contents of the `\\systeme{...}` macro\n */\nexport function parse(\n ast: Ast.Node[],\n options?: Options\n): Options extends { startRule: infer R }\n ? R extends \"path_spec\"\n ? TikzSpec.PathSpec\n : TikzSpec.ForeachBody\n : TikzSpec.PathSpec {\n const { startRule = \"path_spec\" } = options || {};\n if (!Array.isArray(ast)) {\n throw new Error(\"You must pass an array of nodes\");\n }\n // We need to at functions to `nodes` so that it imitates\n // a Javascript string. Because we're mutating, make a copy first\n ast = decorateArrayForPegjs([...ast]);\n // matchers are passed in via the second argument (the `options` argument)\n // so they are available from within the Pegjs grammar.\n return TikzPegParser.parse(ast, {\n ...matchers,\n startRule,\n });\n}\n", "import { PgfkeysPegParser } from \"@unified-latex/unified-latex-util-pegjs\";\nimport * as Ast from \"@unified-latex/unified-latex-types\";\nimport { match } from \"@unified-latex/unified-latex-util-match\";\nimport { decorateArrayForPegjs } from \"@unified-latex/unified-latex-util-pegjs\";\n\n// The types returned by the grammar\n\nexport type Item = {\n itemParts?: Ast.Node[][];\n trailingComment: Ast.Comment | null;\n trailingComma?: boolean;\n leadingParbreak?: boolean;\n};\n\nexport function createMatchers() {\n return {\n isChar: (node: Ast.Node, char: string) => match.string(node, char),\n isComma: (node: Ast.Node) => match.string(node, \",\"),\n isEquals: (node: Ast.Node) => match.string(node, \"=\"),\n isWhitespace: (node: Ast.Node) => match.whitespace(node),\n isParbreak: (node: Ast.Node) => match.parbreak(node),\n isSameLineComment: (node: Ast.Node) =>\n match.comment(node) && node.sameline,\n isOwnLineComment: (node: Ast.Node) =>\n match.comment(node) && !node.sameline,\n };\n}\n\n/**\n * Parse the arguments of a Pgfkeys macro. The `ast`\n * is expected to be a comma separated list of `Item`s.\n * Each item can have 0 or more item parts, which are separated\n * by \"=\". If `itemPart` is undefined,\n *\n * If `options.allowParenGroups === true`, then commas that occur inside groups of parenthesis\n * will not be parsed as separators. This is useful for parsing tikz `\\foreach` loops.\n */\nexport function parsePgfkeys(\n ast: Ast.Node[],\n options?: { allowParenGroups: boolean }\n): Item[] {\n if (!Array.isArray(ast)) {\n throw new Error(\"You must pass an array of nodes\");\n }\n const { allowParenGroups = false } = options || {};\n // We need to at functions to `nodes` so that it imitates\n // a Javascript string. Because we're mutating, make a copy first\n ast = decorateArrayForPegjs([...ast]);\n // matchers are passed in via the second argument (the `options` argument)\n // so they are available from within the Pegjs grammar.\n return PgfkeysPegParser.parse(ast, {\n ...createMatchers(),\n allowParenGroups,\n }) as Item[];\n}\n", "import * as Ast from \"@unified-latex/unified-latex-types\";\nimport { match } from \"@unified-latex/unified-latex-util-match\";\nimport { printRaw } from \"@unified-latex/unified-latex-util-print-raw\";\nimport { parsePgfkeys } from \"./pgfkeys-parser\";\n\n/**\n * Parse `arg` as pgfkeys and return a JavaScript object with the results.\n * The keys will be normalized to strings and the values will be arrays of nodes.\n */\nexport function pgfkeysArgToObject(\n arg: Ast.Argument | Ast.Node[]\n): Record {\n function parseFront(nodes: Ast.Node[]): string {\n return printRaw(nodes);\n }\n function parseBack(nodes: Ast.Node[] | undefined): Ast.Node[] {\n if (!nodes) {\n return [];\n }\n // If the only element is a group, we unwrap it\n if (nodes.length === 1 && match.group(nodes[0])) {\n return nodes[0].content;\n }\n return nodes;\n }\n\n let nodeList: Ast.Node[];\n if (match.argument(arg)) {\n nodeList = arg.content;\n } else {\n nodeList = arg;\n }\n const parsedArgs = parsePgfkeys(nodeList);\n return Object.fromEntries(\n parsedArgs\n .filter((part) => part.itemParts)\n .map((part) => [\n parseFront(part.itemParts![0]),\n parseBack(part.itemParts![1]),\n ])\n );\n}\n", "import { Doc } from \"prettier\";\nimport * as Ast from \"@unified-latex/unified-latex-types\";\nimport {\n hardline,\n join,\n breakParent,\n line,\n group,\n indent,\n softline,\n} from \"./common\";\nimport {\n linebreak,\n printRaw,\n} from \"@unified-latex/unified-latex-util-print-raw\";\nimport { parsePgfkeys } from \"@unified-latex/unified-latex-util-pgfkeys\";\n\n/**\n * Format a sequence of Pgfkeys key-value pairs. `nodes` will be parsed\n * by a grammar defining Pgfkeys\n */\nexport function printArgumentPgfkeys(\n nodes: Ast.Node[],\n options: {\n openMark: string;\n closeMark: string;\n leadingComment?: Ast.Comment | null | undefined;\n allowParenGroups?: boolean;\n }\n): Doc {\n const { allowParenGroups = false } = options;\n const parsed = parsePgfkeys(nodes, { allowParenGroups });\n\n const content: Doc[] = [];\n for (const part of parsed) {\n const isLastItem = part === parsed[parsed.length - 1];\n\n if (part.itemParts) {\n // parts are printed using `printRaw`, `hardline` is used in place\n // of \"\\n\"\n const parts = part.itemParts.map((node) =>\n printRaw(node, { asArray: true }).map((token) =>\n token === linebreak ? hardline : token\n )\n );\n const row = join(\"=\", parts);\n content.push(row);\n if (part.trailingComma) {\n content.push(\",\");\n }\n }\n if (part.trailingComment) {\n const leadingContent: Doc[] = part.itemParts ? [\" \"] : [];\n if (part.leadingParbreak) {\n // We preserve parbreaks before comments, so if we have\n // one, insert an extra hardline\n leadingContent.push(hardline);\n }\n\n content.push(\n ...leadingContent,\n // We're carefully and manually controlling the newlines,\n // so print the comment directly without any newlines\n \"%\",\n part.trailingComment.content,\n breakParent\n );\n }\n\n if (!isLastItem) {\n content.push(line);\n }\n }\n\n let leadingComment: Doc[] = [\"\"];\n if (options.leadingComment) {\n if (options.leadingComment.leadingWhitespace) {\n leadingComment.push(\" \");\n }\n leadingComment.push(\"%\" + options.leadingComment.content, breakParent);\n }\n\n return group([\n options.openMark,\n ...leadingComment,\n // If there is no content, we don't want to push an extra `softline`.\n // This matters because the braces group could still be broken by `leadingComment`\n content.length > 0 ? indent([softline, ...content]) : \"\",\n softline,\n options.closeMark,\n ]);\n}\n", "import type { Doc } from \"prettier\";\nimport * as Ast from \"@unified-latex/unified-latex-types\";\nimport * as PrettierTypes from \"./prettier-types\";\nimport {\n getNodeInfo,\n formatDocArray,\n hardline,\n join,\n ifBreak,\n breakParent,\n line,\n group,\n indent,\n softline,\n fill,\n} from \"./common\";\nimport {\n printRaw,\n} from \"@unified-latex/unified-latex-util-print-raw\";\nimport { match } from \"@unified-latex/unified-latex-util-match\";\nimport { trim } from \"@unified-latex/unified-latex-util-trim\";\nimport {\n parse as parseTikz,\n PathSpec,\n PathSpecNode,\n printRaw as tikzPrintRaw,\n} from \"@unified-latex/unified-latex-ctan/package/tikz\";\nimport { printArgumentPgfkeys } from \"./print-argument-pgfkeys\";\n\nexport function printTikzArgument(\n path: PrettierTypes.AstPath,\n print: PrettierTypes.RecursivePrintFunc,\n options: any\n): Doc {\n const node = path.getNode() as Ast.Argument;\n const { renderInfo, previousNode, nextNode, referenceMap } = getNodeInfo(\n node,\n options\n );\n\n const content: Doc[] = [];\n const nodes = [...node.content];\n trim(nodes);\n try {\n const tikzAst = parseTikz(nodes);\n if (tikzAst.content.length === 0) {\n content.push(\";\");\n return content;\n }\n\n const printer = new TikzArgumentPrinter(tikzAst, path, print);\n return printer.toDoc();\n } catch (e) {\n console.warn(\"Encountered error when trying to parse tikz argument\", e);\n }\n\n content.push(\";\");\n\n return content;\n}\n\n/**\n * Print a fragment of an AST to a `Doc`.\n */\nfunction printFragment(\n fragment: Ast.Node | Ast.Argument,\n path: PrettierTypes.AstPath,\n print: PrettierTypes.RecursivePrintFunc\n): Doc {\n const tmpKey = Symbol();\n const currNode = path.getNode();\n if (!currNode) {\n throw new Error(\n \"tried to print a fragment, but the current node is `null`\"\n );\n }\n (currNode as any)[tmpKey] = fragment;\n const ret = print(tmpKey);\n delete (currNode as any)[tmpKey];\n return ret;\n}\n\n/**\n * Turn an item in a tikz PathSpec into a Doc for printing.\n */\nfunction printTikzPathSpecNode(\n node: PathSpecNode,\n path: PrettierTypes.AstPath,\n print: PrettierTypes.RecursivePrintFunc\n): Doc {\n switch (node.type) {\n case \"comment\":\n return printFragment(node, path, print);\n case \"unknown\":\n // `\"unknown\"` nodes contain regular AST nodes as children which couldn't be identified by the parser\n return printFragment(node.content, path, print);\n case \"coordinate\":\n return [printRaw(node.prefix), \"(\", printRaw(node.content), \")\"];\n case \"line_to\":\n return node.command;\n case \"square_brace_group\":\n return printOptionalArgs(node.content);\n case \"operation\":\n return node.content.content;\n case \"svg_operation\": {\n const comments = node.comments.map((n) =>\n printTikzPathSpecNode(n, path, print)\n );\n const options = node.options ? printOptionalArgs(node.options) : [];\n const rest: Doc[] = node.options\n ? [group(indent([line, printRaw(node.content)]))]\n : [\" \", printRaw(node.content)];\n return [...comments, \"svg\", options, ...rest];\n }\n case \"curve_to\": {\n const comments = node.comments.map((n) =>\n printTikzPathSpecNode(n, path, print)\n );\n const printedControls =\n node.controls.length > 1\n ? [\n printTikzPathSpecNode(node.controls[0], path, print),\n \" \",\n \"and\",\n line,\n printTikzPathSpecNode(node.controls[1]!, path, print),\n ]\n : [printTikzPathSpecNode(node.controls[0], path, print)];\n return [\n ...comments,\n \"..\",\n \" \",\n group(\n indent([\"controls\", line, ...printedControls, \" \", \"..\"])\n ),\n ];\n }\n case \"animation\": {\n const comments = node.comments.map((n) =>\n printTikzPathSpecNode(n, path, print)\n );\n\n return [\n ...comments,\n \":\",\n node.attribute,\n \" \",\n \"=\",\n \" \",\n group(\n indent([\n printArgumentPgfkeys(node.content, {\n openMark: \"{\",\n closeMark: \"}\",\n }),\n ])\n ),\n ];\n }\n case \"foreach\": {\n const comments = node.comments.map((n) =>\n printTikzPathSpecNode(n, path, print)\n );\n const variables = [...node.variables];\n trim(variables);\n const list =\n node.list.type === \"macro\"\n ? printFragment(node.list, path, print)\n : printArgumentPgfkeys(node.list.content, {\n openMark: \"{\",\n closeMark: \"}\",\n allowParenGroups: true,\n });\n const doc = [\n ...comments,\n printRaw(node.start),\n \" \",\n printRaw(variables),\n ];\n if (node.options) {\n doc.push(\" \", indent(printOptionalArgs(node.options)));\n }\n\n // The list, e.g. `{1,2,...,9}`\n doc.push(\" \", \"in\", \" \", group(indent(list)));\n // The loop body\n // XXX: if we are in a tikz node, whitespace doesn't matter. If we are in a regular\n // part of the document, the loop body is whitespace-sensitive\n const commandType = node.command.type;\n switch (commandType) {\n case \"foreach\":\n doc.push(\n indent([\n line,\n printTikzPathSpecNode(node.command, path, print),\n ])\n );\n break;\n case \"macro\":\n doc.push(\n indent([line, printFragment(node.command, path, print)])\n );\n break;\n case \"group\": {\n const groupContent = [...node.command.content];\n trim(groupContent);\n doc.push(\n \" \",\n indent(\n group([\n \"{\",\n indent([\n softline,\n ...groupContent.map((n) =>\n printFragment(n, path, print)\n ),\n ]),\n softline,\n \"}\",\n ])\n )\n );\n break;\n }\n default:\n const invalidType: void = commandType;\n console.warn(\n `Unhandled command type when printing \"foreach\": ${invalidType}`\n );\n }\n\n return indent(doc);\n }\n }\n console.warn(\n `Encountered unknown type when trying to print tikz PathSpec: \"${\n (node as any).type\n }\"`\n );\n return [];\n}\n\nfunction printOptionalArgs(nodes: Ast.Node[]): Doc {\n return printArgumentPgfkeys(nodes, {\n openMark: \"[\",\n closeMark: \"]\",\n });\n}\n\n/**\n * Utility to turn a Tikz PathSpec into a Prettier Doc.\n */\nclass TikzArgumentPrinter {\n #path: PrettierTypes.AstPath;\n #print: PrettierTypes.RecursivePrintFunc;\n nodes: PathSpec[\"content\"];\n constructor(\n spec: PathSpec,\n path: PrettierTypes.AstPath,\n print: PrettierTypes.RecursivePrintFunc\n ) {\n this.#path = path;\n this.#print = print;\n this.nodes = [...spec.content];\n }\n\n nodeToDoc(node: PathSpecNode): Doc {\n return printTikzPathSpecNode(node, this.#path, this.#print);\n }\n\n toDoc(): Doc {\n const doc: Doc = [];\n const startArg = this.eatOptionalArg();\n if (startArg.optionalArg) {\n doc.push(\n ...startArg.comments.map((c) =>\n printFragment(c, this.#path, this.#print)\n )\n );\n doc.push(printOptionalArgs(startArg.optionalArg.content));\n }\n\n const innerDoc: Doc = [];\n doc.push(group([indent(innerDoc), \";\"]));\n let cycle = -1;\n while (this.nodes.length > 0) {\n cycle++;\n // If this is the first item being printed and the draw command has no optional\n // argument, then we force the command to start printing on the same line.\n const firstSep = cycle === 0 && !startArg.optionalArg ? \" \" : line;\n const comingUp = this.peek();\n switch (comingUp) {\n case \"short_path\": {\n const [n0, n1, n2] = this.nodes.splice(0, 3);\n // A short path does not break\n innerDoc.push(\n firstSep,\n this.nodeToDoc(n0),\n \" \",\n this.nodeToDoc(n1),\n \" \",\n this.nodeToDoc(n2)\n );\n continue;\n }\n case \"long_path\": {\n // A long path consists of at least a node followed by a joiner\n const [n0, n1] = this.nodes.splice(0, 2);\n if (n1.type === \"operation\") {\n this.nodes.unshift(n1);\n innerDoc.push(\n firstSep,\n this.nodeToDoc(n0),\n \" \",\n this.eatOperation()\n );\n } else {\n innerDoc.push(\n firstSep,\n this.nodeToDoc(n0),\n \" \",\n this.nodeToDoc(n1)\n );\n }\n continue;\n }\n case \"node\":\n {\n const eatenNode = this.eatNode();\n if (eatenNode) {\n innerDoc.push(line, ...eatenNode);\n continue;\n }\n console.warn(\n \"Expected to print a tikz `node` PathSpec but couldn't find the text `node`\"\n );\n }\n continue;\n case \"operation\":\n innerDoc.push(firstSep, this.eatOperation());\n continue;\n case \"unknown\": {\n const node = this.nodes.shift()!;\n innerDoc.push(firstSep, this.nodeToDoc(node));\n continue;\n }\n }\n this.nodes.shift();\n }\n\n return doc;\n }\n\n /**\n * Look at the current node and the nodes that follow. Return what\n * \"type\" is recognized.\n */\n peek() {\n // A short path is two coordinates, joined by a line_to (with no coordinates/line_to's following).\n // If there are comments intermixed, the short path is broken.\n const [n0, n1, n2, n3] = [\n this.nodes[0],\n this.nodes[1],\n this.nodes[2],\n this.nodes[3],\n ];\n if (n0?.type === \"coordinate\" && isPathJoinOperation(n1)) {\n if (\n n2?.type === \"coordinate\" &&\n !(n3?.type === \"coordinate\" || isPathJoinOperation(n3))\n ) {\n return \"short_path\";\n }\n return \"long_path\";\n }\n if (n0?.type === \"operation\") {\n if (n0.content.content === \"node\") {\n // Nodes are a special type of operation.\n return \"node\";\n }\n return \"operation\";\n }\n\n return \"unknown\";\n }\n\n /**\n * Eat comments and an optional arg if present. If no optional\n * arg is present, do nothing.\n */\n eatOptionalArg() {\n let i = 0;\n const comments: Ast.Comment[] = [];\n let optionalArg:\n | (PathSpecNode & { type: \"square_brace_group\" })\n | null = null;\n for (; i < this.nodes.length; i++) {\n const node = this.nodes[i];\n if (node.type === \"square_brace_group\") {\n optionalArg = node;\n i++;\n break;\n }\n if (node.type === \"comment\") {\n comments.push(node);\n continue;\n }\n break;\n }\n if (optionalArg) {\n // If we grabbed an optional argument, remove it and everything\n // preceding it.\n this.nodes.splice(0, i);\n }\n return { optionalArg, comments };\n }\n\n /**\n * Eat a `type === \"operation\"` node whose contents is `\"node\"`. I.e.,\n * the type of thing that shows up in `\\path node at (1,1) {foo};`\n */\n eatNode(): Doc[] | null {\n const firstNode = this.nodes[0];\n if (\n firstNode?.type === \"operation\" &&\n firstNode.content.content === \"node\"\n ) {\n this.nodes.shift();\n } else {\n return null;\n }\n\n // From the tikz documentation:\n // \\path \u2026 node \u27E8foreach statements\u27E9 [\u27E8options\u27E9] (\u27E8name\u27E9) at(\u27E8coordinate\u27E9)\n // :\u27E8animation attribute\u27E9={\u27E8options\u27E9} {\u27E8node contents\u27E9} \u2026;\n //\n // Order of the parts of the specification.\n // Everything between \u201Cnode\u201D and the opening brace of a node is optional.\n // If there are \u27E8foreach statements\u27E9, they must come first, directly following \u201Cnode\u201D.\n // Other than that, the ordering of all the other elements of a node specification\n // (the \u27E8options\u27E9, the \u27E8name\u27E9, \u27E8coordinate\u27E9, and \u27E8animation attribute\u27E9) is arbitrary, indeed,\n // there can be multiple occurrences of any of these elements (although for the name and the\n // coordinate this makes no sense).\n\n const innerDoc: Doc = [];\n const commentBlock: Doc = [];\n const doc: Doc = [commentBlock, \"node\", group(indent(innerDoc))];\n // We now peek to see if a group `{...}` is the next thing. If so,\n // we're going to eat everything up to it and call it quits. Otherwise,\n // we bail.\n let hasNodeArgument = false;\n let shouldBail = false;\n let i = 0;\n const comments: Doc[] = [];\n const options: Doc[] = [];\n const name: Doc[] = [];\n const atLocations: Doc[] = [];\n const animations: Doc[] = [];\n let content: Doc = [];\n for (; i < this.nodes.length && !shouldBail; i++) {\n const node = this.nodes[i];\n switch (node.type) {\n case \"animation\":\n animations.push(this.nodeToDoc(node));\n continue;\n case \"comment\": {\n const comment: Ast.Comment = {\n ...node,\n leadingWhitespace: false,\n };\n comments.push(this.nodeToDoc(comment));\n continue;\n }\n case \"square_brace_group\":\n options.push(printOptionalArgs(node.content));\n continue;\n case \"coordinate\":\n name.push(this.nodeToDoc(node));\n continue;\n case \"operation\": {\n // An \"at\" should be followed by a coordinate or a macro. If it is,\n // then we slurp it. Otherwise we bail.\n if (node.content.content === \"at\") {\n const nextNode = this.nodes[i + 1];\n if (\n !nextNode ||\n !(\n nextNode.type === \"coordinate\" ||\n (nextNode.type === \"unknown\" &&\n match.anyMacro(nextNode.content))\n )\n ) {\n shouldBail = true;\n continue;\n }\n atLocations.push([\"at\", \" \", this.nodeToDoc(nextNode)]);\n i++;\n continue;\n }\n shouldBail = true;\n continue;\n }\n case \"unknown\": {\n // If we're here, we must be the termination group.\n if (match.group(node.content)) {\n hasNodeArgument = true;\n content = this.nodeToDoc(node);\n }\n // NOTE: the fallthrough here is on purpose. Finding the terminating\n // groups should end our loop.\n }\n }\n break;\n }\n if (!hasNodeArgument) {\n return innerDoc;\n }\n // We have collected docs for all the nodes we've scanned, so delete\n // them from the list.\n this.nodes.splice(0, i + 1);\n\n // We standardize node rendering as `[options] :animations (name) at (pos) {content}`\n let isFirstElement = true;\n let isNamed = !(Array.isArray(name) && name.length === 0);\n // Comments get hoisted to before the \"node\" keyword\n for (const comment of comments) {\n commentBlock.push(comment, hardline);\n }\n if (options.length > 0) {\n innerDoc.push(join(\" \", options));\n isFirstElement = false;\n }\n if (animations.length > 0) {\n innerDoc.push(isFirstElement ? \" \" : line);\n innerDoc.push(join(line, animations));\n isFirstElement = false;\n }\n if (isNamed) {\n innerDoc.push(isFirstElement ? \" \" : line);\n innerDoc.push(name);\n isFirstElement = false;\n }\n if (atLocations.length > 0) {\n innerDoc.push(isFirstElement || isNamed ? \" \" : line);\n innerDoc.push(join(line, atLocations));\n isFirstElement = false;\n }\n innerDoc.push(line, content);\n\n return doc;\n }\n\n /**\n * Eat a `type === \"operation\"` node, including its optional arguments.\n */\n eatOperation(): Doc[] {\n const node = this.nodes[0];\n if (node?.type === \"operation\") {\n this.nodes.shift();\n } else {\n return [];\n }\n\n const doc: Doc[] = [];\n if (node?.type !== \"operation\") {\n throw new Error(\"Expecting `operation` node.\");\n }\n const options = this.eatOptionalArg();\n doc.push(\n ...options.comments.map((c) =>\n printFragment(c, this.#path, this.#print)\n ),\n node.content.content\n );\n if (options.optionalArg) {\n doc.push(indent(printOptionalArgs(options.optionalArg.content)));\n }\n\n return doc;\n }\n}\n\nconst PATH_JOIN_OPERATIONS = new Set([\"rectangle\", \"grid\", \"sin\", \"cos\", \"to\"]);\n/**\n * Return whether `node` is a \"path join\", like `--`, `rectangle`, etc.\n *\n * A path join is an operation that sits between two coordinates, like\n * `(a) -- (b)` or `(a) rectangle (b)`.\n */\nfunction isPathJoinOperation(node?: PathSpecNode): boolean {\n if (!node) {\n return false;\n }\n switch (node.type) {\n case \"line_to\":\n case \"curve_to\":\n return true;\n case \"operation\":\n return PATH_JOIN_OPERATIONS.has(node.content.content);\n }\n return false;\n}\n", "import type { Doc } from \"prettier\";\nimport * as Ast from \"@unified-latex/unified-latex-types\";\nimport * as PrettierTypes from \"./prettier-types\";\nimport { getNodeInfo, formatDocArray, hardline, ifBreak, fill } from \"./common\";\nimport { match } from \"@unified-latex/unified-latex-util-match\";\nimport { trim } from \"@unified-latex/unified-latex-util-trim\";\nimport { printTikzArgument } from \"./tikz\";\nimport { printArgumentPgfkeys } from \"./print-argument-pgfkeys\";\n\nexport function printArgument(\n path: PrettierTypes.AstPath,\n print: PrettierTypes.RecursivePrintFunc,\n options: any\n): Doc {\n const node = path.getNode() as Ast.Argument;\n const { renderInfo, previousNode, nextNode, referenceMap } = getNodeInfo(\n node,\n options\n );\n\n // We can return early for empty arguments (this is common for omitted optional arguments)\n if (\n node.openMark === \"\" &&\n node.closeMark === \"\" &&\n node.content.length === 0\n ) {\n return [];\n }\n const parentNode = path.getParentNode();\n const { renderInfo: parentRenderInfo } = getNodeInfo(parentNode, options);\n // We handle printing pgfkeys arguments manually\n if (parentRenderInfo.pgfkeysArgs) {\n const leadingComment =\n node.content.length > 0 &&\n match.comment(node.content[0]) &&\n node.content[0].sameline\n ? node.content[0]\n : null;\n const content = leadingComment ? node.content.slice(1) : node.content;\n trim(content);\n return printArgumentPgfkeys(content, {\n openMark: node.openMark,\n closeMark: node.closeMark,\n leadingComment,\n });\n }\n if (parentRenderInfo.tikzPathCommand) {\n return printTikzArgument(path, print, options);\n }\n\n // Regular argument printing\n const openMark = node.openMark;\n const closeMark = node.closeMark;\n let content = path.map(print, \"content\");\n content = formatDocArray(node.content, content, options);\n\n // if the last item is a comment, we need to insert a hardline\n if (match.comment(node.content[node.content.length - 1])) {\n content.push(hardline);\n }\n\n let rawRet: Doc[] = [openMark, fill(content), closeMark];\n if (renderInfo.inParMode) {\n // In paragraph node, arguments should flow just like text\n rawRet = [openMark, ...content, closeMark];\n }\n if (referenceMap) {\n // Save the raw rendered data in case a renderer higher up\n // wants to unwrap it\n referenceMap.setRenderCache(node, rawRet);\n }\n\n return rawRet;\n}\n", "import type { Doc } from \"prettier\";\nimport * as Ast from \"@unified-latex/unified-latex-types\";\nimport * as PrettierTypes from \"./prettier-types\";\nimport { getNodeInfo, fill, formatDocArray } from \"./common\";\nimport { match } from \"@unified-latex/unified-latex-util-match\";\n\n/**\n * Returns true if a `\\documentclass` macro is detected,\n * which would indicate that the node list contains the preamble.\n *\n * @param {[object]} nodes\n */\nexport function hasPreambleCode(nodes: Ast.Node[]) {\n return nodes.some((node) => match.macro(node, \"documentclass\"));\n}\n\nexport function printRoot(\n path: PrettierTypes.AstPath,\n print: PrettierTypes.RecursivePrintFunc,\n options: any\n): Doc {\n const node = path.getNode() as Ast.Root;\n const { renderInfo, previousNode, nextNode, referenceMap } = getNodeInfo(\n node,\n options\n );\n\n const content = path.map(print, \"content\");\n const rawContent = formatDocArray(node.content, content, options);\n\n const concatFunction = hasPreambleCode(node.content) ? (x: any) => x : fill;\n return concatFunction(rawContent);\n}\n", "import type { Doc } from \"prettier\";\nimport * as Ast from \"@unified-latex/unified-latex-types\";\nimport { printRaw } from \"@unified-latex/unified-latex-util-print-raw\";\nimport * as PrettierTypes from \"./prettier-types\";\n\nexport function printComment(\n path: PrettierTypes.AstPath,\n _print: PrettierTypes.RecursivePrintFunc,\n _options: any\n): Doc {\n const node = path.getNode() as Ast.Comment;\n\n // If a comment is on the same line as other content and it has leading whitespace,\n // add a single whitespace token.\n let leadingWhitespace = \"\";\n if (node.leadingWhitespace && node.sameline) {\n leadingWhitespace = \" \";\n }\n\n const content: Doc[] = [leadingWhitespace, \"%\" + printRaw(node.content)];\n return content;\n}\n", "import type { Doc } from \"prettier\";\nimport * as Ast from \"@unified-latex/unified-latex-types\";\nimport * as PrettierTypes from \"./prettier-types\";\nimport {\n getNodeInfo,\n softline,\n fill,\n hardline,\n line,\n indent,\n ESCAPE,\n joinWithSoftline,\n formatDocArray,\n} from \"./common\";\n\nexport function printInlineMath(\n path: PrettierTypes.AstPath,\n print: PrettierTypes.RecursivePrintFunc,\n options: any\n): Doc {\n const node = path.getNode() as Ast.InlineMath;\n\n // Since `$$` starts display math mode (in plain TeX),\n // an empty inline math environment must be printed as `$ $`.\n // We special case this.\n if (node.content.length === 0) {\n // We won't allow an empty math environment to be broken\n return [\"$\", \" \", \"$\"];\n }\n\n let content = path.map(print, \"content\");\n content = formatDocArray(node.content, content, options);\n content = joinWithSoftline(content);\n\n // If the last node is a comment, we need a linebreak before the closing `$`\n if (node.content[node.content.length - 1].type === \"comment\") {\n content.push(hardline);\n }\n\n return fill([\"$\", ...content, \"$\"]);\n}\n\nexport function printDisplayMath(\n path: PrettierTypes.AstPath,\n print: PrettierTypes.RecursivePrintFunc,\n options: any\n): Doc {\n const node = path.getNode() as Ast.InlineMath;\n\n let content = path.map(print, \"content\");\n content = formatDocArray(node.content, content, options);\n content = joinWithSoftline(content);\n\n // If we start with a comment on the same line as the environment\n // We should not insert a newline at the start of the environment body\n const bodyStartToken: PrettierTypes.Doc[] = [hardline];\n if (\n node.content.length === 0 ||\n (node.content[0].type === \"comment\" && node.content[0].sameline)\n ) {\n bodyStartToken.pop();\n }\n\n return [\n ESCAPE + \"[\",\n indent(fill(bodyStartToken.concat(content))),\n hardline,\n ESCAPE + \"]\",\n ];\n}\n", "import * as Ast from \"@unified-latex/unified-latex-types\";\nimport { match } from \"@unified-latex/unified-latex-util-match\";\nimport {\n AlignEnvironmentPegParser,\n decorateArrayForPegjs,\n} from \"@unified-latex/unified-latex-util-pegjs\";\n\n// The types returned by the grammar\ninterface RowItems {\n cells: Ast.Node[][];\n colSeps: Ast.String[];\n}\n\ninterface Row extends RowItems {\n rowSep: Ast.Macro | null;\n trailingComment: Ast.Comment | null;\n}\n\nexport function createMatchers(rowSepMacros: string[], colSep: string[]) {\n const isRowSep = match.createMacroMatcher(rowSepMacros);\n return {\n isRowSep,\n isColSep: (node: Ast.Node) =>\n colSep.some((sep) => match.string(node, sep)),\n isWhitespace: (node: Ast.Node) => match.whitespace(node),\n isSameLineComment: (node: Ast.Node) =>\n match.comment(node) && node.sameline,\n isOwnLineComment: (node: Ast.Node) =>\n match.comment(node) && !node.sameline,\n };\n}\n\n/**\n * Parse the content of an align environment into an array of row objects.\n * Each row object looks like\n * ```\n * {\n * cells: [...],\n * colSeps: [...],\n * rowSep: ...,\n * trailingComment: ...\n * }\n * ```\n * `...` may be an ast node or `null`.\n *\n * @export\n * @param {[object]} ast\n * @param {string} [colSep=[\"&\"]]\n * @param {string} [rowSepMacros=[\"\\\\\", \"hline\", \"cr\"]]\n * @returns\n */\nexport function parseAlignEnvironment(\n ast: Ast.Node[],\n colSep = [\"&\"],\n rowSepMacros = [\"\\\\\", \"hline\", \"cr\"]\n): Row[] {\n if (!Array.isArray(ast)) {\n throw new Error(\"You must pass an array of nodes\");\n }\n // We need to at functions to `nodes` so that it imitates\n // a Javascript string. Because we're mutating, make a copy first\n ast = decorateArrayForPegjs([...ast]);\n // matchers are passed in via the second argument (the `options` argument)\n // so they are available from within the Pegjs grammar.\n return AlignEnvironmentPegParser.parse(\n ast,\n createMatchers(rowSepMacros, colSep)\n ) as Row[];\n}\n", "import type { Doc } from \"prettier\";\nimport * as PrettierTypes from \"./prettier-types\";\nimport {\n getNodeInfo,\n softline,\n fill,\n indent,\n hardline,\n line,\n ESCAPE,\n formatEnvSurround,\n joinWithSoftline,\n formatDocArray,\n} from \"./common\";\nimport { printRaw } from \"@unified-latex/unified-latex-util-print-raw\";\nimport { parseAlignEnvironment } from \"@unified-latex/unified-latex-util-align\";\nimport * as Ast from \"@unified-latex/unified-latex-types\";\nimport { trim } from \"@unified-latex/unified-latex-util-trim\";\n\nexport function printVerbatimEnvironment(\n path: PrettierTypes.AstPath,\n print: PrettierTypes.RecursivePrintFunc,\n options: any\n): Doc {\n const node = path.getNode() as Ast.VerbatimEnvironment;\n\n const env = formatEnvSurround(node as any);\n\n return [env.start, node.content, env.end];\n}\n\nexport function printEnvironment(\n path: PrettierTypes.AstPath,\n print: PrettierTypes.RecursivePrintFunc,\n options: any\n): Doc {\n const node = path.getNode() as Ast.Environment;\n const { renderInfo, previousNode, nextNode, referenceMap } = getNodeInfo(\n node,\n options\n );\n\n const args = node.args ? path.map(print, \"args\" as any) : [];\n const env = formatEnvSurround(node);\n\n let content = path.map(print, \"content\");\n content = formatDocArray(node.content, content, options);\n if (renderInfo.inMathMode) {\n content = joinWithSoftline(content);\n }\n\n // If we start with a comment on the same line as the environment\n // We should not insert a newline at the start of the environment body\n let bodyStartToken: PrettierTypes.Doc[] = [hardline];\n if (\n node.content.length === 0 ||\n (node.content[0].type === \"comment\" && node.content[0].sameline)\n ) {\n bodyStartToken.pop();\n }\n\n return [\n env.start,\n ...args,\n indent(fill(bodyStartToken.concat(content))),\n hardline,\n env.end,\n ];\n}\n\nexport function printAlignedEnvironment(\n path: PrettierTypes.AstPath,\n print: PrettierTypes.RecursivePrintFunc,\n options: any\n): Doc {\n const node = path.getNode() as Ast.Environment;\n const { renderInfo, previousNode, nextNode, referenceMap } = getNodeInfo(\n node,\n options\n );\n\n const args = node.args ? path.map(print, \"args\" as any) : [];\n const env = formatEnvSurround(node);\n\n // If an aligned environment starts with a same-line comment, we want\n // to ignore it. It will be printed by the environment itself.\n const leadingComment =\n node.content[0] &&\n node.content[0].type === \"comment\" &&\n node.content[0].sameline\n ? node.content[0]\n : null;\n\n const { rows, rowSeps, trailingComments } = formatAlignedContent(\n leadingComment ? node.content.slice(1) : node.content\n );\n\n const content = [];\n for (let i = 0; i < rows.length; i++) {\n const row = rows[i];\n const rowSep = rowSeps[i];\n const trailingComment = trailingComments[i];\n\n // A row has\n // 1) Content\n // 2) (optional) rowSep (e.g., `\\\\`)\n // 3) (optional) comment\n // We want there to be exactly one space before the rowsep and exactly one space\n // before any comment.\n content.push(row);\n if (rowSep) {\n content.push(printRaw(rowSep));\n }\n if (rowSep && trailingComment) {\n content.push(\" \");\n }\n if (trailingComment) {\n content.push([\"%\", printRaw(trailingComment.content)]);\n }\n if (rowSep || trailingComment) {\n content.push(hardline);\n }\n }\n // Make sure the last item is not a `hardline`.\n if (content[content.length - 1] === hardline) {\n content.pop();\n }\n\n if (leadingComment) {\n content.unshift(\n leadingComment.leadingWhitespace ? \" \" : \"\",\n \"%\" + printRaw(leadingComment.content),\n hardline\n );\n return [env.start, ...args, indent(content), hardline, env.end];\n }\n return [\n env.start,\n ...args,\n indent([hardline, ...content]),\n hardline,\n env.end,\n ];\n}\n\n/**\n * Formats the content of an aligned/tabular environment's content.\n * Ensures the \"&\" delimiters all line up.\n *\n * @export\n * @param {[object]} nodes\n * @returns {{rows: [string], rowSeps: [object]}}\n */\nexport function formatAlignedContent(nodes: Ast.Node[]) {\n function getSpace(len = 1) {\n return \" \".repeat(len);\n }\n\n const rows = parseAlignEnvironment(nodes as any);\n // Find the number of columns\n const numCols = Math.max(...rows.map((r) => r.cells.length));\n const rowSeps = rows.map(({ rowSep }) => printRaw(rowSep || []));\n const trailingComments = rows.map(({ trailingComment }) => trailingComment);\n\n // Get the widths of each column.\n // Column widths will be the width of column contents plus the width\n // of the separator. This way, even multi-character separators\n // can be accommodated when rendering.\n const renderedRows = rows.map(({ cells, colSeps }) => ({\n cells: cells.map((nodes) => {\n trim(nodes);\n\n return printRaw(nodes);\n }),\n seps: colSeps.map((nodes) => printRaw(nodes)),\n }));\n const colWidths: number[] = [];\n for (let i = 0; i < numCols; i++) {\n colWidths.push(\n Math.max(\n ...renderedRows.map(\n ({ cells, seps }) =>\n ((cells[i] || \"\") + (seps[i] || \"\")).length\n )\n )\n );\n }\n\n const joinedRows = renderedRows.map(({ cells, seps }) => {\n if (cells.length === 1 && cells[0] === \"\") {\n return \"\";\n }\n let ret = \"\";\n for (let i = 0; i < cells.length; i++) {\n // There are at least as many cells as there are `seps`. Possibly one extra\n const width = colWidths[i] - (seps[i] || \"\").length;\n\n // Insert a space at the start so we don't run into the prior separator.\n // We'll trim this off in the end, in case it's not needed.\n ret +=\n (i === 0 ? \"\" : \" \") +\n cells[i] +\n getSpace(width - cells[i].length + 1) +\n (seps[i] || \"\");\n }\n return ret;\n });\n\n return { rows: joinedRows, rowSeps, trailingComments };\n}\n", "import * as Ast from \"@unified-latex/unified-latex-types\";\nimport { visit } from \"@unified-latex/unified-latex-util-visit\";\n\n/**\n * Generate a data structure that can be queried\n * for the next/previous node. This allows for \"peeking\"\n * during the rendering process.\n *\n * @class ReferenceMap\n */\nexport class ReferenceMap {\n ast: Ast.Ast;\n map: Map<\n Ast.Ast,\n { previous?: Ast.Ast; next?: Ast.Ast; renderCache?: any }\n >;\n\n constructor(ast: Ast.Ast) {\n this.ast = ast;\n this.map = new Map();\n visit(\n this.ast,\n (nodeList) => {\n for (let i = 0; i < nodeList.length; i++) {\n this.map.set(nodeList[i], {\n previous: nodeList[i - 1],\n next: nodeList[i + 1],\n });\n }\n },\n { includeArrays: true, test: Array.isArray }\n );\n }\n\n /**\n * Associate render-specific data with this node. This data\n * will be overwritten if `setRenderCache` is called twice.\n *\n * @param {Ast.Ast} node\n * @param {*} data\n * @memberof ReferenceMap\n */\n setRenderCache(node: any, data: any): void {\n const currData = this.map.get(node) || {};\n this.map.set(node, { ...currData, renderCache: data });\n }\n\n /**\n * Retrieve data associated with `node` via `setRenderCache`\n *\n * @param {Ast.Ast} node\n * @returns {(object | undefined)}\n * @memberof ReferenceMap\n */\n getRenderCache(node: any): object | any[] | undefined {\n return this.map.get(node)?.renderCache;\n }\n\n getPreviousNode(node: Ast.Ast): Ast.Node | undefined {\n return (this.map.get(node) || ({} as any)).previous;\n }\n\n getNextNode(node: Ast.Ast): Ast.Node | undefined {\n return (this.map.get(node) || ({} as any)).next;\n }\n}\n", "import type { Doc } from \"prettier\";\nimport * as PrettierTypes from \"./prettier-types\";\n\nimport { hardline, line, ESCAPE, getNodeInfo } from \"./common\";\nimport { printMacro } from \"./macro\";\nimport { printArgument } from \"./argument\";\nimport { printRoot } from \"./root\";\nimport { printComment } from \"./comment\";\nimport { printInlineMath, printDisplayMath } from \"./math\";\nimport {\n printVerbatimEnvironment,\n printEnvironment,\n printAlignedEnvironment,\n} from \"./environment\";\nimport {\n linebreak,\n printRaw,\n} from \"@unified-latex/unified-latex-util-print-raw\";\nimport { ReferenceMap } from \"../reference-map\";\n\nexport function printLatexAst(\n path: PrettierTypes.AstPath,\n options: PrettierTypes.Options & { referenceMap?: ReferenceMap },\n print: PrettierTypes.RecursivePrintFunc\n): Doc {\n const node = path.getValue();\n const { renderInfo } = getNodeInfo(node, options);\n\n if (node == null) {\n return node;\n }\n if (typeof node === \"string\") {\n return node;\n }\n\n switch (node.type) {\n case \"root\":\n // Create the ReferenceMap from the root node, so that\n // it can traverse the entire AST\n if (options.referenceMap) {\n console.warn(\n \"Processing root node, but ReferenceMap already exists. Are there multiple nodes of type 'root'?\"\n );\n }\n options.referenceMap = new ReferenceMap(node);\n return printRoot(path, print, options);\n case \"argument\":\n return printArgument(path, print, options);\n case \"comment\":\n return printComment(path, print, options);\n case \"environment\":\n case \"mathenv\":\n if (renderInfo.alignContent) {\n return printAlignedEnvironment(path, print, options);\n }\n return printEnvironment(path, print, options);\n case \"displaymath\":\n return printDisplayMath(path, print, options);\n case \"group\":\n // When we print a group, we are conservative and do a raw print of its contents.\n // However, we want to use `linebreak`s instead of literal `\\n` tokens.\n const content = printRaw(node.content, {\n asArray: true,\n }).map((token) => (token === linebreak ? hardline : token));\n return [\"{\", ...content, \"}\"];\n case \"inlinemath\":\n return printInlineMath(path, print, options);\n case \"macro\":\n return printMacro(path, print, options);\n case \"parbreak\":\n return [hardline, hardline];\n case \"string\":\n return node.content;\n case \"verb\":\n return [\n ESCAPE,\n node.env,\n node.escape,\n printRaw(node.content),\n node.escape,\n ];\n case \"verbatim\":\n return printVerbatimEnvironment(path, print, options);\n case \"whitespace\":\n return line;\n default:\n console.warn(\"Printing unknown type\", node);\n return printRaw(node);\n }\n}\n", "/**\n * Throw a given error.\n *\n * @param {Error|null|undefined} [error]\n * Maybe error.\n * @returns {asserts error is null|undefined}\n */\nexport function bail(error) {\n if (error) {\n throw error\n }\n}\n", "/**\n * @typedef {import('unist').Node} Node\n * @typedef {import('vfile').VFileCompatible} VFileCompatible\n * @typedef {import('vfile').VFileValue} VFileValue\n * @typedef {import('..').Processor} Processor\n * @typedef {import('..').Plugin} Plugin\n * @typedef {import('..').Preset} Preset\n * @typedef {import('..').Pluggable} Pluggable\n * @typedef {import('..').PluggableList} PluggableList\n * @typedef {import('..').Transformer} Transformer\n * @typedef {import('..').Parser} Parser\n * @typedef {import('..').Compiler} Compiler\n * @typedef {import('..').RunCallback} RunCallback\n * @typedef {import('..').ProcessCallback} ProcessCallback\n *\n * @typedef Context\n * @property {Node} tree\n * @property {VFile} file\n */\n\nimport {bail} from 'bail'\nimport isBuffer from 'is-buffer'\nimport extend from 'extend'\nimport isPlainObj from 'is-plain-obj'\nimport {trough} from 'trough'\nimport {VFile} from 'vfile'\n\n// Expose a frozen processor.\nexport const unified = base().freeze()\n\nconst own = {}.hasOwnProperty\n\n// Function to create the first processor.\n/**\n * @returns {Processor}\n */\nfunction base() {\n const transformers = trough()\n /** @type {Processor['attachers']} */\n const attachers = []\n /** @type {Record} */\n let namespace = {}\n /** @type {boolean|undefined} */\n let frozen\n let freezeIndex = -1\n\n // Data management.\n // @ts-expect-error: overloads are handled.\n processor.data = data\n processor.Parser = undefined\n processor.Compiler = undefined\n\n // Lock.\n processor.freeze = freeze\n\n // Plugins.\n processor.attachers = attachers\n // @ts-expect-error: overloads are handled.\n processor.use = use\n\n // API.\n processor.parse = parse\n processor.stringify = stringify\n // @ts-expect-error: overloads are handled.\n processor.run = run\n processor.runSync = runSync\n // @ts-expect-error: overloads are handled.\n processor.process = process\n processor.processSync = processSync\n\n // Expose.\n return processor\n\n // Create a new processor based on the processor in the current scope.\n /** @type {Processor} */\n function processor() {\n const destination = base()\n let index = -1\n\n while (++index < attachers.length) {\n destination.use(...attachers[index])\n }\n\n destination.data(extend(true, {}, namespace))\n\n return destination\n }\n\n /**\n * @param {string|Record} [key]\n * @param {unknown} [value]\n * @returns {unknown}\n */\n function data(key, value) {\n if (typeof key === 'string') {\n // Set `key`.\n if (arguments.length === 2) {\n assertUnfrozen('data', frozen)\n namespace[key] = value\n return processor\n }\n\n // Get `key`.\n return (own.call(namespace, key) && namespace[key]) || null\n }\n\n // Set space.\n if (key) {\n assertUnfrozen('data', frozen)\n namespace = key\n return processor\n }\n\n // Get space.\n return namespace\n }\n\n /** @type {Processor['freeze']} */\n function freeze() {\n if (frozen) {\n return processor\n }\n\n while (++freezeIndex < attachers.length) {\n const [attacher, ...options] = attachers[freezeIndex]\n\n if (options[0] === false) {\n continue\n }\n\n if (options[0] === true) {\n options[0] = undefined\n }\n\n /** @type {Transformer|void} */\n const transformer = attacher.call(processor, ...options)\n\n if (typeof transformer === 'function') {\n transformers.use(transformer)\n }\n }\n\n frozen = true\n freezeIndex = Number.POSITIVE_INFINITY\n\n return processor\n }\n\n /**\n * @param {Pluggable|null|undefined} [value]\n * @param {...unknown} options\n * @returns {Processor}\n */\n function use(value, ...options) {\n /** @type {Record|undefined} */\n let settings\n\n assertUnfrozen('use', frozen)\n\n if (value === null || value === undefined) {\n // Empty.\n } else if (typeof value === 'function') {\n addPlugin(value, ...options)\n } else if (typeof value === 'object') {\n if (Array.isArray(value)) {\n addList(value)\n } else {\n addPreset(value)\n }\n } else {\n throw new TypeError('Expected usable value, not `' + value + '`')\n }\n\n if (settings) {\n namespace.settings = Object.assign(namespace.settings || {}, settings)\n }\n\n return processor\n\n /**\n * @param {import('..').Pluggable} value\n * @returns {void}\n */\n function add(value) {\n if (typeof value === 'function') {\n addPlugin(value)\n } else if (typeof value === 'object') {\n if (Array.isArray(value)) {\n const [plugin, ...options] = value\n addPlugin(plugin, ...options)\n } else {\n addPreset(value)\n }\n } else {\n throw new TypeError('Expected usable value, not `' + value + '`')\n }\n }\n\n /**\n * @param {Preset} result\n * @returns {void}\n */\n function addPreset(result) {\n addList(result.plugins)\n\n if (result.settings) {\n settings = Object.assign(settings || {}, result.settings)\n }\n }\n\n /**\n * @param {PluggableList|null|undefined} [plugins]\n * @returns {void}\n */\n function addList(plugins) {\n let index = -1\n\n if (plugins === null || plugins === undefined) {\n // Empty.\n } else if (Array.isArray(plugins)) {\n while (++index < plugins.length) {\n const thing = plugins[index]\n add(thing)\n }\n } else {\n throw new TypeError('Expected a list of plugins, not `' + plugins + '`')\n }\n }\n\n /**\n * @param {Plugin} plugin\n * @param {...unknown} [value]\n * @returns {void}\n */\n function addPlugin(plugin, value) {\n let index = -1\n /** @type {Processor['attachers'][number]|undefined} */\n let entry\n\n while (++index < attachers.length) {\n if (attachers[index][0] === plugin) {\n entry = attachers[index]\n break\n }\n }\n\n if (entry) {\n if (isPlainObj(entry[1]) && isPlainObj(value)) {\n value = extend(true, entry[1], value)\n }\n\n entry[1] = value\n } else {\n // @ts-expect-error: fine.\n attachers.push([...arguments])\n }\n }\n }\n\n /** @type {Processor['parse']} */\n function parse(doc) {\n processor.freeze()\n const file = vfile(doc)\n const Parser = processor.Parser\n assertParser('parse', Parser)\n\n if (newable(Parser, 'parse')) {\n // @ts-expect-error: `newable` checks this.\n return new Parser(String(file), file).parse()\n }\n\n // @ts-expect-error: `newable` checks this.\n return Parser(String(file), file) // eslint-disable-line new-cap\n }\n\n /** @type {Processor['stringify']} */\n function stringify(node, doc) {\n processor.freeze()\n const file = vfile(doc)\n const Compiler = processor.Compiler\n assertCompiler('stringify', Compiler)\n assertNode(node)\n\n if (newable(Compiler, 'compile')) {\n // @ts-expect-error: `newable` checks this.\n return new Compiler(node, file).compile()\n }\n\n // @ts-expect-error: `newable` checks this.\n return Compiler(node, file) // eslint-disable-line new-cap\n }\n\n /**\n * @param {Node} node\n * @param {VFileCompatible|RunCallback} [doc]\n * @param {RunCallback} [callback]\n * @returns {Promise|void}\n */\n function run(node, doc, callback) {\n assertNode(node)\n processor.freeze()\n\n if (!callback && typeof doc === 'function') {\n callback = doc\n doc = undefined\n }\n\n if (!callback) {\n return new Promise(executor)\n }\n\n executor(null, callback)\n\n /**\n * @param {null|((node: Node) => void)} resolve\n * @param {(error: Error) => void} reject\n * @returns {void}\n */\n function executor(resolve, reject) {\n // @ts-expect-error: `doc` can\u2019t be a callback anymore, we checked.\n transformers.run(node, vfile(doc), done)\n\n /**\n * @param {Error|null} error\n * @param {Node} tree\n * @param {VFile} file\n * @returns {void}\n */\n function done(error, tree, file) {\n tree = tree || node\n if (error) {\n reject(error)\n } else if (resolve) {\n resolve(tree)\n } else {\n // @ts-expect-error: `callback` is defined if `resolve` is not.\n callback(null, tree, file)\n }\n }\n }\n }\n\n /** @type {Processor['runSync']} */\n function runSync(node, file) {\n /** @type {Node|undefined} */\n let result\n /** @type {boolean|undefined} */\n let complete\n\n processor.run(node, file, done)\n\n assertDone('runSync', 'run', complete)\n\n // @ts-expect-error: we either bailed on an error or have a tree.\n return result\n\n /**\n * @param {Error|null} [error]\n * @param {Node} [tree]\n * @returns {void}\n */\n function done(error, tree) {\n bail(error)\n result = tree\n complete = true\n }\n }\n\n /**\n * @param {VFileCompatible} doc\n * @param {ProcessCallback} [callback]\n * @returns {Promise|undefined}\n */\n function process(doc, callback) {\n processor.freeze()\n assertParser('process', processor.Parser)\n assertCompiler('process', processor.Compiler)\n\n if (!callback) {\n return new Promise(executor)\n }\n\n executor(null, callback)\n\n /**\n * @param {null|((file: VFile) => void)} resolve\n * @param {(error?: Error|null|undefined) => void} reject\n * @returns {void}\n */\n function executor(resolve, reject) {\n const file = vfile(doc)\n\n processor.run(processor.parse(file), file, (error, tree, file) => {\n if (error || !tree || !file) {\n done(error)\n } else {\n /** @type {unknown} */\n const result = processor.stringify(tree, file)\n\n if (result === undefined || result === null) {\n // Empty.\n } else if (looksLikeAVFileValue(result)) {\n file.value = result\n } else {\n file.result = result\n }\n\n done(error, file)\n }\n })\n\n /**\n * @param {Error|null|undefined} [error]\n * @param {VFile|undefined} [file]\n * @returns {void}\n */\n function done(error, file) {\n if (error || !file) {\n reject(error)\n } else if (resolve) {\n resolve(file)\n } else {\n // @ts-expect-error: `callback` is defined if `resolve` is not.\n callback(null, file)\n }\n }\n }\n }\n\n /** @type {Processor['processSync']} */\n function processSync(doc) {\n /** @type {boolean|undefined} */\n let complete\n\n processor.freeze()\n assertParser('processSync', processor.Parser)\n assertCompiler('processSync', processor.Compiler)\n\n const file = vfile(doc)\n\n processor.process(file, done)\n\n assertDone('processSync', 'process', complete)\n\n return file\n\n /**\n * @param {Error|null|undefined} [error]\n * @returns {void}\n */\n function done(error) {\n complete = true\n bail(error)\n }\n }\n}\n\n/**\n * Check if `value` is a constructor.\n *\n * @param {unknown} value\n * @param {string} name\n * @returns {boolean}\n */\nfunction newable(value, name) {\n return (\n typeof value === 'function' &&\n // Prototypes do exist.\n // type-coverage:ignore-next-line\n value.prototype &&\n // A function with keys in its prototype is probably a constructor.\n // Classes\u2019 prototype methods are not enumerable, so we check if some value\n // exists in the prototype.\n // type-coverage:ignore-next-line\n (keys(value.prototype) || name in value.prototype)\n )\n}\n\n/**\n * Check if `value` is an object with keys.\n *\n * @param {Record} value\n * @returns {boolean}\n */\nfunction keys(value) {\n /** @type {string} */\n let key\n\n for (key in value) {\n if (own.call(value, key)) {\n return true\n }\n }\n\n return false\n}\n\n/**\n * Assert a parser is available.\n *\n * @param {string} name\n * @param {unknown} value\n * @returns {asserts value is Parser}\n */\nfunction assertParser(name, value) {\n if (typeof value !== 'function') {\n throw new TypeError('Cannot `' + name + '` without `Parser`')\n }\n}\n\n/**\n * Assert a compiler is available.\n *\n * @param {string} name\n * @param {unknown} value\n * @returns {asserts value is Compiler}\n */\nfunction assertCompiler(name, value) {\n if (typeof value !== 'function') {\n throw new TypeError('Cannot `' + name + '` without `Compiler`')\n }\n}\n\n/**\n * Assert the processor is not frozen.\n *\n * @param {string} name\n * @param {unknown} frozen\n * @returns {asserts frozen is false}\n */\nfunction assertUnfrozen(name, frozen) {\n if (frozen) {\n throw new Error(\n 'Cannot call `' +\n name +\n '` on a frozen processor.\\nCreate a new processor first, by calling it: use `processor()` instead of `processor`.'\n )\n }\n}\n\n/**\n * Assert `node` is a unist node.\n *\n * @param {unknown} node\n * @returns {asserts node is Node}\n */\nfunction assertNode(node) {\n // `isPlainObj` unfortunately uses `any` instead of `unknown`.\n // type-coverage:ignore-next-line\n if (!isPlainObj(node) || typeof node.type !== 'string') {\n throw new TypeError('Expected node, got `' + node + '`')\n // Fine.\n }\n}\n\n/**\n * Assert that `complete` is `true`.\n *\n * @param {string} name\n * @param {string} asyncName\n * @param {unknown} complete\n * @returns {asserts complete is true}\n */\nfunction assertDone(name, asyncName, complete) {\n if (!complete) {\n throw new Error(\n '`' + name + '` finished async. Use `' + asyncName + '` instead'\n )\n }\n}\n\n/**\n * @param {VFileCompatible} [value]\n * @returns {VFile}\n */\nfunction vfile(value) {\n return looksLikeAVFile(value) ? value : new VFile(value)\n}\n\n/**\n * @param {VFileCompatible} [value]\n * @returns {value is VFile}\n */\nfunction looksLikeAVFile(value) {\n return Boolean(\n value &&\n typeof value === 'object' &&\n 'message' in value &&\n 'messages' in value\n )\n}\n\n/**\n * @param {unknown} [value]\n * @returns {value is VFileValue}\n */\nfunction looksLikeAVFileValue(value) {\n return typeof value === 'string' || isBuffer(value)\n}\n", "export default function isPlainObject(value) {\n\tif (typeof value !== 'object' || value === null) {\n\t\treturn false;\n\t}\n\n\tconst prototype = Object.getPrototypeOf(value);\n\treturn (prototype === null || prototype === Object.prototype || Object.getPrototypeOf(prototype) === null) && !(Symbol.toStringTag in value) && !(Symbol.iterator in value);\n}\n", "/**\n * @typedef {(error?: Error|null|undefined, ...output: Array) => void} Callback\n * @typedef {(...input: Array) => any} Middleware\n *\n * @typedef {(...input: Array) => void} Run\n * Call all middleware.\n * @typedef {(fn: Middleware) => Pipeline} Use\n * Add `fn` (middleware) to the list.\n * @typedef {{run: Run, use: Use}} Pipeline\n * Middleware.\n */\n\n/**\n * Create new middleware.\n *\n * @returns {Pipeline}\n */\nexport function trough() {\n /** @type {Array} */\n const fns = []\n /** @type {Pipeline} */\n const pipeline = {run, use}\n\n return pipeline\n\n /** @type {Run} */\n function run(...values) {\n let middlewareIndex = -1\n /** @type {Callback} */\n const callback = values.pop()\n\n if (typeof callback !== 'function') {\n throw new TypeError('Expected function as last argument, not ' + callback)\n }\n\n next(null, ...values)\n\n /**\n * Run the next `fn`, or we\u2019re done.\n *\n * @param {Error|null|undefined} error\n * @param {Array} output\n */\n function next(error, ...output) {\n const fn = fns[++middlewareIndex]\n let index = -1\n\n if (error) {\n callback(error)\n return\n }\n\n // Copy non-nullish input into values.\n while (++index < values.length) {\n if (output[index] === null || output[index] === undefined) {\n output[index] = values[index]\n }\n }\n\n // Save the newly created `output` for the next call.\n values = output\n\n // Next or done.\n if (fn) {\n wrap(fn, next)(...output)\n } else {\n callback(null, ...output)\n }\n }\n }\n\n /** @type {Use} */\n function use(middelware) {\n if (typeof middelware !== 'function') {\n throw new TypeError(\n 'Expected `middelware` to be a function, not ' + middelware\n )\n }\n\n fns.push(middelware)\n return pipeline\n }\n}\n\n/**\n * Wrap `middleware`.\n * Can be sync or async; return a promise, receive a callback, or return new\n * values and errors.\n *\n * @param {Middleware} middleware\n * @param {Callback} callback\n */\nexport function wrap(middleware, callback) {\n /** @type {boolean} */\n let called\n\n return wrapped\n\n /**\n * Call `middleware`.\n * @this {any}\n * @param {Array} parameters\n * @returns {void}\n */\n function wrapped(...parameters) {\n const fnExpectsCallback = middleware.length > parameters.length\n /** @type {any} */\n let result\n\n if (fnExpectsCallback) {\n parameters.push(done)\n }\n\n try {\n result = middleware.apply(this, parameters)\n } catch (error) {\n const exception = /** @type {Error} */ (error)\n\n // Well, this is quite the pickle.\n // `middleware` received a callback and called it synchronously, but that\n // threw an error.\n // The only thing left to do is to throw the thing instead.\n if (fnExpectsCallback && called) {\n throw exception\n }\n\n return done(exception)\n }\n\n if (!fnExpectsCallback) {\n if (result instanceof Promise) {\n result.then(then, done)\n } else if (result instanceof Error) {\n done(result)\n } else {\n then(result)\n }\n }\n }\n\n /**\n * Call `callback`, only once.\n * @type {Callback}\n */\n function done(error, ...output) {\n if (!called) {\n called = true\n callback(error, ...output)\n }\n }\n\n /**\n * Call `done` with one value.\n *\n * @param {any} [value]\n */\n function then(value) {\n done(null, value)\n }\n}\n", "/**\n * @typedef {import('unist').Node} Node\n * @typedef {import('unist').Position} Position\n * @typedef {import('unist').Point} Point\n * @typedef {Record & {type: string, position?: Position|undefined}} NodeLike\n * @typedef {import('./minurl.shared.js').URL} URL\n * @typedef {import('../index.js').Data} Data\n * @typedef {import('../index.js').Value} Value\n *\n * @typedef {'ascii'|'utf8'|'utf-8'|'utf16le'|'ucs2'|'ucs-2'|'base64'|'base64url'|'latin1'|'binary'|'hex'} BufferEncoding\n * Encodings supported by the buffer class.\n * This is a copy of the typing from Node, copied to prevent Node globals from\n * being needed.\n * Copied from: \n *\n * @typedef {Value|Options|VFile|URL} Compatible\n * Things that can be passed to the constructor.\n *\n * @typedef VFileCoreOptions\n * @property {Value} [value]\n * @property {string} [cwd]\n * @property {Array} [history]\n * @property {string|URL} [path]\n * @property {string} [basename]\n * @property {string} [stem]\n * @property {string} [extname]\n * @property {string} [dirname]\n * @property {Data} [data]\n *\n * @typedef Map\n * Raw source map, see:\n * .\n * @property {number} version\n * @property {Array} sources\n * @property {Array} names\n * @property {string|undefined} [sourceRoot]\n * @property {Array|undefined} [sourcesContent]\n * @property {string} mappings\n * @property {string} file\n *\n * @typedef {{[key: string]: unknown} & VFileCoreOptions} Options\n * Configuration: a bunch of keys that will be shallow copied over to the new\n * file.\n *\n * @typedef {Record} ReporterSettings\n * @typedef {(files: Array, options: T) => string} Reporter\n */\n\nimport buffer from 'is-buffer'\nimport {VFileMessage} from 'vfile-message'\nimport {path} from './minpath.js'\nimport {proc} from './minproc.js'\nimport {urlToPath, isUrl} from './minurl.js'\n\n// Order of setting (least specific to most), we need this because otherwise\n// `{stem: 'a', path: '~/b.js'}` would throw, as a path is needed before a\n// stem can be set.\nconst order = ['history', 'path', 'basename', 'stem', 'extname', 'dirname']\n\nexport class VFile {\n /**\n * Create a new virtual file.\n *\n * If `options` is `string` or `Buffer`, it\u2019s treated as `{value: options}`.\n * If `options` is a `URL`, it\u2019s treated as `{path: options}`.\n * If `options` is a `VFile`, shallow copies its data over to the new file.\n * All fields in `options` are set on the newly created `VFile`.\n *\n * Path related fields are set in the following order (least specific to\n * most specific): `history`, `path`, `basename`, `stem`, `extname`,\n * `dirname`.\n *\n * It\u2019s not possible to set either `dirname` or `extname` without setting\n * either `history`, `path`, `basename`, or `stem` as well.\n *\n * @param {Compatible} [value]\n */\n constructor(value) {\n /** @type {Options} */\n let options\n\n if (!value) {\n options = {}\n } else if (typeof value === 'string' || buffer(value)) {\n // @ts-expect-error Looks like a buffer.\n options = {value}\n } else if (isUrl(value)) {\n options = {path: value}\n } else {\n // @ts-expect-error Looks like file or options.\n options = value\n }\n\n /**\n * Place to store custom information (default: `{}`).\n * It\u2019s OK to store custom data directly on the file but moving it to\n * `data` is recommended.\n * @type {Data}\n */\n this.data = {}\n\n /**\n * List of messages associated with the file.\n * @type {Array}\n */\n this.messages = []\n\n /**\n * List of filepaths the file moved between.\n * The first is the original path and the last is the current path.\n * @type {Array}\n */\n this.history = []\n\n /**\n * Base of `path` (default: `process.cwd()` or `'/'` in browsers).\n * @type {string}\n */\n this.cwd = proc.cwd()\n\n /* eslint-disable no-unused-expressions */\n /**\n * Raw value.\n * @type {Value}\n */\n this.value\n\n // The below are non-standard, they are \u201Cwell-known\u201D.\n // As in, used in several tools.\n\n /**\n * Whether a file was saved to disk.\n * This is used by vfile reporters.\n * @type {boolean}\n */\n this.stored\n\n /**\n * Sometimes files have a non-string, compiled, representation.\n * This can be stored in the `result` field.\n * One example is when turning markdown into React nodes.\n * This is used by unified to store non-string results.\n * @type {unknown}\n */\n this.result\n\n /**\n * Sometimes files have a source map associated with them.\n * This can be stored in the `map` field.\n * This should be a `Map` type, which is equivalent to the `RawSourceMap`\n * type from the `source-map` module.\n * @type {Map|undefined}\n */\n this.map\n /* eslint-enable no-unused-expressions */\n\n // Set path related properties in the correct order.\n let index = -1\n\n while (++index < order.length) {\n const prop = order[index]\n\n // Note: we specifically use `in` instead of `hasOwnProperty` to accept\n // `vfile`s too.\n if (prop in options && options[prop] !== undefined) {\n // @ts-expect-error: TS is confused by the different types for `history`.\n this[prop] = prop === 'history' ? [...options[prop]] : options[prop]\n }\n }\n\n /** @type {string} */\n let prop\n\n // Set non-path related properties.\n for (prop in options) {\n // @ts-expect-error: fine to set other things.\n if (!order.includes(prop)) this[prop] = options[prop]\n }\n }\n\n /**\n * Get the full path (example: `'~/index.min.js'`).\n * @returns {string}\n */\n get path() {\n return this.history[this.history.length - 1]\n }\n\n /**\n * Set the full path (example: `'~/index.min.js'`).\n * Cannot be nullified.\n * You can set a file URL (a `URL` object with a `file:` protocol) which will\n * be turned into a path with `url.fileURLToPath`.\n * @param {string|URL} path\n */\n set path(path) {\n if (isUrl(path)) {\n path = urlToPath(path)\n }\n\n assertNonEmpty(path, 'path')\n\n if (this.path !== path) {\n this.history.push(path)\n }\n }\n\n /**\n * Get the parent path (example: `'~'`).\n */\n get dirname() {\n return typeof this.path === 'string' ? path.dirname(this.path) : undefined\n }\n\n /**\n * Set the parent path (example: `'~'`).\n * Cannot be set if there\u2019s no `path` yet.\n */\n set dirname(dirname) {\n assertPath(this.basename, 'dirname')\n this.path = path.join(dirname || '', this.basename)\n }\n\n /**\n * Get the basename (including extname) (example: `'index.min.js'`).\n */\n get basename() {\n return typeof this.path === 'string' ? path.basename(this.path) : undefined\n }\n\n /**\n * Set basename (including extname) (`'index.min.js'`).\n * Cannot contain path separators (`'/'` on unix, macOS, and browsers, `'\\'`\n * on windows).\n * Cannot be nullified (use `file.path = file.dirname` instead).\n */\n set basename(basename) {\n assertNonEmpty(basename, 'basename')\n assertPart(basename, 'basename')\n this.path = path.join(this.dirname || '', basename)\n }\n\n /**\n * Get the extname (including dot) (example: `'.js'`).\n */\n get extname() {\n return typeof this.path === 'string' ? path.extname(this.path) : undefined\n }\n\n /**\n * Set the extname (including dot) (example: `'.js'`).\n * Cannot contain path separators (`'/'` on unix, macOS, and browsers, `'\\'`\n * on windows).\n * Cannot be set if there\u2019s no `path` yet.\n */\n set extname(extname) {\n assertPart(extname, 'extname')\n assertPath(this.dirname, 'extname')\n\n if (extname) {\n if (extname.charCodeAt(0) !== 46 /* `.` */) {\n throw new Error('`extname` must start with `.`')\n }\n\n if (extname.includes('.', 1)) {\n throw new Error('`extname` cannot contain multiple dots')\n }\n }\n\n this.path = path.join(this.dirname, this.stem + (extname || ''))\n }\n\n /**\n * Get the stem (basename w/o extname) (example: `'index.min'`).\n */\n get stem() {\n return typeof this.path === 'string'\n ? path.basename(this.path, this.extname)\n : undefined\n }\n\n /**\n * Set the stem (basename w/o extname) (example: `'index.min'`).\n * Cannot contain path separators (`'/'` on unix, macOS, and browsers, `'\\'`\n * on windows).\n * Cannot be nullified (use `file.path = file.dirname` instead).\n */\n set stem(stem) {\n assertNonEmpty(stem, 'stem')\n assertPart(stem, 'stem')\n this.path = path.join(this.dirname || '', stem + (this.extname || ''))\n }\n\n /**\n * Serialize the file.\n *\n * @param {BufferEncoding} [encoding='utf8']\n * When `value` is a `Buffer`, `encoding` is a character encoding to\n * understand it as (default: `'utf8'`).\n * @returns {string}\n * Serialized file.\n */\n toString(encoding) {\n return (this.value || '').toString(encoding)\n }\n\n /**\n * Constructs a new `VFileMessage`, where `fatal` is set to `false`, and\n * associates it with the file by adding it to `vfile.messages` and setting\n * `message.file` to the current filepath.\n *\n * @param {string|Error|VFileMessage} reason\n * Human readable reason for the message, uses the stack and message of the error if given.\n * @param {Node|NodeLike|Position|Point} [place]\n * Place where the message occurred in the file.\n * @param {string} [origin]\n * Computer readable reason for the message\n * @returns {VFileMessage}\n * Message.\n */\n message(reason, place, origin) {\n const message = new VFileMessage(reason, place, origin)\n\n if (this.path) {\n message.name = this.path + ':' + message.name\n message.file = this.path\n }\n\n message.fatal = false\n\n this.messages.push(message)\n\n return message\n }\n\n /**\n * Like `VFile#message()`, but associates an informational message where\n * `fatal` is set to `null`.\n *\n * @param {string|Error|VFileMessage} reason\n * Human readable reason for the message, uses the stack and message of the error if given.\n * @param {Node|NodeLike|Position|Point} [place]\n * Place where the message occurred in the file.\n * @param {string} [origin]\n * Computer readable reason for the message\n * @returns {VFileMessage}\n * Message.\n */\n info(reason, place, origin) {\n const message = this.message(reason, place, origin)\n\n message.fatal = null\n\n return message\n }\n\n /**\n * Like `VFile#message()`, but associates a fatal message where `fatal` is\n * set to `true`, and then immediately throws it.\n *\n * > \uD83D\uDC49 **Note**: a fatal error means that a file is no longer processable.\n *\n * @param {string|Error|VFileMessage} reason\n * Human readable reason for the message, uses the stack and message of the error if given.\n * @param {Node|NodeLike|Position|Point} [place]\n * Place where the message occurred in the file.\n * @param {string} [origin]\n * Computer readable reason for the message\n * @returns {never}\n * Message.\n */\n fail(reason, place, origin) {\n const message = this.message(reason, place, origin)\n\n message.fatal = true\n\n throw message\n }\n}\n\n/**\n * Assert that `part` is not a path (as in, does not contain `path.sep`).\n *\n * @param {string|undefined} part\n * @param {string} name\n * @returns {void}\n */\nfunction assertPart(part, name) {\n if (part && part.includes(path.sep)) {\n throw new Error(\n '`' + name + '` cannot be a path: did not expect `' + path.sep + '`'\n )\n }\n}\n\n/**\n * Assert that `part` is not empty.\n *\n * @param {string|undefined} part\n * @param {string} name\n * @returns {asserts part is string}\n */\nfunction assertNonEmpty(part, name) {\n if (!part) {\n throw new Error('`' + name + '` cannot be empty')\n }\n}\n\n/**\n * Assert `path` exists.\n *\n * @param {string|undefined} path\n * @param {string} name\n * @returns {asserts path is string}\n */\nfunction assertPath(path, name) {\n if (!path) {\n throw new Error('Setting `' + name + '` requires `path` to be set too')\n }\n}\n", "/**\n * @typedef {import('unist').Node} Node\n * @typedef {import('unist').Point} Point\n * @typedef {import('unist').Position} Position\n */\n\n/**\n * @typedef NodeLike\n * @property {string} type\n * @property {PositionLike | null | undefined} [position]\n *\n * @typedef PositionLike\n * @property {PointLike | null | undefined} [start]\n * @property {PointLike | null | undefined} [end]\n *\n * @typedef PointLike\n * @property {number | null | undefined} [line]\n * @property {number | null | undefined} [column]\n * @property {number | null | undefined} [offset]\n */\n\n/**\n * Serialize the positional info of a point, position (start and end points),\n * or node.\n *\n * @param {Node | NodeLike | Position | PositionLike | Point | PointLike | null | undefined} [value]\n * Node, position, or point.\n * @returns {string}\n * Pretty printed positional info of a node (`string`).\n *\n * In the format of a range `ls:cs-le:ce` (when given `node` or `position`)\n * or a point `l:c` (when given `point`), where `l` stands for line, `c` for\n * column, `s` for `start`, and `e` for end.\n * An empty string (`''`) is returned if the given value is neither `node`,\n * `position`, nor `point`.\n */\nexport function stringifyPosition(value) {\n // Nothing.\n if (!value || typeof value !== 'object') {\n return ''\n }\n\n // Node.\n if ('position' in value || 'type' in value) {\n return position(value.position)\n }\n\n // Position.\n if ('start' in value || 'end' in value) {\n return position(value)\n }\n\n // Point.\n if ('line' in value || 'column' in value) {\n return point(value)\n }\n\n // ?\n return ''\n}\n\n/**\n * @param {Point | PointLike | null | undefined} point\n * @returns {string}\n */\nfunction point(point) {\n return index(point && point.line) + ':' + index(point && point.column)\n}\n\n/**\n * @param {Position | PositionLike | null | undefined} pos\n * @returns {string}\n */\nfunction position(pos) {\n return point(pos && pos.start) + '-' + point(pos && pos.end)\n}\n\n/**\n * @param {number | null | undefined} value\n * @returns {number}\n */\nfunction index(value) {\n return value && typeof value === 'number' ? value : 1\n}\n", "/**\n * @typedef {import('unist').Node} Node\n * @typedef {import('unist').Position} Position\n * @typedef {import('unist').Point} Point\n * @typedef {object & {type: string, position?: Position|undefined}} NodeLike\n */\n\nimport {stringifyPosition} from 'unist-util-stringify-position'\n\nexport class VFileMessage extends Error {\n /**\n * Create a message for `reason` at `place` from `origin`.\n *\n * When an error is passed in as `reason`, the `stack` is copied.\n *\n * @param {string|Error|VFileMessage} reason\n * Reason for message.\n * Uses the stack and message of the error if given.\n * @param {Node|NodeLike|Position|Point} [place]\n * Place at which the message occurred in a file.\n * @param {string} [origin]\n * Place in code the message originates from (example `'my-package:my-rule-name'`)\n */\n constructor(reason, place, origin) {\n /** @type {[string|null, string|null]} */\n const parts = [null, null]\n /** @type {Position} */\n let position = {\n // @ts-expect-error: we always follows the structure of `position`.\n start: {line: null, column: null},\n // @ts-expect-error: \"\n end: {line: null, column: null}\n }\n\n super()\n\n if (typeof place === 'string') {\n origin = place\n place = undefined\n }\n\n if (typeof origin === 'string') {\n const index = origin.indexOf(':')\n\n if (index === -1) {\n parts[1] = origin\n } else {\n parts[0] = origin.slice(0, index)\n parts[1] = origin.slice(index + 1)\n }\n }\n\n if (place) {\n // Node.\n if ('type' in place || 'position' in place) {\n if (place.position) {\n // @ts-expect-error: looks like a position.\n position = place.position\n }\n }\n // Position.\n else if ('start' in place || 'end' in place) {\n // @ts-expect-error: looks like a position.\n position = place\n }\n // Point.\n else if ('line' in place || 'column' in place) {\n position.start = place\n }\n }\n\n // Fields from `Error`\n this.name = stringifyPosition(place) || '1:1'\n /** @type {string} */\n this.message = typeof reason === 'object' ? reason.message : reason\n /** @type {string} */\n this.stack = ''\n\n if (typeof reason === 'object' && reason.stack) {\n this.stack = reason.stack\n }\n\n /**\n * Reason for message.\n *\n * @type {string}\n */\n this.reason = this.message\n\n /* eslint-disable no-unused-expressions */\n /**\n * Whether this is a fatal problem that marks an associated file as no\n * longer processable.\n * If `true`, marks associated file as no longer processable.\n * If `false`, necessitates a (potential) change.\n * The value can also be `null` or `undefined`, for things that might not\n * need changing.\n *\n * @type {boolean?}\n */\n this.fatal\n\n /**\n * Starting line of error.\n *\n * @type {number?}\n */\n this.line = position.start.line\n\n /**\n * Starting column of error.\n *\n * @type {number?}\n */\n this.column = position.start.column\n\n /**\n * Full range information, when available.\n * Has `start` and `end` fields, both set to an object with `line` and\n * `column`, set to `number?`.\n *\n * @type {Position?}\n */\n this.position = position\n\n /**\n * Namespace of warning (example: `'my-package'`).\n *\n * @type {string?}\n */\n this.source = parts[0]\n\n /**\n * Category of message (example: `'my-rule-name'`).\n *\n * @type {string?}\n */\n this.ruleId = parts[1]\n\n /**\n * Path of a file (used throughout the VFile ecosystem).\n *\n * @type {string?}\n */\n this.file\n\n // The following fields are \u201Cwell known\u201D.\n // Not standard.\n // Feel free to add other non-standard fields to your messages.\n\n /**\n * Specify the source value that\u2019s being reported, which is deemed\n * incorrect.\n *\n * @type {string?}\n */\n this.actual\n\n /**\n * Suggest values that should be used instead of `actual`, one or more\n * values that are deemed as acceptable.\n *\n * @type {Array?}\n */\n this.expected\n\n /**\n * Link to documentation for the message.\n *\n * @type {string?}\n */\n this.url\n\n /**\n * Long form description of the message (supported by `vfile-reporter`).\n *\n * @type {string?}\n */\n this.note\n /* eslint-enable no-unused-expressions */\n }\n}\n\nVFileMessage.prototype.file = ''\nVFileMessage.prototype.name = ''\nVFileMessage.prototype.reason = ''\nVFileMessage.prototype.message = ''\nVFileMessage.prototype.stack = ''\nVFileMessage.prototype.fatal = null\nVFileMessage.prototype.column = null\nVFileMessage.prototype.line = null\nVFileMessage.prototype.source = null\nVFileMessage.prototype.ruleId = null\nVFileMessage.prototype.position = null\n", "// A derivative work based on:\n// .\n// Which is licensed:\n//\n// MIT License\n//\n// Copyright (c) 2013 James Halliday\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy of\n// this software and associated documentation files (the \"Software\"), to deal in\n// the Software without restriction, including without limitation the rights to\n// use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of\n// the Software, and to permit persons to whom the Software is furnished to do so,\n// subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in all\n// copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS\n// FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR\n// COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER\n// IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN\n// CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.\n// A derivative work based on:\n//\n// Parts of that are extracted from Node\u2019s internal `path` module:\n// .\n// Which is licensed:\n//\n// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\nexport const path = {basename, dirname, extname, join, sep: '/'}\n\n/* eslint-disable max-depth, complexity */\n\n/**\n * @param {string} path\n * @param {string} [ext]\n * @returns {string}\n */\nfunction basename(path, ext) {\n if (ext !== undefined && typeof ext !== 'string') {\n throw new TypeError('\"ext\" argument must be a string')\n }\n\n assertPath(path)\n let start = 0\n let end = -1\n let index = path.length\n /** @type {boolean|undefined} */\n let seenNonSlash\n\n if (ext === undefined || ext.length === 0 || ext.length > path.length) {\n while (index--) {\n if (path.charCodeAt(index) === 47 /* `/` */) {\n // If we reached a path separator that was not part of a set of path\n // separators at the end of the string, stop now.\n if (seenNonSlash) {\n start = index + 1\n break\n }\n } else if (end < 0) {\n // We saw the first non-path separator, mark this as the end of our\n // path component.\n seenNonSlash = true\n end = index + 1\n }\n }\n\n return end < 0 ? '' : path.slice(start, end)\n }\n\n if (ext === path) {\n return ''\n }\n\n let firstNonSlashEnd = -1\n let extIndex = ext.length - 1\n\n while (index--) {\n if (path.charCodeAt(index) === 47 /* `/` */) {\n // If we reached a path separator that was not part of a set of path\n // separators at the end of the string, stop now.\n if (seenNonSlash) {\n start = index + 1\n break\n }\n } else {\n if (firstNonSlashEnd < 0) {\n // We saw the first non-path separator, remember this index in case\n // we need it if the extension ends up not matching.\n seenNonSlash = true\n firstNonSlashEnd = index + 1\n }\n\n if (extIndex > -1) {\n // Try to match the explicit extension.\n if (path.charCodeAt(index) === ext.charCodeAt(extIndex--)) {\n if (extIndex < 0) {\n // We matched the extension, so mark this as the end of our path\n // component\n end = index\n }\n } else {\n // Extension does not match, so our result is the entire path\n // component\n extIndex = -1\n end = firstNonSlashEnd\n }\n }\n }\n }\n\n if (start === end) {\n end = firstNonSlashEnd\n } else if (end < 0) {\n end = path.length\n }\n\n return path.slice(start, end)\n}\n\n/**\n * @param {string} path\n * @returns {string}\n */\nfunction dirname(path) {\n assertPath(path)\n\n if (path.length === 0) {\n return '.'\n }\n\n let end = -1\n let index = path.length\n /** @type {boolean|undefined} */\n let unmatchedSlash\n\n // Prefix `--` is important to not run on `0`.\n while (--index) {\n if (path.charCodeAt(index) === 47 /* `/` */) {\n if (unmatchedSlash) {\n end = index\n break\n }\n } else if (!unmatchedSlash) {\n // We saw the first non-path separator\n unmatchedSlash = true\n }\n }\n\n return end < 0\n ? path.charCodeAt(0) === 47 /* `/` */\n ? '/'\n : '.'\n : end === 1 && path.charCodeAt(0) === 47 /* `/` */\n ? '//'\n : path.slice(0, end)\n}\n\n/**\n * @param {string} path\n * @returns {string}\n */\nfunction extname(path) {\n assertPath(path)\n\n let index = path.length\n\n let end = -1\n let startPart = 0\n let startDot = -1\n // Track the state of characters (if any) we see before our first dot and\n // after any path separator we find.\n let preDotState = 0\n /** @type {boolean|undefined} */\n let unmatchedSlash\n\n while (index--) {\n const code = path.charCodeAt(index)\n\n if (code === 47 /* `/` */) {\n // If we reached a path separator that was not part of a set of path\n // separators at the end of the string, stop now.\n if (unmatchedSlash) {\n startPart = index + 1\n break\n }\n\n continue\n }\n\n if (end < 0) {\n // We saw the first non-path separator, mark this as the end of our\n // extension.\n unmatchedSlash = true\n end = index + 1\n }\n\n if (code === 46 /* `.` */) {\n // If this is our first dot, mark it as the start of our extension.\n if (startDot < 0) {\n startDot = index\n } else if (preDotState !== 1) {\n preDotState = 1\n }\n } else if (startDot > -1) {\n // We saw a non-dot and non-path separator before our dot, so we should\n // have a good chance at having a non-empty extension.\n preDotState = -1\n }\n }\n\n if (\n startDot < 0 ||\n end < 0 ||\n // We saw a non-dot character immediately before the dot.\n preDotState === 0 ||\n // The (right-most) trimmed path component is exactly `..`.\n (preDotState === 1 && startDot === end - 1 && startDot === startPart + 1)\n ) {\n return ''\n }\n\n return path.slice(startDot, end)\n}\n\n/**\n * @param {Array} segments\n * @returns {string}\n */\nfunction join(...segments) {\n let index = -1\n /** @type {string|undefined} */\n let joined\n\n while (++index < segments.length) {\n assertPath(segments[index])\n\n if (segments[index]) {\n joined =\n joined === undefined ? segments[index] : joined + '/' + segments[index]\n }\n }\n\n return joined === undefined ? '.' : normalize(joined)\n}\n\n/**\n * Note: `normalize` is not exposed as `path.normalize`, so some code is\n * manually removed from it.\n *\n * @param {string} path\n * @returns {string}\n */\nfunction normalize(path) {\n assertPath(path)\n\n const absolute = path.charCodeAt(0) === 47 /* `/` */\n\n // Normalize the path according to POSIX rules.\n let value = normalizeString(path, !absolute)\n\n if (value.length === 0 && !absolute) {\n value = '.'\n }\n\n if (value.length > 0 && path.charCodeAt(path.length - 1) === 47 /* / */) {\n value += '/'\n }\n\n return absolute ? '/' + value : value\n}\n\n/**\n * Resolve `.` and `..` elements in a path with directory names.\n *\n * @param {string} path\n * @param {boolean} allowAboveRoot\n * @returns {string}\n */\nfunction normalizeString(path, allowAboveRoot) {\n let result = ''\n let lastSegmentLength = 0\n let lastSlash = -1\n let dots = 0\n let index = -1\n /** @type {number|undefined} */\n let code\n /** @type {number} */\n let lastSlashIndex\n\n while (++index <= path.length) {\n if (index < path.length) {\n code = path.charCodeAt(index)\n } else if (code === 47 /* `/` */) {\n break\n } else {\n code = 47 /* `/` */\n }\n\n if (code === 47 /* `/` */) {\n if (lastSlash === index - 1 || dots === 1) {\n // Empty.\n } else if (lastSlash !== index - 1 && dots === 2) {\n if (\n result.length < 2 ||\n lastSegmentLength !== 2 ||\n result.charCodeAt(result.length - 1) !== 46 /* `.` */ ||\n result.charCodeAt(result.length - 2) !== 46 /* `.` */\n ) {\n if (result.length > 2) {\n lastSlashIndex = result.lastIndexOf('/')\n\n if (lastSlashIndex !== result.length - 1) {\n if (lastSlashIndex < 0) {\n result = ''\n lastSegmentLength = 0\n } else {\n result = result.slice(0, lastSlashIndex)\n lastSegmentLength = result.length - 1 - result.lastIndexOf('/')\n }\n\n lastSlash = index\n dots = 0\n continue\n }\n } else if (result.length > 0) {\n result = ''\n lastSegmentLength = 0\n lastSlash = index\n dots = 0\n continue\n }\n }\n\n if (allowAboveRoot) {\n result = result.length > 0 ? result + '/..' : '..'\n lastSegmentLength = 2\n }\n } else {\n if (result.length > 0) {\n result += '/' + path.slice(lastSlash + 1, index)\n } else {\n result = path.slice(lastSlash + 1, index)\n }\n\n lastSegmentLength = index - lastSlash - 1\n }\n\n lastSlash = index\n dots = 0\n } else if (code === 46 /* `.` */ && dots > -1) {\n dots++\n } else {\n dots = -1\n }\n }\n\n return result\n}\n\n/**\n * @param {string} path\n */\nfunction assertPath(path) {\n if (typeof path !== 'string') {\n throw new TypeError(\n 'Path must be a string. Received ' + JSON.stringify(path)\n )\n }\n}\n\n/* eslint-enable max-depth, complexity */\n", "// Somewhat based on:\n// .\n// But I don\u2019t think one tiny line of code can be copyrighted. \uD83D\uDE05\nexport const proc = {cwd}\n\nfunction cwd() {\n return '/'\n}\n", "/**\n * @typedef URL\n * @property {string} hash\n * @property {string} host\n * @property {string} hostname\n * @property {string} href\n * @property {string} origin\n * @property {string} password\n * @property {string} pathname\n * @property {string} port\n * @property {string} protocol\n * @property {string} search\n * @property {any} searchParams\n * @property {string} username\n * @property {() => string} toString\n * @property {() => string} toJSON\n */\n\n/**\n * @param {unknown} fileURLOrPath\n * @returns {fileURLOrPath is URL}\n */\n// From: \nexport function isUrl(fileURLOrPath) {\n return (\n fileURLOrPath !== null &&\n typeof fileURLOrPath === 'object' &&\n // @ts-expect-error: indexable.\n fileURLOrPath.href &&\n // @ts-expect-error: indexable.\n fileURLOrPath.origin\n )\n}\n", "/// \n\nimport {isUrl} from './minurl.shared.js'\n\n// See: \n\n/**\n * @param {string|URL} path\n */\nexport function urlToPath(path) {\n if (typeof path === 'string') {\n path = new URL(path)\n } else if (!isUrl(path)) {\n /** @type {NodeJS.ErrnoException} */\n const error = new TypeError(\n 'The \"path\" argument must be of type string or an instance of URL. Received `' +\n path +\n '`'\n )\n error.code = 'ERR_INVALID_ARG_TYPE'\n throw error\n }\n\n if (path.protocol !== 'file:') {\n /** @type {NodeJS.ErrnoException} */\n const error = new TypeError('The URL must be of scheme file')\n error.code = 'ERR_INVALID_URL_SCHEME'\n throw error\n }\n\n return getPathFromURLPosix(path)\n}\n\n/**\n * @param {URL} url\n */\nfunction getPathFromURLPosix(url) {\n if (url.hostname !== '') {\n /** @type {NodeJS.ErrnoException} */\n const error = new TypeError(\n 'File URL host must be \"localhost\" or empty on darwin'\n )\n error.code = 'ERR_INVALID_FILE_URL_HOST'\n throw error\n }\n\n const pathname = url.pathname\n let index = -1\n\n while (++index < pathname.length) {\n if (\n pathname.charCodeAt(index) === 37 /* `%` */ &&\n pathname.charCodeAt(index + 1) === 50 /* `2` */\n ) {\n const third = pathname.charCodeAt(index + 2)\n if (third === 70 /* `F` */ || third === 102 /* `f` */) {\n /** @type {NodeJS.ErrnoException} */\n const error = new TypeError(\n 'File URL path must not include encoded / characters'\n )\n error.code = 'ERR_INVALID_FILE_URL_PATH'\n throw error\n }\n }\n }\n\n return decodeURIComponent(pathname)\n}\n\nexport {isUrl} from './minurl.shared.js'\n", "import * as Ast from \"@unified-latex/unified-latex-types\";\nimport { match } from \"@unified-latex/unified-latex-util-match\";\nimport { splitOnCondition } from \"./split-on-condition\";\n\n/**\n * Split an array of AST nodes based on a macro. An object `{segments: [], macros: []}`\n * is returned. The original array is reconstructed as\n * `segments[0] + macros[0] + segments[1] + ...`.\n *\n * @param {[object]} ast\n * @param {(string|[string])} macroName\n * @returns {{segments: [object], macros: [object]}}\n */\nexport function splitOnMacro(\n ast: Ast.Node[],\n macroName: string | string[]\n): { segments: Ast.Node[][]; macros: Ast.Macro[] } {\n if (typeof macroName === \"string\") {\n macroName = [macroName];\n }\n if (!Array.isArray(macroName)) {\n throw new Error(\"Type coercion failed\");\n }\n const isSeparator = match.createMacroMatcher(macroName);\n const { segments, separators } = splitOnCondition(ast, isSeparator);\n return { segments, macros: separators as Ast.Macro[] };\n}\n", "import * as Ast from \"@unified-latex/unified-latex-types\";\n\n/**\n * Split a list of nodes based on whether `splitFunc` returns `true`.\n * If `onlySplitOnFirstOccurrence` is set to true in the `options` object, then\n * there will be at most two segments returned.\n */\nexport function splitOnCondition(\n nodes: Ast.Node[],\n splitFunc: (node: Ast.Node) => boolean = () => false,\n options?: { onlySplitOnFirstOccurrence?: boolean }\n): { segments: Ast.Node[][]; separators: Ast.Node[] } {\n if (!Array.isArray(nodes)) {\n throw new Error(`Can only split an Array, not ${nodes}`);\n }\n\n const { onlySplitOnFirstOccurrence = false } = options || {};\n\n const splitIndices: number[] = [];\n for (let i = 0; i < nodes.length; i++) {\n if (splitFunc(nodes[i])) {\n splitIndices.push(i);\n if (onlySplitOnFirstOccurrence) {\n break;\n }\n }\n }\n\n // Short circuit if there is no splitting to be done\n if (splitIndices.length === 0) {\n return { segments: [nodes], separators: [] };\n }\n\n let separators = splitIndices.map((i) => nodes[i]);\n let segments = splitIndices.map((splitEnd, i) => {\n const splitStart = i === 0 ? 0 : splitIndices[i - 1] + 1;\n return nodes.slice(splitStart, splitEnd);\n });\n segments.push(\n nodes.slice(splitIndices[splitIndices.length - 1] + 1, nodes.length)\n );\n\n return { segments, separators };\n}\n", "import * as Ast from \"@unified-latex/unified-latex-types\";\n\n/**\n * Does the reverse of `splitOnMacro`\n */\nexport function unsplitOnMacro({\n segments,\n macros,\n}: {\n segments: Ast.Node[][];\n macros: Ast.Node[] | Ast.Node[][];\n}) {\n if (segments.length === 0) {\n console.warn(\"Trying to join zero segments\");\n return [];\n }\n if (segments.length !== macros.length + 1) {\n console.warn(\n \"Mismatch between lengths of macros and segments when trying to unsplit\"\n );\n }\n\n let ret = segments[0];\n for (let i = 0; i < macros.length; i++) {\n // Even though the type of macros[i] is node and not array,\n // Array.concat still works\n ret = ret.concat(macros[i]).concat(segments[i + 1]);\n }\n\n return ret;\n}\n", "/**\n * Joins an array of arrays with the item `sep`\n */\nexport function arrayJoin(array: T[][], sep: T | T[]): T[] {\n return array.flatMap((item, i) => {\n if (i === 0) {\n return item;\n }\n if (Array.isArray(sep)) {\n return [...sep, ...item];\n } else {\n return [sep, ...item];\n }\n });\n}\n", "import * as Ast from \"@unified-latex/unified-latex-types\";\nimport {\n visit,\n VisitInfo,\n} from \"@unified-latex/unified-latex-util-visit\";\n\n/**\n * Recursively replace nodes in `ast`. The `visitor` function is called on each node. If\n * `visitor` returns a node or an array of nodes, those nodes replace the node passed to `visitor`.\n * If `null` is returned, the node is deleted. If `undefined` is returned, no replacement happens.\n */\nexport function replaceNode(\n ast: Ast.Ast,\n visitor: (\n node: Ast.Node | Ast.Argument,\n info: VisitInfo\n ) =>\n | Ast.Node\n | Ast.Argument\n | (Ast.Node | Ast.Argument)[]\n | null\n | undefined\n | void\n) {\n visit(ast, {\n leave: (node, info) => {\n let replacement = visitor(node, info);\n // Returning `undefined` or the same node means we shouldn't replace that node\n if (typeof replacement === \"undefined\" || replacement === node) {\n return;\n }\n\n if (!info.containingArray || info.index == null) {\n throw new Error(\n \"Trying to replace node, but cannot find containing array\"\n );\n }\n\n if (\n replacement === null ||\n (Array.isArray(replacement) && replacement.length === 0)\n ) {\n // A null return means that we delete the current node\n info.containingArray.splice(info.index, 1);\n return info.index;\n }\n\n if (!Array.isArray(replacement)) {\n replacement = [replacement];\n }\n\n info.containingArray.splice(info.index, 1, ...replacement);\n // We don't want to *reprocess* the nodes we just inserted into the array,\n // lest we get stuck in a recursive loop if the replacement contains the original.\n // Thus we jump to the index after our replacements.\n return info.index + replacement.length;\n },\n });\n}\n", "import { Plugin } from \"unified\";\nimport * as Ast from \"@unified-latex/unified-latex-types\";\nimport { match } from \"@unified-latex/unified-latex-util-match\";\nimport { trimEnd, trimStart } from \"@unified-latex/unified-latex-util-trim\";\nimport { visit } from \"@unified-latex/unified-latex-util-visit\";\nimport { replaceStreamingCommand } from \"./replace-streaming-command\";\nimport { replaceNodeDuringVisit } from \"./replace-node-during-visit\";\n\ntype PluginOptions = {\n replacers: Record<\n string,\n (\n content: Ast.Node[],\n streamingCommand: Ast.Macro\n ) => Ast.Node | Ast.Node[]\n >;\n};\n\n/**\n * Unified plugin to replace all found streaming commands with their argument-style equivalents.\n * This only applies to sections of the tree with no math ancestor.\n *\n * @param options.replacer A record of macro names and replacer functions. A replacer function accepts content and the original streaming command and is expected to return the argument-style command. It may be called multiple times per streaming command.\n */\nexport const unifiedLatexReplaceStreamingCommands: Plugin<\n PluginOptions[],\n Ast.Root,\n Ast.Root\n> = function unifiedLatexReplaceStreamingCommands(options) {\n const { replacers = {} } = options || {};\n const isReplaceable = match.createMacroMatcher(replacers);\n return (tree) => {\n // We traverse all groups before we replace nodes in other contexts\n visit(\n tree,\n (group, info) => {\n if (\n info.context.hasMathModeAncestor ||\n !group.content.some(isReplaceable)\n ) {\n return;\n }\n\n let fixed = replaceStreamingCommand(\n group,\n isReplaceable,\n (content, command) => {\n return replacers[command.content](content, command);\n }\n );\n\n // We cannot replace the node unless we can access the containing array.\n if (!info.containingArray || info.index == null) {\n return;\n }\n\n // `fixed` may consist of only whitespace. If this is the case,\n // surrounding whitespace must trimmed before\n // inserting the group's contents.\n const prevToken = info.containingArray[info.index - 1];\n const nextToken = info.containingArray[info.index + 1];\n if (\n match.whitespaceLike(prevToken) &&\n match.whitespaceLike(fixed[0])\n ) {\n trimStart(fixed);\n }\n if (\n match.whitespaceLike(nextToken) &&\n match.whitespaceLike(fixed[fixed.length - 1])\n ) {\n trimEnd(fixed);\n }\n replaceNodeDuringVisit(fixed, info);\n },\n { test: match.group }\n );\n\n visit(\n tree,\n (nodes, info) => {\n if (\n info.context.hasMathModeAncestor ||\n !nodes.some(isReplaceable)\n ) {\n return;\n }\n\n const replaced = replaceStreamingCommand(\n nodes,\n isReplaceable,\n (content, command) => {\n return replacers[command.content](content, command);\n }\n );\n\n // If we get back a different array than we input, the replacement did\n // not happen in-place. In this case we need to manipulate `nodes`.\n if (replaced !== nodes) {\n nodes.length = 0;\n nodes.push(...replaced);\n }\n },\n { includeArrays: true, test: Array.isArray }\n );\n };\n};\n", "import * as Ast from \"@unified-latex/unified-latex-types\";\nimport { match } from \"@unified-latex/unified-latex-util-match\";\nimport {\n splitOnCondition,\n unsplitOnMacro,\n} from \"@unified-latex/unified-latex-util-split\";\nimport {\n trim,\n trimEnd,\n trimStart,\n} from \"@unified-latex/unified-latex-util-trim\";\nimport { firstSignificantNode } from \"./utils/significant-node\";\nimport { replaceStreamingCommandInArray } from \"./utils/replace-streaming-command-in-array\";\nimport { wrapSignificantContent } from \"./utils/wrap-significant-content\";\n\ntype Replacer = (nodes: Ast.Node[]) => Ast.Node[];\n\n/**\n * Process streaming commands in a group. If needed, \"escape\" the group.\n * For example, `{\\bfseries xx}` -> `\\textbf{xx}`, but `{foo \\bfseries xx}` -> `{foo \\textbf{xx}}`.\n */\nexport function replaceStreamingCommandInGroup(\n group: Ast.Group,\n isStreamingCommand: (node: any) => node is Ast.Macro,\n replacer: (\n content: Ast.Node[],\n streamingCommand: Ast.Macro\n ) => Ast.Node | Ast.Node[],\n options?: {\n macrosThatBreakPars?: string[];\n environmentsThatDontBreakPars?: string[];\n }\n): Ast.Node[] {\n const content = group.content;\n // If the group started with a streaming command, we want to pop\n // out of the group. E.g. `{\\bfseries foo}` -> `\\textbf{foo}` and not `{\\textbf{foo}}`\n let popFromGroup = isStreamingCommand(firstSignificantNode(content));\n\n let innerProcessed = replaceStreamingCommand(\n content,\n isStreamingCommand,\n replacer,\n options\n );\n\n // If the group consisted of just streaming commands (for some reason...)\n // it should be eliminated\n if (innerProcessed.length === 0) {\n return [];\n }\n\n if (popFromGroup) {\n return innerProcessed;\n } else {\n return [{ type: \"group\", content: innerProcessed }];\n }\n}\n\n/**\n * Given a group or a node array, look for streaming commands (e.g., `\\bfseries`) and replace them\n * with the specified macro. The \"arguments\" of the streaming command are passed to `replacer` and the return\n * value of `replacer` is inserted into the stream.\n *\n * By default, this command will split at parbreaks (since commands like `\\textbf{...} do not accept parbreaks in their\n * contents) and call `replacer` multiple times, once per paragraph.\n *\n * Commands are also split at environments and at any macros listed in `macrosThatBreakPars`.\n */\nexport function replaceStreamingCommand(\n ast: Ast.Group | Ast.Node[],\n isStreamingCommand: (node: any) => node is Ast.Macro,\n replacer: (\n content: Ast.Node[],\n streamingCommand: Ast.Macro\n ) => Ast.Node | Ast.Node[],\n options?: {\n macrosThatBreakPars?: string[];\n environmentsThatDontBreakPars?: string[];\n }\n): Ast.Node[] {\n if (typeof isStreamingCommand !== \"function\") {\n throw new Error(\n `'isStreamingCommand' must be a function, not '${typeof isStreamingCommand}'`\n );\n }\n\n const {\n macrosThatBreakPars = [\n \"part\",\n \"chapter\",\n \"section\",\n \"subsection\",\n \"subsubsection\",\n \"vspace\",\n \"smallskip\",\n \"medskip\",\n \"bigskip\",\n \"hfill\",\n ],\n environmentsThatDontBreakPars = [],\n } = options || {};\n\n let processedContent: Ast.Node[] = [];\n if (match.group(ast)) {\n processedContent = replaceStreamingCommandInGroup(\n ast,\n isStreamingCommand,\n replacer\n );\n }\n\n if (Array.isArray(ast)) {\n // Streaming commands that come at the end of a sequence of nodes don't do anything.\n // They also will consume whitespace, so we should remove them and the whitespace.\n const nodes = ast;\n let scanIndex = nodes.length;\n let sliceIndex = scanIndex;\n while (\n scanIndex > 0 &&\n (isStreamingCommand(nodes[scanIndex - 1]) ||\n match.whitespace(nodes[scanIndex - 1]))\n ) {\n scanIndex--;\n if (isStreamingCommand(nodes[scanIndex])) {\n sliceIndex = scanIndex;\n }\n }\n if (sliceIndex !== nodes.length) {\n nodes.splice(sliceIndex);\n }\n\n const macroThatBreaks = match.createMacroMatcher(macrosThatBreakPars);\n const envThatDoesntBreak = match.createEnvironmentMatcher(\n environmentsThatDontBreakPars\n );\n // A \"par\" is anything that a streaming command shouldn't wrap and breaks the stream.\n // This includes regular pars, but also environments and special macros like \\section\n const isPar = (node: Ast.Node) =>\n match.parbreak(node) ||\n match.macro(node, \"par\") ||\n macroThatBreaks(node) ||\n (match.environment(node) && !envThatDoesntBreak(node)) ||\n node.type === \"displaymath\";\n\n // We split on both a parbreak and a literal `\\par`. But we will\n // normalize everything to be parbreaks\n const splitByPar = splitOnCondition(nodes, isPar);\n splitByPar.separators = splitByPar.separators.map((sep) =>\n match.macro(sep, \"par\") ? { type: \"parbreak\" } : sep\n );\n\n const replacers: Replacer[] = [];\n let segments = splitByPar.segments.map((segment) => {\n if (segment.length === 0) {\n return segment;\n }\n function applyAccumulatedReplacers(nodes: Ast.Node[]): Ast.Node[] {\n if (replacers.length === 0) {\n return nodes;\n }\n return wrapSignificantContent(\n nodes,\n composeReplacers(replacers)\n );\n }\n\n const { foundStreamingCommands } = replaceStreamingCommandInArray(\n segment,\n isStreamingCommand,\n replacer\n );\n\n // All streaming commands in `segment` have now been replaced. However,\n // there might be commands from the previous paragraphs that should wrap\n // the current segment!\n const ret = applyAccumulatedReplacers(segment);\n\n // Any streaming commands from this segment will carry over to the next,\n // so keep track of them.\n foundStreamingCommands.forEach((macro) => {\n replacers.push((nodes: Ast.Node[]) => {\n const ret = replacer(nodes, macro as Ast.Macro);\n if (!Array.isArray(ret)) {\n return [ret];\n }\n return ret;\n });\n });\n\n return ret;\n });\n\n // Leading/trailing whitespace was hoisted in front/back of each replacer.\n // Since we're separated by parbreaks, we can safely trim all that whitespace.\n if (segments.length > 1) {\n segments.forEach((segment, i) => {\n if (i === 0) {\n trimEnd(segment);\n } else if (i === segments.length - 1) {\n trimStart(segment);\n } else {\n trim(segment);\n }\n });\n }\n\n processedContent = unsplitOnMacro({\n segments: segments,\n macros: splitByPar.separators,\n });\n }\n\n return processedContent;\n}\n\n/**\n * Given a sequence of replacer functions `[f, g, h]` return\n * `h \\circ g \\circ f`\n *\n * @param {((nodes: Ast.Node[]) => Ast.Node)[]} replacers\n * @returns {(nodes: Ast.Node[]) => Ast.Node}\n */\nfunction composeReplacers(replacers: Replacer[]): Replacer {\n if (replacers.length === 0) {\n throw new Error(\"Cannot compose zero replacement functions\");\n }\n return (nodes: Ast.Node[]) => {\n let ret = nodes;\n for (let i = 0; i < replacers.length; i++) {\n const func = replacers[i];\n ret = func(ret);\n }\n return ret;\n };\n}\n", "import * as Ast from \"@unified-latex/unified-latex-types\";\nimport { match } from \"@unified-latex/unified-latex-util-match\";\n\n/**\n * Returns the first non-whitespace/non-comment node in `nodes`. If there is no such\n * node, `null` is returned.\n */\nexport function firstSignificantNode(\n nodes: Ast.Node[],\n parbreaksAreInsignificant?: boolean\n): Ast.Node | null {\n const index = firstSignificantNodeIndex(nodes, parbreaksAreInsignificant);\n if (index == null) {\n return null;\n }\n return nodes[index];\n}\n\n/**\n * Returns the last non-whitespace/non-comment node in `nodes`. If there is no such\n * node, `null` is returned.\n */\nexport function lastSignificantNode(\n nodes: Ast.Node[],\n parbreaksAreInsignificant?: boolean\n): Ast.Node | null {\n const index = lastSignificantNodeIndex(nodes, parbreaksAreInsignificant);\n if (index == null) {\n return null;\n }\n return nodes[index];\n}\n\n/**\n * Returns the index of the last non-whitespace/non-comment node in `nodes`. If there is no such\n * node, `null` is returned.\n */\nexport function lastSignificantNodeIndex(\n nodes: Ast.Node[],\n parbreaksAreInsignificant?: boolean\n): number | undefined {\n for (let i = nodes.length - 1; i >= 0; i--) {\n const node = nodes[i];\n if (\n match.whitespace(node) ||\n match.comment(node) ||\n (parbreaksAreInsignificant && match.parbreak(node))\n ) {\n continue;\n }\n return i;\n }\n return undefined;\n}\n\n/**\n * Returns the index of the first non-whitespace/non-comment node in `nodes`. If there is no such\n * node, `null` is returned.\n */\nexport function firstSignificantNodeIndex(\n nodes: Ast.Node[],\n parbreaksAreInsignificant?: boolean\n): number | undefined {\n for (let i = 0; i < nodes.length; i++) {\n const node = nodes[i];\n if (\n match.whitespace(node) ||\n match.comment(node) ||\n (parbreaksAreInsignificant && match.parbreak(node))\n ) {\n continue;\n }\n return i;\n }\n return undefined;\n}\n", "import * as Ast from \"@unified-latex/unified-latex-types\";\nimport { trimEnd, trimStart } from \"@unified-latex/unified-latex-util-trim\";\nimport { joinWithoutExcessWhitespace } from \"./join-without-excess-whitespace\";\nimport { wrapSignificantContent } from \"./wrap-significant-content\";\n\n/**\n * Replace commands identified by `isStreamingCommand` with the return value of `replacer`.\n * E.g., the array `[head, streamingCommand, ...tail]` will become `[head, replacer(tail, streamingCommand)]`.\n * This function does not split based on parbreaks/etc.. It is right-associative and returns\n * the streaming commands that were encountered.\n */\nexport function replaceStreamingCommandInArray(\n nodes: Ast.Node[],\n isStreamingCommand: (node: any) => node is Ast.Macro,\n replacer: (\n content: Ast.Node[],\n streamingCommand: Ast.Macro\n ) => Ast.Node | Ast.Node[]\n): { foundStreamingCommands: Ast.Node[] } {\n // Streaming commands that come at the end don't do anything,\n // so we should remove them\n while (nodes.length > 0 && isStreamingCommand(nodes[nodes.length - 1])) {\n nodes.pop();\n trimEnd(nodes);\n }\n\n const foundStreamingCommands: Ast.Node[] = [];\n\n for (let i = nodes.length - 1; i >= 0; i--) {\n const node = nodes[i];\n if (isStreamingCommand(node)) {\n const wrapper = (content: Ast.Node[]) => replacer(content, node);\n let tail = nodes.slice(i + 1);\n // Streaming commands are followed by whitespace, which becomes unneeded when the commands are replaced.\n trimStart(tail);\n tail = wrapSignificantContent(tail, wrapper);\n foundStreamingCommands.push(node);\n\n // Trim off what we're about to replace!\n nodes.splice(i);\n\n joinWithoutExcessWhitespace(nodes, tail);\n }\n }\n\n return { foundStreamingCommands };\n}\n", "import * as Ast from \"@unified-latex/unified-latex-types\";\nimport { match } from \"@unified-latex/unified-latex-util-match\";\nimport { trimStart } from \"@unified-latex/unified-latex-util-trim\";\n\n/**\n * Is the node space-like? I.e., is it whitespace or\n * a comment with leading whitespace?\n */\nfunction isSpaceLike(node: Ast.Node): boolean {\n return (\n match.whitespace(node) ||\n (match.comment(node) && Boolean(node.leadingWhitespace))\n );\n}\n\n/**\n * Similar to `head.push(...tail)` except that whitespace at the start\n * of `tail` and the end of `head` is collapsed.\n */\nexport function joinWithoutExcessWhitespace(\n head: Ast.Node[],\n tail: Ast.Node[]\n): void {\n if (tail.length === 0) {\n return;\n }\n if (head.length === 0) {\n head.push(...tail);\n return;\n }\n const headEnd = head[head.length - 1];\n const tailStart = tail[0];\n // Whitespace we can just trim off from either end\n if (match.whitespace(headEnd) && match.whitespace(tailStart)) {\n head.push(...tail.slice(1));\n return;\n }\n // If there's no whitespace at one of the ends, no need to worry\n // unless `tailStart` is a comment, in which case it should \"eat\"\n // the whitespace\n if (!isSpaceLike(headEnd) || !isSpaceLike(tailStart)) {\n if (match.whitespace(headEnd) && match.comment(tailStart)) {\n const comment: Ast.Comment = {\n type: \"comment\",\n content: tailStart.content,\n sameline: true,\n leadingWhitespace: true,\n };\n tail = tail.slice(1);\n trimStart(tail);\n head.pop();\n head.push(comment, ...tail);\n return;\n }\n head.push(...tail);\n return;\n }\n\n // If we're here, we have a comment with leading whitespace on one side\n // and whitespace/comments on the other.\n if (match.comment(headEnd) && match.comment(tailStart)) {\n if (tailStart.leadingWhitespace || tailStart.sameline) {\n head.push(\n { type: \"comment\", content: tailStart.content },\n ...tail.slice(1)\n );\n return;\n }\n head.push(...tail);\n return;\n }\n\n // Exactly one side is a comment, so we should trim the whitespace and keep the comment,\n // but make sure the comment has leading whitespace!\n let comment = match.comment(headEnd) ? headEnd : tailStart;\n if (!match.comment(comment)) {\n throw new Error(\n `Expected a comment but found ${JSON.stringify(comment)}`\n );\n }\n\n if (!comment.leadingWhitespace || !comment.sameline) {\n comment = {\n type: \"comment\",\n content: comment.content,\n leadingWhitespace: true,\n sameline: true,\n };\n }\n\n head.pop();\n head.push(comment, ...tail.slice(1));\n}\n", "import * as Ast from \"@unified-latex/unified-latex-types\";\nimport { match } from \"@unified-latex/unified-latex-util-match\";\n\n/**\n * Wraps `content` in the specified wrapper. This command is roughly equivalent to\n * `wrapper(content)` except that leading and trailing whitespace and comments are extracted\n * from `content` and moved to the front or back of the return array. For example,\n * `[\" \", \"foo\", \"bar\", \"% xxx\"]` -> `[\" \", wrapped([\"foo\", \"bar\"]), \"% xxx\"]`.\n *\n */\nexport function wrapSignificantContent(\n content: Ast.Node[],\n wrapper: (content: Ast.Node[]) => Ast.Node[] | Ast.Node\n): Ast.Node[] {\n let hoistUntil = 0;\n let hoistAfter = content.length;\n for (let i = 0; i < content.length; i++) {\n if (match.whitespace(content[i]) || match.comment(content[i])) {\n hoistUntil = i + 1;\n continue;\n }\n break;\n }\n for (let j = content.length - 1; j >= 0; j--) {\n if (match.whitespace(content[j]) || match.comment(content[j])) {\n hoistAfter = j;\n continue;\n }\n break;\n }\n\n if (hoistUntil === 0 && hoistAfter === content.length) {\n return ensureArray(wrapper(content));\n }\n\n const frontMatter = content.slice(0, hoistUntil);\n const middle = content.slice(hoistUntil, hoistAfter);\n const backMatter = content.slice(hoistAfter, content.length);\n\n return frontMatter.concat(wrapper(middle), backMatter);\n}\n\nfunction ensureArray(x: Ast.Node | Ast.Node[]) {\n if (!Array.isArray(x)) {\n return [x];\n }\n return x;\n}\n", "import { VisitInfo } from \"@unified-latex/unified-latex-util-visit\";\nimport * as Ast from \"@unified-latex/unified-latex-types\";\n\n/**\n * Replaces the current node with `replacement`. It is assumed that the current\n * node is in an array that is a child of a parent element. If this is not the case,\n * the function will error.\n */\nexport function replaceNodeDuringVisit(\n replacement: Ast.Node | Ast.Argument | (Ast.Node | Ast.Argument)[],\n info: VisitInfo\n) {\n const parent = info.parents[0];\n if (!parent) {\n throw new Error(`Cannot replace node: parent not found`);\n }\n const container = parent[info.key as keyof typeof parent] as\n | (Ast.Node | Ast.Argument)[]\n | undefined;\n if (!Array.isArray(container)) {\n throw new Error(`Cannot replace node: containing array not found`);\n }\n if (info.index == null) {\n throw new Error(`Cannot replace node: node index undefined`);\n }\n if (!Array.isArray(replacement)) {\n container[info.index] = replacement;\n } else {\n container.splice(info.index, 1, ...replacement);\n }\n}\n", "import { MacroInfoRecord, EnvInfoRecord } from \"@unified-latex/unified-latex-types\";\n\nexport const macros: MacroInfoRecord = {\n cref: { signature: \"s m\" },\n Cref: { signature: \"s m\" },\n crefrange: { signature: \"s m m\" },\n Crefrange: { signature: \"s m m\" },\n cpageref: { signature: \"s m\" },\n Cpageref: { signature: \"s m\" },\n ref: { signature: \"m\" },\n pageref: { signature: \"m\" },\n namecref: { signature: \"m\" },\n nameCref: { signature: \"m\" },\n lcnamecref: { signature: \"m\" },\n namecrefs: { signature: \"m\" },\n nameCrefs: { signature: \"m\" },\n lcnamecrefs: { signature: \"m\" },\n labelcref: { signature: \"m\" },\n labelcpageref: { signature: \"m\" },\n crefalias: { signature: \"m m\" },\n crefname: { signature: \"m m m\" },\n // XXX there are many more obscure commands to add here\n // https://ctan.org/pkg/cleveref\n crefdefaultlabelformat: { signature: \"m\" },\n crefrangeconjunction: { signature: \"m\" },\n};\n\nexport const environments: EnvInfoRecord = {};\n", "import { arg } from \"@unified-latex/unified-latex-builder\";\nimport * as Ast from \"@unified-latex/unified-latex-types\";\nimport { match } from \"@unified-latex/unified-latex-util-match\";\nimport { printRaw } from \"@unified-latex/unified-latex-util-print-raw\";\nimport { updateRenderInfo } from \"@unified-latex/unified-latex-util-render-info\";\nimport {\n lastSignificantNode,\n lastSignificantNodeIndex,\n} from \"@unified-latex/unified-latex-util-replace\";\nimport { splitOnMacro } from \"@unified-latex/unified-latex-util-split\";\nimport { trim, trimEnd } from \"@unified-latex/unified-latex-util-trim\";\n\n/**\n * Clean up any whitespace issues in an enumerate environment. In particular,\n * * Remove any leading or ending whitespace\n * * Ensure there is a par between occurrences of `\\item`\n * * Ensure there is whitespace after each occurrence of `\\item` provided there is content there\n * `itemName` can be used to set what the \"item\" macro is called.\n *\n * This function attaches content following a `\\item` to the `\\item` macro with\n * `openMark` and `closeMark` set to empty. This allows hanging-indents to be rendered.\n */\nexport function cleanEnumerateBody(\n ast: Ast.Node[],\n itemName = \"item\"\n): Ast.Node[] {\n let { segments, macros } = splitOnMacro(ast, itemName);\n // Trim the content of each block, but make sure there is a space\n // between each macro and the content. Since the first segment of content\n // appears *before* any macro, don't add a space there.\n for (let i = 0; i < segments.length; i++) {\n const segment = segments[i];\n if (i === 0) {\n // The very first segment might be comment with leading whitespace. We don't want to trim that off\n trimEnd(segment);\n } else {\n trim(segment);\n }\n // The very first segment comes before any `\\item` macros. It is either\n // blank or contains comments (or is invalid LaTeX). We don't insert a space\n // in this case.\n if (segment.length > 0 && i > 0) {\n segment.unshift({ type: \"whitespace\" });\n }\n }\n\n let insertParbreakBefore: WeakSet = new WeakSet();\n\n // We want a trailing indent for the `\\item` nodes. We will\n // do this with a trick: we will add an argument to the index node\n // with openMark=\" \" and closeMark=\"\"\n let body: Ast.Node[] = macros.flatMap((node, i) => {\n const segment = segments[i + 1];\n const trailingComments = popTrailingComments(segment);\n node.args = node.args || [];\n node.args.push(arg(segment, { openMark: \"\", closeMark: \"\" }));\n updateRenderInfo(node, { inParMode: true });\n\n // The stream contains a mix of `\\item` macros and comments/parbreaks. We only\n // want to insert parbreaks before `\\item` macros, so we record these for later.\n if (i > 0 || segments[0]?.length > 0) {\n insertParbreakBefore.add(node);\n }\n\n return [node, ...trailingComments];\n });\n\n // We want a parbreak between each `\\item` block and the preceding content.\n // We've already logged the `\\item` macros in `insertParbreakBefore`.\n body = body.flatMap((node) =>\n insertParbreakBefore.has(node) ? [{ type: \"parbreak\" }, node] : node\n );\n\n body.unshift(...segments[0]);\n\n // We have inserted parbreaks so some comments need to be told that there is a suffix parbreak\n for (let i = 0; i < body.length - 1; i++) {\n const node = body[i];\n const nextNode = body[i + 1];\n if (!match.parbreak(nextNode)) {\n continue;\n }\n if (match.comment(node)) {\n node.suffixParbreak = true;\n }\n // The heuristic for detecting an `item`-like node is that its last argument has no close mark.\n // Regardless of what it is, if there is no close mark, when rendered we don't want two newlines to\n // appear.\n if (\n match.macro(node) &&\n node.args &&\n node.args[node.args.length - 1].closeMark === \"\"\n ) {\n const args = node.args[node.args.length - 1].content;\n const lastArg = args[args.length - 1];\n if (match.comment(lastArg)) {\n lastArg.suffixParbreak = true;\n }\n }\n }\n\n return body;\n}\n\n/**\n * Removes and returns any number of trailing comments/parbreaks from `nodes`.\n */\nfunction popTrailingComments(nodes: Ast.Node[]): Ast.Node[] {\n let lastNodeIndex = lastSignificantNodeIndex(nodes, true);\n if (\n lastNodeIndex === nodes.length - 1 ||\n (lastNodeIndex == null && nodes.length === 0)\n ) {\n return [];\n }\n\n // If `nodes` has a non-zero length and we didn't find a significant node, everything is comments!\n if (lastNodeIndex == null) {\n lastNodeIndex = -1;\n }\n return nodes.splice(lastNodeIndex + 1);\n}\n", "import { MacroInfoRecord, EnvInfoRecord } from \"@unified-latex/unified-latex-types\";\nimport { cleanEnumerateBody } from \"../../utils/enumerate\";\n\nexport const macros: MacroInfoRecord = {\n answerline: { signature: \"o\" },\n fillin: { signature: \"o o\" },\n fullwidth: { signature: \"m\" },\n fillwidthlines: { signature: \"m\" },\n fillwidthdottedlines: { signature: \"m\" },\n fillwidthgrid: { signature: \"m\" },\n makeemptybox: { signature: \"m\" },\n CorrectChoiceEmphasis: {\n signature: \"m\",\n renderInfo: { breakAround: true },\n },\n SolutionEmphasis: { signature: \"m\", renderInfo: { breakAround: true } },\n uplevel: { signature: \"m\", renderInfo: { breakAround: true } },\n checkboxchar: { signature: \"m\", renderInfo: { breakAround: true } },\n checkedchar: { signature: \"m\", renderInfo: { breakAround: true } },\n pointname: { signature: \"m\", renderInfo: { breakAround: true } },\n marginpointname: { signature: \"m\", renderInfo: { breakAround: true } },\n extrawidth: { signature: \"m\", renderInfo: { breakAround: true } },\n pointformat: { signature: \"m\", renderInfo: { breakAround: true } },\n bonuspointformat: { signature: \"m\", renderInfo: { breakAround: true } },\n totalformat: { signature: \"m\", renderInfo: { breakAround: true } },\n qformat: { signature: \"m\", renderInfo: { breakAround: true } },\n titledquestion: { signature: \"m o\", renderInfo: { breakAround: true } },\n pointpoints: { signature: \"m m\", renderInfo: { breakAround: true } },\n bonuspointpoints: { signature: \"m m\", renderInfo: { breakAround: true } },\n};\n\nexport const environments: EnvInfoRecord = {\n choices: {\n signature: \"o\",\n processContent: (nodes) => cleanEnumerateBody(nodes, \"choice\"),\n },\n checkboxes: {\n signature: \"o\",\n processContent: (nodes) => cleanEnumerateBody(nodes, \"choice\"),\n },\n oneparchoices: {\n signature: \"o\",\n processContent: (nodes) => cleanEnumerateBody(nodes, \"choice\"),\n },\n oneparcheckboxes: {\n signature: \"o\",\n processContent: (nodes) => cleanEnumerateBody(nodes, \"choice\"),\n },\n parts: {\n signature: \"o\",\n processContent: (nodes) => cleanEnumerateBody(nodes, \"part\"),\n },\n subparts: {\n signature: \"o\",\n processContent: (nodes) => cleanEnumerateBody(nodes, \"subpart\"),\n },\n subsubparts: {\n signature: \"o\",\n processContent: (nodes) => cleanEnumerateBody(nodes, \"subsubpart\"),\n },\n questions: {\n signature: \"o\",\n processContent: (nodes) => cleanEnumerateBody(nodes, \"question\"),\n },\n};\n", "import { MacroInfoRecord, EnvInfoRecord } from \"@unified-latex/unified-latex-types\";\n\nexport const macros: MacroInfoRecord = {\n geometry: {\n signature: \"m\",\n renderInfo: { breakAround: true, pgfkeysArgs: true },\n },\n};\n\nexport const environments: EnvInfoRecord = {};\n", "import { MacroInfoRecord, EnvInfoRecord } from \"@unified-latex/unified-latex-types\";\n\nexport const macros: MacroInfoRecord = {\n hypersetup: {\n signature: \"m\",\n renderInfo: { breakAround: true, pgfkeysArgs: true },\n },\n href: { signature: \"o m m\" },\n url: { signature: \"m\" },\n nolinkurl: { signature: \"m\" },\n hyperbaseurl: { signature: \"m\" },\n hyperimage: { signature: \"m m\" },\n hyperdef: { signature: \"m m m\" },\n hyperref: { signature: \"o m\" },\n hyperlink: { signature: \"m m\" },\n hypertarget: { signature: \"m m\" },\n autoref: { signature: \"s m\" },\n pageref: { signature: \"s m\" },\n autopageref: { signature: \"s m\" },\n pdfstringdef: { signature: \"m m\" },\n pdfbookmark: { signature: \"o m m\" },\n currentpdfbookmark: { signature: \"m m\" },\n subpdfbookmark: { signature: \"m m\" },\n belowpdfbookmark: { signature: \"m m\" },\n texorpdfstring: { signature: \"m m\" },\n thispdfpagelabel: { signature: \"m\" },\n hypercalcbp: { signature: \"m\" },\n};\n\nexport const environments: EnvInfoRecord = {};\n", "import {\n MacroInfoRecord,\n EnvInfoRecord,\n} from \"@unified-latex/unified-latex-types\";\nimport { trim } from \"@unified-latex/unified-latex-util-trim\";\nimport { cleanEnumerateBody } from \"../../utils/enumerate\";\n\nexport const macros: MacroInfoRecord = {\n // Special\n \"\\\\\": { signature: \"!s !o\" },\n _: { signature: \"m\", escapeToken: \"\" },\n \"^\": { signature: \"m\", escapeToken: \"\" },\n // \\newcommand arg signature from https://www.texdev.net/2020/08/19/the-good-the-bad-and-the-ugly-creating-document-commands\n // List can be found in latex2e.pdf \"An unofficial reference manual\"\n newcommand: {\n signature: \"s +m o +o +m\",\n renderInfo: {\n breakAround: true,\n namedArguments: [\"starred\", \"name\", \"numArgs\", \"default\", \"body\"],\n },\n },\n renewcommand: {\n signature: \"s +m o +o +m\",\n renderInfo: {\n breakAround: true,\n namedArguments: [\"starred\", \"name\", \"numArgs\", \"default\", \"body\"],\n },\n },\n providecommand: {\n signature: \"s +m o +o +m\",\n renderInfo: { breakAround: true },\n },\n // Counters\n newcounter: {\n signature: \"m o\",\n renderInfo: { breakAround: true },\n },\n usecounter: {\n signature: \"m\",\n },\n setcounter: {\n signature: \"m m\",\n renderInfo: { breakAround: true },\n },\n addtocounter: {\n signature: \"m m\",\n renderInfo: { breakAround: true },\n },\n stepcounter: {\n signature: \"m\",\n renderInfo: { breakAround: true },\n },\n refstepcounter: {\n signature: \"m\",\n renderInfo: { breakAround: true },\n },\n // Lengths\n newlength: {\n signature: \"m\",\n renderInfo: { breakAround: true },\n },\n addtolength: {\n signature: \"m m\",\n renderInfo: { breakAround: true },\n },\n settodepth: {\n signature: \"m m\",\n renderInfo: { breakAround: true },\n },\n settoheight: {\n signature: \"m m\",\n renderInfo: { breakAround: true },\n },\n settowidth: {\n signature: \"m m\",\n renderInfo: { breakAround: true },\n },\n // Spaces\n stretch: { signature: \"m\" },\n hspace: { signature: \"s m\" },\n vspace: { signature: \"s m\", renderInfo: { breakAround: true } },\n vfill: { renderInfo: { breakAround: true } },\n indent: { renderInfo: { breakAround: true } },\n phantom: { signature: \"m\" },\n vphantom: { signature: \"m\" },\n hphantom: { signature: \"m\" },\n noindent: { renderInfo: { breakAround: true } },\n smallskip: { renderInfo: { breakAround: true } },\n medskip: { renderInfo: { breakAround: true } },\n bigskip: { renderInfo: { breakAround: true } },\n smallbreak: { renderInfo: { breakAround: true } },\n medbreak: { renderInfo: { breakAround: true } },\n bigbreak: { renderInfo: { breakAround: true } },\n newline: { renderInfo: { breakAround: true } },\n linebreak: { signature: \"o\", renderInfo: { breakAround: true } },\n nolinebreak: { signature: \"o\", renderInfo: { breakAround: true } },\n clearpage: { renderInfo: { breakAround: true } },\n cleardoublepage: { renderInfo: { breakAround: true } },\n newpage: { renderInfo: { breakAround: true } },\n enlargethispage: { signature: \"s\", renderInfo: { breakAround: true } },\n pagebreak: { signature: \"o\", renderInfo: { breakAround: true } },\n nopagebreak: { signature: \"o\", renderInfo: { breakAround: true } },\n // Boxes\n newsavebox: {\n signature: \"m\",\n renderInfo: { breakAround: true },\n },\n sbox: {\n signature: \"m m\",\n renderInfo: { breakAround: true },\n },\n savebox: {\n signature: \"m o o m\",\n renderInfo: { breakAround: true },\n },\n mbox: { signature: \"m\" },\n makebox: { signature: \"d() o o m\", renderInfo: { breakAround: true } },\n fbox: { signature: \"m\" },\n framebox: { signature: \"o o m\", renderInfo: { breakAround: true } },\n frame: { signature: \"m\", renderInfo: { breakAround: true } },\n parbox: { signature: \"o o o m m\", renderInfo: { breakAround: true } },\n raisebox: { signature: \"m o o m\" },\n marginpar: { signature: \"o m\", renderInfo: { breakAround: true } },\n colorbox: { signature: \"o m m\", renderInfo: { breakAround: true } },\n fcolorbox: { signature: \"o m m\", renderInfo: { breakAround: true } },\n rotatebox: { signature: \"o m m\" },\n scalebox: { signature: \"m o m\" },\n reflectbox: { signature: \"m\" },\n resizebox: { signature: \"s m m m\" },\n // Define environments\n newenvironment: {\n signature: \"s m o o m m\",\n renderInfo: { breakAround: true },\n },\n renewenvironment: {\n signature: \"s m o o m m\",\n renderInfo: { breakAround: true },\n },\n newtheorem: {\n signature: \"s m o m o\",\n renderInfo: { breakAround: true },\n },\n newfont: {\n signature: \"m m\",\n renderInfo: { breakAround: true },\n },\n // Counters\n alph: { signature: \"m\" },\n Alph: { signature: \"m\" },\n arabic: { signature: \"m\" },\n roman: { signature: \"m\" },\n Roman: { signature: \"m\" },\n fnsymbol: { signature: \"m\" },\n // Other\n documentclass: {\n signature: \"o m\",\n renderInfo: { breakAround: true, pgfkeysArgs: true },\n },\n usepackage: {\n signature: \"o m\",\n renderInfo: { breakAround: true, pgfkeysArgs: true },\n },\n item: {\n signature: \"o\",\n renderInfo: { hangingIndent: true, namedArguments: [\"label\"] },\n },\n value: { signature: \"m\" },\n centering: { renderInfo: { breakAround: true } },\n input: { signature: \"m\", renderInfo: { breakAround: true } },\n include: { signature: \"m\", renderInfo: { breakAround: true } },\n includeonly: {\n signature: \"m\",\n renderInfo: { breakAround: true, pgfkeysArgs: true },\n },\n discretionary: { signature: \"m m m\" },\n hyphenation: { signature: \"m m m\" },\n footnote: { signature: \"o m\", renderInfo: { inParMode: true } },\n footnotemark: { signature: \"o\" },\n footnotetext: { signature: \"o m\", renderInfo: { inParMode: true } },\n caption: {\n signature: \"o m\",\n renderInfo: { inParMode: true, breakAround: true },\n },\n // Math Commands\n sqrt: { signature: \"o m\", renderInfo: { inMathMode: true } },\n frac: { signature: \"m m\", renderInfo: { inMathMode: true } },\n stackrel: { signature: \"m m\" },\n ensuremath: { signature: \"m\", renderInfo: { inMathMode: true } },\n // Layout commands\n abstract: {\n signature: \"m\",\n renderInfo: { breakAround: true, inParMode: true },\n },\n maketitle: { renderInfo: { breakAround: true } },\n doublespacing: { renderInfo: { breakAround: true } },\n singlespacing: { renderInfo: { breakAround: true } },\n author: {\n signature: \"m\",\n renderInfo: { breakAround: true, inParMode: true },\n },\n date: { signature: \"o m\", renderInfo: { breakAround: true } },\n thanks: {\n signature: \"m\",\n renderInfo: { breakAround: true, inParMode: true },\n },\n // amsart document class adds an optional argument\n title: {\n signature: \"o m\",\n renderInfo: { breakAround: true, inParMode: true },\n },\n pagenumbering: { signature: \"m\", renderInfo: { breakAround: true } },\n pagestyle: { signature: \"m\", renderInfo: { breakAround: true } },\n thispagestyle: { signature: \"m\", renderInfo: { breakAround: true } },\n // Colors\n definecolor: { signature: \"m m m\", renderInfo: { breakAround: true } },\n pagecolor: { signature: \"o m\", renderInfo: { breakAround: true } },\n nopagecolor: { renderInfo: { breakAround: true } },\n multicolumn: { signature: \"m m m\" },\n // Graphics\n includegraphics: {\n signature: \"s o o m\",\n renderInfo: { breakAround: true, pgfkeysArgs: true },\n },\n rule: { signature: \"o m m\" },\n // Sectioning\n part: {\n signature: \"s o m\",\n renderInfo: {\n breakAround: true,\n inParMode: true,\n namedArguments: [\"starred\", \"tocTitle\", \"title\"],\n },\n },\n chapter: {\n signature: \"s o m\",\n renderInfo: {\n breakAround: true,\n inParMode: true,\n namedArguments: [\"starred\", \"tocTitle\", \"title\"],\n },\n },\n section: {\n signature: \"s o m\",\n renderInfo: {\n breakAround: true,\n inParMode: true,\n namedArguments: [\"starred\", \"tocTitle\", \"title\"],\n },\n },\n subsection: {\n signature: \"s o m\",\n renderInfo: {\n breakAround: true,\n inParMode: true,\n namedArguments: [\"starred\", \"tocTitle\", \"title\"],\n },\n },\n subsubsection: {\n signature: \"s o m\",\n renderInfo: {\n breakAround: true,\n inParMode: true,\n namedArguments: [\"starred\", \"tocTitle\", \"title\"],\n },\n },\n paragraph: {\n signature: \"s o m\",\n renderInfo: {\n breakAround: true,\n inParMode: true,\n namedArguments: [\"starred\", \"tocTitle\", \"title\"],\n },\n },\n subparagraph: {\n signature: \"s o m\",\n renderInfo: {\n breakAround: true,\n inParMode: true,\n namedArguments: [\"starred\", \"tocTitle\", \"title\"],\n },\n },\n appendix: { renderInfo: { breakAround: true, inParMode: true } },\n frontmatter: { renderInfo: { breakAround: true, inParMode: true } },\n mainmatter: { renderInfo: { breakAround: true, inParMode: true } },\n backmatter: { renderInfo: { breakAround: true, inParMode: true } },\n // Citing and references\n bibitem: { signature: \"o m\", renderInfo: { hangingIndent: true } },\n cite: { signature: \"o m\" },\n // Fonts\n textrm: { signature: \"m\", renderInfo: { inParMode: true } },\n textit: { signature: \"m\", renderInfo: { inParMode: true } },\n textmd: { signature: \"m\", renderInfo: { inParMode: true } },\n textbf: { signature: \"m\", renderInfo: { inParMode: true } },\n textup: { signature: \"m\", renderInfo: { inParMode: true } },\n textsl: { signature: \"m\", renderInfo: { inParMode: true } },\n textsf: { signature: \"m\", renderInfo: { inParMode: true } },\n textsc: { signature: \"m\", renderInfo: { inParMode: true } },\n texttt: { signature: \"m\", renderInfo: { inParMode: true } },\n emph: { signature: \"m\", renderInfo: { inParMode: true } },\n textnormal: { signature: \"m\", renderInfo: { inParMode: true } },\n uppercase: { signature: \"m\", renderInfo: { inParMode: true } },\n mathbf: { signature: \"m\" },\n mathsf: { signature: \"m\" },\n mathtt: { signature: \"m\" },\n mathit: { signature: \"m\" },\n mathnormal: { signature: \"m\" },\n mathcal: { signature: \"m\" },\n mathrm: { signature: \"m\" },\n // Other\n setlength: { signature: \"m m\", renderInfo: { breakAround: true } },\n ref: { signature: \"s m\" },\n label: { signature: \"o m\" }, // cleveref changes \\label to have this signature\n printbibliography: { renderInfo: { breakAround: true } },\n addtocontents: { signature: \"m m\", renderInfo: { breakAround: true } },\n addcontentsline: { signature: \"m m m\", renderInfo: { breakAround: true } },\n contentsline: { signature: \"m m m\", renderInfo: { breakAround: true } },\n bibliography: { signature: \"m\", renderInfo: { breakAround: true } },\n bibliographystyle: { signature: \"m\", renderInfo: { breakAround: true } },\n};\n\nexport const environments: EnvInfoRecord = {\n document: {\n processContent: (nodes) => {\n trim(nodes);\n return nodes;\n },\n },\n array: { signature: \"o m\", renderInfo: { alignContent: true } },\n description: { signature: \"o\", processContent: cleanEnumerateBody },\n enumerate: {\n signature: \"o\",\n processContent: cleanEnumerateBody,\n renderInfo: { pgfkeysArgs: true },\n },\n itemize: { signature: \"o\", processContent: cleanEnumerateBody },\n trivlist: { signature: \"o\", processContent: cleanEnumerateBody },\n list: { signature: \"m m\", processContent: cleanEnumerateBody },\n figure: { signature: \"o\" },\n \"figure*\": { signature: \"o\" },\n filecontents: { signature: \"o m\" },\n \"filecontents*\": { signature: \"o m\" },\n minipage: { signature: \"o o o m\" },\n picture: { signature: \"r() d()\" },\n tabbing: { renderInfo: { alignContent: true } },\n table: { signature: \"o\" },\n tabular: { signature: \"o m\", renderInfo: { alignContent: true } },\n \"tabular*\": { signature: \"m o m\", renderInfo: { alignContent: true } },\n thebibliography: {\n signature: \"m\",\n processContent: (nodes) => cleanEnumerateBody(nodes, \"bibitem\"),\n },\n // Math\n math: { renderInfo: { inMathMode: true } },\n};\n", "import { arg } from \"@unified-latex/unified-latex-builder\";\nimport { Argument, ArgumentParser } from \"@unified-latex/unified-latex-types\";\nimport { parse as parseArgspec } from \"@unified-latex/unified-latex-util-argspec\";\nimport { Node } from \"@unified-latex/unified-latex-util-argspec/libs/argspec-types\";\nimport { gobbleSingleArgument } from \"@unified-latex/unified-latex-util-arguments\";\nimport { match } from \"@unified-latex/unified-latex-util-match\";\n\nconst argSpecM = parseArgspec(\"m\")[0];\nconst argSpecO = parseArgspec(\"o\")[0];\nconst argSpecRDelim: { [delim: string]: Node } = {};\n\n/**\n * This argument parser parses arguments in the form of\n * - [\u27E8key=value list\u27E9]\u27E8character\u27E9\u27E8source code\u27E9\u27E8same character\u27E9\n * - [\u27E8key=value list\u27E9]{\u27E8source code\u27E9}\n */\nexport const argumentParser: ArgumentParser = (nodes, startPos) => {\n const { argument: optionalArg, nodesRemoved: optionalArgNodesRemoved } =\n gobbleSingleArgument(nodes, argSpecO, startPos);\n\n let codeArg: Argument | null = null;\n let codeArgNodesRemoved: number = 0;\n const nextNode = nodes[startPos];\n if (match.group(nextNode)) {\n const mandatoryArg = gobbleSingleArgument(nodes, argSpecM, startPos);\n codeArg = mandatoryArg.argument;\n codeArgNodesRemoved = mandatoryArg.nodesRemoved;\n } else if (match.string(nextNode) && nextNode.content.length === 1) {\n const delim = nextNode.content;\n argSpecRDelim[delim] =\n argSpecRDelim[delim] || parseArgspec(`r${delim}${delim}`)[0];\n const delimArg = gobbleSingleArgument(\n nodes,\n argSpecRDelim[delim],\n startPos\n );\n codeArg = delimArg.argument;\n codeArgNodesRemoved = delimArg.nodesRemoved;\n }\n\n return {\n args: [optionalArg || arg(null), codeArg || arg(null)],\n nodesRemoved: optionalArgNodesRemoved + codeArgNodesRemoved,\n };\n};\n", "import {\n MacroInfoRecord,\n EnvInfoRecord,\n} from \"@unified-latex/unified-latex-types\";\nimport { argumentParser } from \"./libs/argument-parser\";\n\nexport const macros: MacroInfoRecord = {\n lstset: { signature: \"m\" },\n lstinline: { argumentParser: argumentParser },\n lstinputlisting: { signature: \"o m\" },\n lstdefinestyle: { signature: \"m m\" },\n lstnewenvironment: { signature: \"m o o m m\" },\n lstMakeShortInline: { signature: \"o m\" },\n lstDeleteShortInline: { signature: \"m\" },\n lstdefineformat: { signature: \"m m\" },\n lstdefinelanguage: { signature: \"o m o m o\" },\n lstalias: { signature: \"o m o m\" },\n lstloadlanguages: { signature: \"m\" },\n};\n\nexport const environments: EnvInfoRecord = {};\n", "import { MacroInfoRecord, EnvInfoRecord } from \"@unified-latex/unified-latex-types\";\n\nexport const macros: MacroInfoRecord = {\n see: { signature: \"m m\" },\n seealso: { signature: \"m m\" },\n seename: { signature: \"m\" },\n alsoname: { signature: \"m\" },\n index: { signature: \"m\" },\n};\n\nexport const environments: EnvInfoRecord = {};\n", "import { MacroInfoRecord, EnvInfoRecord } from \"@unified-latex/unified-latex-types\";\n\nexport const macros: MacroInfoRecord = {\n mathtoolsset: {\n signature: \"m\",\n renderInfo: { breakAround: true, pgfkeysArgs: true },\n },\n mathllap: {\n signature: \"o m\",\n },\n mathrlap: {\n signature: \"o m\",\n },\n mathclap: {\n signature: \"o m\",\n },\n clap: {\n signature: \"m\",\n },\n mathmbox: {\n signature: \"m\",\n },\n mathmakebox: {\n signature: \"o o m\",\n },\n cramped: {\n signature: \"o m\",\n },\n crampedllap: {\n signature: \"o m\",\n },\n crampedrlap: {\n signature: \"o m\",\n },\n crampedclap: {\n signature: \"o m\",\n },\n crampedsubstack: {\n signature: \"o m\",\n },\n smashoperator: {\n signature: \"o m\",\n },\n newtagform: {\n signature: \"m o m m\",\n },\n renewtagform: {\n signature: \"m o m m\",\n },\n usetagform: {\n signature: \"m\",\n },\n xleftrightarrow: { signature: \"o m\" },\n xLeftarrow: { signature: \"o m\" },\n xhookleftarrow: { signature: \"o m\" },\n xmapsto: { signature: \"o m\" },\n xRightarrow: { signature: \"o m\" },\n xLeftrightarrow: { signature: \"o m\" },\n xhookrightarrow: { signature: \"o m\" },\n underbracket: { signature: \"o o m\" },\n overbracket: { signature: \"o o m\" },\n underbrace: { signature: \"m\" },\n overbrace: { signature: \"m\" },\n shoveleft: { signature: \"o m\" },\n shoveright: { signature: \"o m\" },\n ArrowBetweenLines: { signature: \"s o\" },\n vdotswithin: { signature: \"m\" },\n shortdotswithin: { signature: \"s m\" },\n DeclarePairedDelimiter: {\n signature: \"m m m\",\n renderInfo: { breakAround: true },\n },\n DeclarePairedDelimiterX: {\n signature: \"m o m m m\",\n renderInfo: { breakAround: true },\n },\n DeclarePairedDelimiterXPP: {\n signature: \"m o m m m m m\",\n renderInfo: { breakAround: true },\n },\n prescript: { signature: \"m m m\" },\n DeclareMathSizes: { signature: \"m m m m\" },\n newgathered: { signature: \"m m m m\" },\n renewgathered: { signature: \"m m m m\" },\n splitfrac: { signature: \"m m\" },\n splitdfrac: { signature: \"m m\" },\n xmathstrut: { signature: \"o m\" },\n // amsthm\n newtheorem: { signature: \"s m o m o\", renderInfo: { breakAround: true } },\n theoremstyle: { signature: \"m\", renderInfo: { breakAround: true } },\n newtheoremstyle: {\n signature: \"m m m m m m m m m\",\n renderInfo: { breakAround: true },\n },\n // amsmath\n text: { signature: \"m\", renderInfo: { inMathMode: false } },\n // amsfonts\n mathbb: { signature: \"m\" },\n mathscr: { signature: \"m\" },\n mathfrak: { signature: \"m\" },\n frak: { signature: \"m\" },\n Bdd: { signature: \"m\" },\n bold: { signature: \"m\" },\n // amsopn\n operatorname: { signature: \"s m\" },\n DeclareMathOperator: {\n signature: \"s m m\",\n renderInfo: { breakAround: true },\n },\n};\n\nexport const environments: EnvInfoRecord = {\n crampedsubarray: {\n signature: \"m\",\n renderInfo: { alignContent: true, inMathMode: true },\n },\n matrix: { renderInfo: { alignContent: true, inMathMode: true } },\n bmatrix: { renderInfo: { alignContent: true, inMathMode: true } },\n pmatrix: { renderInfo: { alignContent: true, inMathMode: true } },\n vmatrix: { renderInfo: { alignContent: true, inMathMode: true } },\n Bmatrix: { renderInfo: { alignContent: true, inMathMode: true } },\n Vmatrix: { renderInfo: { alignContent: true, inMathMode: true } },\n smallmatrix: { renderInfo: { alignContent: true, inMathMode: true } },\n psmallmatrix: { renderInfo: { alignContent: true, inMathMode: true } },\n vsmallmatrix: { renderInfo: { alignContent: true, inMathMode: true } },\n bsmallmatrix: { renderInfo: { alignContent: true, inMathMode: true } },\n Bsmallmatrix: { renderInfo: { alignContent: true, inMathMode: true } },\n Vsmallmatrix: { renderInfo: { alignContent: true, inMathMode: true } },\n \"matrix*\": {\n signature: \"o\",\n renderInfo: { alignContent: true, inMathMode: true },\n },\n \"bmatrix*\": {\n signature: \"o\",\n renderInfo: { alignContent: true, inMathMode: true },\n },\n \"pmatrix*\": {\n signature: \"o\",\n renderInfo: { alignContent: true, inMathMode: true },\n },\n \"vmatrix*\": {\n signature: \"o\",\n renderInfo: { alignContent: true, inMathMode: true },\n },\n \"Bmatrix*\": {\n signature: \"o\",\n renderInfo: { alignContent: true, inMathMode: true },\n },\n \"Vmatrix*\": {\n signature: \"o\",\n renderInfo: { alignContent: true, inMathMode: true },\n },\n \"smallmatrix*\": {\n signature: \"o\",\n renderInfo: { alignContent: true, inMathMode: true },\n },\n \"psmallmatrix*\": {\n signature: \"o\",\n renderInfo: { alignContent: true, inMathMode: true },\n },\n \"bsmallmatrix*\": {\n signature: \"o\",\n renderInfo: { alignContent: true, inMathMode: true },\n },\n \"vsmallmatrix*\": {\n signature: \"o\",\n renderInfo: { alignContent: true, inMathMode: true },\n },\n \"Bsmallmatrix*\": {\n signature: \"o\",\n renderInfo: { alignContent: true, inMathMode: true },\n },\n \"Vsmallmatrix*\": {\n signature: \"o\",\n renderInfo: { alignContent: true, inMathMode: true },\n },\n multilined: { signature: \"o o\", renderInfo: { inMathMode: true } },\n cases: { renderInfo: { alignContent: true, inMathMode: true } },\n \"cases*\": { renderInfo: { alignContent: true, inMathMode: true } },\n dcases: { renderInfo: { alignContent: true, inMathMode: true } },\n \"dcases*\": { renderInfo: { alignContent: true, inMathMode: true } },\n rcases: { renderInfo: { alignContent: true, inMathMode: true } },\n \"rcases*\": { renderInfo: { alignContent: true, inMathMode: true } },\n drcases: { renderInfo: { alignContent: true, inMathMode: true } },\n \"drcases*\": { renderInfo: { alignContent: true, inMathMode: true } },\n spreadlines: { signature: \"m\", renderInfo: { inMathMode: true } },\n lgathered: { signature: \"o\", renderInfo: { inMathMode: true } },\n rgathered: { signature: \"o\", renderInfo: { inMathMode: true } },\n // amsmath\n \"align*\": { renderInfo: { inMathMode: true, alignContent: true } },\n align: { renderInfo: { inMathMode: true, alignContent: true } },\n aligned: { renderInfo: { inMathMode: true, alignContent: true } },\n \"alignat*\": { renderInfo: { inMathMode: true, alignContent: true } },\n alignat: { renderInfo: { inMathMode: true, alignContent: true } },\n \"equation*\": { renderInfo: { inMathMode: true } },\n equation: { renderInfo: { inMathMode: true } },\n \"gather*\": { renderInfo: { inMathMode: true } },\n gather: { renderInfo: { inMathMode: true } },\n \"multline*\": { renderInfo: { inMathMode: true } },\n multline: { renderInfo: { inMathMode: true } },\n \"flalign*\": { renderInfo: { inMathMode: true, alignContent: true } },\n flalign: { renderInfo: { inMathMode: true, alignContent: true } },\n split: { renderInfo: { inMathMode: true } },\n // Math environments\n displaymath: { renderInfo: { inMathMode: true } },\n // Typical amsthm environments\n theorem: { signature: \"o\" },\n lemma: { signature: \"o\" },\n definition: { signature: \"o\" },\n proposition: { signature: \"o\" },\n corollary: { signature: \"o\" },\n remark: { signature: \"!o\" },\n example: { signature: \"!o\" },\n proof: { signature: \"o\" },\n};\n", "import { arg } from \"@unified-latex/unified-latex-builder\";\nimport { Argument, ArgumentParser } from \"@unified-latex/unified-latex-types\";\nimport { parse as parseArgspec } from \"@unified-latex/unified-latex-util-argspec\";\nimport { Node } from \"@unified-latex/unified-latex-util-argspec/libs/argspec-types\";\nimport { gobbleSingleArgument } from \"@unified-latex/unified-latex-util-arguments\";\nimport { match } from \"@unified-latex/unified-latex-util-match\";\n\nconst argSpecM = parseArgspec(\"m\")[0];\nconst argSpecO = parseArgspec(\"o\")[0];\nconst argSpecRDelim: { [delim: string]: Node } = {};\n\n/**\n * This argument parser parses arguments in the form of\n * - [\u27E8options\u27E9]{\u27E8language\u27E9}\u27E8delim\u27E9\u27E8code\u27E9\u27E8delim\u27E9\n * - [\u27E8options\u27E9]{\u27E8language\u27E9}{\u27E8code\u27E9}\n */\nexport const argumentParser: ArgumentParser = (nodes, startPos) => {\n const { argument: optionalArg, nodesRemoved: optionalArgNodesRemoved } =\n gobbleSingleArgument(nodes, argSpecO, startPos);\n\n const { argument: languageArg, nodesRemoved: languageArgNodesRemoved } =\n gobbleSingleArgument(nodes, argSpecM, startPos);\n\n let codeArg: Argument | null = null;\n let codeArgNodesRemoved: number = 0;\n const nextNode = nodes[startPos];\n if (match.group(nextNode)) {\n const mandatoryArg = gobbleSingleArgument(nodes, argSpecM, startPos);\n codeArg = mandatoryArg.argument;\n codeArgNodesRemoved = mandatoryArg.nodesRemoved;\n } else if (match.string(nextNode) && nextNode.content.length === 1) {\n const delim = nextNode.content;\n argSpecRDelim[delim] =\n argSpecRDelim[delim] || parseArgspec(`r${delim}${delim}`)[0];\n const delimArg = gobbleSingleArgument(\n nodes,\n argSpecRDelim[delim],\n startPos\n );\n codeArg = delimArg.argument;\n codeArgNodesRemoved = delimArg.nodesRemoved;\n }\n\n return {\n args: [\n optionalArg || arg(null),\n languageArg || arg(null),\n codeArg || arg(null),\n ],\n nodesRemoved:\n optionalArgNodesRemoved +\n languageArgNodesRemoved +\n codeArgNodesRemoved,\n };\n};\n", "import {\n MacroInfoRecord,\n EnvInfoRecord,\n} from \"@unified-latex/unified-latex-types\";\nimport { argumentParser } from \"./libs/argument-parser\";\n\nexport const macros: MacroInfoRecord = {\n mint: { argumentParser: argumentParser },\n mintinline: { argumentParser: argumentParser },\n inputminted: { argumentParser: argumentParser },\n usemintedstyle: { signature: \"m\" },\n setminted: { signature: \"o m\" },\n setmintedinline: { signature: \"o m\" },\n newmint: { signature: \"o m m\" },\n newminted: { signature: \"o m m\" },\n newmintinline: { signature: \"o m m\" },\n newmintedfile: { signature: \"o m m\" },\n};\n\nexport const environments: EnvInfoRecord = {};\n", "import { MacroInfoRecord, EnvInfoRecord } from \"@unified-latex/unified-latex-types\";\n\nexport const macros: MacroInfoRecord = {\n NiceMatrixOptions: {\n signature: \"m\",\n renderInfo: { pgfkeysArgs: true, breakAround: true },\n },\n};\n\nexport const environments: EnvInfoRecord = {\n NiceTabular: {\n signature: \"o m !o\",\n renderInfo: { pgfkeysArgs: true, alignContent: true },\n },\n NiceMatrixBlock: {\n signature: \"!o\",\n renderInfo: { pgfkeysArgs: true, alignContent: true },\n },\n NiceArrayWithDelims: {\n signature: \"m m o m !o\",\n renderInfo: { pgfkeysArgs: true, alignContent: true },\n },\n NiceArray: {\n signature: \"o m !o\",\n renderInfo: { pgfkeysArgs: true, alignContent: true },\n },\n pNiceArray: {\n signature: \"o m !o\",\n renderInfo: { pgfkeysArgs: true, alignContent: true },\n },\n bNiceArray: {\n signature: \"o m !o\",\n renderInfo: { pgfkeysArgs: true, alignContent: true },\n },\n BNiceArray: {\n signature: \"o m !o\",\n renderInfo: { pgfkeysArgs: true, alignContent: true },\n },\n vNiceArray: {\n signature: \"o m !o\",\n renderInfo: { pgfkeysArgs: true, alignContent: true },\n },\n VNiceArray: {\n signature: \"o m !o\",\n renderInfo: { pgfkeysArgs: true, alignContent: true },\n },\n NiceMatrix: {\n signature: \"!o\",\n renderInfo: { pgfkeysArgs: true, alignContent: true },\n },\n pNiceMatrix: {\n signature: \"!o\",\n renderInfo: { pgfkeysArgs: true, alignContent: true },\n },\n bNiceMatrix: {\n signature: \"!o\",\n renderInfo: { pgfkeysArgs: true, alignContent: true },\n },\n BNiceMatrix: {\n signature: \"!o\",\n renderInfo: { pgfkeysArgs: true, alignContent: true },\n },\n vNiceMatrix: {\n signature: \"!o\",\n renderInfo: { pgfkeysArgs: true, alignContent: true },\n },\n VNiceMatrix: {\n signature: \"!o\",\n renderInfo: { pgfkeysArgs: true, alignContent: true },\n },\n};\n", "import { MacroInfoRecord, EnvInfoRecord } from \"@unified-latex/unified-latex-types\";\n\nexport const macros: MacroInfoRecord = {\n systeme: {\n signature: \"s o o m\",\n renderInfo: { inMathMode: true },\n },\n sysdelim: {\n signature: \"m m\",\n },\n syseqsep: { signature: \"m\" },\n sysalign: { signature: \"m\" },\n syssignspace: { signature: \"m\" },\n syseqspace: { signature: \"m\" },\n syslineskipcoeff: { signature: \"m\" },\n syseqivsign: { signature: \"m\" },\n sysaddeqsign: { signature: \"m\" },\n sysremoveeqsign: { signature: \"m\" },\n sysextracolonsign: { signature: \"m\" },\n syscodeextracol: { signature: \"m\" },\n sysautonum: { signature: \"m\" },\n syssubstitute: { signature: \"m\" },\n};\n\nexport const environments: EnvInfoRecord = {};\n", "import * as Ast from \"@unified-latex/unified-latex-types\";\nimport * as SystemeSpec from \"./types\";\nimport { match } from \"@unified-latex/unified-latex-util-match\";\nimport { decorateArrayForPegjs } from \"@unified-latex/unified-latex-util-pegjs\";\nimport { SystemePegParser } from \"@unified-latex/unified-latex-util-pegjs\";\n\ntype SystemeMatchers = {\n at?: string;\n equals?: string;\n equationSeparator?: string;\n mathOperations?: string[];\n whitelistedVariables?: (string | Ast.String | Ast.Macro)[];\n};\n\nfunction createMatchers({\n at = \"@\",\n equals = \"=\",\n equationSeparator = \",\",\n mathOperations = [\"+\", \"-\"],\n whitelistedVariables,\n}: SystemeMatchers = {}) {\n let isVar: (node: Ast.Node) => boolean = (node: Ast.Node) =>\n match.anyString(node) && !!node.content.match(/[a-zA-Z]/);\n if (whitelistedVariables) {\n // Unwrap all strings\n whitelistedVariables = whitelistedVariables.map((v) =>\n match.anyString(v) ? v.content : v\n );\n const macros = whitelistedVariables.filter((v) =>\n match.anyMacro(v)\n ) as Ast.Macro[];\n const strings = whitelistedVariables.filter(\n (v) => typeof v === \"string\"\n ) as string[];\n const macroHash = Object.fromEntries(macros.map((v) => [v.content, v]));\n const stringHash = Object.fromEntries(strings.map((s) => [s, s]));\n const macroMatcher = match.createMacroMatcher(macroHash);\n isVar = (node: Ast.Node) =>\n macroMatcher(node) ||\n (match.anyString(node) && !!stringHash[node.content]);\n }\n return {\n isSep: (node: Ast.Node) => match.string(node, equationSeparator),\n isVar,\n isOperation: (node: Ast.Node) =>\n mathOperations.some((op) => match.string(node, op)),\n isEquals: (node: Ast.Node) => match.string(node, equals),\n isAt: (node: Ast.Node) => match.string(node, at),\n isSubscript: (node: Ast.Node) =>\n match.macro(node, \"_\") && node.escapeToken === \"\",\n isWhitespace: match.whitespace,\n isSameLineComment: (node: Ast.Node) =>\n match.comment(node) && node.sameline,\n isOwnLineComment: (node: Ast.Node) =>\n match.comment(node) && !node.sameline,\n };\n}\n\n/**\n * Parse the contents of the `\\systeme{...}` macro\n */\nexport function parse(\n ast: Ast.Node[],\n options?: SystemeMatchers\n): SystemeSpec.Line[] {\n if (!Array.isArray(ast)) {\n throw new Error(\"You must pass an array of nodes\");\n }\n // We need to at functions to `nodes` so that it imitates\n // a Javascript string. Because we're mutating, make a copy first\n ast = decorateArrayForPegjs([...ast]);\n // matchers are passed in via the second argument (the `options` argument)\n // so they are available from within the Pegjs grammar.\n return SystemePegParser.parse(\n ast,\n createMatchers(options || {})\n ) as SystemeSpec.Line[];\n}\n", "import { printRaw as latexPrintRaw } from \"@unified-latex/unified-latex-util-print-raw\";\nimport * as SystemeSpec from \"./types\";\n\n/**\n * Print an `systeme` argument specification AST to a string.\n */\nexport function printRaw(node: SystemeSpec.Ast, root = false): string {\n if (typeof node === \"string\") {\n return node;\n }\n\n if (Array.isArray(node)) {\n const sepToken = root ? \" \" : \"\";\n return node.map((tok) => printRaw(tok)).join(sepToken);\n }\n\n switch (node.type) {\n case \"annotation\":\n return `${latexPrintRaw(node.marker)}${latexPrintRaw(\n node.content\n )}`;\n case \"item\":\n return `${node.op ? latexPrintRaw(node.op) : \"\"}${latexPrintRaw(\n node.content\n )}`;\n case \"equation\":\n const left = node.left.map((n) => printRaw(n)).join(\"\");\n const right = latexPrintRaw(node.right);\n const equals = node.equals ? latexPrintRaw(node.equals) : \"\";\n return `${left}${equals}${right}`;\n case \"line\":\n const equation = node.equation ? printRaw(node.equation) : \"\";\n const annotation = node.annotation ? printRaw(node.annotation) : \"\";\n const sep = node.sep ? latexPrintRaw(node.sep) : \"\";\n\n const body = `${equation}${annotation}${sep}`;\n if (node.trailingComment) {\n return latexPrintRaw([body, node.trailingComment]);\n }\n\n return body;\n\n default:\n console.warn(\n `Unknown node type \"${(node as any).type}\" for node`,\n node\n );\n return \"\";\n }\n}\n", "import * as SystemeSpec from \"./types\";\nimport * as Ast from \"@unified-latex/unified-latex-types\";\nimport { printRaw } from \"@unified-latex/unified-latex-util-print-raw\";\nimport { match } from \"@unified-latex/unified-latex-util-match\";\nimport { arrayJoin } from \"@unified-latex/unified-latex-util-split\";\nimport { parse } from \"./parser\";\nimport { structuredClone } from \"@unified-latex/structured-clone\";\nimport { deleteComments } from \"@unified-latex/unified-latex-util-comments\";\nimport { visit } from \"@unified-latex/unified-latex-util-visit\";\nimport { updateRenderInfo } from \"@unified-latex/unified-latex-util-render-info\";\nimport { getArgsContent } from \"@unified-latex/unified-latex-util-arguments\";\n\nconst AMP: Ast.String = { type: \"string\", content: \"&\" };\nconst SEP: Ast.Macro = { type: \"macro\", content: \"\\\\\" };\nconst QUAD: Ast.Macro = { type: \"macro\", content: \"quad\" };\nconst PLUS: Ast.String = { type: \"string\", content: \"+\" };\nconst COLUMN_KERN_ADJUSTMENT: Ast.Node[] = [\n { type: \"string\", content: \"@\" },\n {\n type: \"group\",\n content: [\n { type: \"macro\", content: \"mkern\" },\n { type: \"string\", content: \"5mu\" },\n ],\n },\n];\n\n/**\n * Return a map giving the sorted index of each variable in `vars`. There\n * may be duplicated variables in `vars`. The map will send duplicates to the same index.\n *\n * @param {Ast.Node[][]} vars\n * @returns\n */\nfunction sortVariables(\n vars: Ast.Node[][],\n whitelistedVariables?: Ast.Node[] | null\n) {\n const varMap = new Map(vars.map((v) => [v, printRaw(v)]));\n const varNames = Array.from(new Set(varMap.values()));\n varNames.sort();\n const nameToPos = whitelistedVariables\n ? new Map(whitelistedVariables.map((v, i) => [printRaw(v), i]))\n : new Map(varNames.map((name, i) => [name, i]));\n\n return new Map(\n Array.from(varMap.entries()).map(([variable, name]) => {\n return [variable, nameToPos.get(name) ?? -1];\n })\n );\n}\n\n/**\n * Make an array of arrays representing the operation/content of each item in an equation\n * + the annotation. The return value is suitable to be joined with `&` for the body of an array.\n */\nfunction processLine(\n line: SystemeSpec.Line,\n numVars: number,\n varOrder: Map,\n hasEquals: boolean,\n hasAnnotation: boolean\n) {\n const ret: Ast.Node[][] = [];\n if (line.equation) {\n // We need to combine all non-var items into a single expression\n const nonVarItems = line.equation.left.filter(\n (item) => item.variable == null\n );\n const varItems = line.equation.left.filter(\n (item) => item.variable != null\n );\n let nonVarTerm: SystemeSpec.Item | null = null;\n if (nonVarItems.length === 1) {\n nonVarTerm = nonVarItems[0];\n } else if (nonVarItems.length > 1) {\n // We need to combine all the items. We do so by constructing a new item with the rest of the item's contents\n // added on the back\n nonVarTerm = {\n ...nonVarItems[0],\n content: nonVarItems[0].content.concat(\n nonVarItems.slice(1).flatMap((item) => {\n if (item.op) {\n return [item.op, ...item.content];\n }\n return [PLUS, ...item.content];\n })\n ),\n };\n }\n\n const allItems = nonVarTerm ? varItems.concat(nonVarTerm) : varItems;\n\n const indexToItem = new Map(\n allItems.map((item) => {\n if (item.variable == null) {\n return [numVars - 1, item];\n }\n return [varOrder.get(item.variable), item];\n })\n );\n\n let isFirstItem = true;\n for (let i = 0; i < numVars; i++) {\n const item = indexToItem.get(i);\n if (item) {\n if (\n isFirstItem &&\n (match.string(item.op, \"+\") || item.op == null)\n ) {\n // If the first item starts with a plus or doesn't have a starting operation,\n // we don't use a starting symbol.\n ret.push([]);\n ret.push(item.content);\n } else {\n // If we are not the first item, we always push an operation\n ret.push([item.op || PLUS]);\n ret.push(item.content);\n }\n isFirstItem = false;\n } else {\n // If there is no item for this position, we push a blank operation and content\n ret.push([]);\n ret.push([]);\n }\n }\n // If we have an equals, we need to push its contents\n if (hasEquals) {\n const equalsPart = (\n line.equation.equals ? [line.equation.equals] : []\n ).concat(line.equation.right);\n ret.push(equalsPart);\n }\n }\n // If we have an annotation, we need to push it or a blank\n if (hasAnnotation) {\n ret.push(line.annotation ? line.annotation.content : []);\n }\n\n return ret;\n}\n\n/**\n * Add kerning information to the array specification. E.g. `crl` becomes `c@{\\mkern5mu}r@{\\mkern5mu}l`.\n * This is so the operations when typesetting a system of equations are properly spaced.\n */\nfunction arraySpecToSpacedArraySpec(spec: string, hasAnnotation?: boolean) {\n const annotationSpec = hasAnnotation ? spec.charAt(spec.length - 1) : \"\";\n const bodySpec = hasAnnotation ? spec.slice(0, spec.length - 1) : spec;\n\n const bodyStrings: Ast.Node[][] = Array.from(bodySpec).map((x) => [\n { type: \"string\", content: x },\n ]);\n const body = arrayJoin(bodyStrings, COLUMN_KERN_ADJUSTMENT);\n return annotationSpec\n ? body.concat({ type: \"string\", content: annotationSpec })\n : body;\n}\n\n/**\n * Extract the variables from a systeme system of equations.\n */\nexport function extractVariables(nodes: SystemeSpec.Node[]): Ast.Node[][] {\n return nodes.flatMap((node) => {\n if (node.type === \"line\" && node.equation) {\n return extractVariables(node.equation.left);\n }\n if (node.type === \"equation\") {\n return node.left.flatMap((item) =>\n item.variable ? [item.variable] : []\n );\n }\n if (node.type === \"item\") {\n return node.variable ? [node.variable] : [];\n }\n return [];\n });\n}\n\n/**\n * Remove any whitespace from the variable list (including an explicit \" \" string).\n * As well, filter out any non-macro/non-string items.\n */\nfunction normalizeVariableWhitelist(\n vars: (string | Ast.Node)[] | null | undefined\n) {\n if (!vars) {\n return null;\n }\n const normalized: Ast.Node[] = vars.map((v) =>\n typeof v === \"string\" ? { type: \"string\", content: v } : v\n );\n const ret = normalized.filter(\n (v) =>\n (match.anyMacro(v) || match.anyString(v)) &&\n !match.string(v, \" \") &&\n !match.whitespace(v)\n ) as (Ast.Macro | Ast.String)[];\n return ret;\n}\n\n/**\n * Lays out the contents of a \\systeme{...} macro as an array. This function sorts the variables\n * in alphabetical order and lays out any annotations. An `\\begin{array}...\\end{array}` environment\n * is returned.\n *\n * If `properSpacing=true` then kerning information will be included in the array specification to space\n * the operators correctly. This kerning information will make the specification long (and may make it incompatible\n * with KaTeX).\n *\n * An optional whitelist of variables may be supplied. If supplied, only listed items will count as variables and\n * the order of variable appearance will be the same as the order of the whitelisted variables.\n */\nexport function systemeContentsToArray(\n nodes: Ast.Node[],\n options?: {\n properSpacing?: boolean;\n whitelistedVariables?: (string | Ast.String | Ast.Macro)[];\n }\n) {\n nodes = structuredClone(nodes);\n deleteComments(nodes);\n const { properSpacing = true, whitelistedVariables } = options || {};\n const coercedWhitelistedVariables =\n normalizeVariableWhitelist(whitelistedVariables);\n const systemeAst = parse(nodes, { whitelistedVariables });\n const vars = extractVariables(systemeAst);\n const varOrder = sortVariables(vars, coercedWhitelistedVariables);\n let numVars = coercedWhitelistedVariables\n ? coercedWhitelistedVariables.length\n : Math.max(...Array.from(varOrder.values())) + 1;\n // If there are terms with no variable, we need a spot for them\n if (\n systemeAst.some((line) => {\n if (line.equation) {\n return line.equation.left.some((item) => item.variable == null);\n }\n })\n ) {\n numVars += 1;\n }\n const hasEquals = systemeAst.some(\n (line) => line.equation && line.equation.equals\n );\n const hasAnnotation = systemeAst.some((line) => line.annotation);\n\n let rows = systemeAst.map((line) =>\n processLine(line, numVars, varOrder, hasEquals, hasAnnotation)\n );\n // If we have no leading `-` signs (e.g., only leading `+` or bank signs)\n // We don't need space for the first operation to be stored\n const noLeadingOperation = rows.every((row) => row[0].length === 0);\n\n // Every item in an equation has a centered operation and a right-aligned variable part.\n let arraySignature = Array.from({ length: numVars }, () => \"cr\").join(\"\");\n if (noLeadingOperation) {\n // We might not have a leading operation on the first item(s)\n arraySignature = arraySignature.slice(1);\n rows = rows.map((row) => row.slice(1));\n }\n if (hasEquals) {\n // The part after the equals is left-aligned\n arraySignature += \"l\";\n }\n if (hasAnnotation) {\n // The annotation is left-aligned\n arraySignature += \"l\";\n // We also manually insert space in front of any annotation\n rows = rows.map((row) => {\n if (row[row.length - 1].length === 0) {\n return row;\n }\n return [\n ...row.slice(0, row.length - 1),\n [QUAD, { type: \"whitespace\" }, ...row[row.length - 1]],\n ];\n });\n }\n\n // By default, the array signature will put lots of space between items.\n // We can correct for that manually.\n const arraySignatureWithSpacing: Ast.Node[] = properSpacing\n ? arraySpecToSpacedArraySpec(arraySignature, hasAnnotation)\n : [{ type: \"string\", content: arraySignature }];\n\n const bodyRows = rows.map((row) => arrayJoin(row, AMP));\n const body = arrayJoin(bodyRows, SEP);\n\n const ret: Ast.Environment = {\n type: \"environment\",\n env: \"array\",\n args: [\n {\n type: \"argument\",\n openMark: \"{\",\n closeMark: \"}\",\n content: arraySignatureWithSpacing,\n },\n ],\n content: body,\n };\n\n return ret;\n}\n\n/**\n * Find any systeme definitions, e.g. `\\sysdelim{.}{.}`, and attach their information\n * to the renderInfo of of the systeme macros.\n *\n */\nexport function attachSystemeSettingsAsRenderInfo(ast: Ast.Ast) {\n const systemeMatcher = match.createMacroMatcher([\"systeme\", \"sysdelim\"]);\n\n visit(\n ast,\n (nodes, info) => {\n if (!info.context.inMathMode || !nodes.some(systemeMatcher)) {\n return;\n }\n // Find the positions of the systeme and sysdelim macros\n const systemeLocations = nodes.flatMap((node, i) =>\n match.macro(node, \"systeme\") ? i : []\n );\n const sysdelimLocations = nodes.flatMap((node, i) =>\n match.macro(node, \"sysdelim\") ? i : []\n );\n\n if (\n systemeLocations.length === 0 ||\n sysdelimLocations.length === 0\n ) {\n return;\n }\n\n for (const i of systemeLocations) {\n // Find any sysdelim macros that occur before\n const lastSysdelim = Math.max(\n ...sysdelimLocations.filter((loc) => loc < i)\n );\n if (lastSysdelim >= 0) {\n const node = nodes[i];\n const sysdelimMacro = nodes[lastSysdelim];\n if (!match.anyMacro(sysdelimMacro)) {\n throw new Error(\n `Expecting sysdelim macro but found \"${printRaw(\n sysdelimMacro\n )}\"`\n );\n }\n const args = getArgsContent(sysdelimMacro);\n updateRenderInfo(node, { sysdelims: args });\n }\n }\n },\n {\n test: Array.isArray,\n includeArrays: true,\n }\n );\n}\n", "// @ts-nocheck\n\n// globalThis polyfill from https://mathiasbynens.be/notes/globalthis\n(function () {\n if (typeof globalThis === \"object\") return;\n Object.defineProperty(Object.prototype, \"__magic__\", {\n get: function () {\n return this;\n },\n configurable: true, // This makes it possible to `delete` the getter later.\n });\n __magic__.globalThis = __magic__; // lolwat\n delete Object.prototype.__magic__;\n})();\n\nconst clone =\n typeof globalThis.structuredClone === \"function\"\n ? globalThis.structuredClone\n : (obj: any) => JSON.parse(JSON.stringify(obj));\n\n/**\n * Wrapper around the built-in structured clone. Uses `JSON.parse(JSON.stringify(...))`\n * as a fallback.\n */\nexport function structuredClone(obj: T): T {\n return clone(obj);\n}\n", "import {\n MacroInfoRecord,\n EnvInfoRecord,\n} from \"@unified-latex/unified-latex-types\";\nimport * as Ast from \"@unified-latex/unified-latex-types\";\nimport { attachMacroArgsInArray } from \"@unified-latex/unified-latex-util-arguments\";\nimport { tikzCommandArgumentParser } from \"./libs/tikz-command-argument-parser\";\n\nexport const macros: MacroInfoRecord = {\n pgfkeys: {\n signature: \"m\",\n renderInfo: { breakAround: true, pgfkeysArgs: true },\n },\n tikzoption: {\n signature: \"m\",\n renderInfo: { breakAround: true, pgfkeysArgs: true },\n },\n tikzstyle: {\n signature: \"m\",\n renderInfo: { breakAround: true, pgfkeysArgs: true },\n },\n usetikzlibrary: {\n signature: \"m\",\n renderInfo: { breakAround: true, pgfkeysArgs: true },\n },\n usepgfmodule: { signature: \"m\", renderInfo: { pgfkeysArgs: true } },\n usepgflibrary: { signature: \"m\", renderInfo: { pgfkeysArgs: true } },\n pgfplotsset: {\n signature: \"m\",\n renderInfo: { breakAround: true, pgfkeysArgs: true },\n },\n pgfplotstabletypeset: {\n signature: \"o m\",\n renderInfo: { breakAround: true, pgfkeysArgs: true },\n },\n tikz: {\n signature: \"o o m\",\n argumentParser: tikzCommandArgumentParser,\n renderInfo: { namedArguments: [\"animation\", \"options\", \"command\"] },\n },\n};\n\nexport const environments: EnvInfoRecord = {\n tikzpicture: {\n signature: \"o\",\n renderInfo: { pgfkeysArgs: true, tikzEnvironment: true },\n processContent: processTikzEnvironmentContent,\n },\n axis: {\n signature: \"o\",\n renderInfo: { pgfkeysArgs: true, tikzEnvironment: true },\n processContent: processTikzEnvironmentContent,\n },\n scope: {\n signature: \"o\",\n renderInfo: { pgfkeysArgs: true, tikzEnvironment: true },\n processContent: processTikzEnvironmentContent,\n },\n pgfonlayer: {\n signature: \"m\",\n renderInfo: { tikzEnvironment: true },\n processContent: processTikzEnvironmentContent,\n },\n pgflowlevelscope: {\n signature: \"m\",\n renderInfo: { tikzEnvironment: true },\n processContent: processTikzEnvironmentContent,\n },\n pgfviewboxscope: {\n signature: \"m m m m m\",\n renderInfo: { tikzEnvironment: true },\n processContent: processTikzEnvironmentContent,\n },\n pgftransparencygroup: {\n signature: \"o\",\n renderInfo: { pgfkeysArgs: true, tikzEnvironment: true },\n processContent: processTikzEnvironmentContent,\n },\n behindforegroundpath: {\n signature: \"m\",\n processContent: processTikzEnvironmentContent,\n },\n pgfmetadecoration: {\n signature: \"m\",\n processContent: processTikzEnvironmentContent,\n },\n colormixin: { signature: \"m\", renderInfo: { pgfkeysArgs: true } },\n};\n\n/**\n * Attach macro arguments for all macros that are only available within a tikz environment.\n */\nfunction processTikzEnvironmentContent(nodes: Ast.Node[]): Ast.Node[] {\n attachMacroArgsInArray(nodes, conditionalMacros);\n return nodes;\n}\n\n/**\n * Macros that are only parsed inside a tikz environment.\n */\nexport const conditionalMacros: MacroInfoRecord = {\n pgfextra: { signature: \"m\" },\n beginpgfgraphicnamed: { signature: \"m\" },\n pgfrealjobname: { signature: \"m\" },\n pgfplotstreampoint: { signature: \"m\" },\n pgfplotstreampointoutlier: { signature: \"m\" },\n pgfplotstreamspecial: { signature: \"m\" },\n pgfplotxyfile: { signature: \"m\" },\n pgfplotxyzfile: { signature: \"m\" },\n pgfplotfunction: { signature: \"mmm\" },\n pgfplotgnuplot: { signature: \"o m\" },\n pgfplothandlerrecord: { signature: \"m\" },\n pgfdeclareplothandler: { signature: \"m m m\" },\n pgfdeclarelayer: { signature: \"m\" },\n pgfsetlayers: { signature: \"m\", renderInfo: { pgfkeysArgs: true } },\n pgfonlayer: { signature: \"m\" },\n startpgfonlayer: { signature: \"m\" },\n pgfdeclarehorizontalshading: { signature: \"o m m m \" },\n pgfdeclareradialshading: { signature: \"o m m m\" },\n pgfdeclarefunctionalshading: { signature: \"o m m m m m\" },\n pgfshadecolortorgb: { signature: \"m m\" },\n pgfshadecolortocmyk: { signature: \"m m\" },\n pgfshadecolortogray: { signature: \"m m\" },\n pgfuseshading: { signature: \"m\" },\n pgfshadepath: { signature: \"m m\" },\n pgfsetadditionalshadetransform: { signature: \"m\" },\n pgfsetstrokeopacity: { signature: \"m\" },\n pgfsetfillopacity: { signature: \"m\" },\n pgfsetblendmode: { signature: \"m\" },\n pgfdeclarefading: { signature: \"m m\" },\n pgfsetfading: { signature: \"m m\" },\n pgfsetfadingforcurrentpath: { signature: \"m m\" },\n pgfsetfadingforcurrentpathstroked: { signature: \"m m\" },\n pgfanimateattribute: { signature: \"m m\" },\n pgfsnapshot: { signature: \"m\" },\n pgfqpoint: { signature: \"m m\" },\n pgfqpointxy: { signature: \"m m\" },\n pgfqpointxyz: { signature: \"m m m\" },\n pgfqpointscale: { signature: \"m m\" },\n pgfpathqmoveto: { signature: \"m m\" },\n pgfpathqlineto: { signature: \"m m\" },\n pgfpathqcurveto: { signature: \"m m m m m m\" },\n pgfpathqcircle: { signature: \"m\" },\n pgfqbox: { signature: \"m\" },\n pgfqboxsynced: { signature: \"m\" },\n pgfaliasimage: { signature: \"m m\" },\n pgfuseimage: { signature: \"m\" },\n pgfimage: { signature: \"o m\", renderInfo: { pgfkeysArgs: true } },\n pgfdeclaremask: { signature: \"o m m\", renderInfo: { pgfkeysArgs: true } },\n pgfdeclarepatternformonly: { signature: \"o m m m m m\" },\n pgfdeclarepatterninherentlycolored: { signature: \"o m m m m m\" },\n pgfsetfillpattern: { signature: \"m m\" },\n // Coordinate canvas and nonlinear transformations\n pgftransformshift: { signature: \"m\" },\n pgftransformxshift: { signature: \"m\" },\n pgftransformyshift: { signature: \"m\" },\n pgftransformscale: { signature: \"m\" },\n pgftransformxscale: { signature: \"m\" },\n pgftransformyscale: { signature: \"m\" },\n pgftransformxslant: { signature: \"m\" },\n pgftransformyslant: { signature: \"m\" },\n pgftransformrotate: { signature: \"m\" },\n pgftransformtriangle: { signature: \"m m m\" },\n pgftransformcm: { signature: \"m m m m m\" },\n pgftransformarrow: { signature: \"m m\" },\n pgftransformlineattime: { signature: \"m m m\" },\n pgftransformcurveattime: { signature: \"m m m m m\" },\n pgftransformarcaxesattime: { signature: \"m m m m m m\" },\n pgfgettransform: { signature: \"m\" },\n pgfsettransform: { signature: \"m\" },\n pgfgettransformentries: { signature: \"m m m m m m\" },\n pgfsettransformentries: { signature: \"m m m m m m\" },\n pgfpointtransformed: { signature: \"m\" },\n pgflowlevel: { signature: \"m\" },\n pgflowlevelobj: { signature: \"m m\" },\n pgflowlevelscope: { signature: \"m\" },\n startpgflowlevelscope: { signature: \"m\" },\n pgfviewboxscope: { signature: \"m m m m m\" },\n startpgfviewboxscope: { signature: \"m m m m m\" },\n pgftransformnonlinear: { signature: \"m\" },\n pgfpointtransformednonlinear: { signature: \"m\" },\n pgfsetcurvilinearbeziercurve: { signature: \"m m m m\" },\n pgfcurvilineardistancetotime: { signature: \"m\" },\n pgfpointcurvilinearbezierorthogonal: { signature: \"m m\" },\n pgfpointcurvilinearbezierpolar: { signature: \"m m\" },\n // Matrices\n pgfmatrix: { signature: \"m m m m m m m\" },\n pgfsetmatrixcolumnsep: { signature: \"m\" },\n pgfmatrixnextcell: { signature: \"o\" },\n pgfsetmatrixrowsep: { signature: \"m\" },\n pgfmatrixendrow: { signature: \"o\" },\n // Nodes and shapes\n pgfnode: { signature: \"m m m m m\" },\n pgfmultipartnode: { signature: \"m m m m\" },\n pgfcoordinate: { signature: \"m m\" },\n pgfnodealias: { signature: \"m m\" },\n pgfnoderename: { signature: \"m m\" },\n pgfpositionnodelater: { signature: \"m\" },\n pgfpositionnodenow: { signature: \"m\" },\n pgfnodepostsetupcode: { signature: \"m m\" },\n pgfpointanchor: { signature: \"m m\" },\n pgfpointshapeborder: { signature: \"m m\" },\n pgfdeclareshape: { signature: \"m m\" },\n saveddimen: { signature: \"m m\" },\n savedmacro: { signature: \" m\" },\n anchor: { signature: \"m m\" },\n deferredanchor: { signature: \"m m\" },\n anchorborder: { signature: \"m\" },\n backgroundpath: { signature: \"m\" },\n foregroundpath: { signature: \"m\" },\n behindbackgroundpath: { signature: \"m\" },\n beforebackgroundpath: { signature: \"m\" },\n beforeforegroundpath: { signature: \"m\" },\n behindforegroundpath: { signature: \"m\" },\n // Arrows\n pgfdeclarearrow: { signature: \"m\" },\n pgfarrowssettipend: { signature: \"m\" },\n pgfarrowssetbackend: { signature: \"m\" },\n pgfarrowssetlineend: { signature: \"m\" },\n pgfarrowssetvisualbackend: { signature: \"m\" },\n pgfarrowssetvisualtipend: { signature: \"m\" },\n pgfarrowshullpoint: { signature: \"m m\" },\n pgfarrowsupperhullpoint: { signature: \"m m\" },\n pgfarrowssave: { signature: \"m\" },\n pgfarrowssavethe: { signature: \"m\" },\n pgfarrowsaddtooptions: { signature: \"m\" },\n pgfarrowsaddtolateoptions: { signature: \"m\" },\n pgfarrowsaddtolengthscalelist: { signature: \"m\" },\n pgfarrowsaddtowidthscalelist: { signature: \"m\" },\n pgfarrowsthreeparameters: { signature: \"m\" },\n pgfarrowslinewidthdependent: { signature: \"m m m\" },\n pgfarrowslengthdependent: { signature: \"m\" },\n // Path\n pgfusepath: { signature: \"m\" },\n pgfsetlinewidth: { signature: \"m\" },\n pgfsetmiterlimit: { signature: \"m\" },\n pgfsetdash: { signature: \"m m\" },\n pgfsetstrokecolor: { signature: \"m\" },\n pgfsetcolor: { signature: \"m\" },\n pgfsetinnerlinewidth: { signature: \"m\" },\n pgfsetinnerstrokecolor: { signature: \"m\" },\n pgfsetarrowsstart: { signature: \"m\" },\n pgfsetarrowsend: { signature: \"m\" },\n pgfsetarrows: { signature: \"m\" },\n pgfsetshortenstart: { signature: \"m\" },\n pgfsetshortenend: { signature: \"m\" },\n pgfsetfillcolor: { signature: \"m\" },\n // Decorations\n pgfdeclaredecoration: { signature: \"m m m\" },\n state: { signature: \"m o m\" },\n pgfdecoratepath: { signature: \"m m\" },\n startpgfdecoration: { signature: \"m\" },\n pgfdecoration: { signature: \"m\" },\n pgfdecoratecurrentpath: { signature: \"m\" },\n pgfsetdecorationsegmenttransformation: { signature: \"m\" },\n pgfdeclaremetadecorate: { signature: \"m m m\" },\n pgfmetadecoration: { signature: \"m\" },\n startpgfmetadecoration: { signature: \"m\" },\n // Constructing paths\n pgfpathmoveto: { signature: \"m\" },\n pgfpathlineto: { signature: \"m\" },\n pgfpathcurveto: { signature: \"m m m\" },\n pgfpathquadraticcurveto: { signature: \"m m\" },\n pgfpathcurvebetweentime: { signature: \"m m m m m m\" },\n pgfpathcurvebetweentimecontinue: { signature: \"m m m m m m\" },\n pgfpatharc: { signature: \"m m m\" },\n pgfpatharcaxes: { signature: \"m m m m\" },\n pgfpatharcto: { signature: \"m m m m m m\" },\n pgfpatharctoprecomputed: { signature: \"m m m m m m m m\" },\n pgfpathellipse: { signature: \"m m m\" },\n pgfpathcircle: { signature: \"m m\" },\n pgfpathrectangle: { signature: \"m m\" },\n pgfpathrectanglecorners: { signature: \"m m\" },\n pgfpathgrid: { signature: \" o m m\" },\n pgfpathparabola: { signature: \"m m\" },\n pgfpathsine: { signature: \"m\" },\n pgfpathcosine: { signature: \"m\" },\n pgfsetcornersarced: { signature: \"m\" },\n \"pgf@protocolsizes\": { signature: \"m m\" },\n // Specifying coordinates\n pgfpoint: { signature: \"m m\" },\n pgfpointpolar: { signature: \"m m m\" },\n pgfpointxy: { signature: \"m m\" },\n pgfsetxvec: { signature: \"m\" },\n pgfsetyvec: { signature: \"m\" },\n pgfpointpolarxy: { signature: \"m m\" },\n pgfpointxyz: { signature: \"m m m\" },\n pgfsetzvec: { signature: \"m\" },\n pgfpointcylindrical: { signature: \"m m m\" },\n pgfpointspherical: { signature: \"m m m\" },\n pgfpointadd: { signature: \"m m\" },\n pgfpointscale: { signature: \"m m\" },\n pgfpointdiff: { signature: \"m m\" },\n pgfpointnormalised: { signature: \"m\" },\n pgfpointlineattime: { signature: \"m m m\" },\n pgfpointlineatdistance: { signature: \"m m m\" },\n pgfpointarcaxesattime: { signature: \"m m m m m m\" },\n pgfpointcurveattime: { signature: \"m m m m m\" },\n pgfpointborderrectangle: { signature: \"m m\" },\n pgfpointborderellipse: { signature: \"m m\" },\n pgfpointintersectionoflines: { signature: \"m m m m\" },\n pgfpointintersectionofcircles: { signature: \"m m m m m\" },\n pgfintersectionofpaths: { signature: \"m m\" },\n pgfpointintersectionsolution: { signature: \"m\" },\n pgfextractx: { signature: \"m m\" },\n pgfextracty: { signature: \"m m\" },\n pgfgetlastxy: { signature: \"m m\" },\n \"pgf@process\": { signature: \"m\" },\n // Heirarchical structres ...\n pgfsetbaseline: { signature: \"m\" },\n pgfsetbaselinepointnow: { signature: \"m\" },\n pgfsetbaselinepointlater: { signature: \"m\" },\n pgftext: { signature: \"o m\", renderInfo: { pgfkeysArgs: true } },\n pgfuseid: { signature: \"m\" },\n pgfusetype: { signature: \"m\" },\n pgfidrefnextuse: { signature: \"m m\" },\n pgfidrefprevuse: { signature: \"m m\" },\n pgfaliasid: { signature: \"m m\" },\n pgfgaliasid: { signature: \"m m\" },\n pgfifidreferenced: { signature: \"m m m\" },\n pgfrdfabout: { signature: \"m\" },\n pgfrdfcontent: { signature: \"m\" },\n pgfrdfdatatype: { signature: \"m\" },\n pgfrdfhref: { signature: \"m\" },\n pgfrdfprefix: { signature: \"m\" },\n pgfrdfproperty: { signature: \"m\" },\n pgfrdfrel: { signature: \"m\" },\n pgfrdfresource: { signature: \"m\" },\n pgfrdfrev: { signature: \"m\" },\n pgfrdfsrc: { signature: \"m\" },\n pgfrdftypeof: { signature: \"m\" },\n pgfrdfvocab: { signature: \"m\" },\n pgferror: { signature: \"m\" },\n pgfwarning: { signature: \"m\" },\n path: {\n signature: \"u;\",\n renderInfo: { breakAround: true, tikzPathCommand: true },\n },\n draw: {\n signature: \"u;\",\n renderInfo: { breakAround: true, tikzPathCommand: true },\n },\n fill: {\n signature: \"u;\",\n renderInfo: { breakAround: true, tikzPathCommand: true },\n },\n filldraw: {\n signature: \"u;\",\n renderInfo: { breakAround: true, tikzPathCommand: true },\n },\n pattern: {\n signature: \"u;\",\n renderInfo: { breakAround: true, tikzPathCommand: true },\n },\n shade: {\n signature: \"u;\",\n renderInfo: { breakAround: true, tikzPathCommand: true },\n },\n clip: {\n signature: \"u;\",\n renderInfo: { breakAround: true, tikzPathCommand: true },\n },\n useasboundingbox: {\n signature: \"u;\",\n renderInfo: { breakAround: true, tikzPathCommand: true },\n },\n node: {\n signature: \"u;\",\n renderInfo: { breakAround: true, tikzPathCommand: true },\n },\n coordinate: {\n signature: \"u;\",\n renderInfo: { breakAround: true, tikzPathCommand: true },\n },\n graph: {\n signature: \"u;\",\n renderInfo: { breakAround: true, tikzPathCommand: true },\n },\n scoped: {\n signature: \"o o m\",\n argumentParser: tikzCommandArgumentParser,\n renderInfo: {\n namedArguments: [\"animation\", \"options\", \"command\"],\n breakAround: true,\n },\n },\n};\n", "import { arg } from \"@unified-latex/unified-latex-builder\";\nimport * as Ast from \"@unified-latex/unified-latex-types\";\nimport {\n ArgSpecAst as ArgSpec,\n parse as parseArgspec,\n} from \"@unified-latex/unified-latex-util-argspec\";\nimport { ArgumentParser } from \"@unified-latex/unified-latex-types\";\nimport { gobbleSingleArgument } from \"@unified-latex/unified-latex-util-arguments\";\nimport { match } from \"@unified-latex/unified-latex-util-match\";\nimport { scan } from \"@unified-latex/unified-latex-util-scan\";\nimport { trim } from \"@unified-latex/unified-latex-util-trim\";\nimport { printRaw } from \"@unified-latex/unified-latex-util-print-raw\";\n\nconst OPTIONAL_ARGUMENT_ARG_SPEC = parseArgspec(\"o\")[0];\n\nfunction blankArg() {\n return arg([], { openMark: \"\", closeMark: \"\" });\n}\n\n/**\n * Find the arguments of a tikz command. Many tikz commands accept either\n * the a group as their only argument, or they scan their arguments until the first\n * `;` is found.\n *\n * This behavior cannot be achieved via a standard xparse spec.\n */\nexport const tikzCommandArgumentParser: ArgumentParser = (nodes, startPos) => {\n const origStartPos = startPos;\n let pos = startPos;\n let nodesRemoved = 0;\n\n const cursorPosAfterAnimations = eatAllAnimationSpecs(nodes, pos);\n let animationArg = blankArg();\n if (cursorPosAfterAnimations !== pos) {\n const argContent = nodes.splice(pos, cursorPosAfterAnimations - pos);\n trim(argContent);\n animationArg = arg(argContent, {\n openMark: \" \",\n closeMark: \" \",\n });\n }\n nodesRemoved += cursorPosAfterAnimations - pos;\n\n const {\n argument: _optionalArgument,\n nodesRemoved: optionalArgumentNodesRemoved,\n } = gobbleSingleArgument(nodes, OPTIONAL_ARGUMENT_ARG_SPEC, pos);\n nodesRemoved += optionalArgumentNodesRemoved;\n const optionalArg = _optionalArgument || blankArg();\n\n // Eat whitespace\n while (match.whitespace(nodes[pos])) {\n pos++;\n }\n const firstNode = nodes[pos];\n\n // If we're past the end of the array, give up.\n if (!firstNode) {\n return {\n args: [animationArg, optionalArg, blankArg()],\n nodesRemoved: 0,\n };\n }\n\n // If we're a group, grab the contents and call it good.\n if (match.group(firstNode)) {\n const args = [animationArg, optionalArg, arg(firstNode.content)];\n nodes.splice(origStartPos, pos - origStartPos + 1);\n return { args, nodesRemoved: pos - origStartPos + 1 + nodesRemoved };\n }\n\n // No group, so scan for a semicolon.\n const semicolonPosition = scan(nodes, \";\", { startIndex: pos });\n if (semicolonPosition != null) {\n const argNodes = nodes.splice(\n origStartPos,\n semicolonPosition - origStartPos + 1\n );\n trim(argNodes);\n const args = [animationArg, optionalArg, arg(argNodes)];\n return {\n args,\n nodesRemoved: origStartPos - semicolonPosition + 1 + nodesRemoved,\n };\n }\n\n // If there was no semicolon, give up.\n return {\n args: [animationArg, optionalArg, blankArg()],\n nodesRemoved: 0,\n };\n};\n\n/**\n * Find the next index after all animation specs. If no animation specs are present,\n * return `startPos`.\n *\n * An animation spec looks like\n * ```\n * :rotate = { 0s=\"0\", 2s=\"90\", begin on=click }\n * ```\n * Any number can be listed. They start with a colon and have an equals sign followed by a group.\n */\nfunction eatAllAnimationSpecs(nodes: Ast.Node[], startPos: number): number {\n const colonPos = scan(nodes, \":\", {\n startIndex: startPos,\n allowSubstringMatches: true,\n onlySkipWhitespaceAndComments: true,\n });\n\n if (!colonPos) {\n return startPos;\n }\n\n let lastMatchPos = startPos;\n let i = colonPos + 1;\n for (; i < nodes.length; i++) {\n const node = nodes[i];\n if (match.string(node, \"[\")) {\n // XXX As per the tikz manual, we stop scanning if we find an open square brace.\n break;\n }\n if (match.string(node, \"=\")) {\n i++;\n // Look for a group next\n while (match.whitespace(nodes[i]) || match.comment(nodes[i])) {\n i++;\n }\n if (!match.group(nodes[i])) {\n break;\n }\n // We have a match!\n lastMatchPos = i + 1;\n\n // Start the process again\n const colonPos = scan(nodes, \":\", {\n startIndex: lastMatchPos,\n allowSubstringMatches: true,\n onlySkipWhitespaceAndComments: true,\n });\n if (colonPos == null) {\n break;\n }\n i = colonPos + 1;\n }\n }\n\n return lastMatchPos;\n}\n", "import { printRaw as latexPrintRaw } from \"@unified-latex/unified-latex-util-print-raw\";\nimport { trim } from \"@unified-latex/unified-latex-util-trim\";\nimport * as TikzSpec from \"./types\";\n\n/**\n * Print an `systeme` argument specification AST to a string.\n */\nexport function printRaw(node: TikzSpec.Ast, root = false): string {\n if (typeof node === \"string\") {\n return node;\n }\n\n if (Array.isArray(node)) {\n const sepToken = root ? \" \" : \"\";\n const printed: string[] = [];\n for (let i = 0; i < node.length; i++) {\n const tok = node[i];\n const prevTok = node[i - 1];\n if (!prevTok) {\n printed.push(printRaw(tok));\n continue;\n }\n if (prevTok.type === \"comment\") {\n printed.push(printRaw(tok));\n continue;\n }\n if (tok.type !== \"comment\") {\n printed.push(sepToken);\n }\n printed.push(printRaw(tok));\n }\n return printed.join(\"\");\n }\n const type = node.type;\n\n switch (type) {\n case \"path_spec\":\n return printRaw(node.content, (root = true));\n case \"coordinate\":\n return `${latexPrintRaw(node.prefix)}(${latexPrintRaw(\n node.content\n )})`;\n case \"operation\":\n return latexPrintRaw(node.content);\n case \"comment\":\n return latexPrintRaw(node);\n case \"line_to\":\n return node.command;\n case \"curve_to\": {\n const comments = node.comments\n .map((c) => latexPrintRaw({ ...c, leadingWhitespace: false }))\n .join(\"\");\n if (node.controls.length === 1) {\n return `${comments}.. controls ${printRaw(\n node.controls[0]\n )} ..`;\n } else {\n return `${comments}.. controls ${printRaw(\n node.controls[0]\n )} and ${printRaw(node.controls[1])} ..`;\n }\n }\n case \"unknown\":\n return latexPrintRaw(node.content);\n case \"square_brace_group\":\n return `[${latexPrintRaw(node.content)}]`;\n case \"foreach\": {\n const comments = node.comments\n .map((c) => latexPrintRaw({ ...c, leadingWhitespace: false }))\n .join(\"\");\n let options = \"\";\n if (node.options) {\n options = ` [${latexPrintRaw(node.options)}]`;\n }\n const start = latexPrintRaw(node.start);\n const variables = [...node.variables];\n trim(variables);\n let printedVariables = latexPrintRaw(variables);\n // It is possible that the variables are specified as `[var=\\p]`, in the optional argument, instead of as `\\p`\n // In this case, `node.variables` will be empty and we don't want an extra space showing up.\n if (printedVariables.length > 0) {\n printedVariables = \" \" + printedVariables;\n }\n\n const command =\n node.command.type === \"foreach\"\n ? printRaw(node.command)\n : latexPrintRaw(node.command);\n\n return `${comments}${start}${printedVariables}${options} in ${latexPrintRaw(\n node.list\n )} ${command}`;\n }\n case \"svg_operation\": {\n const comments = node.comments\n .map((c) => latexPrintRaw({ ...c, leadingWhitespace: false }))\n .join(\"\");\n let options = \"\";\n if (node.options) {\n options = `[${latexPrintRaw(node.options)}]`;\n }\n\n return `${comments}svg${options} ${latexPrintRaw(node.content)}`;\n }\n case \"animation\": {\n const comments = node.comments\n .map((c) => latexPrintRaw({ ...c, leadingWhitespace: false }))\n .join(\"\");\n\n return `${comments}:${node.attribute} = {${latexPrintRaw(\n node.content\n )}}`;\n }\n\n default:\n const unprintedType: void = type;\n console.warn(`Unknown node type \"${unprintedType}\" for node`, node);\n return \"\";\n }\n}\n", "import * as Ast from \"@unified-latex/unified-latex-types\";\nimport * as TikzSpec from \"./types\";\nimport { match } from \"@unified-latex/unified-latex-util-match\";\nimport { decorateArrayForPegjs } from \"@unified-latex/unified-latex-util-pegjs\";\nimport { TikzPegParser } from \"@unified-latex/unified-latex-util-pegjs\";\n\ntype TikzParseOptions = {\n startRule?: \"path_spec\" | \"foreach_body\";\n};\n\nfunction createMatchers() {\n return {\n isChar: match.string,\n isTerminal: (node: any) => match.string(node, \";\"),\n isOperation: (node: any) =>\n match.anyString(node) && node.content.match(/[a-zA-Z]/),\n isWhitespace: (node: any) =>\n match.whitespace(node) || match.parbreak(node),\n isComment: match.comment,\n isGroup: match.group,\n isMacro: match.macro,\n isAnyMacro: match.anyMacro,\n };\n}\n\nconst matchers = createMatchers();\n\n/**\n * Parse the contents of the `\\systeme{...}` macro\n */\nexport function parse(\n ast: Ast.Node[],\n options?: Options\n): Options extends { startRule: infer R }\n ? R extends \"path_spec\"\n ? TikzSpec.PathSpec\n : TikzSpec.ForeachBody\n : TikzSpec.PathSpec {\n const { startRule = \"path_spec\" } = options || {};\n if (!Array.isArray(ast)) {\n throw new Error(\"You must pass an array of nodes\");\n }\n // We need to at functions to `nodes` so that it imitates\n // a Javascript string. Because we're mutating, make a copy first\n ast = decorateArrayForPegjs([...ast]);\n // matchers are passed in via the second argument (the `options` argument)\n // so they are available from within the Pegjs grammar.\n return TikzPegParser.parse(ast, {\n ...matchers,\n startRule,\n });\n}\n", "import { MacroInfoRecord, EnvInfoRecord } from \"@unified-latex/unified-latex-types\";\n\nexport const macros: MacroInfoRecord = {\n substitutecolormodel: {\n signature: \"m m\",\n renderInfo: { breakAround: true },\n },\n selectcolormodel: {\n signature: \"m\",\n renderInfo: { breakAround: true },\n },\n definecolor: {\n signature: \"o m m m\",\n renderInfo: { breakAround: true },\n },\n providecolor: {\n signature: \"o m m m\",\n renderInfo: { breakAround: true },\n },\n colorlet: {\n signature: \"o m o m\",\n renderInfo: { breakAround: true },\n },\n definecolorset: {\n signature: \"o m m m\",\n renderInfo: { breakAround: true },\n },\n providecolorset: {\n signature: \"o m m m m\",\n renderInfo: { breakAround: true },\n },\n preparecolor: {\n signature: \"o m m m\",\n renderInfo: { breakAround: true },\n },\n preparecolorset: {\n signature: \"o m m m m\",\n renderInfo: { breakAround: true },\n },\n DefineNamedColor: {\n signature: \"m m m m\",\n renderInfo: { breakAround: true },\n },\n definecolors: {\n signature: \"m\",\n renderInfo: { breakAround: true },\n },\n providecolors: {\n signature: \"m\",\n renderInfo: { breakAround: true },\n },\n color: { signature: \"o m\", renderInfo: { breakAround: true } },\n textcolor: { signature: \"o m m\", renderInfo: { inParMode: true } },\n pagecolor: { signature: \"o m\" },\n colorbox: { signature: \"o m m\" },\n fcolorbox: { signature: \"o m o m m\" },\n boxframe: { signature: \"o m\" },\n testcolor: { signature: \"o m\" },\n blendcolors: { signature: \"s m\" },\n maskcolors: { signature: \"o m\" },\n definecolorseries: {\n signature: \"m m m o m o m\",\n renderInfo: { breakAround: true },\n },\n resetcolorseries: {\n signature: \"o m\",\n renderInfo: { breakAround: true },\n },\n rowcolors: { signature: \"s o m m m\" },\n extractcolorspec: { signature: \"m m\" },\n extractcolorspecs: { signature: \"m m m\" },\n convertcolorspec: { signature: \"m m m m\" },\n};\n\nexport const environments: EnvInfoRecord = {\n testcolors: { signature: \"o\", renderInfo: { pgfkeysArgs: true } },\n};\n", "import Color from \"color\";\nimport { DVI_PS_NAMES, SVG_NAMES, X11_NAMES } from \"./predefined-colors\";\nimport { XColor } from \"./types\";\nimport { parse as xcolorParser } from \"./parser\";\n\nconst CORE_MODELS = new Set([\"rgb\", \"cmy\", \"cmyk\", \"hsb\", \"gray\"]);\n\nexport const XColorCoreModelToColor = {\n rgb: ([r, g, b]: number[]) => Color([r * 255, g * 255, b * 255], \"rgb\"),\n cmy: ([c, m, y]: number[]) =>\n XColorCoreModelToColor.rgb([1 - c, 1 - m, 1 - y]),\n cmyk: ([c, m, y, k]: number[]) =>\n Color([c * 255, m * 255, y * 255, k * 100], \"cmyk\"),\n hsb: ([h, s, b]: number[]) => Color([h * 360, s * 100, b * 100], \"hsv\"),\n gray: ([v]: number[]) => Color([v * 255, v * 255, v * 255], \"rgb\"),\n};\nconst XColorModelToColor = {\n wave: ([lambda]: number[]) => {\n // Constants according to the xcolor readme\n const gamma = 0.8;\n let baseRgb = [0, 0, 0];\n if (380 <= lambda && lambda < 440) {\n baseRgb = [(440 - lambda) / (440 - 380), 0, 1];\n }\n if (440 <= lambda && lambda < 490) {\n baseRgb = [0, (lambda - 440) / (490 - 440), 1];\n }\n if (490 <= lambda && lambda < 510) {\n baseRgb = [0, 1, (510 - lambda) / (510 - 490)];\n }\n if (510 <= lambda && lambda < 580) {\n baseRgb = [(lambda - 510) / (580 - 510), 1, 0];\n }\n if (580 <= lambda && lambda < 6450) {\n baseRgb = [1, (645 - lambda) / (645 - 580), 0];\n }\n if (645 <= lambda && lambda <= 780) {\n baseRgb = [1, 0, 0];\n }\n let f = 1.0;\n if (380 <= lambda && 420 < lambda) {\n f = 0.3 + (0.7 * (lambda - 380)) / (420 - 380);\n }\n if (700 < lambda && lambda <= 780) {\n f = 0.3 + (0.7 * (780 - lambda)) / (780 - 700);\n }\n\n const rgb = [\n Math.pow(baseRgb[0] * f, gamma),\n Math.pow(baseRgb[1] * f, gamma),\n Math.pow(baseRgb[2] * f, gamma),\n ];\n\n return Color([rgb[0] * 255, rgb[1] * 255, rgb[2] * 255], \"rgb\");\n },\n Hsb: ([h, s, b]: number[]) => XColorCoreModelToColor.hsb([h / 360, s, b]),\n HSB: ([h, s, b]: number[]) =>\n XColorCoreModelToColor.hsb([h / 240, s / 240, b / 240]),\n HTML: ([v]: [string]) => (v.startsWith(\"#\") ? Color(v) : Color(`#${v}`)),\n RGB: ([r, g, b]: number[]) => Color([r, g, b], \"rgb\"),\n Gray: ([v]: number[]) => XColorCoreModelToColor.gray([v / 15]),\n ...XColorCoreModelToColor,\n};\n\nconst ColorToXColorModel = {\n rgb: (color: Color) =>\n color\n .rgb()\n .array()\n .map((v) => v / 255),\n cmy: (color: Color) =>\n [255 - color.red(), 255 - color.green(), 255 - color.blue()].map(\n (v) => v / 255\n ),\n cmyk: (color: Color) =>\n color\n .cmyk()\n .array()\n // The k component goes from 0-100\n .map((v, i) => (i === 3 ? v / 100 : v / 255)),\n hsb: (color: Color) => [\n color.hue() / 360,\n color.saturationv() / 100,\n color.value() / 100,\n ],\n gray: (color: Color) => [color.gray() / 100],\n};\n\nexport const PREDEFINED_XCOLOR_COLORS: Record> = {\n // Core colors\n red: XColorCoreModelToColor.rgb([1, 0, 0]),\n green: XColorCoreModelToColor.rgb([0, 1, 0]),\n blue: XColorCoreModelToColor.rgb([0, 0, 1]),\n brown: XColorCoreModelToColor.rgb([0.75, 0.5, 0.25]),\n lime: XColorCoreModelToColor.rgb([0.75, 1, 0]),\n orange: XColorCoreModelToColor.rgb([1, 0.5, 0]),\n pink: XColorCoreModelToColor.rgb([1, 0.75, 0.75]),\n purple: XColorCoreModelToColor.rgb([0.75, 0, 0.25]),\n teal: XColorCoreModelToColor.rgb([0, 0.5, 0.5]),\n violet: XColorCoreModelToColor.rgb([0.5, 0, 0.5]),\n cyan: XColorCoreModelToColor.rgb([0, 1, 1]),\n magenta: XColorCoreModelToColor.rgb([1, 0, 1]),\n yellow: XColorCoreModelToColor.rgb([1, 1, 0]),\n olive: XColorCoreModelToColor.rgb([0.5, 0.5, 0]),\n black: XColorCoreModelToColor.rgb([0, 0, 0]),\n darkgray: XColorCoreModelToColor.rgb([0.25, 0.25, 0.25]),\n gray: XColorCoreModelToColor.rgb([0.5, 0.5, 0.5]),\n lightgray: XColorCoreModelToColor.rgb([0.75, 0.75, 0.75]),\n white: XColorCoreModelToColor.rgb([1, 1, 1]),\n ...DVI_PS_NAMES,\n ...SVG_NAMES,\n ...X11_NAMES,\n};\n\nfunction scalarMul(scalar: number, vec: number[]) {\n return vec.map((v) => scalar * v);\n}\nfunction addVectors(...vecs: number[][]) {\n return vecs.reduce((prev, current) => prev.map((v, i) => v + current[i]));\n}\n\n/**\n * Mix a color in color model `model` as per the algorithm in 2.3.3 of the xcolor manual.\n */\nfunction mixInModel(\n model: string,\n colorsAndCoefficients: [number, Color][]\n): Color {\n if (!CORE_MODELS.has(model)) {\n throw new Error(\n `Cannot mix colors in model \"${model}\"; only core modes ${Array.from(\n CORE_MODELS\n ).join(\", \")} are supported`\n );\n }\n const toModel =\n ColorToXColorModel[model as keyof typeof ColorToXColorModel];\n const fromModel =\n XColorCoreModelToColor[model as keyof typeof XColorCoreModelToColor];\n\n const mixed = addVectors(\n ...colorsAndCoefficients.map(([v, color]) => {\n const colorInModel = toModel(color);\n return scalarMul(v, colorInModel);\n })\n );\n return fromModel(mixed);\n}\n\n/**\n * Given a parsed `XColor`, compute the color and return a `Color` object\n * (that can be used in CSS, for example).\n */\nexport function computeColor(\n expr: XColor,\n predefinedColors: Record> = {}\n): Color {\n if (expr.type !== \"color\") {\n throw new Error(\n `Can only compute the color of a \"color\" expression, not one of type ${expr.type}`\n );\n }\n\n const knownColors = { ...PREDEFINED_XCOLOR_COLORS, ...predefinedColors };\n function getColor(name: string) {\n if (!knownColors[name]) {\n throw new Error(`Unknown color \"${name}\"`);\n }\n return knownColors[name];\n }\n\n const color = expr.color;\n let computedColor = Color(\"#000000\");\n if (color.type === \"expr\") {\n // From the algorithm in 2.3.2 of the xcolor manual\n\n // TODO: the suffix `!![num]` is not yet implemented.\n let base = getColor(color.name);\n for (const mix of color.mix_expr) {\n if (mix.type === \"complete_mix\") {\n const mixColor = getColor(mix.name);\n base = base.mix(mixColor, 1 - mix.mix_percent / 100);\n } else if (mix.type === \"partial_mix\") {\n base = base.mix(Color(\"#FFFFFF\"), 1 - mix.mix_percent / 100);\n }\n }\n if (color.prefix && color.prefix.length % 2 === 1) {\n base = base.rotate(180);\n }\n computedColor = base;\n }\n if (color.type === \"extended_expr\") {\n const model = color.core_model;\n const div =\n color.div ||\n color.expressions.reduce((a, expr) => a + expr.weight, 0);\n if (div <= 0) {\n throw new Error(\n `Cannot mix color with ratios that have a denominator of ${div}`\n );\n }\n const colorsToMix: [number, Color][] = color.expressions.map(\n (expr) => [\n expr.weight / div,\n computeColor({\n type: \"color\",\n color: expr.color,\n functions: [],\n }),\n ]\n );\n computedColor = mixInModel(model, colorsToMix);\n }\n\n // Now we apply any color functions\n for (const func of expr.functions) {\n if (func.name === \"wheel\") {\n const angle = func.args[0];\n const circ = func.args[1] || 360;\n computedColor = computedColor.rotate((angle / circ) * 360);\n }\n if (func.name === \"twheel\") {\n // This function depends on the definition of \\rangetHsb, which we\n // don't actually know, so we just use it's default, which is to\n // add a 60 deg. angle to everything. I think...\n const angle = func.args[0];\n const circ = func.args[1] || 360;\n computedColor = computedColor.rotate((angle / circ) * 360 + 60);\n }\n }\n\n return computedColor;\n}\n\n/**\n * Convert the xcolor defined color to RGB Hex representation.\n * If the color is unknown or cannot be computed, `null` is returned.\n *\n * If `model` is supplied,\n *\n * The most likely reason a color will be `null` is if the color is defined\n * using a pre-defined color that wasn't supplied as an argument.\n */\nexport function xcolorColorToHex(\n color: string,\n model?: string | null,\n options: {\n predefinedColors?: Record>;\n } = { predefinedColors: {} }\n): string | null {\n const { predefinedColors = {} } = options;\n const parsed = xcolorParser(color);\n // If a model was entered, the corresponding color was directly entered without\n // mixing, unless the parsed type was \"color\". This would through an error in `xcolor`,\n // but we won't error.\n if (model && model !== \"default\" && parsed.type !== \"color\") {\n if (!(model in XColorModelToColor)) {\n throw new Error(\n `Unknown color model \"${model}\"; known models are ${Object.keys(\n XColorModelToColor\n ).join(\", \")}`\n );\n }\n if (parsed.type !== \"hex_spec\" && parsed.type !== \"num_spec\") {\n throw new Error(\n `Cannot use model ${model} to compute the color \"${color}\"`\n );\n }\n\n if (model === \"HTML\" && parsed.type === \"hex_spec\") {\n return XColorModelToColor.HTML(parsed.content).hex();\n } else if (parsed.type === \"num_spec\") {\n type x = keyof Omit;\n return XColorModelToColor[\n model as keyof Omit\n ](parsed.content).hex();\n }\n\n throw new Error(\n `Don't know how to process color \"${color}\" in model \"${model}\"`\n );\n }\n\n if (Array.isArray(parsed) || parsed.type !== \"color\") {\n throw new Error(\n `Cannot the color \"${color}\" is not a valid color string`\n );\n }\n let computed: Color | null = null;\n try {\n computed = computeColor(parsed, predefinedColors);\n } catch (e) {}\n\n return computed && computed.hex();\n}\n", "import Color from \"color\";\n\nconst fromRgb = ([r, g, b]: number[]) =>\n Color([r * 255, g * 255, b * 255], \"rgb\");\n\nexport const DVI_PS_NAMES = {\n Apricot: Color(\"#FBB982\"),\n Aquamarine: Color(\"#00B5BE\"),\n Bittersweet: Color(\"#C04F17\"),\n Black: Color(\"#221E1F\"),\n Blue: Color(\"#2D2F92\"),\n BlueGreen: Color(\"#00B3B8\"),\n BlueViolet: Color(\"#473992\"),\n BrickRed: Color(\"#B6321C\"),\n Brown: Color(\"#792500\"),\n BurntOrange: Color(\"#F7921D\"),\n CadetBlue: Color(\"#74729A\"),\n CarnationPink: Color(\"#F282B4\"),\n Cerulean: Color(\"#00A2E3\"),\n CornflowerBlue: Color(\"#41B0E4\"),\n Cyan: Color(\"#00AEEF\"),\n Dandelion: Color(\"#FDBC42\"),\n DarkOrchid: Color(\"#A4538A\"),\n Emerald: Color(\"#00A99D\"),\n ForestGreen: Color(\"#009B55\"),\n Fuchsia: Color(\"#8C368C\"),\n Goldenrod: Color(\"#FFDF42\"),\n Gray: Color(\"#949698\"),\n Green: Color(\"#00A64F\"),\n GreenYellow: Color(\"#DFE674\"),\n JungleGreen: Color(\"#00A99A\"),\n Lavender: Color(\"#F49EC4\"),\n LimeGreen: Color(\"#8DC73E\"),\n Magenta: Color(\"#EC008C\"),\n Mahogany: Color(\"#A9341F\"),\n Maroon: Color(\"#AF3235\"),\n Melon: Color(\"#F89E7B\"),\n MidnightBlue: Color(\"#006795\"),\n Mulberry: Color(\"#A93C93\"),\n NavyBlue: Color(\"#006EB8\"),\n OliveGreen: Color(\"#3C8031\"),\n Orange: Color(\"#F58137\"),\n OrangeRed: Color(\"#ED135A\"),\n Orchid: Color(\"#AF72B0\"),\n Peach: Color(\"#F7965A\"),\n Periwinkle: Color(\"#7977B8\"),\n PineGreen: Color(\"#008B72\"),\n Plum: Color(\"#92268F\"),\n ProcessBlue: Color(\"#00B0F0\"),\n Purple: Color(\"#99479B\"),\n RawSienna: Color(\"#974006\"),\n Red: Color(\"#ED1B23\"),\n RedOrange: Color(\"#F26035\"),\n RedViolet: Color(\"#A1246B\"),\n Rhodamine: Color(\"#EF559F\"),\n RoyalBlue: Color(\"#0071BC\"),\n RoyalPurple: Color(\"#613F99\"),\n RubineRed: Color(\"#ED017D\"),\n Salmon: Color(\"#F69289\"),\n SeaGreen: Color(\"#3FBC9D\"),\n Sepia: Color(\"#671800\"),\n SkyBlue: Color(\"#46C5DD\"),\n SpringGreen: Color(\"#C6DC67\"),\n Tan: Color(\"#DA9D76\"),\n TealBlue: Color(\"#00AEB3\"),\n Thistle: Color(\"#D883B7\"),\n Turquoise: Color(\"#00B4CE\"),\n Violet: Color(\"#58429B\"),\n VioletRed: Color(\"#EF58A0\"),\n White: Color(\"#FFFFFF\"),\n WildStrawberry: Color(\"#EE2967\"),\n Yellow: Color(\"#FFF200\"),\n YellowGreen: Color(\"#98CC70\"),\n YellowOrange: Color(\"#FAA21A\"),\n};\n\nexport const SVG_NAMES = {\n AliceBlue: fromRgb([0.94, 0.972, 1]),\n AntiqueWhite: fromRgb([0.98, 0.92, 0.844]),\n Aqua: fromRgb([0, 1, 1]),\n Aquamarine: fromRgb([0.498, 1, 0.83]),\n Azure: fromRgb([0.94, 1, 1]),\n Beige: fromRgb([0.96, 0.96, 0.864]),\n Bisque: fromRgb([1, 0.894, 0.77]),\n Black: fromRgb([0, 0, 0]),\n BlanchedAlmond: fromRgb([1, 0.92, 0.804]),\n Blue: fromRgb([0, 0, 1]),\n BlueViolet: fromRgb([0.54, 0.17, 0.888]),\n Brown: fromRgb([0.648, 0.165, 0.165]),\n BurlyWood: fromRgb([0.87, 0.72, 0.53]),\n CadetBlue: fromRgb([0.372, 0.62, 0.628]),\n Chartreuse: fromRgb([0.498, 1, 0]),\n Chocolate: fromRgb([0.824, 0.41, 0.116]),\n Coral: fromRgb([1, 0.498, 0.312]),\n CornflowerBlue: fromRgb([0.392, 0.585, 0.93]),\n Cornsilk: fromRgb([1, 0.972, 0.864]),\n Crimson: fromRgb([0.864, 0.08, 0.235]),\n Cyan: fromRgb([0, 1, 1]),\n DarkBlue: fromRgb([0, 0, 0.545]),\n DarkCyan: fromRgb([0, 0.545, 0.545]),\n DarkGoldenrod: fromRgb([0.72, 0.525, 0.044]),\n DarkGray: fromRgb([0.664, 0.664, 0.664]),\n DarkGreen: fromRgb([0, 0.392, 0]),\n DarkGrey: fromRgb([0.664, 0.664, 0.664]),\n DarkKhaki: fromRgb([0.74, 0.716, 0.42]),\n DarkMagenta: fromRgb([0.545, 0, 0.545]),\n DarkOliveGreen: fromRgb([0.332, 0.42, 0.185]),\n DarkOrange: fromRgb([1, 0.55, 0]),\n DarkOrchid: fromRgb([0.6, 0.196, 0.8]),\n DarkRed: fromRgb([0.545, 0, 0]),\n DarkSalmon: fromRgb([0.912, 0.59, 0.48]),\n DarkSeaGreen: fromRgb([0.56, 0.736, 0.56]),\n DarkSlateBlue: fromRgb([0.284, 0.24, 0.545]),\n DarkSlateGray: fromRgb([0.185, 0.31, 0.31]),\n DarkSlateGrey: fromRgb([0.185, 0.31, 0.31]),\n DarkTurquoise: fromRgb([0, 0.808, 0.82]),\n DarkViolet: fromRgb([0.58, 0, 0.828]),\n DeepPink: fromRgb([1, 0.08, 0.576]),\n DeepSkyBlue: fromRgb([0, 0.75, 1]),\n DimGray: fromRgb([0.41, 0.41, 0.41]),\n DimGrey: fromRgb([0.41, 0.41, 0.41]),\n DodgerBlue: fromRgb([0.116, 0.565, 1]),\n FireBrick: fromRgb([0.698, 0.132, 0.132]),\n FloralWhite: fromRgb([1, 0.98, 0.94]),\n ForestGreen: fromRgb([0.132, 0.545, 0.132]),\n Fuchsia: fromRgb([1, 0, 1]),\n Gainsboro: fromRgb([0.864, 0.864, 0.864]),\n GhostWhite: fromRgb([0.972, 0.972, 1]),\n Gold: fromRgb([1, 0.844, 0]),\n Goldenrod: fromRgb([0.855, 0.648, 0.125]),\n Gray: fromRgb([0.5, 0.5, 0.5]),\n Green: fromRgb([0, 0.5, 0]),\n GreenYellow: fromRgb([0.68, 1, 0.185]),\n Grey: fromRgb([0.5, 0.5, 0.5]),\n Honeydew: fromRgb([0.94, 1, 0.94]),\n HotPink: fromRgb([1, 0.41, 0.705]),\n IndianRed: fromRgb([0.804, 0.36, 0.36]),\n Indigo: fromRgb([0.294, 0, 0.51]),\n Ivory: fromRgb([1, 1, 0.94]),\n Khaki: fromRgb([0.94, 0.9, 0.55]),\n Lavender: fromRgb([0.9, 0.9, 0.98]),\n LavenderBlush: fromRgb([1, 0.94, 0.96]),\n LawnGreen: fromRgb([0.488, 0.99, 0]),\n LemonChiffon: fromRgb([1, 0.98, 0.804]),\n LightBlue: fromRgb([0.68, 0.848, 0.9]),\n LightCoral: fromRgb([0.94, 0.5, 0.5]),\n LightCyan: fromRgb([0.88, 1, 1]),\n LightGoldenrod: fromRgb([0.933, 0.867, 0.51]),\n LightGoldenrodYellow: fromRgb([0.98, 0.98, 0.824]),\n LightGray: fromRgb([0.828, 0.828, 0.828]),\n LightGreen: fromRgb([0.565, 0.932, 0.565]),\n LightGrey: fromRgb([0.828, 0.828, 0.828]),\n LightPink: fromRgb([1, 0.712, 0.756]),\n LightSalmon: fromRgb([1, 0.628, 0.48]),\n LightSeaGreen: fromRgb([0.125, 0.698, 0.668]),\n LightSkyBlue: fromRgb([0.53, 0.808, 0.98]),\n LightSlateBlue: fromRgb([0.518, 0.44, 1]),\n LightSlateGray: fromRgb([0.468, 0.532, 0.6]),\n LightSlateGrey: fromRgb([0.468, 0.532, 0.6]),\n LightSteelBlue: fromRgb([0.69, 0.77, 0.87]),\n LightYellow: fromRgb([1, 1, 0.88]),\n Lime: fromRgb([0, 1, 0]),\n LimeGreen: fromRgb([0.196, 0.804, 0.196]),\n Linen: fromRgb([0.98, 0.94, 0.9]),\n Magenta: fromRgb([1, 0, 1]),\n Maroon: fromRgb([0.5, 0, 0]),\n MediumAquamarine: fromRgb([0.4, 0.804, 0.668]),\n MediumBlue: fromRgb([0, 0, 0.804]),\n MediumOrchid: fromRgb([0.73, 0.332, 0.828]),\n MediumPurple: fromRgb([0.576, 0.44, 0.86]),\n MediumSeaGreen: fromRgb([0.235, 0.7, 0.444]),\n MediumSlateBlue: fromRgb([0.484, 0.408, 0.932]),\n MediumSpringGreen: fromRgb([0, 0.98, 0.604]),\n MediumTurquoise: fromRgb([0.284, 0.82, 0.8]),\n MediumVioletRed: fromRgb([0.78, 0.084, 0.52]),\n MidnightBlue: fromRgb([0.098, 0.098, 0.44]),\n MintCream: fromRgb([0.96, 1, 0.98]),\n MistyRose: fromRgb([1, 0.894, 0.884]),\n Moccasin: fromRgb([1, 0.894, 0.71]),\n NavajoWhite: fromRgb([1, 0.87, 0.68]),\n Navy: fromRgb([0, 0, 0.5]),\n NavyBlue: fromRgb([0, 0, 0.5]),\n OldLace: fromRgb([0.992, 0.96, 0.9]),\n Olive: fromRgb([0.5, 0.5, 0]),\n OliveDrab: fromRgb([0.42, 0.556, 0.136]),\n Orange: fromRgb([1, 0.648, 0]),\n OrangeRed: fromRgb([1, 0.27, 0]),\n Orchid: fromRgb([0.855, 0.44, 0.84]),\n PaleGoldenrod: fromRgb([0.932, 0.91, 0.668]),\n PaleGreen: fromRgb([0.596, 0.985, 0.596]),\n PaleTurquoise: fromRgb([0.688, 0.932, 0.932]),\n PaleVioletRed: fromRgb([0.86, 0.44, 0.576]),\n PapayaWhip: fromRgb([1, 0.936, 0.835]),\n PeachPuff: fromRgb([1, 0.855, 0.725]),\n Peru: fromRgb([0.804, 0.52, 0.248]),\n Pink: fromRgb([1, 0.752, 0.796]),\n Plum: fromRgb([0.868, 0.628, 0.868]),\n PowderBlue: fromRgb([0.69, 0.88, 0.9]),\n Purple: fromRgb([0.5, 0, 0.5]),\n Red: fromRgb([1, 0, 0]),\n RosyBrown: fromRgb([0.736, 0.56, 0.56]),\n RoyalBlue: fromRgb([0.255, 0.41, 0.884]),\n SaddleBrown: fromRgb([0.545, 0.27, 0.075]),\n Salmon: fromRgb([0.98, 0.5, 0.448]),\n SandyBrown: fromRgb([0.956, 0.644, 0.376]),\n SeaGreen: fromRgb([0.18, 0.545, 0.34]),\n Seashell: fromRgb([1, 0.96, 0.932]),\n Sienna: fromRgb([0.628, 0.32, 0.176]),\n Silver: fromRgb([0.752, 0.752, 0.752]),\n SkyBlue: fromRgb([0.53, 0.808, 0.92]),\n SlateBlue: fromRgb([0.415, 0.352, 0.804]),\n SlateGray: fromRgb([0.44, 0.5, 0.565]),\n SlateGrey: fromRgb([0.44, 0.5, 0.565]),\n Snow: fromRgb([1, 0.98, 0.98]),\n SpringGreen: fromRgb([0, 1, 0.498]),\n SteelBlue: fromRgb([0.275, 0.51, 0.705]),\n Tan: fromRgb([0.824, 0.705, 0.55]),\n Teal: fromRgb([0, 0.5, 0.5]),\n Thistle: fromRgb([0.848, 0.75, 0.848]),\n Tomato: fromRgb([1, 0.39, 0.28]),\n Turquoise: fromRgb([0.25, 0.88, 0.815]),\n Violet: fromRgb([0.932, 0.51, 0.932]),\n VioletRed: fromRgb([0.816, 0.125, 0.565]),\n Wheat: fromRgb([0.96, 0.87, 0.7]),\n White: fromRgb([1, 1, 1]),\n WhiteSmoke: fromRgb([0.96, 0.96, 0.96]),\n Yellow: fromRgb([1, 1, 0]),\n YellowGreen: fromRgb([0.604, 0.804, 0.196]),\n};\n\nexport const X11_NAMES = {\n AntiqueWhite1: fromRgb([1, 0.936, 0.86]),\n AntiqueWhite2: fromRgb([0.932, 0.875, 0.8]),\n AntiqueWhite3: fromRgb([0.804, 0.752, 0.69]),\n AntiqueWhite4: fromRgb([0.545, 0.512, 0.47]),\n Aquamarine1: fromRgb([0.498, 1, 0.83]),\n Aquamarine2: fromRgb([0.464, 0.932, 0.776]),\n Aquamarine3: fromRgb([0.4, 0.804, 0.668]),\n Aquamarine4: fromRgb([0.27, 0.545, 0.455]),\n Azure1: fromRgb([0.94, 1, 1]),\n Azure2: fromRgb([0.88, 0.932, 0.932]),\n Azure3: fromRgb([0.756, 0.804, 0.804]),\n Azure4: fromRgb([0.512, 0.545, 0.545]),\n Bisque1: fromRgb([1, 0.894, 0.77]),\n Bisque2: fromRgb([0.932, 0.835, 0.716]),\n Bisque3: fromRgb([0.804, 0.716, 0.62]),\n Bisque4: fromRgb([0.545, 0.49, 0.42]),\n Blue1: fromRgb([0, 0, 1]),\n Blue2: fromRgb([0, 0, 0.932]),\n Blue3: fromRgb([0, 0, 0.804]),\n Blue4: fromRgb([0, 0, 0.545]),\n Brown1: fromRgb([1, 0.25, 0.25]),\n Brown2: fromRgb([0.932, 0.23, 0.23]),\n Brown3: fromRgb([0.804, 0.2, 0.2]),\n Brown4: fromRgb([0.545, 0.136, 0.136]),\n Burlywood1: fromRgb([1, 0.828, 0.608]),\n Burlywood2: fromRgb([0.932, 0.772, 0.57]),\n Burlywood3: fromRgb([0.804, 0.668, 0.49]),\n Burlywood4: fromRgb([0.545, 0.45, 0.332]),\n CadetBlue1: fromRgb([0.596, 0.96, 1]),\n CadetBlue2: fromRgb([0.556, 0.898, 0.932]),\n CadetBlue3: fromRgb([0.48, 0.772, 0.804]),\n CadetBlue4: fromRgb([0.325, 0.525, 0.545]),\n Chartreuse1: fromRgb([0.498, 1, 0]),\n Chartreuse2: fromRgb([0.464, 0.932, 0]),\n Chartreuse3: fromRgb([0.4, 0.804, 0]),\n Chartreuse4: fromRgb([0.27, 0.545, 0]),\n Chocolate1: fromRgb([1, 0.498, 0.14]),\n Chocolate2: fromRgb([0.932, 0.464, 0.13]),\n Chocolate3: fromRgb([0.804, 0.4, 0.112]),\n Chocolate4: fromRgb([0.545, 0.27, 0.075]),\n Coral1: fromRgb([1, 0.448, 0.336]),\n Coral2: fromRgb([0.932, 0.415, 0.312]),\n Coral3: fromRgb([0.804, 0.356, 0.27]),\n Coral4: fromRgb([0.545, 0.244, 0.185]),\n Cornsilk1: fromRgb([1, 0.972, 0.864]),\n Cornsilk2: fromRgb([0.932, 0.91, 0.804]),\n Cornsilk3: fromRgb([0.804, 0.785, 0.694]),\n Cornsilk4: fromRgb([0.545, 0.532, 0.47]),\n Cyan1: fromRgb([0, 1, 1]),\n Cyan2: fromRgb([0, 0.932, 0.932]),\n Cyan3: fromRgb([0, 0.804, 0.804]),\n Cyan4: fromRgb([0, 0.545, 0.545]),\n DarkGoldenrod1: fromRgb([1, 0.725, 0.06]),\n DarkGoldenrod2: fromRgb([0.932, 0.68, 0.055]),\n DarkGoldenrod3: fromRgb([0.804, 0.585, 0.048]),\n DarkGoldenrod4: fromRgb([0.545, 0.396, 0.03]),\n DarkOliveGreen1: fromRgb([0.792, 1, 0.44]),\n DarkOliveGreen2: fromRgb([0.736, 0.932, 0.408]),\n DarkOliveGreen3: fromRgb([0.635, 0.804, 0.352]),\n DarkOliveGreen4: fromRgb([0.43, 0.545, 0.24]),\n DarkOrange1: fromRgb([1, 0.498, 0]),\n DarkOrange2: fromRgb([0.932, 0.464, 0]),\n DarkOrange3: fromRgb([0.804, 0.4, 0]),\n DarkOrange4: fromRgb([0.545, 0.27, 0]),\n DarkOrchid1: fromRgb([0.75, 0.244, 1]),\n DarkOrchid2: fromRgb([0.698, 0.228, 0.932]),\n DarkOrchid3: fromRgb([0.604, 0.196, 0.804]),\n DarkOrchid4: fromRgb([0.408, 0.132, 0.545]),\n DarkSeaGreen1: fromRgb([0.756, 1, 0.756]),\n DarkSeaGreen2: fromRgb([0.705, 0.932, 0.705]),\n DarkSeaGreen3: fromRgb([0.608, 0.804, 0.608]),\n DarkSeaGreen4: fromRgb([0.41, 0.545, 0.41]),\n DarkSlateGray1: fromRgb([0.592, 1, 1]),\n DarkSlateGray2: fromRgb([0.552, 0.932, 0.932]),\n DarkSlateGray3: fromRgb([0.475, 0.804, 0.804]),\n DarkSlateGray4: fromRgb([0.32, 0.545, 0.545]),\n DeepPink1: fromRgb([1, 0.08, 0.576]),\n DeepPink2: fromRgb([0.932, 0.07, 0.536]),\n DeepPink3: fromRgb([0.804, 0.064, 0.464]),\n DeepPink4: fromRgb([0.545, 0.04, 0.312]),\n DeepSkyBlue1: fromRgb([0, 0.75, 1]),\n DeepSkyBlue2: fromRgb([0, 0.698, 0.932]),\n DeepSkyBlue3: fromRgb([0, 0.604, 0.804]),\n DeepSkyBlue4: fromRgb([0, 0.408, 0.545]),\n DodgerBlue1: fromRgb([0.116, 0.565, 1]),\n DodgerBlue2: fromRgb([0.11, 0.525, 0.932]),\n DodgerBlue3: fromRgb([0.094, 0.455, 0.804]),\n DodgerBlue4: fromRgb([0.064, 0.305, 0.545]),\n Firebrick1: fromRgb([1, 0.19, 0.19]),\n Firebrick2: fromRgb([0.932, 0.172, 0.172]),\n Firebrick3: fromRgb([0.804, 0.15, 0.15]),\n Firebrick4: fromRgb([0.545, 0.1, 0.1]),\n Gold1: fromRgb([1, 0.844, 0]),\n Gold2: fromRgb([0.932, 0.79, 0]),\n Gold3: fromRgb([0.804, 0.68, 0]),\n Gold4: fromRgb([0.545, 0.46, 0]),\n Goldenrod1: fromRgb([1, 0.756, 0.145]),\n Goldenrod2: fromRgb([0.932, 0.705, 0.132]),\n Goldenrod3: fromRgb([0.804, 0.608, 0.112]),\n Goldenrod4: fromRgb([0.545, 0.41, 0.08]),\n Green1: fromRgb([0, 1, 0]),\n Green2: fromRgb([0, 0.932, 0]),\n Green3: fromRgb([0, 0.804, 0]),\n Green4: fromRgb([0, 0.545, 0]),\n Honeydew1: fromRgb([0.94, 1, 0.94]),\n Honeydew2: fromRgb([0.88, 0.932, 0.88]),\n Honeydew3: fromRgb([0.756, 0.804, 0.756]),\n Honeydew4: fromRgb([0.512, 0.545, 0.512]),\n HotPink1: fromRgb([1, 0.43, 0.705]),\n HotPink2: fromRgb([0.932, 0.415, 0.655]),\n HotPink3: fromRgb([0.804, 0.376, 0.565]),\n HotPink4: fromRgb([0.545, 0.228, 0.385]),\n IndianRed1: fromRgb([1, 0.415, 0.415]),\n IndianRed2: fromRgb([0.932, 0.39, 0.39]),\n IndianRed3: fromRgb([0.804, 0.332, 0.332]),\n IndianRed4: fromRgb([0.545, 0.228, 0.228]),\n Ivory1: fromRgb([1, 1, 0.94]),\n Ivory2: fromRgb([0.932, 0.932, 0.88]),\n Ivory3: fromRgb([0.804, 0.804, 0.756]),\n Ivory4: fromRgb([0.545, 0.545, 0.512]),\n Khaki1: fromRgb([1, 0.965, 0.56]),\n Khaki2: fromRgb([0.932, 0.9, 0.52]),\n Khaki3: fromRgb([0.804, 0.776, 0.45]),\n Khaki4: fromRgb([0.545, 0.525, 0.305]),\n LavenderBlush1: fromRgb([1, 0.94, 0.96]),\n LavenderBlush2: fromRgb([0.932, 0.88, 0.898]),\n LavenderBlush3: fromRgb([0.804, 0.756, 0.772]),\n LavenderBlush4: fromRgb([0.545, 0.512, 0.525]),\n LemonChiffon1: fromRgb([1, 0.98, 0.804]),\n LemonChiffon2: fromRgb([0.932, 0.912, 0.75]),\n LemonChiffon3: fromRgb([0.804, 0.79, 0.648]),\n LemonChiffon4: fromRgb([0.545, 0.536, 0.44]),\n LightBlue1: fromRgb([0.75, 0.936, 1]),\n LightBlue2: fromRgb([0.698, 0.875, 0.932]),\n LightBlue3: fromRgb([0.604, 0.752, 0.804]),\n LightBlue4: fromRgb([0.408, 0.512, 0.545]),\n LightCyan1: fromRgb([0.88, 1, 1]),\n LightCyan2: fromRgb([0.82, 0.932, 0.932]),\n LightCyan3: fromRgb([0.705, 0.804, 0.804]),\n LightCyan4: fromRgb([0.48, 0.545, 0.545]),\n LightGoldenrod1: fromRgb([1, 0.925, 0.545]),\n LightGoldenrod2: fromRgb([0.932, 0.864, 0.51]),\n LightGoldenrod3: fromRgb([0.804, 0.745, 0.44]),\n LightGoldenrod4: fromRgb([0.545, 0.505, 0.298]),\n LightPink1: fromRgb([1, 0.684, 0.725]),\n LightPink2: fromRgb([0.932, 0.635, 0.68]),\n LightPink3: fromRgb([0.804, 0.55, 0.585]),\n LightPink4: fromRgb([0.545, 0.372, 0.396]),\n LightSalmon1: fromRgb([1, 0.628, 0.48]),\n LightSalmon2: fromRgb([0.932, 0.585, 0.448]),\n LightSalmon3: fromRgb([0.804, 0.505, 0.385]),\n LightSalmon4: fromRgb([0.545, 0.34, 0.26]),\n LightSkyBlue1: fromRgb([0.69, 0.888, 1]),\n LightSkyBlue2: fromRgb([0.644, 0.828, 0.932]),\n LightSkyBlue3: fromRgb([0.552, 0.712, 0.804]),\n LightSkyBlue4: fromRgb([0.376, 0.484, 0.545]),\n LightSteelBlue1: fromRgb([0.792, 0.884, 1]),\n LightSteelBlue2: fromRgb([0.736, 0.824, 0.932]),\n LightSteelBlue3: fromRgb([0.635, 0.71, 0.804]),\n LightSteelBlue4: fromRgb([0.43, 0.484, 0.545]),\n LightYellow1: fromRgb([1, 1, 0.88]),\n LightYellow2: fromRgb([0.932, 0.932, 0.82]),\n LightYellow3: fromRgb([0.804, 0.804, 0.705]),\n LightYellow4: fromRgb([0.545, 0.545, 0.48]),\n Magenta1: fromRgb([1, 0, 1]),\n Magenta2: fromRgb([0.932, 0, 0.932]),\n Magenta3: fromRgb([0.804, 0, 0.804]),\n Magenta4: fromRgb([0.545, 0, 0.545]),\n Maroon1: fromRgb([1, 0.204, 0.7]),\n Maroon2: fromRgb([0.932, 0.19, 0.655]),\n Maroon3: fromRgb([0.804, 0.16, 0.565]),\n Maroon4: fromRgb([0.545, 0.11, 0.385]),\n MediumOrchid1: fromRgb([0.88, 0.4, 1]),\n MediumOrchid2: fromRgb([0.82, 0.372, 0.932]),\n MediumOrchid3: fromRgb([0.705, 0.32, 0.804]),\n MediumOrchid4: fromRgb([0.48, 0.215, 0.545]),\n MediumPurple1: fromRgb([0.67, 0.51, 1]),\n MediumPurple2: fromRgb([0.624, 0.475, 0.932]),\n MediumPurple3: fromRgb([0.536, 0.408, 0.804]),\n MediumPurple4: fromRgb([0.365, 0.28, 0.545]),\n MistyRose1: fromRgb([1, 0.894, 0.884]),\n MistyRose2: fromRgb([0.932, 0.835, 0.824]),\n MistyRose3: fromRgb([0.804, 0.716, 0.71]),\n MistyRose4: fromRgb([0.545, 0.49, 0.484]),\n NavajoWhite1: fromRgb([1, 0.87, 0.68]),\n NavajoWhite2: fromRgb([0.932, 0.81, 0.63]),\n NavajoWhite3: fromRgb([0.804, 0.7, 0.545]),\n NavajoWhite4: fromRgb([0.545, 0.475, 0.37]),\n OliveDrab1: fromRgb([0.752, 1, 0.244]),\n OliveDrab2: fromRgb([0.7, 0.932, 0.228]),\n OliveDrab3: fromRgb([0.604, 0.804, 0.196]),\n OliveDrab4: fromRgb([0.41, 0.545, 0.132]),\n Orange1: fromRgb([1, 0.648, 0]),\n Orange2: fromRgb([0.932, 0.604, 0]),\n Orange3: fromRgb([0.804, 0.52, 0]),\n Orange4: fromRgb([0.545, 0.352, 0]),\n OrangeRed1: fromRgb([1, 0.27, 0]),\n OrangeRed2: fromRgb([0.932, 0.25, 0]),\n OrangeRed3: fromRgb([0.804, 0.215, 0]),\n OrangeRed4: fromRgb([0.545, 0.145, 0]),\n Orchid1: fromRgb([1, 0.512, 0.98]),\n Orchid2: fromRgb([0.932, 0.48, 0.912]),\n Orchid3: fromRgb([0.804, 0.41, 0.79]),\n Orchid4: fromRgb([0.545, 0.28, 0.536]),\n PaleGreen1: fromRgb([0.604, 1, 0.604]),\n PaleGreen2: fromRgb([0.565, 0.932, 0.565]),\n PaleGreen3: fromRgb([0.488, 0.804, 0.488]),\n PaleGreen4: fromRgb([0.33, 0.545, 0.33]),\n PaleTurquoise1: fromRgb([0.732, 1, 1]),\n PaleTurquoise2: fromRgb([0.684, 0.932, 0.932]),\n PaleTurquoise3: fromRgb([0.59, 0.804, 0.804]),\n PaleTurquoise4: fromRgb([0.4, 0.545, 0.545]),\n PaleVioletRed1: fromRgb([1, 0.51, 0.67]),\n PaleVioletRed2: fromRgb([0.932, 0.475, 0.624]),\n PaleVioletRed3: fromRgb([0.804, 0.408, 0.536]),\n PaleVioletRed4: fromRgb([0.545, 0.28, 0.365]),\n PeachPuff1: fromRgb([1, 0.855, 0.725]),\n PeachPuff2: fromRgb([0.932, 0.796, 0.68]),\n PeachPuff3: fromRgb([0.804, 0.688, 0.585]),\n PeachPuff4: fromRgb([0.545, 0.468, 0.396]),\n Pink1: fromRgb([1, 0.71, 0.772]),\n Pink2: fromRgb([0.932, 0.664, 0.72]),\n Pink3: fromRgb([0.804, 0.57, 0.62]),\n Pink4: fromRgb([0.545, 0.39, 0.424]),\n Plum1: fromRgb([1, 0.732, 1]),\n Plum2: fromRgb([0.932, 0.684, 0.932]),\n Plum3: fromRgb([0.804, 0.59, 0.804]),\n Plum4: fromRgb([0.545, 0.4, 0.545]),\n Purple1: fromRgb([0.608, 0.19, 1]),\n Purple2: fromRgb([0.57, 0.172, 0.932]),\n Purple3: fromRgb([0.49, 0.15, 0.804]),\n Purple4: fromRgb([0.332, 0.1, 0.545]),\n Red1: fromRgb([1, 0, 0]),\n Red2: fromRgb([0.932, 0, 0]),\n Red3: fromRgb([0.804, 0, 0]),\n Red4: fromRgb([0.545, 0, 0]),\n RosyBrown1: fromRgb([1, 0.756, 0.756]),\n RosyBrown2: fromRgb([0.932, 0.705, 0.705]),\n RosyBrown3: fromRgb([0.804, 0.608, 0.608]),\n RosyBrown4: fromRgb([0.545, 0.41, 0.41]),\n RoyalBlue1: fromRgb([0.284, 0.464, 1]),\n RoyalBlue2: fromRgb([0.264, 0.43, 0.932]),\n RoyalBlue3: fromRgb([0.228, 0.372, 0.804]),\n RoyalBlue4: fromRgb([0.152, 0.25, 0.545]),\n Salmon1: fromRgb([1, 0.55, 0.41]),\n Salmon2: fromRgb([0.932, 0.51, 0.385]),\n Salmon3: fromRgb([0.804, 0.44, 0.33]),\n Salmon4: fromRgb([0.545, 0.298, 0.224]),\n SeaGreen1: fromRgb([0.33, 1, 0.624]),\n SeaGreen2: fromRgb([0.305, 0.932, 0.58]),\n SeaGreen3: fromRgb([0.264, 0.804, 0.5]),\n SeaGreen4: fromRgb([0.18, 0.545, 0.34]),\n Seashell1: fromRgb([1, 0.96, 0.932]),\n Seashell2: fromRgb([0.932, 0.898, 0.87]),\n Seashell3: fromRgb([0.804, 0.772, 0.75]),\n Seashell4: fromRgb([0.545, 0.525, 0.51]),\n Sienna1: fromRgb([1, 0.51, 0.28]),\n Sienna2: fromRgb([0.932, 0.475, 0.26]),\n Sienna3: fromRgb([0.804, 0.408, 0.224]),\n Sienna4: fromRgb([0.545, 0.28, 0.15]),\n SkyBlue1: fromRgb([0.53, 0.808, 1]),\n SkyBlue2: fromRgb([0.494, 0.752, 0.932]),\n SkyBlue3: fromRgb([0.424, 0.65, 0.804]),\n SkyBlue4: fromRgb([0.29, 0.44, 0.545]),\n SlateBlue1: fromRgb([0.512, 0.435, 1]),\n SlateBlue2: fromRgb([0.48, 0.404, 0.932]),\n SlateBlue3: fromRgb([0.41, 0.35, 0.804]),\n SlateBlue4: fromRgb([0.28, 0.235, 0.545]),\n SlateGray1: fromRgb([0.776, 0.888, 1]),\n SlateGray2: fromRgb([0.725, 0.828, 0.932]),\n SlateGray3: fromRgb([0.624, 0.712, 0.804]),\n SlateGray4: fromRgb([0.424, 0.484, 0.545]),\n Snow1: fromRgb([1, 0.98, 0.98]),\n Snow2: fromRgb([0.932, 0.912, 0.912]),\n Snow3: fromRgb([0.804, 0.79, 0.79]),\n Snow4: fromRgb([0.545, 0.536, 0.536]),\n SpringGreen1: fromRgb([0, 1, 0.498]),\n SpringGreen2: fromRgb([0, 0.932, 0.464]),\n SpringGreen3: fromRgb([0, 0.804, 0.4]),\n SpringGreen4: fromRgb([0, 0.545, 0.27]),\n SteelBlue1: fromRgb([0.39, 0.72, 1]),\n SteelBlue2: fromRgb([0.36, 0.675, 0.932]),\n SteelBlue3: fromRgb([0.31, 0.58, 0.804]),\n SteelBlue4: fromRgb([0.21, 0.392, 0.545]),\n Tan1: fromRgb([1, 0.648, 0.31]),\n Tan2: fromRgb([0.932, 0.604, 0.288]),\n Tan3: fromRgb([0.804, 0.52, 0.248]),\n Tan4: fromRgb([0.545, 0.352, 0.17]),\n Thistle1: fromRgb([1, 0.884, 1]),\n Thistle2: fromRgb([0.932, 0.824, 0.932]),\n Thistle3: fromRgb([0.804, 0.71, 0.804]),\n Thistle4: fromRgb([0.545, 0.484, 0.545]),\n Tomato1: fromRgb([1, 0.39, 0.28]),\n Tomato2: fromRgb([0.932, 0.36, 0.26]),\n Tomato3: fromRgb([0.804, 0.31, 0.224]),\n Tomato4: fromRgb([0.545, 0.21, 0.15]),\n Turquoise1: fromRgb([0, 0.96, 1]),\n Turquoise2: fromRgb([0, 0.898, 0.932]),\n Turquoise3: fromRgb([0, 0.772, 0.804]),\n Turquoise4: fromRgb([0, 0.525, 0.545]),\n VioletRed1: fromRgb([1, 0.244, 0.59]),\n VioletRed2: fromRgb([0.932, 0.228, 0.55]),\n VioletRed3: fromRgb([0.804, 0.196, 0.47]),\n VioletRed4: fromRgb([0.545, 0.132, 0.32]),\n Wheat1: fromRgb([1, 0.905, 0.73]),\n Wheat2: fromRgb([0.932, 0.848, 0.684]),\n Wheat3: fromRgb([0.804, 0.73, 0.59]),\n Wheat4: fromRgb([0.545, 0.494, 0.4]),\n Yellow1: fromRgb([1, 1, 0]),\n Yellow2: fromRgb([0.932, 0.932, 0]),\n Yellow3: fromRgb([0.804, 0.804, 0]),\n Yellow4: fromRgb([0.545, 0.545, 0]),\n Gray0: fromRgb([0.745, 0.745, 0.745]),\n Green0: fromRgb([0, 1, 0]),\n Grey0: fromRgb([0.745, 0.745, 0.745]),\n Maroon0: fromRgb([0.69, 0.19, 0.376]),\n Purple0: fromRgb([0.628, 0.125, 0.94]),\n};\n", "import { XColorPegParser } from \"@unified-latex/unified-latex-util-pegjs\";\nimport * as XColorSpec from \"./types\";\n\nconst parseCache: Record = {};\n\n/**\n * Parse an `xparse` argument specification string to an AST.\n * This function caches results. Don't mutate the returned AST!\n *\n * @param {string} [str=\"\"] - LaTeX string input\n * @returns - AST for LaTeX string\n */\nexport function parse(str = \"\"): XColorSpec.Ast {\n parseCache[str] =\n parseCache[str] || (XColorPegParser.parse(str) as XColorSpec.Ast);\n return parseCache[str];\n}\n", "import * as Ast from \"@unified-latex/unified-latex-types\";\nimport { getArgsContent } from \"@unified-latex/unified-latex-util-arguments\";\nimport { printRaw } from \"@unified-latex/unified-latex-util-print-raw\";\nimport { xcolorColorToHex } from \"./xcolor\";\nimport { structuredClone } from \"@unified-latex/structured-clone\";\nimport { deleteComments } from \"@unified-latex/unified-latex-util-comments\";\n\n/**\n * Compute the hex representation of a color specified by an xcolor color command.\n * For example `\\color[rgb]{1 .5 .5}` or `\\textcolor{red}{foo}`. If the color cannot be parsed,\n * `null` is returned for the hex value. In all cases a css variable name (prefixed with \"--\"\")\n * is returned. This can be used to set up CSS for custom colors.\n */\nexport function xcolorMacroToHex(node: Ast.Macro): {\n hex: string | null;\n cssVarName: string;\n} {\n // We do some destructive operations on the node, so clone it first.\n node = structuredClone(node);\n deleteComments(node);\n\n // We assume the node has signature \"o m\" where o is the model and\n // m is the color spec.\n\n const args = getArgsContent(node);\n const model = args[0] && printRaw(args[0]);\n const colorStr = printRaw(args[1] || []);\n let hex: string | null = null;\n try {\n hex = xcolorColorToHex(colorStr, model);\n } catch (e) {}\n\n const cssVarName = \"--\" + colorStr.replace(/[^a-zA-Z0-9-_]/g, \"-\");\n\n return { hex, cssVarName };\n}\n", "import { arg } from \"@unified-latex/unified-latex-builder\";\nimport * as Ast from \"@unified-latex/unified-latex-types\";\n\n/**\n * Create a `\\textcolor` macro. Color arguments are taken from `origMacro`.\n */\nexport function colorToTextcolorMacro(\n content: Ast.Node | Ast.Node[],\n origMacro: Ast.Macro\n): Ast.Macro {\n if (!Array.isArray(content)) {\n content = [content];\n }\n // Signature of \\color is \"o m\".\n // We want to carry through the same arguments\n const args = (\n origMacro.args\n ? origMacro.args\n : [arg([], { closeMark: \"\", openMark: \"\" }), arg([])]\n ).concat(arg(content));\n\n return {\n type: \"macro\",\n content: \"textcolor\",\n args,\n _renderInfo: { inParMode: true },\n };\n}", "import { MacroInfoRecord, EnvInfoRecord } from \"@unified-latex/unified-latex-types\";\n\nexport const macros: MacroInfoRecord = {\n NewDocumentCommand: {\n signature: \"m m m\",\n renderInfo: { breakAround: true },\n },\n RenewDocumentCommand: {\n signature: \"m m m\",\n renderInfo: { breakAround: true },\n },\n ProvideDocumentCommand: {\n signature: \"m m m\",\n renderInfo: { breakAround: true },\n },\n DeclareDocumentCommand: {\n signature: \"m m m\",\n renderInfo: { breakAround: true },\n },\n NewDocumentEnvironment: {\n signature: \"m m m m\",\n renderInfo: { breakAround: true },\n },\n RenewDocumentEnvironment: {\n signature: \"m m m m\",\n renderInfo: { breakAround: true },\n },\n ProvideDocumentEnvironment: {\n signature: \"m m m m\",\n renderInfo: { breakAround: true },\n },\n DeclareDocumentEnvironment: {\n signature: \"m m m m\",\n renderInfo: { breakAround: true },\n },\n NewExpandableDocumentCommand: {\n signature: \"m m m\",\n renderInfo: { breakAround: true },\n },\n RenewExpandableDocumentCommand: {\n signature: \"m m m\",\n renderInfo: { breakAround: true },\n },\n ProvideExpandableDocumentCommand: {\n signature: \"m m m\",\n renderInfo: { breakAround: true },\n },\n DeclareExpandableDocumentCommand: {\n signature: \"m m m\",\n renderInfo: { breakAround: true },\n },\n RequirePackage: {\n signature: \"o m\",\n renderInfo: { pgfkeysArgs: true, breakAround: true },\n },\n DeclareOption: { signature: \"m m\", renderInfo: { breakAround: true } },\n};\n\nexport const environments: EnvInfoRecord = {};\n", "import {\n MacroInfoRecord,\n EnvInfoRecord,\n} from \"@unified-latex/unified-latex-types\";\n\nexport const macros: MacroInfoRecord = {\n mode: { signature: \"s d<> d{}\", renderInfo: { breakAround: true } },\n insertnavigation: { signature: \"m\", renderInfo: { breakAround: true } },\n insertsectionnavigation: {\n signature: \"m\",\n renderInfo: { breakAround: true },\n },\n insertsectionnavigationhorizontal: {\n signature: \"m m m\",\n renderInfo: { breakAround: true },\n },\n insertauthor: { signature: \"o\", renderInfo: { breakAround: true } },\n insertshortauthor: { signature: \"o\", renderInfo: { breakAround: true } },\n insertshortdate: { signature: \"o\", renderInfo: { breakAround: true } },\n insertshortinstitute: { signature: \"o\", renderInfo: { breakAround: true } },\n insertshortpart: { signature: \"o\", renderInfo: { breakAround: true } },\n insertshorttitle: { signature: \"o\", renderInfo: { breakAround: true } },\n insertsubsectionnavigation: {\n signature: \"m\",\n renderInfo: { breakAround: true },\n },\n insertsubsectionnavigationhorizontal: {\n signature: \"m m m\",\n renderInfo: { breakAround: true },\n },\n insertverticalnavigation: {\n signature: \"m\",\n renderInfo: { breakAround: true },\n },\n usebeamercolor: { signature: \"s m\", renderInfo: { breakAround: true } },\n usebeamertemplate: { signature: \"s m\", renderInfo: { breakAround: true } },\n setbeamercolor: {\n signature: \"m m\",\n renderInfo: { breakAround: true, pgfkeysArgs: true },\n },\n setbeamersize: {\n signature: \"m o o\",\n renderInfo: { breakAround: true, pgfkeysArgs: true },\n },\n setbeamertemplate: {\n signature: \"m o o d{}\",\n renderInfo: { breakAround: true, pgfkeysArgs: true },\n },\n\n newcommand: {\n signature: \"s d<> +m o +o +m\",\n renderInfo: {\n breakAround: true,\n namedArguments: [\n \"starred\",\n null,\n \"name\",\n \"numArgs\",\n \"default\",\n \"body\",\n ],\n },\n },\n renewcommand: {\n signature: \"s d<> +m o +o +m\",\n renderInfo: {\n breakAround: true,\n namedArguments: [\n \"starred\",\n null,\n \"name\",\n \"numArgs\",\n \"default\",\n \"body\",\n ],\n },\n },\n newenvironment: {\n signature: \"s d<> m o o m m\",\n renderInfo: { breakAround: true },\n },\n renewenvironment: {\n signature: \"s d<> m o o m m\",\n renderInfo: { breakAround: true },\n },\n resetcounteronoverlays: {\n signature: \"m\",\n renderInfo: { breakAround: true },\n },\n resetcountonoverlays: { signature: \"m\", renderInfo: { breakAround: true } },\n\n logo: { signature: \"m\", renderInfo: { breakAround: true } },\n frametitle: { signature: \"d<> o m\", renderInfo: { breakAround: true } },\n framesubtitle: { signature: \"d<> m\", renderInfo: { breakAround: true } },\n pause: { signature: \"o\" },\n onslide: { signature: \"t+ t* d<> d{}\" },\n only: { signature: \"d<> m d<>\" },\n uncover: { signature: \"d<> m\" },\n visible: { signature: \"d<> m\" },\n invisible: { signature: \"d<> m\" },\n alt: { signature: \"d<> m m d<>\" },\n temporal: { signature: \"r<> m m m\" },\n item: {\n signature: \"d<> o d<>\",\n renderInfo: {\n hangingIndent: true,\n namedArguments: [null, \"label\", null],\n },\n },\n label: { signature: \"d<> o m\" }, // cleveref adds an optional argument to label; this gives maximum compatibility.\n action: { signature: \"d<> m\" },\n beamerdefaultoverlayspecification: { signature: \"m\" },\n\n titlegraphic: { signature: \"m\", renderInfo: { breakAround: true } },\n subject: { signature: \"m\", renderInfo: { breakAround: true } },\n keywords: { signature: \"m\", renderInfo: { breakAround: true } },\n\n lecture: { signature: \"o m m\", renderInfo: { breakAround: true } },\n partpage: { renderInfo: { breakAround: true } },\n sectionpage: { renderInfo: { breakAround: true } },\n subsectionpage: { renderInfo: { breakAround: true } },\n AtBeginLecture: { signature: \"m\", renderInfo: { breakAround: true } },\n AtBeginPart: { signature: \"m\", renderInfo: { breakAround: true } },\n tableofcontents: {\n signature: \"o\",\n renderInfo: { breakAround: true, pgfkeysArgs: true },\n },\n againframe: { signature: \"d<> o o m\", renderInfo: { breakAround: true } },\n framezoom: {\n signature: \"r<> r<> o r() r()\",\n renderInfo: { breakAround: true },\n },\n column: { signature: \"d<> o m\", renderInfo: { breakAround: true } },\n\n animate: { signature: \"r<>\", renderInfo: { breakAround: true } },\n animatevalue: { signature: \"r<> m m m\", renderInfo: { breakAround: true } },\n sound: {\n signature: \"o m m\",\n renderInfo: { breakAround: true, pgfkeysArgs: true },\n },\n hyperlinksound: {\n signature: \"o m m\",\n renderInfo: { breakAround: true, pgfkeysArgs: true },\n },\n hyperlinkmute: { signature: \"m\", renderInfo: { breakAround: true } },\n\n // These signatures conflict with the default signatures.\n // Care must be taken when processing an AST.\n section: {\n signature: \"s d<> o m\",\n renderInfo: {\n breakAround: true,\n namedArguments: [\"starred\", null, \"tocTitle\", \"title\"],\n },\n },\n subsection: {\n signature: \"s d<> o m\",\n renderInfo: {\n breakAround: true,\n namedArguments: [\"starred\", null, \"tocTitle\", \"title\"],\n },\n },\n subsubsection: {\n signature: \"s d<> o m\",\n renderInfo: {\n breakAround: true,\n namedArguments: [\"starred\", null, \"tocTitle\", \"title\"],\n },\n },\n part: {\n signature: \"s d<> o m\",\n renderInfo: {\n breakAround: true,\n namedArguments: [\"starred\", null, \"tocTitle\", \"title\"],\n },\n },\n bibitem: {\n signature: \"s d<> o m\",\n renderInfo: {\n hangingIndent: true,\n namedArguments: [\"starred\", null, \"tocTitle\", \"title\"],\n },\n },\n};\n\nexport const environments: EnvInfoRecord = {\n frame: {\n signature: \"!d<> !o !o !d{} !d{}\",\n },\n block: {\n signature: \"!d<> !d{} !d<>\",\n },\n alertblock: {\n signature: \"!d<> !d{} !d<>\",\n },\n exampleblock: {\n signature: \"!d<> !d{} !d<>\",\n },\n onlyenv: {\n signature: \"!d<>\",\n },\n altenv: {\n signature: \"!d<> m m m m !d<>\",\n },\n overlayarea: { signature: \"m m\" },\n overprint: { signature: \"o\" },\n actionenv: { signature: \"!d<>\" },\n columns: { signature: \"d<> o\" },\n column: { signature: \"d<> o m\" },\n};\n", "import {\n MacroInfoRecord,\n EnvInfoRecord,\n} from \"@unified-latex/unified-latex-types\";\n\nexport const macros: MacroInfoRecord = {\n columnbreak: { renderInfo: { breakAround: true } },\n};\n\nexport const environments: EnvInfoRecord = {\n multicols: {\n signature: \"m o o\",\n },\n \"multicols*\": {\n signature: \"m o o\",\n },\n};\n", "import * as cleveref from \"./package/cleveref\";\nimport * as exam from \"./package/exam\";\nimport * as geometry from \"./package/geometry\";\nimport * as hyperref from \"./package/hyperref\";\nimport * as latex2e from \"./package/latex2e\";\nimport * as listings from \"./package/listings\";\nimport * as makeidx from \"./package/makeidx\";\nimport * as mathtools from \"./package/mathtools\";\nimport * as minted from \"./package/minted\";\nimport * as nicematrix from \"./package/nicematrix\";\nimport * as systeme from \"./package/systeme\";\nimport * as tikz from \"./package/tikz\";\nimport * as xcolor from \"./package/xcolor\";\nimport * as xparse from \"./package/xparse\";\nimport * as beamer from \"./package/beamer\";\nimport * as multicol from \"./package/multicol\";\n\n/**\n * Info about the macros for available ctan packages. `latex2e` contains\n * the standard macros for LaTeX.\n */\nexport const macroInfo = {\n cleveref: cleveref.macros,\n exam: exam.macros,\n geometry: geometry.macros,\n hyperref: hyperref.macros,\n latex2e: latex2e.macros,\n listings: listings.macros,\n makeidx: makeidx.macros,\n mathtools: mathtools.macros,\n minted: minted.macros,\n nicematrix: nicematrix.macros,\n systeme: systeme.macros,\n tikz: tikz.macros,\n xcolor: xcolor.macros,\n xparse: xparse.macros,\n beamer: beamer.macros,\n multicol: multicol.macros,\n};\n\n/**\n * Info about the environments for available ctan packages. `latex2e` contains\n * the standard environments for LaTeX.\n */\nexport const environmentInfo = {\n cleveref: cleveref.environments,\n exam: exam.environments,\n geometry: geometry.environments,\n hyperref: hyperref.environments,\n latex2e: latex2e.environments,\n listings: listings.environments,\n makeidx: makeidx.environments,\n mathtools: mathtools.environments,\n minted: minted.environments,\n nicematrix: nicematrix.environments,\n systeme: systeme.environments,\n tikz: tikz.environments,\n xcolor: xcolor.environments,\n xparse: xparse.environments,\n beamer: beamer.environments,\n multicol: multicol.environments,\n};\n\n// NOTE: The docstring comment must be the last item in the index.ts file!\n/**\n * ## What is this?\n *\n * Macro/environment definitions and utilities for specific LaTeX packages from CTAN.\n *\n * Note: basic LaTeX macro/environment definitions come from the `latex2e` package, even though\n * this is technically not a CTAN \"package\".\n *\n * ## When should I use this?\n *\n * If you want information about special functions/macros from particular CTAN packages, or\n * you need to parse special environments.\n *\n * ## Notes\n *\n * By default all macros/environments that are exported get processed. If multiple packages\n * export a macro with the same name, then the later-exported one takes precedence. If two packages\n * export a macro/environment of the same name but with conflicting argument signatures, this can\n * cause issues when another unified-latex package processes arguments positionally. For example,\n * by default `\\textbf` takes one argument, but the beamer version of `\\textbf` takes two arguments.\n * During HTML conversion, if arguments are referenced positionally, this may cause previously-working\n * code to fail with when beamer macro signatures are used. A workaround is provided: `_renderInfo.namedArguments`.\n * If `_renderInfo.namedArguments` is specified on both the original macro/environment definition\n * **and** the conflicting one, other unified-latex commands can reference arguments by name instead\n * of by position.\n */\n", "import * as Ast from \"@unified-latex/unified-latex-types\";\nimport { EnvInfo, EnvInfoRecord } from \"@unified-latex/unified-latex-types\";\nimport { updateRenderInfo } from \"@unified-latex/unified-latex-util-render-info\";\nimport { gobbleArguments } from \"@unified-latex/unified-latex-util-arguments\";\nimport { match } from \"@unified-latex/unified-latex-util-match\";\nimport { visit } from \"@unified-latex/unified-latex-util-visit\";\nimport { printRaw } from \"@unified-latex/unified-latex-util-print-raw\";\n\n/**\n * Performs any needed processing on the environment (as specified by `envInfo`)\n * including attaching arguments and possibly manipulating the environment's body.\n */\nexport function processEnvironment(envNode: Ast.Environment, envInfo: EnvInfo) {\n if (envInfo.signature && envNode.args == null) {\n const { args } = gobbleArguments(envNode.content, envInfo.signature);\n envNode.args = args;\n }\n\n updateRenderInfo(envNode, envInfo.renderInfo);\n if (typeof envInfo.processContent === \"function\") {\n envNode.content = envInfo.processContent(envNode.content);\n }\n}\n\n/**\n * Recursively search for and process the specified environments. Arguments are\n * consumed according to the `signature` specified. The body is processed\n * with the specified `processContent` function (if given). Any specified `renderInfo`\n * is attached to the environment node.\n */\nexport function processEnvironments(\n tree: Ast.Ast,\n environments: EnvInfoRecord\n) {\n const isRelevantEnvironment = match.createEnvironmentMatcher(environments);\n\n visit(\n tree,\n {\n leave: (node) => {\n const envName = printRaw(node.env);\n const envInfo = environments[envName];\n if (!envInfo) {\n throw new Error(\n `Could not find environment info for environment \"${envName}\"`\n );\n }\n processEnvironment(node, envInfo);\n },\n },\n { test: isRelevantEnvironment }\n );\n}\n", "import * as Ast from \"@unified-latex/unified-latex-types\";\nimport { EnvInfoRecord } from \"@unified-latex/unified-latex-types\";\nimport { Plugin } from \"unified\";\nimport { visit } from \"@unified-latex/unified-latex-util-visit\";\nimport { match } from \"@unified-latex/unified-latex-util-match\";\nimport { processEnvironment } from \"./process-environment\";\nimport { printRaw } from \"@unified-latex/unified-latex-util-print-raw\";\n\ntype PluginOptions = { environments: EnvInfoRecord } | undefined;\n\n/**\n * Unified plugin to process environment content and attach arguments.\n *\n * @param environments An object whose keys are environment names and values contains information about the environment and its argument signature.\n */\nexport const unifiedLatexProcessEnvironments: Plugin<\n PluginOptions[],\n Ast.Root,\n Ast.Root\n> = function unifiedLatexAttachMacroArguments(options) {\n const { environments = {} } = options || {};\n const isRelevantEnvironment = match.createEnvironmentMatcher(environments);\n\n return (tree) => {\n if (Object.keys(environments).length === 0) {\n console.warn(\n \"Attempting to attach macro arguments but no macros are specified.\"\n );\n }\n\n visit(\n tree,\n {\n leave: (node) => {\n const envName = printRaw(node.env);\n const envInfo = environments[envName];\n if (!envInfo) {\n throw new Error(\n `Could not find environment info for environment \"${envName}\"`\n );\n }\n processEnvironment(node, envInfo);\n },\n },\n { test: isRelevantEnvironment }\n );\n };\n};\n", "import * as Ast from \"@unified-latex/unified-latex-types\";\nimport { Region } from \"./regions\";\n\n/**\n * Find all contiguous segments in the array that are between start and end blocks.\n * The `start` and `end` are functions that determine when a region starts and ends.\n */\nexport function findRegionInArray(\n tree: Ast.Node[],\n start: (node: Ast.Node) => boolean,\n end: (node: Ast.Node) => boolean\n): Region[] {\n const ret: Region[] = [];\n let currRegion: Region = { start: undefined as any, end: tree.length };\n for (let i = 0; i < tree.length; i++) {\n const node = tree[i];\n if (start(node)) {\n currRegion.start = i;\n }\n if (end(node)) {\n currRegion.end = i + 1;\n ret.push(currRegion);\n currRegion = { start: undefined as any, end: tree.length };\n }\n }\n\n if (currRegion.start != null) {\n // Regions don't necessarily have to encounter an `end` to end.\n ret.push(currRegion);\n }\n return ret;\n}\n", "import * as Ast from \"@unified-latex/unified-latex-types\";\nimport { match } from \"@unified-latex/unified-latex-util-match\";\nimport { findRegionInArray } from \"./find-region\";\nimport { refineRegions, Region, splitByRegions } from \"./regions\";\nimport { SKIP, visit } from \"@unified-latex/unified-latex-util-visit\";\nimport { reparseMacroNames } from \"./reparse-macro-names\";\n\nconst expl3Find = {\n start: match.createMacroMatcher([\"ExplSyntaxOn\"]),\n end: match.createMacroMatcher([\"ExplSyntaxOff\"]),\n};\nconst atLetterFind = {\n start: match.createMacroMatcher([\"makeatletter\"]),\n end: match.createMacroMatcher([\"makeatother\"]),\n};\n\n/**\n * Find regions between `\\ExplSyntaxOn...\\ExplSyntaxOff` and `\\makeatletter...\\makeatother`.\n * Returns an object containing regions where one or both syntax's apply.\n */\nexport function findExpl3AndAtLetterRegionsInArray(tree: Ast.Node[]): {\n explOnly: Region[];\n atLetterOnly: Region[];\n both: Region[];\n} {\n const expl3 = findRegionInArray(tree, expl3Find.start, expl3Find.end);\n const atLetter = findRegionInArray(\n tree,\n atLetterFind.start,\n atLetterFind.end\n );\n\n const regionMap = new Map([\n ...(expl3.map((x) => [x, \"expl\"]) as [Region, \"expl\"][]),\n ...(atLetter.map((x) => [x, \"atLetter\"]) as [Region, \"atLetter\"][]),\n ]);\n const all = refineRegions([...expl3, ...atLetter]);\n\n const ret = {\n explOnly: [] as Region[],\n atLetterOnly: [] as Region[],\n both: [] as Region[],\n };\n\n for (let i = 0; i < all.regions.length; i++) {\n const region = all.regions[i];\n const containedIn = all.regionsContainedIn[i];\n if (containedIn.size === 2) {\n ret.both.push(region);\n continue;\n }\n for (const v of containedIn.values()) {\n if (regionMap.get(v) === \"expl\") {\n ret.explOnly.push(region);\n }\n if (regionMap.get(v) === \"atLetter\") {\n ret.atLetterOnly.push(region);\n }\n }\n }\n\n // Regions of size 1 only contain the starting/stopping macro, so they should be discarded\n ret.explOnly = ret.explOnly.filter((r) => r.end - r.start > 1);\n ret.atLetterOnly = ret.atLetterOnly.filter((r) => r.end - r.start > 1);\n ret.both = ret.both.filter((r) => r.end - r.start > 1);\n\n return ret;\n}\n\nconst atLetterSet = new Set([\"@\"]);\nconst explSet = new Set([\"_\", \":\"]);\nconst bothSet = new Set([\"_\", \":\", \"@\"]);\n\n/**\n * Find regions between `\\ExplSyntaxOn...\\ExplSyntaxOff` and `\\makeatletter...\\makeatother`\n * and reparse their contents so that the relevant characters (e.g., `@`, `_`, and `:`) become\n * part of the macro names.\n */\nexport function reparseExpl3AndAtLetterRegions(tree: Ast.Ast) {\n visit(\n tree,\n {\n leave: (nodes) => {\n const regions = findExpl3AndAtLetterRegionsInArray(nodes);\n // In all likelihood, we don't need to do any reparsing, so bail early here\n const totalNumRegions =\n regions.both.length +\n regions.atLetterOnly.length +\n regions.explOnly.length;\n if (totalNumRegions === 0) {\n return;\n }\n\n const splits = splitByRegions(nodes, regions);\n const processed: typeof nodes = [];\n for (const [key, slice] of splits) {\n switch (key) {\n case null:\n processed.push(...slice);\n continue;\n case \"atLetterOnly\":\n reparseMacroNames(slice, atLetterSet);\n processed.push(...slice);\n continue;\n case \"explOnly\":\n reparseMacroNames(slice, explSet);\n processed.push(...slice);\n continue;\n case \"both\":\n reparseMacroNames(slice, bothSet);\n processed.push(...slice);\n continue;\n default:\n throw new Error(\n `Unexpected case when splitting ${key}`\n );\n }\n }\n\n nodes.length = 0;\n nodes.push(...processed);\n return SKIP;\n },\n },\n { includeArrays: true, test: Array.isArray }\n );\n}\n", "import * as Ast from \"@unified-latex/unified-latex-types\";\n\nexport type Region = { start: number; end: number };\n\n/**\n * Given `regions`, a list of `Region`s (not necessarily ordered, possibly overlapping), return a list of in-order,\n * non-overlapping regions and a corresponding list containing a set of the original `Region`s that the new region\n * is a subset of.\n */\nexport function refineRegions(regions: Region[]): {\n regions: Region[];\n regionsContainedIn: Set[];\n} {\n const _regions = [...regions];\n _regions.sort((a, b) => a.start - b.start);\n const cutPointsSet = new Set(_regions.flatMap((r) => [r.start, r.end]));\n const cutPoints = Array.from(cutPointsSet);\n cutPoints.sort((a, b) => a - b);\n\n const retRegions: Region[] = [];\n const retRegionsContainedIn: Set[] = [];\n\n // We will be checking what regions we are completely contained in.\n // Because `_regions` is sorted by start, `seekIndex` will be incremented\n // by end, so that we don't do too much array testing.\n let seekIndex = 0;\n for (let i = 0; i < cutPoints.length - 1; i++) {\n const start = cutPoints[i];\n const end = cutPoints[i + 1];\n const region = { start, end };\n const regionContainedIn: Set = new Set();\n\n let encounteredEndPastStart = false;\n for (let j = seekIndex; j < _regions.length; j++) {\n const superRegion = _regions[j];\n if (superRegion.end >= region.start) {\n encounteredEndPastStart = true;\n }\n if (!encounteredEndPastStart && superRegion.end < region.start) {\n // In this case, the region (and all regions that came before)\n // end before the region we are testing, so we may safely skip past it\n // from here on out.\n seekIndex = j + 1;\n continue;\n }\n\n if (superRegion.start > end) {\n // Because `_regions` is sorted, we can stop here\n break;\n }\n if (\n superRegion.start <= region.start &&\n superRegion.end >= region.end\n ) {\n encounteredEndPastStart = true;\n regionContainedIn.add(superRegion);\n }\n }\n\n if (regionContainedIn.size > 0) {\n // We only count if we are contained in a subregion\n retRegions.push(region);\n retRegionsContainedIn.push(regionContainedIn);\n }\n }\n\n return { regions: retRegions, regionsContainedIn: retRegionsContainedIn };\n}\n\n/**\n * Split an array up into the disjoint regions specified by `regionRecord`.\n * Returned is a list of tuples, the first item being the key of `regionRecord` if there\n * was a corresponding region, or `null` if there was no corresponding region.\n *\n * This function assumes that the regions in `regionRecord` are disjoint and fully contained\n * within the bounds of `array`.\n */\nexport function splitByRegions<\n T extends unknown,\n RegionRecord extends Record\n>(array: T[], regionsRecord: RegionRecord) {\n const ret: [keyof RegionRecord | null, T[]][] = [];\n\n const indices = [0, array.length];\n const reverseMap: Record = {};\n for (const [key, records] of Object.entries(regionsRecord)) {\n indices.push(\n ...records.flatMap((r) => {\n reverseMap[\"\" + [r.start, r.end]] = key;\n return [r.start, r.end];\n })\n );\n }\n indices.sort((a, b) => a - b);\n\n for (let i = 0; i < indices.length - 1; i++) {\n const start = indices[i];\n const end = indices[i + 1];\n if (start === end) {\n continue;\n }\n const regionKey = reverseMap[\"\" + [start, end]];\n\n ret.push([regionKey || null, array.slice(start, end)]);\n }\n\n return ret;\n}\n", "import * as Ast from \"@unified-latex/unified-latex-types\";\nimport { match } from \"@unified-latex/unified-latex-util-match\";\nimport { EXIT, visit } from \"@unified-latex/unified-latex-util-visit\";\n\n/**\n * Escape a string so that it can be used to build a regular expression.\n *\n * From: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions\n */\nfunction escapeRegExp(str: string) {\n return str.replace(/[.*+?^${}()|[\\]\\\\]/g, \"\\\\$&\"); // $& means the whole matched string\n}\n\n/**\n * Build a regular expression that matches everything up to the first non-allowed symbol.\n */\nfunction buildWordRegex(allowedSet: Set): RegExp {\n // /\\p{L}/ matches all letters, including unicode letters. We join this with\n // everything allowed in our set to form a regexp like\n // /(\\p{L}|_|:)*/u\n // The `u` at the end allows unicode characters to be matched.\n const regexpStr = `^(${[\"\\\\p{L}\"]\n .concat(Array.from(allowedSet).map(escapeRegExp))\n .join(\"|\")})*`;\n return new RegExp(regexpStr, \"u\");\n}\n\n/**\n * Checks whether the array has a macro that could be reparsed given the `allowedTokens` but\n * do not do any reparsing. This function can be used in auto-detection schemes to determine if\n * macro names should actually be reparsed.\n */\nexport function hasReparsableMacroNamesInArray(\n tree: Ast.Node[],\n allowedTokens: Set\n): boolean {\n for (let i = 0; i < tree.length; i++) {\n const macro = tree[i];\n const string = tree[i + 1];\n if (match.anyMacro(macro) && match.anyString(string)) {\n // There are two options. Either the macro ends with the special character,\n // e.g. `\\@foo` or the special character starts the next string, e.g. `\\foo@`.\n if (\n allowedTokens.has(\n macro.content.charAt(macro.content.length - 1)\n ) ||\n allowedTokens.has(string.content.charAt(0))\n ) {\n return true;\n }\n }\n }\n return false;\n}\n\n/**\n * Checks whether `tree` has a macro that could be reparsed given the `allowedTokens` but\n * do not do any reparsing. This function can be used in auto-detection schemes to determine if\n * macro names should actually be reparsed.\n */\nexport function hasReparsableMacroNames(\n tree: Ast.Ast,\n allowedTokens: string | Set\n): boolean {\n if (typeof allowedTokens === \"string\") {\n allowedTokens = new Set(allowedTokens.split(\"\"));\n }\n // Recast so typescript doesn't complain\n const _allowedTokens = allowedTokens;\n for (const v of _allowedTokens) {\n if (v.length > 1) {\n throw new Error(\n `Only single characters are allowed as \\`allowedTokens\\` when reparsing macro names, not \\`${v}\\`.`\n );\n }\n }\n\n let ret = false;\n visit(\n tree,\n (nodes) => {\n if (hasReparsableMacroNamesInArray(nodes, _allowedTokens)) {\n ret = true;\n return EXIT;\n }\n },\n { includeArrays: true, test: Array.isArray }\n );\n return ret;\n}\n\n/**\n * Reparses all macro names in the array so that they may optionally include characters listed in `allowedTokens`.\n * This is used, for example, when parsing expl3 syntax which allows `_` to be used in a macro name (even though\n * `_` is normally stops the parsing for a macro name).\n */\nexport function reparseMacroNamesInArray(\n tree: Ast.Node[],\n allowedTokens: Set\n) {\n const regex = buildWordRegex(allowedTokens);\n let i = 0;\n while (i < tree.length) {\n const macro = tree[i];\n const string = tree[i + 1];\n if (\n match.anyMacro(macro) &&\n // The _^ macros in math mode should not be extended no-matter what;\n // So we check to make sure that the macro we're dealing with has the default escape token.\n (macro.escapeToken == null || macro.escapeToken === \"\\\\\") &&\n match.anyString(string) &&\n // There are two options. Either the macro ends with the special character,\n // e.g. `\\@foo` or the special character starts the next string, e.g. `\\foo@`.\n (allowedTokens.has(\n macro.content.charAt(macro.content.length - 1)\n ) ||\n allowedTokens.has(string.content.charAt(0)))\n ) {\n // There might be a number somewhere in the string. If so, we should\n // break the string apart at that number\n const match = string.content.match(regex);\n const takeable = match ? match[0] : \"\";\n if (takeable.length > 0) {\n if (takeable.length === string.content.length) {\n // The whole string can be appended to the macro name\n macro.content += string.content;\n tree.splice(i + 1, 1);\n\n // Preserve the source location if available\n if (macro.position && string.position?.end) {\n macro.position.end = string.position.end;\n }\n } else {\n // Only part of the string can be appended to the macro name\n macro.content += takeable;\n string.content = string.content.slice(takeable.length);\n\n // Preserve the source location if available\n if (macro.position?.end) {\n macro.position.end.offset += takeable.length;\n macro.position.end.column += takeable.length;\n }\n if (string.position?.start) {\n string.position.start.offset += takeable.length;\n string.position.start.column += takeable.length;\n }\n }\n } else {\n i++;\n }\n } else {\n ++i;\n }\n }\n}\n\n/**\n * Reparses all macro names so that they may optionally include characters listed in `allowedTokens`.\n * This is used, for example, when parsing expl3 syntax which allows `_` to be used in a macro name (even though\n * `_` is normally stops the parsing for a macro name). Thus, a macro `\\foo_bar:Nn` would be parsed as having\n * the name `foo_bar:Nn` rather than as `foo` followed by the strings `_`, `bar`, `:`, `Nn`.\n */\nexport function reparseMacroNames(\n tree: Ast.Ast,\n allowedTokens: string | Set\n) {\n if (typeof allowedTokens === \"string\") {\n allowedTokens = new Set(allowedTokens.split(\"\"));\n }\n // Recast so typescript doesn't complain\n const _allowedTokens = allowedTokens;\n for (const v of _allowedTokens) {\n if (v.length > 1) {\n throw new Error(\n `Only single characters are allowed as \\`allowedTokens\\` when reparsing macro names, not \\`${v}\\`.`\n );\n }\n }\n\n visit(\n tree,\n (nodes) => {\n reparseMacroNamesInArray(nodes, _allowedTokens);\n },\n { includeArrays: true, test: Array.isArray }\n );\n}\n", "import { Plugin } from \"unified\";\nimport * as Ast from \"@unified-latex/unified-latex-types\";\n\n/**\n * Unified complier plugin that passes through a LaTeX AST without modification.\n */\nexport const unifiedLatexAstComplier: Plugin =\n function unifiedLatexAstComplier() {\n Object.assign(this, { Compiler: (x: Ast.Root) => x });\n };\n", "import { Plugin, Parser, unified } from \"unified\";\nimport { environmentInfo, macroInfo } from \"@unified-latex/unified-latex-ctan\";\nimport * as Ast from \"@unified-latex/unified-latex-types\";\nimport {\n EnvInfoRecord,\n MacroInfoRecord,\n} from \"@unified-latex/unified-latex-types\";\nimport {\n unifiedLatexTrimEnvironmentContents,\n unifiedLatexTrimRoot,\n} from \"@unified-latex/unified-latex-util-trim\";\nimport { unifiedLatexAstComplier } from \"./compiler-ast\";\nimport { unifiedLatexFromStringMinimal } from \"./plugin-from-string-minimal\";\nimport { unifiedLatexProcessMacrosAndEnvironmentsWithMathReparse } from \"./process-macros-and-environments\";\nimport { unifiedLatexProcessAtLetterAndExplMacros } from \"./process-at-letter-and-expl-macros\";\n\nexport type PluginOptions =\n | {\n mode?: \"math\" | \"regular\";\n macros?: MacroInfoRecord;\n environments?: EnvInfoRecord;\n flags?: {\n /**\n * Whether to parse macros as if `\\makeatletter` is set (i.e., parse `@` as a regular macro character)\n */\n atLetter?: boolean;\n /**\n * Whether to parse macros as if `\\ExplSyntaxOn` is set (i.e., parse `_` and `:` as a regular macro character)\n */\n expl3?: boolean;\n /**\n * Attempt to autodetect whether there are macros that look like they should contain `@`, `_`, or `:`.\n * Defaults to `false`.\n */\n autodetectExpl3AndAtLetter?: boolean;\n };\n }\n | undefined;\n\n/**\n * Parse a string to a LaTeX AST.\n */\nexport const unifiedLatexFromString: Plugin =\n function unifiedLatexFromString(options) {\n const {\n mode = \"regular\",\n macros = {},\n environments = {},\n flags: {\n atLetter = false,\n expl3 = false,\n autodetectExpl3AndAtLetter = false,\n } = {},\n } = options || {};\n\n // Build up a parsing plugin with only unified components\n const allMacroInfo: MacroInfoRecord = Object.assign(\n {},\n ...Object.values(macroInfo),\n macros\n );\n const allEnvInfo: EnvInfoRecord = Object.assign(\n {},\n ...Object.values(environmentInfo),\n environments\n );\n\n // Build up a parser that will perform all the needed steps\n const fullParser = unified()\n .use(unifiedLatexFromStringMinimal, { mode })\n .use(unifiedLatexProcessAtLetterAndExplMacros, {\n atLetter,\n expl3,\n autodetectExpl3AndAtLetter,\n })\n // Math environments that aren't hardcoded into the PEG grammar need to be re-parsed,\n // so do a minimal pass first with just those environments.\n .use(unifiedLatexProcessMacrosAndEnvironmentsWithMathReparse, {\n macros: allMacroInfo,\n environments: allEnvInfo,\n })\n .use(unifiedLatexTrimEnvironmentContents)\n .use(unifiedLatexTrimRoot)\n .use(unifiedLatexAstComplier);\n\n const parser: Parser = (str) => {\n const file = fullParser.processSync({ value: str });\n return file.result;\n };\n\n Object.assign(this, { Parser: parser });\n };\n", "import { LatexPegParser } from \"@unified-latex/unified-latex-util-pegjs\";\nimport * as Ast from \"@unified-latex/unified-latex-types\";\n\n/**\n * Parse `str` to an AST with minimal processing. E.g., macro\n * arguments are not attached to macros, etc. when parsed with this\n * function.\n */\nexport function parseMinimal(str: string): Ast.Root {\n return LatexPegParser.parse(str);\n}\n\n/**\n * Parse `str` to an AST with minimal processing. E.g., macro\n * arguments are not attached to macros, etc. when parsed with this\n * function.\n *\n * The parsing assumes a math-mode context, so, for example, `^` and `_` are\n * parsed as macros (even though arguments are not attached to them).\n */\nexport function parseMathMinimal(str: string): Ast.Node[] {\n return LatexPegParser.parse(str, { startRule: \"math\" });\n}\n", "import { Plugin, Parser } from \"unified\";\nimport * as Ast from \"@unified-latex/unified-latex-types\";\nimport { parseMathMinimal, parseMinimal } from \"./parse-minimal\";\n\ntype PluginOptions = {\n /**\n * Whether the text will be parsed assuming math mode or not.\n */\n mode: \"math\" | \"regular\";\n} | void;\n\n/**\n * Parse a string to a LaTeX AST with no post processing. For example,\n * no macro arguments will be attached, etc.\n */\nexport const unifiedLatexFromStringMinimal: Plugin<\n PluginOptions[],\n string,\n Ast.Root\n> = function unifiedLatexFromStringMinimal(options) {\n const parser: Parser = (str) => {\n if (options?.mode === \"math\") {\n return {\n type: \"root\",\n content: parseMathMinimal(str),\n _renderInfo: { inMathMode: true },\n };\n }\n return parseMinimal(str);\n };\n\n Object.assign(this, { Parser: parser });\n};\n", "import * as Ast from \"@unified-latex/unified-latex-types\";\nimport { EnvInfoRecord, MacroInfoRecord } from \"@unified-latex/unified-latex-types\";\nimport { Plugin } from \"unified\";\nimport { visit } from \"@unified-latex/unified-latex-util-visit\";\nimport { match } from \"@unified-latex/unified-latex-util-match\";\nimport { printRaw } from \"@unified-latex/unified-latex-util-print-raw\";\nimport {\n unifiedLatexReparseMathConstructPlugin,\n} from \"./reparse-math\";\nimport { attachMacroArgsInArray } from \"@unified-latex/unified-latex-util-arguments\";\nimport { processEnvironment } from \"@unified-latex/unified-latex-util-environments\";\n\ntype PluginOptions =\n | { environments: EnvInfoRecord; macros: MacroInfoRecord }\n | undefined;\n\n/**\n * Unified plugin to process macros and environments. Any environments that contain math content\n * are reparsed (if needed) in math mode.\n */\nexport const unifiedLatexProcessMacrosAndEnvironmentsWithMathReparse: Plugin<\n PluginOptions[],\n Ast.Root,\n Ast.Root\n> = function unifiedLatexProcessMacrosAndEnvironmentsWithMathReparse(options) {\n const { environments = {}, macros = {} } = options || {};\n\n const mathMacros = Object.fromEntries(\n Object.entries(macros).filter(\n ([_, info]) => info.renderInfo?.inMathMode === true\n )\n );\n const mathEnvs = Object.fromEntries(\n Object.entries(environments).filter(\n ([_, info]) => info.renderInfo?.inMathMode === true\n )\n );\n\n const mathReparser = unifiedLatexReparseMathConstructPlugin({\n mathEnvs: Object.keys(mathEnvs),\n mathMacros: Object.keys(mathMacros),\n });\n\n const isRelevantEnvironment = match.createEnvironmentMatcher(environments);\n const isRelevantMathEnvironment = match.createEnvironmentMatcher(mathEnvs);\n\n return (tree) => {\n // First we attach all arguments/process all nodes/environments that have math content\n visit(\n tree,\n {\n enter: (nodes) => {\n if (!Array.isArray(nodes)) {\n return;\n }\n attachMacroArgsInArray(nodes, mathMacros);\n },\n leave: (node) => {\n if (!isRelevantMathEnvironment(node)) {\n return;\n }\n const envName = printRaw(node.env);\n const envInfo = environments[envName];\n if (!envInfo) {\n throw new Error(\n `Could not find environment info for environment \"${envName}\"`\n );\n }\n processEnvironment(node, envInfo);\n },\n },\n { includeArrays: true }\n );\n\n // Next we reparse macros/envs that may not have been parsed in math mode\n mathReparser(tree);\n\n // Now we attach all arguments/process all environment bodies\n visit(\n tree,\n {\n enter: (nodes) => {\n if (!Array.isArray(nodes)) {\n return;\n }\n attachMacroArgsInArray(nodes, macros);\n },\n leave: (node) => {\n if (!isRelevantEnvironment(node)) {\n return;\n }\n const envName = printRaw(node.env);\n const envInfo = environments[envName];\n if (!envInfo) {\n throw new Error(\n `Could not find environment info for environment \"${envName}\"`\n );\n }\n processEnvironment(node, envInfo);\n },\n },\n { includeArrays: true }\n );\n };\n};\n", "import { Plugin } from \"unified\";\nimport * as Ast from \"@unified-latex/unified-latex-types\";\nimport { match } from \"@unified-latex/unified-latex-util-match\";\nimport { printRaw } from \"@unified-latex/unified-latex-util-print-raw\";\nimport { visit } from \"@unified-latex/unified-latex-util-visit\";\nimport { parseMathMinimal } from \"./parse-minimal\";\n\ntype PluginOptions =\n | {\n /**\n * List of environments whose body should be parsed in math mode\n */\n mathEnvs: string[];\n /**\n * List of macros whose bodies should be parsed in math mode\n */\n mathMacros: string[];\n }\n | undefined;\n\n/**\n * Reparse math environments/macro contents that should have been parsed in math mode but weren't.\n */\nexport const unifiedLatexReparseMath: Plugin<\n PluginOptions[],\n Ast.Root,\n Ast.Root\n> = function unifiedLatexReparseMath(options) {\n const { mathEnvs = [], mathMacros = [] } = options || {};\n\n return unifiedLatexReparseMathConstructPlugin({ mathMacros, mathEnvs });\n};\n\n/**\n * Construct the inner function for the `unifiedLatexReparseMath` plugin. This function should not be used by libraries.\n */\nexport function unifiedLatexReparseMathConstructPlugin({\n mathEnvs,\n mathMacros,\n}: {\n mathEnvs: string[];\n mathMacros: string[];\n}) {\n const isMathEnvironment = match.createEnvironmentMatcher(mathEnvs);\n const isMathMacro = match.createMacroMatcher(mathMacros);\n\n return (tree: Ast.Root) => {\n visit(\n tree,\n (node) => {\n if (match.anyMacro(node)) {\n for (const arg of node.args || []) {\n if (\n arg.content.length > 0 &&\n !wasParsedInMathMode(arg.content)\n ) {\n arg.content = parseMathMinimal(\n printRaw(arg.content)\n );\n }\n }\n }\n if (match.anyEnvironment(node)) {\n if (!wasParsedInMathMode(node.content)) {\n node.content = parseMathMinimal(printRaw(node.content));\n }\n }\n },\n {\n test: (node) => isMathEnvironment(node) || isMathMacro(node),\n }\n );\n };\n}\n\n/**\n * Use a heuristic to decide whether a string was parsed in math mode. The heuristic\n * looks for strings of length greater than 1 or the failure for \"_\" and \"^\" to be parsed\n * as a macro.\n */\nfunction wasParsedInMathMode(nodes: Ast.Node[]): boolean {\n return !nodes.some(\n (node) =>\n // If there are multi-char strings or ^ and _ have been parsed as strings, we know\n // that we were not parsed in math mode.\n (match.anyString(node) && node.content.length > 1) ||\n match.string(node, \"^\") ||\n match.string(node, \"_\")\n );\n}\n", "import * as Ast from \"@unified-latex/unified-latex-types\";\nimport { Plugin } from \"unified\";\nimport { reparseExpl3AndAtLetterRegions } from \"@unified-latex/unified-latex-util-catcode\";\nimport {\n hasReparsableMacroNames,\n reparseMacroNames,\n} from \"@unified-latex/unified-latex-util-catcode\";\n\ntype PluginOptions =\n | {\n /**\n * Whether to parse macros as if `\\makeatletter` is set (i.e., parse `@` as a regular macro character).\n * If this option is true, it disables autodetect.\n */\n atLetter?: boolean;\n /**\n * Whether to parse macros as if `\\ExplSyntaxOn` is set (i.e., parse `_` and `:` as a regular macro character)\n * If this option is true, it disables autodetect.\n */\n expl3?: boolean;\n /**\n * Attempt to autodetect whether there are macros that look like they should contain `@`, `_`, or `:`.\n * Defaults to `true`.\n */\n autodetectExpl3AndAtLetter?: boolean;\n }\n | undefined;\n\n/**\n * Unified plugin to reprocess macros names to possibly include `@`, `_`, or `:`.\n * This plugin detects the `\\makeatletter` and `\\ExplSyntaxOn` commands and reprocesses macro names\n * inside of those blocks to include those characters.\n */\nexport const unifiedLatexProcessAtLetterAndExplMacros: Plugin<\n PluginOptions[],\n Ast.Root,\n Ast.Root\n> = function unifiedLatexProcessAtLetterAndExplMacros(options) {\n let {\n atLetter = false,\n expl3 = false,\n autodetectExpl3AndAtLetter = false,\n } = options || {};\n\n return (tree) => {\n // First we reparse based on explicit \\makeatletter and \\ExplSyntaxOn macros\n reparseExpl3AndAtLetterRegions(tree);\n if (atLetter || expl3) {\n autodetectExpl3AndAtLetter = false;\n }\n if (autodetectExpl3AndAtLetter) {\n atLetter = hasReparsableMacroNames(tree, \"@\");\n // We don't check for the `:` here because it could be prone to misidentification.\n expl3 = hasReparsableMacroNames(tree, \"_\");\n }\n const charSet: Set = new Set();\n if (atLetter) {\n charSet.add(\"@\");\n }\n if (expl3) {\n charSet.add(\":\");\n charSet.add(\"_\");\n }\n\n if (charSet.size > 0) {\n reparseMacroNames(tree, charSet);\n }\n };\n};\n", "import * as Ast from \"@unified-latex/unified-latex-types\";\nimport { type FrozenProcessor, unified } from \"unified\";\nimport { unifiedLatexFromString } from \"./plugin-from-string\";\nimport type { PluginOptions } from \"./plugin-from-string\";\n\nlet parser = unified().use(unifiedLatexFromString).freeze();\n\n/**\n * Parse the string into an AST.\n */\nexport function parse(str: string): Ast.Root {\n return parser.parse(str);\n}\n\n/**\n * Returns the default `unified-latex` parser, or create a new one with the\n * provided `unifiedLatexFromString` options\n * @param options Plugin options of `unifiedLatexFromString` plugin.\n * @returns The default `unified-latex` parser if `options` is `undefined`, or a\n * newly created `unified-latex` parser with the provided `options`.\n */\nexport function getParser(\n options?: PluginOptions\n): FrozenProcessor {\n return options\n ? unified().use(unifiedLatexFromString, options).freeze()\n : parser;\n}\n", "import { unified } from \"unified\";\nimport * as Ast from \"@unified-latex/unified-latex-types\";\nimport { printRaw } from \"@unified-latex/unified-latex-util-print-raw\";\nimport { unifiedLatexAstComplier } from \"./compiler-ast\";\nimport { unifiedLatexFromString } from \"./plugin-from-string\";\n\n/**\n * Parse `str` into an AST. Parsing starts in math mode and a list of\n * nodes is returned (instead of a \"root\" node).\n */\nexport function parseMath(str: string | Ast.Ast): Ast.Node[] {\n if (typeof str !== \"string\") {\n str = printRaw(str);\n }\n const file = unified()\n .use(unifiedLatexFromString, { mode: \"math\" })\n .use(unifiedLatexAstComplier)\n .processSync({ value: str });\n return (file.result as Ast.Root).content;\n}\n", "import type { Plugin, Printer } from \"prettier\";\nimport * as Ast from \"@unified-latex/unified-latex-types\";\nimport { parse } from \"@unified-latex/unified-latex-util-parse\";\nimport { printLatexAst } from \"./printer\";\n\nconst languages = [\n {\n name: \"latex\",\n extensions: [\".tex\"],\n parsers: [\"latex-parser\"],\n },\n];\n\nconst parsers = {\n \"latex-parser\": {\n parse,\n astFormat: \"latex-ast\",\n locStart: (node: Ast.Node) =>\n node.position ? node.position.start.offset : 0,\n locEnd: (node: Ast.Node) =>\n node.position ? node.position.end.offset : 1,\n },\n};\n\nconst printers = {\n \"latex-ast\": {\n print: printLatexAst,\n } as Printer,\n};\n\nconst prettierPluginLatex: Plugin = { languages, parsers, printers };\n\nexport { prettierPluginLatex };\n"], + "mappings": "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", + "names": ["module", "module", "index", "module", "module", "module", "index", "module", "pushInOrder", "module", "module", "permute", "module", "reducer", "input", "module", "isBuffer", "module", "isArray", "isPlainObject", "setProperty", "getProperty", "extend", "clone", "module", "module", "module", "swizzle", "arg", "module", "string", "match", "s", "module", "s", "string", "match", "module", "path", "module", "module", "Color", "keys", "__defProp", "__export", "index", "group2", "indent2", "lineSuffix2", "whitespace", "macros", "macro", "group", "ESCAPE", "softline", "group", "fill", "ifBreak", "line", "hardline", "lineSuffix", "lineSuffixBoundary", "breakParent", "indent", "markAsRoot", "join", "path", "ESCAPE", "arg", "indent", "fill", "group", "index", "result", "key", "trim", "unifiedLatexTrimEnvironmentContents", "match", "unifiedLatexTrimRoot", "s", "line", "expected", "found", "x", "macro", "comment", "location", "text", "options", "at", "braces", "args", "argument", "arg", "macros", "match", "macro", "macroInfo", "createMatchers", "parse", "createMatchers", "hardline", "join", "breakParent", "line", "group", "indent", "softline", "path", "trim", "parse", "printer", "group", "indent", "line", "softline", "comment", "hardline", "join", "path", "content", "trim", "hardline", "fill", "path", "fill", "path", "_print", "path", "hardline", "fill", "ESCAPE", "indent", "createMatchers", "path", "hardline", "indent", "fill", "nodes", "trim", "path", "hardline", "ESCAPE", "line", "import_is_buffer", "index", "point", "position", "index", "join", "path", "index", "path", "index", "buffer", "index", "prop", "path", "dirname", "assertPath", "basename", "extname", "parse", "index", "extend", "value", "options", "file", "isBuffer", "import_color", "macros", "trim", "environments", "match", "arg", "argSpecM", "parseArgspec", "argSpecO", "argSpecRDelim", "argumentParser", "gobbleSingleArgument", "OPTIONAL_ARGUMENT_ARG_SPEC", "tikzCommandArgumentParser", "colonPos", "createMatchers", "matchers", "Color", "s", "macro", "string", "match", "visit", "unifiedLatexAstComplier", "unifiedLatexFromStringMinimal", "parser", "arg", "unifiedLatexProcessMacrosAndEnvironmentsWithMathReparse", "environments", "macros", "match", "visit", "printRaw", "unifiedLatexProcessAtLetterAndExplMacros", "unifiedLatexFromString", "unified", "parse", "parse"] +} diff --git a/node_modules/@unified-latex/unified-latex-prettier/index.d.ts b/node_modules/@unified-latex/unified-latex-prettier/index.d.ts new file mode 100644 index 0000000..d65a638 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-prettier/index.d.ts @@ -0,0 +1,14 @@ +export * from "./libs/printer"; +export * from "./libs/prettier-plugin-latex"; +/** + * ## What is this? + * + * A [Prettier](https://prettier.io/) plugin for formatting and pretty-printing LaTeX source code. + * + * ## When should I use this? + * + * If you want to construct a `Prettier` instance that has LaTeX parsing abilities. + * + * You should probably use the `prettier-plugin-latex` package instead of directly accessing this package. + */ +//# sourceMappingURL=index.d.ts.map \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-prettier/index.d.ts.map b/node_modules/@unified-latex/unified-latex-prettier/index.d.ts.map new file mode 100644 index 0000000..61909db --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-prettier/index.d.ts.map @@ -0,0 +1 @@ +{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../index.ts"],"names":[],"mappings":"AAAA,cAAc,gBAAgB,CAAC;AAC/B,cAAc,8BAA8B,CAAC;AAG7C;;;;;;;;;;GAUG"} \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-prettier/index.js b/node_modules/@unified-latex/unified-latex-prettier/index.js new file mode 100644 index 0000000..9bfcba8 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-prettier/index.js @@ -0,0 +1,2377 @@ +var __accessCheck = (obj, member, msg) => { + if (!member.has(obj)) + throw TypeError("Cannot " + msg); +}; +var __privateGet = (obj, member, getter) => { + __accessCheck(obj, member, "read from private field"); + return getter ? getter.call(obj) : member.get(obj); +}; +var __privateAdd = (obj, member, value) => { + if (member.has(obj)) + throw TypeError("Cannot add the same private member more than once"); + member instanceof WeakSet ? member.add(obj) : member.set(obj, value); +}; +var __privateSet = (obj, member, value, setter) => { + __accessCheck(obj, member, "write to private field"); + setter ? setter.call(obj, value) : member.set(obj, value); + return value; +}; + +// node_modules/prettier/doc.mjs +var __defProp = Object.defineProperty; +var __export = (target, all) => { + for (var name in all) + __defProp(target, name, { get: all[name], enumerable: true }); +}; +var public_exports = {}; +__export(public_exports, { + builders: () => builders, + printer: () => printer, + utils: () => utils +}); +var DOC_TYPE_STRING = "string"; +var DOC_TYPE_ARRAY = "array"; +var DOC_TYPE_CURSOR = "cursor"; +var DOC_TYPE_INDENT = "indent"; +var DOC_TYPE_ALIGN = "align"; +var DOC_TYPE_TRIM = "trim"; +var DOC_TYPE_GROUP = "group"; +var DOC_TYPE_FILL = "fill"; +var DOC_TYPE_IF_BREAK = "if-break"; +var DOC_TYPE_INDENT_IF_BREAK = "indent-if-break"; +var DOC_TYPE_LINE_SUFFIX = "line-suffix"; +var DOC_TYPE_LINE_SUFFIX_BOUNDARY = "line-suffix-boundary"; +var DOC_TYPE_LINE = "line"; +var DOC_TYPE_LABEL = "label"; +var DOC_TYPE_BREAK_PARENT = "break-parent"; +var VALID_OBJECT_DOC_TYPES = /* @__PURE__ */ new Set([ + DOC_TYPE_CURSOR, + DOC_TYPE_INDENT, + DOC_TYPE_ALIGN, + DOC_TYPE_TRIM, + DOC_TYPE_GROUP, + DOC_TYPE_FILL, + DOC_TYPE_IF_BREAK, + DOC_TYPE_INDENT_IF_BREAK, + DOC_TYPE_LINE_SUFFIX, + DOC_TYPE_LINE_SUFFIX_BOUNDARY, + DOC_TYPE_LINE, + DOC_TYPE_LABEL, + DOC_TYPE_BREAK_PARENT +]); +function getDocType(doc) { + if (typeof doc === "string") { + return DOC_TYPE_STRING; + } + if (Array.isArray(doc)) { + return DOC_TYPE_ARRAY; + } + if (!doc) { + return; + } + const { type } = doc; + if (VALID_OBJECT_DOC_TYPES.has(type)) { + return type; + } +} +var get_doc_type_default = getDocType; +var disjunctionListFormat = (list) => new Intl.ListFormat("en-US", { type: "disjunction" }).format(list); +function getDocErrorMessage(doc) { + const type = doc === null ? "null" : typeof doc; + if (type !== "string" && type !== "object") { + return `Unexpected doc '${type}', +Expected it to be 'string' or 'object'.`; + } + if (get_doc_type_default(doc)) { + throw new Error("doc is valid."); + } + const objectType = Object.prototype.toString.call(doc); + if (objectType !== "[object Object]") { + return `Unexpected doc '${objectType}'.`; + } + const EXPECTED_TYPE_VALUES = disjunctionListFormat( + [...VALID_OBJECT_DOC_TYPES].map((type2) => `'${type2}'`) + ); + return `Unexpected doc.type '${doc.type}'. +Expected it to be ${EXPECTED_TYPE_VALUES}.`; +} +var InvalidDocError = class extends Error { + name = "InvalidDocError"; + constructor(doc) { + super(getDocErrorMessage(doc)); + this.doc = doc; + } +}; +var invalid_doc_error_default = InvalidDocError; +var traverseDocOnExitStackMarker = {}; +function traverseDoc(doc, onEnter, onExit, shouldTraverseConditionalGroups) { + const docsStack = [doc]; + while (docsStack.length > 0) { + const doc2 = docsStack.pop(); + if (doc2 === traverseDocOnExitStackMarker) { + onExit(docsStack.pop()); + continue; + } + if (onExit) { + docsStack.push(doc2, traverseDocOnExitStackMarker); + } + const docType = get_doc_type_default(doc2); + if (!docType) { + throw new invalid_doc_error_default(doc2); + } + if ((onEnter == null ? void 0 : onEnter(doc2)) === false) { + continue; + } + switch (docType) { + case DOC_TYPE_ARRAY: + case DOC_TYPE_FILL: { + const parts = docType === DOC_TYPE_ARRAY ? doc2 : doc2.parts; + for (let ic = parts.length, i = ic - 1; i >= 0; --i) { + docsStack.push(parts[i]); + } + break; + } + case DOC_TYPE_IF_BREAK: + docsStack.push(doc2.flatContents, doc2.breakContents); + break; + case DOC_TYPE_GROUP: + if (shouldTraverseConditionalGroups && doc2.expandedStates) { + for (let ic = doc2.expandedStates.length, i = ic - 1; i >= 0; --i) { + docsStack.push(doc2.expandedStates[i]); + } + } else { + docsStack.push(doc2.contents); + } + break; + case DOC_TYPE_ALIGN: + case DOC_TYPE_INDENT: + case DOC_TYPE_INDENT_IF_BREAK: + case DOC_TYPE_LABEL: + case DOC_TYPE_LINE_SUFFIX: + docsStack.push(doc2.contents); + break; + case DOC_TYPE_STRING: + case DOC_TYPE_CURSOR: + case DOC_TYPE_TRIM: + case DOC_TYPE_LINE_SUFFIX_BOUNDARY: + case DOC_TYPE_LINE: + case DOC_TYPE_BREAK_PARENT: + break; + default: + throw new invalid_doc_error_default(doc2); + } + } +} +var traverse_doc_default = traverseDoc; +var noop = () => { +}; +var assertDoc = true ? noop : function(doc) { + traverse_doc_default(doc, (doc2) => { + if (checked.has(doc2)) { + return false; + } + if (typeof doc2 !== "string") { + checked.add(doc2); + } + }); +}; +var assertDocArray = true ? noop : function(docs, optional = false) { + if (optional && !docs) { + return; + } + if (!Array.isArray(docs)) { + throw new TypeError("Unexpected doc array."); + } + for (const doc of docs) { + assertDoc(doc); + } +}; +function indent(contents) { + assertDoc(contents); + return { type: DOC_TYPE_INDENT, contents }; +} +function align(widthOrString, contents) { + assertDoc(contents); + return { type: DOC_TYPE_ALIGN, contents, n: widthOrString }; +} +function group(contents, opts = {}) { + assertDoc(contents); + assertDocArray( + opts.expandedStates, + /* optional */ + true + ); + return { + type: DOC_TYPE_GROUP, + id: opts.id, + contents, + break: Boolean(opts.shouldBreak), + expandedStates: opts.expandedStates + }; +} +function dedentToRoot(contents) { + return align(Number.NEGATIVE_INFINITY, contents); +} +function markAsRoot(contents) { + return align({ type: "root" }, contents); +} +function dedent(contents) { + return align(-1, contents); +} +function conditionalGroup(states, opts) { + return group(states[0], { ...opts, expandedStates: states }); +} +function fill(parts) { + assertDocArray(parts); + return { type: DOC_TYPE_FILL, parts }; +} +function ifBreak(breakContents, flatContents = "", opts = {}) { + assertDoc(breakContents); + if (flatContents !== "") { + assertDoc(flatContents); + } + return { + type: DOC_TYPE_IF_BREAK, + breakContents, + flatContents, + groupId: opts.groupId + }; +} +function indentIfBreak(contents, opts) { + assertDoc(contents); + return { + type: DOC_TYPE_INDENT_IF_BREAK, + contents, + groupId: opts.groupId, + negate: opts.negate + }; +} +function lineSuffix(contents) { + assertDoc(contents); + return { type: DOC_TYPE_LINE_SUFFIX, contents }; +} +var lineSuffixBoundary = { type: DOC_TYPE_LINE_SUFFIX_BOUNDARY }; +var breakParent = { type: DOC_TYPE_BREAK_PARENT }; +var trim = { type: DOC_TYPE_TRIM }; +var hardlineWithoutBreakParent = { type: DOC_TYPE_LINE, hard: true }; +var literallineWithoutBreakParent = { + type: DOC_TYPE_LINE, + hard: true, + literal: true +}; +var line = { type: DOC_TYPE_LINE }; +var softline = { type: DOC_TYPE_LINE, soft: true }; +var hardline = [hardlineWithoutBreakParent, breakParent]; +var literalline = [literallineWithoutBreakParent, breakParent]; +var cursor = { type: DOC_TYPE_CURSOR }; +function join(separator, docs) { + assertDoc(separator); + assertDocArray(docs); + const parts = []; + for (let i = 0; i < docs.length; i++) { + if (i !== 0) { + parts.push(separator); + } + parts.push(docs[i]); + } + return parts; +} +function addAlignmentToDoc(doc, size, tabWidth) { + assertDoc(doc); + let aligned = doc; + if (size > 0) { + for (let i = 0; i < Math.floor(size / tabWidth); ++i) { + aligned = indent(aligned); + } + aligned = align(size % tabWidth, aligned); + aligned = align(Number.NEGATIVE_INFINITY, aligned); + } + return aligned; +} +function label(label2, contents) { + assertDoc(contents); + return label2 ? { type: DOC_TYPE_LABEL, label: label2, contents } : contents; +} +var at = (isOptionalObject, object, index) => { + if (isOptionalObject && (object === void 0 || object === null)) { + return; + } + if (Array.isArray(object) || typeof object === "string") { + return object[index < 0 ? object.length + index : index]; + } + return object.at(index); +}; +var at_default = at; +var stringReplaceAll = (isOptionalObject, original, pattern, replacement) => { + if (isOptionalObject && (original === void 0 || original === null)) { + return; + } + if (original.replaceAll) { + return original.replaceAll(pattern, replacement); + } + if (pattern.global) { + return original.replace(pattern, replacement); + } + return original.split(pattern).join(replacement); +}; +var string_replace_all_default = stringReplaceAll; +function convertEndOfLineToChars(value) { + switch (value) { + case "cr": + return "\r"; + case "crlf": + return "\r\n"; + default: + return "\n"; + } +} +var emoji_regex_default = () => { + return /[#*0-9]\uFE0F?\u20E3|[\xA9\xAE\u203C\u2049\u2122\u2139\u2194-\u2199\u21A9\u21AA\u231A\u231B\u2328\u23CF\u23ED-\u23EF\u23F1\u23F2\u23F8-\u23FA\u24C2\u25AA\u25AB\u25B6\u25C0\u25FB\u25FC\u25FE\u2600-\u2604\u260E\u2611\u2614\u2615\u2618\u2620\u2622\u2623\u2626\u262A\u262E\u262F\u2638-\u263A\u2640\u2642\u2648-\u2653\u265F\u2660\u2663\u2665\u2666\u2668\u267B\u267E\u267F\u2692\u2694-\u2697\u2699\u269B\u269C\u26A0\u26A7\u26AA\u26B0\u26B1\u26BD\u26BE\u26C4\u26C8\u26CF\u26D1\u26D3\u26E9\u26F0-\u26F5\u26F7\u26F8\u26FA\u2702\u2708\u2709\u270F\u2712\u2714\u2716\u271D\u2721\u2733\u2734\u2744\u2747\u2757\u2763\u27A1\u2934\u2935\u2B05-\u2B07\u2B1B\u2B1C\u2B55\u3030\u303D\u3297\u3299]\uFE0F?|[\u261D\u270C\u270D](?:\uFE0F|\uD83C[\uDFFB-\uDFFF])?|[\u270A\u270B](?:\uD83C[\uDFFB-\uDFFF])?|[\u23E9-\u23EC\u23F0\u23F3\u25FD\u2693\u26A1\u26AB\u26C5\u26CE\u26D4\u26EA\u26FD\u2705\u2728\u274C\u274E\u2753-\u2755\u2795-\u2797\u27B0\u27BF\u2B50]|\u26F9(?:\uFE0F|\uD83C[\uDFFB-\uDFFF])?(?:\u200D[\u2640\u2642]\uFE0F?)?|\u2764\uFE0F?(?:\u200D(?:\uD83D\uDD25|\uD83E\uDE79))?|\uD83C(?:[\uDC04\uDD70\uDD71\uDD7E\uDD7F\uDE02\uDE37\uDF21\uDF24-\uDF2C\uDF36\uDF7D\uDF96\uDF97\uDF99-\uDF9B\uDF9E\uDF9F\uDFCD\uDFCE\uDFD4-\uDFDF\uDFF5\uDFF7]\uFE0F?|[\uDF85\uDFC2\uDFC7](?:\uD83C[\uDFFB-\uDFFF])?|[\uDFC3\uDFC4\uDFCA](?:\uD83C[\uDFFB-\uDFFF])?(?:\u200D[\u2640\u2642]\uFE0F?)?|[\uDFCB\uDFCC](?:\uFE0F|\uD83C[\uDFFB-\uDFFF])?(?:\u200D[\u2640\u2642]\uFE0F?)?|[\uDCCF\uDD8E\uDD91-\uDD9A\uDE01\uDE1A\uDE2F\uDE32-\uDE36\uDE38-\uDE3A\uDE50\uDE51\uDF00-\uDF20\uDF2D-\uDF35\uDF37-\uDF7C\uDF7E-\uDF84\uDF86-\uDF93\uDFA0-\uDFC1\uDFC5\uDFC6\uDFC8\uDFC9\uDFCF-\uDFD3\uDFE0-\uDFF0\uDFF8-\uDFFF]|\uDDE6\uD83C[\uDDE8-\uDDEC\uDDEE\uDDF1\uDDF2\uDDF4\uDDF6-\uDDFA\uDDFC\uDDFD\uDDFF]|\uDDE7\uD83C[\uDDE6\uDDE7\uDDE9-\uDDEF\uDDF1-\uDDF4\uDDF6-\uDDF9\uDDFB\uDDFC\uDDFE\uDDFF]|\uDDE8\uD83C[\uDDE6\uDDE8\uDDE9\uDDEB-\uDDEE\uDDF0-\uDDF5\uDDF7\uDDFA-\uDDFF]|\uDDE9\uD83C[\uDDEA\uDDEC\uDDEF\uDDF0\uDDF2\uDDF4\uDDFF]|\uDDEA\uD83C[\uDDE6\uDDE8\uDDEA\uDDEC\uDDED\uDDF7-\uDDFA]|\uDDEB\uD83C[\uDDEE-\uDDF0\uDDF2\uDDF4\uDDF7]|\uDDEC\uD83C[\uDDE6\uDDE7\uDDE9-\uDDEE\uDDF1-\uDDF3\uDDF5-\uDDFA\uDDFC\uDDFE]|\uDDED\uD83C[\uDDF0\uDDF2\uDDF3\uDDF7\uDDF9\uDDFA]|\uDDEE\uD83C[\uDDE8-\uDDEA\uDDF1-\uDDF4\uDDF6-\uDDF9]|\uDDEF\uD83C[\uDDEA\uDDF2\uDDF4\uDDF5]|\uDDF0\uD83C[\uDDEA\uDDEC-\uDDEE\uDDF2\uDDF3\uDDF5\uDDF7\uDDFC\uDDFE\uDDFF]|\uDDF1\uD83C[\uDDE6-\uDDE8\uDDEE\uDDF0\uDDF7-\uDDFB\uDDFE]|\uDDF2\uD83C[\uDDE6\uDDE8-\uDDED\uDDF0-\uDDFF]|\uDDF3\uD83C[\uDDE6\uDDE8\uDDEA-\uDDEC\uDDEE\uDDF1\uDDF4\uDDF5\uDDF7\uDDFA\uDDFF]|\uDDF4\uD83C\uDDF2|\uDDF5\uD83C[\uDDE6\uDDEA-\uDDED\uDDF0-\uDDF3\uDDF7-\uDDF9\uDDFC\uDDFE]|\uDDF6\uD83C\uDDE6|\uDDF7\uD83C[\uDDEA\uDDF4\uDDF8\uDDFA\uDDFC]|\uDDF8\uD83C[\uDDE6-\uDDEA\uDDEC-\uDDF4\uDDF7-\uDDF9\uDDFB\uDDFD-\uDDFF]|\uDDF9\uD83C[\uDDE6\uDDE8\uDDE9\uDDEB-\uDDED\uDDEF-\uDDF4\uDDF7\uDDF9\uDDFB\uDDFC\uDDFF]|\uDDFA\uD83C[\uDDE6\uDDEC\uDDF2\uDDF3\uDDF8\uDDFE\uDDFF]|\uDDFB\uD83C[\uDDE6\uDDE8\uDDEA\uDDEC\uDDEE\uDDF3\uDDFA]|\uDDFC\uD83C[\uDDEB\uDDF8]|\uDDFD\uD83C\uDDF0|\uDDFE\uD83C[\uDDEA\uDDF9]|\uDDFF\uD83C[\uDDE6\uDDF2\uDDFC]|\uDFF3\uFE0F?(?:\u200D(?:\u26A7\uFE0F?|\uD83C\uDF08))?|\uDFF4(?:\u200D\u2620\uFE0F?|\uDB40\uDC67\uDB40\uDC62\uDB40(?:\uDC65\uDB40\uDC6E\uDB40\uDC67|\uDC73\uDB40\uDC63\uDB40\uDC74|\uDC77\uDB40\uDC6C\uDB40\uDC73)\uDB40\uDC7F)?)|\uD83D(?:[\uDC08\uDC26](?:\u200D\u2B1B)?|[\uDC3F\uDCFD\uDD49\uDD4A\uDD6F\uDD70\uDD73\uDD76-\uDD79\uDD87\uDD8A-\uDD8D\uDDA5\uDDA8\uDDB1\uDDB2\uDDBC\uDDC2-\uDDC4\uDDD1-\uDDD3\uDDDC-\uDDDE\uDDE1\uDDE3\uDDE8\uDDEF\uDDF3\uDDFA\uDECB\uDECD-\uDECF\uDEE0-\uDEE5\uDEE9\uDEF0\uDEF3]\uFE0F?|[\uDC42\uDC43\uDC46-\uDC50\uDC66\uDC67\uDC6B-\uDC6D\uDC72\uDC74-\uDC76\uDC78\uDC7C\uDC83\uDC85\uDC8F\uDC91\uDCAA\uDD7A\uDD95\uDD96\uDE4C\uDE4F\uDEC0\uDECC](?:\uD83C[\uDFFB-\uDFFF])?|[\uDC6E\uDC70\uDC71\uDC73\uDC77\uDC81\uDC82\uDC86\uDC87\uDE45-\uDE47\uDE4B\uDE4D\uDE4E\uDEA3\uDEB4-\uDEB6](?:\uD83C[\uDFFB-\uDFFF])?(?:\u200D[\u2640\u2642]\uFE0F?)?|[\uDD74\uDD90](?:\uFE0F|\uD83C[\uDFFB-\uDFFF])?|[\uDC00-\uDC07\uDC09-\uDC14\uDC16-\uDC25\uDC27-\uDC3A\uDC3C-\uDC3E\uDC40\uDC44\uDC45\uDC51-\uDC65\uDC6A\uDC79-\uDC7B\uDC7D-\uDC80\uDC84\uDC88-\uDC8E\uDC90\uDC92-\uDCA9\uDCAB-\uDCFC\uDCFF-\uDD3D\uDD4B-\uDD4E\uDD50-\uDD67\uDDA4\uDDFB-\uDE2D\uDE2F-\uDE34\uDE37-\uDE44\uDE48-\uDE4A\uDE80-\uDEA2\uDEA4-\uDEB3\uDEB7-\uDEBF\uDEC1-\uDEC5\uDED0-\uDED2\uDED5-\uDED7\uDEDC-\uDEDF\uDEEB\uDEEC\uDEF4-\uDEFC\uDFE0-\uDFEB\uDFF0]|\uDC15(?:\u200D\uD83E\uDDBA)?|\uDC3B(?:\u200D\u2744\uFE0F?)?|\uDC41\uFE0F?(?:\u200D\uD83D\uDDE8\uFE0F?)?|\uDC68(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:\uDC8B\u200D\uD83D)?\uDC68|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D(?:[\uDC68\uDC69]\u200D\uD83D(?:\uDC66(?:\u200D\uD83D\uDC66)?|\uDC67(?:\u200D\uD83D[\uDC66\uDC67])?)|[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uDC66(?:\u200D\uD83D\uDC66)?|\uDC67(?:\u200D\uD83D[\uDC66\uDC67])?)|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\uD83C(?:\uDFFB(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:\uDC8B\u200D\uD83D)?\uDC68\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF-\uDDB3\uDDBC\uDDBD]|\uDD1D\u200D\uD83D\uDC68\uD83C[\uDFFC-\uDFFF])))?|\uDFFC(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:\uDC8B\u200D\uD83D)?\uDC68\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF-\uDDB3\uDDBC\uDDBD]|\uDD1D\u200D\uD83D\uDC68\uD83C[\uDFFB\uDFFD-\uDFFF])))?|\uDFFD(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:\uDC8B\u200D\uD83D)?\uDC68\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF-\uDDB3\uDDBC\uDDBD]|\uDD1D\u200D\uD83D\uDC68\uD83C[\uDFFB\uDFFC\uDFFE\uDFFF])))?|\uDFFE(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:\uDC8B\u200D\uD83D)?\uDC68\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF-\uDDB3\uDDBC\uDDBD]|\uDD1D\u200D\uD83D\uDC68\uD83C[\uDFFB-\uDFFD\uDFFF])))?|\uDFFF(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:\uDC8B\u200D\uD83D)?\uDC68\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF-\uDDB3\uDDBC\uDDBD]|\uDD1D\u200D\uD83D\uDC68\uD83C[\uDFFB-\uDFFE])))?))?|\uDC69(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:\uDC8B\u200D\uD83D)?[\uDC68\uDC69]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D(?:[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uDC66(?:\u200D\uD83D\uDC66)?|\uDC67(?:\u200D\uD83D[\uDC66\uDC67])?|\uDC69\u200D\uD83D(?:\uDC66(?:\u200D\uD83D\uDC66)?|\uDC67(?:\u200D\uD83D[\uDC66\uDC67])?))|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\uD83C(?:\uDFFB(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:[\uDC68\uDC69]|\uDC8B\u200D\uD83D[\uDC68\uDC69])\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF-\uDDB3\uDDBC\uDDBD]|\uDD1D\u200D\uD83D[\uDC68\uDC69]\uD83C[\uDFFC-\uDFFF])))?|\uDFFC(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:[\uDC68\uDC69]|\uDC8B\u200D\uD83D[\uDC68\uDC69])\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF-\uDDB3\uDDBC\uDDBD]|\uDD1D\u200D\uD83D[\uDC68\uDC69]\uD83C[\uDFFB\uDFFD-\uDFFF])))?|\uDFFD(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:[\uDC68\uDC69]|\uDC8B\u200D\uD83D[\uDC68\uDC69])\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF-\uDDB3\uDDBC\uDDBD]|\uDD1D\u200D\uD83D[\uDC68\uDC69]\uD83C[\uDFFB\uDFFC\uDFFE\uDFFF])))?|\uDFFE(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:[\uDC68\uDC69]|\uDC8B\u200D\uD83D[\uDC68\uDC69])\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF-\uDDB3\uDDBC\uDDBD]|\uDD1D\u200D\uD83D[\uDC68\uDC69]\uD83C[\uDFFB-\uDFFD\uDFFF])))?|\uDFFF(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:[\uDC68\uDC69]|\uDC8B\u200D\uD83D[\uDC68\uDC69])\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF-\uDDB3\uDDBC\uDDBD]|\uDD1D\u200D\uD83D[\uDC68\uDC69]\uD83C[\uDFFB-\uDFFE])))?))?|\uDC6F(?:\u200D[\u2640\u2642]\uFE0F?)?|\uDD75(?:\uFE0F|\uD83C[\uDFFB-\uDFFF])?(?:\u200D[\u2640\u2642]\uFE0F?)?|\uDE2E(?:\u200D\uD83D\uDCA8)?|\uDE35(?:\u200D\uD83D\uDCAB)?|\uDE36(?:\u200D\uD83C\uDF2B\uFE0F?)?)|\uD83E(?:[\uDD0C\uDD0F\uDD18-\uDD1F\uDD30-\uDD34\uDD36\uDD77\uDDB5\uDDB6\uDDBB\uDDD2\uDDD3\uDDD5\uDEC3-\uDEC5\uDEF0\uDEF2-\uDEF8](?:\uD83C[\uDFFB-\uDFFF])?|[\uDD26\uDD35\uDD37-\uDD39\uDD3D\uDD3E\uDDB8\uDDB9\uDDCD-\uDDCF\uDDD4\uDDD6-\uDDDD](?:\uD83C[\uDFFB-\uDFFF])?(?:\u200D[\u2640\u2642]\uFE0F?)?|[\uDDDE\uDDDF](?:\u200D[\u2640\u2642]\uFE0F?)?|[\uDD0D\uDD0E\uDD10-\uDD17\uDD20-\uDD25\uDD27-\uDD2F\uDD3A\uDD3F-\uDD45\uDD47-\uDD76\uDD78-\uDDB4\uDDB7\uDDBA\uDDBC-\uDDCC\uDDD0\uDDE0-\uDDFF\uDE70-\uDE7C\uDE80-\uDE88\uDE90-\uDEBD\uDEBF-\uDEC2\uDECE-\uDEDB\uDEE0-\uDEE8]|\uDD3C(?:\u200D[\u2640\u2642]\uFE0F?|\uD83C[\uDFFB-\uDFFF])?|\uDDD1(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\uD83C[\uDF3E\uDF73\uDF7C\uDF84\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF-\uDDB3\uDDBC\uDDBD]|\uDD1D\u200D\uD83E\uDDD1))|\uD83C(?:\uDFFB(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D(?:\uD83D\uDC8B\u200D)?\uD83E\uDDD1\uD83C[\uDFFC-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF84\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF-\uDDB3\uDDBC\uDDBD]|\uDD1D\u200D\uD83E\uDDD1\uD83C[\uDFFB-\uDFFF])))?|\uDFFC(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D(?:\uD83D\uDC8B\u200D)?\uD83E\uDDD1\uD83C[\uDFFB\uDFFD-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF84\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF-\uDDB3\uDDBC\uDDBD]|\uDD1D\u200D\uD83E\uDDD1\uD83C[\uDFFB-\uDFFF])))?|\uDFFD(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D(?:\uD83D\uDC8B\u200D)?\uD83E\uDDD1\uD83C[\uDFFB\uDFFC\uDFFE\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF84\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF-\uDDB3\uDDBC\uDDBD]|\uDD1D\u200D\uD83E\uDDD1\uD83C[\uDFFB-\uDFFF])))?|\uDFFE(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D(?:\uD83D\uDC8B\u200D)?\uD83E\uDDD1\uD83C[\uDFFB-\uDFFD\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF84\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF-\uDDB3\uDDBC\uDDBD]|\uDD1D\u200D\uD83E\uDDD1\uD83C[\uDFFB-\uDFFF])))?|\uDFFF(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D(?:\uD83D\uDC8B\u200D)?\uD83E\uDDD1\uD83C[\uDFFB-\uDFFE]|\uD83C[\uDF3E\uDF73\uDF7C\uDF84\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF-\uDDB3\uDDBC\uDDBD]|\uDD1D\u200D\uD83E\uDDD1\uD83C[\uDFFB-\uDFFF])))?))?|\uDEF1(?:\uD83C(?:\uDFFB(?:\u200D\uD83E\uDEF2\uD83C[\uDFFC-\uDFFF])?|\uDFFC(?:\u200D\uD83E\uDEF2\uD83C[\uDFFB\uDFFD-\uDFFF])?|\uDFFD(?:\u200D\uD83E\uDEF2\uD83C[\uDFFB\uDFFC\uDFFE\uDFFF])?|\uDFFE(?:\u200D\uD83E\uDEF2\uD83C[\uDFFB-\uDFFD\uDFFF])?|\uDFFF(?:\u200D\uD83E\uDEF2\uD83C[\uDFFB-\uDFFE])?))?)/g; +}; +var eastasianwidth_default = { + eastAsianWidth(character) { + var x = character.charCodeAt(0); + var y = character.length == 2 ? character.charCodeAt(1) : 0; + var codePoint = x; + if (55296 <= x && x <= 56319 && 56320 <= y && y <= 57343) { + x &= 1023; + y &= 1023; + codePoint = x << 10 | y; + codePoint += 65536; + } + if (12288 == codePoint || 65281 <= codePoint && codePoint <= 65376 || 65504 <= codePoint && codePoint <= 65510) { + return "F"; + } + if (4352 <= codePoint && codePoint <= 4447 || 4515 <= codePoint && codePoint <= 4519 || 4602 <= codePoint && codePoint <= 4607 || 9001 <= codePoint && codePoint <= 9002 || 11904 <= codePoint && codePoint <= 11929 || 11931 <= codePoint && codePoint <= 12019 || 12032 <= codePoint && codePoint <= 12245 || 12272 <= codePoint && codePoint <= 12283 || 12289 <= codePoint && codePoint <= 12350 || 12353 <= codePoint && codePoint <= 12438 || 12441 <= codePoint && codePoint <= 12543 || 12549 <= codePoint && codePoint <= 12589 || 12593 <= codePoint && codePoint <= 12686 || 12688 <= codePoint && codePoint <= 12730 || 12736 <= codePoint && codePoint <= 12771 || 12784 <= codePoint && codePoint <= 12830 || 12832 <= codePoint && codePoint <= 12871 || 12880 <= codePoint && codePoint <= 13054 || 13056 <= codePoint && codePoint <= 19903 || 19968 <= codePoint && codePoint <= 42124 || 42128 <= codePoint && codePoint <= 42182 || 43360 <= codePoint && codePoint <= 43388 || 44032 <= codePoint && codePoint <= 55203 || 55216 <= codePoint && codePoint <= 55238 || 55243 <= codePoint && codePoint <= 55291 || 63744 <= codePoint && codePoint <= 64255 || 65040 <= codePoint && codePoint <= 65049 || 65072 <= codePoint && codePoint <= 65106 || 65108 <= codePoint && codePoint <= 65126 || 65128 <= codePoint && codePoint <= 65131 || 110592 <= codePoint && codePoint <= 110593 || 127488 <= codePoint && codePoint <= 127490 || 127504 <= codePoint && codePoint <= 127546 || 127552 <= codePoint && codePoint <= 127560 || 127568 <= codePoint && codePoint <= 127569 || 131072 <= codePoint && codePoint <= 194367 || 177984 <= codePoint && codePoint <= 196605 || 196608 <= codePoint && codePoint <= 262141) { + return "W"; + } + return "N"; + } +}; +var notAsciiRegex = /[^\x20-\x7F]/; +function getStringWidth(text) { + if (!text) { + return 0; + } + if (!notAsciiRegex.test(text)) { + return text.length; + } + text = text.replace(emoji_regex_default(), " "); + let width = 0; + for (const character of text) { + const codePoint = character.codePointAt(0); + if (codePoint <= 31 || codePoint >= 127 && codePoint <= 159) { + continue; + } + if (codePoint >= 768 && codePoint <= 879) { + continue; + } + const code = eastasianwidth_default.eastAsianWidth(character); + width += code === "F" || code === "W" ? 2 : 1; + } + return width; +} +var get_string_width_default = getStringWidth; +var getDocParts = (doc) => { + if (Array.isArray(doc)) { + return doc; + } + if (doc.type !== DOC_TYPE_FILL) { + throw new Error(`Expect doc to be 'array' or '${DOC_TYPE_FILL}'.`); + } + return doc.parts; +}; +function mapDoc(doc, cb) { + if (typeof doc === "string") { + return cb(doc); + } + const mapped = /* @__PURE__ */ new Map(); + return rec(doc); + function rec(doc2) { + if (mapped.has(doc2)) { + return mapped.get(doc2); + } + const result = process2(doc2); + mapped.set(doc2, result); + return result; + } + function process2(doc2) { + switch (get_doc_type_default(doc2)) { + case DOC_TYPE_ARRAY: + return cb(doc2.map(rec)); + case DOC_TYPE_FILL: + return cb({ + ...doc2, + parts: doc2.parts.map(rec) + }); + case DOC_TYPE_IF_BREAK: + return cb({ + ...doc2, + breakContents: rec(doc2.breakContents), + flatContents: rec(doc2.flatContents) + }); + case DOC_TYPE_GROUP: { + let { + expandedStates, + contents + } = doc2; + if (expandedStates) { + expandedStates = expandedStates.map(rec); + contents = expandedStates[0]; + } else { + contents = rec(contents); + } + return cb({ + ...doc2, + contents, + expandedStates + }); + } + case DOC_TYPE_ALIGN: + case DOC_TYPE_INDENT: + case DOC_TYPE_INDENT_IF_BREAK: + case DOC_TYPE_LABEL: + case DOC_TYPE_LINE_SUFFIX: + return cb({ + ...doc2, + contents: rec(doc2.contents) + }); + case DOC_TYPE_STRING: + case DOC_TYPE_CURSOR: + case DOC_TYPE_TRIM: + case DOC_TYPE_LINE_SUFFIX_BOUNDARY: + case DOC_TYPE_LINE: + case DOC_TYPE_BREAK_PARENT: + return cb(doc2); + default: + throw new invalid_doc_error_default(doc2); + } + } +} +function findInDoc(doc, fn, defaultValue) { + let result = defaultValue; + let shouldSkipFurtherProcessing = false; + function findInDocOnEnterFn(doc2) { + if (shouldSkipFurtherProcessing) { + return false; + } + const maybeResult = fn(doc2); + if (maybeResult !== void 0) { + shouldSkipFurtherProcessing = true; + result = maybeResult; + } + } + traverse_doc_default(doc, findInDocOnEnterFn); + return result; +} +function willBreakFn(doc) { + if (doc.type === DOC_TYPE_GROUP && doc.break) { + return true; + } + if (doc.type === DOC_TYPE_LINE && doc.hard) { + return true; + } + if (doc.type === DOC_TYPE_BREAK_PARENT) { + return true; + } +} +function willBreak(doc) { + return findInDoc(doc, willBreakFn, false); +} +function breakParentGroup(groupStack) { + if (groupStack.length > 0) { + const parentGroup = at_default( + /* isOptionalObject*/ + false, + groupStack, + -1 + ); + if (!parentGroup.expandedStates && !parentGroup.break) { + parentGroup.break = "propagated"; + } + } + return null; +} +function propagateBreaks(doc) { + const alreadyVisitedSet = /* @__PURE__ */ new Set(); + const groupStack = []; + function propagateBreaksOnEnterFn(doc2) { + if (doc2.type === DOC_TYPE_BREAK_PARENT) { + breakParentGroup(groupStack); + } + if (doc2.type === DOC_TYPE_GROUP) { + groupStack.push(doc2); + if (alreadyVisitedSet.has(doc2)) { + return false; + } + alreadyVisitedSet.add(doc2); + } + } + function propagateBreaksOnExitFn(doc2) { + if (doc2.type === DOC_TYPE_GROUP) { + const group22 = groupStack.pop(); + if (group22.break) { + breakParentGroup(groupStack); + } + } + } + traverse_doc_default( + doc, + propagateBreaksOnEnterFn, + propagateBreaksOnExitFn, + /* shouldTraverseConditionalGroups */ + true + ); +} +function removeLinesFn(doc) { + if (doc.type === DOC_TYPE_LINE && !doc.hard) { + return doc.soft ? "" : " "; + } + if (doc.type === DOC_TYPE_IF_BREAK) { + return doc.flatContents; + } + return doc; +} +function removeLines(doc) { + return mapDoc(doc, removeLinesFn); +} +function stripTrailingHardlineFromParts(parts) { + parts = [...parts]; + while (parts.length >= 2 && at_default( + /* isOptionalObject*/ + false, + parts, + -2 + ).type === DOC_TYPE_LINE && at_default( + /* isOptionalObject*/ + false, + parts, + -1 + ).type === DOC_TYPE_BREAK_PARENT) { + parts.length -= 2; + } + if (parts.length > 0) { + const lastPart = stripTrailingHardlineFromDoc(at_default( + /* isOptionalObject*/ + false, + parts, + -1 + )); + parts[parts.length - 1] = lastPart; + } + return parts; +} +function stripTrailingHardlineFromDoc(doc) { + switch (get_doc_type_default(doc)) { + case DOC_TYPE_ALIGN: + case DOC_TYPE_INDENT: + case DOC_TYPE_INDENT_IF_BREAK: + case DOC_TYPE_GROUP: + case DOC_TYPE_LINE_SUFFIX: + case DOC_TYPE_LABEL: { + const contents = stripTrailingHardlineFromDoc(doc.contents); + return { + ...doc, + contents + }; + } + case DOC_TYPE_IF_BREAK: + return { + ...doc, + breakContents: stripTrailingHardlineFromDoc(doc.breakContents), + flatContents: stripTrailingHardlineFromDoc(doc.flatContents) + }; + case DOC_TYPE_FILL: + return { + ...doc, + parts: stripTrailingHardlineFromParts(doc.parts) + }; + case DOC_TYPE_ARRAY: + return stripTrailingHardlineFromParts(doc); + case DOC_TYPE_STRING: + return doc.replace(/[\n\r]*$/, ""); + case DOC_TYPE_CURSOR: + case DOC_TYPE_TRIM: + case DOC_TYPE_LINE_SUFFIX_BOUNDARY: + case DOC_TYPE_LINE: + case DOC_TYPE_BREAK_PARENT: + break; + default: + throw new invalid_doc_error_default(doc); + } + return doc; +} +function stripTrailingHardline(doc) { + return stripTrailingHardlineFromDoc(cleanDoc(doc)); +} +function cleanDocFn(doc) { + switch (get_doc_type_default(doc)) { + case DOC_TYPE_FILL: + if (doc.parts.every((part) => part === "")) { + return ""; + } + break; + case DOC_TYPE_GROUP: + if (!doc.contents && !doc.id && !doc.break && !doc.expandedStates) { + return ""; + } + if (doc.contents.type === DOC_TYPE_GROUP && doc.contents.id === doc.id && doc.contents.break === doc.break && doc.contents.expandedStates === doc.expandedStates) { + return doc.contents; + } + break; + case DOC_TYPE_ALIGN: + case DOC_TYPE_INDENT: + case DOC_TYPE_INDENT_IF_BREAK: + case DOC_TYPE_LINE_SUFFIX: + if (!doc.contents) { + return ""; + } + break; + case DOC_TYPE_IF_BREAK: + if (!doc.flatContents && !doc.breakContents) { + return ""; + } + break; + case DOC_TYPE_ARRAY: { + const parts = []; + for (const part of doc) { + if (!part) { + continue; + } + const [currentPart, ...restParts] = Array.isArray(part) ? part : [part]; + if (typeof currentPart === "string" && typeof at_default( + /* isOptionalObject*/ + false, + parts, + -1 + ) === "string") { + parts[parts.length - 1] += currentPart; + } else { + parts.push(currentPart); + } + parts.push(...restParts); + } + if (parts.length === 0) { + return ""; + } + if (parts.length === 1) { + return parts[0]; + } + return parts; + } + case DOC_TYPE_STRING: + case DOC_TYPE_CURSOR: + case DOC_TYPE_TRIM: + case DOC_TYPE_LINE_SUFFIX_BOUNDARY: + case DOC_TYPE_LINE: + case DOC_TYPE_LABEL: + case DOC_TYPE_BREAK_PARENT: + break; + default: + throw new invalid_doc_error_default(doc); + } + return doc; +} +function cleanDoc(doc) { + return mapDoc(doc, (currentDoc) => cleanDocFn(currentDoc)); +} +function replaceEndOfLine(doc, replacement = literalline) { + return mapDoc(doc, (currentDoc) => typeof currentDoc === "string" ? join(replacement, currentDoc.split("\n")) : currentDoc); +} +function canBreakFn(doc) { + if (doc.type === DOC_TYPE_LINE) { + return true; + } +} +function canBreak(doc) { + return findInDoc(doc, canBreakFn, false); +} +var MODE_BREAK = Symbol("MODE_BREAK"); +var MODE_FLAT = Symbol("MODE_FLAT"); +var CURSOR_PLACEHOLDER = Symbol("cursor"); +function rootIndent() { + return { + value: "", + length: 0, + queue: [] + }; +} +function makeIndent(ind, options) { + return generateInd(ind, { + type: "indent" + }, options); +} +function makeAlign(indent22, widthOrDoc, options) { + if (widthOrDoc === Number.NEGATIVE_INFINITY) { + return indent22.root || rootIndent(); + } + if (widthOrDoc < 0) { + return generateInd(indent22, { + type: "dedent" + }, options); + } + if (!widthOrDoc) { + return indent22; + } + if (widthOrDoc.type === "root") { + return { + ...indent22, + root: indent22 + }; + } + const alignType = typeof widthOrDoc === "string" ? "stringAlign" : "numberAlign"; + return generateInd(indent22, { + type: alignType, + n: widthOrDoc + }, options); +} +function generateInd(ind, newPart, options) { + const queue = newPart.type === "dedent" ? ind.queue.slice(0, -1) : [...ind.queue, newPart]; + let value = ""; + let length = 0; + let lastTabs = 0; + let lastSpaces = 0; + for (const part of queue) { + switch (part.type) { + case "indent": + flush(); + if (options.useTabs) { + addTabs(1); + } else { + addSpaces(options.tabWidth); + } + break; + case "stringAlign": + flush(); + value += part.n; + length += part.n.length; + break; + case "numberAlign": + lastTabs += 1; + lastSpaces += part.n; + break; + default: + throw new Error(`Unexpected type '${part.type}'`); + } + } + flushSpaces(); + return { + ...ind, + value, + length, + queue + }; + function addTabs(count) { + value += " ".repeat(count); + length += options.tabWidth * count; + } + function addSpaces(count) { + value += " ".repeat(count); + length += count; + } + function flush() { + if (options.useTabs) { + flushTabs(); + } else { + flushSpaces(); + } + } + function flushTabs() { + if (lastTabs > 0) { + addTabs(lastTabs); + } + resetLast(); + } + function flushSpaces() { + if (lastSpaces > 0) { + addSpaces(lastSpaces); + } + resetLast(); + } + function resetLast() { + lastTabs = 0; + lastSpaces = 0; + } +} +function trim2(out) { + let trimCount = 0; + let cursorCount = 0; + let outIndex = out.length; + outer: + while (outIndex--) { + const last = out[outIndex]; + if (last === CURSOR_PLACEHOLDER) { + cursorCount++; + continue; + } + if (false) { + throw new Error(`Unexpected value in trim: '${typeof last}'`); + } + for (let charIndex = last.length - 1; charIndex >= 0; charIndex--) { + const char = last[charIndex]; + if (char === " " || char === " ") { + trimCount++; + } else { + out[outIndex] = last.slice(0, charIndex + 1); + break outer; + } + } + } + if (trimCount > 0 || cursorCount > 0) { + out.length = outIndex + 1; + while (cursorCount-- > 0) { + out.push(CURSOR_PLACEHOLDER); + } + } + return trimCount; +} +function fits(next, restCommands, width, hasLineSuffix, groupModeMap, mustBeFlat) { + if (width === Number.POSITIVE_INFINITY) { + return true; + } + let restIdx = restCommands.length; + const cmds = [next]; + const out = []; + while (width >= 0) { + if (cmds.length === 0) { + if (restIdx === 0) { + return true; + } + cmds.push(restCommands[--restIdx]); + continue; + } + const { + mode, + doc + } = cmds.pop(); + switch (get_doc_type_default(doc)) { + case DOC_TYPE_STRING: + out.push(doc); + width -= get_string_width_default(doc); + break; + case DOC_TYPE_ARRAY: + case DOC_TYPE_FILL: { + const parts = getDocParts(doc); + for (let i = parts.length - 1; i >= 0; i--) { + cmds.push({ + mode, + doc: parts[i] + }); + } + break; + } + case DOC_TYPE_INDENT: + case DOC_TYPE_ALIGN: + case DOC_TYPE_INDENT_IF_BREAK: + case DOC_TYPE_LABEL: + cmds.push({ + mode, + doc: doc.contents + }); + break; + case DOC_TYPE_TRIM: + width += trim2(out); + break; + case DOC_TYPE_GROUP: { + if (mustBeFlat && doc.break) { + return false; + } + const groupMode = doc.break ? MODE_BREAK : mode; + const contents = doc.expandedStates && groupMode === MODE_BREAK ? at_default( + /* isOptionalObject*/ + false, + doc.expandedStates, + -1 + ) : doc.contents; + cmds.push({ + mode: groupMode, + doc: contents + }); + break; + } + case DOC_TYPE_IF_BREAK: { + const groupMode = doc.groupId ? groupModeMap[doc.groupId] || MODE_FLAT : mode; + const contents = groupMode === MODE_BREAK ? doc.breakContents : doc.flatContents; + if (contents) { + cmds.push({ + mode, + doc: contents + }); + } + break; + } + case DOC_TYPE_LINE: + if (mode === MODE_BREAK || doc.hard) { + return true; + } + if (!doc.soft) { + out.push(" "); + width--; + } + break; + case DOC_TYPE_LINE_SUFFIX: + hasLineSuffix = true; + break; + case DOC_TYPE_LINE_SUFFIX_BOUNDARY: + if (hasLineSuffix) { + return false; + } + break; + } + } + return false; +} +function printDocToString(doc, options) { + const groupModeMap = {}; + const width = options.printWidth; + const newLine = convertEndOfLineToChars(options.endOfLine); + let pos = 0; + const cmds = [{ + ind: rootIndent(), + mode: MODE_BREAK, + doc + }]; + const out = []; + let shouldRemeasure = false; + const lineSuffix22 = []; + let printedCursorCount = 0; + propagateBreaks(doc); + while (cmds.length > 0) { + const { + ind, + mode, + doc: doc2 + } = cmds.pop(); + switch (get_doc_type_default(doc2)) { + case DOC_TYPE_STRING: { + const formatted = newLine !== "\n" ? string_replace_all_default( + /* isOptionalObject*/ + false, + doc2, + "\n", + newLine + ) : doc2; + out.push(formatted); + if (cmds.length > 0) { + pos += get_string_width_default(formatted); + } + break; + } + case DOC_TYPE_ARRAY: + for (let i = doc2.length - 1; i >= 0; i--) { + cmds.push({ + ind, + mode, + doc: doc2[i] + }); + } + break; + case DOC_TYPE_CURSOR: + if (printedCursorCount >= 2) { + throw new Error("There are too many 'cursor' in doc."); + } + out.push(CURSOR_PLACEHOLDER); + printedCursorCount++; + break; + case DOC_TYPE_INDENT: + cmds.push({ + ind: makeIndent(ind, options), + mode, + doc: doc2.contents + }); + break; + case DOC_TYPE_ALIGN: + cmds.push({ + ind: makeAlign(ind, doc2.n, options), + mode, + doc: doc2.contents + }); + break; + case DOC_TYPE_TRIM: + pos -= trim2(out); + break; + case DOC_TYPE_GROUP: + switch (mode) { + case MODE_FLAT: + if (!shouldRemeasure) { + cmds.push({ + ind, + mode: doc2.break ? MODE_BREAK : MODE_FLAT, + doc: doc2.contents + }); + break; + } + case MODE_BREAK: { + shouldRemeasure = false; + const next = { + ind, + mode: MODE_FLAT, + doc: doc2.contents + }; + const rem = width - pos; + const hasLineSuffix = lineSuffix22.length > 0; + if (!doc2.break && fits(next, cmds, rem, hasLineSuffix, groupModeMap)) { + cmds.push(next); + } else { + if (doc2.expandedStates) { + const mostExpanded = at_default( + /* isOptionalObject*/ + false, + doc2.expandedStates, + -1 + ); + if (doc2.break) { + cmds.push({ + ind, + mode: MODE_BREAK, + doc: mostExpanded + }); + break; + } else { + for (let i = 1; i < doc2.expandedStates.length + 1; i++) { + if (i >= doc2.expandedStates.length) { + cmds.push({ + ind, + mode: MODE_BREAK, + doc: mostExpanded + }); + break; + } else { + const state = doc2.expandedStates[i]; + const cmd = { + ind, + mode: MODE_FLAT, + doc: state + }; + if (fits(cmd, cmds, rem, hasLineSuffix, groupModeMap)) { + cmds.push(cmd); + break; + } + } + } + } + } else { + cmds.push({ + ind, + mode: MODE_BREAK, + doc: doc2.contents + }); + } + } + break; + } + } + if (doc2.id) { + groupModeMap[doc2.id] = at_default( + /* isOptionalObject*/ + false, + cmds, + -1 + ).mode; + } + break; + case DOC_TYPE_FILL: { + const rem = width - pos; + const { + parts + } = doc2; + if (parts.length === 0) { + break; + } + const [content, whitespace] = parts; + const contentFlatCmd = { + ind, + mode: MODE_FLAT, + doc: content + }; + const contentBreakCmd = { + ind, + mode: MODE_BREAK, + doc: content + }; + const contentFits = fits(contentFlatCmd, [], rem, lineSuffix22.length > 0, groupModeMap, true); + if (parts.length === 1) { + if (contentFits) { + cmds.push(contentFlatCmd); + } else { + cmds.push(contentBreakCmd); + } + break; + } + const whitespaceFlatCmd = { + ind, + mode: MODE_FLAT, + doc: whitespace + }; + const whitespaceBreakCmd = { + ind, + mode: MODE_BREAK, + doc: whitespace + }; + if (parts.length === 2) { + if (contentFits) { + cmds.push(whitespaceFlatCmd, contentFlatCmd); + } else { + cmds.push(whitespaceBreakCmd, contentBreakCmd); + } + break; + } + parts.splice(0, 2); + const remainingCmd = { + ind, + mode, + doc: fill(parts) + }; + const secondContent = parts[0]; + const firstAndSecondContentFlatCmd = { + ind, + mode: MODE_FLAT, + doc: [content, whitespace, secondContent] + }; + const firstAndSecondContentFits = fits(firstAndSecondContentFlatCmd, [], rem, lineSuffix22.length > 0, groupModeMap, true); + if (firstAndSecondContentFits) { + cmds.push(remainingCmd, whitespaceFlatCmd, contentFlatCmd); + } else if (contentFits) { + cmds.push(remainingCmd, whitespaceBreakCmd, contentFlatCmd); + } else { + cmds.push(remainingCmd, whitespaceBreakCmd, contentBreakCmd); + } + break; + } + case DOC_TYPE_IF_BREAK: + case DOC_TYPE_INDENT_IF_BREAK: { + const groupMode = doc2.groupId ? groupModeMap[doc2.groupId] : mode; + if (groupMode === MODE_BREAK) { + const breakContents = doc2.type === DOC_TYPE_IF_BREAK ? doc2.breakContents : doc2.negate ? doc2.contents : indent(doc2.contents); + if (breakContents) { + cmds.push({ + ind, + mode, + doc: breakContents + }); + } + } + if (groupMode === MODE_FLAT) { + const flatContents = doc2.type === DOC_TYPE_IF_BREAK ? doc2.flatContents : doc2.negate ? indent(doc2.contents) : doc2.contents; + if (flatContents) { + cmds.push({ + ind, + mode, + doc: flatContents + }); + } + } + break; + } + case DOC_TYPE_LINE_SUFFIX: + lineSuffix22.push({ + ind, + mode, + doc: doc2.contents + }); + break; + case DOC_TYPE_LINE_SUFFIX_BOUNDARY: + if (lineSuffix22.length > 0) { + cmds.push({ + ind, + mode, + doc: hardlineWithoutBreakParent + }); + } + break; + case DOC_TYPE_LINE: + switch (mode) { + case MODE_FLAT: + if (!doc2.hard) { + if (!doc2.soft) { + out.push(" "); + pos += 1; + } + break; + } else { + shouldRemeasure = true; + } + case MODE_BREAK: + if (lineSuffix22.length > 0) { + cmds.push({ + ind, + mode, + doc: doc2 + }, ...lineSuffix22.reverse()); + lineSuffix22.length = 0; + break; + } + if (doc2.literal) { + if (ind.root) { + out.push(newLine, ind.root.value); + pos = ind.root.length; + } else { + out.push(newLine); + pos = 0; + } + } else { + pos -= trim2(out); + out.push(newLine + ind.value); + pos = ind.length; + } + break; + } + break; + case DOC_TYPE_LABEL: + cmds.push({ + ind, + mode, + doc: doc2.contents + }); + break; + case DOC_TYPE_BREAK_PARENT: + break; + default: + throw new invalid_doc_error_default(doc2); + } + if (cmds.length === 0 && lineSuffix22.length > 0) { + cmds.push(...lineSuffix22.reverse()); + lineSuffix22.length = 0; + } + } + const cursorPlaceholderIndex = out.indexOf(CURSOR_PLACEHOLDER); + if (cursorPlaceholderIndex !== -1) { + const otherCursorPlaceholderIndex = out.indexOf(CURSOR_PLACEHOLDER, cursorPlaceholderIndex + 1); + const beforeCursor = out.slice(0, cursorPlaceholderIndex).join(""); + const aroundCursor = out.slice(cursorPlaceholderIndex + 1, otherCursorPlaceholderIndex).join(""); + const afterCursor = out.slice(otherCursorPlaceholderIndex + 1).join(""); + return { + formatted: beforeCursor + aroundCursor + afterCursor, + cursorNodeStart: beforeCursor.length, + cursorNodeText: aroundCursor + }; + } + return { + formatted: out.join("") + }; +} +var builders = { + join, + line, + softline, + hardline, + literalline, + group, + conditionalGroup, + fill, + lineSuffix, + lineSuffixBoundary, + cursor, + breakParent, + ifBreak, + trim, + indent, + indentIfBreak, + align, + addAlignmentToDoc, + markAsRoot, + dedentToRoot, + dedent, + hardlineWithoutBreakParent, + literallineWithoutBreakParent, + label, + // TODO: Remove this in v4 + concat: (parts) => parts +}; +var printer = { printDocToString }; +var utils = { + willBreak, + traverseDoc: traverse_doc_default, + findInDoc, + mapDoc, + removeLines, + stripTrailingHardline, + replaceEndOfLine, + canBreak +}; + +// libs/printer/common.ts +import { printRaw } from "@unified-latex/unified-latex-util-print-raw"; +import { match } from "@unified-latex/unified-latex-util-match"; +function formatEnvSurround(node) { + const env = printRaw(node.env); + return { + envName: env, + start: ESCAPE + "begin{" + env + "}", + end: ESCAPE + "end{" + env + "}" + }; +} +function isLineType(elm) { + if (elm == null || typeof elm === "string") { + return false; + } + if (Array.isArray(elm)) { + return isLineType(elm[0]); + } + if (elm.type === "concat") { + return isLineType(elm.parts); + } + return elm.type === "line"; +} +function joinWithSoftline(arr) { + if (arr.length === 0 || arr.length === 1) { + return arr; + } + const ret = [arr[0]]; + for (let i = 1; i < arr.length; i++) { + const prevNode = arr[i - 1]; + const nextNode = arr[i]; + if (!isLineType(prevNode) && !isLineType(nextNode)) { + ret.push(softline2); + } + ret.push(nextNode); + } + return ret; +} +function getNodeInfo(node, options) { + if (!node) { + return { renderInfo: {} }; + } + const renderInfo = node._renderInfo || {}; + const previousNode = options.referenceMap && options.referenceMap.getPreviousNode(node); + const nextNode = options.referenceMap && options.referenceMap.getNextNode(node); + const renderCache = options.referenceMap && options.referenceMap.getRenderCache(node); + return { + renderInfo, + renderCache, + previousNode, + nextNode, + referenceMap: options.referenceMap + }; +} +var ESCAPE = "\\"; +var { + group: group2, + fill: fill2, + ifBreak: ifBreak2, + line: line2, + softline: softline2, + hardline: hardline2, + lineSuffix: lineSuffix2, + lineSuffixBoundary: lineSuffixBoundary2, + breakParent: breakParent2, + indent: indent2, + markAsRoot: markAsRoot2, + join: join2 +} = builders; +function formatDocArray(nodes, docArray, options) { + const ret = []; + for (let i = 0; i < nodes.length; i++) { + const rawNode = nodes[i]; + const printedNode = docArray[i]; + const { renderInfo, referenceMap, previousNode, nextNode } = getNodeInfo(rawNode, options); + const renderCache = referenceMap && referenceMap.getRenderCache(rawNode); + switch (rawNode.type) { + case "comment": + if (!rawNode.sameline && previousNode && !match.comment(previousNode) && !match.parbreak(previousNode)) { + ret.push(hardline2); + } + ret.push(printedNode); + if (nextNode && !rawNode.suffixParbreak) { + ret.push(hardline2); + } + break; + case "environment": + case "displaymath": + case "mathenv": + if (previousNode && (previousNode == null ? void 0 : previousNode.type) !== "parbreak") { + if (ret[ret.length - 1] === line2) { + ret.pop(); + } + if (ret[ret.length - 1] !== hardline2) { + ret.push(hardline2); + } + } + ret.push(printedNode); + if ((nextNode == null ? void 0 : nextNode.type) === "whitespace") { + ret.push(hardline2); + i++; + } + break; + case "macro": + if (renderInfo.breakBefore || renderInfo.breakAround) { + if (previousNode) { + if (ret[ret.length - 1] === line2 || ret[ret.length - 1] === hardline2) { + ret.pop(); + ret.push(hardline2); + } else if (!match.comment(previousNode) && !match.parbreak(previousNode)) { + ret.push(hardline2); + } + } + } + if (renderInfo.inParMode && !renderInfo.hangingIndent && renderCache) { + ret.push( + renderCache.content, + ...renderCache.rawArgs || [] + ); + } else { + ret.push(printedNode); + } + if (renderInfo.breakAfter || renderInfo.breakAround) { + if (nextNode) { + if (match.whitespace(nextNode)) { + ret.push(hardline2); + i++; + } else if (match.parbreak(nextNode)) { + } else if (!match.comment(nextNode)) { + ret.push(hardline2); + } + } + } + break; + case "parbreak": + ret.push(hardline2, hardline2); + break; + default: + ret.push(printedNode); + break; + } + } + return ret; +} + +// libs/zip.ts +function zip(array1, array2) { + const ret = []; + const len = Math.min(array1.length, array2.length); + for (let i = 0; i < len; i++) { + ret.push([array1[i], array2[i]]); + } + return ret; +} + +// libs/printer/macro.ts +function printMacro(path, print, options) { + const node = path.getNode(); + const { renderInfo, previousNode, nextNode, referenceMap } = getNodeInfo( + node, + options + ); + const content = (node.escapeToken != null ? node.escapeToken : ESCAPE) + node.content; + const args = node.args ? path.map(print, "args") : []; + const rawArgs = []; + for (const [arg, printedArg] of zip(node.args || [], args)) { + const renderCache = referenceMap && referenceMap.getRenderCache(arg); + if (renderInfo.inParMode && renderCache) { + rawArgs.push(...renderCache); + } else { + rawArgs.push(printedArg); + } + } + if (referenceMap) { + referenceMap.setRenderCache(node, { rawArgs, content }); + } + if (renderInfo.hangingIndent) { + return indent2(fill2([content, ...rawArgs])); + } + return group2([content, ...rawArgs]); +} + +// libs/printer/argument.ts +import { match as match3 } from "@unified-latex/unified-latex-util-match"; +import { trim as trim4 } from "@unified-latex/unified-latex-util-trim"; + +// libs/printer/tikz.ts +import { + printRaw as printRaw3 +} from "@unified-latex/unified-latex-util-print-raw"; +import { match as match2 } from "@unified-latex/unified-latex-util-match"; +import { trim as trim3 } from "@unified-latex/unified-latex-util-trim"; +import { + parse as parseTikz +} from "@unified-latex/unified-latex-ctan/package/tikz"; + +// libs/printer/print-argument-pgfkeys.ts +import { + linebreak, + printRaw as printRaw2 +} from "@unified-latex/unified-latex-util-print-raw"; +import { parsePgfkeys } from "@unified-latex/unified-latex-util-pgfkeys"; +function printArgumentPgfkeys(nodes, options) { + const { allowParenGroups = false } = options; + const parsed = parsePgfkeys(nodes, { allowParenGroups }); + const content = []; + for (const part of parsed) { + const isLastItem = part === parsed[parsed.length - 1]; + if (part.itemParts) { + const parts = part.itemParts.map( + (node) => printRaw2(node, { asArray: true }).map( + (token) => token === linebreak ? hardline2 : token + ) + ); + const row = join2("=", parts); + content.push(row); + if (part.trailingComma) { + content.push(","); + } + } + if (part.trailingComment) { + const leadingContent = part.itemParts ? [" "] : []; + if (part.leadingParbreak) { + leadingContent.push(hardline2); + } + content.push( + ...leadingContent, + // We're carefully and manually controlling the newlines, + // so print the comment directly without any newlines + "%", + part.trailingComment.content, + breakParent2 + ); + } + if (!isLastItem) { + content.push(line2); + } + } + let leadingComment = [""]; + if (options.leadingComment) { + if (options.leadingComment.leadingWhitespace) { + leadingComment.push(" "); + } + leadingComment.push("%" + options.leadingComment.content, breakParent2); + } + return group2([ + options.openMark, + ...leadingComment, + // If there is no content, we don't want to push an extra `softline`. + // This matters because the braces group could still be broken by `leadingComment` + content.length > 0 ? indent2([softline2, ...content]) : "", + softline2, + options.closeMark + ]); +} + +// libs/printer/tikz.ts +function printTikzArgument(path, print, options) { + const node = path.getNode(); + const { renderInfo, previousNode, nextNode, referenceMap } = getNodeInfo( + node, + options + ); + const content = []; + const nodes = [...node.content]; + trim3(nodes); + try { + const tikzAst = parseTikz(nodes); + if (tikzAst.content.length === 0) { + content.push(";"); + return content; + } + const printer2 = new TikzArgumentPrinter(tikzAst, path, print); + return printer2.toDoc(); + } catch (e) { + console.warn("Encountered error when trying to parse tikz argument", e); + } + content.push(";"); + return content; +} +function printFragment(fragment, path, print) { + const tmpKey = Symbol(); + const currNode = path.getNode(); + if (!currNode) { + throw new Error( + "tried to print a fragment, but the current node is `null`" + ); + } + currNode[tmpKey] = fragment; + const ret = print(tmpKey); + delete currNode[tmpKey]; + return ret; +} +function printTikzPathSpecNode(node, path, print) { + switch (node.type) { + case "comment": + return printFragment(node, path, print); + case "unknown": + return printFragment(node.content, path, print); + case "coordinate": + return [printRaw3(node.prefix), "(", printRaw3(node.content), ")"]; + case "line_to": + return node.command; + case "square_brace_group": + return printOptionalArgs(node.content); + case "operation": + return node.content.content; + case "svg_operation": { + const comments = node.comments.map( + (n) => printTikzPathSpecNode(n, path, print) + ); + const options = node.options ? printOptionalArgs(node.options) : []; + const rest = node.options ? [group2(indent2([line2, printRaw3(node.content)]))] : [" ", printRaw3(node.content)]; + return [...comments, "svg", options, ...rest]; + } + case "curve_to": { + const comments = node.comments.map( + (n) => printTikzPathSpecNode(n, path, print) + ); + const printedControls = node.controls.length > 1 ? [ + printTikzPathSpecNode(node.controls[0], path, print), + " ", + "and", + line2, + printTikzPathSpecNode(node.controls[1], path, print) + ] : [printTikzPathSpecNode(node.controls[0], path, print)]; + return [ + ...comments, + "..", + " ", + group2( + indent2(["controls", line2, ...printedControls, " ", ".."]) + ) + ]; + } + case "animation": { + const comments = node.comments.map( + (n) => printTikzPathSpecNode(n, path, print) + ); + return [ + ...comments, + ":", + node.attribute, + " ", + "=", + " ", + group2( + indent2([ + printArgumentPgfkeys(node.content, { + openMark: "{", + closeMark: "}" + }) + ]) + ) + ]; + } + case "foreach": { + const comments = node.comments.map( + (n) => printTikzPathSpecNode(n, path, print) + ); + const variables = [...node.variables]; + trim3(variables); + const list = node.list.type === "macro" ? printFragment(node.list, path, print) : printArgumentPgfkeys(node.list.content, { + openMark: "{", + closeMark: "}", + allowParenGroups: true + }); + const doc = [ + ...comments, + printRaw3(node.start), + " ", + printRaw3(variables) + ]; + if (node.options) { + doc.push(" ", indent2(printOptionalArgs(node.options))); + } + doc.push(" ", "in", " ", group2(indent2(list))); + const commandType = node.command.type; + switch (commandType) { + case "foreach": + doc.push( + indent2([ + line2, + printTikzPathSpecNode(node.command, path, print) + ]) + ); + break; + case "macro": + doc.push( + indent2([line2, printFragment(node.command, path, print)]) + ); + break; + case "group": { + const groupContent = [...node.command.content]; + trim3(groupContent); + doc.push( + " ", + indent2( + group2([ + "{", + indent2([ + softline2, + ...groupContent.map( + (n) => printFragment(n, path, print) + ) + ]), + softline2, + "}" + ]) + ) + ); + break; + } + default: + const invalidType = commandType; + console.warn( + `Unhandled command type when printing "foreach": ${invalidType}` + ); + } + return indent2(doc); + } + } + console.warn( + `Encountered unknown type when trying to print tikz PathSpec: "${node.type}"` + ); + return []; +} +function printOptionalArgs(nodes) { + return printArgumentPgfkeys(nodes, { + openMark: "[", + closeMark: "]" + }); +} +var _path, _print; +var TikzArgumentPrinter = class { + constructor(spec, path, print) { + __privateAdd(this, _path, void 0); + __privateAdd(this, _print, void 0); + __privateSet(this, _path, path); + __privateSet(this, _print, print); + this.nodes = [...spec.content]; + } + nodeToDoc(node) { + return printTikzPathSpecNode(node, __privateGet(this, _path), __privateGet(this, _print)); + } + toDoc() { + const doc = []; + const startArg = this.eatOptionalArg(); + if (startArg.optionalArg) { + doc.push( + ...startArg.comments.map( + (c) => printFragment(c, __privateGet(this, _path), __privateGet(this, _print)) + ) + ); + doc.push(printOptionalArgs(startArg.optionalArg.content)); + } + const innerDoc = []; + doc.push(group2([indent2(innerDoc), ";"])); + let cycle = -1; + while (this.nodes.length > 0) { + cycle++; + const firstSep = cycle === 0 && !startArg.optionalArg ? " " : line2; + const comingUp = this.peek(); + switch (comingUp) { + case "short_path": { + const [n0, n1, n2] = this.nodes.splice(0, 3); + innerDoc.push( + firstSep, + this.nodeToDoc(n0), + " ", + this.nodeToDoc(n1), + " ", + this.nodeToDoc(n2) + ); + continue; + } + case "long_path": { + const [n0, n1] = this.nodes.splice(0, 2); + if (n1.type === "operation") { + this.nodes.unshift(n1); + innerDoc.push( + firstSep, + this.nodeToDoc(n0), + " ", + this.eatOperation() + ); + } else { + innerDoc.push( + firstSep, + this.nodeToDoc(n0), + " ", + this.nodeToDoc(n1) + ); + } + continue; + } + case "node": + { + const eatenNode = this.eatNode(); + if (eatenNode) { + innerDoc.push(line2, ...eatenNode); + continue; + } + console.warn( + "Expected to print a tikz `node` PathSpec but couldn't find the text `node`" + ); + } + continue; + case "operation": + innerDoc.push(firstSep, this.eatOperation()); + continue; + case "unknown": { + const node = this.nodes.shift(); + innerDoc.push(firstSep, this.nodeToDoc(node)); + continue; + } + } + this.nodes.shift(); + } + return doc; + } + /** + * Look at the current node and the nodes that follow. Return what + * "type" is recognized. + */ + peek() { + const [n0, n1, n2, n3] = [ + this.nodes[0], + this.nodes[1], + this.nodes[2], + this.nodes[3] + ]; + if ((n0 == null ? void 0 : n0.type) === "coordinate" && isPathJoinOperation(n1)) { + if ((n2 == null ? void 0 : n2.type) === "coordinate" && !((n3 == null ? void 0 : n3.type) === "coordinate" || isPathJoinOperation(n3))) { + return "short_path"; + } + return "long_path"; + } + if ((n0 == null ? void 0 : n0.type) === "operation") { + if (n0.content.content === "node") { + return "node"; + } + return "operation"; + } + return "unknown"; + } + /** + * Eat comments and an optional arg if present. If no optional + * arg is present, do nothing. + */ + eatOptionalArg() { + let i = 0; + const comments = []; + let optionalArg = null; + for (; i < this.nodes.length; i++) { + const node = this.nodes[i]; + if (node.type === "square_brace_group") { + optionalArg = node; + i++; + break; + } + if (node.type === "comment") { + comments.push(node); + continue; + } + break; + } + if (optionalArg) { + this.nodes.splice(0, i); + } + return { optionalArg, comments }; + } + /** + * Eat a `type === "operation"` node whose contents is `"node"`. I.e., + * the type of thing that shows up in `\path node at (1,1) {foo};` + */ + eatNode() { + const firstNode = this.nodes[0]; + if ((firstNode == null ? void 0 : firstNode.type) === "operation" && firstNode.content.content === "node") { + this.nodes.shift(); + } else { + return null; + } + const innerDoc = []; + const commentBlock = []; + const doc = [commentBlock, "node", group2(indent2(innerDoc))]; + let hasNodeArgument = false; + let shouldBail = false; + let i = 0; + const comments = []; + const options = []; + const name = []; + const atLocations = []; + const animations = []; + let content = []; + for (; i < this.nodes.length && !shouldBail; i++) { + const node = this.nodes[i]; + switch (node.type) { + case "animation": + animations.push(this.nodeToDoc(node)); + continue; + case "comment": { + const comment = { + ...node, + leadingWhitespace: false + }; + comments.push(this.nodeToDoc(comment)); + continue; + } + case "square_brace_group": + options.push(printOptionalArgs(node.content)); + continue; + case "coordinate": + name.push(this.nodeToDoc(node)); + continue; + case "operation": { + if (node.content.content === "at") { + const nextNode = this.nodes[i + 1]; + if (!nextNode || !(nextNode.type === "coordinate" || nextNode.type === "unknown" && match2.anyMacro(nextNode.content))) { + shouldBail = true; + continue; + } + atLocations.push(["at", " ", this.nodeToDoc(nextNode)]); + i++; + continue; + } + shouldBail = true; + continue; + } + case "unknown": { + if (match2.group(node.content)) { + hasNodeArgument = true; + content = this.nodeToDoc(node); + } + } + } + break; + } + if (!hasNodeArgument) { + return innerDoc; + } + this.nodes.splice(0, i + 1); + let isFirstElement = true; + let isNamed = !(Array.isArray(name) && name.length === 0); + for (const comment of comments) { + commentBlock.push(comment, hardline2); + } + if (options.length > 0) { + innerDoc.push(join2(" ", options)); + isFirstElement = false; + } + if (animations.length > 0) { + innerDoc.push(isFirstElement ? " " : line2); + innerDoc.push(join2(line2, animations)); + isFirstElement = false; + } + if (isNamed) { + innerDoc.push(isFirstElement ? " " : line2); + innerDoc.push(name); + isFirstElement = false; + } + if (atLocations.length > 0) { + innerDoc.push(isFirstElement || isNamed ? " " : line2); + innerDoc.push(join2(line2, atLocations)); + isFirstElement = false; + } + innerDoc.push(line2, content); + return doc; + } + /** + * Eat a `type === "operation"` node, including its optional arguments. + */ + eatOperation() { + const node = this.nodes[0]; + if ((node == null ? void 0 : node.type) === "operation") { + this.nodes.shift(); + } else { + return []; + } + const doc = []; + if ((node == null ? void 0 : node.type) !== "operation") { + throw new Error("Expecting `operation` node."); + } + const options = this.eatOptionalArg(); + doc.push( + ...options.comments.map( + (c) => printFragment(c, __privateGet(this, _path), __privateGet(this, _print)) + ), + node.content.content + ); + if (options.optionalArg) { + doc.push(indent2(printOptionalArgs(options.optionalArg.content))); + } + return doc; + } +}; +_path = new WeakMap(); +_print = new WeakMap(); +var PATH_JOIN_OPERATIONS = /* @__PURE__ */ new Set(["rectangle", "grid", "sin", "cos", "to"]); +function isPathJoinOperation(node) { + if (!node) { + return false; + } + switch (node.type) { + case "line_to": + case "curve_to": + return true; + case "operation": + return PATH_JOIN_OPERATIONS.has(node.content.content); + } + return false; +} + +// libs/printer/argument.ts +function printArgument(path, print, options) { + const node = path.getNode(); + const { renderInfo, previousNode, nextNode, referenceMap } = getNodeInfo( + node, + options + ); + if (node.openMark === "" && node.closeMark === "" && node.content.length === 0) { + return []; + } + const parentNode = path.getParentNode(); + const { renderInfo: parentRenderInfo } = getNodeInfo(parentNode, options); + if (parentRenderInfo.pgfkeysArgs) { + const leadingComment = node.content.length > 0 && match3.comment(node.content[0]) && node.content[0].sameline ? node.content[0] : null; + const content2 = leadingComment ? node.content.slice(1) : node.content; + trim4(content2); + return printArgumentPgfkeys(content2, { + openMark: node.openMark, + closeMark: node.closeMark, + leadingComment + }); + } + if (parentRenderInfo.tikzPathCommand) { + return printTikzArgument(path, print, options); + } + const openMark = node.openMark; + const closeMark = node.closeMark; + let content = path.map(print, "content"); + content = formatDocArray(node.content, content, options); + if (match3.comment(node.content[node.content.length - 1])) { + content.push(hardline2); + } + let rawRet = [openMark, fill2(content), closeMark]; + if (renderInfo.inParMode) { + rawRet = [openMark, ...content, closeMark]; + } + if (referenceMap) { + referenceMap.setRenderCache(node, rawRet); + } + return rawRet; +} + +// libs/printer/root.ts +import { match as match4 } from "@unified-latex/unified-latex-util-match"; +function hasPreambleCode(nodes) { + return nodes.some((node) => match4.macro(node, "documentclass")); +} +function printRoot(path, print, options) { + const node = path.getNode(); + const { renderInfo, previousNode, nextNode, referenceMap } = getNodeInfo( + node, + options + ); + const content = path.map(print, "content"); + const rawContent = formatDocArray(node.content, content, options); + const concatFunction = hasPreambleCode(node.content) ? (x) => x : fill2; + return concatFunction(rawContent); +} + +// libs/printer/comment.ts +import { printRaw as printRaw4 } from "@unified-latex/unified-latex-util-print-raw"; +function printComment(path, _print2, _options) { + const node = path.getNode(); + let leadingWhitespace = ""; + if (node.leadingWhitespace && node.sameline) { + leadingWhitespace = " "; + } + const content = [leadingWhitespace, "%" + printRaw4(node.content)]; + return content; +} + +// libs/printer/math.ts +function printInlineMath(path, print, options) { + const node = path.getNode(); + if (node.content.length === 0) { + return ["$", " ", "$"]; + } + let content = path.map(print, "content"); + content = formatDocArray(node.content, content, options); + content = joinWithSoftline(content); + if (node.content[node.content.length - 1].type === "comment") { + content.push(hardline2); + } + return fill2(["$", ...content, "$"]); +} +function printDisplayMath(path, print, options) { + const node = path.getNode(); + let content = path.map(print, "content"); + content = formatDocArray(node.content, content, options); + content = joinWithSoftline(content); + const bodyStartToken = [hardline2]; + if (node.content.length === 0 || node.content[0].type === "comment" && node.content[0].sameline) { + bodyStartToken.pop(); + } + return [ + ESCAPE + "[", + indent2(fill2(bodyStartToken.concat(content))), + hardline2, + ESCAPE + "]" + ]; +} + +// libs/printer/environment.ts +import { printRaw as printRaw5 } from "@unified-latex/unified-latex-util-print-raw"; +import { parseAlignEnvironment } from "@unified-latex/unified-latex-util-align"; +import { trim as trim5 } from "@unified-latex/unified-latex-util-trim"; +function printVerbatimEnvironment(path, print, options) { + const node = path.getNode(); + const env = formatEnvSurround(node); + return [env.start, node.content, env.end]; +} +function printEnvironment(path, print, options) { + const node = path.getNode(); + const { renderInfo, previousNode, nextNode, referenceMap } = getNodeInfo( + node, + options + ); + const args = node.args ? path.map(print, "args") : []; + const env = formatEnvSurround(node); + let content = path.map(print, "content"); + content = formatDocArray(node.content, content, options); + if (renderInfo.inMathMode) { + content = joinWithSoftline(content); + } + let bodyStartToken = [hardline2]; + if (node.content.length === 0 || node.content[0].type === "comment" && node.content[0].sameline) { + bodyStartToken.pop(); + } + return [ + env.start, + ...args, + indent2(fill2(bodyStartToken.concat(content))), + hardline2, + env.end + ]; +} +function printAlignedEnvironment(path, print, options) { + const node = path.getNode(); + const { renderInfo, previousNode, nextNode, referenceMap } = getNodeInfo( + node, + options + ); + const args = node.args ? path.map(print, "args") : []; + const env = formatEnvSurround(node); + const leadingComment = node.content[0] && node.content[0].type === "comment" && node.content[0].sameline ? node.content[0] : null; + const { rows, rowSeps, trailingComments } = formatAlignedContent( + leadingComment ? node.content.slice(1) : node.content + ); + const content = []; + for (let i = 0; i < rows.length; i++) { + const row = rows[i]; + const rowSep = rowSeps[i]; + const trailingComment = trailingComments[i]; + content.push(row); + if (rowSep) { + content.push(printRaw5(rowSep)); + } + if (rowSep && trailingComment) { + content.push(" "); + } + if (trailingComment) { + content.push(["%", printRaw5(trailingComment.content)]); + } + if (rowSep || trailingComment) { + content.push(hardline2); + } + } + if (content[content.length - 1] === hardline2) { + content.pop(); + } + if (leadingComment) { + content.unshift( + leadingComment.leadingWhitespace ? " " : "", + "%" + printRaw5(leadingComment.content), + hardline2 + ); + return [env.start, ...args, indent2(content), hardline2, env.end]; + } + return [ + env.start, + ...args, + indent2([hardline2, ...content]), + hardline2, + env.end + ]; +} +function formatAlignedContent(nodes) { + function getSpace(len = 1) { + return " ".repeat(len); + } + const rows = parseAlignEnvironment(nodes); + const numCols = Math.max(...rows.map((r) => r.cells.length)); + const rowSeps = rows.map(({ rowSep }) => printRaw5(rowSep || [])); + const trailingComments = rows.map(({ trailingComment }) => trailingComment); + const renderedRows = rows.map(({ cells, colSeps }) => ({ + cells: cells.map((nodes2) => { + trim5(nodes2); + return printRaw5(nodes2); + }), + seps: colSeps.map((nodes2) => printRaw5(nodes2)) + })); + const colWidths = []; + for (let i = 0; i < numCols; i++) { + colWidths.push( + Math.max( + ...renderedRows.map( + ({ cells, seps }) => ((cells[i] || "") + (seps[i] || "")).length + ) + ) + ); + } + const joinedRows = renderedRows.map(({ cells, seps }) => { + if (cells.length === 1 && cells[0] === "") { + return ""; + } + let ret = ""; + for (let i = 0; i < cells.length; i++) { + const width = colWidths[i] - (seps[i] || "").length; + ret += (i === 0 ? "" : " ") + cells[i] + getSpace(width - cells[i].length + 1) + (seps[i] || ""); + } + return ret; + }); + return { rows: joinedRows, rowSeps, trailingComments }; +} + +// libs/printer/printer.ts +import { + linebreak as linebreak2, + printRaw as printRaw6 +} from "@unified-latex/unified-latex-util-print-raw"; + +// libs/reference-map.ts +import { visit } from "@unified-latex/unified-latex-util-visit"; +var ReferenceMap = class { + constructor(ast) { + this.ast = ast; + this.map = /* @__PURE__ */ new Map(); + visit( + this.ast, + (nodeList) => { + for (let i = 0; i < nodeList.length; i++) { + this.map.set(nodeList[i], { + previous: nodeList[i - 1], + next: nodeList[i + 1] + }); + } + }, + { includeArrays: true, test: Array.isArray } + ); + } + /** + * Associate render-specific data with this node. This data + * will be overwritten if `setRenderCache` is called twice. + * + * @param {Ast.Ast} node + * @param {*} data + * @memberof ReferenceMap + */ + setRenderCache(node, data) { + const currData = this.map.get(node) || {}; + this.map.set(node, { ...currData, renderCache: data }); + } + /** + * Retrieve data associated with `node` via `setRenderCache` + * + * @param {Ast.Ast} node + * @returns {(object | undefined)} + * @memberof ReferenceMap + */ + getRenderCache(node) { + var _a; + return (_a = this.map.get(node)) == null ? void 0 : _a.renderCache; + } + getPreviousNode(node) { + return (this.map.get(node) || {}).previous; + } + getNextNode(node) { + return (this.map.get(node) || {}).next; + } +}; + +// libs/printer/printer.ts +function printLatexAst(path, options, print) { + const node = path.getValue(); + const { renderInfo } = getNodeInfo(node, options); + if (node == null) { + return node; + } + if (typeof node === "string") { + return node; + } + switch (node.type) { + case "root": + if (options.referenceMap) { + console.warn( + "Processing root node, but ReferenceMap already exists. Are there multiple nodes of type 'root'?" + ); + } + options.referenceMap = new ReferenceMap(node); + return printRoot(path, print, options); + case "argument": + return printArgument(path, print, options); + case "comment": + return printComment(path, print, options); + case "environment": + case "mathenv": + if (renderInfo.alignContent) { + return printAlignedEnvironment(path, print, options); + } + return printEnvironment(path, print, options); + case "displaymath": + return printDisplayMath(path, print, options); + case "group": + const content = printRaw6(node.content, { + asArray: true + }).map((token) => token === linebreak2 ? hardline2 : token); + return ["{", ...content, "}"]; + case "inlinemath": + return printInlineMath(path, print, options); + case "macro": + return printMacro(path, print, options); + case "parbreak": + return [hardline2, hardline2]; + case "string": + return node.content; + case "verb": + return [ + ESCAPE, + node.env, + node.escape, + printRaw6(node.content), + node.escape + ]; + case "verbatim": + return printVerbatimEnvironment(path, print, options); + case "whitespace": + return line2; + default: + console.warn("Printing unknown type", node); + return printRaw6(node); + } +} + +// libs/prettier-plugin-latex.ts +import { parse } from "@unified-latex/unified-latex-util-parse"; +var languages = [ + { + name: "latex", + extensions: [".tex"], + parsers: ["latex-parser"] + } +]; +var parsers = { + "latex-parser": { + parse, + astFormat: "latex-ast", + locStart: (node) => node.position ? node.position.start.offset : 0, + locEnd: (node) => node.position ? node.position.end.offset : 1 + } +}; +var printers = { + "latex-ast": { + print: printLatexAst + } +}; +var prettierPluginLatex = { languages, parsers, printers }; +export { + prettierPluginLatex, + printLatexAst, + printLatexAst as printer +}; +//# sourceMappingURL=index.js.map diff --git a/node_modules/@unified-latex/unified-latex-prettier/index.js.map b/node_modules/@unified-latex/unified-latex-prettier/index.js.map new file mode 100644 index 0000000..710d6f3 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-prettier/index.js.map @@ -0,0 +1,7 @@ +{ + "version": 3, + "sources": ["../node_modules/prettier/doc.mjs", "../libs/printer/common.ts", "../libs/zip.ts", "../libs/printer/macro.ts", "../libs/printer/argument.ts", "../libs/printer/tikz.ts", "../libs/printer/print-argument-pgfkeys.ts", "../libs/printer/root.ts", "../libs/printer/comment.ts", "../libs/printer/math.ts", "../libs/printer/environment.ts", "../libs/printer/printer.ts", "../libs/reference-map.ts", "../libs/prettier-plugin-latex.ts"], + "sourcesContent": ["var __defProp = Object.defineProperty;\nvar __export = (target, all) => {\n for (var name in all)\n __defProp(target, name, { get: all[name], enumerable: true });\n};\n\n// src/document/public.js\nvar public_exports = {};\n__export(public_exports, {\n builders: () => builders,\n printer: () => printer,\n utils: () => utils\n});\n\n// src/document/constants.js\nvar DOC_TYPE_STRING = \"string\";\nvar DOC_TYPE_ARRAY = \"array\";\nvar DOC_TYPE_CURSOR = \"cursor\";\nvar DOC_TYPE_INDENT = \"indent\";\nvar DOC_TYPE_ALIGN = \"align\";\nvar DOC_TYPE_TRIM = \"trim\";\nvar DOC_TYPE_GROUP = \"group\";\nvar DOC_TYPE_FILL = \"fill\";\nvar DOC_TYPE_IF_BREAK = \"if-break\";\nvar DOC_TYPE_INDENT_IF_BREAK = \"indent-if-break\";\nvar DOC_TYPE_LINE_SUFFIX = \"line-suffix\";\nvar DOC_TYPE_LINE_SUFFIX_BOUNDARY = \"line-suffix-boundary\";\nvar DOC_TYPE_LINE = \"line\";\nvar DOC_TYPE_LABEL = \"label\";\nvar DOC_TYPE_BREAK_PARENT = \"break-parent\";\nvar VALID_OBJECT_DOC_TYPES = /* @__PURE__ */ new Set([\n DOC_TYPE_CURSOR,\n DOC_TYPE_INDENT,\n DOC_TYPE_ALIGN,\n DOC_TYPE_TRIM,\n DOC_TYPE_GROUP,\n DOC_TYPE_FILL,\n DOC_TYPE_IF_BREAK,\n DOC_TYPE_INDENT_IF_BREAK,\n DOC_TYPE_LINE_SUFFIX,\n DOC_TYPE_LINE_SUFFIX_BOUNDARY,\n DOC_TYPE_LINE,\n DOC_TYPE_LABEL,\n DOC_TYPE_BREAK_PARENT\n]);\n\n// src/document/utils/get-doc-type.js\nfunction getDocType(doc) {\n if (typeof doc === \"string\") {\n return DOC_TYPE_STRING;\n }\n if (Array.isArray(doc)) {\n return DOC_TYPE_ARRAY;\n }\n if (!doc) {\n return;\n }\n const { type } = doc;\n if (VALID_OBJECT_DOC_TYPES.has(type)) {\n return type;\n }\n}\nvar get_doc_type_default = getDocType;\n\n// src/document/invalid-doc-error.js\nvar disjunctionListFormat = (list) => new Intl.ListFormat(\"en-US\", { type: \"disjunction\" }).format(list);\nfunction getDocErrorMessage(doc) {\n const type = doc === null ? \"null\" : typeof doc;\n if (type !== \"string\" && type !== \"object\") {\n return `Unexpected doc '${type}', \nExpected it to be 'string' or 'object'.`;\n }\n if (get_doc_type_default(doc)) {\n throw new Error(\"doc is valid.\");\n }\n const objectType = Object.prototype.toString.call(doc);\n if (objectType !== \"[object Object]\") {\n return `Unexpected doc '${objectType}'.`;\n }\n const EXPECTED_TYPE_VALUES = disjunctionListFormat(\n [...VALID_OBJECT_DOC_TYPES].map((type2) => `'${type2}'`)\n );\n return `Unexpected doc.type '${doc.type}'.\nExpected it to be ${EXPECTED_TYPE_VALUES}.`;\n}\nvar InvalidDocError = class extends Error {\n name = \"InvalidDocError\";\n constructor(doc) {\n super(getDocErrorMessage(doc));\n this.doc = doc;\n }\n};\nvar invalid_doc_error_default = InvalidDocError;\n\n// src/document/utils/traverse-doc.js\nvar traverseDocOnExitStackMarker = {};\nfunction traverseDoc(doc, onEnter, onExit, shouldTraverseConditionalGroups) {\n const docsStack = [doc];\n while (docsStack.length > 0) {\n const doc2 = docsStack.pop();\n if (doc2 === traverseDocOnExitStackMarker) {\n onExit(docsStack.pop());\n continue;\n }\n if (onExit) {\n docsStack.push(doc2, traverseDocOnExitStackMarker);\n }\n const docType = get_doc_type_default(doc2);\n if (!docType) {\n throw new invalid_doc_error_default(doc2);\n }\n if ((onEnter == null ? void 0 : onEnter(doc2)) === false) {\n continue;\n }\n switch (docType) {\n case DOC_TYPE_ARRAY:\n case DOC_TYPE_FILL: {\n const parts = docType === DOC_TYPE_ARRAY ? doc2 : doc2.parts;\n for (let ic = parts.length, i = ic - 1; i >= 0; --i) {\n docsStack.push(parts[i]);\n }\n break;\n }\n case DOC_TYPE_IF_BREAK:\n docsStack.push(doc2.flatContents, doc2.breakContents);\n break;\n case DOC_TYPE_GROUP:\n if (shouldTraverseConditionalGroups && doc2.expandedStates) {\n for (let ic = doc2.expandedStates.length, i = ic - 1; i >= 0; --i) {\n docsStack.push(doc2.expandedStates[i]);\n }\n } else {\n docsStack.push(doc2.contents);\n }\n break;\n case DOC_TYPE_ALIGN:\n case DOC_TYPE_INDENT:\n case DOC_TYPE_INDENT_IF_BREAK:\n case DOC_TYPE_LABEL:\n case DOC_TYPE_LINE_SUFFIX:\n docsStack.push(doc2.contents);\n break;\n case DOC_TYPE_STRING:\n case DOC_TYPE_CURSOR:\n case DOC_TYPE_TRIM:\n case DOC_TYPE_LINE_SUFFIX_BOUNDARY:\n case DOC_TYPE_LINE:\n case DOC_TYPE_BREAK_PARENT:\n break;\n default:\n throw new invalid_doc_error_default(doc2);\n }\n }\n}\nvar traverse_doc_default = traverseDoc;\n\n// src/document/utils/assert-doc.js\nvar noop = () => {\n};\nvar assertDoc = true ? noop : function(doc) {\n traverse_doc_default(doc, (doc2) => {\n if (checked.has(doc2)) {\n return false;\n }\n if (typeof doc2 !== \"string\") {\n checked.add(doc2);\n }\n });\n};\nvar assertDocArray = true ? noop : function(docs, optional = false) {\n if (optional && !docs) {\n return;\n }\n if (!Array.isArray(docs)) {\n throw new TypeError(\"Unexpected doc array.\");\n }\n for (const doc of docs) {\n assertDoc(doc);\n }\n};\n\n// src/document/builders.js\nfunction indent(contents) {\n assertDoc(contents);\n return { type: DOC_TYPE_INDENT, contents };\n}\nfunction align(widthOrString, contents) {\n assertDoc(contents);\n return { type: DOC_TYPE_ALIGN, contents, n: widthOrString };\n}\nfunction group(contents, opts = {}) {\n assertDoc(contents);\n assertDocArray(\n opts.expandedStates,\n /* optional */\n true\n );\n return {\n type: DOC_TYPE_GROUP,\n id: opts.id,\n contents,\n break: Boolean(opts.shouldBreak),\n expandedStates: opts.expandedStates\n };\n}\nfunction dedentToRoot(contents) {\n return align(Number.NEGATIVE_INFINITY, contents);\n}\nfunction markAsRoot(contents) {\n return align({ type: \"root\" }, contents);\n}\nfunction dedent(contents) {\n return align(-1, contents);\n}\nfunction conditionalGroup(states, opts) {\n return group(states[0], { ...opts, expandedStates: states });\n}\nfunction fill(parts) {\n assertDocArray(parts);\n return { type: DOC_TYPE_FILL, parts };\n}\nfunction ifBreak(breakContents, flatContents = \"\", opts = {}) {\n assertDoc(breakContents);\n if (flatContents !== \"\") {\n assertDoc(flatContents);\n }\n return {\n type: DOC_TYPE_IF_BREAK,\n breakContents,\n flatContents,\n groupId: opts.groupId\n };\n}\nfunction indentIfBreak(contents, opts) {\n assertDoc(contents);\n return {\n type: DOC_TYPE_INDENT_IF_BREAK,\n contents,\n groupId: opts.groupId,\n negate: opts.negate\n };\n}\nfunction lineSuffix(contents) {\n assertDoc(contents);\n return { type: DOC_TYPE_LINE_SUFFIX, contents };\n}\nvar lineSuffixBoundary = { type: DOC_TYPE_LINE_SUFFIX_BOUNDARY };\nvar breakParent = { type: DOC_TYPE_BREAK_PARENT };\nvar trim = { type: DOC_TYPE_TRIM };\nvar hardlineWithoutBreakParent = { type: DOC_TYPE_LINE, hard: true };\nvar literallineWithoutBreakParent = {\n type: DOC_TYPE_LINE,\n hard: true,\n literal: true\n};\nvar line = { type: DOC_TYPE_LINE };\nvar softline = { type: DOC_TYPE_LINE, soft: true };\nvar hardline = [hardlineWithoutBreakParent, breakParent];\nvar literalline = [literallineWithoutBreakParent, breakParent];\nvar cursor = { type: DOC_TYPE_CURSOR };\nfunction join(separator, docs) {\n assertDoc(separator);\n assertDocArray(docs);\n const parts = [];\n for (let i = 0; i < docs.length; i++) {\n if (i !== 0) {\n parts.push(separator);\n }\n parts.push(docs[i]);\n }\n return parts;\n}\nfunction addAlignmentToDoc(doc, size, tabWidth) {\n assertDoc(doc);\n let aligned = doc;\n if (size > 0) {\n for (let i = 0; i < Math.floor(size / tabWidth); ++i) {\n aligned = indent(aligned);\n }\n aligned = align(size % tabWidth, aligned);\n aligned = align(Number.NEGATIVE_INFINITY, aligned);\n }\n return aligned;\n}\nfunction label(label2, contents) {\n assertDoc(contents);\n return label2 ? { type: DOC_TYPE_LABEL, label: label2, contents } : contents;\n}\n\n// scripts/build/shims/at.js\nvar at = (isOptionalObject, object, index) => {\n if (isOptionalObject && (object === void 0 || object === null)) {\n return;\n }\n if (Array.isArray(object) || typeof object === \"string\") {\n return object[index < 0 ? object.length + index : index];\n }\n return object.at(index);\n};\nvar at_default = at;\n\n// scripts/build/shims/string-replace-all.js\nvar stringReplaceAll = (isOptionalObject, original, pattern, replacement) => {\n if (isOptionalObject && (original === void 0 || original === null)) {\n return;\n }\n if (original.replaceAll) {\n return original.replaceAll(pattern, replacement);\n }\n if (pattern.global) {\n return original.replace(pattern, replacement);\n }\n return original.split(pattern).join(replacement);\n};\nvar string_replace_all_default = stringReplaceAll;\n\n// src/common/end-of-line.js\nfunction convertEndOfLineToChars(value) {\n switch (value) {\n case \"cr\":\n return \"\\r\";\n case \"crlf\":\n return \"\\r\\n\";\n default:\n return \"\\n\";\n }\n}\n\n// node_modules/emoji-regex/index.mjs\nvar emoji_regex_default = () => {\n return /[#*0-9]\\uFE0F?\\u20E3|[\\xA9\\xAE\\u203C\\u2049\\u2122\\u2139\\u2194-\\u2199\\u21A9\\u21AA\\u231A\\u231B\\u2328\\u23CF\\u23ED-\\u23EF\\u23F1\\u23F2\\u23F8-\\u23FA\\u24C2\\u25AA\\u25AB\\u25B6\\u25C0\\u25FB\\u25FC\\u25FE\\u2600-\\u2604\\u260E\\u2611\\u2614\\u2615\\u2618\\u2620\\u2622\\u2623\\u2626\\u262A\\u262E\\u262F\\u2638-\\u263A\\u2640\\u2642\\u2648-\\u2653\\u265F\\u2660\\u2663\\u2665\\u2666\\u2668\\u267B\\u267E\\u267F\\u2692\\u2694-\\u2697\\u2699\\u269B\\u269C\\u26A0\\u26A7\\u26AA\\u26B0\\u26B1\\u26BD\\u26BE\\u26C4\\u26C8\\u26CF\\u26D1\\u26D3\\u26E9\\u26F0-\\u26F5\\u26F7\\u26F8\\u26FA\\u2702\\u2708\\u2709\\u270F\\u2712\\u2714\\u2716\\u271D\\u2721\\u2733\\u2734\\u2744\\u2747\\u2757\\u2763\\u27A1\\u2934\\u2935\\u2B05-\\u2B07\\u2B1B\\u2B1C\\u2B55\\u3030\\u303D\\u3297\\u3299]\\uFE0F?|[\\u261D\\u270C\\u270D](?:\\uFE0F|\\uD83C[\\uDFFB-\\uDFFF])?|[\\u270A\\u270B](?:\\uD83C[\\uDFFB-\\uDFFF])?|[\\u23E9-\\u23EC\\u23F0\\u23F3\\u25FD\\u2693\\u26A1\\u26AB\\u26C5\\u26CE\\u26D4\\u26EA\\u26FD\\u2705\\u2728\\u274C\\u274E\\u2753-\\u2755\\u2795-\\u2797\\u27B0\\u27BF\\u2B50]|\\u26F9(?:\\uFE0F|\\uD83C[\\uDFFB-\\uDFFF])?(?:\\u200D[\\u2640\\u2642]\\uFE0F?)?|\\u2764\\uFE0F?(?:\\u200D(?:\\uD83D\\uDD25|\\uD83E\\uDE79))?|\\uD83C(?:[\\uDC04\\uDD70\\uDD71\\uDD7E\\uDD7F\\uDE02\\uDE37\\uDF21\\uDF24-\\uDF2C\\uDF36\\uDF7D\\uDF96\\uDF97\\uDF99-\\uDF9B\\uDF9E\\uDF9F\\uDFCD\\uDFCE\\uDFD4-\\uDFDF\\uDFF5\\uDFF7]\\uFE0F?|[\\uDF85\\uDFC2\\uDFC7](?:\\uD83C[\\uDFFB-\\uDFFF])?|[\\uDFC3\\uDFC4\\uDFCA](?:\\uD83C[\\uDFFB-\\uDFFF])?(?:\\u200D[\\u2640\\u2642]\\uFE0F?)?|[\\uDFCB\\uDFCC](?:\\uFE0F|\\uD83C[\\uDFFB-\\uDFFF])?(?:\\u200D[\\u2640\\u2642]\\uFE0F?)?|[\\uDCCF\\uDD8E\\uDD91-\\uDD9A\\uDE01\\uDE1A\\uDE2F\\uDE32-\\uDE36\\uDE38-\\uDE3A\\uDE50\\uDE51\\uDF00-\\uDF20\\uDF2D-\\uDF35\\uDF37-\\uDF7C\\uDF7E-\\uDF84\\uDF86-\\uDF93\\uDFA0-\\uDFC1\\uDFC5\\uDFC6\\uDFC8\\uDFC9\\uDFCF-\\uDFD3\\uDFE0-\\uDFF0\\uDFF8-\\uDFFF]|\\uDDE6\\uD83C[\\uDDE8-\\uDDEC\\uDDEE\\uDDF1\\uDDF2\\uDDF4\\uDDF6-\\uDDFA\\uDDFC\\uDDFD\\uDDFF]|\\uDDE7\\uD83C[\\uDDE6\\uDDE7\\uDDE9-\\uDDEF\\uDDF1-\\uDDF4\\uDDF6-\\uDDF9\\uDDFB\\uDDFC\\uDDFE\\uDDFF]|\\uDDE8\\uD83C[\\uDDE6\\uDDE8\\uDDE9\\uDDEB-\\uDDEE\\uDDF0-\\uDDF5\\uDDF7\\uDDFA-\\uDDFF]|\\uDDE9\\uD83C[\\uDDEA\\uDDEC\\uDDEF\\uDDF0\\uDDF2\\uDDF4\\uDDFF]|\\uDDEA\\uD83C[\\uDDE6\\uDDE8\\uDDEA\\uDDEC\\uDDED\\uDDF7-\\uDDFA]|\\uDDEB\\uD83C[\\uDDEE-\\uDDF0\\uDDF2\\uDDF4\\uDDF7]|\\uDDEC\\uD83C[\\uDDE6\\uDDE7\\uDDE9-\\uDDEE\\uDDF1-\\uDDF3\\uDDF5-\\uDDFA\\uDDFC\\uDDFE]|\\uDDED\\uD83C[\\uDDF0\\uDDF2\\uDDF3\\uDDF7\\uDDF9\\uDDFA]|\\uDDEE\\uD83C[\\uDDE8-\\uDDEA\\uDDF1-\\uDDF4\\uDDF6-\\uDDF9]|\\uDDEF\\uD83C[\\uDDEA\\uDDF2\\uDDF4\\uDDF5]|\\uDDF0\\uD83C[\\uDDEA\\uDDEC-\\uDDEE\\uDDF2\\uDDF3\\uDDF5\\uDDF7\\uDDFC\\uDDFE\\uDDFF]|\\uDDF1\\uD83C[\\uDDE6-\\uDDE8\\uDDEE\\uDDF0\\uDDF7-\\uDDFB\\uDDFE]|\\uDDF2\\uD83C[\\uDDE6\\uDDE8-\\uDDED\\uDDF0-\\uDDFF]|\\uDDF3\\uD83C[\\uDDE6\\uDDE8\\uDDEA-\\uDDEC\\uDDEE\\uDDF1\\uDDF4\\uDDF5\\uDDF7\\uDDFA\\uDDFF]|\\uDDF4\\uD83C\\uDDF2|\\uDDF5\\uD83C[\\uDDE6\\uDDEA-\\uDDED\\uDDF0-\\uDDF3\\uDDF7-\\uDDF9\\uDDFC\\uDDFE]|\\uDDF6\\uD83C\\uDDE6|\\uDDF7\\uD83C[\\uDDEA\\uDDF4\\uDDF8\\uDDFA\\uDDFC]|\\uDDF8\\uD83C[\\uDDE6-\\uDDEA\\uDDEC-\\uDDF4\\uDDF7-\\uDDF9\\uDDFB\\uDDFD-\\uDDFF]|\\uDDF9\\uD83C[\\uDDE6\\uDDE8\\uDDE9\\uDDEB-\\uDDED\\uDDEF-\\uDDF4\\uDDF7\\uDDF9\\uDDFB\\uDDFC\\uDDFF]|\\uDDFA\\uD83C[\\uDDE6\\uDDEC\\uDDF2\\uDDF3\\uDDF8\\uDDFE\\uDDFF]|\\uDDFB\\uD83C[\\uDDE6\\uDDE8\\uDDEA\\uDDEC\\uDDEE\\uDDF3\\uDDFA]|\\uDDFC\\uD83C[\\uDDEB\\uDDF8]|\\uDDFD\\uD83C\\uDDF0|\\uDDFE\\uD83C[\\uDDEA\\uDDF9]|\\uDDFF\\uD83C[\\uDDE6\\uDDF2\\uDDFC]|\\uDFF3\\uFE0F?(?:\\u200D(?:\\u26A7\\uFE0F?|\\uD83C\\uDF08))?|\\uDFF4(?:\\u200D\\u2620\\uFE0F?|\\uDB40\\uDC67\\uDB40\\uDC62\\uDB40(?:\\uDC65\\uDB40\\uDC6E\\uDB40\\uDC67|\\uDC73\\uDB40\\uDC63\\uDB40\\uDC74|\\uDC77\\uDB40\\uDC6C\\uDB40\\uDC73)\\uDB40\\uDC7F)?)|\\uD83D(?:[\\uDC08\\uDC26](?:\\u200D\\u2B1B)?|[\\uDC3F\\uDCFD\\uDD49\\uDD4A\\uDD6F\\uDD70\\uDD73\\uDD76-\\uDD79\\uDD87\\uDD8A-\\uDD8D\\uDDA5\\uDDA8\\uDDB1\\uDDB2\\uDDBC\\uDDC2-\\uDDC4\\uDDD1-\\uDDD3\\uDDDC-\\uDDDE\\uDDE1\\uDDE3\\uDDE8\\uDDEF\\uDDF3\\uDDFA\\uDECB\\uDECD-\\uDECF\\uDEE0-\\uDEE5\\uDEE9\\uDEF0\\uDEF3]\\uFE0F?|[\\uDC42\\uDC43\\uDC46-\\uDC50\\uDC66\\uDC67\\uDC6B-\\uDC6D\\uDC72\\uDC74-\\uDC76\\uDC78\\uDC7C\\uDC83\\uDC85\\uDC8F\\uDC91\\uDCAA\\uDD7A\\uDD95\\uDD96\\uDE4C\\uDE4F\\uDEC0\\uDECC](?:\\uD83C[\\uDFFB-\\uDFFF])?|[\\uDC6E\\uDC70\\uDC71\\uDC73\\uDC77\\uDC81\\uDC82\\uDC86\\uDC87\\uDE45-\\uDE47\\uDE4B\\uDE4D\\uDE4E\\uDEA3\\uDEB4-\\uDEB6](?:\\uD83C[\\uDFFB-\\uDFFF])?(?:\\u200D[\\u2640\\u2642]\\uFE0F?)?|[\\uDD74\\uDD90](?:\\uFE0F|\\uD83C[\\uDFFB-\\uDFFF])?|[\\uDC00-\\uDC07\\uDC09-\\uDC14\\uDC16-\\uDC25\\uDC27-\\uDC3A\\uDC3C-\\uDC3E\\uDC40\\uDC44\\uDC45\\uDC51-\\uDC65\\uDC6A\\uDC79-\\uDC7B\\uDC7D-\\uDC80\\uDC84\\uDC88-\\uDC8E\\uDC90\\uDC92-\\uDCA9\\uDCAB-\\uDCFC\\uDCFF-\\uDD3D\\uDD4B-\\uDD4E\\uDD50-\\uDD67\\uDDA4\\uDDFB-\\uDE2D\\uDE2F-\\uDE34\\uDE37-\\uDE44\\uDE48-\\uDE4A\\uDE80-\\uDEA2\\uDEA4-\\uDEB3\\uDEB7-\\uDEBF\\uDEC1-\\uDEC5\\uDED0-\\uDED2\\uDED5-\\uDED7\\uDEDC-\\uDEDF\\uDEEB\\uDEEC\\uDEF4-\\uDEFC\\uDFE0-\\uDFEB\\uDFF0]|\\uDC15(?:\\u200D\\uD83E\\uDDBA)?|\\uDC3B(?:\\u200D\\u2744\\uFE0F?)?|\\uDC41\\uFE0F?(?:\\u200D\\uD83D\\uDDE8\\uFE0F?)?|\\uDC68(?:\\u200D(?:[\\u2695\\u2696\\u2708]\\uFE0F?|\\u2764\\uFE0F?\\u200D\\uD83D(?:\\uDC8B\\u200D\\uD83D)?\\uDC68|\\uD83C[\\uDF3E\\uDF73\\uDF7C\\uDF93\\uDFA4\\uDFA8\\uDFEB\\uDFED]|\\uD83D(?:[\\uDC68\\uDC69]\\u200D\\uD83D(?:\\uDC66(?:\\u200D\\uD83D\\uDC66)?|\\uDC67(?:\\u200D\\uD83D[\\uDC66\\uDC67])?)|[\\uDCBB\\uDCBC\\uDD27\\uDD2C\\uDE80\\uDE92]|\\uDC66(?:\\u200D\\uD83D\\uDC66)?|\\uDC67(?:\\u200D\\uD83D[\\uDC66\\uDC67])?)|\\uD83E[\\uDDAF-\\uDDB3\\uDDBC\\uDDBD])|\\uD83C(?:\\uDFFB(?:\\u200D(?:[\\u2695\\u2696\\u2708]\\uFE0F?|\\u2764\\uFE0F?\\u200D\\uD83D(?:\\uDC8B\\u200D\\uD83D)?\\uDC68\\uD83C[\\uDFFB-\\uDFFF]|\\uD83C[\\uDF3E\\uDF73\\uDF7C\\uDF93\\uDFA4\\uDFA8\\uDFEB\\uDFED]|\\uD83D[\\uDCBB\\uDCBC\\uDD27\\uDD2C\\uDE80\\uDE92]|\\uD83E(?:[\\uDDAF-\\uDDB3\\uDDBC\\uDDBD]|\\uDD1D\\u200D\\uD83D\\uDC68\\uD83C[\\uDFFC-\\uDFFF])))?|\\uDFFC(?:\\u200D(?:[\\u2695\\u2696\\u2708]\\uFE0F?|\\u2764\\uFE0F?\\u200D\\uD83D(?:\\uDC8B\\u200D\\uD83D)?\\uDC68\\uD83C[\\uDFFB-\\uDFFF]|\\uD83C[\\uDF3E\\uDF73\\uDF7C\\uDF93\\uDFA4\\uDFA8\\uDFEB\\uDFED]|\\uD83D[\\uDCBB\\uDCBC\\uDD27\\uDD2C\\uDE80\\uDE92]|\\uD83E(?:[\\uDDAF-\\uDDB3\\uDDBC\\uDDBD]|\\uDD1D\\u200D\\uD83D\\uDC68\\uD83C[\\uDFFB\\uDFFD-\\uDFFF])))?|\\uDFFD(?:\\u200D(?:[\\u2695\\u2696\\u2708]\\uFE0F?|\\u2764\\uFE0F?\\u200D\\uD83D(?:\\uDC8B\\u200D\\uD83D)?\\uDC68\\uD83C[\\uDFFB-\\uDFFF]|\\uD83C[\\uDF3E\\uDF73\\uDF7C\\uDF93\\uDFA4\\uDFA8\\uDFEB\\uDFED]|\\uD83D[\\uDCBB\\uDCBC\\uDD27\\uDD2C\\uDE80\\uDE92]|\\uD83E(?:[\\uDDAF-\\uDDB3\\uDDBC\\uDDBD]|\\uDD1D\\u200D\\uD83D\\uDC68\\uD83C[\\uDFFB\\uDFFC\\uDFFE\\uDFFF])))?|\\uDFFE(?:\\u200D(?:[\\u2695\\u2696\\u2708]\\uFE0F?|\\u2764\\uFE0F?\\u200D\\uD83D(?:\\uDC8B\\u200D\\uD83D)?\\uDC68\\uD83C[\\uDFFB-\\uDFFF]|\\uD83C[\\uDF3E\\uDF73\\uDF7C\\uDF93\\uDFA4\\uDFA8\\uDFEB\\uDFED]|\\uD83D[\\uDCBB\\uDCBC\\uDD27\\uDD2C\\uDE80\\uDE92]|\\uD83E(?:[\\uDDAF-\\uDDB3\\uDDBC\\uDDBD]|\\uDD1D\\u200D\\uD83D\\uDC68\\uD83C[\\uDFFB-\\uDFFD\\uDFFF])))?|\\uDFFF(?:\\u200D(?:[\\u2695\\u2696\\u2708]\\uFE0F?|\\u2764\\uFE0F?\\u200D\\uD83D(?:\\uDC8B\\u200D\\uD83D)?\\uDC68\\uD83C[\\uDFFB-\\uDFFF]|\\uD83C[\\uDF3E\\uDF73\\uDF7C\\uDF93\\uDFA4\\uDFA8\\uDFEB\\uDFED]|\\uD83D[\\uDCBB\\uDCBC\\uDD27\\uDD2C\\uDE80\\uDE92]|\\uD83E(?:[\\uDDAF-\\uDDB3\\uDDBC\\uDDBD]|\\uDD1D\\u200D\\uD83D\\uDC68\\uD83C[\\uDFFB-\\uDFFE])))?))?|\\uDC69(?:\\u200D(?:[\\u2695\\u2696\\u2708]\\uFE0F?|\\u2764\\uFE0F?\\u200D\\uD83D(?:\\uDC8B\\u200D\\uD83D)?[\\uDC68\\uDC69]|\\uD83C[\\uDF3E\\uDF73\\uDF7C\\uDF93\\uDFA4\\uDFA8\\uDFEB\\uDFED]|\\uD83D(?:[\\uDCBB\\uDCBC\\uDD27\\uDD2C\\uDE80\\uDE92]|\\uDC66(?:\\u200D\\uD83D\\uDC66)?|\\uDC67(?:\\u200D\\uD83D[\\uDC66\\uDC67])?|\\uDC69\\u200D\\uD83D(?:\\uDC66(?:\\u200D\\uD83D\\uDC66)?|\\uDC67(?:\\u200D\\uD83D[\\uDC66\\uDC67])?))|\\uD83E[\\uDDAF-\\uDDB3\\uDDBC\\uDDBD])|\\uD83C(?:\\uDFFB(?:\\u200D(?:[\\u2695\\u2696\\u2708]\\uFE0F?|\\u2764\\uFE0F?\\u200D\\uD83D(?:[\\uDC68\\uDC69]|\\uDC8B\\u200D\\uD83D[\\uDC68\\uDC69])\\uD83C[\\uDFFB-\\uDFFF]|\\uD83C[\\uDF3E\\uDF73\\uDF7C\\uDF93\\uDFA4\\uDFA8\\uDFEB\\uDFED]|\\uD83D[\\uDCBB\\uDCBC\\uDD27\\uDD2C\\uDE80\\uDE92]|\\uD83E(?:[\\uDDAF-\\uDDB3\\uDDBC\\uDDBD]|\\uDD1D\\u200D\\uD83D[\\uDC68\\uDC69]\\uD83C[\\uDFFC-\\uDFFF])))?|\\uDFFC(?:\\u200D(?:[\\u2695\\u2696\\u2708]\\uFE0F?|\\u2764\\uFE0F?\\u200D\\uD83D(?:[\\uDC68\\uDC69]|\\uDC8B\\u200D\\uD83D[\\uDC68\\uDC69])\\uD83C[\\uDFFB-\\uDFFF]|\\uD83C[\\uDF3E\\uDF73\\uDF7C\\uDF93\\uDFA4\\uDFA8\\uDFEB\\uDFED]|\\uD83D[\\uDCBB\\uDCBC\\uDD27\\uDD2C\\uDE80\\uDE92]|\\uD83E(?:[\\uDDAF-\\uDDB3\\uDDBC\\uDDBD]|\\uDD1D\\u200D\\uD83D[\\uDC68\\uDC69]\\uD83C[\\uDFFB\\uDFFD-\\uDFFF])))?|\\uDFFD(?:\\u200D(?:[\\u2695\\u2696\\u2708]\\uFE0F?|\\u2764\\uFE0F?\\u200D\\uD83D(?:[\\uDC68\\uDC69]|\\uDC8B\\u200D\\uD83D[\\uDC68\\uDC69])\\uD83C[\\uDFFB-\\uDFFF]|\\uD83C[\\uDF3E\\uDF73\\uDF7C\\uDF93\\uDFA4\\uDFA8\\uDFEB\\uDFED]|\\uD83D[\\uDCBB\\uDCBC\\uDD27\\uDD2C\\uDE80\\uDE92]|\\uD83E(?:[\\uDDAF-\\uDDB3\\uDDBC\\uDDBD]|\\uDD1D\\u200D\\uD83D[\\uDC68\\uDC69]\\uD83C[\\uDFFB\\uDFFC\\uDFFE\\uDFFF])))?|\\uDFFE(?:\\u200D(?:[\\u2695\\u2696\\u2708]\\uFE0F?|\\u2764\\uFE0F?\\u200D\\uD83D(?:[\\uDC68\\uDC69]|\\uDC8B\\u200D\\uD83D[\\uDC68\\uDC69])\\uD83C[\\uDFFB-\\uDFFF]|\\uD83C[\\uDF3E\\uDF73\\uDF7C\\uDF93\\uDFA4\\uDFA8\\uDFEB\\uDFED]|\\uD83D[\\uDCBB\\uDCBC\\uDD27\\uDD2C\\uDE80\\uDE92]|\\uD83E(?:[\\uDDAF-\\uDDB3\\uDDBC\\uDDBD]|\\uDD1D\\u200D\\uD83D[\\uDC68\\uDC69]\\uD83C[\\uDFFB-\\uDFFD\\uDFFF])))?|\\uDFFF(?:\\u200D(?:[\\u2695\\u2696\\u2708]\\uFE0F?|\\u2764\\uFE0F?\\u200D\\uD83D(?:[\\uDC68\\uDC69]|\\uDC8B\\u200D\\uD83D[\\uDC68\\uDC69])\\uD83C[\\uDFFB-\\uDFFF]|\\uD83C[\\uDF3E\\uDF73\\uDF7C\\uDF93\\uDFA4\\uDFA8\\uDFEB\\uDFED]|\\uD83D[\\uDCBB\\uDCBC\\uDD27\\uDD2C\\uDE80\\uDE92]|\\uD83E(?:[\\uDDAF-\\uDDB3\\uDDBC\\uDDBD]|\\uDD1D\\u200D\\uD83D[\\uDC68\\uDC69]\\uD83C[\\uDFFB-\\uDFFE])))?))?|\\uDC6F(?:\\u200D[\\u2640\\u2642]\\uFE0F?)?|\\uDD75(?:\\uFE0F|\\uD83C[\\uDFFB-\\uDFFF])?(?:\\u200D[\\u2640\\u2642]\\uFE0F?)?|\\uDE2E(?:\\u200D\\uD83D\\uDCA8)?|\\uDE35(?:\\u200D\\uD83D\\uDCAB)?|\\uDE36(?:\\u200D\\uD83C\\uDF2B\\uFE0F?)?)|\\uD83E(?:[\\uDD0C\\uDD0F\\uDD18-\\uDD1F\\uDD30-\\uDD34\\uDD36\\uDD77\\uDDB5\\uDDB6\\uDDBB\\uDDD2\\uDDD3\\uDDD5\\uDEC3-\\uDEC5\\uDEF0\\uDEF2-\\uDEF8](?:\\uD83C[\\uDFFB-\\uDFFF])?|[\\uDD26\\uDD35\\uDD37-\\uDD39\\uDD3D\\uDD3E\\uDDB8\\uDDB9\\uDDCD-\\uDDCF\\uDDD4\\uDDD6-\\uDDDD](?:\\uD83C[\\uDFFB-\\uDFFF])?(?:\\u200D[\\u2640\\u2642]\\uFE0F?)?|[\\uDDDE\\uDDDF](?:\\u200D[\\u2640\\u2642]\\uFE0F?)?|[\\uDD0D\\uDD0E\\uDD10-\\uDD17\\uDD20-\\uDD25\\uDD27-\\uDD2F\\uDD3A\\uDD3F-\\uDD45\\uDD47-\\uDD76\\uDD78-\\uDDB4\\uDDB7\\uDDBA\\uDDBC-\\uDDCC\\uDDD0\\uDDE0-\\uDDFF\\uDE70-\\uDE7C\\uDE80-\\uDE88\\uDE90-\\uDEBD\\uDEBF-\\uDEC2\\uDECE-\\uDEDB\\uDEE0-\\uDEE8]|\\uDD3C(?:\\u200D[\\u2640\\u2642]\\uFE0F?|\\uD83C[\\uDFFB-\\uDFFF])?|\\uDDD1(?:\\u200D(?:[\\u2695\\u2696\\u2708]\\uFE0F?|\\uD83C[\\uDF3E\\uDF73\\uDF7C\\uDF84\\uDF93\\uDFA4\\uDFA8\\uDFEB\\uDFED]|\\uD83D[\\uDCBB\\uDCBC\\uDD27\\uDD2C\\uDE80\\uDE92]|\\uD83E(?:[\\uDDAF-\\uDDB3\\uDDBC\\uDDBD]|\\uDD1D\\u200D\\uD83E\\uDDD1))|\\uD83C(?:\\uDFFB(?:\\u200D(?:[\\u2695\\u2696\\u2708]\\uFE0F?|\\u2764\\uFE0F?\\u200D(?:\\uD83D\\uDC8B\\u200D)?\\uD83E\\uDDD1\\uD83C[\\uDFFC-\\uDFFF]|\\uD83C[\\uDF3E\\uDF73\\uDF7C\\uDF84\\uDF93\\uDFA4\\uDFA8\\uDFEB\\uDFED]|\\uD83D[\\uDCBB\\uDCBC\\uDD27\\uDD2C\\uDE80\\uDE92]|\\uD83E(?:[\\uDDAF-\\uDDB3\\uDDBC\\uDDBD]|\\uDD1D\\u200D\\uD83E\\uDDD1\\uD83C[\\uDFFB-\\uDFFF])))?|\\uDFFC(?:\\u200D(?:[\\u2695\\u2696\\u2708]\\uFE0F?|\\u2764\\uFE0F?\\u200D(?:\\uD83D\\uDC8B\\u200D)?\\uD83E\\uDDD1\\uD83C[\\uDFFB\\uDFFD-\\uDFFF]|\\uD83C[\\uDF3E\\uDF73\\uDF7C\\uDF84\\uDF93\\uDFA4\\uDFA8\\uDFEB\\uDFED]|\\uD83D[\\uDCBB\\uDCBC\\uDD27\\uDD2C\\uDE80\\uDE92]|\\uD83E(?:[\\uDDAF-\\uDDB3\\uDDBC\\uDDBD]|\\uDD1D\\u200D\\uD83E\\uDDD1\\uD83C[\\uDFFB-\\uDFFF])))?|\\uDFFD(?:\\u200D(?:[\\u2695\\u2696\\u2708]\\uFE0F?|\\u2764\\uFE0F?\\u200D(?:\\uD83D\\uDC8B\\u200D)?\\uD83E\\uDDD1\\uD83C[\\uDFFB\\uDFFC\\uDFFE\\uDFFF]|\\uD83C[\\uDF3E\\uDF73\\uDF7C\\uDF84\\uDF93\\uDFA4\\uDFA8\\uDFEB\\uDFED]|\\uD83D[\\uDCBB\\uDCBC\\uDD27\\uDD2C\\uDE80\\uDE92]|\\uD83E(?:[\\uDDAF-\\uDDB3\\uDDBC\\uDDBD]|\\uDD1D\\u200D\\uD83E\\uDDD1\\uD83C[\\uDFFB-\\uDFFF])))?|\\uDFFE(?:\\u200D(?:[\\u2695\\u2696\\u2708]\\uFE0F?|\\u2764\\uFE0F?\\u200D(?:\\uD83D\\uDC8B\\u200D)?\\uD83E\\uDDD1\\uD83C[\\uDFFB-\\uDFFD\\uDFFF]|\\uD83C[\\uDF3E\\uDF73\\uDF7C\\uDF84\\uDF93\\uDFA4\\uDFA8\\uDFEB\\uDFED]|\\uD83D[\\uDCBB\\uDCBC\\uDD27\\uDD2C\\uDE80\\uDE92]|\\uD83E(?:[\\uDDAF-\\uDDB3\\uDDBC\\uDDBD]|\\uDD1D\\u200D\\uD83E\\uDDD1\\uD83C[\\uDFFB-\\uDFFF])))?|\\uDFFF(?:\\u200D(?:[\\u2695\\u2696\\u2708]\\uFE0F?|\\u2764\\uFE0F?\\u200D(?:\\uD83D\\uDC8B\\u200D)?\\uD83E\\uDDD1\\uD83C[\\uDFFB-\\uDFFE]|\\uD83C[\\uDF3E\\uDF73\\uDF7C\\uDF84\\uDF93\\uDFA4\\uDFA8\\uDFEB\\uDFED]|\\uD83D[\\uDCBB\\uDCBC\\uDD27\\uDD2C\\uDE80\\uDE92]|\\uD83E(?:[\\uDDAF-\\uDDB3\\uDDBC\\uDDBD]|\\uDD1D\\u200D\\uD83E\\uDDD1\\uD83C[\\uDFFB-\\uDFFF])))?))?|\\uDEF1(?:\\uD83C(?:\\uDFFB(?:\\u200D\\uD83E\\uDEF2\\uD83C[\\uDFFC-\\uDFFF])?|\\uDFFC(?:\\u200D\\uD83E\\uDEF2\\uD83C[\\uDFFB\\uDFFD-\\uDFFF])?|\\uDFFD(?:\\u200D\\uD83E\\uDEF2\\uD83C[\\uDFFB\\uDFFC\\uDFFE\\uDFFF])?|\\uDFFE(?:\\u200D\\uD83E\\uDEF2\\uD83C[\\uDFFB-\\uDFFD\\uDFFF])?|\\uDFFF(?:\\u200D\\uD83E\\uDEF2\\uD83C[\\uDFFB-\\uDFFE])?))?)/g;\n};\n\n// node_modules/eastasianwidth/eastasianwidth.js\nvar eastasianwidth_default = {\n eastAsianWidth(character) {\n var x = character.charCodeAt(0);\n var y = character.length == 2 ? character.charCodeAt(1) : 0;\n var codePoint = x;\n if (55296 <= x && x <= 56319 && 56320 <= y && y <= 57343) {\n x &= 1023;\n y &= 1023;\n codePoint = x << 10 | y;\n codePoint += 65536;\n }\n if (12288 == codePoint || 65281 <= codePoint && codePoint <= 65376 || 65504 <= codePoint && codePoint <= 65510) {\n return \"F\";\n }\n if (4352 <= codePoint && codePoint <= 4447 || 4515 <= codePoint && codePoint <= 4519 || 4602 <= codePoint && codePoint <= 4607 || 9001 <= codePoint && codePoint <= 9002 || 11904 <= codePoint && codePoint <= 11929 || 11931 <= codePoint && codePoint <= 12019 || 12032 <= codePoint && codePoint <= 12245 || 12272 <= codePoint && codePoint <= 12283 || 12289 <= codePoint && codePoint <= 12350 || 12353 <= codePoint && codePoint <= 12438 || 12441 <= codePoint && codePoint <= 12543 || 12549 <= codePoint && codePoint <= 12589 || 12593 <= codePoint && codePoint <= 12686 || 12688 <= codePoint && codePoint <= 12730 || 12736 <= codePoint && codePoint <= 12771 || 12784 <= codePoint && codePoint <= 12830 || 12832 <= codePoint && codePoint <= 12871 || 12880 <= codePoint && codePoint <= 13054 || 13056 <= codePoint && codePoint <= 19903 || 19968 <= codePoint && codePoint <= 42124 || 42128 <= codePoint && codePoint <= 42182 || 43360 <= codePoint && codePoint <= 43388 || 44032 <= codePoint && codePoint <= 55203 || 55216 <= codePoint && codePoint <= 55238 || 55243 <= codePoint && codePoint <= 55291 || 63744 <= codePoint && codePoint <= 64255 || 65040 <= codePoint && codePoint <= 65049 || 65072 <= codePoint && codePoint <= 65106 || 65108 <= codePoint && codePoint <= 65126 || 65128 <= codePoint && codePoint <= 65131 || 110592 <= codePoint && codePoint <= 110593 || 127488 <= codePoint && codePoint <= 127490 || 127504 <= codePoint && codePoint <= 127546 || 127552 <= codePoint && codePoint <= 127560 || 127568 <= codePoint && codePoint <= 127569 || 131072 <= codePoint && codePoint <= 194367 || 177984 <= codePoint && codePoint <= 196605 || 196608 <= codePoint && codePoint <= 262141) {\n return \"W\";\n }\n return \"N\";\n }\n};\n\n// src/utils/get-string-width.js\nvar notAsciiRegex = /[^\\x20-\\x7F]/;\nfunction getStringWidth(text) {\n if (!text) {\n return 0;\n }\n if (!notAsciiRegex.test(text)) {\n return text.length;\n }\n text = text.replace(emoji_regex_default(), \" \");\n let width = 0;\n for (const character of text) {\n const codePoint = character.codePointAt(0);\n if (codePoint <= 31 || codePoint >= 127 && codePoint <= 159) {\n continue;\n }\n if (codePoint >= 768 && codePoint <= 879) {\n continue;\n }\n const code = eastasianwidth_default.eastAsianWidth(character);\n width += code === \"F\" || code === \"W\" ? 2 : 1;\n }\n return width;\n}\nvar get_string_width_default = getStringWidth;\n\n// src/document/utils.js\nvar getDocParts = (doc) => {\n if (Array.isArray(doc)) {\n return doc;\n }\n if (doc.type !== DOC_TYPE_FILL) {\n throw new Error(`Expect doc to be 'array' or '${DOC_TYPE_FILL}'.`);\n }\n return doc.parts;\n};\nfunction mapDoc(doc, cb) {\n if (typeof doc === \"string\") {\n return cb(doc);\n }\n const mapped = /* @__PURE__ */ new Map();\n return rec(doc);\n function rec(doc2) {\n if (mapped.has(doc2)) {\n return mapped.get(doc2);\n }\n const result = process2(doc2);\n mapped.set(doc2, result);\n return result;\n }\n function process2(doc2) {\n switch (get_doc_type_default(doc2)) {\n case DOC_TYPE_ARRAY:\n return cb(doc2.map(rec));\n case DOC_TYPE_FILL:\n return cb({\n ...doc2,\n parts: doc2.parts.map(rec)\n });\n case DOC_TYPE_IF_BREAK:\n return cb({\n ...doc2,\n breakContents: rec(doc2.breakContents),\n flatContents: rec(doc2.flatContents)\n });\n case DOC_TYPE_GROUP: {\n let {\n expandedStates,\n contents\n } = doc2;\n if (expandedStates) {\n expandedStates = expandedStates.map(rec);\n contents = expandedStates[0];\n } else {\n contents = rec(contents);\n }\n return cb({\n ...doc2,\n contents,\n expandedStates\n });\n }\n case DOC_TYPE_ALIGN:\n case DOC_TYPE_INDENT:\n case DOC_TYPE_INDENT_IF_BREAK:\n case DOC_TYPE_LABEL:\n case DOC_TYPE_LINE_SUFFIX:\n return cb({\n ...doc2,\n contents: rec(doc2.contents)\n });\n case DOC_TYPE_STRING:\n case DOC_TYPE_CURSOR:\n case DOC_TYPE_TRIM:\n case DOC_TYPE_LINE_SUFFIX_BOUNDARY:\n case DOC_TYPE_LINE:\n case DOC_TYPE_BREAK_PARENT:\n return cb(doc2);\n default:\n throw new invalid_doc_error_default(doc2);\n }\n }\n}\nfunction findInDoc(doc, fn, defaultValue) {\n let result = defaultValue;\n let shouldSkipFurtherProcessing = false;\n function findInDocOnEnterFn(doc2) {\n if (shouldSkipFurtherProcessing) {\n return false;\n }\n const maybeResult = fn(doc2);\n if (maybeResult !== void 0) {\n shouldSkipFurtherProcessing = true;\n result = maybeResult;\n }\n }\n traverse_doc_default(doc, findInDocOnEnterFn);\n return result;\n}\nfunction willBreakFn(doc) {\n if (doc.type === DOC_TYPE_GROUP && doc.break) {\n return true;\n }\n if (doc.type === DOC_TYPE_LINE && doc.hard) {\n return true;\n }\n if (doc.type === DOC_TYPE_BREAK_PARENT) {\n return true;\n }\n}\nfunction willBreak(doc) {\n return findInDoc(doc, willBreakFn, false);\n}\nfunction breakParentGroup(groupStack) {\n if (groupStack.length > 0) {\n const parentGroup = at_default(\n /* isOptionalObject*/\n false,\n groupStack,\n -1\n );\n if (!parentGroup.expandedStates && !parentGroup.break) {\n parentGroup.break = \"propagated\";\n }\n }\n return null;\n}\nfunction propagateBreaks(doc) {\n const alreadyVisitedSet = /* @__PURE__ */ new Set();\n const groupStack = [];\n function propagateBreaksOnEnterFn(doc2) {\n if (doc2.type === DOC_TYPE_BREAK_PARENT) {\n breakParentGroup(groupStack);\n }\n if (doc2.type === DOC_TYPE_GROUP) {\n groupStack.push(doc2);\n if (alreadyVisitedSet.has(doc2)) {\n return false;\n }\n alreadyVisitedSet.add(doc2);\n }\n }\n function propagateBreaksOnExitFn(doc2) {\n if (doc2.type === DOC_TYPE_GROUP) {\n const group2 = groupStack.pop();\n if (group2.break) {\n breakParentGroup(groupStack);\n }\n }\n }\n traverse_doc_default(\n doc,\n propagateBreaksOnEnterFn,\n propagateBreaksOnExitFn,\n /* shouldTraverseConditionalGroups */\n true\n );\n}\nfunction removeLinesFn(doc) {\n if (doc.type === DOC_TYPE_LINE && !doc.hard) {\n return doc.soft ? \"\" : \" \";\n }\n if (doc.type === DOC_TYPE_IF_BREAK) {\n return doc.flatContents;\n }\n return doc;\n}\nfunction removeLines(doc) {\n return mapDoc(doc, removeLinesFn);\n}\nfunction stripTrailingHardlineFromParts(parts) {\n parts = [...parts];\n while (parts.length >= 2 && at_default(\n /* isOptionalObject*/\n false,\n parts,\n -2\n ).type === DOC_TYPE_LINE && at_default(\n /* isOptionalObject*/\n false,\n parts,\n -1\n ).type === DOC_TYPE_BREAK_PARENT) {\n parts.length -= 2;\n }\n if (parts.length > 0) {\n const lastPart = stripTrailingHardlineFromDoc(at_default(\n /* isOptionalObject*/\n false,\n parts,\n -1\n ));\n parts[parts.length - 1] = lastPart;\n }\n return parts;\n}\nfunction stripTrailingHardlineFromDoc(doc) {\n switch (get_doc_type_default(doc)) {\n case DOC_TYPE_ALIGN:\n case DOC_TYPE_INDENT:\n case DOC_TYPE_INDENT_IF_BREAK:\n case DOC_TYPE_GROUP:\n case DOC_TYPE_LINE_SUFFIX:\n case DOC_TYPE_LABEL: {\n const contents = stripTrailingHardlineFromDoc(doc.contents);\n return {\n ...doc,\n contents\n };\n }\n case DOC_TYPE_IF_BREAK:\n return {\n ...doc,\n breakContents: stripTrailingHardlineFromDoc(doc.breakContents),\n flatContents: stripTrailingHardlineFromDoc(doc.flatContents)\n };\n case DOC_TYPE_FILL:\n return {\n ...doc,\n parts: stripTrailingHardlineFromParts(doc.parts)\n };\n case DOC_TYPE_ARRAY:\n return stripTrailingHardlineFromParts(doc);\n case DOC_TYPE_STRING:\n return doc.replace(/[\\n\\r]*$/, \"\");\n case DOC_TYPE_CURSOR:\n case DOC_TYPE_TRIM:\n case DOC_TYPE_LINE_SUFFIX_BOUNDARY:\n case DOC_TYPE_LINE:\n case DOC_TYPE_BREAK_PARENT:\n break;\n default:\n throw new invalid_doc_error_default(doc);\n }\n return doc;\n}\nfunction stripTrailingHardline(doc) {\n return stripTrailingHardlineFromDoc(cleanDoc(doc));\n}\nfunction cleanDocFn(doc) {\n switch (get_doc_type_default(doc)) {\n case DOC_TYPE_FILL:\n if (doc.parts.every((part) => part === \"\")) {\n return \"\";\n }\n break;\n case DOC_TYPE_GROUP:\n if (!doc.contents && !doc.id && !doc.break && !doc.expandedStates) {\n return \"\";\n }\n if (doc.contents.type === DOC_TYPE_GROUP && doc.contents.id === doc.id && doc.contents.break === doc.break && doc.contents.expandedStates === doc.expandedStates) {\n return doc.contents;\n }\n break;\n case DOC_TYPE_ALIGN:\n case DOC_TYPE_INDENT:\n case DOC_TYPE_INDENT_IF_BREAK:\n case DOC_TYPE_LINE_SUFFIX:\n if (!doc.contents) {\n return \"\";\n }\n break;\n case DOC_TYPE_IF_BREAK:\n if (!doc.flatContents && !doc.breakContents) {\n return \"\";\n }\n break;\n case DOC_TYPE_ARRAY: {\n const parts = [];\n for (const part of doc) {\n if (!part) {\n continue;\n }\n const [currentPart, ...restParts] = Array.isArray(part) ? part : [part];\n if (typeof currentPart === \"string\" && typeof at_default(\n /* isOptionalObject*/\n false,\n parts,\n -1\n ) === \"string\") {\n parts[parts.length - 1] += currentPart;\n } else {\n parts.push(currentPart);\n }\n parts.push(...restParts);\n }\n if (parts.length === 0) {\n return \"\";\n }\n if (parts.length === 1) {\n return parts[0];\n }\n return parts;\n }\n case DOC_TYPE_STRING:\n case DOC_TYPE_CURSOR:\n case DOC_TYPE_TRIM:\n case DOC_TYPE_LINE_SUFFIX_BOUNDARY:\n case DOC_TYPE_LINE:\n case DOC_TYPE_LABEL:\n case DOC_TYPE_BREAK_PARENT:\n break;\n default:\n throw new invalid_doc_error_default(doc);\n }\n return doc;\n}\nfunction cleanDoc(doc) {\n return mapDoc(doc, (currentDoc) => cleanDocFn(currentDoc));\n}\nfunction replaceEndOfLine(doc, replacement = literalline) {\n return mapDoc(doc, (currentDoc) => typeof currentDoc === \"string\" ? join(replacement, currentDoc.split(\"\\n\")) : currentDoc);\n}\nfunction canBreakFn(doc) {\n if (doc.type === DOC_TYPE_LINE) {\n return true;\n }\n}\nfunction canBreak(doc) {\n return findInDoc(doc, canBreakFn, false);\n}\n\n// src/document/printer.js\nvar MODE_BREAK = Symbol(\"MODE_BREAK\");\nvar MODE_FLAT = Symbol(\"MODE_FLAT\");\nvar CURSOR_PLACEHOLDER = Symbol(\"cursor\");\nfunction rootIndent() {\n return {\n value: \"\",\n length: 0,\n queue: []\n };\n}\nfunction makeIndent(ind, options) {\n return generateInd(ind, {\n type: \"indent\"\n }, options);\n}\nfunction makeAlign(indent2, widthOrDoc, options) {\n if (widthOrDoc === Number.NEGATIVE_INFINITY) {\n return indent2.root || rootIndent();\n }\n if (widthOrDoc < 0) {\n return generateInd(indent2, {\n type: \"dedent\"\n }, options);\n }\n if (!widthOrDoc) {\n return indent2;\n }\n if (widthOrDoc.type === \"root\") {\n return {\n ...indent2,\n root: indent2\n };\n }\n const alignType = typeof widthOrDoc === \"string\" ? \"stringAlign\" : \"numberAlign\";\n return generateInd(indent2, {\n type: alignType,\n n: widthOrDoc\n }, options);\n}\nfunction generateInd(ind, newPart, options) {\n const queue = newPart.type === \"dedent\" ? ind.queue.slice(0, -1) : [...ind.queue, newPart];\n let value = \"\";\n let length = 0;\n let lastTabs = 0;\n let lastSpaces = 0;\n for (const part of queue) {\n switch (part.type) {\n case \"indent\":\n flush();\n if (options.useTabs) {\n addTabs(1);\n } else {\n addSpaces(options.tabWidth);\n }\n break;\n case \"stringAlign\":\n flush();\n value += part.n;\n length += part.n.length;\n break;\n case \"numberAlign\":\n lastTabs += 1;\n lastSpaces += part.n;\n break;\n default:\n throw new Error(`Unexpected type '${part.type}'`);\n }\n }\n flushSpaces();\n return {\n ...ind,\n value,\n length,\n queue\n };\n function addTabs(count) {\n value += \"\t\".repeat(count);\n length += options.tabWidth * count;\n }\n function addSpaces(count) {\n value += \" \".repeat(count);\n length += count;\n }\n function flush() {\n if (options.useTabs) {\n flushTabs();\n } else {\n flushSpaces();\n }\n }\n function flushTabs() {\n if (lastTabs > 0) {\n addTabs(lastTabs);\n }\n resetLast();\n }\n function flushSpaces() {\n if (lastSpaces > 0) {\n addSpaces(lastSpaces);\n }\n resetLast();\n }\n function resetLast() {\n lastTabs = 0;\n lastSpaces = 0;\n }\n}\nfunction trim2(out) {\n let trimCount = 0;\n let cursorCount = 0;\n let outIndex = out.length;\n outer:\n while (outIndex--) {\n const last = out[outIndex];\n if (last === CURSOR_PLACEHOLDER) {\n cursorCount++;\n continue;\n }\n if (false) {\n throw new Error(`Unexpected value in trim: '${typeof last}'`);\n }\n for (let charIndex = last.length - 1; charIndex >= 0; charIndex--) {\n const char = last[charIndex];\n if (char === \" \" || char === \"\t\") {\n trimCount++;\n } else {\n out[outIndex] = last.slice(0, charIndex + 1);\n break outer;\n }\n }\n }\n if (trimCount > 0 || cursorCount > 0) {\n out.length = outIndex + 1;\n while (cursorCount-- > 0) {\n out.push(CURSOR_PLACEHOLDER);\n }\n }\n return trimCount;\n}\nfunction fits(next, restCommands, width, hasLineSuffix, groupModeMap, mustBeFlat) {\n if (width === Number.POSITIVE_INFINITY) {\n return true;\n }\n let restIdx = restCommands.length;\n const cmds = [next];\n const out = [];\n while (width >= 0) {\n if (cmds.length === 0) {\n if (restIdx === 0) {\n return true;\n }\n cmds.push(restCommands[--restIdx]);\n continue;\n }\n const {\n mode,\n doc\n } = cmds.pop();\n switch (get_doc_type_default(doc)) {\n case DOC_TYPE_STRING:\n out.push(doc);\n width -= get_string_width_default(doc);\n break;\n case DOC_TYPE_ARRAY:\n case DOC_TYPE_FILL: {\n const parts = getDocParts(doc);\n for (let i = parts.length - 1; i >= 0; i--) {\n cmds.push({\n mode,\n doc: parts[i]\n });\n }\n break;\n }\n case DOC_TYPE_INDENT:\n case DOC_TYPE_ALIGN:\n case DOC_TYPE_INDENT_IF_BREAK:\n case DOC_TYPE_LABEL:\n cmds.push({\n mode,\n doc: doc.contents\n });\n break;\n case DOC_TYPE_TRIM:\n width += trim2(out);\n break;\n case DOC_TYPE_GROUP: {\n if (mustBeFlat && doc.break) {\n return false;\n }\n const groupMode = doc.break ? MODE_BREAK : mode;\n const contents = doc.expandedStates && groupMode === MODE_BREAK ? at_default(\n /* isOptionalObject*/\n false,\n doc.expandedStates,\n -1\n ) : doc.contents;\n cmds.push({\n mode: groupMode,\n doc: contents\n });\n break;\n }\n case DOC_TYPE_IF_BREAK: {\n const groupMode = doc.groupId ? groupModeMap[doc.groupId] || MODE_FLAT : mode;\n const contents = groupMode === MODE_BREAK ? doc.breakContents : doc.flatContents;\n if (contents) {\n cmds.push({\n mode,\n doc: contents\n });\n }\n break;\n }\n case DOC_TYPE_LINE:\n if (mode === MODE_BREAK || doc.hard) {\n return true;\n }\n if (!doc.soft) {\n out.push(\" \");\n width--;\n }\n break;\n case DOC_TYPE_LINE_SUFFIX:\n hasLineSuffix = true;\n break;\n case DOC_TYPE_LINE_SUFFIX_BOUNDARY:\n if (hasLineSuffix) {\n return false;\n }\n break;\n }\n }\n return false;\n}\nfunction printDocToString(doc, options) {\n const groupModeMap = {};\n const width = options.printWidth;\n const newLine = convertEndOfLineToChars(options.endOfLine);\n let pos = 0;\n const cmds = [{\n ind: rootIndent(),\n mode: MODE_BREAK,\n doc\n }];\n const out = [];\n let shouldRemeasure = false;\n const lineSuffix2 = [];\n let printedCursorCount = 0;\n propagateBreaks(doc);\n while (cmds.length > 0) {\n const {\n ind,\n mode,\n doc: doc2\n } = cmds.pop();\n switch (get_doc_type_default(doc2)) {\n case DOC_TYPE_STRING: {\n const formatted = newLine !== \"\\n\" ? string_replace_all_default(\n /* isOptionalObject*/\n false,\n doc2,\n \"\\n\",\n newLine\n ) : doc2;\n out.push(formatted);\n if (cmds.length > 0) {\n pos += get_string_width_default(formatted);\n }\n break;\n }\n case DOC_TYPE_ARRAY:\n for (let i = doc2.length - 1; i >= 0; i--) {\n cmds.push({\n ind,\n mode,\n doc: doc2[i]\n });\n }\n break;\n case DOC_TYPE_CURSOR:\n if (printedCursorCount >= 2) {\n throw new Error(\"There are too many 'cursor' in doc.\");\n }\n out.push(CURSOR_PLACEHOLDER);\n printedCursorCount++;\n break;\n case DOC_TYPE_INDENT:\n cmds.push({\n ind: makeIndent(ind, options),\n mode,\n doc: doc2.contents\n });\n break;\n case DOC_TYPE_ALIGN:\n cmds.push({\n ind: makeAlign(ind, doc2.n, options),\n mode,\n doc: doc2.contents\n });\n break;\n case DOC_TYPE_TRIM:\n pos -= trim2(out);\n break;\n case DOC_TYPE_GROUP:\n switch (mode) {\n case MODE_FLAT:\n if (!shouldRemeasure) {\n cmds.push({\n ind,\n mode: doc2.break ? MODE_BREAK : MODE_FLAT,\n doc: doc2.contents\n });\n break;\n }\n case MODE_BREAK: {\n shouldRemeasure = false;\n const next = {\n ind,\n mode: MODE_FLAT,\n doc: doc2.contents\n };\n const rem = width - pos;\n const hasLineSuffix = lineSuffix2.length > 0;\n if (!doc2.break && fits(next, cmds, rem, hasLineSuffix, groupModeMap)) {\n cmds.push(next);\n } else {\n if (doc2.expandedStates) {\n const mostExpanded = at_default(\n /* isOptionalObject*/\n false,\n doc2.expandedStates,\n -1\n );\n if (doc2.break) {\n cmds.push({\n ind,\n mode: MODE_BREAK,\n doc: mostExpanded\n });\n break;\n } else {\n for (let i = 1; i < doc2.expandedStates.length + 1; i++) {\n if (i >= doc2.expandedStates.length) {\n cmds.push({\n ind,\n mode: MODE_BREAK,\n doc: mostExpanded\n });\n break;\n } else {\n const state = doc2.expandedStates[i];\n const cmd = {\n ind,\n mode: MODE_FLAT,\n doc: state\n };\n if (fits(cmd, cmds, rem, hasLineSuffix, groupModeMap)) {\n cmds.push(cmd);\n break;\n }\n }\n }\n }\n } else {\n cmds.push({\n ind,\n mode: MODE_BREAK,\n doc: doc2.contents\n });\n }\n }\n break;\n }\n }\n if (doc2.id) {\n groupModeMap[doc2.id] = at_default(\n /* isOptionalObject*/\n false,\n cmds,\n -1\n ).mode;\n }\n break;\n case DOC_TYPE_FILL: {\n const rem = width - pos;\n const {\n parts\n } = doc2;\n if (parts.length === 0) {\n break;\n }\n const [content, whitespace] = parts;\n const contentFlatCmd = {\n ind,\n mode: MODE_FLAT,\n doc: content\n };\n const contentBreakCmd = {\n ind,\n mode: MODE_BREAK,\n doc: content\n };\n const contentFits = fits(contentFlatCmd, [], rem, lineSuffix2.length > 0, groupModeMap, true);\n if (parts.length === 1) {\n if (contentFits) {\n cmds.push(contentFlatCmd);\n } else {\n cmds.push(contentBreakCmd);\n }\n break;\n }\n const whitespaceFlatCmd = {\n ind,\n mode: MODE_FLAT,\n doc: whitespace\n };\n const whitespaceBreakCmd = {\n ind,\n mode: MODE_BREAK,\n doc: whitespace\n };\n if (parts.length === 2) {\n if (contentFits) {\n cmds.push(whitespaceFlatCmd, contentFlatCmd);\n } else {\n cmds.push(whitespaceBreakCmd, contentBreakCmd);\n }\n break;\n }\n parts.splice(0, 2);\n const remainingCmd = {\n ind,\n mode,\n doc: fill(parts)\n };\n const secondContent = parts[0];\n const firstAndSecondContentFlatCmd = {\n ind,\n mode: MODE_FLAT,\n doc: [content, whitespace, secondContent]\n };\n const firstAndSecondContentFits = fits(firstAndSecondContentFlatCmd, [], rem, lineSuffix2.length > 0, groupModeMap, true);\n if (firstAndSecondContentFits) {\n cmds.push(remainingCmd, whitespaceFlatCmd, contentFlatCmd);\n } else if (contentFits) {\n cmds.push(remainingCmd, whitespaceBreakCmd, contentFlatCmd);\n } else {\n cmds.push(remainingCmd, whitespaceBreakCmd, contentBreakCmd);\n }\n break;\n }\n case DOC_TYPE_IF_BREAK:\n case DOC_TYPE_INDENT_IF_BREAK: {\n const groupMode = doc2.groupId ? groupModeMap[doc2.groupId] : mode;\n if (groupMode === MODE_BREAK) {\n const breakContents = doc2.type === DOC_TYPE_IF_BREAK ? doc2.breakContents : doc2.negate ? doc2.contents : indent(doc2.contents);\n if (breakContents) {\n cmds.push({\n ind,\n mode,\n doc: breakContents\n });\n }\n }\n if (groupMode === MODE_FLAT) {\n const flatContents = doc2.type === DOC_TYPE_IF_BREAK ? doc2.flatContents : doc2.negate ? indent(doc2.contents) : doc2.contents;\n if (flatContents) {\n cmds.push({\n ind,\n mode,\n doc: flatContents\n });\n }\n }\n break;\n }\n case DOC_TYPE_LINE_SUFFIX:\n lineSuffix2.push({\n ind,\n mode,\n doc: doc2.contents\n });\n break;\n case DOC_TYPE_LINE_SUFFIX_BOUNDARY:\n if (lineSuffix2.length > 0) {\n cmds.push({\n ind,\n mode,\n doc: hardlineWithoutBreakParent\n });\n }\n break;\n case DOC_TYPE_LINE:\n switch (mode) {\n case MODE_FLAT:\n if (!doc2.hard) {\n if (!doc2.soft) {\n out.push(\" \");\n pos += 1;\n }\n break;\n } else {\n shouldRemeasure = true;\n }\n case MODE_BREAK:\n if (lineSuffix2.length > 0) {\n cmds.push({\n ind,\n mode,\n doc: doc2\n }, ...lineSuffix2.reverse());\n lineSuffix2.length = 0;\n break;\n }\n if (doc2.literal) {\n if (ind.root) {\n out.push(newLine, ind.root.value);\n pos = ind.root.length;\n } else {\n out.push(newLine);\n pos = 0;\n }\n } else {\n pos -= trim2(out);\n out.push(newLine + ind.value);\n pos = ind.length;\n }\n break;\n }\n break;\n case DOC_TYPE_LABEL:\n cmds.push({\n ind,\n mode,\n doc: doc2.contents\n });\n break;\n case DOC_TYPE_BREAK_PARENT:\n break;\n default:\n throw new invalid_doc_error_default(doc2);\n }\n if (cmds.length === 0 && lineSuffix2.length > 0) {\n cmds.push(...lineSuffix2.reverse());\n lineSuffix2.length = 0;\n }\n }\n const cursorPlaceholderIndex = out.indexOf(CURSOR_PLACEHOLDER);\n if (cursorPlaceholderIndex !== -1) {\n const otherCursorPlaceholderIndex = out.indexOf(CURSOR_PLACEHOLDER, cursorPlaceholderIndex + 1);\n const beforeCursor = out.slice(0, cursorPlaceholderIndex).join(\"\");\n const aroundCursor = out.slice(cursorPlaceholderIndex + 1, otherCursorPlaceholderIndex).join(\"\");\n const afterCursor = out.slice(otherCursorPlaceholderIndex + 1).join(\"\");\n return {\n formatted: beforeCursor + aroundCursor + afterCursor,\n cursorNodeStart: beforeCursor.length,\n cursorNodeText: aroundCursor\n };\n }\n return {\n formatted: out.join(\"\")\n };\n}\n\n// src/document/public.js\nvar builders = {\n join,\n line,\n softline,\n hardline,\n literalline,\n group,\n conditionalGroup,\n fill,\n lineSuffix,\n lineSuffixBoundary,\n cursor,\n breakParent,\n ifBreak,\n trim,\n indent,\n indentIfBreak,\n align,\n addAlignmentToDoc,\n markAsRoot,\n dedentToRoot,\n dedent,\n hardlineWithoutBreakParent,\n literallineWithoutBreakParent,\n label,\n // TODO: Remove this in v4\n concat: (parts) => parts\n};\nvar printer = { printDocToString };\nvar utils = {\n willBreak,\n traverseDoc: traverse_doc_default,\n findInDoc,\n mapDoc,\n removeLines,\n stripTrailingHardline,\n replaceEndOfLine,\n canBreak\n};\n\n// with-default-export:src/document/public.js\nvar public_default = public_exports;\nexport {\n builders,\n public_default as default,\n printer,\n utils\n};\n", "import { builders } from \"prettier/doc\";\nimport type { Doc } from \"prettier\";\nimport * as Ast from \"@unified-latex/unified-latex-types\";\nimport * as PrettierTypes from \"./prettier-types\";\nimport { printRaw } from \"@unified-latex/unified-latex-util-print-raw\";\nimport { ReferenceMap } from \"../reference-map\";\nimport { match } from \"@unified-latex/unified-latex-util-match\";\n\n/**\n * Computes the environment name, start/end, and args.\n * E.g., for \"\\begin{x}abc\\end{x}\", it returns\n * ```\n * {\n * envName: \"x\",\n * start: \"\\\\begin{x}\",\n * end: \"\\\\end{x}\",\n * }\n * ```\n *\n * @param {*} node\n * @returns\n */\nexport function formatEnvSurround(node: Ast.Environment) {\n const env = printRaw(node.env);\n\n return {\n envName: env,\n start: ESCAPE + \"begin{\" + env + \"}\",\n end: ESCAPE + \"end{\" + env + \"}\",\n };\n}\n\n/**\n * Determine if `elm` is a line type (softline/hardline/etc). If `elm` is an\n * array or a concat, the first element is checked.\n */\nfunction isLineType(elm: Doc): boolean {\n if (elm == null || typeof elm === \"string\") {\n return false;\n }\n if (Array.isArray(elm)) {\n return isLineType(elm[0]);\n }\n // Perhaps we can sneak by with Prettier v2 compatibility?\n // @ts-ignore\n if (elm.type === \"concat\") {\n // @ts-ignore\n return isLineType(elm.parts);\n }\n return elm.type === \"line\";\n}\n\n/**\n * Join an array with `softline`. However, if a `line` is\n * found, do not insert an additional softline. For example\n * `[a, b, c]` -> `[a, softline, b, softline, c]`\n *\n * but\n *\n * `[a, line, b, c]` -> `[a, line, b, softline, c]`\n *\n * @param {*} arr\n * @returns\n */\nexport function joinWithSoftline(arr: Doc[]) {\n if (arr.length === 0 || arr.length === 1) {\n return arr;\n }\n const ret = [arr[0]];\n for (let i = 1; i < arr.length; i++) {\n const prevNode = arr[i - 1];\n const nextNode = arr[i];\n if (!isLineType(prevNode) && !isLineType(nextNode)) {\n ret.push(softline);\n }\n ret.push(nextNode);\n }\n return ret;\n}\n\nexport function getNodeInfo(\n node: any,\n options: PrettierTypes.Options & { referenceMap?: ReferenceMap }\n): {\n renderInfo: Record;\n renderCache?: object;\n previousNode?: Ast.Node;\n nextNode?: Ast.Node;\n referenceMap?: ReferenceMap;\n} {\n if (!node) {\n return { renderInfo: {} };\n }\n const renderInfo = node._renderInfo || {};\n const previousNode =\n options.referenceMap && options.referenceMap.getPreviousNode(node);\n const nextNode =\n options.referenceMap && options.referenceMap.getNextNode(node);\n const renderCache =\n options.referenceMap && options.referenceMap.getRenderCache(node);\n // It's useful to know whether we're the start or end node in an array,\n // so compute this information.\n return {\n renderInfo,\n renderCache,\n previousNode,\n nextNode,\n referenceMap: options.referenceMap,\n };\n}\n\nexport const ESCAPE = \"\\\\\";\n\n// Commands to build the prettier syntax tree\nexport const {\n group,\n fill,\n ifBreak,\n line,\n softline,\n hardline,\n lineSuffix,\n lineSuffixBoundary,\n breakParent,\n indent,\n markAsRoot,\n join,\n} = builders;\n\n/**\n * Given an array of nodes and the corresponding printed versions, prepares\n * a final Doc array. This function does things like ensures there are `hardlines`\n * around environments and that there aren't excess hardlines at the start or end.\n * It also unwraps `inParMode` macro contents.\n *\n * @export\n * @param {Ast.Node[]} nodes\n * @param {Doc[]} docArray\n * @param {*} options\n * @returns {Doc[]}\n */\nexport function formatDocArray(\n nodes: Ast.Node[],\n docArray: Doc[],\n options: any\n): Doc[] {\n const ret: Doc[] = [];\n\n for (let i = 0; i < nodes.length; i++) {\n const rawNode = nodes[i];\n const printedNode = docArray[i];\n const { renderInfo, referenceMap, previousNode, nextNode } =\n getNodeInfo(rawNode, options);\n const renderCache =\n referenceMap && referenceMap.getRenderCache(rawNode);\n\n switch (rawNode.type) {\n case \"comment\":\n // Comments don't insert hardlines themselves; they depend on appropriate\n // hardlines being inserted here.\n\n // This comment printer inserts hardlines after comments, so do not insert\n // a hardline before a comment if there is a comment right before.\n if (\n !rawNode.sameline &&\n previousNode &&\n !match.comment(previousNode) &&\n !match.parbreak(previousNode)\n ) {\n ret.push(hardline);\n }\n ret.push(printedNode);\n if (nextNode && !rawNode.suffixParbreak) {\n ret.push(hardline);\n }\n break;\n case \"environment\":\n case \"displaymath\":\n case \"mathenv\":\n // Environments always start on a new line (unless they are the first\n // item). Peek to see if there is a newline inserted already.\n if (previousNode && previousNode?.type !== \"parbreak\") {\n if (ret[ret.length - 1] === line) {\n // A preceding `line` should be converted into a `hardline`.\n // Remove the line so a hardline can be added\n ret.pop();\n }\n if (ret[ret.length - 1] !== hardline) {\n ret.push(hardline);\n }\n }\n ret.push(printedNode);\n // If an environment is followed by whitespace, replace it with a hardline\n // instead\n if (nextNode?.type === \"whitespace\") {\n ret.push(hardline);\n i++;\n }\n\n break;\n case \"macro\":\n if (renderInfo.breakBefore || renderInfo.breakAround) {\n // Commands like \\section{} should always be preceded by a hardline\n if (previousNode) {\n if (\n ret[ret.length - 1] === line ||\n ret[ret.length - 1] === hardline\n ) {\n // We may be replacing a hardline here for no reason. However,\n // if there is already a hardline, we don't want to continue\n // and accidentally add too many linebreaks\n ret.pop();\n ret.push(hardline);\n } else if (\n !match.comment(previousNode) &&\n !match.parbreak(previousNode)\n ) {\n ret.push(hardline);\n }\n }\n }\n // Macros marked as `inParMode` should be unwrapped\n // unless they have a hanging indent, in which case the macro\n // has already be wrapped in an `indent` block\n if (\n renderInfo.inParMode &&\n !renderInfo.hangingIndent &&\n renderCache\n ) {\n ret.push(\n (renderCache as any).content,\n ...((renderCache as any).rawArgs || [])\n );\n } else {\n ret.push(printedNode);\n }\n if (renderInfo.breakAfter || renderInfo.breakAround) {\n // Commands like \\section{} should always be followed by a hardline\n if (nextNode) {\n if (match.whitespace(nextNode)) {\n ret.push(hardline);\n i++;\n } else if (match.parbreak(nextNode)) {\n // If the next node is a parbreak, it will insert its own newline\n } else if (!match.comment(nextNode)) {\n ret.push(hardline);\n }\n }\n }\n break;\n case \"parbreak\":\n ret.push(hardline, hardline);\n break;\n default:\n ret.push(printedNode);\n break;\n }\n }\n\n return ret;\n}\n", "export function zip(array1: T[], array2: U[]): [T, U][] {\n const ret: [T, U][] = [];\n const len = Math.min(array1.length, array2.length);\n for (let i = 0; i < len; i++) {\n ret.push([array1[i], array2[i]]);\n }\n return ret;\n}\n", "import type { Doc } from \"prettier\";\nimport * as PrettierTypes from \"./prettier-types\";\nimport { getNodeInfo, fill, ESCAPE, indent, group } from \"./common\";\nimport { zip } from \"../zip\";\nimport * as Ast from \"@unified-latex/unified-latex-types\";\n\nexport function printMacro(\n path: PrettierTypes.AstPath,\n print: PrettierTypes.RecursivePrintFunc,\n options: any\n): Doc {\n const node = path.getNode() as Ast.Macro;\n const { renderInfo, previousNode, nextNode, referenceMap } = getNodeInfo(\n node,\n options\n );\n\n const content =\n (node.escapeToken != null ? node.escapeToken : ESCAPE) + node.content;\n const args = node.args ? path.map(print, \"args\" as any) : [];\n\n // Some of the arguments want to be printed \"inline\".\n // We loop through the arguments and unwrap the inline ones.\n const rawArgs = [];\n for (const [arg, printedArg] of zip(node.args || [], args)) {\n const renderCache = referenceMap && referenceMap.getRenderCache(arg);\n if (renderInfo.inParMode && renderCache) {\n rawArgs.push(...(renderCache as any[]));\n } else {\n rawArgs.push(printedArg);\n }\n }\n\n if (referenceMap) {\n referenceMap.setRenderCache(node, { rawArgs, content });\n }\n\n if (renderInfo.hangingIndent) {\n return indent(fill([content, ...rawArgs]));\n }\n\n return group([content, ...rawArgs]);\n}\n", "import type { Doc } from \"prettier\";\nimport * as Ast from \"@unified-latex/unified-latex-types\";\nimport * as PrettierTypes from \"./prettier-types\";\nimport { getNodeInfo, formatDocArray, hardline, ifBreak, fill } from \"./common\";\nimport { match } from \"@unified-latex/unified-latex-util-match\";\nimport { trim } from \"@unified-latex/unified-latex-util-trim\";\nimport { printTikzArgument } from \"./tikz\";\nimport { printArgumentPgfkeys } from \"./print-argument-pgfkeys\";\n\nexport function printArgument(\n path: PrettierTypes.AstPath,\n print: PrettierTypes.RecursivePrintFunc,\n options: any\n): Doc {\n const node = path.getNode() as Ast.Argument;\n const { renderInfo, previousNode, nextNode, referenceMap } = getNodeInfo(\n node,\n options\n );\n\n // We can return early for empty arguments (this is common for omitted optional arguments)\n if (\n node.openMark === \"\" &&\n node.closeMark === \"\" &&\n node.content.length === 0\n ) {\n return [];\n }\n const parentNode = path.getParentNode();\n const { renderInfo: parentRenderInfo } = getNodeInfo(parentNode, options);\n // We handle printing pgfkeys arguments manually\n if (parentRenderInfo.pgfkeysArgs) {\n const leadingComment =\n node.content.length > 0 &&\n match.comment(node.content[0]) &&\n node.content[0].sameline\n ? node.content[0]\n : null;\n const content = leadingComment ? node.content.slice(1) : node.content;\n trim(content);\n return printArgumentPgfkeys(content, {\n openMark: node.openMark,\n closeMark: node.closeMark,\n leadingComment,\n });\n }\n if (parentRenderInfo.tikzPathCommand) {\n return printTikzArgument(path, print, options);\n }\n\n // Regular argument printing\n const openMark = node.openMark;\n const closeMark = node.closeMark;\n let content = path.map(print, \"content\");\n content = formatDocArray(node.content, content, options);\n\n // if the last item is a comment, we need to insert a hardline\n if (match.comment(node.content[node.content.length - 1])) {\n content.push(hardline);\n }\n\n let rawRet: Doc[] = [openMark, fill(content), closeMark];\n if (renderInfo.inParMode) {\n // In paragraph node, arguments should flow just like text\n rawRet = [openMark, ...content, closeMark];\n }\n if (referenceMap) {\n // Save the raw rendered data in case a renderer higher up\n // wants to unwrap it\n referenceMap.setRenderCache(node, rawRet);\n }\n\n return rawRet;\n}\n", "import type { Doc } from \"prettier\";\nimport * as Ast from \"@unified-latex/unified-latex-types\";\nimport * as PrettierTypes from \"./prettier-types\";\nimport {\n getNodeInfo,\n formatDocArray,\n hardline,\n join,\n ifBreak,\n breakParent,\n line,\n group,\n indent,\n softline,\n fill,\n} from \"./common\";\nimport {\n printRaw,\n} from \"@unified-latex/unified-latex-util-print-raw\";\nimport { match } from \"@unified-latex/unified-latex-util-match\";\nimport { trim } from \"@unified-latex/unified-latex-util-trim\";\nimport {\n parse as parseTikz,\n PathSpec,\n PathSpecNode,\n printRaw as tikzPrintRaw,\n} from \"@unified-latex/unified-latex-ctan/package/tikz\";\nimport { printArgumentPgfkeys } from \"./print-argument-pgfkeys\";\n\nexport function printTikzArgument(\n path: PrettierTypes.AstPath,\n print: PrettierTypes.RecursivePrintFunc,\n options: any\n): Doc {\n const node = path.getNode() as Ast.Argument;\n const { renderInfo, previousNode, nextNode, referenceMap } = getNodeInfo(\n node,\n options\n );\n\n const content: Doc[] = [];\n const nodes = [...node.content];\n trim(nodes);\n try {\n const tikzAst = parseTikz(nodes);\n if (tikzAst.content.length === 0) {\n content.push(\";\");\n return content;\n }\n\n const printer = new TikzArgumentPrinter(tikzAst, path, print);\n return printer.toDoc();\n } catch (e) {\n console.warn(\"Encountered error when trying to parse tikz argument\", e);\n }\n\n content.push(\";\");\n\n return content;\n}\n\n/**\n * Print a fragment of an AST to a `Doc`.\n */\nfunction printFragment(\n fragment: Ast.Node | Ast.Argument,\n path: PrettierTypes.AstPath,\n print: PrettierTypes.RecursivePrintFunc\n): Doc {\n const tmpKey = Symbol();\n const currNode = path.getNode();\n if (!currNode) {\n throw new Error(\n \"tried to print a fragment, but the current node is `null`\"\n );\n }\n (currNode as any)[tmpKey] = fragment;\n const ret = print(tmpKey);\n delete (currNode as any)[tmpKey];\n return ret;\n}\n\n/**\n * Turn an item in a tikz PathSpec into a Doc for printing.\n */\nfunction printTikzPathSpecNode(\n node: PathSpecNode,\n path: PrettierTypes.AstPath,\n print: PrettierTypes.RecursivePrintFunc\n): Doc {\n switch (node.type) {\n case \"comment\":\n return printFragment(node, path, print);\n case \"unknown\":\n // `\"unknown\"` nodes contain regular AST nodes as children which couldn't be identified by the parser\n return printFragment(node.content, path, print);\n case \"coordinate\":\n return [printRaw(node.prefix), \"(\", printRaw(node.content), \")\"];\n case \"line_to\":\n return node.command;\n case \"square_brace_group\":\n return printOptionalArgs(node.content);\n case \"operation\":\n return node.content.content;\n case \"svg_operation\": {\n const comments = node.comments.map((n) =>\n printTikzPathSpecNode(n, path, print)\n );\n const options = node.options ? printOptionalArgs(node.options) : [];\n const rest: Doc[] = node.options\n ? [group(indent([line, printRaw(node.content)]))]\n : [\" \", printRaw(node.content)];\n return [...comments, \"svg\", options, ...rest];\n }\n case \"curve_to\": {\n const comments = node.comments.map((n) =>\n printTikzPathSpecNode(n, path, print)\n );\n const printedControls =\n node.controls.length > 1\n ? [\n printTikzPathSpecNode(node.controls[0], path, print),\n \" \",\n \"and\",\n line,\n printTikzPathSpecNode(node.controls[1]!, path, print),\n ]\n : [printTikzPathSpecNode(node.controls[0], path, print)];\n return [\n ...comments,\n \"..\",\n \" \",\n group(\n indent([\"controls\", line, ...printedControls, \" \", \"..\"])\n ),\n ];\n }\n case \"animation\": {\n const comments = node.comments.map((n) =>\n printTikzPathSpecNode(n, path, print)\n );\n\n return [\n ...comments,\n \":\",\n node.attribute,\n \" \",\n \"=\",\n \" \",\n group(\n indent([\n printArgumentPgfkeys(node.content, {\n openMark: \"{\",\n closeMark: \"}\",\n }),\n ])\n ),\n ];\n }\n case \"foreach\": {\n const comments = node.comments.map((n) =>\n printTikzPathSpecNode(n, path, print)\n );\n const variables = [...node.variables];\n trim(variables);\n const list =\n node.list.type === \"macro\"\n ? printFragment(node.list, path, print)\n : printArgumentPgfkeys(node.list.content, {\n openMark: \"{\",\n closeMark: \"}\",\n allowParenGroups: true,\n });\n const doc = [\n ...comments,\n printRaw(node.start),\n \" \",\n printRaw(variables),\n ];\n if (node.options) {\n doc.push(\" \", indent(printOptionalArgs(node.options)));\n }\n\n // The list, e.g. `{1,2,...,9}`\n doc.push(\" \", \"in\", \" \", group(indent(list)));\n // The loop body\n // XXX: if we are in a tikz node, whitespace doesn't matter. If we are in a regular\n // part of the document, the loop body is whitespace-sensitive\n const commandType = node.command.type;\n switch (commandType) {\n case \"foreach\":\n doc.push(\n indent([\n line,\n printTikzPathSpecNode(node.command, path, print),\n ])\n );\n break;\n case \"macro\":\n doc.push(\n indent([line, printFragment(node.command, path, print)])\n );\n break;\n case \"group\": {\n const groupContent = [...node.command.content];\n trim(groupContent);\n doc.push(\n \" \",\n indent(\n group([\n \"{\",\n indent([\n softline,\n ...groupContent.map((n) =>\n printFragment(n, path, print)\n ),\n ]),\n softline,\n \"}\",\n ])\n )\n );\n break;\n }\n default:\n const invalidType: void = commandType;\n console.warn(\n `Unhandled command type when printing \"foreach\": ${invalidType}`\n );\n }\n\n return indent(doc);\n }\n }\n console.warn(\n `Encountered unknown type when trying to print tikz PathSpec: \"${\n (node as any).type\n }\"`\n );\n return [];\n}\n\nfunction printOptionalArgs(nodes: Ast.Node[]): Doc {\n return printArgumentPgfkeys(nodes, {\n openMark: \"[\",\n closeMark: \"]\",\n });\n}\n\n/**\n * Utility to turn a Tikz PathSpec into a Prettier Doc.\n */\nclass TikzArgumentPrinter {\n #path: PrettierTypes.AstPath;\n #print: PrettierTypes.RecursivePrintFunc;\n nodes: PathSpec[\"content\"];\n constructor(\n spec: PathSpec,\n path: PrettierTypes.AstPath,\n print: PrettierTypes.RecursivePrintFunc\n ) {\n this.#path = path;\n this.#print = print;\n this.nodes = [...spec.content];\n }\n\n nodeToDoc(node: PathSpecNode): Doc {\n return printTikzPathSpecNode(node, this.#path, this.#print);\n }\n\n toDoc(): Doc {\n const doc: Doc = [];\n const startArg = this.eatOptionalArg();\n if (startArg.optionalArg) {\n doc.push(\n ...startArg.comments.map((c) =>\n printFragment(c, this.#path, this.#print)\n )\n );\n doc.push(printOptionalArgs(startArg.optionalArg.content));\n }\n\n const innerDoc: Doc = [];\n doc.push(group([indent(innerDoc), \";\"]));\n let cycle = -1;\n while (this.nodes.length > 0) {\n cycle++;\n // If this is the first item being printed and the draw command has no optional\n // argument, then we force the command to start printing on the same line.\n const firstSep = cycle === 0 && !startArg.optionalArg ? \" \" : line;\n const comingUp = this.peek();\n switch (comingUp) {\n case \"short_path\": {\n const [n0, n1, n2] = this.nodes.splice(0, 3);\n // A short path does not break\n innerDoc.push(\n firstSep,\n this.nodeToDoc(n0),\n \" \",\n this.nodeToDoc(n1),\n \" \",\n this.nodeToDoc(n2)\n );\n continue;\n }\n case \"long_path\": {\n // A long path consists of at least a node followed by a joiner\n const [n0, n1] = this.nodes.splice(0, 2);\n if (n1.type === \"operation\") {\n this.nodes.unshift(n1);\n innerDoc.push(\n firstSep,\n this.nodeToDoc(n0),\n \" \",\n this.eatOperation()\n );\n } else {\n innerDoc.push(\n firstSep,\n this.nodeToDoc(n0),\n \" \",\n this.nodeToDoc(n1)\n );\n }\n continue;\n }\n case \"node\":\n {\n const eatenNode = this.eatNode();\n if (eatenNode) {\n innerDoc.push(line, ...eatenNode);\n continue;\n }\n console.warn(\n \"Expected to print a tikz `node` PathSpec but couldn't find the text `node`\"\n );\n }\n continue;\n case \"operation\":\n innerDoc.push(firstSep, this.eatOperation());\n continue;\n case \"unknown\": {\n const node = this.nodes.shift()!;\n innerDoc.push(firstSep, this.nodeToDoc(node));\n continue;\n }\n }\n this.nodes.shift();\n }\n\n return doc;\n }\n\n /**\n * Look at the current node and the nodes that follow. Return what\n * \"type\" is recognized.\n */\n peek() {\n // A short path is two coordinates, joined by a line_to (with no coordinates/line_to's following).\n // If there are comments intermixed, the short path is broken.\n const [n0, n1, n2, n3] = [\n this.nodes[0],\n this.nodes[1],\n this.nodes[2],\n this.nodes[3],\n ];\n if (n0?.type === \"coordinate\" && isPathJoinOperation(n1)) {\n if (\n n2?.type === \"coordinate\" &&\n !(n3?.type === \"coordinate\" || isPathJoinOperation(n3))\n ) {\n return \"short_path\";\n }\n return \"long_path\";\n }\n if (n0?.type === \"operation\") {\n if (n0.content.content === \"node\") {\n // Nodes are a special type of operation.\n return \"node\";\n }\n return \"operation\";\n }\n\n return \"unknown\";\n }\n\n /**\n * Eat comments and an optional arg if present. If no optional\n * arg is present, do nothing.\n */\n eatOptionalArg() {\n let i = 0;\n const comments: Ast.Comment[] = [];\n let optionalArg:\n | (PathSpecNode & { type: \"square_brace_group\" })\n | null = null;\n for (; i < this.nodes.length; i++) {\n const node = this.nodes[i];\n if (node.type === \"square_brace_group\") {\n optionalArg = node;\n i++;\n break;\n }\n if (node.type === \"comment\") {\n comments.push(node);\n continue;\n }\n break;\n }\n if (optionalArg) {\n // If we grabbed an optional argument, remove it and everything\n // preceding it.\n this.nodes.splice(0, i);\n }\n return { optionalArg, comments };\n }\n\n /**\n * Eat a `type === \"operation\"` node whose contents is `\"node\"`. I.e.,\n * the type of thing that shows up in `\\path node at (1,1) {foo};`\n */\n eatNode(): Doc[] | null {\n const firstNode = this.nodes[0];\n if (\n firstNode?.type === \"operation\" &&\n firstNode.content.content === \"node\"\n ) {\n this.nodes.shift();\n } else {\n return null;\n }\n\n // From the tikz documentation:\n // \\path \u2026 node \u27E8foreach statements\u27E9 [\u27E8options\u27E9] (\u27E8name\u27E9) at(\u27E8coordinate\u27E9)\n // :\u27E8animation attribute\u27E9={\u27E8options\u27E9} {\u27E8node contents\u27E9} \u2026;\n //\n // Order of the parts of the specification.\n // Everything between \u201Cnode\u201D and the opening brace of a node is optional.\n // If there are \u27E8foreach statements\u27E9, they must come first, directly following \u201Cnode\u201D.\n // Other than that, the ordering of all the other elements of a node specification\n // (the \u27E8options\u27E9, the \u27E8name\u27E9, \u27E8coordinate\u27E9, and \u27E8animation attribute\u27E9) is arbitrary, indeed,\n // there can be multiple occurrences of any of these elements (although for the name and the\n // coordinate this makes no sense).\n\n const innerDoc: Doc = [];\n const commentBlock: Doc = [];\n const doc: Doc = [commentBlock, \"node\", group(indent(innerDoc))];\n // We now peek to see if a group `{...}` is the next thing. If so,\n // we're going to eat everything up to it and call it quits. Otherwise,\n // we bail.\n let hasNodeArgument = false;\n let shouldBail = false;\n let i = 0;\n const comments: Doc[] = [];\n const options: Doc[] = [];\n const name: Doc[] = [];\n const atLocations: Doc[] = [];\n const animations: Doc[] = [];\n let content: Doc = [];\n for (; i < this.nodes.length && !shouldBail; i++) {\n const node = this.nodes[i];\n switch (node.type) {\n case \"animation\":\n animations.push(this.nodeToDoc(node));\n continue;\n case \"comment\": {\n const comment: Ast.Comment = {\n ...node,\n leadingWhitespace: false,\n };\n comments.push(this.nodeToDoc(comment));\n continue;\n }\n case \"square_brace_group\":\n options.push(printOptionalArgs(node.content));\n continue;\n case \"coordinate\":\n name.push(this.nodeToDoc(node));\n continue;\n case \"operation\": {\n // An \"at\" should be followed by a coordinate or a macro. If it is,\n // then we slurp it. Otherwise we bail.\n if (node.content.content === \"at\") {\n const nextNode = this.nodes[i + 1];\n if (\n !nextNode ||\n !(\n nextNode.type === \"coordinate\" ||\n (nextNode.type === \"unknown\" &&\n match.anyMacro(nextNode.content))\n )\n ) {\n shouldBail = true;\n continue;\n }\n atLocations.push([\"at\", \" \", this.nodeToDoc(nextNode)]);\n i++;\n continue;\n }\n shouldBail = true;\n continue;\n }\n case \"unknown\": {\n // If we're here, we must be the termination group.\n if (match.group(node.content)) {\n hasNodeArgument = true;\n content = this.nodeToDoc(node);\n }\n // NOTE: the fallthrough here is on purpose. Finding the terminating\n // groups should end our loop.\n }\n }\n break;\n }\n if (!hasNodeArgument) {\n return innerDoc;\n }\n // We have collected docs for all the nodes we've scanned, so delete\n // them from the list.\n this.nodes.splice(0, i + 1);\n\n // We standardize node rendering as `[options] :animations (name) at (pos) {content}`\n let isFirstElement = true;\n let isNamed = !(Array.isArray(name) && name.length === 0);\n // Comments get hoisted to before the \"node\" keyword\n for (const comment of comments) {\n commentBlock.push(comment, hardline);\n }\n if (options.length > 0) {\n innerDoc.push(join(\" \", options));\n isFirstElement = false;\n }\n if (animations.length > 0) {\n innerDoc.push(isFirstElement ? \" \" : line);\n innerDoc.push(join(line, animations));\n isFirstElement = false;\n }\n if (isNamed) {\n innerDoc.push(isFirstElement ? \" \" : line);\n innerDoc.push(name);\n isFirstElement = false;\n }\n if (atLocations.length > 0) {\n innerDoc.push(isFirstElement || isNamed ? \" \" : line);\n innerDoc.push(join(line, atLocations));\n isFirstElement = false;\n }\n innerDoc.push(line, content);\n\n return doc;\n }\n\n /**\n * Eat a `type === \"operation\"` node, including its optional arguments.\n */\n eatOperation(): Doc[] {\n const node = this.nodes[0];\n if (node?.type === \"operation\") {\n this.nodes.shift();\n } else {\n return [];\n }\n\n const doc: Doc[] = [];\n if (node?.type !== \"operation\") {\n throw new Error(\"Expecting `operation` node.\");\n }\n const options = this.eatOptionalArg();\n doc.push(\n ...options.comments.map((c) =>\n printFragment(c, this.#path, this.#print)\n ),\n node.content.content\n );\n if (options.optionalArg) {\n doc.push(indent(printOptionalArgs(options.optionalArg.content)));\n }\n\n return doc;\n }\n}\n\nconst PATH_JOIN_OPERATIONS = new Set([\"rectangle\", \"grid\", \"sin\", \"cos\", \"to\"]);\n/**\n * Return whether `node` is a \"path join\", like `--`, `rectangle`, etc.\n *\n * A path join is an operation that sits between two coordinates, like\n * `(a) -- (b)` or `(a) rectangle (b)`.\n */\nfunction isPathJoinOperation(node?: PathSpecNode): boolean {\n if (!node) {\n return false;\n }\n switch (node.type) {\n case \"line_to\":\n case \"curve_to\":\n return true;\n case \"operation\":\n return PATH_JOIN_OPERATIONS.has(node.content.content);\n }\n return false;\n}\n", "import { Doc } from \"prettier\";\nimport * as Ast from \"@unified-latex/unified-latex-types\";\nimport {\n hardline,\n join,\n breakParent,\n line,\n group,\n indent,\n softline,\n} from \"./common\";\nimport {\n linebreak,\n printRaw,\n} from \"@unified-latex/unified-latex-util-print-raw\";\nimport { parsePgfkeys } from \"@unified-latex/unified-latex-util-pgfkeys\";\n\n/**\n * Format a sequence of Pgfkeys key-value pairs. `nodes` will be parsed\n * by a grammar defining Pgfkeys\n */\nexport function printArgumentPgfkeys(\n nodes: Ast.Node[],\n options: {\n openMark: string;\n closeMark: string;\n leadingComment?: Ast.Comment | null | undefined;\n allowParenGroups?: boolean;\n }\n): Doc {\n const { allowParenGroups = false } = options;\n const parsed = parsePgfkeys(nodes, { allowParenGroups });\n\n const content: Doc[] = [];\n for (const part of parsed) {\n const isLastItem = part === parsed[parsed.length - 1];\n\n if (part.itemParts) {\n // parts are printed using `printRaw`, `hardline` is used in place\n // of \"\\n\"\n const parts = part.itemParts.map((node) =>\n printRaw(node, { asArray: true }).map((token) =>\n token === linebreak ? hardline : token\n )\n );\n const row = join(\"=\", parts);\n content.push(row);\n if (part.trailingComma) {\n content.push(\",\");\n }\n }\n if (part.trailingComment) {\n const leadingContent: Doc[] = part.itemParts ? [\" \"] : [];\n if (part.leadingParbreak) {\n // We preserve parbreaks before comments, so if we have\n // one, insert an extra hardline\n leadingContent.push(hardline);\n }\n\n content.push(\n ...leadingContent,\n // We're carefully and manually controlling the newlines,\n // so print the comment directly without any newlines\n \"%\",\n part.trailingComment.content,\n breakParent\n );\n }\n\n if (!isLastItem) {\n content.push(line);\n }\n }\n\n let leadingComment: Doc[] = [\"\"];\n if (options.leadingComment) {\n if (options.leadingComment.leadingWhitespace) {\n leadingComment.push(\" \");\n }\n leadingComment.push(\"%\" + options.leadingComment.content, breakParent);\n }\n\n return group([\n options.openMark,\n ...leadingComment,\n // If there is no content, we don't want to push an extra `softline`.\n // This matters because the braces group could still be broken by `leadingComment`\n content.length > 0 ? indent([softline, ...content]) : \"\",\n softline,\n options.closeMark,\n ]);\n}\n", "import type { Doc } from \"prettier\";\nimport * as Ast from \"@unified-latex/unified-latex-types\";\nimport * as PrettierTypes from \"./prettier-types\";\nimport { getNodeInfo, fill, formatDocArray } from \"./common\";\nimport { match } from \"@unified-latex/unified-latex-util-match\";\n\n/**\n * Returns true if a `\\documentclass` macro is detected,\n * which would indicate that the node list contains the preamble.\n *\n * @param {[object]} nodes\n */\nexport function hasPreambleCode(nodes: Ast.Node[]) {\n return nodes.some((node) => match.macro(node, \"documentclass\"));\n}\n\nexport function printRoot(\n path: PrettierTypes.AstPath,\n print: PrettierTypes.RecursivePrintFunc,\n options: any\n): Doc {\n const node = path.getNode() as Ast.Root;\n const { renderInfo, previousNode, nextNode, referenceMap } = getNodeInfo(\n node,\n options\n );\n\n const content = path.map(print, \"content\");\n const rawContent = formatDocArray(node.content, content, options);\n\n const concatFunction = hasPreambleCode(node.content) ? (x: any) => x : fill;\n return concatFunction(rawContent);\n}\n", "import type { Doc } from \"prettier\";\nimport * as Ast from \"@unified-latex/unified-latex-types\";\nimport { printRaw } from \"@unified-latex/unified-latex-util-print-raw\";\nimport * as PrettierTypes from \"./prettier-types\";\n\nexport function printComment(\n path: PrettierTypes.AstPath,\n _print: PrettierTypes.RecursivePrintFunc,\n _options: any\n): Doc {\n const node = path.getNode() as Ast.Comment;\n\n // If a comment is on the same line as other content and it has leading whitespace,\n // add a single whitespace token.\n let leadingWhitespace = \"\";\n if (node.leadingWhitespace && node.sameline) {\n leadingWhitespace = \" \";\n }\n\n const content: Doc[] = [leadingWhitespace, \"%\" + printRaw(node.content)];\n return content;\n}\n", "import type { Doc } from \"prettier\";\nimport * as Ast from \"@unified-latex/unified-latex-types\";\nimport * as PrettierTypes from \"./prettier-types\";\nimport {\n getNodeInfo,\n softline,\n fill,\n hardline,\n line,\n indent,\n ESCAPE,\n joinWithSoftline,\n formatDocArray,\n} from \"./common\";\n\nexport function printInlineMath(\n path: PrettierTypes.AstPath,\n print: PrettierTypes.RecursivePrintFunc,\n options: any\n): Doc {\n const node = path.getNode() as Ast.InlineMath;\n\n // Since `$$` starts display math mode (in plain TeX),\n // an empty inline math environment must be printed as `$ $`.\n // We special case this.\n if (node.content.length === 0) {\n // We won't allow an empty math environment to be broken\n return [\"$\", \" \", \"$\"];\n }\n\n let content = path.map(print, \"content\");\n content = formatDocArray(node.content, content, options);\n content = joinWithSoftline(content);\n\n // If the last node is a comment, we need a linebreak before the closing `$`\n if (node.content[node.content.length - 1].type === \"comment\") {\n content.push(hardline);\n }\n\n return fill([\"$\", ...content, \"$\"]);\n}\n\nexport function printDisplayMath(\n path: PrettierTypes.AstPath,\n print: PrettierTypes.RecursivePrintFunc,\n options: any\n): Doc {\n const node = path.getNode() as Ast.InlineMath;\n\n let content = path.map(print, \"content\");\n content = formatDocArray(node.content, content, options);\n content = joinWithSoftline(content);\n\n // If we start with a comment on the same line as the environment\n // We should not insert a newline at the start of the environment body\n const bodyStartToken: PrettierTypes.Doc[] = [hardline];\n if (\n node.content.length === 0 ||\n (node.content[0].type === \"comment\" && node.content[0].sameline)\n ) {\n bodyStartToken.pop();\n }\n\n return [\n ESCAPE + \"[\",\n indent(fill(bodyStartToken.concat(content))),\n hardline,\n ESCAPE + \"]\",\n ];\n}\n", "import type { Doc } from \"prettier\";\nimport * as PrettierTypes from \"./prettier-types\";\nimport {\n getNodeInfo,\n softline,\n fill,\n indent,\n hardline,\n line,\n ESCAPE,\n formatEnvSurround,\n joinWithSoftline,\n formatDocArray,\n} from \"./common\";\nimport { printRaw } from \"@unified-latex/unified-latex-util-print-raw\";\nimport { parseAlignEnvironment } from \"@unified-latex/unified-latex-util-align\";\nimport * as Ast from \"@unified-latex/unified-latex-types\";\nimport { trim } from \"@unified-latex/unified-latex-util-trim\";\n\nexport function printVerbatimEnvironment(\n path: PrettierTypes.AstPath,\n print: PrettierTypes.RecursivePrintFunc,\n options: any\n): Doc {\n const node = path.getNode() as Ast.VerbatimEnvironment;\n\n const env = formatEnvSurround(node as any);\n\n return [env.start, node.content, env.end];\n}\n\nexport function printEnvironment(\n path: PrettierTypes.AstPath,\n print: PrettierTypes.RecursivePrintFunc,\n options: any\n): Doc {\n const node = path.getNode() as Ast.Environment;\n const { renderInfo, previousNode, nextNode, referenceMap } = getNodeInfo(\n node,\n options\n );\n\n const args = node.args ? path.map(print, \"args\" as any) : [];\n const env = formatEnvSurround(node);\n\n let content = path.map(print, \"content\");\n content = formatDocArray(node.content, content, options);\n if (renderInfo.inMathMode) {\n content = joinWithSoftline(content);\n }\n\n // If we start with a comment on the same line as the environment\n // We should not insert a newline at the start of the environment body\n let bodyStartToken: PrettierTypes.Doc[] = [hardline];\n if (\n node.content.length === 0 ||\n (node.content[0].type === \"comment\" && node.content[0].sameline)\n ) {\n bodyStartToken.pop();\n }\n\n return [\n env.start,\n ...args,\n indent(fill(bodyStartToken.concat(content))),\n hardline,\n env.end,\n ];\n}\n\nexport function printAlignedEnvironment(\n path: PrettierTypes.AstPath,\n print: PrettierTypes.RecursivePrintFunc,\n options: any\n): Doc {\n const node = path.getNode() as Ast.Environment;\n const { renderInfo, previousNode, nextNode, referenceMap } = getNodeInfo(\n node,\n options\n );\n\n const args = node.args ? path.map(print, \"args\" as any) : [];\n const env = formatEnvSurround(node);\n\n // If an aligned environment starts with a same-line comment, we want\n // to ignore it. It will be printed by the environment itself.\n const leadingComment =\n node.content[0] &&\n node.content[0].type === \"comment\" &&\n node.content[0].sameline\n ? node.content[0]\n : null;\n\n const { rows, rowSeps, trailingComments } = formatAlignedContent(\n leadingComment ? node.content.slice(1) : node.content\n );\n\n const content = [];\n for (let i = 0; i < rows.length; i++) {\n const row = rows[i];\n const rowSep = rowSeps[i];\n const trailingComment = trailingComments[i];\n\n // A row has\n // 1) Content\n // 2) (optional) rowSep (e.g., `\\\\`)\n // 3) (optional) comment\n // We want there to be exactly one space before the rowsep and exactly one space\n // before any comment.\n content.push(row);\n if (rowSep) {\n content.push(printRaw(rowSep));\n }\n if (rowSep && trailingComment) {\n content.push(\" \");\n }\n if (trailingComment) {\n content.push([\"%\", printRaw(trailingComment.content)]);\n }\n if (rowSep || trailingComment) {\n content.push(hardline);\n }\n }\n // Make sure the last item is not a `hardline`.\n if (content[content.length - 1] === hardline) {\n content.pop();\n }\n\n if (leadingComment) {\n content.unshift(\n leadingComment.leadingWhitespace ? \" \" : \"\",\n \"%\" + printRaw(leadingComment.content),\n hardline\n );\n return [env.start, ...args, indent(content), hardline, env.end];\n }\n return [\n env.start,\n ...args,\n indent([hardline, ...content]),\n hardline,\n env.end,\n ];\n}\n\n/**\n * Formats the content of an aligned/tabular environment's content.\n * Ensures the \"&\" delimiters all line up.\n *\n * @export\n * @param {[object]} nodes\n * @returns {{rows: [string], rowSeps: [object]}}\n */\nexport function formatAlignedContent(nodes: Ast.Node[]) {\n function getSpace(len = 1) {\n return \" \".repeat(len);\n }\n\n const rows = parseAlignEnvironment(nodes as any);\n // Find the number of columns\n const numCols = Math.max(...rows.map((r) => r.cells.length));\n const rowSeps = rows.map(({ rowSep }) => printRaw(rowSep || []));\n const trailingComments = rows.map(({ trailingComment }) => trailingComment);\n\n // Get the widths of each column.\n // Column widths will be the width of column contents plus the width\n // of the separator. This way, even multi-character separators\n // can be accommodated when rendering.\n const renderedRows = rows.map(({ cells, colSeps }) => ({\n cells: cells.map((nodes) => {\n trim(nodes);\n\n return printRaw(nodes);\n }),\n seps: colSeps.map((nodes) => printRaw(nodes)),\n }));\n const colWidths: number[] = [];\n for (let i = 0; i < numCols; i++) {\n colWidths.push(\n Math.max(\n ...renderedRows.map(\n ({ cells, seps }) =>\n ((cells[i] || \"\") + (seps[i] || \"\")).length\n )\n )\n );\n }\n\n const joinedRows = renderedRows.map(({ cells, seps }) => {\n if (cells.length === 1 && cells[0] === \"\") {\n return \"\";\n }\n let ret = \"\";\n for (let i = 0; i < cells.length; i++) {\n // There are at least as many cells as there are `seps`. Possibly one extra\n const width = colWidths[i] - (seps[i] || \"\").length;\n\n // Insert a space at the start so we don't run into the prior separator.\n // We'll trim this off in the end, in case it's not needed.\n ret +=\n (i === 0 ? \"\" : \" \") +\n cells[i] +\n getSpace(width - cells[i].length + 1) +\n (seps[i] || \"\");\n }\n return ret;\n });\n\n return { rows: joinedRows, rowSeps, trailingComments };\n}\n", "import type { Doc } from \"prettier\";\nimport * as PrettierTypes from \"./prettier-types\";\n\nimport { hardline, line, ESCAPE, getNodeInfo } from \"./common\";\nimport { printMacro } from \"./macro\";\nimport { printArgument } from \"./argument\";\nimport { printRoot } from \"./root\";\nimport { printComment } from \"./comment\";\nimport { printInlineMath, printDisplayMath } from \"./math\";\nimport {\n printVerbatimEnvironment,\n printEnvironment,\n printAlignedEnvironment,\n} from \"./environment\";\nimport {\n linebreak,\n printRaw,\n} from \"@unified-latex/unified-latex-util-print-raw\";\nimport { ReferenceMap } from \"../reference-map\";\n\nexport function printLatexAst(\n path: PrettierTypes.AstPath,\n options: PrettierTypes.Options & { referenceMap?: ReferenceMap },\n print: PrettierTypes.RecursivePrintFunc\n): Doc {\n const node = path.getValue();\n const { renderInfo } = getNodeInfo(node, options);\n\n if (node == null) {\n return node;\n }\n if (typeof node === \"string\") {\n return node;\n }\n\n switch (node.type) {\n case \"root\":\n // Create the ReferenceMap from the root node, so that\n // it can traverse the entire AST\n if (options.referenceMap) {\n console.warn(\n \"Processing root node, but ReferenceMap already exists. Are there multiple nodes of type 'root'?\"\n );\n }\n options.referenceMap = new ReferenceMap(node);\n return printRoot(path, print, options);\n case \"argument\":\n return printArgument(path, print, options);\n case \"comment\":\n return printComment(path, print, options);\n case \"environment\":\n case \"mathenv\":\n if (renderInfo.alignContent) {\n return printAlignedEnvironment(path, print, options);\n }\n return printEnvironment(path, print, options);\n case \"displaymath\":\n return printDisplayMath(path, print, options);\n case \"group\":\n // When we print a group, we are conservative and do a raw print of its contents.\n // However, we want to use `linebreak`s instead of literal `\\n` tokens.\n const content = printRaw(node.content, {\n asArray: true,\n }).map((token) => (token === linebreak ? hardline : token));\n return [\"{\", ...content, \"}\"];\n case \"inlinemath\":\n return printInlineMath(path, print, options);\n case \"macro\":\n return printMacro(path, print, options);\n case \"parbreak\":\n return [hardline, hardline];\n case \"string\":\n return node.content;\n case \"verb\":\n return [\n ESCAPE,\n node.env,\n node.escape,\n printRaw(node.content),\n node.escape,\n ];\n case \"verbatim\":\n return printVerbatimEnvironment(path, print, options);\n case \"whitespace\":\n return line;\n default:\n console.warn(\"Printing unknown type\", node);\n return printRaw(node);\n }\n}\n", "import * as Ast from \"@unified-latex/unified-latex-types\";\nimport { visit } from \"@unified-latex/unified-latex-util-visit\";\n\n/**\n * Generate a data structure that can be queried\n * for the next/previous node. This allows for \"peeking\"\n * during the rendering process.\n *\n * @class ReferenceMap\n */\nexport class ReferenceMap {\n ast: Ast.Ast;\n map: Map<\n Ast.Ast,\n { previous?: Ast.Ast; next?: Ast.Ast; renderCache?: any }\n >;\n\n constructor(ast: Ast.Ast) {\n this.ast = ast;\n this.map = new Map();\n visit(\n this.ast,\n (nodeList) => {\n for (let i = 0; i < nodeList.length; i++) {\n this.map.set(nodeList[i], {\n previous: nodeList[i - 1],\n next: nodeList[i + 1],\n });\n }\n },\n { includeArrays: true, test: Array.isArray }\n );\n }\n\n /**\n * Associate render-specific data with this node. This data\n * will be overwritten if `setRenderCache` is called twice.\n *\n * @param {Ast.Ast} node\n * @param {*} data\n * @memberof ReferenceMap\n */\n setRenderCache(node: any, data: any): void {\n const currData = this.map.get(node) || {};\n this.map.set(node, { ...currData, renderCache: data });\n }\n\n /**\n * Retrieve data associated with `node` via `setRenderCache`\n *\n * @param {Ast.Ast} node\n * @returns {(object | undefined)}\n * @memberof ReferenceMap\n */\n getRenderCache(node: any): object | any[] | undefined {\n return this.map.get(node)?.renderCache;\n }\n\n getPreviousNode(node: Ast.Ast): Ast.Node | undefined {\n return (this.map.get(node) || ({} as any)).previous;\n }\n\n getNextNode(node: Ast.Ast): Ast.Node | undefined {\n return (this.map.get(node) || ({} as any)).next;\n }\n}\n", "import type { Plugin, Printer } from \"prettier\";\nimport * as Ast from \"@unified-latex/unified-latex-types\";\nimport { parse } from \"@unified-latex/unified-latex-util-parse\";\nimport { printLatexAst } from \"./printer\";\n\nconst languages = [\n {\n name: \"latex\",\n extensions: [\".tex\"],\n parsers: [\"latex-parser\"],\n },\n];\n\nconst parsers = {\n \"latex-parser\": {\n parse,\n astFormat: \"latex-ast\",\n locStart: (node: Ast.Node) =>\n node.position ? node.position.start.offset : 0,\n locEnd: (node: Ast.Node) =>\n node.position ? node.position.end.offset : 1,\n },\n};\n\nconst printers = {\n \"latex-ast\": {\n print: printLatexAst,\n } as Printer,\n};\n\nconst prettierPluginLatex: Plugin = { languages, parsers, printers };\n\nexport { prettierPluginLatex };\n"], + "mappings": "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", + "names": ["group2", "indent2", "lineSuffix2", "softline", "group", "fill", "ifBreak", "line", "hardline", "lineSuffix", "lineSuffixBoundary", "breakParent", "indent", "markAsRoot", "join", "indent", "fill", "group", "match", "trim", "printRaw", "match", "trim", "printRaw", "hardline", "join", "breakParent", "line", "group", "indent", "softline", "trim", "printer", "printRaw", "group", "indent", "line", "softline", "match", "hardline", "join", "match", "content", "trim", "hardline", "fill", "match", "fill", "printRaw", "_print", "hardline", "fill", "indent", "printRaw", "trim", "hardline", "indent", "fill", "nodes", "linebreak", "printRaw", "printRaw", "linebreak", "hardline", "line"] +} diff --git a/node_modules/@unified-latex/unified-latex-prettier/libs/prettier-plugin-latex.d.ts b/node_modules/@unified-latex/unified-latex-prettier/libs/prettier-plugin-latex.d.ts new file mode 100644 index 0000000..78c9a4d --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-prettier/libs/prettier-plugin-latex.d.ts @@ -0,0 +1,5 @@ +import type { Plugin } from "prettier"; +import * as Ast from "@unified-latex/unified-latex-types"; +declare const prettierPluginLatex: Plugin; +export { prettierPluginLatex }; +//# sourceMappingURL=prettier-plugin-latex.d.ts.map \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-prettier/libs/prettier-plugin-latex.d.ts.map b/node_modules/@unified-latex/unified-latex-prettier/libs/prettier-plugin-latex.d.ts.map new file mode 100644 index 0000000..b8fc97a --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-prettier/libs/prettier-plugin-latex.d.ts.map @@ -0,0 +1 @@ +{"version":3,"file":"prettier-plugin-latex.d.ts","sourceRoot":"","sources":["../../libs/prettier-plugin-latex.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAW,MAAM,UAAU,CAAC;AAChD,OAAO,KAAK,GAAG,MAAM,oCAAoC,CAAC;AA6B1D,QAAA,MAAM,mBAAmB,EAAE,MAAM,CAAC,GAAG,CAAC,IAAI,CAAoC,CAAC;AAE/E,OAAO,EAAE,mBAAmB,EAAE,CAAC"} \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-prettier/libs/printer/argument.d.ts b/node_modules/@unified-latex/unified-latex-prettier/libs/printer/argument.d.ts new file mode 100644 index 0000000..4c1b8df --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-prettier/libs/printer/argument.d.ts @@ -0,0 +1,4 @@ +import type { Doc } from "prettier"; +import * as PrettierTypes from "./prettier-types"; +export declare function printArgument(path: PrettierTypes.AstPath, print: PrettierTypes.RecursivePrintFunc, options: any): Doc; +//# sourceMappingURL=argument.d.ts.map \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-prettier/libs/printer/argument.d.ts.map b/node_modules/@unified-latex/unified-latex-prettier/libs/printer/argument.d.ts.map new file mode 100644 index 0000000..45bff47 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-prettier/libs/printer/argument.d.ts.map @@ -0,0 +1 @@ +{"version":3,"file":"argument.d.ts","sourceRoot":"","sources":["../../../libs/printer/argument.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,UAAU,CAAC;AAEpC,OAAO,KAAK,aAAa,MAAM,kBAAkB,CAAC;AAOlD,wBAAgB,aAAa,CACzB,IAAI,EAAE,aAAa,CAAC,OAAO,EAC3B,KAAK,EAAE,aAAa,CAAC,kBAAkB,EACvC,OAAO,EAAE,GAAG,GACb,GAAG,CA4DL"} \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-prettier/libs/printer/comment.d.ts b/node_modules/@unified-latex/unified-latex-prettier/libs/printer/comment.d.ts new file mode 100644 index 0000000..0be0aba --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-prettier/libs/printer/comment.d.ts @@ -0,0 +1,4 @@ +import type { Doc } from "prettier"; +import * as PrettierTypes from "./prettier-types"; +export declare function printComment(path: PrettierTypes.AstPath, _print: PrettierTypes.RecursivePrintFunc, _options: any): Doc; +//# sourceMappingURL=comment.d.ts.map \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-prettier/libs/printer/comment.d.ts.map b/node_modules/@unified-latex/unified-latex-prettier/libs/printer/comment.d.ts.map new file mode 100644 index 0000000..a8b7a1b --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-prettier/libs/printer/comment.d.ts.map @@ -0,0 +1 @@ +{"version":3,"file":"comment.d.ts","sourceRoot":"","sources":["../../../libs/printer/comment.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,UAAU,CAAC;AAGpC,OAAO,KAAK,aAAa,MAAM,kBAAkB,CAAC;AAElD,wBAAgB,YAAY,CACxB,IAAI,EAAE,aAAa,CAAC,OAAO,EAC3B,MAAM,EAAE,aAAa,CAAC,kBAAkB,EACxC,QAAQ,EAAE,GAAG,GACd,GAAG,CAYL"} \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-prettier/libs/printer/common.d.ts b/node_modules/@unified-latex/unified-latex-prettier/libs/printer/common.d.ts new file mode 100644 index 0000000..9410272 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-prettier/libs/printer/common.d.ts @@ -0,0 +1,62 @@ +import { builders } from "prettier/doc"; +import type { Doc } from "prettier"; +import * as Ast from "@unified-latex/unified-latex-types"; +import * as PrettierTypes from "./prettier-types"; +import { ReferenceMap } from "../reference-map"; +/** + * Computes the environment name, start/end, and args. + * E.g., for "\begin{x}abc\end{x}", it returns + * ``` + * { + * envName: "x", + * start: "\\begin{x}", + * end: "\\end{x}", + * } + * ``` + * + * @param {*} node + * @returns + */ +export declare function formatEnvSurround(node: Ast.Environment): { + envName: string; + start: string; + end: string; +}; +/** + * Join an array with `softline`. However, if a `line` is + * found, do not insert an additional softline. For example + * `[a, b, c]` -> `[a, softline, b, softline, c]` + * + * but + * + * `[a, line, b, c]` -> `[a, line, b, softline, c]` + * + * @param {*} arr + * @returns + */ +export declare function joinWithSoftline(arr: Doc[]): builders.Doc[]; +export declare function getNodeInfo(node: any, options: PrettierTypes.Options & { + referenceMap?: ReferenceMap; +}): { + renderInfo: Record; + renderCache?: object; + previousNode?: Ast.Node; + nextNode?: Ast.Node; + referenceMap?: ReferenceMap; +}; +export declare const ESCAPE = "\\"; +export declare const group: typeof builders.group, fill: typeof builders.fill, ifBreak: typeof builders.ifBreak, line: builders.Line, softline: builders.Softline, hardline: builders.Hardline, lineSuffix: typeof builders.lineSuffix, lineSuffixBoundary: builders.LineSuffixBoundary, breakParent: builders.BreakParent, indent: typeof builders.indent, markAsRoot: typeof builders.markAsRoot, join: typeof builders.join; +/** + * Given an array of nodes and the corresponding printed versions, prepares + * a final Doc array. This function does things like ensures there are `hardlines` + * around environments and that there aren't excess hardlines at the start or end. + * It also unwraps `inParMode` macro contents. + * + * @export + * @param {Ast.Node[]} nodes + * @param {Doc[]} docArray + * @param {*} options + * @returns {Doc[]} + */ +export declare function formatDocArray(nodes: Ast.Node[], docArray: Doc[], options: any): Doc[]; +//# sourceMappingURL=common.d.ts.map \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-prettier/libs/printer/common.d.ts.map b/node_modules/@unified-latex/unified-latex-prettier/libs/printer/common.d.ts.map new file mode 100644 index 0000000..e78d110 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-prettier/libs/printer/common.d.ts.map @@ -0,0 +1 @@ +{"version":3,"file":"common.d.ts","sourceRoot":"","sources":["../../../libs/printer/common.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAC;AACxC,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,UAAU,CAAC;AACpC,OAAO,KAAK,GAAG,MAAM,oCAAoC,CAAC;AAC1D,OAAO,KAAK,aAAa,MAAM,kBAAkB,CAAC;AAElD,OAAO,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAGhD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,GAAG,CAAC,WAAW;;;;EAQtD;AAsBD;;;;;;;;;;;GAWG;AACH,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,GAAG,EAAE,kBAc1C;AAED,wBAAgB,WAAW,CACvB,IAAI,EAAE,GAAG,EACT,OAAO,EAAE,aAAa,CAAC,OAAO,GAAG;IAAE,YAAY,CAAC,EAAE,YAAY,CAAA;CAAE,GACjE;IACC,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IAChC,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,YAAY,CAAC,EAAE,GAAG,CAAC,IAAI,CAAC;IACxB,QAAQ,CAAC,EAAE,GAAG,CAAC,IAAI,CAAC;IACpB,YAAY,CAAC,EAAE,YAAY,CAAC;CAC/B,CAoBA;AAED,eAAO,MAAM,MAAM,OAAO,CAAC;AAG3B,eAAO,MACH,KAAK,yBACL,IAAI,wBACJ,OAAO,2BACP,IAAI,iBACJ,QAAQ,qBACR,QAAQ,qBACR,UAAU,8BACV,kBAAkB,+BAClB,WAAW,wBACX,MAAM,0BACN,UAAU,8BACV,IAAI,sBACI,CAAC;AAEb;;;;;;;;;;;GAWG;AACH,wBAAgB,cAAc,CAC1B,KAAK,EAAE,GAAG,CAAC,IAAI,EAAE,EACjB,QAAQ,EAAE,GAAG,EAAE,EACf,OAAO,EAAE,GAAG,GACb,GAAG,EAAE,CAmHP"} \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-prettier/libs/printer/environment.d.ts b/node_modules/@unified-latex/unified-latex-prettier/libs/printer/environment.d.ts new file mode 100644 index 0000000..146dd0f --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-prettier/libs/printer/environment.d.ts @@ -0,0 +1,20 @@ +import type { Doc } from "prettier"; +import * as PrettierTypes from "./prettier-types"; +import * as Ast from "@unified-latex/unified-latex-types"; +export declare function printVerbatimEnvironment(path: PrettierTypes.AstPath, print: PrettierTypes.RecursivePrintFunc, options: any): Doc; +export declare function printEnvironment(path: PrettierTypes.AstPath, print: PrettierTypes.RecursivePrintFunc, options: any): Doc; +export declare function printAlignedEnvironment(path: PrettierTypes.AstPath, print: PrettierTypes.RecursivePrintFunc, options: any): Doc; +/** + * Formats the content of an aligned/tabular environment's content. + * Ensures the "&" delimiters all line up. + * + * @export + * @param {[object]} nodes + * @returns {{rows: [string], rowSeps: [object]}} + */ +export declare function formatAlignedContent(nodes: Ast.Node[]): { + rows: string[]; + rowSeps: string[]; + trailingComments: (Ast.Comment | null)[]; +}; +//# sourceMappingURL=environment.d.ts.map \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-prettier/libs/printer/environment.d.ts.map b/node_modules/@unified-latex/unified-latex-prettier/libs/printer/environment.d.ts.map new file mode 100644 index 0000000..cc31736 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-prettier/libs/printer/environment.d.ts.map @@ -0,0 +1 @@ +{"version":3,"file":"environment.d.ts","sourceRoot":"","sources":["../../../libs/printer/environment.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,UAAU,CAAC;AACpC,OAAO,KAAK,aAAa,MAAM,kBAAkB,CAAC;AAelD,OAAO,KAAK,GAAG,MAAM,oCAAoC,CAAC;AAG1D,wBAAgB,wBAAwB,CACpC,IAAI,EAAE,aAAa,CAAC,OAAO,EAC3B,KAAK,EAAE,aAAa,CAAC,kBAAkB,EACvC,OAAO,EAAE,GAAG,GACb,GAAG,CAML;AAED,wBAAgB,gBAAgB,CAC5B,IAAI,EAAE,aAAa,CAAC,OAAO,EAC3B,KAAK,EAAE,aAAa,CAAC,kBAAkB,EACvC,OAAO,EAAE,GAAG,GACb,GAAG,CAiCL;AAED,wBAAgB,uBAAuB,CACnC,IAAI,EAAE,aAAa,CAAC,OAAO,EAC3B,KAAK,EAAE,aAAa,CAAC,kBAAkB,EACvC,OAAO,EAAE,GAAG,GACb,GAAG,CAqEL;AAED;;;;;;;GAOG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,GAAG,CAAC,IAAI,EAAE;;;;EAwDrD"} \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-prettier/libs/printer/index.d.ts b/node_modules/@unified-latex/unified-latex-prettier/libs/printer/index.d.ts new file mode 100644 index 0000000..87c80e1 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-prettier/libs/printer/index.d.ts @@ -0,0 +1,3 @@ +import { printLatexAst } from "./printer"; +export { printLatexAst, printLatexAst as printer }; +//# sourceMappingURL=index.d.ts.map \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-prettier/libs/printer/index.d.ts.map b/node_modules/@unified-latex/unified-latex-prettier/libs/printer/index.d.ts.map new file mode 100644 index 0000000..a268e63 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-prettier/libs/printer/index.d.ts.map @@ -0,0 +1 @@ +{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../libs/printer/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,WAAW,CAAC;AAE1C,OAAO,EAAE,aAAa,EAAE,aAAa,IAAI,OAAO,EAAE,CAAC"} \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-prettier/libs/printer/macro.d.ts b/node_modules/@unified-latex/unified-latex-prettier/libs/printer/macro.d.ts new file mode 100644 index 0000000..c4d1fec --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-prettier/libs/printer/macro.d.ts @@ -0,0 +1,4 @@ +import type { Doc } from "prettier"; +import * as PrettierTypes from "./prettier-types"; +export declare function printMacro(path: PrettierTypes.AstPath, print: PrettierTypes.RecursivePrintFunc, options: any): Doc; +//# sourceMappingURL=macro.d.ts.map \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-prettier/libs/printer/macro.d.ts.map b/node_modules/@unified-latex/unified-latex-prettier/libs/printer/macro.d.ts.map new file mode 100644 index 0000000..acfa9da --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-prettier/libs/printer/macro.d.ts.map @@ -0,0 +1 @@ +{"version":3,"file":"macro.d.ts","sourceRoot":"","sources":["../../../libs/printer/macro.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,UAAU,CAAC;AACpC,OAAO,KAAK,aAAa,MAAM,kBAAkB,CAAC;AAKlD,wBAAgB,UAAU,CACtB,IAAI,EAAE,aAAa,CAAC,OAAO,EAC3B,KAAK,EAAE,aAAa,CAAC,kBAAkB,EACvC,OAAO,EAAE,GAAG,GACb,GAAG,CAgCL"} \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-prettier/libs/printer/math.d.ts b/node_modules/@unified-latex/unified-latex-prettier/libs/printer/math.d.ts new file mode 100644 index 0000000..0d5a2d8 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-prettier/libs/printer/math.d.ts @@ -0,0 +1,5 @@ +import type { Doc } from "prettier"; +import * as PrettierTypes from "./prettier-types"; +export declare function printInlineMath(path: PrettierTypes.AstPath, print: PrettierTypes.RecursivePrintFunc, options: any): Doc; +export declare function printDisplayMath(path: PrettierTypes.AstPath, print: PrettierTypes.RecursivePrintFunc, options: any): Doc; +//# sourceMappingURL=math.d.ts.map \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-prettier/libs/printer/math.d.ts.map b/node_modules/@unified-latex/unified-latex-prettier/libs/printer/math.d.ts.map new file mode 100644 index 0000000..ebbcb3d --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-prettier/libs/printer/math.d.ts.map @@ -0,0 +1 @@ +{"version":3,"file":"math.d.ts","sourceRoot":"","sources":["../../../libs/printer/math.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,UAAU,CAAC;AAEpC,OAAO,KAAK,aAAa,MAAM,kBAAkB,CAAC;AAalD,wBAAgB,eAAe,CAC3B,IAAI,EAAE,aAAa,CAAC,OAAO,EAC3B,KAAK,EAAE,aAAa,CAAC,kBAAkB,EACvC,OAAO,EAAE,GAAG,GACb,GAAG,CAqBL;AAED,wBAAgB,gBAAgB,CAC5B,IAAI,EAAE,aAAa,CAAC,OAAO,EAC3B,KAAK,EAAE,aAAa,CAAC,kBAAkB,EACvC,OAAO,EAAE,GAAG,GACb,GAAG,CAuBL"} \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-prettier/libs/printer/prettier-types.d.ts b/node_modules/@unified-latex/unified-latex-prettier/libs/printer/prettier-types.d.ts new file mode 100644 index 0000000..93888de --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-prettier/libs/printer/prettier-types.d.ts @@ -0,0 +1,12 @@ +/** We recreate several of the Prettier types because the types supplied by prettier have some errors in them... */ +import type { Doc, AstPath as _AstPath, Options, ParserOptions } from "prettier"; +import * as Ast from "@unified-latex/unified-latex-types"; +export { Doc, Options }; +export type AstPath = _AstPath; +export interface PrintFunc { + (path: AstPath, options: ParserOptions, print: (path: AstPath) => Doc): Doc; +} +export interface RecursivePrintFunc { + (path: U, index?: number, value?: any): Doc; +} +//# sourceMappingURL=prettier-types.d.ts.map \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-prettier/libs/printer/prettier-types.d.ts.map b/node_modules/@unified-latex/unified-latex-prettier/libs/printer/prettier-types.d.ts.map new file mode 100644 index 0000000..f5346ad --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-prettier/libs/printer/prettier-types.d.ts.map @@ -0,0 +1 @@ +{"version":3,"file":"prettier-types.d.ts","sourceRoot":"","sources":["../../../libs/printer/prettier-types.ts"],"names":[],"mappings":"AAAA,mHAAmH;AAEnH,OAAO,KAAK,EACR,GAAG,EACH,OAAO,IAAI,QAAQ,EACnB,OAAO,EACP,aAAa,EAEhB,MAAM,UAAU,CAAC;AAClB,OAAO,KAAK,GAAG,MAAM,oCAAoC,CAAC;AAC1D,OAAO,EAAE,GAAG,EAAE,OAAO,EAAE,CAAC;AAGxB,MAAM,MAAM,OAAO,GAAG,QAAQ,CAAC,GAAG,CAAC,IAAI,GAAG,GAAG,CAAC,QAAQ,CAAC,CAAC;AAExD,MAAM,WAAW,SAAS;IACtB,CAAC,IAAI,EAAE,OAAO,EAAE,OAAO,EAAE,aAAa,EAAE,KAAK,EAAE,CAAC,IAAI,EAAE,OAAO,KAAK,GAAG,GAAG,GAAG,CAAC;CAC/E;AAED,MAAM,WAAW,kBAAkB,CAAC,CAAC,GAAG,GAAG;IACvC,CAAC,IAAI,EAAE,CAAC,EAAE,KAAK,CAAC,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,GAAG,GAAG,GAAG,CAAC;CAC/C"} \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-prettier/libs/printer/print-argument-pgfkeys.d.ts b/node_modules/@unified-latex/unified-latex-prettier/libs/printer/print-argument-pgfkeys.d.ts new file mode 100644 index 0000000..1ebf7a2 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-prettier/libs/printer/print-argument-pgfkeys.d.ts @@ -0,0 +1,13 @@ +import { Doc } from "prettier"; +import * as Ast from "@unified-latex/unified-latex-types"; +/** + * Format a sequence of Pgfkeys key-value pairs. `nodes` will be parsed + * by a grammar defining Pgfkeys + */ +export declare function printArgumentPgfkeys(nodes: Ast.Node[], options: { + openMark: string; + closeMark: string; + leadingComment?: Ast.Comment | null | undefined; + allowParenGroups?: boolean; +}): Doc; +//# sourceMappingURL=print-argument-pgfkeys.d.ts.map \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-prettier/libs/printer/print-argument-pgfkeys.d.ts.map b/node_modules/@unified-latex/unified-latex-prettier/libs/printer/print-argument-pgfkeys.d.ts.map new file mode 100644 index 0000000..465e0e9 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-prettier/libs/printer/print-argument-pgfkeys.d.ts.map @@ -0,0 +1 @@ +{"version":3,"file":"print-argument-pgfkeys.d.ts","sourceRoot":"","sources":["../../../libs/printer/print-argument-pgfkeys.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,MAAM,UAAU,CAAC;AAC/B,OAAO,KAAK,GAAG,MAAM,oCAAoC,CAAC;AAgB1D;;;GAGG;AACH,wBAAgB,oBAAoB,CAChC,KAAK,EAAE,GAAG,CAAC,IAAI,EAAE,EACjB,OAAO,EAAE;IACL,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,cAAc,CAAC,EAAE,GAAG,CAAC,OAAO,GAAG,IAAI,GAAG,SAAS,CAAC;IAChD,gBAAgB,CAAC,EAAE,OAAO,CAAC;CAC9B,GACF,GAAG,CA8DL"} \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-prettier/libs/printer/printer.d.ts b/node_modules/@unified-latex/unified-latex-prettier/libs/printer/printer.d.ts new file mode 100644 index 0000000..8ea68e0 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-prettier/libs/printer/printer.d.ts @@ -0,0 +1,7 @@ +import type { Doc } from "prettier"; +import * as PrettierTypes from "./prettier-types"; +import { ReferenceMap } from "../reference-map"; +export declare function printLatexAst(path: PrettierTypes.AstPath, options: PrettierTypes.Options & { + referenceMap?: ReferenceMap; +}, print: PrettierTypes.RecursivePrintFunc): Doc; +//# sourceMappingURL=printer.d.ts.map \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-prettier/libs/printer/printer.d.ts.map b/node_modules/@unified-latex/unified-latex-prettier/libs/printer/printer.d.ts.map new file mode 100644 index 0000000..c4a59e8 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-prettier/libs/printer/printer.d.ts.map @@ -0,0 +1 @@ +{"version":3,"file":"printer.d.ts","sourceRoot":"","sources":["../../../libs/printer/printer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,UAAU,CAAC;AACpC,OAAO,KAAK,aAAa,MAAM,kBAAkB,CAAC;AAiBlD,OAAO,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAEhD,wBAAgB,aAAa,CACzB,IAAI,EAAE,aAAa,CAAC,OAAO,EAC3B,OAAO,EAAE,aAAa,CAAC,OAAO,GAAG;IAAE,YAAY,CAAC,EAAE,YAAY,CAAA;CAAE,EAChE,KAAK,EAAE,aAAa,CAAC,kBAAkB,GACxC,GAAG,CAiEL"} \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-prettier/libs/printer/root.d.ts b/node_modules/@unified-latex/unified-latex-prettier/libs/printer/root.d.ts new file mode 100644 index 0000000..51595ac --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-prettier/libs/printer/root.d.ts @@ -0,0 +1,12 @@ +import type { Doc } from "prettier"; +import * as Ast from "@unified-latex/unified-latex-types"; +import * as PrettierTypes from "./prettier-types"; +/** + * Returns true if a `\documentclass` macro is detected, + * which would indicate that the node list contains the preamble. + * + * @param {[object]} nodes + */ +export declare function hasPreambleCode(nodes: Ast.Node[]): boolean; +export declare function printRoot(path: PrettierTypes.AstPath, print: PrettierTypes.RecursivePrintFunc, options: any): Doc; +//# sourceMappingURL=root.d.ts.map \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-prettier/libs/printer/root.d.ts.map b/node_modules/@unified-latex/unified-latex-prettier/libs/printer/root.d.ts.map new file mode 100644 index 0000000..1d8b4eb --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-prettier/libs/printer/root.d.ts.map @@ -0,0 +1 @@ +{"version":3,"file":"root.d.ts","sourceRoot":"","sources":["../../../libs/printer/root.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,UAAU,CAAC;AACpC,OAAO,KAAK,GAAG,MAAM,oCAAoC,CAAC;AAC1D,OAAO,KAAK,aAAa,MAAM,kBAAkB,CAAC;AAIlD;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,GAAG,CAAC,IAAI,EAAE,WAEhD;AAED,wBAAgB,SAAS,CACrB,IAAI,EAAE,aAAa,CAAC,OAAO,EAC3B,KAAK,EAAE,aAAa,CAAC,kBAAkB,EACvC,OAAO,EAAE,GAAG,GACb,GAAG,CAYL"} \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-prettier/libs/printer/tikz.d.ts b/node_modules/@unified-latex/unified-latex-prettier/libs/printer/tikz.d.ts new file mode 100644 index 0000000..c90463e --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-prettier/libs/printer/tikz.d.ts @@ -0,0 +1,4 @@ +import type { Doc } from "prettier"; +import * as PrettierTypes from "./prettier-types"; +export declare function printTikzArgument(path: PrettierTypes.AstPath, print: PrettierTypes.RecursivePrintFunc, options: any): Doc; +//# sourceMappingURL=tikz.d.ts.map \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-prettier/libs/printer/tikz.d.ts.map b/node_modules/@unified-latex/unified-latex-prettier/libs/printer/tikz.d.ts.map new file mode 100644 index 0000000..e4625f4 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-prettier/libs/printer/tikz.d.ts.map @@ -0,0 +1 @@ +{"version":3,"file":"tikz.d.ts","sourceRoot":"","sources":["../../../libs/printer/tikz.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,UAAU,CAAC;AAEpC,OAAO,KAAK,aAAa,MAAM,kBAAkB,CAAC;AA2BlD,wBAAgB,iBAAiB,CAC7B,IAAI,EAAE,aAAa,CAAC,OAAO,EAC3B,KAAK,EAAE,aAAa,CAAC,kBAAkB,EACvC,OAAO,EAAE,GAAG,GACb,GAAG,CA0BL"} \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-prettier/libs/reference-map.d.ts b/node_modules/@unified-latex/unified-latex-prettier/libs/reference-map.d.ts new file mode 100644 index 0000000..d440382 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-prettier/libs/reference-map.d.ts @@ -0,0 +1,37 @@ +import * as Ast from "@unified-latex/unified-latex-types"; +/** + * Generate a data structure that can be queried + * for the next/previous node. This allows for "peeking" + * during the rendering process. + * + * @class ReferenceMap + */ +export declare class ReferenceMap { + ast: Ast.Ast; + map: Map; + constructor(ast: Ast.Ast); + /** + * Associate render-specific data with this node. This data + * will be overwritten if `setRenderCache` is called twice. + * + * @param {Ast.Ast} node + * @param {*} data + * @memberof ReferenceMap + */ + setRenderCache(node: any, data: any): void; + /** + * Retrieve data associated with `node` via `setRenderCache` + * + * @param {Ast.Ast} node + * @returns {(object | undefined)} + * @memberof ReferenceMap + */ + getRenderCache(node: any): object | any[] | undefined; + getPreviousNode(node: Ast.Ast): Ast.Node | undefined; + getNextNode(node: Ast.Ast): Ast.Node | undefined; +} +//# sourceMappingURL=reference-map.d.ts.map \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-prettier/libs/reference-map.d.ts.map b/node_modules/@unified-latex/unified-latex-prettier/libs/reference-map.d.ts.map new file mode 100644 index 0000000..15fb512 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-prettier/libs/reference-map.d.ts.map @@ -0,0 +1 @@ +{"version":3,"file":"reference-map.d.ts","sourceRoot":"","sources":["../../libs/reference-map.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,GAAG,MAAM,oCAAoC,CAAC;AAG1D;;;;;;GAMG;AACH,qBAAa,YAAY;IACrB,GAAG,EAAE,GAAG,CAAC,GAAG,CAAC;IACb,GAAG,EAAE,GAAG,CACJ,GAAG,CAAC,GAAG,EACP;QAAE,QAAQ,CAAC,EAAE,GAAG,CAAC,GAAG,CAAC;QAAC,IAAI,CAAC,EAAE,GAAG,CAAC,GAAG,CAAC;QAAC,WAAW,CAAC,EAAE,GAAG,CAAA;KAAE,CAC5D,CAAC;gBAEU,GAAG,EAAE,GAAG,CAAC,GAAG;IAiBxB;;;;;;;OAOG;IACH,cAAc,CAAC,IAAI,EAAE,GAAG,EAAE,IAAI,EAAE,GAAG,GAAG,IAAI;IAK1C;;;;;;OAMG;IACH,cAAc,CAAC,IAAI,EAAE,GAAG,GAAG,MAAM,GAAG,GAAG,EAAE,GAAG,SAAS;IAIrD,eAAe,CAAC,IAAI,EAAE,GAAG,CAAC,GAAG,GAAG,GAAG,CAAC,IAAI,GAAG,SAAS;IAIpD,WAAW,CAAC,IAAI,EAAE,GAAG,CAAC,GAAG,GAAG,GAAG,CAAC,IAAI,GAAG,SAAS;CAGnD"} \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-prettier/libs/zip.d.ts b/node_modules/@unified-latex/unified-latex-prettier/libs/zip.d.ts new file mode 100644 index 0000000..da390d6 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-prettier/libs/zip.d.ts @@ -0,0 +1,2 @@ +export declare function zip(array1: T[], array2: U[]): [T, U][]; +//# sourceMappingURL=zip.d.ts.map \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-prettier/libs/zip.d.ts.map b/node_modules/@unified-latex/unified-latex-prettier/libs/zip.d.ts.map new file mode 100644 index 0000000..06508f1 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-prettier/libs/zip.d.ts.map @@ -0,0 +1 @@ +{"version":3,"file":"zip.d.ts","sourceRoot":"","sources":["../../libs/zip.ts"],"names":[],"mappings":"AAAA,wBAAgB,GAAG,CAAC,CAAC,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,EAAE,MAAM,EAAE,CAAC,EAAE,GAAG,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,CAO5D"} \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-prettier/package.json b/node_modules/@unified-latex/unified-latex-prettier/package.json new file mode 100644 index 0000000..2d300bd --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-prettier/package.json @@ -0,0 +1,61 @@ +{ + "name": "@unified-latex/unified-latex-prettier", + "version": "2.4.2", + "description": "Prettier plugin for processing LaTeX code via unified-latex", + "main": "index.js", + "type": "module", + "dependencies": { + "@unified-latex/unified-latex-ctan": "^1.4.1", + "@unified-latex/unified-latex-types": "^1.3.1", + "@unified-latex/unified-latex-util-align": "^1.4.0", + "@unified-latex/unified-latex-util-match": "^1.4.0", + "@unified-latex/unified-latex-util-parse": "^1.4.1", + "@unified-latex/unified-latex-util-pgfkeys": "^1.4.0", + "@unified-latex/unified-latex-util-print-raw": "^1.4.0", + "@unified-latex/unified-latex-util-trim": "^1.4.0", + "@unified-latex/unified-latex-util-visit": "^1.4.0", + "prettier": "^3.0.3", + "unified": "^10.1.2" + }, + "repository": { + "type": "git", + "url": "git+https://github.com/siefkenj/unified-latex.git" + }, + "keywords": [ + "pegjs", + "latex", + "parser", + "prettier", + "unified-latex", + "unified" + ], + "author": "Jason Siefken", + "license": "MIT", + "bugs": { + "url": "https://github.com/siefkenj/unified-latex/issues" + }, + "homepage": "https://github.com/siefkenj/unified-latex#readme", + "exports": { + ".": { + "import": "./index.js", + "require": "./index.cjs", + "types": "./index.d.ts" + }, + "./*js": "./*js", + "./*": { + "import": "./*/index.js", + "require": "./*/index.cjs", + "types": "./*/index.d.ts" + }, + "./*/index": { + "import": "./*/index.js", + "require": "./*/index.cjs" + } + }, + "files": [ + "**/*ts", + "**/*js", + "**/*.map", + "**/*.json" + ] +} \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-types/README.md b/node_modules/@unified-latex/unified-latex-types/README.md new file mode 100644 index 0000000..057b6ab --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-types/README.md @@ -0,0 +1,238 @@ + + + + +# unified-latex-types + +## What is this? + +Types for the `unified-latex` Abstract Syntax Tree (AST). These types extend the `unist` AST, +but instead of a `children` attribute, they have a `content` attribute. + +## When should I use this? + +If you're working with `unified-latex` ASTs. + +## Install + +```bash +npm install @unified-latex/unified-latex-types +``` + +This package contains both esm and commonjs exports. To explicitly access the esm export, +import the `.js` file. To explicitly access the commonjs export, import the `.cjs` file. + +# Types + +## `ArgumentParser` + +```typescript +export type ArgumentParser = ( + nodes: Ast.Node[], + startPos: number +) => { args: Ast.Argument[]; nodesRemoved: number }; +``` + +## `Ast` + +```typescript +export type Ast = Node | Argument | Node[]; +``` + +## `EnvInfo` + +```typescript +export type EnvInfo = { + renderInfo?: { + /** + * Whether the body of the environment should be treated as math mode + * + * @type {boolean} + */ + inMathMode?: boolean; + /** + * Whether to align the environment contents based on `&` and `\\` delimiters + * (like a matrix or tabular environment). + * + * @type {boolean} + */ + alignContent?: boolean; + /** + * Whether the arguments should be treated as pgfkeys-type arguments. + * + * @type {boolean} + */ + pgfkeysArgs?: boolean; + /** + * A list of names to be given to each argument when processing. This list should + * be the same length as the number of arguments. `null` can appear any number of times + * for "un-named" arguments. + * + * This allows a consistent reference to macro arguments even if the macro signatures are redefined between + * packages. + * + * @type {((string|null)[])} + */ + namedArguments?: (string | null)[]; + /** + * Whether the body is tikz-environment like (e.g., a `tikzpicture` or `scope`, etc.) + * + * @type {boolean} + */ + tikzEnvironment?: boolean; + }; + /** + * Function to process the body of an environment. The return value of `processContent` + * is treated as the new body. + * + */ + processContent?: (ast: Ast.Node[]) => Ast.Node[]; + /** + * The environment signature as an xparse argument specification string. + * + * @type {string} + */ + signature?: string; +}; +``` + +## `EnvInfoRecord` + +```typescript +export type EnvInfoRecord = Record; +``` + +## `GenericAst` + +```typescript +export type GenericAst = GenericNode | GenericNode[]; +``` + +## `MacroInfo` + +```typescript +export type MacroInfo = { + renderInfo?: { + /** + * Whether the macro's contents wraps along with the current + * paragraph or displays as it's own block. + * + * @type {boolean} + */ + inParMode?: boolean; + /** + * Whether the arguments should be processed as pgfkeys-type arguments. + * + * @type {boolean} + */ + pgfkeysArgs?: boolean; + /** + * Whether there should be line breaks after the macro + * (e.g., like the `\\` command.) + * + * @type {boolean} + */ + breakAfter?: boolean; + /** + * Whether there should be line breaks before and after the macro + * (e.g., like the `\section{...}` command.) + * + * @type {boolean} + */ + breakAround?: boolean; + /** + * Whether there should be line breaks before the macro. + * + * @type {boolean} + */ + breakBefore?: boolean; + /** + * Whether the contents of the macro should be assumed to be in math mode. + * + * @type {boolean} + */ + inMathMode?: boolean; + /** + * Whether the arguments should be rendered with a hanging indent when the wrap + * (like the arguments to \item in an enumerate environment.) + * + * @type {boolean} + */ + hangingIndent?: boolean; + /** + * A list of names to be given to each argument when processing. This list should + * be the same length as the number of arguments. `null` can appear any number of times + * for "un-named" arguments. + * + * This allows a consistent reference to macro arguments even if the macro signatures are redefined between + * packages. + * + * @type {((string|null)[])} + */ + namedArguments?: (string | null)[]; + /** + * Whether the macro represents a tikz path command (e.g. `\draw (0,0) -- (1,1);`). + * + * @type {boolean} + */ + tikzPathCommand?: boolean; + /** + * If `\sysdelims` is present, this contains the global information about the delimiters. + */ + sysdelims?: (Ast.Node[] | null)[]; + }; + /** + * The macro signature as an xparse argument specification string. + * + * @type {string} + */ + signature?: string; + /** + * Some special macros like `^` and `_` don't use + * an escape token. When matching against these macros, + * care must be taken to match the macro contents and the macro's + * escape token. + */ + escapeToken?: string; + /** + * Custom argument parser. If present, function overrides the default argument + * parsing of `signature`. An array of nodes is passed as well as the position + * of the first node **after** the macro. This function is expected to _mutate_ + * the input array, removing any nodes that are part of the macro's argument. + * + * This function will only be called on a macro if it has no existing `args`. + * + * Note: for stability when printing/accessing a node's arguments, this function + * should always return an argument array of the same length, regardless of + * whether optional arguments are present. For example, if this function parses + * a node with signature `o m`, it should ways return a length-two array of arguments. + * A "blank" argument (one that does not show up during printing) can be created + * with `args([], { openMark: "", closeMark: "" })`, using the `unified-latex-builder` package. + */ + argumentParser?: ArgumentParser; +}; +``` + +## `MacroInfoRecord` + +```typescript +export type MacroInfoRecord = Record; +``` + +## `Node` + +```typescript +export type Node = + | Root + | String + | Whitespace + | Parbreak + | Comment + | Macro + | Environment + | VerbatimEnvironment + | InlineMath + | DisplayMath + | Group + | Verb; +``` diff --git a/node_modules/@unified-latex/unified-latex-types/index.cjs b/node_modules/@unified-latex/unified-latex-types/index.cjs new file mode 100644 index 0000000..0b0915b --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-types/index.cjs @@ -0,0 +1,4 @@ +"use strict"; +const index = {}; +module.exports = index; +//# sourceMappingURL=index.cjs.map diff --git a/node_modules/@unified-latex/unified-latex-types/index.cjs.map b/node_modules/@unified-latex/unified-latex-types/index.cjs.map new file mode 100644 index 0000000..4ea1717 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-types/index.cjs.map @@ -0,0 +1 @@ +{"version":3,"file":"index.cjs","sources":["../index.ts"],"sourcesContent":["export * from \"./libs/ast-types\";\nexport * from \"./libs/type-guard\";\nexport * from \"./libs/info-specs\";\n\n// Export something for importing packages\nexport default {};\n\n// NOTE: The docstring comment must be the last item in the index.ts file!\n/**\n * ## What is this?\n *\n * Types for the `unified-latex` Abstract Syntax Tree (AST). These types extend the `unist` AST,\n * but instead of a `children` attribute, they have a `content` attribute.\n *\n * ## When should I use this?\n *\n * If you're working with `unified-latex` ASTs.\n */\n"],"names":[],"mappings":";AAKA,MAAA,QAAe,CAAC;;"} \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-types/index.d.ts b/node_modules/@unified-latex/unified-latex-types/index.d.ts new file mode 100644 index 0000000..4bf7ff3 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-types/index.d.ts @@ -0,0 +1,16 @@ +export * from './libs/ast-types'; +export * from './libs/type-guard'; +export * from './libs/info-specs'; +declare const _default: {}; +export default _default; +/** + * ## What is this? + * + * Types for the `unified-latex` Abstract Syntax Tree (AST). These types extend the `unist` AST, + * but instead of a `children` attribute, they have a `content` attribute. + * + * ## When should I use this? + * + * If you're working with `unified-latex` ASTs. + */ +//# sourceMappingURL=index.d.ts.map \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-types/index.js b/node_modules/@unified-latex/unified-latex-types/index.js new file mode 100644 index 0000000..18167e9 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-types/index.js @@ -0,0 +1,5 @@ +const index = {}; +export { + index as default +}; +//# sourceMappingURL=index.js.map diff --git a/node_modules/@unified-latex/unified-latex-types/index.js.map b/node_modules/@unified-latex/unified-latex-types/index.js.map new file mode 100644 index 0000000..757d6ff --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-types/index.js.map @@ -0,0 +1 @@ +{"version":3,"file":"index.js","sources":["../index.ts"],"sourcesContent":["export * from \"./libs/ast-types\";\nexport * from \"./libs/type-guard\";\nexport * from \"./libs/info-specs\";\n\n// Export something for importing packages\nexport default {};\n\n// NOTE: The docstring comment must be the last item in the index.ts file!\n/**\n * ## What is this?\n *\n * Types for the `unified-latex` Abstract Syntax Tree (AST). These types extend the `unist` AST,\n * but instead of a `children` attribute, they have a `content` attribute.\n *\n * ## When should I use this?\n *\n * If you're working with `unified-latex` ASTs.\n */\n"],"names":[],"mappings":"AAKA,MAAA,QAAe,CAAC;"} \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-types/libs/ast-types.d.ts b/node_modules/@unified-latex/unified-latex-types/libs/ast-types.d.ts new file mode 100644 index 0000000..49c56ad --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-types/libs/ast-types.d.ts @@ -0,0 +1,88 @@ +import { EnvInfo, MacroInfo } from './info-specs'; +export type GenericAst = GenericNode | GenericNode[]; +export interface GenericNode { + [x: string]: any; + type: string; + _renderInfo?: object; +} +interface BaseNode { + type: string; + _renderInfo?: (MacroInfo["renderInfo"] | EnvInfo["renderInfo"]) & { + defaultArg?: string; + } & Record; + position?: { + start: { + offset: number; + line: number; + column: number; + }; + end: { + offset: number; + line: number; + column: number; + }; + }; +} +interface ContentNode extends BaseNode { + content: Node[]; +} +export interface Root extends ContentNode { + type: "root"; +} +export interface String extends BaseNode { + type: "string"; + content: string; +} +export interface Whitespace extends BaseNode { + type: "whitespace"; +} +export interface Parbreak extends BaseNode { + type: "parbreak"; +} +export interface Comment extends BaseNode { + type: "comment"; + content: string; + sameline?: boolean; + suffixParbreak?: boolean; + leadingWhitespace?: boolean; +} +export interface Macro extends BaseNode { + type: "macro"; + content: string; + escapeToken?: string; + args?: Argument[]; +} +export interface Environment extends ContentNode { + type: "environment" | "mathenv"; + env: string; + args?: Argument[]; +} +export interface VerbatimEnvironment extends BaseNode { + type: "verbatim"; + env: string; + content: string; +} +export interface DisplayMath extends ContentNode { + type: "displaymath"; +} +export interface Group extends ContentNode { + type: "group"; +} +export interface InlineMath extends ContentNode { + type: "inlinemath"; +} +export interface Verb extends BaseNode { + type: "verb"; + env: string; + escape: string; + content: string; +} +export interface Argument extends ContentNode { + type: "argument"; + openMark: string; + closeMark: string; +} +export type Node = Root | String | Whitespace | Parbreak | Comment | Macro | Environment | VerbatimEnvironment | InlineMath | DisplayMath | Group | Verb; +export type Ast = Node | Argument | Node[]; +export {}; +//# sourceMappingURL=ast-types.d.ts.map \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-types/libs/info-specs.d.ts b/node_modules/@unified-latex/unified-latex-types/libs/info-specs.d.ts new file mode 100644 index 0000000..5110f92 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-types/libs/info-specs.d.ts @@ -0,0 +1,160 @@ +import * as Ast from "./ast-types"; +export type ArgumentParser = (nodes: Ast.Node[], startPos: number) => { + args: Ast.Argument[]; + nodesRemoved: number; +}; +export type EnvInfo = { + renderInfo?: { + /** + * Whether the body of the environment should be treated as math mode + * + * @type {boolean} + */ + inMathMode?: boolean; + /** + * Whether to align the environment contents based on `&` and `\\` delimiters + * (like a matrix or tabular environment). + * + * @type {boolean} + */ + alignContent?: boolean; + /** + * Whether the arguments should be treated as pgfkeys-type arguments. + * + * @type {boolean} + */ + pgfkeysArgs?: boolean; + /** + * A list of names to be given to each argument when processing. This list should + * be the same length as the number of arguments. `null` can appear any number of times + * for "un-named" arguments. + * + * This allows a consistent reference to macro arguments even if the macro signatures are redefined between + * packages. + * + * @type {((string|null)[])} + */ + namedArguments?: (string | null)[]; + /** + * Whether the body is tikz-environment like (e.g., a `tikzpicture` or `scope`, etc.) + * + * @type {boolean} + */ + tikzEnvironment?: boolean; + }; + /** + * Function to process the body of an environment. The return value of `processContent` + * is treated as the new body. + * + */ + processContent?: (ast: Ast.Node[]) => Ast.Node[]; + /** + * The environment signature as an xparse argument specification string. + * + * @type {string} + */ + signature?: string; +}; +export type MacroInfo = { + renderInfo?: { + /** + * Whether the macro's contents wraps along with the current + * paragraph or displays as it's own block. + * + * @type {boolean} + */ + inParMode?: boolean; + /** + * Whether the arguments should be processed as pgfkeys-type arguments. + * + * @type {boolean} + */ + pgfkeysArgs?: boolean; + /** + * Whether there should be line breaks after the macro + * (e.g., like the `\\` command.) + * + * @type {boolean} + */ + breakAfter?: boolean; + /** + * Whether there should be line breaks before and after the macro + * (e.g., like the `\section{...}` command.) + * + * @type {boolean} + */ + breakAround?: boolean; + /** + * Whether there should be line breaks before the macro. + * + * @type {boolean} + */ + breakBefore?: boolean; + /** + * Whether the contents of the macro should be assumed to be in math mode. + * + * @type {boolean} + */ + inMathMode?: boolean; + /** + * Whether the arguments should be rendered with a hanging indent when the wrap + * (like the arguments to \item in an enumerate environment.) + * + * @type {boolean} + */ + hangingIndent?: boolean; + /** + * A list of names to be given to each argument when processing. This list should + * be the same length as the number of arguments. `null` can appear any number of times + * for "un-named" arguments. + * + * This allows a consistent reference to macro arguments even if the macro signatures are redefined between + * packages. + * + * @type {((string|null)[])} + */ + namedArguments?: (string | null)[]; + /** + * Whether the macro represents a tikz path command (e.g. `\draw (0,0) -- (1,1);`). + * + * @type {boolean} + */ + tikzPathCommand?: boolean; + /** + * If `\sysdelims` is present, this contains the global information about the delimiters. + */ + sysdelims?: (Ast.Node[] | null)[]; + }; + /** + * The macro signature as an xparse argument specification string. + * + * @type {string} + */ + signature?: string; + /** + * Some special macros like `^` and `_` don't use + * an escape token. When matching against these macros, + * care must be taken to match the macro contents and the macro's + * escape token. + */ + escapeToken?: string; + /** + * Custom argument parser. If present, function overrides the default argument + * parsing of `signature`. An array of nodes is passed as well as the position + * of the first node **after** the macro. This function is expected to _mutate_ + * the input array, removing any nodes that are part of the macro's argument. + * + * This function will only be called on a macro if it has no existing `args`. + * + * Note: for stability when printing/accessing a node's arguments, this function + * should always return an argument array of the same length, regardless of + * whether optional arguments are present. For example, if this function parses + * a node with signature `o m`, it should ways return a length-two array of arguments. + * A "blank" argument (one that does not show up during printing) can be created + * with `args([], { openMark: "", closeMark: "" })`, using the `unified-latex-builder` package. + */ + argumentParser?: ArgumentParser; +}; +export type EnvInfoRecord = Record; +export type MacroInfoRecord = Record; +//# sourceMappingURL=info-specs.d.ts.map \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-types/libs/type-guard.d.ts b/node_modules/@unified-latex/unified-latex-types/libs/type-guard.d.ts new file mode 100644 index 0000000..5ab5dcc --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-types/libs/type-guard.d.ts @@ -0,0 +1,7 @@ +/** + * Generic type of a type-guard function. + */ +export interface TypeGuard { + (node: any): node is T; +} +//# sourceMappingURL=type-guard.d.ts.map \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-types/package.json b/node_modules/@unified-latex/unified-latex-types/package.json new file mode 100644 index 0000000..0ffc1e8 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-types/package.json @@ -0,0 +1,48 @@ +{ + "name": "@unified-latex/unified-latex-types", + "version": "1.8.0", + "description": "type definitions for unified-latex", + "main": "index.js", + "type": "module", + "repository": { + "type": "git", + "url": "git+https://github.com/siefkenj/unified-latex.git" + }, + "keywords": [ + "pegjs", + "latex", + "parser", + "prettier", + "unified-latex", + "unified" + ], + "author": "Jason Siefken", + "license": "MIT", + "bugs": { + "url": "https://github.com/siefkenj/unified-latex/issues" + }, + "homepage": "https://github.com/siefkenj/unified-latex#readme", + "exports": { + ".": { + "import": "./index.js", + "require": "./index.cjs", + "types": "./index.d.ts" + }, + "./*js": "./*js", + "./*": { + "import": "./*/index.js", + "require": "./*/index.cjs", + "types": "./*/index.d.ts" + }, + "./*/index": { + "import": "./*/index.js", + "require": "./*/index.cjs" + } + }, + "files": [ + "**/*ts", + "**/*js", + "**/*.map", + "**/*.json" + ] +} \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-util-align/README.md b/node_modules/@unified-latex/unified-latex-util-align/README.md new file mode 100644 index 0000000..989844b --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-util-align/README.md @@ -0,0 +1,79 @@ + + + + +# unified-latex-util-align + +## What is this? + +Functions to parse an analyze "align" environments like `\begin{align}...\end{align}` or +`\begin{bmatrix}...\end{bmatrix}`. + +## When should I use this? + +If you need to process the contents of an align environment for, e.g., pretty-printing. + +## Install + +```bash +npm install @unified-latex/unified-latex-util-align +``` + +This package contains both esm and commonjs exports. To explicitly access the esm export, +import the `.js` file. To explicitly access the commonjs export, import the `.cjs` file. + +# Functions + +## `createMatchers(rowSepMacros, colSep)` + + + +```typescript +function createMatchers( + rowSepMacros: string[], + colSep: string[] +): { + isRowSep: Ast.TypeGuard; + isColSep: (node: Ast.Node) => boolean; + isWhitespace: (node: Ast.Node) => node is Ast.Whitespace; + isSameLineComment: (node: Ast.Node) => boolean; + isOwnLineComment: (node: Ast.Node) => boolean; +}; +``` + +**Parameters** + +| Param | Type | +| :----------- | :--------- | +| rowSepMacros | `string[]` | +| colSep | `string[]` | + +## `parseAlignEnvironment(ast, colSep, rowSepMacros)` + +Parse the content of an align environment into an array of row objects. +Each row object looks like + + { + cells: [...], + colSeps: [...], + rowSep: ..., + trailingComment: ... + } + +`...` may be an ast node or `null`. + +```typescript +function parseAlignEnvironment( + ast: Ast.Node[], + colSep: string[], + rowSepMacros: string[] +): Row[]; +``` + +**Parameters** + +| Param | Type | +| :----------- | :----------- | +| ast | `Ast.Node[]` | +| colSep | `string[]` | +| rowSepMacros | `string[]` | diff --git a/node_modules/@unified-latex/unified-latex-util-align/index.cjs b/node_modules/@unified-latex/unified-latex-util-align/index.cjs new file mode 100644 index 0000000..65a72b0 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-util-align/index.cjs @@ -0,0 +1,27 @@ +"use strict"; +Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" }); +const unifiedLatexUtilMatch = require("@unified-latex/unified-latex-util-match"); +const unifiedLatexUtilPegjs = require("@unified-latex/unified-latex-util-pegjs"); +function createMatchers(rowSepMacros, colSep) { + const isRowSep = unifiedLatexUtilMatch.match.createMacroMatcher(rowSepMacros); + return { + isRowSep, + isColSep: (node) => colSep.some((sep) => unifiedLatexUtilMatch.match.string(node, sep)), + isWhitespace: (node) => unifiedLatexUtilMatch.match.whitespace(node), + isSameLineComment: (node) => unifiedLatexUtilMatch.match.comment(node) && node.sameline, + isOwnLineComment: (node) => unifiedLatexUtilMatch.match.comment(node) && !node.sameline + }; +} +function parseAlignEnvironment(ast, colSep = ["&"], rowSepMacros = ["\\", "hline", "cr"]) { + if (!Array.isArray(ast)) { + throw new Error("You must pass an array of nodes"); + } + ast = unifiedLatexUtilPegjs.decorateArrayForPegjs([...ast]); + return unifiedLatexUtilPegjs.AlignEnvironmentPegParser.parse( + ast, + createMatchers(rowSepMacros, colSep) + ); +} +exports.createMatchers = createMatchers; +exports.parseAlignEnvironment = parseAlignEnvironment; +//# sourceMappingURL=index.cjs.map diff --git a/node_modules/@unified-latex/unified-latex-util-align/index.cjs.map b/node_modules/@unified-latex/unified-latex-util-align/index.cjs.map new file mode 100644 index 0000000..9ea2877 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-util-align/index.cjs.map @@ -0,0 +1 @@ +{"version":3,"file":"index.cjs","sources":["../libs/parse-align-environment.ts"],"sourcesContent":["import * as Ast from \"@unified-latex/unified-latex-types\";\nimport { match } from \"@unified-latex/unified-latex-util-match\";\nimport {\n AlignEnvironmentPegParser,\n decorateArrayForPegjs,\n} from \"@unified-latex/unified-latex-util-pegjs\";\n\n// The types returned by the grammar\ninterface RowItems {\n cells: Ast.Node[][];\n colSeps: Ast.String[];\n}\n\ninterface Row extends RowItems {\n rowSep: Ast.Macro | null;\n trailingComment: Ast.Comment | null;\n}\n\nexport function createMatchers(rowSepMacros: string[], colSep: string[]) {\n const isRowSep = match.createMacroMatcher(rowSepMacros);\n return {\n isRowSep,\n isColSep: (node: Ast.Node) =>\n colSep.some((sep) => match.string(node, sep)),\n isWhitespace: (node: Ast.Node) => match.whitespace(node),\n isSameLineComment: (node: Ast.Node) =>\n match.comment(node) && node.sameline,\n isOwnLineComment: (node: Ast.Node) =>\n match.comment(node) && !node.sameline,\n };\n}\n\n/**\n * Parse the content of an align environment into an array of row objects.\n * Each row object looks like\n * ```\n * {\n * cells: [...],\n * colSeps: [...],\n * rowSep: ...,\n * trailingComment: ...\n * }\n * ```\n * `...` may be an ast node or `null`.\n *\n * @export\n * @param {[object]} ast\n * @param {string} [colSep=[\"&\"]]\n * @param {string} [rowSepMacros=[\"\\\\\", \"hline\", \"cr\"]]\n * @returns\n */\nexport function parseAlignEnvironment(\n ast: Ast.Node[],\n colSep = [\"&\"],\n rowSepMacros = [\"\\\\\", \"hline\", \"cr\"]\n): Row[] {\n if (!Array.isArray(ast)) {\n throw new Error(\"You must pass an array of nodes\");\n }\n // We need to at functions to `nodes` so that it imitates\n // a Javascript string. Because we're mutating, make a copy first\n ast = decorateArrayForPegjs([...ast]);\n // matchers are passed in via the second argument (the `options` argument)\n // so they are available from within the Pegjs grammar.\n return AlignEnvironmentPegParser.parse(\n ast,\n createMatchers(rowSepMacros, colSep)\n ) as Row[];\n}\n"],"names":["match","decorateArrayForPegjs","AlignEnvironmentPegParser"],"mappings":";;;;AAkBgB,SAAA,eAAe,cAAwB,QAAkB;AAC/D,QAAA,WAAWA,sBAAAA,MAAM,mBAAmB,YAAY;AAC/C,SAAA;AAAA,IACH;AAAA,IACA,UAAU,CAAC,SACP,OAAO,KAAK,CAAC,QAAQA,sBAAAA,MAAM,OAAO,MAAM,GAAG,CAAC;AAAA,IAChD,cAAc,CAAC,SAAmBA,4BAAM,WAAW,IAAI;AAAA,IACvD,mBAAmB,CAAC,SAChBA,4BAAM,QAAQ,IAAI,KAAK,KAAK;AAAA,IAChC,kBAAkB,CAAC,SACfA,sBAAA,MAAM,QAAQ,IAAI,KAAK,CAAC,KAAK;AAAA,EAAA;AAEzC;AAqBgB,SAAA,sBACZ,KACA,SAAS,CAAC,GAAG,GACb,eAAe,CAAC,MAAM,SAAS,IAAI,GAC9B;AACL,MAAI,CAAC,MAAM,QAAQ,GAAG,GAAG;AACf,UAAA,IAAI,MAAM,iCAAiC;AAAA,EACrD;AAGA,QAAMC,sBAAsB,sBAAA,CAAC,GAAG,GAAG,CAAC;AAGpC,SAAOC,sBAA0B,0BAAA;AAAA,IAC7B;AAAA,IACA,eAAe,cAAc,MAAM;AAAA,EAAA;AAE3C;;;"} \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-util-align/index.d.ts b/node_modules/@unified-latex/unified-latex-util-align/index.d.ts new file mode 100644 index 0000000..ee74084 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-util-align/index.d.ts @@ -0,0 +1,44 @@ +import * as Ast from '@unified-latex/unified-latex-types'; + +export declare function createMatchers(rowSepMacros: string[], colSep: string[]): { + isRowSep: Ast.TypeGuard; + isColSep: (node: Ast.Node) => boolean; + isWhitespace: (node: Ast.Node) => node is Ast.Whitespace; + isSameLineComment: (node: Ast.Node) => boolean | undefined; + isOwnLineComment: (node: Ast.Node) => boolean; +}; + +/** + * Parse the content of an align environment into an array of row objects. + * Each row object looks like + * ``` + * { + * cells: [...], + * colSeps: [...], + * rowSep: ..., + * trailingComment: ... + * } + * ``` + * `...` may be an ast node or `null`. + * + * @export + * @param {[object]} ast + * @param {string} [colSep=["&"]] + * @param {string} [rowSepMacros=["\\", "hline", "cr"]] + * @returns + */ +export declare function parseAlignEnvironment(ast: Ast.Node[], colSep?: string[], rowSepMacros?: string[]): Row[]; + +declare interface Row extends RowItems { + rowSep: Ast.Macro | null; + trailingComment: Ast.Comment | null; +} + +declare interface RowItems { + cells: Ast.Node[][]; + colSeps: Ast.String[]; +} + +export { } diff --git a/node_modules/@unified-latex/unified-latex-util-align/index.js b/node_modules/@unified-latex/unified-latex-util-align/index.js new file mode 100644 index 0000000..9a66788 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-util-align/index.js @@ -0,0 +1,27 @@ +import { match } from "@unified-latex/unified-latex-util-match"; +import { decorateArrayForPegjs, AlignEnvironmentPegParser } from "@unified-latex/unified-latex-util-pegjs"; +function createMatchers(rowSepMacros, colSep) { + const isRowSep = match.createMacroMatcher(rowSepMacros); + return { + isRowSep, + isColSep: (node) => colSep.some((sep) => match.string(node, sep)), + isWhitespace: (node) => match.whitespace(node), + isSameLineComment: (node) => match.comment(node) && node.sameline, + isOwnLineComment: (node) => match.comment(node) && !node.sameline + }; +} +function parseAlignEnvironment(ast, colSep = ["&"], rowSepMacros = ["\\", "hline", "cr"]) { + if (!Array.isArray(ast)) { + throw new Error("You must pass an array of nodes"); + } + ast = decorateArrayForPegjs([...ast]); + return AlignEnvironmentPegParser.parse( + ast, + createMatchers(rowSepMacros, colSep) + ); +} +export { + createMatchers, + parseAlignEnvironment +}; +//# sourceMappingURL=index.js.map diff --git a/node_modules/@unified-latex/unified-latex-util-align/index.js.map b/node_modules/@unified-latex/unified-latex-util-align/index.js.map new file mode 100644 index 0000000..ce6fe1d --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-util-align/index.js.map @@ -0,0 +1 @@ +{"version":3,"file":"index.js","sources":["../libs/parse-align-environment.ts"],"sourcesContent":["import * as Ast from \"@unified-latex/unified-latex-types\";\nimport { match } from \"@unified-latex/unified-latex-util-match\";\nimport {\n AlignEnvironmentPegParser,\n decorateArrayForPegjs,\n} from \"@unified-latex/unified-latex-util-pegjs\";\n\n// The types returned by the grammar\ninterface RowItems {\n cells: Ast.Node[][];\n colSeps: Ast.String[];\n}\n\ninterface Row extends RowItems {\n rowSep: Ast.Macro | null;\n trailingComment: Ast.Comment | null;\n}\n\nexport function createMatchers(rowSepMacros: string[], colSep: string[]) {\n const isRowSep = match.createMacroMatcher(rowSepMacros);\n return {\n isRowSep,\n isColSep: (node: Ast.Node) =>\n colSep.some((sep) => match.string(node, sep)),\n isWhitespace: (node: Ast.Node) => match.whitespace(node),\n isSameLineComment: (node: Ast.Node) =>\n match.comment(node) && node.sameline,\n isOwnLineComment: (node: Ast.Node) =>\n match.comment(node) && !node.sameline,\n };\n}\n\n/**\n * Parse the content of an align environment into an array of row objects.\n * Each row object looks like\n * ```\n * {\n * cells: [...],\n * colSeps: [...],\n * rowSep: ...,\n * trailingComment: ...\n * }\n * ```\n * `...` may be an ast node or `null`.\n *\n * @export\n * @param {[object]} ast\n * @param {string} [colSep=[\"&\"]]\n * @param {string} [rowSepMacros=[\"\\\\\", \"hline\", \"cr\"]]\n * @returns\n */\nexport function parseAlignEnvironment(\n ast: Ast.Node[],\n colSep = [\"&\"],\n rowSepMacros = [\"\\\\\", \"hline\", \"cr\"]\n): Row[] {\n if (!Array.isArray(ast)) {\n throw new Error(\"You must pass an array of nodes\");\n }\n // We need to at functions to `nodes` so that it imitates\n // a Javascript string. Because we're mutating, make a copy first\n ast = decorateArrayForPegjs([...ast]);\n // matchers are passed in via the second argument (the `options` argument)\n // so they are available from within the Pegjs grammar.\n return AlignEnvironmentPegParser.parse(\n ast,\n createMatchers(rowSepMacros, colSep)\n ) as Row[];\n}\n"],"names":[],"mappings":";;AAkBgB,SAAA,eAAe,cAAwB,QAAkB;AAC/D,QAAA,WAAW,MAAM,mBAAmB,YAAY;AAC/C,SAAA;AAAA,IACH;AAAA,IACA,UAAU,CAAC,SACP,OAAO,KAAK,CAAC,QAAQ,MAAM,OAAO,MAAM,GAAG,CAAC;AAAA,IAChD,cAAc,CAAC,SAAmB,MAAM,WAAW,IAAI;AAAA,IACvD,mBAAmB,CAAC,SAChB,MAAM,QAAQ,IAAI,KAAK,KAAK;AAAA,IAChC,kBAAkB,CAAC,SACf,MAAM,QAAQ,IAAI,KAAK,CAAC,KAAK;AAAA,EAAA;AAEzC;AAqBgB,SAAA,sBACZ,KACA,SAAS,CAAC,GAAG,GACb,eAAe,CAAC,MAAM,SAAS,IAAI,GAC9B;AACL,MAAI,CAAC,MAAM,QAAQ,GAAG,GAAG;AACf,UAAA,IAAI,MAAM,iCAAiC;AAAA,EACrD;AAGA,QAAM,sBAAsB,CAAC,GAAG,GAAG,CAAC;AAGpC,SAAO,0BAA0B;AAAA,IAC7B;AAAA,IACA,eAAe,cAAc,MAAM;AAAA,EAAA;AAE3C;"} \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-util-align/package.json b/node_modules/@unified-latex/unified-latex-util-align/package.json new file mode 100644 index 0000000..ea12585 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-util-align/package.json @@ -0,0 +1,53 @@ +{ + "name": "@unified-latex/unified-latex-util-align", + "version": "1.8.1", + "description": "Tools for manipulating unified-latex ASTs", + "main": "index.js", + "type": "module", + "dependencies": { + "@unified-latex/unified-latex-types": "^1.8.0", + "@unified-latex/unified-latex-util-match": "^1.8.0", + "@unified-latex/unified-latex-util-pegjs": "^1.8.1" + }, + "repository": { + "type": "git", + "url": "git+https://github.com/siefkenj/unified-latex.git" + }, + "keywords": [ + "pegjs", + "latex", + "parser", + "prettier", + "unified-latex", + "unified" + ], + "author": "Jason Siefken", + "license": "MIT", + "bugs": { + "url": "https://github.com/siefkenj/unified-latex/issues" + }, + "homepage": "https://github.com/siefkenj/unified-latex#readme", + "exports": { + ".": { + "import": "./index.js", + "require": "./index.cjs", + "types": "./index.d.ts" + }, + "./*js": "./*js", + "./*": { + "import": "./*/index.js", + "require": "./*/index.cjs", + "types": "./*/index.d.ts" + }, + "./*/index": { + "import": "./*/index.js", + "require": "./*/index.cjs" + } + }, + "files": [ + "**/*ts", + "**/*js", + "**/*.map", + "**/*.json" + ] +} \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-util-argspec/README.md b/node_modules/@unified-latex/unified-latex-util-argspec/README.md new file mode 100644 index 0000000..30302c9 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-util-argspec/README.md @@ -0,0 +1,59 @@ + + + + +# unified-latex-util-argspec + +## What is this? + +Tools to deal with `xparse` argument signatures. (E.g., `"o m"` for optional followed by mandatory +argument). + +## When should I use this? + +If you are working on the internals of `unified-latex`. + +## Install + +```bash +npm install @unified-latex/unified-latex-util-argspec +``` + +This package contains both esm and commonjs exports. To explicitly access the esm export, +import the `.js` file. To explicitly access the commonjs export, import the `.cjs` file. + +# Functions + +## `parse(str)` + +Parse an `xparse` argument specification string to an AST. +This function caches results. Don't mutate the returned AST! + +```typescript +function parse(str: String): ArgSpec.Node[]; +``` + +**Parameters** + +| Param | Type | Description | +| :---- | :------- | ---------------------- | +| str | `String` | * LaTeX string input | + +## `printRaw(node, root)` + +Print an `xparse` argument specification AST +to a string. + +```typescript +function printRaw( + node: string | ArgSpec.Node | (string | ArgSpec.Node)[], + root: Boolean +): string; +``` + +**Parameters** + +| Param | Type | +| :---- | :-------------------------------- | +| node | Omitted | +| root | `Boolean` | diff --git a/node_modules/@unified-latex/unified-latex-util-argspec/index.cjs b/node_modules/@unified-latex/unified-latex-util-argspec/index.cjs new file mode 100644 index 0000000..ba88aed --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-util-argspec/index.cjs @@ -0,0 +1,90 @@ +"use strict"; +Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" }); +const unifiedLatexUtilPegjs = require("@unified-latex/unified-latex-util-pegjs"); +function getDecorators(node) { + let ret = ""; + if (node.noLeadingWhitespace) { + ret += "!"; + } + return ret; +} +function printRaw(node, root = false) { + if (typeof node === "string") { + return node; + } + if (Array.isArray(node)) { + const sepToken = root ? " " : ""; + return node.map((tok) => printRaw(tok)).join(sepToken); + } + const decorators = getDecorators(node); + const defaultArg = printDefaultArg( + "defaultArg" in node ? node.defaultArg : void 0, + // `embellishment`s are the only spec that can have multiple default args + node.type === "embellishment" + ); + let spec = decorators; + const type = node.type; + switch (type) { + case "body": + return decorators + "b"; + case "optionalStar": + return decorators + "s"; + case "optionalToken": + return spec + "t" + node.token; + case "optional": + if (node.openBrace === "[" && node.closeBrace === "]") { + spec += node.defaultArg ? "O" : "o"; + } else { + spec += node.defaultArg ? "D" : "d"; + spec += node.openBrace + node.closeBrace; + } + return spec + defaultArg; + case "mandatory": + if (node.openBrace === "{" && node.closeBrace === "}") { + spec += "m"; + } else { + spec += node.defaultArg ? "R" : "r"; + spec += node.openBrace + node.closeBrace; + } + return spec + defaultArg; + case "embellishment": + spec += node.defaultArg ? "E" : "e"; + return spec + "{" + printRaw(node.embellishmentTokens) + "}" + defaultArg; + case "verbatim": + return spec + "v" + node.openBrace; + case "group": + return spec + "{" + printRaw(node.content) + "}"; + case "until": { + const stopTokens = printRaw(node.stopTokens); + return stopTokens.length > 1 || stopTokens[0] === " " ? `u{${stopTokens}}` : `u${stopTokens}`; + } + default: + const neverType = type; + console.warn(`Unknown node type "${neverType}" for node`, node); + return ""; + } +} +const parseCache = {}; +function parse(str = "") { + parseCache[str] = parseCache[str] || unifiedLatexUtilPegjs.ArgSpecPegParser.parse(str); + return parseCache[str]; +} +function printDefaultArg(args, multipleArgs) { + if (!args) { + return ""; + } + if (typeof args === "string") { + args = [args]; + } + if (!multipleArgs) { + return `{${args.join("")}}`; + } + return `{${args.map((a) => `{${a}}`).join("")}}`; +} +const argspecTypes = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({ + __proto__: null +}, Symbol.toStringTag, { value: "Module" })); +exports.ArgSpecAst = argspecTypes; +exports.parse = parse; +exports.printRaw = printRaw; +//# sourceMappingURL=index.cjs.map diff --git a/node_modules/@unified-latex/unified-latex-util-argspec/index.cjs.map b/node_modules/@unified-latex/unified-latex-util-argspec/index.cjs.map new file mode 100644 index 0000000..7d09efa --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-util-argspec/index.cjs.map @@ -0,0 +1 @@ +{"version":3,"file":"index.cjs","sources":["../libs/argspec-parser.ts"],"sourcesContent":["import { ArgSpecPegParser as PegParser } from \"@unified-latex/unified-latex-util-pegjs\";\nimport * as ArgSpec from \"./argspec-types\";\n\n/**\n * Produce a string containing any decorators for the argspec node.\n * For example, `!` in front of a node means \"don't accept leading whitespace\"\n */\nfunction getDecorators(node: ArgSpec.Node): string {\n let ret = \"\";\n if ((node as ArgSpec.LeadingWhitespace).noLeadingWhitespace) {\n ret += \"!\";\n }\n return ret;\n}\n\n/**\n * Print an `xparse` argument specification AST\n * to a string.\n */\nexport function printRaw(\n node: ArgSpec.Node | string | (ArgSpec.Node | string)[],\n root = false\n): string {\n if (typeof node === \"string\") {\n return node;\n }\n\n if (Array.isArray(node)) {\n const sepToken = root ? \" \" : \"\";\n return node.map((tok) => printRaw(tok)).join(sepToken);\n }\n\n const decorators = getDecorators(node);\n const defaultArg = printDefaultArg(\n \"defaultArg\" in node ? node.defaultArg : undefined,\n // `embellishment`s are the only spec that can have multiple default args\n node.type === \"embellishment\"\n );\n let spec = decorators;\n\n const type = node.type;\n switch (type) {\n case \"body\":\n return decorators + \"b\";\n case \"optionalStar\":\n return decorators + \"s\";\n case \"optionalToken\":\n return spec + \"t\" + node.token;\n case \"optional\":\n // [...] is the default enclosure for optional arguments\n if (node.openBrace === \"[\" && node.closeBrace === \"]\") {\n spec += node.defaultArg ? \"O\" : \"o\";\n } else {\n spec += node.defaultArg ? \"D\" : \"d\";\n spec += node.openBrace + node.closeBrace;\n }\n return spec + defaultArg;\n case \"mandatory\":\n // {...} is the default enclosure for mandatory arguments\n if (node.openBrace === \"{\" && node.closeBrace === \"}\") {\n spec += \"m\";\n } else {\n spec += node.defaultArg ? \"R\" : \"r\";\n spec += node.openBrace + node.closeBrace;\n }\n return spec + defaultArg;\n case \"embellishment\":\n spec += node.defaultArg ? \"E\" : \"e\";\n return (\n spec +\n \"{\" +\n printRaw(node.embellishmentTokens) +\n \"}\" +\n defaultArg\n );\n case \"verbatim\":\n return spec + \"v\" + node.openBrace;\n case \"group\":\n return spec + \"{\" + printRaw(node.content) + \"}\";\n case \"until\": {\n const stopTokens = printRaw(node.stopTokens);\n return stopTokens.length > 1 || stopTokens[0] === \" \"\n ? `u{${stopTokens}}`\n : `u${stopTokens}`;\n }\n default:\n const neverType: never = type;\n console.warn(`Unknown node type \"${neverType}\" for node`, node);\n return \"\";\n }\n}\n\nconst parseCache: { [argStr: string]: ArgSpec.Node[] } = {};\n\n/**\n * Parse an `xparse` argument specification string to an AST.\n * This function caches results. Don't mutate the returned AST!\n *\n * @param {string} [str=\"\"] - LaTeX string input\n * @returns - AST for LaTeX string\n */\nexport function parse(str = \"\"): ArgSpec.Node[] {\n parseCache[str] = parseCache[str] || PegParser.parse(str);\n return parseCache[str];\n}\n\nfunction printDefaultArg(\n args: string | string[] | undefined,\n multipleArgs: boolean\n): string {\n if (!args) {\n return \"\";\n }\n if (typeof args === \"string\") {\n args = [args];\n }\n if (!multipleArgs) {\n return `{${args.join(\"\")}}`;\n }\n return `{${args.map((a) => `{${a}}`).join(\"\")}}`;\n}\n"],"names":["PegParser"],"mappings":";;;AAOA,SAAS,cAAc,MAA4B;AAC/C,MAAI,MAAM;AACV,MAAK,KAAmC,qBAAqB;AAClD,WAAA;AAAA,EAAA;AAEJ,SAAA;AACX;AAMgB,SAAA,SACZ,MACA,OAAO,OACD;AACF,MAAA,OAAO,SAAS,UAAU;AACnB,WAAA;AAAA,EAAA;AAGP,MAAA,MAAM,QAAQ,IAAI,GAAG;AACf,UAAA,WAAW,OAAO,MAAM;AACvB,WAAA,KAAK,IAAI,CAAC,QAAQ,SAAS,GAAG,CAAC,EAAE,KAAK,QAAQ;AAAA,EAAA;AAGnD,QAAA,aAAa,cAAc,IAAI;AACrC,QAAM,aAAa;AAAA,IACf,gBAAgB,OAAO,KAAK,aAAa;AAAA;AAAA,IAEzC,KAAK,SAAS;AAAA,EAClB;AACA,MAAI,OAAO;AAEX,QAAM,OAAO,KAAK;AAClB,UAAQ,MAAM;AAAA,IACV,KAAK;AACD,aAAO,aAAa;AAAA,IACxB,KAAK;AACD,aAAO,aAAa;AAAA,IACxB,KAAK;AACM,aAAA,OAAO,MAAM,KAAK;AAAA,IAC7B,KAAK;AAED,UAAI,KAAK,cAAc,OAAO,KAAK,eAAe,KAAK;AAC3C,gBAAA,KAAK,aAAa,MAAM;AAAA,MAAA,OAC7B;AACK,gBAAA,KAAK,aAAa,MAAM;AACxB,gBAAA,KAAK,YAAY,KAAK;AAAA,MAAA;AAElC,aAAO,OAAO;AAAA,IAClB,KAAK;AAED,UAAI,KAAK,cAAc,OAAO,KAAK,eAAe,KAAK;AAC3C,gBAAA;AAAA,MAAA,OACL;AACK,gBAAA,KAAK,aAAa,MAAM;AACxB,gBAAA,KAAK,YAAY,KAAK;AAAA,MAAA;AAElC,aAAO,OAAO;AAAA,IAClB,KAAK;AACO,cAAA,KAAK,aAAa,MAAM;AAChC,aACI,OACA,MACA,SAAS,KAAK,mBAAmB,IACjC,MACA;AAAA,IAER,KAAK;AACM,aAAA,OAAO,MAAM,KAAK;AAAA,IAC7B,KAAK;AACD,aAAO,OAAO,MAAM,SAAS,KAAK,OAAO,IAAI;AAAA,IACjD,KAAK,SAAS;AACJ,YAAA,aAAa,SAAS,KAAK,UAAU;AACpC,aAAA,WAAW,SAAS,KAAK,WAAW,CAAC,MAAM,MAC5C,KAAK,UAAU,MACf,IAAI,UAAU;AAAA,IAAA;AAAA,IAExB;AACI,YAAM,YAAmB;AACzB,cAAQ,KAAK,sBAAsB,SAAS,cAAc,IAAI;AACvD,aAAA;AAAA,EAAA;AAEnB;AAEA,MAAM,aAAmD,CAAC;AAS1C,SAAA,MAAM,MAAM,IAAoB;AAC5C,aAAW,GAAG,IAAI,WAAW,GAAG,KAAKA,sBAAA,iBAAU,MAAM,GAAG;AACxD,SAAO,WAAW,GAAG;AACzB;AAEA,SAAS,gBACL,MACA,cACM;AACN,MAAI,CAAC,MAAM;AACA,WAAA;AAAA,EAAA;AAEP,MAAA,OAAO,SAAS,UAAU;AAC1B,WAAO,CAAC,IAAI;AAAA,EAAA;AAEhB,MAAI,CAAC,cAAc;AACf,WAAO,IAAI,KAAK,KAAK,EAAE,CAAC;AAAA,EAAA;AAErB,SAAA,IAAI,KAAK,IAAI,CAAC,MAAM,IAAI,CAAC,GAAG,EAAE,KAAK,EAAE,CAAC;AACjD;;;;;;;"} \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-util-argspec/index.d.ts b/node_modules/@unified-latex/unified-latex-util-argspec/index.d.ts new file mode 100644 index 0000000..9bf0300 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-util-argspec/index.d.ts @@ -0,0 +1,96 @@ +declare interface Arg extends AstNode { + openBrace: string; + closeBrace: string; +} + +declare namespace ArgSpecAst { + export { + Ast, + Node_2 as Node, + LeadingWhitespace, + DefaultArgument, + DefaultArguments, + Embellishment, + Group + } +} +export { ArgSpecAst } + +declare type Ast = Node_2[] | Node_2; + +declare interface AstNode { + type: string; +} + +declare interface Body_2 extends AstNode { + type: "body"; +} + +declare interface DefaultArgument { + defaultArg?: string; +} + +declare interface DefaultArguments { + defaultArg?: string[]; +} + +declare interface Embellishment extends DefaultArguments, AstNode { + type: "embellishment"; + embellishmentTokens: string[]; +} + +declare interface Group extends AstNode { + type: "group"; + content: (Group | string)[]; +} + +declare interface LeadingWhitespace { + noLeadingWhitespace: boolean | undefined; +} + +declare interface Mandatory extends LeadingWhitespace, DefaultArgument, Arg { + type: "mandatory"; +} + +declare type Node_2 = Optional | Mandatory | Verbatim | Body_2 | Group | Until; + +declare type Optional = OptionalArg | OptionalStar | OptionalToken | Embellishment; + +declare interface OptionalArg extends LeadingWhitespace, DefaultArgument, Arg { + type: "optional"; +} + +declare interface OptionalStar extends LeadingWhitespace, AstNode { + type: "optionalStar"; +} + +declare interface OptionalToken extends LeadingWhitespace, AstNode { + type: "optionalToken"; + token: string; +} + +/** + * Parse an `xparse` argument specification string to an AST. + * This function caches results. Don't mutate the returned AST! + * + * @param {string} [str=""] - LaTeX string input + * @returns - AST for LaTeX string + */ +export declare function parse(str?: string): ArgSpecAst.Node[]; + +/** + * Print an `xparse` argument specification AST + * to a string. + */ +export declare function printRaw(node: ArgSpecAst.Node | string | (ArgSpecAst.Node | string)[], root?: boolean): string; + +declare interface Until extends AstNode { + type: "until"; + stopTokens: string[]; +} + +declare interface Verbatim extends Arg { + type: "verbatim"; +} + +export { } diff --git a/node_modules/@unified-latex/unified-latex-util-argspec/index.js b/node_modules/@unified-latex/unified-latex-util-argspec/index.js new file mode 100644 index 0000000..9884d1d --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-util-argspec/index.js @@ -0,0 +1,90 @@ +import { ArgSpecPegParser } from "@unified-latex/unified-latex-util-pegjs"; +function getDecorators(node) { + let ret = ""; + if (node.noLeadingWhitespace) { + ret += "!"; + } + return ret; +} +function printRaw(node, root = false) { + if (typeof node === "string") { + return node; + } + if (Array.isArray(node)) { + const sepToken = root ? " " : ""; + return node.map((tok) => printRaw(tok)).join(sepToken); + } + const decorators = getDecorators(node); + const defaultArg = printDefaultArg( + "defaultArg" in node ? node.defaultArg : void 0, + // `embellishment`s are the only spec that can have multiple default args + node.type === "embellishment" + ); + let spec = decorators; + const type = node.type; + switch (type) { + case "body": + return decorators + "b"; + case "optionalStar": + return decorators + "s"; + case "optionalToken": + return spec + "t" + node.token; + case "optional": + if (node.openBrace === "[" && node.closeBrace === "]") { + spec += node.defaultArg ? "O" : "o"; + } else { + spec += node.defaultArg ? "D" : "d"; + spec += node.openBrace + node.closeBrace; + } + return spec + defaultArg; + case "mandatory": + if (node.openBrace === "{" && node.closeBrace === "}") { + spec += "m"; + } else { + spec += node.defaultArg ? "R" : "r"; + spec += node.openBrace + node.closeBrace; + } + return spec + defaultArg; + case "embellishment": + spec += node.defaultArg ? "E" : "e"; + return spec + "{" + printRaw(node.embellishmentTokens) + "}" + defaultArg; + case "verbatim": + return spec + "v" + node.openBrace; + case "group": + return spec + "{" + printRaw(node.content) + "}"; + case "until": { + const stopTokens = printRaw(node.stopTokens); + return stopTokens.length > 1 || stopTokens[0] === " " ? `u{${stopTokens}}` : `u${stopTokens}`; + } + default: + const neverType = type; + console.warn(`Unknown node type "${neverType}" for node`, node); + return ""; + } +} +const parseCache = {}; +function parse(str = "") { + parseCache[str] = parseCache[str] || ArgSpecPegParser.parse(str); + return parseCache[str]; +} +function printDefaultArg(args, multipleArgs) { + if (!args) { + return ""; + } + if (typeof args === "string") { + args = [args]; + } + if (!multipleArgs) { + return `{${args.join("")}}`; + } + return `{${args.map((a) => `{${a}}`).join("")}}`; +} +const argspecTypes = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({ + __proto__: null +}, Symbol.toStringTag, { value: "Module" })); +export { + argspecTypes as ArgSpecAst, + parse, + printRaw +}; +//# sourceMappingURL=index.js.map diff --git a/node_modules/@unified-latex/unified-latex-util-argspec/index.js.map b/node_modules/@unified-latex/unified-latex-util-argspec/index.js.map new file mode 100644 index 0000000..e2ce928 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-util-argspec/index.js.map @@ -0,0 +1 @@ +{"version":3,"file":"index.js","sources":["../libs/argspec-parser.ts"],"sourcesContent":["import { ArgSpecPegParser as PegParser } from \"@unified-latex/unified-latex-util-pegjs\";\nimport * as ArgSpec from \"./argspec-types\";\n\n/**\n * Produce a string containing any decorators for the argspec node.\n * For example, `!` in front of a node means \"don't accept leading whitespace\"\n */\nfunction getDecorators(node: ArgSpec.Node): string {\n let ret = \"\";\n if ((node as ArgSpec.LeadingWhitespace).noLeadingWhitespace) {\n ret += \"!\";\n }\n return ret;\n}\n\n/**\n * Print an `xparse` argument specification AST\n * to a string.\n */\nexport function printRaw(\n node: ArgSpec.Node | string | (ArgSpec.Node | string)[],\n root = false\n): string {\n if (typeof node === \"string\") {\n return node;\n }\n\n if (Array.isArray(node)) {\n const sepToken = root ? \" \" : \"\";\n return node.map((tok) => printRaw(tok)).join(sepToken);\n }\n\n const decorators = getDecorators(node);\n const defaultArg = printDefaultArg(\n \"defaultArg\" in node ? node.defaultArg : undefined,\n // `embellishment`s are the only spec that can have multiple default args\n node.type === \"embellishment\"\n );\n let spec = decorators;\n\n const type = node.type;\n switch (type) {\n case \"body\":\n return decorators + \"b\";\n case \"optionalStar\":\n return decorators + \"s\";\n case \"optionalToken\":\n return spec + \"t\" + node.token;\n case \"optional\":\n // [...] is the default enclosure for optional arguments\n if (node.openBrace === \"[\" && node.closeBrace === \"]\") {\n spec += node.defaultArg ? \"O\" : \"o\";\n } else {\n spec += node.defaultArg ? \"D\" : \"d\";\n spec += node.openBrace + node.closeBrace;\n }\n return spec + defaultArg;\n case \"mandatory\":\n // {...} is the default enclosure for mandatory arguments\n if (node.openBrace === \"{\" && node.closeBrace === \"}\") {\n spec += \"m\";\n } else {\n spec += node.defaultArg ? \"R\" : \"r\";\n spec += node.openBrace + node.closeBrace;\n }\n return spec + defaultArg;\n case \"embellishment\":\n spec += node.defaultArg ? \"E\" : \"e\";\n return (\n spec +\n \"{\" +\n printRaw(node.embellishmentTokens) +\n \"}\" +\n defaultArg\n );\n case \"verbatim\":\n return spec + \"v\" + node.openBrace;\n case \"group\":\n return spec + \"{\" + printRaw(node.content) + \"}\";\n case \"until\": {\n const stopTokens = printRaw(node.stopTokens);\n return stopTokens.length > 1 || stopTokens[0] === \" \"\n ? `u{${stopTokens}}`\n : `u${stopTokens}`;\n }\n default:\n const neverType: never = type;\n console.warn(`Unknown node type \"${neverType}\" for node`, node);\n return \"\";\n }\n}\n\nconst parseCache: { [argStr: string]: ArgSpec.Node[] } = {};\n\n/**\n * Parse an `xparse` argument specification string to an AST.\n * This function caches results. Don't mutate the returned AST!\n *\n * @param {string} [str=\"\"] - LaTeX string input\n * @returns - AST for LaTeX string\n */\nexport function parse(str = \"\"): ArgSpec.Node[] {\n parseCache[str] = parseCache[str] || PegParser.parse(str);\n return parseCache[str];\n}\n\nfunction printDefaultArg(\n args: string | string[] | undefined,\n multipleArgs: boolean\n): string {\n if (!args) {\n return \"\";\n }\n if (typeof args === \"string\") {\n args = [args];\n }\n if (!multipleArgs) {\n return `{${args.join(\"\")}}`;\n }\n return `{${args.map((a) => `{${a}}`).join(\"\")}}`;\n}\n"],"names":["PegParser"],"mappings":";AAOA,SAAS,cAAc,MAA4B;AAC/C,MAAI,MAAM;AACV,MAAK,KAAmC,qBAAqB;AAClD,WAAA;AAAA,EAAA;AAEJ,SAAA;AACX;AAMgB,SAAA,SACZ,MACA,OAAO,OACD;AACF,MAAA,OAAO,SAAS,UAAU;AACnB,WAAA;AAAA,EAAA;AAGP,MAAA,MAAM,QAAQ,IAAI,GAAG;AACf,UAAA,WAAW,OAAO,MAAM;AACvB,WAAA,KAAK,IAAI,CAAC,QAAQ,SAAS,GAAG,CAAC,EAAE,KAAK,QAAQ;AAAA,EAAA;AAGnD,QAAA,aAAa,cAAc,IAAI;AACrC,QAAM,aAAa;AAAA,IACf,gBAAgB,OAAO,KAAK,aAAa;AAAA;AAAA,IAEzC,KAAK,SAAS;AAAA,EAClB;AACA,MAAI,OAAO;AAEX,QAAM,OAAO,KAAK;AAClB,UAAQ,MAAM;AAAA,IACV,KAAK;AACD,aAAO,aAAa;AAAA,IACxB,KAAK;AACD,aAAO,aAAa;AAAA,IACxB,KAAK;AACM,aAAA,OAAO,MAAM,KAAK;AAAA,IAC7B,KAAK;AAED,UAAI,KAAK,cAAc,OAAO,KAAK,eAAe,KAAK;AAC3C,gBAAA,KAAK,aAAa,MAAM;AAAA,MAAA,OAC7B;AACK,gBAAA,KAAK,aAAa,MAAM;AACxB,gBAAA,KAAK,YAAY,KAAK;AAAA,MAAA;AAElC,aAAO,OAAO;AAAA,IAClB,KAAK;AAED,UAAI,KAAK,cAAc,OAAO,KAAK,eAAe,KAAK;AAC3C,gBAAA;AAAA,MAAA,OACL;AACK,gBAAA,KAAK,aAAa,MAAM;AACxB,gBAAA,KAAK,YAAY,KAAK;AAAA,MAAA;AAElC,aAAO,OAAO;AAAA,IAClB,KAAK;AACO,cAAA,KAAK,aAAa,MAAM;AAChC,aACI,OACA,MACA,SAAS,KAAK,mBAAmB,IACjC,MACA;AAAA,IAER,KAAK;AACM,aAAA,OAAO,MAAM,KAAK;AAAA,IAC7B,KAAK;AACD,aAAO,OAAO,MAAM,SAAS,KAAK,OAAO,IAAI;AAAA,IACjD,KAAK,SAAS;AACJ,YAAA,aAAa,SAAS,KAAK,UAAU;AACpC,aAAA,WAAW,SAAS,KAAK,WAAW,CAAC,MAAM,MAC5C,KAAK,UAAU,MACf,IAAI,UAAU;AAAA,IAAA;AAAA,IAExB;AACI,YAAM,YAAmB;AACzB,cAAQ,KAAK,sBAAsB,SAAS,cAAc,IAAI;AACvD,aAAA;AAAA,EAAA;AAEnB;AAEA,MAAM,aAAmD,CAAC;AAS1C,SAAA,MAAM,MAAM,IAAoB;AAC5C,aAAW,GAAG,IAAI,WAAW,GAAG,KAAKA,iBAAU,MAAM,GAAG;AACxD,SAAO,WAAW,GAAG;AACzB;AAEA,SAAS,gBACL,MACA,cACM;AACN,MAAI,CAAC,MAAM;AACA,WAAA;AAAA,EAAA;AAEP,MAAA,OAAO,SAAS,UAAU;AAC1B,WAAO,CAAC,IAAI;AAAA,EAAA;AAEhB,MAAI,CAAC,cAAc;AACf,WAAO,IAAI,KAAK,KAAK,EAAE,CAAC;AAAA,EAAA;AAErB,SAAA,IAAI,KAAK,IAAI,CAAC,MAAM,IAAI,CAAC,GAAG,EAAE,KAAK,EAAE,CAAC;AACjD;;;;"} \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-util-argspec/package.json b/node_modules/@unified-latex/unified-latex-util-argspec/package.json new file mode 100644 index 0000000..7974bdf --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-util-argspec/package.json @@ -0,0 +1,51 @@ +{ + "name": "@unified-latex/unified-latex-util-argspec", + "version": "1.8.2", + "description": "Tools parsing a LaTeX argument specification in the xparse format", + "main": "index.js", + "type": "module", + "dependencies": { + "@unified-latex/unified-latex-util-pegjs": "^1.8.1" + }, + "repository": { + "type": "git", + "url": "git+https://github.com/siefkenj/unified-latex.git" + }, + "keywords": [ + "pegjs", + "latex", + "parser", + "prettier", + "unified-latex", + "unified" + ], + "author": "Jason Siefken", + "license": "MIT", + "bugs": { + "url": "https://github.com/siefkenj/unified-latex/issues" + }, + "homepage": "https://github.com/siefkenj/unified-latex#readme", + "exports": { + ".": { + "import": "./index.js", + "require": "./index.cjs", + "types": "./index.d.ts" + }, + "./*js": "./*js", + "./*": { + "import": "./*/index.js", + "require": "./*/index.cjs", + "types": "./*/index.d.ts" + }, + "./*/index": { + "import": "./*/index.js", + "require": "./*/index.cjs" + } + }, + "files": [ + "**/*ts", + "**/*js", + "**/*.map", + "**/*.json" + ] +} \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-util-arguments/README.md b/node_modules/@unified-latex/unified-latex-util-arguments/README.md new file mode 100644 index 0000000..30a9757 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-util-arguments/README.md @@ -0,0 +1,116 @@ + + + + +# unified-latex-util-arguments + +## What is this? + +Functions to help modify and attach arguments to macros in a `unified-latex` Abstract Syntax Tree (AST). + +By default, TeX doesn't actually have a concept of macro "arguments". Instead, TeX searches the +tokens after a macro and processes them according to the macro's rules. However, LaTeX attempts +to make macros look like functions that accept arguments. To attach the "arguments" to a macro +node, the `unified-latex` AST needs to be reparsed and manipulated. + +## When should I use this? + +If you have custom macros that you want arguments attached to. + +If you know ahead of time which macros need arguments attached to them, use `unified-latex-util-parse` +and pass in the appropriate macro info instead. + +## Install + +```bash +npm install @unified-latex/unified-latex-util-arguments +``` + +This package contains both esm and commonjs exports. To explicitly access the esm export, +import the `.js` file. To explicitly access the commonjs export, import the `.cjs` file. + +# Plugins + +## `unifiedLatexAttachMacroArguments` + +Unified plugin to attach macro arguments to the macros specified via the `macros` +option. + +### Usage + +`unified().use(unifiedLatexAttachMacroArguments[, options])` + +#### options + +```typescript +{ macros: MacroInfoRecord; } +``` + +### Type + +`Plugin<{ macros: MacroInfoRecord; }[], Ast.Root, Ast.Root>` + +```typescript +function unifiedLatexAttachMacroArguments(options: { + macros: MacroInfoRecord; +}): (tree: Ast.Root) => void; +``` + +# Functions + +## `getArgsContent(node)` + +Returns the content of `args` for a macro or environment as an array. If an argument +was omitted (e.g., because it was an optional arg that wasn't included), then `null` is returned. + +```typescript +function getArgsContent(node: Ast.Macro | Ast.Environment): Ast.Node[][]; +``` + +**Parameters** + +| Param | Type | +| :---- | :----------------------------- | +| node | `Ast.Macro \| Ast.Environment` | + +## `getNamedArgsContent(node, namedArgumentsFallback)` + +Returns the content of `args` for a macro or environment as an object whose keys are the "names" +of each argument. These names of the arguments must be specified in the `_renderInfo` prop. If `_renderInfo` +does not contain a `namedArguments` array, then an empty object will be returned. + +```typescript +function getNamedArgsContent( + node: Ast.Macro | Ast.Environment, + namedArgumentsFallback: readonly string[] +): Record; +``` + +**Parameters** + +| Param | Type | +| :--------------------- | :----------------------------- | +| node | `Ast.Macro \| Ast.Environment` | +| namedArgumentsFallback | `readonly string[]` | + +## `gobbleSingleArgument(nodes, argSpec, startPos)` + +Gobbles an argument of whose type is specified +by `argSpec` starting at the position `startPos`. +If an argument couldn't be found, `argument` will be `null`. + +```typescript +function gobbleSingleArgument( + nodes: Ast.Node[], + argSpec: ArgSpec.Node, + startPos: Number +): { argument: Ast.Argument | null; nodesRemoved: number }; +``` + +**Parameters** + +| Param | Type | +| :------- | :------------- | +| nodes | `Ast.Node[]` | +| argSpec | `ArgSpec.Node` | +| startPos | `Number` | diff --git a/node_modules/@unified-latex/unified-latex-util-arguments/index.cjs b/node_modules/@unified-latex/unified-latex-util-arguments/index.cjs new file mode 100644 index 0000000..31b79d2 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-util-arguments/index.cjs @@ -0,0 +1,405 @@ +"use strict"; +Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" }); +const unifiedLatexBuilder = require("@unified-latex/unified-latex-builder"); +const unifiedLatexUtilArgspec = require("@unified-latex/unified-latex-util-argspec"); +const unifiedLatexUtilMatch = require("@unified-latex/unified-latex-util-match"); +const unifiedLatexUtilScan = require("@unified-latex/unified-latex-util-scan"); +const unifiedLatexUtilRenderInfo = require("@unified-latex/unified-latex-util-render-info"); +const unifiedLatexUtilVisit = require("@unified-latex/unified-latex-util-visit"); +function gobbleSingleArgument(nodes, argSpec, startPos = 0) { + if (typeof argSpec === "string" || !argSpec.type) { + throw new Error( + `argSpec must be an already-parsed argument specification, not "${JSON.stringify( + argSpec + )}"` + ); + } + let argument = null; + let currPos = startPos; + const gobbleWhitespace = argSpec.noLeadingWhitespace ? () => { + } : () => { + while (currPos < nodes.length) { + if (!unifiedLatexUtilMatch.match.whitespace(nodes[currPos])) { + break; + } + currPos++; + } + }; + const openMark = argSpec.openBrace || ""; + const closeMark = argSpec.closeBrace || ""; + const acceptGroup = (argSpec.type === "mandatory" || argSpec.type === "optional") && openMark === "{" && closeMark === "}"; + gobbleWhitespace(); + const currNode = nodes[currPos]; + if (currNode == null || unifiedLatexUtilMatch.match.comment(currNode) || unifiedLatexUtilMatch.match.parbreak(currNode)) { + const ret = { + argument, + nodesRemoved: 0 + }; + return ret; + } + switch (argSpec.type) { + case "mandatory": + if (acceptGroup) { + let content = [currNode]; + if (unifiedLatexUtilMatch.match.group(currNode)) { + content = currNode.content; + } + argument = unifiedLatexBuilder.arg(content, { + openMark, + closeMark + }); + currPos++; + break; + } else { + const bracePos2 = findBracePositions( + nodes, + currPos, + openMark, + closeMark + ); + if (bracePos2) { + argument = unifiedLatexBuilder.arg(nodes.slice(bracePos2[0] + 1, bracePos2[1]), { + openMark, + closeMark + }); + currPos = bracePos2[1] + 1; + break; + } + } + // NOTE: Fallthrough is on purpose. + // Matching a mandatory argument and an optional argument is the same for our purposes + // because we're not going to fail to parse because of a missing argument. + case "optional": + if (acceptGroup && unifiedLatexUtilMatch.match.group(currNode)) { + argument = unifiedLatexBuilder.arg(currNode.content, { + openMark, + closeMark + }); + currPos++; + break; + } + const bracePos = findBracePositions( + nodes, + currPos, + openMark, + closeMark + ); + if (bracePos) { + argument = unifiedLatexBuilder.arg(nodes.slice(bracePos[0] + 1, bracePos[1]), { + openMark, + closeMark + }); + currPos = bracePos[1] + 1; + break; + } + break; + case "optionalStar": + case "optionalToken": { + const bracePos2 = findBracePositions( + nodes, + currPos, + argSpec.type === "optionalStar" ? "*" : argSpec.token + ); + if (bracePos2) { + argument = unifiedLatexBuilder.arg(currNode, { openMark: "", closeMark: "" }); + currPos = bracePos2[0] + 1; + } + break; + } + case "until": { + if (argSpec.stopTokens.length > 1) { + console.warn( + `"until" matches with multi-token stop conditions are not yet implemented` + ); + break; + } + const rawToken = argSpec.stopTokens[0]; + const stopToken = rawToken === " " ? { type: "whitespace" } : rawToken; + let bracePos2 = findBracePositions( + nodes, + startPos, + void 0, + stopToken + ); + if (!bracePos2) { + break; + } + argument = unifiedLatexBuilder.arg(nodes.slice(startPos, bracePos2[1]), { + openMark: "", + closeMark: rawToken + }); + currPos = bracePos2[1]; + if (currPos < nodes.length) { + currPos++; + } + break; + } + case "embellishment": { + for (const token of argSpec.embellishmentTokens) { + const bracePos2 = findBracePositions(nodes, currPos, token); + if (!bracePos2) { + continue; + } + let argNode = nodes[bracePos2[0] + 1]; + argument = unifiedLatexBuilder.arg( + unifiedLatexUtilMatch.match.group(argNode) ? argNode.content : argNode, + { + openMark: token, + closeMark: "" + } + ); + currPos = bracePos2[1] + 1; + break; + } + break; + } + default: + console.warn( + `Don't know how to find an argument of argspec type "${argSpec.type}"` + ); + } + const nodesRemoved = argument ? currPos - startPos : 0; + nodes.splice(startPos, nodesRemoved); + return { argument, nodesRemoved }; +} +function cloneStringNode(node, content) { + return Object.assign({}, node, { content }); +} +function findBracePositions(nodes, startPos, openMark, closeMark) { + const currNode = nodes[startPos]; + let openMarkPos = startPos; + let closeMarkPos = startPos; + if (openMark) { + if (!unifiedLatexUtilMatch.match.anyString(currNode)) { + return; + } + const nodeContent = currNode.content; + if (!nodeContent.startsWith(openMark)) { + return; + } + openMarkPos = startPos; + if (currNode.content.length > openMark.length) { + const nodeContent2 = currNode.content; + currNode.content = openMark; + nodes.splice( + openMarkPos + 1, + 0, + cloneStringNode(currNode, nodeContent2.slice(openMark.length)) + ); + } + closeMarkPos = openMarkPos + 1; + } + if (!closeMark) { + const argNode = nodes[closeMarkPos]; + if (!argNode) { + return; + } + if (unifiedLatexUtilMatch.match.anyString(argNode) && argNode.content.length > 1) { + const argContent = argNode.content; + argNode.content = argContent[0]; + nodes.splice( + closeMarkPos + 1, + 0, + cloneStringNode(argNode, argContent.slice(1)) + ); + } + return [openMarkPos, closeMarkPos]; + } + closeMarkPos = unifiedLatexUtilScan.scan(nodes, closeMark, { + startIndex: closeMarkPos, + allowSubstringMatches: true + }); + if (closeMarkPos === null) { + return; + } + const closingNode = nodes[closeMarkPos]; + if (unifiedLatexUtilMatch.match.anyString(closingNode) && typeof closeMark === "string") { + const closingNodeContent = closingNode.content; + let closeMarkIndex = closingNodeContent.indexOf(closeMark); + if (closingNodeContent.length > closeMark.length) { + closingNode.content = closeMark; + const prev = closingNodeContent.slice(0, closeMarkIndex); + const next = closingNodeContent.slice( + closeMarkIndex + closeMark.length + ); + if (prev) { + nodes.splice( + closeMarkPos, + 0, + cloneStringNode(closingNode, prev) + ); + closeMarkPos++; + } + if (next) { + nodes.splice( + closeMarkPos + 1, + 0, + cloneStringNode(closingNode, next) + ); + } + } + } + return [openMarkPos, closeMarkPos]; +} +function gobbleArguments(nodes, argSpec, startPos = 0) { + if (typeof argSpec === "function") { + return argSpec(nodes, startPos); + } + if (typeof argSpec === "string") { + argSpec = unifiedLatexUtilArgspec.parse(argSpec); + } + const args = []; + let nodesRemoved = 0; + for (const spec of argSpec) { + if (spec.type === "embellishment") { + const remainingTokens = new Set(spec.embellishmentTokens); + const argForToken = Object.fromEntries( + spec.embellishmentTokens.map((t, i) => { + var _a; + const defaultArg = "defaultArg" in spec ? (_a = spec.defaultArg) == null ? void 0 : _a[i] : void 0; + return [t, emptyArg(defaultArg)]; + }) + ); + let { argument, nodesRemoved: removed } = gobbleSingleArgument( + nodes, + embellishmentSpec(remainingTokens), + startPos + ); + while (argument) { + const token = argument.openMark; + remainingTokens.delete(token); + argForToken[token] = argument; + nodesRemoved += removed; + const newSpec = embellishmentSpec(remainingTokens); + ({ argument, nodesRemoved: removed } = gobbleSingleArgument( + nodes, + newSpec, + startPos + )); + } + args.push(...spec.embellishmentTokens.map((t) => argForToken[t])); + } else { + const { argument, nodesRemoved: removed } = gobbleSingleArgument( + nodes, + spec, + startPos + ); + const defaultArg = "defaultArg" in spec ? spec.defaultArg : void 0; + args.push(argument || emptyArg(defaultArg)); + nodesRemoved += removed; + } + } + return { args, nodesRemoved }; +} +function embellishmentSpec(tokens) { + return { + type: "embellishment", + embellishmentTokens: [...tokens] + }; +} +function emptyArg(defaultArg) { + const ret = unifiedLatexBuilder.arg([], { openMark: "", closeMark: "" }); + if (defaultArg != null) { + unifiedLatexUtilRenderInfo.updateRenderInfo(ret, { defaultArg }); + } + return ret; +} +function attachMacroArgsInArray(nodes, macros) { + let currIndex; + const isRelevantMacro = unifiedLatexUtilMatch.match.createMacroMatcher(macros); + function gobbleUntilMacro() { + while (currIndex >= 0 && !isRelevantMacro(nodes[currIndex])) { + currIndex--; + } + } + currIndex = nodes.length - 1; + while (currIndex >= 0) { + gobbleUntilMacro(); + if (currIndex < 0) { + return; + } + const macroIndex = currIndex; + const macro = nodes[macroIndex]; + const macroName = macro.content; + const macroInfo = macros[macroName]; + unifiedLatexUtilRenderInfo.updateRenderInfo(macro, macroInfo.renderInfo); + const signatureOrParser = macroInfo.argumentParser || macroInfo.signature; + if (signatureOrParser == null) { + currIndex--; + continue; + } + if (macro.args != null) { + currIndex = macroIndex - 1; + continue; + } + currIndex++; + const { args } = gobbleArguments(nodes, signatureOrParser, currIndex); + macro.args = args; + currIndex = macroIndex - 1; + } +} +function attachMacroArgs(tree, macros) { + unifiedLatexUtilVisit.visit( + tree, + (nodes) => { + attachMacroArgsInArray(nodes, macros); + }, + { includeArrays: true, test: Array.isArray } + ); +} +const unifiedLatexAttachMacroArguments = function unifiedLatexAttachMacroArguments2(options) { + return (tree) => { + const { macros = {} } = options || {}; + if (Object.keys(macros).length === 0) { + console.warn( + "Attempting to attach macro arguments but no macros are specified." + ); + } + unifiedLatexUtilVisit.visit( + tree, + (nodes) => { + attachMacroArgsInArray(nodes, macros); + }, + { includeArrays: true, test: Array.isArray } + ); + }; +}; +function getArgsContent(node) { + if (!Array.isArray(node.args)) { + return []; + } + return node.args.map((arg) => { + if (arg.openMark === "" && arg.content.length === 0) { + return null; + } + return arg.content; + }); +} +function getNamedArgsContent(node, namedArgumentsFallback = []) { + var _a; + const names = ((_a = node._renderInfo) == null ? void 0 : _a.namedArguments) || namedArgumentsFallback; + if (!Array.isArray(node.args) || !Array.isArray(names) || names.length === 0) { + return {}; + } + const ret = {}; + node.args.forEach((arg, i) => { + const name = names[i]; + if (name == null) { + return; + } + let val = arg.content; + if (arg.openMark === "" && arg.content.length === 0) { + val = null; + } + ret[name] = val; + }); + return ret; +} +exports.attachMacroArgs = attachMacroArgs; +exports.attachMacroArgsInArray = attachMacroArgsInArray; +exports.getArgsContent = getArgsContent; +exports.getNamedArgsContent = getNamedArgsContent; +exports.gobbleArguments = gobbleArguments; +exports.gobbleSingleArgument = gobbleSingleArgument; +exports.unifiedLatexAttachMacroArguments = unifiedLatexAttachMacroArguments; +//# sourceMappingURL=index.cjs.map diff --git a/node_modules/@unified-latex/unified-latex-util-arguments/index.cjs.map b/node_modules/@unified-latex/unified-latex-util-arguments/index.cjs.map new file mode 100644 index 0000000..4da523e --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-util-arguments/index.cjs.map @@ -0,0 +1 @@ +{"version":3,"file":"index.cjs","sources":["../libs/gobble-single-argument.ts","../libs/gobble-arguments.ts","../libs/attach-arguments.ts","../libs/unified-latex-attach-macro-arguments.ts","../libs/get-args-content.ts"],"sourcesContent":["/* eslint-disable no-fallthrough */\nimport { arg } from \"@unified-latex/unified-latex-builder\";\nimport * as Ast from \"@unified-latex/unified-latex-types\";\nimport {\n ArgSpecAst as ArgSpec,\n printRaw,\n} from \"@unified-latex/unified-latex-util-argspec\";\nimport { match } from \"@unified-latex/unified-latex-util-match\";\nimport { scan } from \"@unified-latex/unified-latex-util-scan\";\n\n/**\n * Gobbles an argument of whose type is specified\n * by `argSpec` starting at the position `startPos`.\n * If an argument couldn't be found, `argument` will be `null`.\n */\nexport function gobbleSingleArgument(\n nodes: Ast.Node[],\n argSpec: ArgSpec.Node,\n startPos = 0\n): {\n argument: Ast.Argument | null;\n nodesRemoved: number;\n} {\n if (typeof argSpec === \"string\" || !argSpec.type) {\n throw new Error(\n `argSpec must be an already-parsed argument specification, not \"${JSON.stringify(\n argSpec\n )}\"`\n );\n }\n\n let argument: Ast.Argument | null = null;\n\n let currPos = startPos;\n\n // Gobble whitespace from `currPos` onward, updating `currPos`.\n // If `argSpec` specifies leading whitespace is not allowed,\n // this function does nothing.\n const gobbleWhitespace = (argSpec as ArgSpec.LeadingWhitespace)\n .noLeadingWhitespace\n ? () => {}\n : () => {\n while (currPos < nodes.length) {\n if (!match.whitespace(nodes[currPos])) {\n break;\n }\n currPos++;\n }\n };\n\n const openMark: string = (argSpec as any).openBrace || \"\";\n const closeMark: string = (argSpec as any).closeBrace || \"\";\n\n // Only mandatory arguments can be wrapped in {...}.\n // Since we already parse such things as groups, we need to\n // check the open and closing symbols to see if we allow for\n // groups to be accepted as arguments\n const acceptGroup =\n (argSpec.type === \"mandatory\" || argSpec.type === \"optional\") &&\n openMark === \"{\" &&\n closeMark === \"}\";\n\n // Do the actual matching\n gobbleWhitespace();\n const currNode = nodes[currPos];\n if (\n currNode == null ||\n match.comment(currNode) ||\n match.parbreak(currNode)\n ) {\n const ret: { argument: null; nodesRemoved: number } = {\n argument,\n nodesRemoved: 0,\n };\n return ret;\n }\n\n switch (argSpec.type) {\n case \"mandatory\":\n if (acceptGroup) {\n // We have already gobbled whitespace, so at this point, `currNode`\n // is either an openMark or we don't have an optional argument.\n let content: Ast.Node[] = [currNode];\n if (match.group(currNode)) {\n // Unwrap a group if there is one.\n content = currNode.content;\n }\n argument = arg(content, {\n openMark,\n closeMark,\n });\n currPos++;\n break;\n } else {\n const bracePos = findBracePositions(\n nodes,\n currPos,\n openMark,\n closeMark\n );\n if (bracePos) {\n argument = arg(nodes.slice(bracePos[0] + 1, bracePos[1]), {\n openMark,\n closeMark,\n });\n currPos = bracePos[1] + 1;\n break;\n }\n }\n // NOTE: Fallthrough is on purpose.\n // Matching a mandatory argument and an optional argument is the same for our purposes\n // because we're not going to fail to parse because of a missing argument.\n case \"optional\":\n // It is possible that an optional argument accepts a group if its open/close braces are `{}`\n if (acceptGroup && match.group(currNode)) {\n argument = arg(currNode.content, {\n openMark,\n closeMark,\n });\n currPos++;\n break;\n }\n // If we're here, we have custom braces to match\n const bracePos = findBracePositions(\n nodes,\n currPos,\n openMark,\n closeMark\n );\n if (bracePos) {\n argument = arg(nodes.slice(bracePos[0] + 1, bracePos[1]), {\n openMark,\n closeMark,\n });\n currPos = bracePos[1] + 1;\n break;\n }\n break;\n case \"optionalStar\":\n case \"optionalToken\": {\n const bracePos = findBracePositions(\n nodes,\n currPos,\n argSpec.type === \"optionalStar\" ? \"*\" : argSpec.token\n );\n if (bracePos) {\n argument = arg(currNode, { openMark: \"\", closeMark: \"\" });\n // Instead of `closeMarkPos` returned from findBracePositions,\n // one should use `openMarkPos + ` because there's no argument\n currPos = bracePos[0] + 1;\n }\n break;\n }\n case \"until\": {\n if (argSpec.stopTokens.length > 1) {\n console.warn(\n `\"until\" matches with multi-token stop conditions are not yet implemented`\n );\n break;\n }\n const rawToken = argSpec.stopTokens[0];\n const stopToken: string | Ast.Whitespace =\n rawToken === \" \" ? { type: \"whitespace\" } : rawToken;\n\n let bracePos = findBracePositions(\n nodes,\n startPos,\n undefined,\n stopToken\n );\n // If the corresponding token is not found, eat nothing;\n if (!bracePos) {\n break;\n }\n\n argument = arg(nodes.slice(startPos, bracePos[1]), {\n openMark: \"\",\n closeMark: rawToken,\n });\n currPos = bracePos[1];\n if (currPos < nodes.length) {\n currPos++;\n }\n break;\n }\n case \"embellishment\": {\n for (const token of argSpec.embellishmentTokens) {\n const bracePos = findBracePositions(nodes, currPos, token);\n if (!bracePos) {\n continue;\n }\n let argNode = nodes[bracePos[0] + 1];\n argument = arg(\n match.group(argNode) ? argNode.content : argNode,\n {\n openMark: token,\n closeMark: \"\",\n }\n );\n currPos = bracePos[1] + 1;\n break;\n }\n break;\n }\n default:\n console.warn(\n `Don't know how to find an argument of argspec type \"${argSpec.type}\"`\n );\n }\n\n // `currPos` is has already stepped past any whitespace. However,\n // if we did not consume an argument, we don't want to consume the whitespace.\n const nodesRemoved = argument ? currPos - startPos : 0;\n nodes.splice(startPos, nodesRemoved);\n return { argument, nodesRemoved };\n}\n\nfunction cloneStringNode(node: Ast.String, content: string): Ast.String {\n return Object.assign({}, node, { content });\n}\n\n/**\n * Find the position of the open brace and the closing brace.\n * Returns undefined if the brace isn't found.\n * This may mutate `nodes`, if braces are not a kind of characters that are\n * always parsed as a separate token\n */\nfunction findBracePositions(\n nodes: Ast.Node[],\n startPos: number,\n openMark?: string,\n closeMark?: string | Ast.Node\n): [number, number] | undefined {\n const currNode = nodes[startPos];\n let openMarkPos = startPos;\n let closeMarkPos: number | null = startPos;\n if (openMark) {\n if (!match.anyString(currNode)) {\n return;\n }\n const nodeContent = currNode.content;\n // The first node we encounter must contain the opening brace.\n if (!nodeContent.startsWith(openMark)) {\n return;\n }\n openMarkPos = startPos;\n if (currNode.content.length > openMark.length) {\n const nodeContent = currNode.content;\n currNode.content = openMark;\n nodes.splice(\n openMarkPos + 1,\n 0,\n cloneStringNode(currNode, nodeContent.slice(openMark.length))\n );\n }\n closeMarkPos = openMarkPos + 1;\n }\n if (!closeMark) {\n // In such a case, the token immediately preceding the opening brace\n // will be treated as an argument. If the next token is a string node,\n // only its first character is picked up.\n const argNode = nodes[closeMarkPos];\n if (!argNode) {\n return;\n }\n if (match.anyString(argNode) && argNode.content.length > 1) {\n const argContent = argNode.content;\n argNode.content = argContent[0];\n nodes.splice(\n closeMarkPos + 1,\n 0,\n cloneStringNode(argNode, argContent.slice(1))\n );\n }\n return [openMarkPos, closeMarkPos];\n }\n // scan for closing marks\n closeMarkPos = scan(nodes, closeMark, {\n startIndex: closeMarkPos,\n allowSubstringMatches: true,\n });\n if (closeMarkPos === null) {\n return;\n }\n const closingNode = nodes[closeMarkPos];\n if (match.anyString(closingNode) && typeof closeMark === \"string\") {\n const closingNodeContent = closingNode.content;\n let closeMarkIndex = closingNodeContent.indexOf(closeMark);\n if (closingNodeContent.length > closeMark.length) {\n closingNode.content = closeMark;\n const prev = closingNodeContent.slice(0, closeMarkIndex);\n const next = closingNodeContent.slice(\n closeMarkIndex + closeMark.length\n );\n if (prev) {\n nodes.splice(\n closeMarkPos,\n 0,\n cloneStringNode(closingNode, prev)\n );\n closeMarkPos++;\n }\n if (next) {\n nodes.splice(\n closeMarkPos + 1,\n 0,\n cloneStringNode(closingNode, next)\n );\n }\n }\n }\n return [openMarkPos, closeMarkPos];\n}\n","import { arg } from \"@unified-latex/unified-latex-builder\";\nimport * as Ast from \"@unified-latex/unified-latex-types\";\nimport { ArgumentParser } from \"@unified-latex/unified-latex-types\";\nimport {\n ArgSpecAst as ArgSpec,\n parse as parseArgspec,\n} from \"@unified-latex/unified-latex-util-argspec\";\nimport { gobbleSingleArgument } from \"./gobble-single-argument\";\nimport { updateRenderInfo } from \"@unified-latex/unified-latex-util-render-info\";\n\n/**\n * Gobbles an argument of whose type is specified\n * by `argSpec` starting at the position `startPos`. If an argument couldn't be found,\n * `argument` will be `null`.\n */\nexport function gobbleArguments(\n nodes: Ast.Node[],\n argSpec: string | ArgSpec.Node[] | ArgumentParser,\n startPos = 0\n): {\n args: Ast.Argument[];\n nodesRemoved: number;\n} {\n if (typeof argSpec === \"function\") {\n return argSpec(nodes, startPos);\n }\n\n if (typeof argSpec === \"string\") {\n argSpec = parseArgspec(argSpec);\n }\n\n const args: Ast.Argument[] = [];\n let nodesRemoved = 0;\n\n for (const spec of argSpec) {\n if (spec.type === \"embellishment\") {\n // We need special behavior for embellishment argspecs.\n // Because an embellishment argspec specifies more than one argument,\n // we need to keep gobbling arguments until we've got them all.\n const remainingTokens = new Set(spec.embellishmentTokens);\n const argForToken = Object.fromEntries(\n spec.embellishmentTokens.map((t, i) => {\n // For empty arguments, we also store their default.\n const defaultArg =\n \"defaultArg\" in spec ? spec.defaultArg?.[i] : undefined;\n return [t, emptyArg(defaultArg)];\n })\n );\n\n let { argument, nodesRemoved: removed } = gobbleSingleArgument(\n nodes,\n embellishmentSpec(remainingTokens),\n startPos\n );\n while (argument) {\n const token = argument.openMark;\n remainingTokens.delete(token);\n argForToken[token] = argument;\n nodesRemoved += removed;\n const newSpec = embellishmentSpec(remainingTokens);\n ({ argument, nodesRemoved: removed } = gobbleSingleArgument(\n nodes,\n newSpec,\n startPos\n ));\n }\n\n args.push(...spec.embellishmentTokens.map((t) => argForToken[t]));\n } else {\n const { argument, nodesRemoved: removed } = gobbleSingleArgument(\n nodes,\n spec,\n startPos\n );\n // For empty arguments, we also store their default.\n const defaultArg =\n \"defaultArg\" in spec ? spec.defaultArg : undefined;\n args.push(argument || emptyArg(defaultArg));\n nodesRemoved += removed;\n }\n }\n\n return { args, nodesRemoved };\n}\n\n/**\n * Create an embellishment argspec from a set of tokens.\n */\nfunction embellishmentSpec(tokens: Set): ArgSpec.Embellishment {\n return {\n type: \"embellishment\",\n embellishmentTokens: [...tokens],\n };\n}\n\n/**\n * Create an empty argument.\n */\nfunction emptyArg(defaultArg?: string): Ast.Argument {\n const ret = arg([], { openMark: \"\", closeMark: \"\" });\n if (defaultArg != null) {\n updateRenderInfo(ret, { defaultArg });\n }\n return ret;\n}\n","import * as Ast from \"@unified-latex/unified-latex-types\";\nimport { match } from \"@unified-latex/unified-latex-util-match\";\nimport { MacroInfoRecord } from \"@unified-latex/unified-latex-types\";\nimport { updateRenderInfo } from \"@unified-latex/unified-latex-util-render-info\";\nimport { gobbleArguments } from \"./gobble-arguments\";\nimport { visit } from \"@unified-latex/unified-latex-util-visit\";\n\n/**\n * Search (in a right-associative way) through the array for instances of\n * `macros` and attach arguments to the macro. Argument signatures are\n * specified by `macros[].signature`.\n *\n * Info stored in `macros[].renderInfo` will be attached to the node\n * with attribute `_renderInfo`.\n */\nexport function attachMacroArgsInArray(\n nodes: Ast.Node[],\n macros: MacroInfoRecord\n): void {\n // Some preliminaries that are only used if `ast` is an array.\n let currIndex: number;\n\n /**\n * Determine whether `node` matches one of the macros in `macros`.\n * Care is taken when matching because not all macros have\n * `\\` as their escape token.\n */\n const isRelevantMacro = match.createMacroMatcher(macros);\n\n function gobbleUntilMacro() {\n // Step backwards until we find the required macro\n while (currIndex >= 0 && !isRelevantMacro(nodes[currIndex])) {\n currIndex--;\n }\n }\n\n // Search for an occurrence of any of the macros `macroName` and its arguments.\n // Some macros are right-associative, so we should start searching from\n // the right\n currIndex = nodes.length - 1;\n while (currIndex >= 0) {\n gobbleUntilMacro();\n if (currIndex < 0) {\n // We didn't find an occurrence of the macro\n return;\n }\n\n // Store the currIndex, which is where the macro is. Start searching\n // for its arguments at the next index.\n const macroIndex = currIndex;\n const macro = nodes[macroIndex] as Ast.Macro;\n const macroName = macro.content;\n const macroInfo = macros[macroName];\n\n // Add `._renderInfo` if we have any\n updateRenderInfo(macro, macroInfo.renderInfo);\n\n const signatureOrParser =\n macroInfo.argumentParser || macroInfo.signature;\n\n // If the macro has no signature, it shouldn't consume any arguments. Just move along.\n // Note: It is important that this happens *after* `updateRenderInfo` is called, since\n // we still want to update the render info even if there are no args.\n if (signatureOrParser == null) {\n currIndex--;\n continue;\n }\n\n // We don't want to search for macro arguments if we already\n // found them. If the macro has arguments, we assume that\n // they've already been attached\n if (macro.args != null) {\n currIndex = macroIndex - 1;\n continue;\n }\n\n // `currIndex` is the position of the macro. We want to start\n // looking for the arguments right after the macro\n currIndex++;\n const { args } = gobbleArguments(nodes, signatureOrParser, currIndex);\n macro.args = args;\n // After we've gobbled the arguments, set\n // ourselves one space before the macro so we can continue.\n currIndex = macroIndex - 1;\n }\n}\n\n/**\n * Recursively search for and attach the arguments for a\n * particular macro to its AST node. `macros` should\n * contain a `signature` property which specifies the arguments\n * signature in xparse syntax.\n */\nexport function attachMacroArgs(tree: Ast.Ast, macros: MacroInfoRecord) {\n visit(\n tree,\n (nodes) => {\n attachMacroArgsInArray(nodes, macros);\n },\n { includeArrays: true, test: Array.isArray }\n );\n}\n","import { Plugin } from \"unified\";\nimport * as Ast from \"@unified-latex/unified-latex-types\";\nimport { MacroInfoRecord } from \"@unified-latex/unified-latex-types\";\nimport { visit } from \"@unified-latex/unified-latex-util-visit\";\nimport { attachMacroArgsInArray } from \"./attach-arguments\";\n\ntype PluginOptions = { macros: MacroInfoRecord } | undefined;\n\n/**\n * Unified plugin to attach macro arguments to the macros specified via the `macros`\n * option.\n *\n * @param macros An object whose keys are macro names and values contains information about the macro and its argument signature.\n */\nexport const unifiedLatexAttachMacroArguments: Plugin<\n PluginOptions[],\n Ast.Root,\n Ast.Root\n> = function unifiedLatexAttachMacroArguments(options) {\n return (tree) => {\n const { macros = {} } = options || {};\n if (Object.keys(macros).length === 0) {\n console.warn(\n \"Attempting to attach macro arguments but no macros are specified.\"\n );\n }\n visit(\n tree,\n (nodes) => {\n attachMacroArgsInArray(nodes, macros);\n },\n { includeArrays: true, test: Array.isArray }\n );\n };\n};\n","import * as Ast from \"@unified-latex/unified-latex-types\";\n\n/**\n * Returns the content of `args` for a macro or environment as an array. If an argument\n * was omitted (e.g., because it was an optional arg that wasn't included), then `null` is returned.\n */\nexport function getArgsContent(\n node: Ast.Macro | Ast.Environment\n): (Ast.Node[] | null)[] {\n if (!Array.isArray(node.args)) {\n return [];\n }\n\n return node.args.map((arg) => {\n if (arg.openMark === \"\" && arg.content.length === 0) {\n return null;\n }\n return arg.content;\n });\n}\n\n/**\n * Returns the content of `args` for a macro or environment as an object whose keys are the \"names\"\n * of each argument. These names of the arguments must be specified in the `_renderInfo` prop. If `_renderInfo`\n * does not contain a `namedArguments` array, then an empty object will be returned.\n *\n * @namedArgumentsFallback - If `_renderInfo.namedArguments` is not provided, `namedArgumentsFallback` is ued.\n */\nexport function getNamedArgsContent(\n node: Ast.Macro | Ast.Environment,\n namedArgumentsFallback: readonly (string | null)[] = []\n): Record {\n const names = node._renderInfo?.namedArguments || namedArgumentsFallback;\n\n if (\n !Array.isArray(node.args) ||\n !Array.isArray(names) ||\n names.length === 0\n ) {\n return {};\n }\n const ret: Record = {};\n\n node.args.forEach((arg, i) => {\n const name = names[i];\n if (name == null) {\n // If a null name was given, it shouldn't be listed as a named argument.\n return;\n }\n let val: Ast.Node[] | null = arg.content;\n if (arg.openMark === \"\" && arg.content.length === 0) {\n val = null;\n }\n ret[name] = val;\n });\n\n return ret;\n}\n"],"names":["match","arg","bracePos","nodeContent","scan","parseArgspec","updateRenderInfo","visit","unifiedLatexAttachMacroArguments"],"mappings":"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"} \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-util-arguments/index.d.ts b/node_modules/@unified-latex/unified-latex-util-arguments/index.d.ts new file mode 100644 index 0000000..c04f680 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-util-arguments/index.d.ts @@ -0,0 +1,72 @@ +import { ArgSpecAst } from '@unified-latex/unified-latex-util-argspec'; +import { ArgumentParser } from '@unified-latex/unified-latex-types'; +import * as Ast from '@unified-latex/unified-latex-types'; +import { MacroInfoRecord } from '@unified-latex/unified-latex-types'; +import { Plugin as Plugin_2 } from 'unified'; + +/** + * Recursively search for and attach the arguments for a + * particular macro to its AST node. `macros` should + * contain a `signature` property which specifies the arguments + * signature in xparse syntax. + */ +export declare function attachMacroArgs(tree: Ast.Ast, macros: MacroInfoRecord): void; + +/** + * Search (in a right-associative way) through the array for instances of + * `macros` and attach arguments to the macro. Argument signatures are + * specified by `macros[].signature`. + * + * Info stored in `macros[].renderInfo` will be attached to the node + * with attribute `_renderInfo`. + */ +export declare function attachMacroArgsInArray(nodes: Ast.Node[], macros: MacroInfoRecord): void; + +/** + * Returns the content of `args` for a macro or environment as an array. If an argument + * was omitted (e.g., because it was an optional arg that wasn't included), then `null` is returned. + */ +export declare function getArgsContent(node: Ast.Macro | Ast.Environment): (Ast.Node[] | null)[]; + +/** + * Returns the content of `args` for a macro or environment as an object whose keys are the "names" + * of each argument. These names of the arguments must be specified in the `_renderInfo` prop. If `_renderInfo` + * does not contain a `namedArguments` array, then an empty object will be returned. + * + * @namedArgumentsFallback - If `_renderInfo.namedArguments` is not provided, `namedArgumentsFallback` is ued. + */ +export declare function getNamedArgsContent(node: Ast.Macro | Ast.Environment, namedArgumentsFallback?: readonly (string | null)[]): Record; + +/** + * Gobbles an argument of whose type is specified + * by `argSpec` starting at the position `startPos`. If an argument couldn't be found, + * `argument` will be `null`. + */ +export declare function gobbleArguments(nodes: Ast.Node[], argSpec: string | ArgSpecAst.Node[] | ArgumentParser, startPos?: number): { + args: Ast.Argument[]; + nodesRemoved: number; +}; + +/** + * Gobbles an argument of whose type is specified + * by `argSpec` starting at the position `startPos`. + * If an argument couldn't be found, `argument` will be `null`. + */ +export declare function gobbleSingleArgument(nodes: Ast.Node[], argSpec: ArgSpecAst.Node, startPos?: number): { + argument: Ast.Argument | null; + nodesRemoved: number; +}; + +declare type PluginOptions = { + macros: MacroInfoRecord; +} | undefined; + +/** + * Unified plugin to attach macro arguments to the macros specified via the `macros` + * option. + * + * @param macros An object whose keys are macro names and values contains information about the macro and its argument signature. + */ +export declare const unifiedLatexAttachMacroArguments: Plugin_2; + +export { } diff --git a/node_modules/@unified-latex/unified-latex-util-arguments/index.js b/node_modules/@unified-latex/unified-latex-util-arguments/index.js new file mode 100644 index 0000000..5aa1213 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-util-arguments/index.js @@ -0,0 +1,405 @@ +import { arg } from "@unified-latex/unified-latex-builder"; +import { parse } from "@unified-latex/unified-latex-util-argspec"; +import { match } from "@unified-latex/unified-latex-util-match"; +import { scan } from "@unified-latex/unified-latex-util-scan"; +import { updateRenderInfo } from "@unified-latex/unified-latex-util-render-info"; +import { visit } from "@unified-latex/unified-latex-util-visit"; +function gobbleSingleArgument(nodes, argSpec, startPos = 0) { + if (typeof argSpec === "string" || !argSpec.type) { + throw new Error( + `argSpec must be an already-parsed argument specification, not "${JSON.stringify( + argSpec + )}"` + ); + } + let argument = null; + let currPos = startPos; + const gobbleWhitespace = argSpec.noLeadingWhitespace ? () => { + } : () => { + while (currPos < nodes.length) { + if (!match.whitespace(nodes[currPos])) { + break; + } + currPos++; + } + }; + const openMark = argSpec.openBrace || ""; + const closeMark = argSpec.closeBrace || ""; + const acceptGroup = (argSpec.type === "mandatory" || argSpec.type === "optional") && openMark === "{" && closeMark === "}"; + gobbleWhitespace(); + const currNode = nodes[currPos]; + if (currNode == null || match.comment(currNode) || match.parbreak(currNode)) { + const ret = { + argument, + nodesRemoved: 0 + }; + return ret; + } + switch (argSpec.type) { + case "mandatory": + if (acceptGroup) { + let content = [currNode]; + if (match.group(currNode)) { + content = currNode.content; + } + argument = arg(content, { + openMark, + closeMark + }); + currPos++; + break; + } else { + const bracePos2 = findBracePositions( + nodes, + currPos, + openMark, + closeMark + ); + if (bracePos2) { + argument = arg(nodes.slice(bracePos2[0] + 1, bracePos2[1]), { + openMark, + closeMark + }); + currPos = bracePos2[1] + 1; + break; + } + } + // NOTE: Fallthrough is on purpose. + // Matching a mandatory argument and an optional argument is the same for our purposes + // because we're not going to fail to parse because of a missing argument. + case "optional": + if (acceptGroup && match.group(currNode)) { + argument = arg(currNode.content, { + openMark, + closeMark + }); + currPos++; + break; + } + const bracePos = findBracePositions( + nodes, + currPos, + openMark, + closeMark + ); + if (bracePos) { + argument = arg(nodes.slice(bracePos[0] + 1, bracePos[1]), { + openMark, + closeMark + }); + currPos = bracePos[1] + 1; + break; + } + break; + case "optionalStar": + case "optionalToken": { + const bracePos2 = findBracePositions( + nodes, + currPos, + argSpec.type === "optionalStar" ? "*" : argSpec.token + ); + if (bracePos2) { + argument = arg(currNode, { openMark: "", closeMark: "" }); + currPos = bracePos2[0] + 1; + } + break; + } + case "until": { + if (argSpec.stopTokens.length > 1) { + console.warn( + `"until" matches with multi-token stop conditions are not yet implemented` + ); + break; + } + const rawToken = argSpec.stopTokens[0]; + const stopToken = rawToken === " " ? { type: "whitespace" } : rawToken; + let bracePos2 = findBracePositions( + nodes, + startPos, + void 0, + stopToken + ); + if (!bracePos2) { + break; + } + argument = arg(nodes.slice(startPos, bracePos2[1]), { + openMark: "", + closeMark: rawToken + }); + currPos = bracePos2[1]; + if (currPos < nodes.length) { + currPos++; + } + break; + } + case "embellishment": { + for (const token of argSpec.embellishmentTokens) { + const bracePos2 = findBracePositions(nodes, currPos, token); + if (!bracePos2) { + continue; + } + let argNode = nodes[bracePos2[0] + 1]; + argument = arg( + match.group(argNode) ? argNode.content : argNode, + { + openMark: token, + closeMark: "" + } + ); + currPos = bracePos2[1] + 1; + break; + } + break; + } + default: + console.warn( + `Don't know how to find an argument of argspec type "${argSpec.type}"` + ); + } + const nodesRemoved = argument ? currPos - startPos : 0; + nodes.splice(startPos, nodesRemoved); + return { argument, nodesRemoved }; +} +function cloneStringNode(node, content) { + return Object.assign({}, node, { content }); +} +function findBracePositions(nodes, startPos, openMark, closeMark) { + const currNode = nodes[startPos]; + let openMarkPos = startPos; + let closeMarkPos = startPos; + if (openMark) { + if (!match.anyString(currNode)) { + return; + } + const nodeContent = currNode.content; + if (!nodeContent.startsWith(openMark)) { + return; + } + openMarkPos = startPos; + if (currNode.content.length > openMark.length) { + const nodeContent2 = currNode.content; + currNode.content = openMark; + nodes.splice( + openMarkPos + 1, + 0, + cloneStringNode(currNode, nodeContent2.slice(openMark.length)) + ); + } + closeMarkPos = openMarkPos + 1; + } + if (!closeMark) { + const argNode = nodes[closeMarkPos]; + if (!argNode) { + return; + } + if (match.anyString(argNode) && argNode.content.length > 1) { + const argContent = argNode.content; + argNode.content = argContent[0]; + nodes.splice( + closeMarkPos + 1, + 0, + cloneStringNode(argNode, argContent.slice(1)) + ); + } + return [openMarkPos, closeMarkPos]; + } + closeMarkPos = scan(nodes, closeMark, { + startIndex: closeMarkPos, + allowSubstringMatches: true + }); + if (closeMarkPos === null) { + return; + } + const closingNode = nodes[closeMarkPos]; + if (match.anyString(closingNode) && typeof closeMark === "string") { + const closingNodeContent = closingNode.content; + let closeMarkIndex = closingNodeContent.indexOf(closeMark); + if (closingNodeContent.length > closeMark.length) { + closingNode.content = closeMark; + const prev = closingNodeContent.slice(0, closeMarkIndex); + const next = closingNodeContent.slice( + closeMarkIndex + closeMark.length + ); + if (prev) { + nodes.splice( + closeMarkPos, + 0, + cloneStringNode(closingNode, prev) + ); + closeMarkPos++; + } + if (next) { + nodes.splice( + closeMarkPos + 1, + 0, + cloneStringNode(closingNode, next) + ); + } + } + } + return [openMarkPos, closeMarkPos]; +} +function gobbleArguments(nodes, argSpec, startPos = 0) { + if (typeof argSpec === "function") { + return argSpec(nodes, startPos); + } + if (typeof argSpec === "string") { + argSpec = parse(argSpec); + } + const args = []; + let nodesRemoved = 0; + for (const spec of argSpec) { + if (spec.type === "embellishment") { + const remainingTokens = new Set(spec.embellishmentTokens); + const argForToken = Object.fromEntries( + spec.embellishmentTokens.map((t, i) => { + var _a; + const defaultArg = "defaultArg" in spec ? (_a = spec.defaultArg) == null ? void 0 : _a[i] : void 0; + return [t, emptyArg(defaultArg)]; + }) + ); + let { argument, nodesRemoved: removed } = gobbleSingleArgument( + nodes, + embellishmentSpec(remainingTokens), + startPos + ); + while (argument) { + const token = argument.openMark; + remainingTokens.delete(token); + argForToken[token] = argument; + nodesRemoved += removed; + const newSpec = embellishmentSpec(remainingTokens); + ({ argument, nodesRemoved: removed } = gobbleSingleArgument( + nodes, + newSpec, + startPos + )); + } + args.push(...spec.embellishmentTokens.map((t) => argForToken[t])); + } else { + const { argument, nodesRemoved: removed } = gobbleSingleArgument( + nodes, + spec, + startPos + ); + const defaultArg = "defaultArg" in spec ? spec.defaultArg : void 0; + args.push(argument || emptyArg(defaultArg)); + nodesRemoved += removed; + } + } + return { args, nodesRemoved }; +} +function embellishmentSpec(tokens) { + return { + type: "embellishment", + embellishmentTokens: [...tokens] + }; +} +function emptyArg(defaultArg) { + const ret = arg([], { openMark: "", closeMark: "" }); + if (defaultArg != null) { + updateRenderInfo(ret, { defaultArg }); + } + return ret; +} +function attachMacroArgsInArray(nodes, macros) { + let currIndex; + const isRelevantMacro = match.createMacroMatcher(macros); + function gobbleUntilMacro() { + while (currIndex >= 0 && !isRelevantMacro(nodes[currIndex])) { + currIndex--; + } + } + currIndex = nodes.length - 1; + while (currIndex >= 0) { + gobbleUntilMacro(); + if (currIndex < 0) { + return; + } + const macroIndex = currIndex; + const macro = nodes[macroIndex]; + const macroName = macro.content; + const macroInfo = macros[macroName]; + updateRenderInfo(macro, macroInfo.renderInfo); + const signatureOrParser = macroInfo.argumentParser || macroInfo.signature; + if (signatureOrParser == null) { + currIndex--; + continue; + } + if (macro.args != null) { + currIndex = macroIndex - 1; + continue; + } + currIndex++; + const { args } = gobbleArguments(nodes, signatureOrParser, currIndex); + macro.args = args; + currIndex = macroIndex - 1; + } +} +function attachMacroArgs(tree, macros) { + visit( + tree, + (nodes) => { + attachMacroArgsInArray(nodes, macros); + }, + { includeArrays: true, test: Array.isArray } + ); +} +const unifiedLatexAttachMacroArguments = function unifiedLatexAttachMacroArguments2(options) { + return (tree) => { + const { macros = {} } = options || {}; + if (Object.keys(macros).length === 0) { + console.warn( + "Attempting to attach macro arguments but no macros are specified." + ); + } + visit( + tree, + (nodes) => { + attachMacroArgsInArray(nodes, macros); + }, + { includeArrays: true, test: Array.isArray } + ); + }; +}; +function getArgsContent(node) { + if (!Array.isArray(node.args)) { + return []; + } + return node.args.map((arg2) => { + if (arg2.openMark === "" && arg2.content.length === 0) { + return null; + } + return arg2.content; + }); +} +function getNamedArgsContent(node, namedArgumentsFallback = []) { + var _a; + const names = ((_a = node._renderInfo) == null ? void 0 : _a.namedArguments) || namedArgumentsFallback; + if (!Array.isArray(node.args) || !Array.isArray(names) || names.length === 0) { + return {}; + } + const ret = {}; + node.args.forEach((arg2, i) => { + const name = names[i]; + if (name == null) { + return; + } + let val = arg2.content; + if (arg2.openMark === "" && arg2.content.length === 0) { + val = null; + } + ret[name] = val; + }); + return ret; +} +export { + attachMacroArgs, + attachMacroArgsInArray, + getArgsContent, + getNamedArgsContent, + gobbleArguments, + gobbleSingleArgument, + unifiedLatexAttachMacroArguments +}; +//# sourceMappingURL=index.js.map diff --git a/node_modules/@unified-latex/unified-latex-util-arguments/index.js.map b/node_modules/@unified-latex/unified-latex-util-arguments/index.js.map new file mode 100644 index 0000000..b6f7b2e --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-util-arguments/index.js.map @@ -0,0 +1 @@ +{"version":3,"file":"index.js","sources":["../libs/gobble-single-argument.ts","../libs/gobble-arguments.ts","../libs/attach-arguments.ts","../libs/unified-latex-attach-macro-arguments.ts","../libs/get-args-content.ts"],"sourcesContent":["/* eslint-disable no-fallthrough */\nimport { arg } from \"@unified-latex/unified-latex-builder\";\nimport * as Ast from \"@unified-latex/unified-latex-types\";\nimport {\n ArgSpecAst as ArgSpec,\n printRaw,\n} from \"@unified-latex/unified-latex-util-argspec\";\nimport { match } from \"@unified-latex/unified-latex-util-match\";\nimport { scan } from \"@unified-latex/unified-latex-util-scan\";\n\n/**\n * Gobbles an argument of whose type is specified\n * by `argSpec` starting at the position `startPos`.\n * If an argument couldn't be found, `argument` will be `null`.\n */\nexport function gobbleSingleArgument(\n nodes: Ast.Node[],\n argSpec: ArgSpec.Node,\n startPos = 0\n): {\n argument: Ast.Argument | null;\n nodesRemoved: number;\n} {\n if (typeof argSpec === \"string\" || !argSpec.type) {\n throw new Error(\n `argSpec must be an already-parsed argument specification, not \"${JSON.stringify(\n argSpec\n )}\"`\n );\n }\n\n let argument: Ast.Argument | null = null;\n\n let currPos = startPos;\n\n // Gobble whitespace from `currPos` onward, updating `currPos`.\n // If `argSpec` specifies leading whitespace is not allowed,\n // this function does nothing.\n const gobbleWhitespace = (argSpec as ArgSpec.LeadingWhitespace)\n .noLeadingWhitespace\n ? () => {}\n : () => {\n while (currPos < nodes.length) {\n if (!match.whitespace(nodes[currPos])) {\n break;\n }\n currPos++;\n }\n };\n\n const openMark: string = (argSpec as any).openBrace || \"\";\n const closeMark: string = (argSpec as any).closeBrace || \"\";\n\n // Only mandatory arguments can be wrapped in {...}.\n // Since we already parse such things as groups, we need to\n // check the open and closing symbols to see if we allow for\n // groups to be accepted as arguments\n const acceptGroup =\n (argSpec.type === \"mandatory\" || argSpec.type === \"optional\") &&\n openMark === \"{\" &&\n closeMark === \"}\";\n\n // Do the actual matching\n gobbleWhitespace();\n const currNode = nodes[currPos];\n if (\n currNode == null ||\n match.comment(currNode) ||\n match.parbreak(currNode)\n ) {\n const ret: { argument: null; nodesRemoved: number } = {\n argument,\n nodesRemoved: 0,\n };\n return ret;\n }\n\n switch (argSpec.type) {\n case \"mandatory\":\n if (acceptGroup) {\n // We have already gobbled whitespace, so at this point, `currNode`\n // is either an openMark or we don't have an optional argument.\n let content: Ast.Node[] = [currNode];\n if (match.group(currNode)) {\n // Unwrap a group if there is one.\n content = currNode.content;\n }\n argument = arg(content, {\n openMark,\n closeMark,\n });\n currPos++;\n break;\n } else {\n const bracePos = findBracePositions(\n nodes,\n currPos,\n openMark,\n closeMark\n );\n if (bracePos) {\n argument = arg(nodes.slice(bracePos[0] + 1, bracePos[1]), {\n openMark,\n closeMark,\n });\n currPos = bracePos[1] + 1;\n break;\n }\n }\n // NOTE: Fallthrough is on purpose.\n // Matching a mandatory argument and an optional argument is the same for our purposes\n // because we're not going to fail to parse because of a missing argument.\n case \"optional\":\n // It is possible that an optional argument accepts a group if its open/close braces are `{}`\n if (acceptGroup && match.group(currNode)) {\n argument = arg(currNode.content, {\n openMark,\n closeMark,\n });\n currPos++;\n break;\n }\n // If we're here, we have custom braces to match\n const bracePos = findBracePositions(\n nodes,\n currPos,\n openMark,\n closeMark\n );\n if (bracePos) {\n argument = arg(nodes.slice(bracePos[0] + 1, bracePos[1]), {\n openMark,\n closeMark,\n });\n currPos = bracePos[1] + 1;\n break;\n }\n break;\n case \"optionalStar\":\n case \"optionalToken\": {\n const bracePos = findBracePositions(\n nodes,\n currPos,\n argSpec.type === \"optionalStar\" ? \"*\" : argSpec.token\n );\n if (bracePos) {\n argument = arg(currNode, { openMark: \"\", closeMark: \"\" });\n // Instead of `closeMarkPos` returned from findBracePositions,\n // one should use `openMarkPos + ` because there's no argument\n currPos = bracePos[0] + 1;\n }\n break;\n }\n case \"until\": {\n if (argSpec.stopTokens.length > 1) {\n console.warn(\n `\"until\" matches with multi-token stop conditions are not yet implemented`\n );\n break;\n }\n const rawToken = argSpec.stopTokens[0];\n const stopToken: string | Ast.Whitespace =\n rawToken === \" \" ? { type: \"whitespace\" } : rawToken;\n\n let bracePos = findBracePositions(\n nodes,\n startPos,\n undefined,\n stopToken\n );\n // If the corresponding token is not found, eat nothing;\n if (!bracePos) {\n break;\n }\n\n argument = arg(nodes.slice(startPos, bracePos[1]), {\n openMark: \"\",\n closeMark: rawToken,\n });\n currPos = bracePos[1];\n if (currPos < nodes.length) {\n currPos++;\n }\n break;\n }\n case \"embellishment\": {\n for (const token of argSpec.embellishmentTokens) {\n const bracePos = findBracePositions(nodes, currPos, token);\n if (!bracePos) {\n continue;\n }\n let argNode = nodes[bracePos[0] + 1];\n argument = arg(\n match.group(argNode) ? argNode.content : argNode,\n {\n openMark: token,\n closeMark: \"\",\n }\n );\n currPos = bracePos[1] + 1;\n break;\n }\n break;\n }\n default:\n console.warn(\n `Don't know how to find an argument of argspec type \"${argSpec.type}\"`\n );\n }\n\n // `currPos` is has already stepped past any whitespace. However,\n // if we did not consume an argument, we don't want to consume the whitespace.\n const nodesRemoved = argument ? currPos - startPos : 0;\n nodes.splice(startPos, nodesRemoved);\n return { argument, nodesRemoved };\n}\n\nfunction cloneStringNode(node: Ast.String, content: string): Ast.String {\n return Object.assign({}, node, { content });\n}\n\n/**\n * Find the position of the open brace and the closing brace.\n * Returns undefined if the brace isn't found.\n * This may mutate `nodes`, if braces are not a kind of characters that are\n * always parsed as a separate token\n */\nfunction findBracePositions(\n nodes: Ast.Node[],\n startPos: number,\n openMark?: string,\n closeMark?: string | Ast.Node\n): [number, number] | undefined {\n const currNode = nodes[startPos];\n let openMarkPos = startPos;\n let closeMarkPos: number | null = startPos;\n if (openMark) {\n if (!match.anyString(currNode)) {\n return;\n }\n const nodeContent = currNode.content;\n // The first node we encounter must contain the opening brace.\n if (!nodeContent.startsWith(openMark)) {\n return;\n }\n openMarkPos = startPos;\n if (currNode.content.length > openMark.length) {\n const nodeContent = currNode.content;\n currNode.content = openMark;\n nodes.splice(\n openMarkPos + 1,\n 0,\n cloneStringNode(currNode, nodeContent.slice(openMark.length))\n );\n }\n closeMarkPos = openMarkPos + 1;\n }\n if (!closeMark) {\n // In such a case, the token immediately preceding the opening brace\n // will be treated as an argument. If the next token is a string node,\n // only its first character is picked up.\n const argNode = nodes[closeMarkPos];\n if (!argNode) {\n return;\n }\n if (match.anyString(argNode) && argNode.content.length > 1) {\n const argContent = argNode.content;\n argNode.content = argContent[0];\n nodes.splice(\n closeMarkPos + 1,\n 0,\n cloneStringNode(argNode, argContent.slice(1))\n );\n }\n return [openMarkPos, closeMarkPos];\n }\n // scan for closing marks\n closeMarkPos = scan(nodes, closeMark, {\n startIndex: closeMarkPos,\n allowSubstringMatches: true,\n });\n if (closeMarkPos === null) {\n return;\n }\n const closingNode = nodes[closeMarkPos];\n if (match.anyString(closingNode) && typeof closeMark === \"string\") {\n const closingNodeContent = closingNode.content;\n let closeMarkIndex = closingNodeContent.indexOf(closeMark);\n if (closingNodeContent.length > closeMark.length) {\n closingNode.content = closeMark;\n const prev = closingNodeContent.slice(0, closeMarkIndex);\n const next = closingNodeContent.slice(\n closeMarkIndex + closeMark.length\n );\n if (prev) {\n nodes.splice(\n closeMarkPos,\n 0,\n cloneStringNode(closingNode, prev)\n );\n closeMarkPos++;\n }\n if (next) {\n nodes.splice(\n closeMarkPos + 1,\n 0,\n cloneStringNode(closingNode, next)\n );\n }\n }\n }\n return [openMarkPos, closeMarkPos];\n}\n","import { arg } from \"@unified-latex/unified-latex-builder\";\nimport * as Ast from \"@unified-latex/unified-latex-types\";\nimport { ArgumentParser } from \"@unified-latex/unified-latex-types\";\nimport {\n ArgSpecAst as ArgSpec,\n parse as parseArgspec,\n} from \"@unified-latex/unified-latex-util-argspec\";\nimport { gobbleSingleArgument } from \"./gobble-single-argument\";\nimport { updateRenderInfo } from \"@unified-latex/unified-latex-util-render-info\";\n\n/**\n * Gobbles an argument of whose type is specified\n * by `argSpec` starting at the position `startPos`. If an argument couldn't be found,\n * `argument` will be `null`.\n */\nexport function gobbleArguments(\n nodes: Ast.Node[],\n argSpec: string | ArgSpec.Node[] | ArgumentParser,\n startPos = 0\n): {\n args: Ast.Argument[];\n nodesRemoved: number;\n} {\n if (typeof argSpec === \"function\") {\n return argSpec(nodes, startPos);\n }\n\n if (typeof argSpec === \"string\") {\n argSpec = parseArgspec(argSpec);\n }\n\n const args: Ast.Argument[] = [];\n let nodesRemoved = 0;\n\n for (const spec of argSpec) {\n if (spec.type === \"embellishment\") {\n // We need special behavior for embellishment argspecs.\n // Because an embellishment argspec specifies more than one argument,\n // we need to keep gobbling arguments until we've got them all.\n const remainingTokens = new Set(spec.embellishmentTokens);\n const argForToken = Object.fromEntries(\n spec.embellishmentTokens.map((t, i) => {\n // For empty arguments, we also store their default.\n const defaultArg =\n \"defaultArg\" in spec ? spec.defaultArg?.[i] : undefined;\n return [t, emptyArg(defaultArg)];\n })\n );\n\n let { argument, nodesRemoved: removed } = gobbleSingleArgument(\n nodes,\n embellishmentSpec(remainingTokens),\n startPos\n );\n while (argument) {\n const token = argument.openMark;\n remainingTokens.delete(token);\n argForToken[token] = argument;\n nodesRemoved += removed;\n const newSpec = embellishmentSpec(remainingTokens);\n ({ argument, nodesRemoved: removed } = gobbleSingleArgument(\n nodes,\n newSpec,\n startPos\n ));\n }\n\n args.push(...spec.embellishmentTokens.map((t) => argForToken[t]));\n } else {\n const { argument, nodesRemoved: removed } = gobbleSingleArgument(\n nodes,\n spec,\n startPos\n );\n // For empty arguments, we also store their default.\n const defaultArg =\n \"defaultArg\" in spec ? spec.defaultArg : undefined;\n args.push(argument || emptyArg(defaultArg));\n nodesRemoved += removed;\n }\n }\n\n return { args, nodesRemoved };\n}\n\n/**\n * Create an embellishment argspec from a set of tokens.\n */\nfunction embellishmentSpec(tokens: Set): ArgSpec.Embellishment {\n return {\n type: \"embellishment\",\n embellishmentTokens: [...tokens],\n };\n}\n\n/**\n * Create an empty argument.\n */\nfunction emptyArg(defaultArg?: string): Ast.Argument {\n const ret = arg([], { openMark: \"\", closeMark: \"\" });\n if (defaultArg != null) {\n updateRenderInfo(ret, { defaultArg });\n }\n return ret;\n}\n","import * as Ast from \"@unified-latex/unified-latex-types\";\nimport { match } from \"@unified-latex/unified-latex-util-match\";\nimport { MacroInfoRecord } from \"@unified-latex/unified-latex-types\";\nimport { updateRenderInfo } from \"@unified-latex/unified-latex-util-render-info\";\nimport { gobbleArguments } from \"./gobble-arguments\";\nimport { visit } from \"@unified-latex/unified-latex-util-visit\";\n\n/**\n * Search (in a right-associative way) through the array for instances of\n * `macros` and attach arguments to the macro. Argument signatures are\n * specified by `macros[].signature`.\n *\n * Info stored in `macros[].renderInfo` will be attached to the node\n * with attribute `_renderInfo`.\n */\nexport function attachMacroArgsInArray(\n nodes: Ast.Node[],\n macros: MacroInfoRecord\n): void {\n // Some preliminaries that are only used if `ast` is an array.\n let currIndex: number;\n\n /**\n * Determine whether `node` matches one of the macros in `macros`.\n * Care is taken when matching because not all macros have\n * `\\` as their escape token.\n */\n const isRelevantMacro = match.createMacroMatcher(macros);\n\n function gobbleUntilMacro() {\n // Step backwards until we find the required macro\n while (currIndex >= 0 && !isRelevantMacro(nodes[currIndex])) {\n currIndex--;\n }\n }\n\n // Search for an occurrence of any of the macros `macroName` and its arguments.\n // Some macros are right-associative, so we should start searching from\n // the right\n currIndex = nodes.length - 1;\n while (currIndex >= 0) {\n gobbleUntilMacro();\n if (currIndex < 0) {\n // We didn't find an occurrence of the macro\n return;\n }\n\n // Store the currIndex, which is where the macro is. Start searching\n // for its arguments at the next index.\n const macroIndex = currIndex;\n const macro = nodes[macroIndex] as Ast.Macro;\n const macroName = macro.content;\n const macroInfo = macros[macroName];\n\n // Add `._renderInfo` if we have any\n updateRenderInfo(macro, macroInfo.renderInfo);\n\n const signatureOrParser =\n macroInfo.argumentParser || macroInfo.signature;\n\n // If the macro has no signature, it shouldn't consume any arguments. Just move along.\n // Note: It is important that this happens *after* `updateRenderInfo` is called, since\n // we still want to update the render info even if there are no args.\n if (signatureOrParser == null) {\n currIndex--;\n continue;\n }\n\n // We don't want to search for macro arguments if we already\n // found them. If the macro has arguments, we assume that\n // they've already been attached\n if (macro.args != null) {\n currIndex = macroIndex - 1;\n continue;\n }\n\n // `currIndex` is the position of the macro. We want to start\n // looking for the arguments right after the macro\n currIndex++;\n const { args } = gobbleArguments(nodes, signatureOrParser, currIndex);\n macro.args = args;\n // After we've gobbled the arguments, set\n // ourselves one space before the macro so we can continue.\n currIndex = macroIndex - 1;\n }\n}\n\n/**\n * Recursively search for and attach the arguments for a\n * particular macro to its AST node. `macros` should\n * contain a `signature` property which specifies the arguments\n * signature in xparse syntax.\n */\nexport function attachMacroArgs(tree: Ast.Ast, macros: MacroInfoRecord) {\n visit(\n tree,\n (nodes) => {\n attachMacroArgsInArray(nodes, macros);\n },\n { includeArrays: true, test: Array.isArray }\n );\n}\n","import { Plugin } from \"unified\";\nimport * as Ast from \"@unified-latex/unified-latex-types\";\nimport { MacroInfoRecord } from \"@unified-latex/unified-latex-types\";\nimport { visit } from \"@unified-latex/unified-latex-util-visit\";\nimport { attachMacroArgsInArray } from \"./attach-arguments\";\n\ntype PluginOptions = { macros: MacroInfoRecord } | undefined;\n\n/**\n * Unified plugin to attach macro arguments to the macros specified via the `macros`\n * option.\n *\n * @param macros An object whose keys are macro names and values contains information about the macro and its argument signature.\n */\nexport const unifiedLatexAttachMacroArguments: Plugin<\n PluginOptions[],\n Ast.Root,\n Ast.Root\n> = function unifiedLatexAttachMacroArguments(options) {\n return (tree) => {\n const { macros = {} } = options || {};\n if (Object.keys(macros).length === 0) {\n console.warn(\n \"Attempting to attach macro arguments but no macros are specified.\"\n );\n }\n visit(\n tree,\n (nodes) => {\n attachMacroArgsInArray(nodes, macros);\n },\n { includeArrays: true, test: Array.isArray }\n );\n };\n};\n","import * as Ast from \"@unified-latex/unified-latex-types\";\n\n/**\n * Returns the content of `args` for a macro or environment as an array. If an argument\n * was omitted (e.g., because it was an optional arg that wasn't included), then `null` is returned.\n */\nexport function getArgsContent(\n node: Ast.Macro | Ast.Environment\n): (Ast.Node[] | null)[] {\n if (!Array.isArray(node.args)) {\n return [];\n }\n\n return node.args.map((arg) => {\n if (arg.openMark === \"\" && arg.content.length === 0) {\n return null;\n }\n return arg.content;\n });\n}\n\n/**\n * Returns the content of `args` for a macro or environment as an object whose keys are the \"names\"\n * of each argument. These names of the arguments must be specified in the `_renderInfo` prop. If `_renderInfo`\n * does not contain a `namedArguments` array, then an empty object will be returned.\n *\n * @namedArgumentsFallback - If `_renderInfo.namedArguments` is not provided, `namedArgumentsFallback` is ued.\n */\nexport function getNamedArgsContent(\n node: Ast.Macro | Ast.Environment,\n namedArgumentsFallback: readonly (string | null)[] = []\n): Record {\n const names = node._renderInfo?.namedArguments || namedArgumentsFallback;\n\n if (\n !Array.isArray(node.args) ||\n !Array.isArray(names) ||\n names.length === 0\n ) {\n return {};\n }\n const ret: Record = {};\n\n node.args.forEach((arg, i) => {\n const name = names[i];\n if (name == null) {\n // If a null name was given, it shouldn't be listed as a named argument.\n return;\n }\n let val: Ast.Node[] | null = arg.content;\n if (arg.openMark === \"\" && arg.content.length === 0) {\n val = null;\n }\n ret[name] = val;\n });\n\n return ret;\n}\n"],"names":["bracePos","nodeContent","parseArgspec","unifiedLatexAttachMacroArguments","arg"],"mappings":"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"} \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-util-arguments/package.json b/node_modules/@unified-latex/unified-latex-util-arguments/package.json new file mode 100644 index 0000000..f00e1c8 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-util-arguments/package.json @@ -0,0 +1,58 @@ +{ + "name": "@unified-latex/unified-latex-util-arguments", + "version": "1.8.2", + "description": "Tools for manipulating unified-latex ASTs", + "main": "index.js", + "type": "module", + "dependencies": { + "@unified-latex/unified-latex-builder": "^1.8.0", + "@unified-latex/unified-latex-types": "^1.8.0", + "@unified-latex/unified-latex-util-argspec": "^1.8.2", + "@unified-latex/unified-latex-util-match": "^1.8.0", + "@unified-latex/unified-latex-util-render-info": "^1.8.2", + "@unified-latex/unified-latex-util-scan": "^1.8.0", + "@unified-latex/unified-latex-util-visit": "^1.8.2", + "unified": "^10.1.2" + }, + "repository": { + "type": "git", + "url": "git+https://github.com/siefkenj/unified-latex.git" + }, + "keywords": [ + "pegjs", + "latex", + "parser", + "prettier", + "unified-latex", + "unified" + ], + "author": "Jason Siefken", + "license": "MIT", + "bugs": { + "url": "https://github.com/siefkenj/unified-latex/issues" + }, + "homepage": "https://github.com/siefkenj/unified-latex#readme", + "exports": { + ".": { + "import": "./index.js", + "require": "./index.cjs", + "types": "./index.d.ts" + }, + "./*js": "./*js", + "./*": { + "import": "./*/index.js", + "require": "./*/index.cjs", + "types": "./*/index.d.ts" + }, + "./*/index": { + "import": "./*/index.js", + "require": "./*/index.cjs" + } + }, + "files": [ + "**/*ts", + "**/*js", + "**/*.map", + "**/*.json" + ] +} \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-util-catcode/README.md b/node_modules/@unified-latex/unified-latex-util-catcode/README.md new file mode 100644 index 0000000..5a325b3 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-util-catcode/README.md @@ -0,0 +1,162 @@ + + + + +# unified-latex-util-catcode + +## What is this? + +Functions to identify regions of a `unified-latex` Abstract Syntax Tree (AST) that need to be reparsed because of different +category codes. For example, regions between `\makeatletter` and `\makeatother`. + +## When should I use this? + +If you need to identify regions of the AST that need to be reparsed. + +## Install + +```bash +npm install @unified-latex/unified-latex-util-catcode +``` + +This package contains both esm and commonjs exports. To explicitly access the esm export, +import the `.js` file. To explicitly access the commonjs export, import the `.cjs` file. + +# Functions + +## `findExpl3AndAtLetterRegionsInArray(tree)` + +Find regions between `\ExplSyntaxOn...\ExplSyntaxOff` and `\makeatletter...\makeatother`. +Returns an object containing regions where one or both syntax's apply. + +```typescript +function findExpl3AndAtLetterRegionsInArray(tree: Ast.Node[]): { + explOnly: Region[]; + atLetterOnly: Region[]; + both: Region[]; +}; +``` + +**Parameters** + +| Param | Type | +| :---- | :----------- | +| tree | `Ast.Node[]` | + +## `findRegionInArray(tree, start, end)` + +Find all contiguous segments in the array that are between start and end blocks. +The `start` and `end` are functions that determine when a region starts and ends. + +```typescript +function findRegionInArray( + tree: Ast.Node[], + start: (node: Ast.Node) => boolean, + end: (node: Ast.Node) => boolean +): Region[]; +``` + +**Parameters** + +| Param | Type | +| :---- | :---------------------------- | +| tree | `Ast.Node[]` | +| start | `(node: Ast.Node) => boolean` | +| end | `(node: Ast.Node) => boolean` | + +## `hasReparsableMacroNames(tree, allowedTokens)` + +Checks whether `tree` has a macro that could be reparsed given the `allowedTokens` but +do not do any reparsing. This function can be used in auto-detection schemes to determine if +macro names should actually be reparsed. + +```typescript +function hasReparsableMacroNames( + tree: Ast.Ast, + allowedTokens: string | Set +): boolean; +``` + +**Parameters** + +| Param | Type | +| :------------ | :---------------------- | +| tree | `Ast.Ast` | +| allowedTokens | `string \| Set` | + +## `hasReparsableMacroNamesInArray(tree, allowedTokens)` + +Checks whether the array has a macro that could be reparsed given the `allowedTokens` but +do not do any reparsing. This function can be used in auto-detection schemes to determine if +macro names should actually be reparsed. + +```typescript +function hasReparsableMacroNamesInArray( + tree: Ast.Node[], + allowedTokens: Set +): boolean; +``` + +**Parameters** + +| Param | Type | +| :------------ | :------------ | +| tree | `Ast.Node[]` | +| allowedTokens | `Set` | + +## `reparseExpl3AndAtLetterRegions(tree)` + +Find regions between `\ExplSyntaxOn...\ExplSyntaxOff` and `\makeatletter...\makeatother` +and reparse their contents so that the relevant characters (e.g., `@`, `_`, and `:`) become +part of the macro names. + +```typescript +function reparseExpl3AndAtLetterRegions(tree: Ast.Ast): void; +``` + +**Parameters** + +| Param | Type | +| :---- | :-------- | +| tree | `Ast.Ast` | + +## `reparseMacroNames(tree, allowedTokens)` + +Reparses all macro names so that they may optionally include characters listed in `allowedTokens`. +This is used, for example, when parsing expl3 syntax which allows `_` to be used in a macro name (even though +`_` is normally stops the parsing for a macro name). Thus, a macro `\foo_bar:Nn` would be parsed as having +the name `foo_bar:Nn` rather than as `foo` followed by the strings `_`, `bar`, `:`, `Nn`. + +```typescript +function reparseMacroNames( + tree: Ast.Ast, + allowedTokens: string | Set +): void; +``` + +**Parameters** + +| Param | Type | +| :------------ | :---------------------- | +| tree | `Ast.Ast` | +| allowedTokens | `string \| Set` | + +## `reparseMacroNamesInArray(tree, allowedTokens)` + +Reparses all macro names in the array so that they may optionally include characters listed in `allowedTokens`. +This is used, for example, when parsing expl3 syntax which allows `_` to be used in a macro name (even though +`_` is normally stops the parsing for a macro name). + +```typescript +function reparseMacroNamesInArray( + tree: Ast.Node[], + allowedTokens: Set +): void; +``` + +**Parameters** + +| Param | Type | +| :------------ | :------------ | +| tree | `Ast.Node[]` | +| allowedTokens | `Set` | diff --git a/node_modules/@unified-latex/unified-latex-util-catcode/index.cjs b/node_modules/@unified-latex/unified-latex-util-catcode/index.cjs new file mode 100644 index 0000000..e79b309 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-util-catcode/index.cjs @@ -0,0 +1,295 @@ +"use strict"; +Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" }); +const unifiedLatexUtilMatch = require("@unified-latex/unified-latex-util-match"); +const unifiedLatexUtilVisit = require("@unified-latex/unified-latex-util-visit"); +function findRegionInArray(tree, start, end) { + const ret = []; + let currRegion = { start: void 0, end: tree.length }; + for (let i = 0; i < tree.length; i++) { + const node = tree[i]; + if (start(node)) { + currRegion.start = i; + } + if (end(node)) { + currRegion.end = i + 1; + ret.push(currRegion); + currRegion = { start: void 0, end: tree.length }; + } + } + if (currRegion.start != null) { + ret.push(currRegion); + } + return ret; +} +function refineRegions(regions) { + const _regions = [...regions]; + _regions.sort((a, b) => a.start - b.start); + const cutPointsSet = new Set(_regions.flatMap((r) => [r.start, r.end])); + const cutPoints = Array.from(cutPointsSet); + cutPoints.sort((a, b) => a - b); + const retRegions = []; + const retRegionsContainedIn = []; + let seekIndex = 0; + for (let i = 0; i < cutPoints.length - 1; i++) { + const start = cutPoints[i]; + const end = cutPoints[i + 1]; + const region = { start, end }; + const regionContainedIn = /* @__PURE__ */ new Set(); + let encounteredEndPastStart = false; + for (let j = seekIndex; j < _regions.length; j++) { + const superRegion = _regions[j]; + if (superRegion.end >= region.start) { + encounteredEndPastStart = true; + } + if (!encounteredEndPastStart && superRegion.end < region.start) { + seekIndex = j + 1; + continue; + } + if (superRegion.start > end) { + break; + } + if (superRegion.start <= region.start && superRegion.end >= region.end) { + encounteredEndPastStart = true; + regionContainedIn.add(superRegion); + } + } + if (regionContainedIn.size > 0) { + retRegions.push(region); + retRegionsContainedIn.push(regionContainedIn); + } + } + return { regions: retRegions, regionsContainedIn: retRegionsContainedIn }; +} +function splitByRegions(array, regionsRecord) { + const ret = []; + const indices = [0, array.length]; + const reverseMap = {}; + for (const [key, records] of Object.entries(regionsRecord)) { + indices.push( + ...records.flatMap((r) => { + reverseMap["" + [r.start, r.end]] = key; + return [r.start, r.end]; + }) + ); + } + indices.sort((a, b) => a - b); + for (let i = 0; i < indices.length - 1; i++) { + const start = indices[i]; + const end = indices[i + 1]; + if (start === end) { + continue; + } + const regionKey = reverseMap["" + [start, end]]; + ret.push([regionKey || null, array.slice(start, end)]); + } + return ret; +} +function escapeRegExp(str) { + return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"); +} +function buildWordRegex(allowedSet) { + const regexpStr = `^(${["\\p{L}"].concat(Array.from(allowedSet).map(escapeRegExp)).join("|")})*`; + return new RegExp(regexpStr, "u"); +} +function hasReparsableMacroNamesInArray(tree, allowedTokens) { + for (let i = 0; i < tree.length; i++) { + const macro = tree[i]; + const string = tree[i + 1]; + if (unifiedLatexUtilMatch.match.anyMacro(macro) && unifiedLatexUtilMatch.match.anyString(string)) { + if (allowedTokens.has( + macro.content.charAt(macro.content.length - 1) + ) || allowedTokens.has(string.content.charAt(0))) { + return true; + } + } + } + return false; +} +function hasReparsableMacroNames(tree, allowedTokens) { + if (typeof allowedTokens === "string") { + allowedTokens = new Set(allowedTokens.split("")); + } + const _allowedTokens = allowedTokens; + for (const v of _allowedTokens) { + if (v.length > 1) { + throw new Error( + `Only single characters are allowed as \`allowedTokens\` when reparsing macro names, not \`${v}\`.` + ); + } + } + let ret = false; + unifiedLatexUtilVisit.visit( + tree, + (nodes) => { + if (hasReparsableMacroNamesInArray(nodes, _allowedTokens)) { + ret = true; + return unifiedLatexUtilVisit.EXIT; + } + }, + { includeArrays: true, test: Array.isArray } + ); + return ret; +} +function reparseMacroNamesInArray(tree, allowedTokens) { + var _a, _b, _c; + const regex = buildWordRegex(allowedTokens); + let i = 0; + while (i < tree.length) { + const macro = tree[i]; + const string = tree[i + 1]; + if (unifiedLatexUtilMatch.match.anyMacro(macro) && // The _^ macros in math mode should not be extended no-matter what; + // So we check to make sure that the macro we're dealing with has the default escape token. + (macro.escapeToken == null || macro.escapeToken === "\\") && unifiedLatexUtilMatch.match.anyString(string) && // There are two options. Either the macro ends with the special character, + // e.g. `\@foo` or the special character starts the next string, e.g. `\foo@`. + (allowedTokens.has( + macro.content.charAt(macro.content.length - 1) + ) || allowedTokens.has(string.content.charAt(0)))) { + const match2 = string.content.match(regex); + const takeable = match2 ? match2[0] : ""; + if (takeable.length > 0) { + if (takeable.length === string.content.length) { + macro.content += string.content; + tree.splice(i + 1, 1); + if (macro.position && ((_a = string.position) == null ? void 0 : _a.end)) { + macro.position.end = string.position.end; + } + } else { + macro.content += takeable; + string.content = string.content.slice(takeable.length); + if ((_b = macro.position) == null ? void 0 : _b.end) { + macro.position.end.offset += takeable.length; + macro.position.end.column += takeable.length; + } + if ((_c = string.position) == null ? void 0 : _c.start) { + string.position.start.offset += takeable.length; + string.position.start.column += takeable.length; + } + } + } else { + i++; + } + } else { + ++i; + } + } +} +function reparseMacroNames(tree, allowedTokens) { + if (typeof allowedTokens === "string") { + allowedTokens = new Set(allowedTokens.split("")); + } + const _allowedTokens = allowedTokens; + for (const v of _allowedTokens) { + if (v.length > 1) { + throw new Error( + `Only single characters are allowed as \`allowedTokens\` when reparsing macro names, not \`${v}\`.` + ); + } + } + unifiedLatexUtilVisit.visit( + tree, + (nodes) => { + reparseMacroNamesInArray(nodes, _allowedTokens); + }, + { includeArrays: true, test: Array.isArray } + ); +} +const expl3Find = { + start: unifiedLatexUtilMatch.match.createMacroMatcher(["ExplSyntaxOn"]), + end: unifiedLatexUtilMatch.match.createMacroMatcher(["ExplSyntaxOff"]) +}; +const atLetterFind = { + start: unifiedLatexUtilMatch.match.createMacroMatcher(["makeatletter"]), + end: unifiedLatexUtilMatch.match.createMacroMatcher(["makeatother"]) +}; +function findExpl3AndAtLetterRegionsInArray(tree) { + const expl3 = findRegionInArray(tree, expl3Find.start, expl3Find.end); + const atLetter = findRegionInArray( + tree, + atLetterFind.start, + atLetterFind.end + ); + const regionMap = new Map([ + ...expl3.map((x) => [x, "expl"]), + ...atLetter.map((x) => [x, "atLetter"]) + ]); + const all = refineRegions([...expl3, ...atLetter]); + const ret = { + explOnly: [], + atLetterOnly: [], + both: [] + }; + for (let i = 0; i < all.regions.length; i++) { + const region = all.regions[i]; + const containedIn = all.regionsContainedIn[i]; + if (containedIn.size === 2) { + ret.both.push(region); + continue; + } + for (const v of containedIn.values()) { + if (regionMap.get(v) === "expl") { + ret.explOnly.push(region); + } + if (regionMap.get(v) === "atLetter") { + ret.atLetterOnly.push(region); + } + } + } + ret.explOnly = ret.explOnly.filter((r) => r.end - r.start > 1); + ret.atLetterOnly = ret.atLetterOnly.filter((r) => r.end - r.start > 1); + ret.both = ret.both.filter((r) => r.end - r.start > 1); + return ret; +} +const atLetterSet = /* @__PURE__ */ new Set(["@"]); +const explSet = /* @__PURE__ */ new Set(["_", ":"]); +const bothSet = /* @__PURE__ */ new Set(["_", ":", "@"]); +function reparseExpl3AndAtLetterRegions(tree) { + unifiedLatexUtilVisit.visit( + tree, + { + leave: (nodes) => { + const regions = findExpl3AndAtLetterRegionsInArray(nodes); + const totalNumRegions = regions.both.length + regions.atLetterOnly.length + regions.explOnly.length; + if (totalNumRegions === 0) { + return; + } + const splits = splitByRegions(nodes, regions); + const processed = []; + for (const [key, slice] of splits) { + switch (key) { + case null: + processed.push(...slice); + continue; + case "atLetterOnly": + reparseMacroNames(slice, atLetterSet); + processed.push(...slice); + continue; + case "explOnly": + reparseMacroNames(slice, explSet); + processed.push(...slice); + continue; + case "both": + reparseMacroNames(slice, bothSet); + processed.push(...slice); + continue; + default: + throw new Error( + `Unexpected case when splitting ${key}` + ); + } + } + nodes.length = 0; + nodes.push(...processed); + return unifiedLatexUtilVisit.SKIP; + } + }, + { includeArrays: true, test: Array.isArray } + ); +} +exports.findExpl3AndAtLetterRegionsInArray = findExpl3AndAtLetterRegionsInArray; +exports.findRegionInArray = findRegionInArray; +exports.hasReparsableMacroNames = hasReparsableMacroNames; +exports.hasReparsableMacroNamesInArray = hasReparsableMacroNamesInArray; +exports.reparseExpl3AndAtLetterRegions = reparseExpl3AndAtLetterRegions; +exports.reparseMacroNames = reparseMacroNames; +exports.reparseMacroNamesInArray = reparseMacroNamesInArray; +//# sourceMappingURL=index.cjs.map diff --git a/node_modules/@unified-latex/unified-latex-util-catcode/index.cjs.map b/node_modules/@unified-latex/unified-latex-util-catcode/index.cjs.map new file mode 100644 index 0000000..4250de2 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-util-catcode/index.cjs.map @@ -0,0 +1 @@ +{"version":3,"file":"index.cjs","sources":["../libs/find-region.ts","../libs/regions.ts","../libs/reparse-macro-names.ts","../libs/special-regions.ts"],"sourcesContent":["import * as Ast from \"@unified-latex/unified-latex-types\";\nimport { Region } from \"./regions\";\n\n/**\n * Find all contiguous segments in the array that are between start and end blocks.\n * The `start` and `end` are functions that determine when a region starts and ends.\n */\nexport function findRegionInArray(\n tree: Ast.Node[],\n start: (node: Ast.Node) => boolean,\n end: (node: Ast.Node) => boolean\n): Region[] {\n const ret: Region[] = [];\n let currRegion: Region = { start: undefined as any, end: tree.length };\n for (let i = 0; i < tree.length; i++) {\n const node = tree[i];\n if (start(node)) {\n currRegion.start = i;\n }\n if (end(node)) {\n currRegion.end = i + 1;\n ret.push(currRegion);\n currRegion = { start: undefined as any, end: tree.length };\n }\n }\n\n if (currRegion.start != null) {\n // Regions don't necessarily have to encounter an `end` to end.\n ret.push(currRegion);\n }\n return ret;\n}\n","import * as Ast from \"@unified-latex/unified-latex-types\";\n\nexport type Region = { start: number; end: number };\n\n/**\n * Given `regions`, a list of `Region`s (not necessarily ordered, possibly overlapping), return a list of in-order,\n * non-overlapping regions and a corresponding list containing a set of the original `Region`s that the new region\n * is a subset of.\n */\nexport function refineRegions(regions: Region[]): {\n regions: Region[];\n regionsContainedIn: Set[];\n} {\n const _regions = [...regions];\n _regions.sort((a, b) => a.start - b.start);\n const cutPointsSet = new Set(_regions.flatMap((r) => [r.start, r.end]));\n const cutPoints = Array.from(cutPointsSet);\n cutPoints.sort((a, b) => a - b);\n\n const retRegions: Region[] = [];\n const retRegionsContainedIn: Set[] = [];\n\n // We will be checking what regions we are completely contained in.\n // Because `_regions` is sorted by start, `seekIndex` will be incremented\n // by end, so that we don't do too much array testing.\n let seekIndex = 0;\n for (let i = 0; i < cutPoints.length - 1; i++) {\n const start = cutPoints[i];\n const end = cutPoints[i + 1];\n const region = { start, end };\n const regionContainedIn: Set = new Set();\n\n let encounteredEndPastStart = false;\n for (let j = seekIndex; j < _regions.length; j++) {\n const superRegion = _regions[j];\n if (superRegion.end >= region.start) {\n encounteredEndPastStart = true;\n }\n if (!encounteredEndPastStart && superRegion.end < region.start) {\n // In this case, the region (and all regions that came before)\n // end before the region we are testing, so we may safely skip past it\n // from here on out.\n seekIndex = j + 1;\n continue;\n }\n\n if (superRegion.start > end) {\n // Because `_regions` is sorted, we can stop here\n break;\n }\n if (\n superRegion.start <= region.start &&\n superRegion.end >= region.end\n ) {\n encounteredEndPastStart = true;\n regionContainedIn.add(superRegion);\n }\n }\n\n if (regionContainedIn.size > 0) {\n // We only count if we are contained in a subregion\n retRegions.push(region);\n retRegionsContainedIn.push(regionContainedIn);\n }\n }\n\n return { regions: retRegions, regionsContainedIn: retRegionsContainedIn };\n}\n\n/**\n * Split an array up into the disjoint regions specified by `regionRecord`.\n * Returned is a list of tuples, the first item being the key of `regionRecord` if there\n * was a corresponding region, or `null` if there was no corresponding region.\n *\n * This function assumes that the regions in `regionRecord` are disjoint and fully contained\n * within the bounds of `array`.\n */\nexport function splitByRegions<\n T,\n RegionRecord extends Record\n>(array: T[], regionsRecord: RegionRecord) {\n const ret: [keyof RegionRecord | null, T[]][] = [];\n\n const indices = [0, array.length];\n const reverseMap: Record = {};\n for (const [key, records] of Object.entries(regionsRecord)) {\n indices.push(\n ...records.flatMap((r) => {\n reverseMap[\"\" + [r.start, r.end]] = key;\n return [r.start, r.end];\n })\n );\n }\n indices.sort((a, b) => a - b);\n\n for (let i = 0; i < indices.length - 1; i++) {\n const start = indices[i];\n const end = indices[i + 1];\n if (start === end) {\n continue;\n }\n const regionKey = reverseMap[\"\" + [start, end]];\n\n ret.push([regionKey || null, array.slice(start, end)]);\n }\n\n return ret;\n}\n","import * as Ast from \"@unified-latex/unified-latex-types\";\nimport { match } from \"@unified-latex/unified-latex-util-match\";\nimport { EXIT, visit } from \"@unified-latex/unified-latex-util-visit\";\n\n/**\n * Escape a string so that it can be used to build a regular expression.\n *\n * From: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions\n */\nfunction escapeRegExp(str: string) {\n return str.replace(/[.*+?^${}()|[\\]\\\\]/g, \"\\\\$&\"); // $& means the whole matched string\n}\n\n/**\n * Build a regular expression that matches everything up to the first non-allowed symbol.\n */\nfunction buildWordRegex(allowedSet: Set): RegExp {\n // /\\p{L}/ matches all letters, including unicode letters. We join this with\n // everything allowed in our set to form a regexp like\n // /(\\p{L}|_|:)*/u\n // The `u` at the end allows unicode characters to be matched.\n const regexpStr = `^(${[\"\\\\p{L}\"]\n .concat(Array.from(allowedSet).map(escapeRegExp))\n .join(\"|\")})*`;\n return new RegExp(regexpStr, \"u\");\n}\n\n/**\n * Checks whether the array has a macro that could be reparsed given the `allowedTokens` but\n * do not do any reparsing. This function can be used in auto-detection schemes to determine if\n * macro names should actually be reparsed.\n */\nexport function hasReparsableMacroNamesInArray(\n tree: Ast.Node[],\n allowedTokens: Set\n): boolean {\n for (let i = 0; i < tree.length; i++) {\n const macro = tree[i];\n const string = tree[i + 1];\n if (match.anyMacro(macro) && match.anyString(string)) {\n // There are two options. Either the macro ends with the special character,\n // e.g. `\\@foo` or the special character starts the next string, e.g. `\\foo@`.\n if (\n allowedTokens.has(\n macro.content.charAt(macro.content.length - 1)\n ) ||\n allowedTokens.has(string.content.charAt(0))\n ) {\n return true;\n }\n }\n }\n return false;\n}\n\n/**\n * Checks whether `tree` has a macro that could be reparsed given the `allowedTokens` but\n * do not do any reparsing. This function can be used in auto-detection schemes to determine if\n * macro names should actually be reparsed.\n */\nexport function hasReparsableMacroNames(\n tree: Ast.Ast,\n allowedTokens: string | Set\n): boolean {\n if (typeof allowedTokens === \"string\") {\n allowedTokens = new Set(allowedTokens.split(\"\"));\n }\n // Recast so typescript doesn't complain\n const _allowedTokens = allowedTokens;\n for (const v of _allowedTokens) {\n if (v.length > 1) {\n throw new Error(\n `Only single characters are allowed as \\`allowedTokens\\` when reparsing macro names, not \\`${v}\\`.`\n );\n }\n }\n\n let ret = false;\n visit(\n tree,\n (nodes) => {\n if (hasReparsableMacroNamesInArray(nodes, _allowedTokens)) {\n ret = true;\n return EXIT;\n }\n },\n { includeArrays: true, test: Array.isArray }\n );\n return ret;\n}\n\n/**\n * Reparses all macro names in the array so that they may optionally include characters listed in `allowedTokens`.\n * This is used, for example, when parsing expl3 syntax which allows `_` to be used in a macro name (even though\n * `_` is normally stops the parsing for a macro name).\n */\nexport function reparseMacroNamesInArray(\n tree: Ast.Node[],\n allowedTokens: Set\n) {\n const regex = buildWordRegex(allowedTokens);\n let i = 0;\n while (i < tree.length) {\n const macro = tree[i];\n const string = tree[i + 1];\n if (\n match.anyMacro(macro) &&\n // The _^ macros in math mode should not be extended no-matter what;\n // So we check to make sure that the macro we're dealing with has the default escape token.\n (macro.escapeToken == null || macro.escapeToken === \"\\\\\") &&\n match.anyString(string) &&\n // There are two options. Either the macro ends with the special character,\n // e.g. `\\@foo` or the special character starts the next string, e.g. `\\foo@`.\n (allowedTokens.has(\n macro.content.charAt(macro.content.length - 1)\n ) ||\n allowedTokens.has(string.content.charAt(0)))\n ) {\n // There might be a number somewhere in the string. If so, we should\n // break the string apart at that number\n const match = string.content.match(regex);\n const takeable = match ? match[0] : \"\";\n if (takeable.length > 0) {\n if (takeable.length === string.content.length) {\n // The whole string can be appended to the macro name\n macro.content += string.content;\n tree.splice(i + 1, 1);\n\n // Preserve the source location if available\n if (macro.position && string.position?.end) {\n macro.position.end = string.position.end;\n }\n } else {\n // Only part of the string can be appended to the macro name\n macro.content += takeable;\n string.content = string.content.slice(takeable.length);\n\n // Preserve the source location if available\n if (macro.position?.end) {\n macro.position.end.offset += takeable.length;\n macro.position.end.column += takeable.length;\n }\n if (string.position?.start) {\n string.position.start.offset += takeable.length;\n string.position.start.column += takeable.length;\n }\n }\n } else {\n i++;\n }\n } else {\n ++i;\n }\n }\n}\n\n/**\n * Reparses all macro names so that they may optionally include characters listed in `allowedTokens`.\n * This is used, for example, when parsing expl3 syntax which allows `_` to be used in a macro name (even though\n * `_` is normally stops the parsing for a macro name). Thus, a macro `\\foo_bar:Nn` would be parsed as having\n * the name `foo_bar:Nn` rather than as `foo` followed by the strings `_`, `bar`, `:`, `Nn`.\n */\nexport function reparseMacroNames(\n tree: Ast.Ast,\n allowedTokens: string | Set\n) {\n if (typeof allowedTokens === \"string\") {\n allowedTokens = new Set(allowedTokens.split(\"\"));\n }\n // Recast so typescript doesn't complain\n const _allowedTokens = allowedTokens;\n for (const v of _allowedTokens) {\n if (v.length > 1) {\n throw new Error(\n `Only single characters are allowed as \\`allowedTokens\\` when reparsing macro names, not \\`${v}\\`.`\n );\n }\n }\n\n visit(\n tree,\n (nodes) => {\n reparseMacroNamesInArray(nodes, _allowedTokens);\n },\n { includeArrays: true, test: Array.isArray }\n );\n}\n","import * as Ast from \"@unified-latex/unified-latex-types\";\nimport { match } from \"@unified-latex/unified-latex-util-match\";\nimport { findRegionInArray } from \"./find-region\";\nimport { refineRegions, Region, splitByRegions } from \"./regions\";\nimport { SKIP, visit } from \"@unified-latex/unified-latex-util-visit\";\nimport { reparseMacroNames } from \"./reparse-macro-names\";\n\nconst expl3Find = {\n start: match.createMacroMatcher([\"ExplSyntaxOn\"]),\n end: match.createMacroMatcher([\"ExplSyntaxOff\"]),\n};\nconst atLetterFind = {\n start: match.createMacroMatcher([\"makeatletter\"]),\n end: match.createMacroMatcher([\"makeatother\"]),\n};\n\n/**\n * Find regions between `\\ExplSyntaxOn...\\ExplSyntaxOff` and `\\makeatletter...\\makeatother`.\n * Returns an object containing regions where one or both syntax's apply.\n */\nexport function findExpl3AndAtLetterRegionsInArray(tree: Ast.Node[]): {\n explOnly: Region[];\n atLetterOnly: Region[];\n both: Region[];\n} {\n const expl3 = findRegionInArray(tree, expl3Find.start, expl3Find.end);\n const atLetter = findRegionInArray(\n tree,\n atLetterFind.start,\n atLetterFind.end\n );\n\n const regionMap = new Map([\n ...(expl3.map((x) => [x, \"expl\"]) as [Region, \"expl\"][]),\n ...(atLetter.map((x) => [x, \"atLetter\"]) as [Region, \"atLetter\"][]),\n ]);\n const all = refineRegions([...expl3, ...atLetter]);\n\n const ret = {\n explOnly: [] as Region[],\n atLetterOnly: [] as Region[],\n both: [] as Region[],\n };\n\n for (let i = 0; i < all.regions.length; i++) {\n const region = all.regions[i];\n const containedIn = all.regionsContainedIn[i];\n if (containedIn.size === 2) {\n ret.both.push(region);\n continue;\n }\n for (const v of containedIn.values()) {\n if (regionMap.get(v) === \"expl\") {\n ret.explOnly.push(region);\n }\n if (regionMap.get(v) === \"atLetter\") {\n ret.atLetterOnly.push(region);\n }\n }\n }\n\n // Regions of size 1 only contain the starting/stopping macro, so they should be discarded\n ret.explOnly = ret.explOnly.filter((r) => r.end - r.start > 1);\n ret.atLetterOnly = ret.atLetterOnly.filter((r) => r.end - r.start > 1);\n ret.both = ret.both.filter((r) => r.end - r.start > 1);\n\n return ret;\n}\n\nconst atLetterSet = new Set([\"@\"]);\nconst explSet = new Set([\"_\", \":\"]);\nconst bothSet = new Set([\"_\", \":\", \"@\"]);\n\n/**\n * Find regions between `\\ExplSyntaxOn...\\ExplSyntaxOff` and `\\makeatletter...\\makeatother`\n * and reparse their contents so that the relevant characters (e.g., `@`, `_`, and `:`) become\n * part of the macro names.\n */\nexport function reparseExpl3AndAtLetterRegions(tree: Ast.Ast) {\n visit(\n tree,\n {\n leave: (nodes) => {\n const regions = findExpl3AndAtLetterRegionsInArray(nodes);\n // In all likelihood, we don't need to do any reparsing, so bail early here\n const totalNumRegions =\n regions.both.length +\n regions.atLetterOnly.length +\n regions.explOnly.length;\n if (totalNumRegions === 0) {\n return;\n }\n\n const splits = splitByRegions(nodes, regions);\n const processed: typeof nodes = [];\n for (const [key, slice] of splits) {\n switch (key) {\n case null:\n processed.push(...slice);\n continue;\n case \"atLetterOnly\":\n reparseMacroNames(slice, atLetterSet);\n processed.push(...slice);\n continue;\n case \"explOnly\":\n reparseMacroNames(slice, explSet);\n processed.push(...slice);\n continue;\n case \"both\":\n reparseMacroNames(slice, bothSet);\n processed.push(...slice);\n continue;\n default:\n throw new Error(\n `Unexpected case when splitting ${key}`\n );\n }\n }\n\n nodes.length = 0;\n nodes.push(...processed);\n return SKIP;\n },\n },\n { includeArrays: true, test: Array.isArray }\n );\n}\n"],"names":["match","visit","EXIT","SKIP"],"mappings":"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"} \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-util-catcode/index.d.ts b/node_modules/@unified-latex/unified-latex-util-catcode/index.d.ts new file mode 100644 index 0000000..ddf03cb --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-util-catcode/index.d.ts @@ -0,0 +1,60 @@ +import * as Ast from '@unified-latex/unified-latex-types'; + +/** + * Find regions between `\ExplSyntaxOn...\ExplSyntaxOff` and `\makeatletter...\makeatother`. + * Returns an object containing regions where one or both syntax's apply. + */ +export declare function findExpl3AndAtLetterRegionsInArray(tree: Ast.Node[]): { + explOnly: Region[]; + atLetterOnly: Region[]; + both: Region[]; +}; + +/** + * Find all contiguous segments in the array that are between start and end blocks. + * The `start` and `end` are functions that determine when a region starts and ends. + */ +export declare function findRegionInArray(tree: Ast.Node[], start: (node: Ast.Node) => boolean, end: (node: Ast.Node) => boolean): Region[]; + +/** + * Checks whether `tree` has a macro that could be reparsed given the `allowedTokens` but + * do not do any reparsing. This function can be used in auto-detection schemes to determine if + * macro names should actually be reparsed. + */ +export declare function hasReparsableMacroNames(tree: Ast.Ast, allowedTokens: string | Set): boolean; + +/** + * Checks whether the array has a macro that could be reparsed given the `allowedTokens` but + * do not do any reparsing. This function can be used in auto-detection schemes to determine if + * macro names should actually be reparsed. + */ +export declare function hasReparsableMacroNamesInArray(tree: Ast.Node[], allowedTokens: Set): boolean; + +declare type Region = { + start: number; + end: number; +}; + +/** + * Find regions between `\ExplSyntaxOn...\ExplSyntaxOff` and `\makeatletter...\makeatother` + * and reparse their contents so that the relevant characters (e.g., `@`, `_`, and `:`) become + * part of the macro names. + */ +export declare function reparseExpl3AndAtLetterRegions(tree: Ast.Ast): void; + +/** + * Reparses all macro names so that they may optionally include characters listed in `allowedTokens`. + * This is used, for example, when parsing expl3 syntax which allows `_` to be used in a macro name (even though + * `_` is normally stops the parsing for a macro name). Thus, a macro `\foo_bar:Nn` would be parsed as having + * the name `foo_bar:Nn` rather than as `foo` followed by the strings `_`, `bar`, `:`, `Nn`. + */ +export declare function reparseMacroNames(tree: Ast.Ast, allowedTokens: string | Set): void; + +/** + * Reparses all macro names in the array so that they may optionally include characters listed in `allowedTokens`. + * This is used, for example, when parsing expl3 syntax which allows `_` to be used in a macro name (even though + * `_` is normally stops the parsing for a macro name). + */ +export declare function reparseMacroNamesInArray(tree: Ast.Node[], allowedTokens: Set): void; + +export { } diff --git a/node_modules/@unified-latex/unified-latex-util-catcode/index.js b/node_modules/@unified-latex/unified-latex-util-catcode/index.js new file mode 100644 index 0000000..2fe0643 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-util-catcode/index.js @@ -0,0 +1,295 @@ +import { match } from "@unified-latex/unified-latex-util-match"; +import { visit, EXIT, SKIP } from "@unified-latex/unified-latex-util-visit"; +function findRegionInArray(tree, start, end) { + const ret = []; + let currRegion = { start: void 0, end: tree.length }; + for (let i = 0; i < tree.length; i++) { + const node = tree[i]; + if (start(node)) { + currRegion.start = i; + } + if (end(node)) { + currRegion.end = i + 1; + ret.push(currRegion); + currRegion = { start: void 0, end: tree.length }; + } + } + if (currRegion.start != null) { + ret.push(currRegion); + } + return ret; +} +function refineRegions(regions) { + const _regions = [...regions]; + _regions.sort((a, b) => a.start - b.start); + const cutPointsSet = new Set(_regions.flatMap((r) => [r.start, r.end])); + const cutPoints = Array.from(cutPointsSet); + cutPoints.sort((a, b) => a - b); + const retRegions = []; + const retRegionsContainedIn = []; + let seekIndex = 0; + for (let i = 0; i < cutPoints.length - 1; i++) { + const start = cutPoints[i]; + const end = cutPoints[i + 1]; + const region = { start, end }; + const regionContainedIn = /* @__PURE__ */ new Set(); + let encounteredEndPastStart = false; + for (let j = seekIndex; j < _regions.length; j++) { + const superRegion = _regions[j]; + if (superRegion.end >= region.start) { + encounteredEndPastStart = true; + } + if (!encounteredEndPastStart && superRegion.end < region.start) { + seekIndex = j + 1; + continue; + } + if (superRegion.start > end) { + break; + } + if (superRegion.start <= region.start && superRegion.end >= region.end) { + encounteredEndPastStart = true; + regionContainedIn.add(superRegion); + } + } + if (regionContainedIn.size > 0) { + retRegions.push(region); + retRegionsContainedIn.push(regionContainedIn); + } + } + return { regions: retRegions, regionsContainedIn: retRegionsContainedIn }; +} +function splitByRegions(array, regionsRecord) { + const ret = []; + const indices = [0, array.length]; + const reverseMap = {}; + for (const [key, records] of Object.entries(regionsRecord)) { + indices.push( + ...records.flatMap((r) => { + reverseMap["" + [r.start, r.end]] = key; + return [r.start, r.end]; + }) + ); + } + indices.sort((a, b) => a - b); + for (let i = 0; i < indices.length - 1; i++) { + const start = indices[i]; + const end = indices[i + 1]; + if (start === end) { + continue; + } + const regionKey = reverseMap["" + [start, end]]; + ret.push([regionKey || null, array.slice(start, end)]); + } + return ret; +} +function escapeRegExp(str) { + return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"); +} +function buildWordRegex(allowedSet) { + const regexpStr = `^(${["\\p{L}"].concat(Array.from(allowedSet).map(escapeRegExp)).join("|")})*`; + return new RegExp(regexpStr, "u"); +} +function hasReparsableMacroNamesInArray(tree, allowedTokens) { + for (let i = 0; i < tree.length; i++) { + const macro = tree[i]; + const string = tree[i + 1]; + if (match.anyMacro(macro) && match.anyString(string)) { + if (allowedTokens.has( + macro.content.charAt(macro.content.length - 1) + ) || allowedTokens.has(string.content.charAt(0))) { + return true; + } + } + } + return false; +} +function hasReparsableMacroNames(tree, allowedTokens) { + if (typeof allowedTokens === "string") { + allowedTokens = new Set(allowedTokens.split("")); + } + const _allowedTokens = allowedTokens; + for (const v of _allowedTokens) { + if (v.length > 1) { + throw new Error( + `Only single characters are allowed as \`allowedTokens\` when reparsing macro names, not \`${v}\`.` + ); + } + } + let ret = false; + visit( + tree, + (nodes) => { + if (hasReparsableMacroNamesInArray(nodes, _allowedTokens)) { + ret = true; + return EXIT; + } + }, + { includeArrays: true, test: Array.isArray } + ); + return ret; +} +function reparseMacroNamesInArray(tree, allowedTokens) { + var _a, _b, _c; + const regex = buildWordRegex(allowedTokens); + let i = 0; + while (i < tree.length) { + const macro = tree[i]; + const string = tree[i + 1]; + if (match.anyMacro(macro) && // The _^ macros in math mode should not be extended no-matter what; + // So we check to make sure that the macro we're dealing with has the default escape token. + (macro.escapeToken == null || macro.escapeToken === "\\") && match.anyString(string) && // There are two options. Either the macro ends with the special character, + // e.g. `\@foo` or the special character starts the next string, e.g. `\foo@`. + (allowedTokens.has( + macro.content.charAt(macro.content.length - 1) + ) || allowedTokens.has(string.content.charAt(0)))) { + const match2 = string.content.match(regex); + const takeable = match2 ? match2[0] : ""; + if (takeable.length > 0) { + if (takeable.length === string.content.length) { + macro.content += string.content; + tree.splice(i + 1, 1); + if (macro.position && ((_a = string.position) == null ? void 0 : _a.end)) { + macro.position.end = string.position.end; + } + } else { + macro.content += takeable; + string.content = string.content.slice(takeable.length); + if ((_b = macro.position) == null ? void 0 : _b.end) { + macro.position.end.offset += takeable.length; + macro.position.end.column += takeable.length; + } + if ((_c = string.position) == null ? void 0 : _c.start) { + string.position.start.offset += takeable.length; + string.position.start.column += takeable.length; + } + } + } else { + i++; + } + } else { + ++i; + } + } +} +function reparseMacroNames(tree, allowedTokens) { + if (typeof allowedTokens === "string") { + allowedTokens = new Set(allowedTokens.split("")); + } + const _allowedTokens = allowedTokens; + for (const v of _allowedTokens) { + if (v.length > 1) { + throw new Error( + `Only single characters are allowed as \`allowedTokens\` when reparsing macro names, not \`${v}\`.` + ); + } + } + visit( + tree, + (nodes) => { + reparseMacroNamesInArray(nodes, _allowedTokens); + }, + { includeArrays: true, test: Array.isArray } + ); +} +const expl3Find = { + start: match.createMacroMatcher(["ExplSyntaxOn"]), + end: match.createMacroMatcher(["ExplSyntaxOff"]) +}; +const atLetterFind = { + start: match.createMacroMatcher(["makeatletter"]), + end: match.createMacroMatcher(["makeatother"]) +}; +function findExpl3AndAtLetterRegionsInArray(tree) { + const expl3 = findRegionInArray(tree, expl3Find.start, expl3Find.end); + const atLetter = findRegionInArray( + tree, + atLetterFind.start, + atLetterFind.end + ); + const regionMap = new Map([ + ...expl3.map((x) => [x, "expl"]), + ...atLetter.map((x) => [x, "atLetter"]) + ]); + const all = refineRegions([...expl3, ...atLetter]); + const ret = { + explOnly: [], + atLetterOnly: [], + both: [] + }; + for (let i = 0; i < all.regions.length; i++) { + const region = all.regions[i]; + const containedIn = all.regionsContainedIn[i]; + if (containedIn.size === 2) { + ret.both.push(region); + continue; + } + for (const v of containedIn.values()) { + if (regionMap.get(v) === "expl") { + ret.explOnly.push(region); + } + if (regionMap.get(v) === "atLetter") { + ret.atLetterOnly.push(region); + } + } + } + ret.explOnly = ret.explOnly.filter((r) => r.end - r.start > 1); + ret.atLetterOnly = ret.atLetterOnly.filter((r) => r.end - r.start > 1); + ret.both = ret.both.filter((r) => r.end - r.start > 1); + return ret; +} +const atLetterSet = /* @__PURE__ */ new Set(["@"]); +const explSet = /* @__PURE__ */ new Set(["_", ":"]); +const bothSet = /* @__PURE__ */ new Set(["_", ":", "@"]); +function reparseExpl3AndAtLetterRegions(tree) { + visit( + tree, + { + leave: (nodes) => { + const regions = findExpl3AndAtLetterRegionsInArray(nodes); + const totalNumRegions = regions.both.length + regions.atLetterOnly.length + regions.explOnly.length; + if (totalNumRegions === 0) { + return; + } + const splits = splitByRegions(nodes, regions); + const processed = []; + for (const [key, slice] of splits) { + switch (key) { + case null: + processed.push(...slice); + continue; + case "atLetterOnly": + reparseMacroNames(slice, atLetterSet); + processed.push(...slice); + continue; + case "explOnly": + reparseMacroNames(slice, explSet); + processed.push(...slice); + continue; + case "both": + reparseMacroNames(slice, bothSet); + processed.push(...slice); + continue; + default: + throw new Error( + `Unexpected case when splitting ${key}` + ); + } + } + nodes.length = 0; + nodes.push(...processed); + return SKIP; + } + }, + { includeArrays: true, test: Array.isArray } + ); +} +export { + findExpl3AndAtLetterRegionsInArray, + findRegionInArray, + hasReparsableMacroNames, + hasReparsableMacroNamesInArray, + reparseExpl3AndAtLetterRegions, + reparseMacroNames, + reparseMacroNamesInArray +}; +//# sourceMappingURL=index.js.map diff --git a/node_modules/@unified-latex/unified-latex-util-catcode/index.js.map b/node_modules/@unified-latex/unified-latex-util-catcode/index.js.map new file mode 100644 index 0000000..9f98cbb --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-util-catcode/index.js.map @@ -0,0 +1 @@ +{"version":3,"file":"index.js","sources":["../libs/find-region.ts","../libs/regions.ts","../libs/reparse-macro-names.ts","../libs/special-regions.ts"],"sourcesContent":["import * as Ast from \"@unified-latex/unified-latex-types\";\nimport { Region } from \"./regions\";\n\n/**\n * Find all contiguous segments in the array that are between start and end blocks.\n * The `start` and `end` are functions that determine when a region starts and ends.\n */\nexport function findRegionInArray(\n tree: Ast.Node[],\n start: (node: Ast.Node) => boolean,\n end: (node: Ast.Node) => boolean\n): Region[] {\n const ret: Region[] = [];\n let currRegion: Region = { start: undefined as any, end: tree.length };\n for (let i = 0; i < tree.length; i++) {\n const node = tree[i];\n if (start(node)) {\n currRegion.start = i;\n }\n if (end(node)) {\n currRegion.end = i + 1;\n ret.push(currRegion);\n currRegion = { start: undefined as any, end: tree.length };\n }\n }\n\n if (currRegion.start != null) {\n // Regions don't necessarily have to encounter an `end` to end.\n ret.push(currRegion);\n }\n return ret;\n}\n","import * as Ast from \"@unified-latex/unified-latex-types\";\n\nexport type Region = { start: number; end: number };\n\n/**\n * Given `regions`, a list of `Region`s (not necessarily ordered, possibly overlapping), return a list of in-order,\n * non-overlapping regions and a corresponding list containing a set of the original `Region`s that the new region\n * is a subset of.\n */\nexport function refineRegions(regions: Region[]): {\n regions: Region[];\n regionsContainedIn: Set[];\n} {\n const _regions = [...regions];\n _regions.sort((a, b) => a.start - b.start);\n const cutPointsSet = new Set(_regions.flatMap((r) => [r.start, r.end]));\n const cutPoints = Array.from(cutPointsSet);\n cutPoints.sort((a, b) => a - b);\n\n const retRegions: Region[] = [];\n const retRegionsContainedIn: Set[] = [];\n\n // We will be checking what regions we are completely contained in.\n // Because `_regions` is sorted by start, `seekIndex` will be incremented\n // by end, so that we don't do too much array testing.\n let seekIndex = 0;\n for (let i = 0; i < cutPoints.length - 1; i++) {\n const start = cutPoints[i];\n const end = cutPoints[i + 1];\n const region = { start, end };\n const regionContainedIn: Set = new Set();\n\n let encounteredEndPastStart = false;\n for (let j = seekIndex; j < _regions.length; j++) {\n const superRegion = _regions[j];\n if (superRegion.end >= region.start) {\n encounteredEndPastStart = true;\n }\n if (!encounteredEndPastStart && superRegion.end < region.start) {\n // In this case, the region (and all regions that came before)\n // end before the region we are testing, so we may safely skip past it\n // from here on out.\n seekIndex = j + 1;\n continue;\n }\n\n if (superRegion.start > end) {\n // Because `_regions` is sorted, we can stop here\n break;\n }\n if (\n superRegion.start <= region.start &&\n superRegion.end >= region.end\n ) {\n encounteredEndPastStart = true;\n regionContainedIn.add(superRegion);\n }\n }\n\n if (regionContainedIn.size > 0) {\n // We only count if we are contained in a subregion\n retRegions.push(region);\n retRegionsContainedIn.push(regionContainedIn);\n }\n }\n\n return { regions: retRegions, regionsContainedIn: retRegionsContainedIn };\n}\n\n/**\n * Split an array up into the disjoint regions specified by `regionRecord`.\n * Returned is a list of tuples, the first item being the key of `regionRecord` if there\n * was a corresponding region, or `null` if there was no corresponding region.\n *\n * This function assumes that the regions in `regionRecord` are disjoint and fully contained\n * within the bounds of `array`.\n */\nexport function splitByRegions<\n T,\n RegionRecord extends Record\n>(array: T[], regionsRecord: RegionRecord) {\n const ret: [keyof RegionRecord | null, T[]][] = [];\n\n const indices = [0, array.length];\n const reverseMap: Record = {};\n for (const [key, records] of Object.entries(regionsRecord)) {\n indices.push(\n ...records.flatMap((r) => {\n reverseMap[\"\" + [r.start, r.end]] = key;\n return [r.start, r.end];\n })\n );\n }\n indices.sort((a, b) => a - b);\n\n for (let i = 0; i < indices.length - 1; i++) {\n const start = indices[i];\n const end = indices[i + 1];\n if (start === end) {\n continue;\n }\n const regionKey = reverseMap[\"\" + [start, end]];\n\n ret.push([regionKey || null, array.slice(start, end)]);\n }\n\n return ret;\n}\n","import * as Ast from \"@unified-latex/unified-latex-types\";\nimport { match } from \"@unified-latex/unified-latex-util-match\";\nimport { EXIT, visit } from \"@unified-latex/unified-latex-util-visit\";\n\n/**\n * Escape a string so that it can be used to build a regular expression.\n *\n * From: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions\n */\nfunction escapeRegExp(str: string) {\n return str.replace(/[.*+?^${}()|[\\]\\\\]/g, \"\\\\$&\"); // $& means the whole matched string\n}\n\n/**\n * Build a regular expression that matches everything up to the first non-allowed symbol.\n */\nfunction buildWordRegex(allowedSet: Set): RegExp {\n // /\\p{L}/ matches all letters, including unicode letters. We join this with\n // everything allowed in our set to form a regexp like\n // /(\\p{L}|_|:)*/u\n // The `u` at the end allows unicode characters to be matched.\n const regexpStr = `^(${[\"\\\\p{L}\"]\n .concat(Array.from(allowedSet).map(escapeRegExp))\n .join(\"|\")})*`;\n return new RegExp(regexpStr, \"u\");\n}\n\n/**\n * Checks whether the array has a macro that could be reparsed given the `allowedTokens` but\n * do not do any reparsing. This function can be used in auto-detection schemes to determine if\n * macro names should actually be reparsed.\n */\nexport function hasReparsableMacroNamesInArray(\n tree: Ast.Node[],\n allowedTokens: Set\n): boolean {\n for (let i = 0; i < tree.length; i++) {\n const macro = tree[i];\n const string = tree[i + 1];\n if (match.anyMacro(macro) && match.anyString(string)) {\n // There are two options. Either the macro ends with the special character,\n // e.g. `\\@foo` or the special character starts the next string, e.g. `\\foo@`.\n if (\n allowedTokens.has(\n macro.content.charAt(macro.content.length - 1)\n ) ||\n allowedTokens.has(string.content.charAt(0))\n ) {\n return true;\n }\n }\n }\n return false;\n}\n\n/**\n * Checks whether `tree` has a macro that could be reparsed given the `allowedTokens` but\n * do not do any reparsing. This function can be used in auto-detection schemes to determine if\n * macro names should actually be reparsed.\n */\nexport function hasReparsableMacroNames(\n tree: Ast.Ast,\n allowedTokens: string | Set\n): boolean {\n if (typeof allowedTokens === \"string\") {\n allowedTokens = new Set(allowedTokens.split(\"\"));\n }\n // Recast so typescript doesn't complain\n const _allowedTokens = allowedTokens;\n for (const v of _allowedTokens) {\n if (v.length > 1) {\n throw new Error(\n `Only single characters are allowed as \\`allowedTokens\\` when reparsing macro names, not \\`${v}\\`.`\n );\n }\n }\n\n let ret = false;\n visit(\n tree,\n (nodes) => {\n if (hasReparsableMacroNamesInArray(nodes, _allowedTokens)) {\n ret = true;\n return EXIT;\n }\n },\n { includeArrays: true, test: Array.isArray }\n );\n return ret;\n}\n\n/**\n * Reparses all macro names in the array so that they may optionally include characters listed in `allowedTokens`.\n * This is used, for example, when parsing expl3 syntax which allows `_` to be used in a macro name (even though\n * `_` is normally stops the parsing for a macro name).\n */\nexport function reparseMacroNamesInArray(\n tree: Ast.Node[],\n allowedTokens: Set\n) {\n const regex = buildWordRegex(allowedTokens);\n let i = 0;\n while (i < tree.length) {\n const macro = tree[i];\n const string = tree[i + 1];\n if (\n match.anyMacro(macro) &&\n // The _^ macros in math mode should not be extended no-matter what;\n // So we check to make sure that the macro we're dealing with has the default escape token.\n (macro.escapeToken == null || macro.escapeToken === \"\\\\\") &&\n match.anyString(string) &&\n // There are two options. Either the macro ends with the special character,\n // e.g. `\\@foo` or the special character starts the next string, e.g. `\\foo@`.\n (allowedTokens.has(\n macro.content.charAt(macro.content.length - 1)\n ) ||\n allowedTokens.has(string.content.charAt(0)))\n ) {\n // There might be a number somewhere in the string. If so, we should\n // break the string apart at that number\n const match = string.content.match(regex);\n const takeable = match ? match[0] : \"\";\n if (takeable.length > 0) {\n if (takeable.length === string.content.length) {\n // The whole string can be appended to the macro name\n macro.content += string.content;\n tree.splice(i + 1, 1);\n\n // Preserve the source location if available\n if (macro.position && string.position?.end) {\n macro.position.end = string.position.end;\n }\n } else {\n // Only part of the string can be appended to the macro name\n macro.content += takeable;\n string.content = string.content.slice(takeable.length);\n\n // Preserve the source location if available\n if (macro.position?.end) {\n macro.position.end.offset += takeable.length;\n macro.position.end.column += takeable.length;\n }\n if (string.position?.start) {\n string.position.start.offset += takeable.length;\n string.position.start.column += takeable.length;\n }\n }\n } else {\n i++;\n }\n } else {\n ++i;\n }\n }\n}\n\n/**\n * Reparses all macro names so that they may optionally include characters listed in `allowedTokens`.\n * This is used, for example, when parsing expl3 syntax which allows `_` to be used in a macro name (even though\n * `_` is normally stops the parsing for a macro name). Thus, a macro `\\foo_bar:Nn` would be parsed as having\n * the name `foo_bar:Nn` rather than as `foo` followed by the strings `_`, `bar`, `:`, `Nn`.\n */\nexport function reparseMacroNames(\n tree: Ast.Ast,\n allowedTokens: string | Set\n) {\n if (typeof allowedTokens === \"string\") {\n allowedTokens = new Set(allowedTokens.split(\"\"));\n }\n // Recast so typescript doesn't complain\n const _allowedTokens = allowedTokens;\n for (const v of _allowedTokens) {\n if (v.length > 1) {\n throw new Error(\n `Only single characters are allowed as \\`allowedTokens\\` when reparsing macro names, not \\`${v}\\`.`\n );\n }\n }\n\n visit(\n tree,\n (nodes) => {\n reparseMacroNamesInArray(nodes, _allowedTokens);\n },\n { includeArrays: true, test: Array.isArray }\n );\n}\n","import * as Ast from \"@unified-latex/unified-latex-types\";\nimport { match } from \"@unified-latex/unified-latex-util-match\";\nimport { findRegionInArray } from \"./find-region\";\nimport { refineRegions, Region, splitByRegions } from \"./regions\";\nimport { SKIP, visit } from \"@unified-latex/unified-latex-util-visit\";\nimport { reparseMacroNames } from \"./reparse-macro-names\";\n\nconst expl3Find = {\n start: match.createMacroMatcher([\"ExplSyntaxOn\"]),\n end: match.createMacroMatcher([\"ExplSyntaxOff\"]),\n};\nconst atLetterFind = {\n start: match.createMacroMatcher([\"makeatletter\"]),\n end: match.createMacroMatcher([\"makeatother\"]),\n};\n\n/**\n * Find regions between `\\ExplSyntaxOn...\\ExplSyntaxOff` and `\\makeatletter...\\makeatother`.\n * Returns an object containing regions where one or both syntax's apply.\n */\nexport function findExpl3AndAtLetterRegionsInArray(tree: Ast.Node[]): {\n explOnly: Region[];\n atLetterOnly: Region[];\n both: Region[];\n} {\n const expl3 = findRegionInArray(tree, expl3Find.start, expl3Find.end);\n const atLetter = findRegionInArray(\n tree,\n atLetterFind.start,\n atLetterFind.end\n );\n\n const regionMap = new Map([\n ...(expl3.map((x) => [x, \"expl\"]) as [Region, \"expl\"][]),\n ...(atLetter.map((x) => [x, \"atLetter\"]) as [Region, \"atLetter\"][]),\n ]);\n const all = refineRegions([...expl3, ...atLetter]);\n\n const ret = {\n explOnly: [] as Region[],\n atLetterOnly: [] as Region[],\n both: [] as Region[],\n };\n\n for (let i = 0; i < all.regions.length; i++) {\n const region = all.regions[i];\n const containedIn = all.regionsContainedIn[i];\n if (containedIn.size === 2) {\n ret.both.push(region);\n continue;\n }\n for (const v of containedIn.values()) {\n if (regionMap.get(v) === \"expl\") {\n ret.explOnly.push(region);\n }\n if (regionMap.get(v) === \"atLetter\") {\n ret.atLetterOnly.push(region);\n }\n }\n }\n\n // Regions of size 1 only contain the starting/stopping macro, so they should be discarded\n ret.explOnly = ret.explOnly.filter((r) => r.end - r.start > 1);\n ret.atLetterOnly = ret.atLetterOnly.filter((r) => r.end - r.start > 1);\n ret.both = ret.both.filter((r) => r.end - r.start > 1);\n\n return ret;\n}\n\nconst atLetterSet = new Set([\"@\"]);\nconst explSet = new Set([\"_\", \":\"]);\nconst bothSet = new Set([\"_\", \":\", \"@\"]);\n\n/**\n * Find regions between `\\ExplSyntaxOn...\\ExplSyntaxOff` and `\\makeatletter...\\makeatother`\n * and reparse their contents so that the relevant characters (e.g., `@`, `_`, and `:`) become\n * part of the macro names.\n */\nexport function reparseExpl3AndAtLetterRegions(tree: Ast.Ast) {\n visit(\n tree,\n {\n leave: (nodes) => {\n const regions = findExpl3AndAtLetterRegionsInArray(nodes);\n // In all likelihood, we don't need to do any reparsing, so bail early here\n const totalNumRegions =\n regions.both.length +\n regions.atLetterOnly.length +\n regions.explOnly.length;\n if (totalNumRegions === 0) {\n return;\n }\n\n const splits = splitByRegions(nodes, regions);\n const processed: typeof nodes = [];\n for (const [key, slice] of splits) {\n switch (key) {\n case null:\n processed.push(...slice);\n continue;\n case \"atLetterOnly\":\n reparseMacroNames(slice, atLetterSet);\n processed.push(...slice);\n continue;\n case \"explOnly\":\n reparseMacroNames(slice, explSet);\n processed.push(...slice);\n continue;\n case \"both\":\n reparseMacroNames(slice, bothSet);\n processed.push(...slice);\n continue;\n default:\n throw new Error(\n `Unexpected case when splitting ${key}`\n );\n }\n }\n\n nodes.length = 0;\n nodes.push(...processed);\n return SKIP;\n },\n },\n { includeArrays: true, test: Array.isArray }\n );\n}\n"],"names":["match"],"mappings":"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"} \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-util-catcode/package.json b/node_modules/@unified-latex/unified-latex-util-catcode/package.json new file mode 100644 index 0000000..c75803a --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-util-catcode/package.json @@ -0,0 +1,53 @@ +{ + "name": "@unified-latex/unified-latex-util-catcode", + "version": "1.8.2", + "description": "Tools for manipulating unified-latex ASTs", + "main": "index.js", + "type": "module", + "dependencies": { + "@unified-latex/unified-latex-types": "^1.8.0", + "@unified-latex/unified-latex-util-match": "^1.8.0", + "@unified-latex/unified-latex-util-visit": "^1.8.2" + }, + "repository": { + "type": "git", + "url": "git+https://github.com/siefkenj/unified-latex.git" + }, + "keywords": [ + "pegjs", + "latex", + "parser", + "prettier", + "unified-latex", + "unified" + ], + "author": "Jason Siefken", + "license": "MIT", + "bugs": { + "url": "https://github.com/siefkenj/unified-latex/issues" + }, + "homepage": "https://github.com/siefkenj/unified-latex#readme", + "exports": { + ".": { + "import": "./index.js", + "require": "./index.cjs", + "types": "./index.d.ts" + }, + "./*js": "./*js", + "./*": { + "import": "./*/index.js", + "require": "./*/index.cjs", + "types": "./*/index.d.ts" + }, + "./*/index": { + "import": "./*/index.js", + "require": "./*/index.cjs" + } + }, + "files": [ + "**/*ts", + "**/*js", + "**/*.map", + "**/*.json" + ] +} \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-util-comments/README.md b/node_modules/@unified-latex/unified-latex-util-comments/README.md new file mode 100644 index 0000000..65192d8 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-util-comments/README.md @@ -0,0 +1,49 @@ + + + + +# unified-latex-util-comments + +## What is this? + +Functions to help modify comments in a `unified-latex` Abstract Syntax Tree (AST). + +## When should I use this? + +If you want to process comments in a `unified-latex` AST. + +## Install + +```bash +npm install @unified-latex/unified-latex-util-comments +``` + +This package contains both esm and commonjs exports. To explicitly access the esm export, +import the `.js` file. To explicitly access the commonjs export, import the `.cjs` file. + +# Functions + +## `deleteComments(ast)` + +Returns a new AST with all comments removed. Care is taken to preserve whitespace. +For example + + x% + y + +becomes `xy` but + + x % + y + +becomes `x y` + +```typescript +function deleteComments(ast: Ast.Ast): void; +``` + +**Parameters** + +| Param | Type | +| :---- | :-------- | +| ast | `Ast.Ast` | diff --git a/node_modules/@unified-latex/unified-latex-util-comments/index.cjs b/node_modules/@unified-latex/unified-latex-util-comments/index.cjs new file mode 100644 index 0000000..3cbd176 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-util-comments/index.cjs @@ -0,0 +1,17 @@ +"use strict"; +Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" }); +const unifiedLatexUtilMatch = require("@unified-latex/unified-latex-util-match"); +const unifiedLatexUtilReplace = require("@unified-latex/unified-latex-util-replace"); +function deleteComments(ast) { + return unifiedLatexUtilReplace.replaceNode(ast, (node) => { + if (!unifiedLatexUtilMatch.match.comment(node)) { + return; + } + if (node.leadingWhitespace) { + return { type: "whitespace" }; + } + return null; + }); +} +exports.deleteComments = deleteComments; +//# sourceMappingURL=index.cjs.map diff --git a/node_modules/@unified-latex/unified-latex-util-comments/index.cjs.map b/node_modules/@unified-latex/unified-latex-util-comments/index.cjs.map new file mode 100644 index 0000000..8e8d507 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-util-comments/index.cjs.map @@ -0,0 +1 @@ +{"version":3,"file":"index.cjs","sources":["../libs/delete-comments.ts"],"sourcesContent":["import * as Ast from \"@unified-latex/unified-latex-types\";\nimport { match } from \"@unified-latex/unified-latex-util-match\";\nimport { replaceNode } from \"@unified-latex/unified-latex-util-replace\";\n\n/**\n * Returns a new AST with all comments removed. Care is taken to preserve whitespace.\n * For example\n * ```\n * x%\n * y\n * ```\n * becomes `xy` but\n * ```\n * x %\n * y\n * ```\n * becomes `x y`\n */\nexport function deleteComments(ast: Ast.Ast) {\n return replaceNode(ast, (node) => {\n if (!match.comment(node)) {\n return;\n }\n\n if (node.leadingWhitespace) {\n return { type: \"whitespace\" };\n }\n\n return null;\n });\n}\n"],"names":["replaceNode","match"],"mappings":";;;;AAkBO,SAAS,eAAe,KAAc;AAClC,SAAAA,wBAAA,YAAY,KAAK,CAAC,SAAS;AAC9B,QAAI,CAACC,sBAAA,MAAM,QAAQ,IAAI,GAAG;AACtB;AAAA,IAAA;AAGJ,QAAI,KAAK,mBAAmB;AACjB,aAAA,EAAE,MAAM,aAAa;AAAA,IAAA;AAGzB,WAAA;AAAA,EAAA,CACV;AACL;;"} \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-util-comments/index.d.ts b/node_modules/@unified-latex/unified-latex-util-comments/index.d.ts new file mode 100644 index 0000000..6c2334c --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-util-comments/index.d.ts @@ -0,0 +1,19 @@ +import * as Ast from '@unified-latex/unified-latex-types'; + +/** + * Returns a new AST with all comments removed. Care is taken to preserve whitespace. + * For example + * ``` + * x% + * y + * ``` + * becomes `xy` but + * ``` + * x % + * y + * ``` + * becomes `x y` + */ +export declare function deleteComments(ast: Ast.Ast): void; + +export { } diff --git a/node_modules/@unified-latex/unified-latex-util-comments/index.js b/node_modules/@unified-latex/unified-latex-util-comments/index.js new file mode 100644 index 0000000..38ad14c --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-util-comments/index.js @@ -0,0 +1,17 @@ +import { match } from "@unified-latex/unified-latex-util-match"; +import { replaceNode } from "@unified-latex/unified-latex-util-replace"; +function deleteComments(ast) { + return replaceNode(ast, (node) => { + if (!match.comment(node)) { + return; + } + if (node.leadingWhitespace) { + return { type: "whitespace" }; + } + return null; + }); +} +export { + deleteComments +}; +//# sourceMappingURL=index.js.map diff --git a/node_modules/@unified-latex/unified-latex-util-comments/index.js.map b/node_modules/@unified-latex/unified-latex-util-comments/index.js.map new file mode 100644 index 0000000..b0b9b2b --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-util-comments/index.js.map @@ -0,0 +1 @@ +{"version":3,"file":"index.js","sources":["../libs/delete-comments.ts"],"sourcesContent":["import * as Ast from \"@unified-latex/unified-latex-types\";\nimport { match } from \"@unified-latex/unified-latex-util-match\";\nimport { replaceNode } from \"@unified-latex/unified-latex-util-replace\";\n\n/**\n * Returns a new AST with all comments removed. Care is taken to preserve whitespace.\n * For example\n * ```\n * x%\n * y\n * ```\n * becomes `xy` but\n * ```\n * x %\n * y\n * ```\n * becomes `x y`\n */\nexport function deleteComments(ast: Ast.Ast) {\n return replaceNode(ast, (node) => {\n if (!match.comment(node)) {\n return;\n }\n\n if (node.leadingWhitespace) {\n return { type: \"whitespace\" };\n }\n\n return null;\n });\n}\n"],"names":[],"mappings":";;AAkBO,SAAS,eAAe,KAAc;AAClC,SAAA,YAAY,KAAK,CAAC,SAAS;AAC9B,QAAI,CAAC,MAAM,QAAQ,IAAI,GAAG;AACtB;AAAA,IAAA;AAGJ,QAAI,KAAK,mBAAmB;AACjB,aAAA,EAAE,MAAM,aAAa;AAAA,IAAA;AAGzB,WAAA;AAAA,EAAA,CACV;AACL;"} \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-util-comments/package.json b/node_modules/@unified-latex/unified-latex-util-comments/package.json new file mode 100644 index 0000000..8a524e3 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-util-comments/package.json @@ -0,0 +1,53 @@ +{ + "name": "@unified-latex/unified-latex-util-comments", + "version": "1.8.2", + "description": "Tools for manipulating unified-latex ASTs", + "main": "index.js", + "type": "module", + "dependencies": { + "@unified-latex/unified-latex-types": "^1.8.0", + "@unified-latex/unified-latex-util-match": "^1.8.0", + "@unified-latex/unified-latex-util-replace": "^1.8.2" + }, + "repository": { + "type": "git", + "url": "git+https://github.com/siefkenj/unified-latex.git" + }, + "keywords": [ + "pegjs", + "latex", + "parser", + "prettier", + "unified-latex", + "unified" + ], + "author": "Jason Siefken", + "license": "MIT", + "bugs": { + "url": "https://github.com/siefkenj/unified-latex/issues" + }, + "homepage": "https://github.com/siefkenj/unified-latex#readme", + "exports": { + ".": { + "import": "./index.js", + "require": "./index.cjs", + "types": "./index.d.ts" + }, + "./*js": "./*js", + "./*": { + "import": "./*/index.js", + "require": "./*/index.cjs", + "types": "./*/index.d.ts" + }, + "./*/index": { + "import": "./*/index.js", + "require": "./*/index.cjs" + } + }, + "files": [ + "**/*ts", + "**/*js", + "**/*.map", + "**/*.json" + ] +} \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-util-environments/README.md b/node_modules/@unified-latex/unified-latex-util-environments/README.md new file mode 100644 index 0000000..1fc6ead --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-util-environments/README.md @@ -0,0 +1,91 @@ + + + + +# unified-latex-util-environments + +## What is this? + +Functions to report on/manipulate environments in a `unified-latex` Abstract Syntax Tree (AST). + +## When should I use this? + +If you are working on the internals of `unified-latex-util-parse` or need to make a custom parser +that treats environments differently. + +## Install + +```bash +npm install @unified-latex/unified-latex-util-environments +``` + +This package contains both esm and commonjs exports. To explicitly access the esm export, +import the `.js` file. To explicitly access the commonjs export, import the `.cjs` file. + +# Plugins + +## `unifiedLatexProcessEnvironments` + +Unified plugin to process environment content and attach arguments. + +### Usage + +`unified().use(unifiedLatexProcessEnvironments[, options])` + +#### options + +```typescript +{ environments: EnvInfoRecord; } +``` + +### Type + +`Plugin<{ environments: EnvInfoRecord; }[], Ast.Root, Ast.Root>` + +```typescript +function unifiedLatexProcessEnvironments(options: { + environments: EnvInfoRecord; +}): (tree: Ast.Root) => void; +``` + +# Functions + +## `processEnvironment(envNode, envInfo)` + +Performs any needed processing on the environment (as specified by `envInfo`) +including attaching arguments and possibly manipulating the environment's body. + +```typescript +function processEnvironment( + envNode: Ast.Environment, + envInfo: Ast.EnvInfo +): void; +``` + +**Parameters** + +| Param | Type | +| :------ | :---------------- | +| envNode | `Ast.Environment` | +| envInfo | `Ast.EnvInfo` | + +## `processEnvironments(tree, environments)` + +Recursively search for and process the specified environments. Arguments are +consumed according to the `signature` specified. The body is processed +with the specified `processContent` function (if given). Any specified `renderInfo` +is attached to the environment node. + +```typescript +function processEnvironments( + tree: Ast.Ast, + environments: Ast.EnvInfoRecord +): void; +``` + +**Parameters** + +| Param | Type | +| :----------- | :------------------ | +| tree | `Ast.Ast` | +| environments | `Ast.EnvInfoRecord` | diff --git a/node_modules/@unified-latex/unified-latex-util-environments/index.cjs b/node_modules/@unified-latex/unified-latex-util-environments/index.cjs new file mode 100644 index 0000000..002ad7a --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-util-environments/index.cjs @@ -0,0 +1,67 @@ +"use strict"; +Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" }); +const unifiedLatexUtilRenderInfo = require("@unified-latex/unified-latex-util-render-info"); +const unifiedLatexUtilArguments = require("@unified-latex/unified-latex-util-arguments"); +const unifiedLatexUtilMatch = require("@unified-latex/unified-latex-util-match"); +const unifiedLatexUtilVisit = require("@unified-latex/unified-latex-util-visit"); +const unifiedLatexUtilPrintRaw = require("@unified-latex/unified-latex-util-print-raw"); +function processEnvironment(envNode, envInfo) { + if (envInfo.signature && envNode.args == null) { + const { args } = unifiedLatexUtilArguments.gobbleArguments(envNode.content, envInfo.signature); + envNode.args = args; + } + unifiedLatexUtilRenderInfo.updateRenderInfo(envNode, envInfo.renderInfo); + if (typeof envInfo.processContent === "function") { + envNode.content = envInfo.processContent(envNode.content); + } +} +function processEnvironments(tree, environments) { + const isRelevantEnvironment = unifiedLatexUtilMatch.match.createEnvironmentMatcher(environments); + unifiedLatexUtilVisit.visit( + tree, + { + leave: (node) => { + const envName = unifiedLatexUtilPrintRaw.printRaw(node.env); + const envInfo = environments[envName]; + if (!envInfo) { + throw new Error( + `Could not find environment info for environment "${envName}"` + ); + } + processEnvironment(node, envInfo); + } + }, + { test: isRelevantEnvironment } + ); +} +const unifiedLatexProcessEnvironments = function unifiedLatexAttachMacroArguments(options) { + const { environments = {} } = options || {}; + const isRelevantEnvironment = unifiedLatexUtilMatch.match.createEnvironmentMatcher(environments); + return (tree) => { + if (Object.keys(environments).length === 0) { + console.warn( + "Attempting to attach macro arguments but no macros are specified." + ); + } + unifiedLatexUtilVisit.visit( + tree, + { + leave: (node) => { + const envName = unifiedLatexUtilPrintRaw.printRaw(node.env); + const envInfo = environments[envName]; + if (!envInfo) { + throw new Error( + `Could not find environment info for environment "${envName}"` + ); + } + processEnvironment(node, envInfo); + } + }, + { test: isRelevantEnvironment } + ); + }; +}; +exports.processEnvironment = processEnvironment; +exports.processEnvironments = processEnvironments; +exports.unifiedLatexProcessEnvironments = unifiedLatexProcessEnvironments; +//# sourceMappingURL=index.cjs.map diff --git a/node_modules/@unified-latex/unified-latex-util-environments/index.cjs.map b/node_modules/@unified-latex/unified-latex-util-environments/index.cjs.map new file mode 100644 index 0000000..b750b74 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-util-environments/index.cjs.map @@ -0,0 +1 @@ +{"version":3,"file":"index.cjs","sources":["../libs/process-environment.ts","../libs/unified-latex-process-environment.ts"],"sourcesContent":["import * as Ast from \"@unified-latex/unified-latex-types\";\nimport { EnvInfo, EnvInfoRecord } from \"@unified-latex/unified-latex-types\";\nimport { updateRenderInfo } from \"@unified-latex/unified-latex-util-render-info\";\nimport { gobbleArguments } from \"@unified-latex/unified-latex-util-arguments\";\nimport { match } from \"@unified-latex/unified-latex-util-match\";\nimport { visit } from \"@unified-latex/unified-latex-util-visit\";\nimport { printRaw } from \"@unified-latex/unified-latex-util-print-raw\";\n\n/**\n * Performs any needed processing on the environment (as specified by `envInfo`)\n * including attaching arguments and possibly manipulating the environment's body.\n */\nexport function processEnvironment(envNode: Ast.Environment, envInfo: EnvInfo) {\n if (envInfo.signature && envNode.args == null) {\n const { args } = gobbleArguments(envNode.content, envInfo.signature);\n envNode.args = args;\n }\n\n updateRenderInfo(envNode, envInfo.renderInfo);\n if (typeof envInfo.processContent === \"function\") {\n envNode.content = envInfo.processContent(envNode.content);\n }\n}\n\n/**\n * Recursively search for and process the specified environments. Arguments are\n * consumed according to the `signature` specified. The body is processed\n * with the specified `processContent` function (if given). Any specified `renderInfo`\n * is attached to the environment node.\n */\nexport function processEnvironments(\n tree: Ast.Ast,\n environments: EnvInfoRecord\n) {\n const isRelevantEnvironment = match.createEnvironmentMatcher(environments);\n\n visit(\n tree,\n {\n leave: (node) => {\n const envName = printRaw(node.env);\n const envInfo = environments[envName];\n if (!envInfo) {\n throw new Error(\n `Could not find environment info for environment \"${envName}\"`\n );\n }\n processEnvironment(node, envInfo);\n },\n },\n { test: isRelevantEnvironment }\n );\n}\n","import * as Ast from \"@unified-latex/unified-latex-types\";\nimport { EnvInfoRecord } from \"@unified-latex/unified-latex-types\";\nimport { Plugin } from \"unified\";\nimport { visit } from \"@unified-latex/unified-latex-util-visit\";\nimport { match } from \"@unified-latex/unified-latex-util-match\";\nimport { processEnvironment } from \"./process-environment\";\nimport { printRaw } from \"@unified-latex/unified-latex-util-print-raw\";\n\ntype PluginOptions = { environments: EnvInfoRecord } | undefined;\n\n/**\n * Unified plugin to process environment content and attach arguments.\n *\n * @param environments An object whose keys are environment names and values contains information about the environment and its argument signature.\n */\nexport const unifiedLatexProcessEnvironments: Plugin<\n PluginOptions[],\n Ast.Root,\n Ast.Root\n> = function unifiedLatexAttachMacroArguments(options) {\n const { environments = {} } = options || {};\n const isRelevantEnvironment = match.createEnvironmentMatcher(environments);\n\n return (tree) => {\n if (Object.keys(environments).length === 0) {\n console.warn(\n \"Attempting to attach macro arguments but no macros are specified.\"\n );\n }\n\n visit(\n tree,\n {\n leave: (node) => {\n const envName = printRaw(node.env);\n const envInfo = environments[envName];\n if (!envInfo) {\n throw new Error(\n `Could not find environment info for environment \"${envName}\"`\n );\n }\n processEnvironment(node, envInfo);\n },\n },\n { test: isRelevantEnvironment }\n );\n };\n};\n"],"names":["gobbleArguments","updateRenderInfo","match","visit","printRaw"],"mappings":";;;;;;;AAYgB,SAAA,mBAAmB,SAA0B,SAAkB;AAC3E,MAAI,QAAQ,aAAa,QAAQ,QAAQ,MAAM;AAC3C,UAAM,EAAE,KAAK,IAAIA,0CAAgB,QAAQ,SAAS,QAAQ,SAAS;AACnE,YAAQ,OAAO;AAAA,EAAA;AAGFC,8CAAA,SAAS,QAAQ,UAAU;AACxC,MAAA,OAAO,QAAQ,mBAAmB,YAAY;AAC9C,YAAQ,UAAU,QAAQ,eAAe,QAAQ,OAAO;AAAA,EAAA;AAEhE;AAQgB,SAAA,oBACZ,MACA,cACF;AACQ,QAAA,wBAAwBC,sBAAAA,MAAM,yBAAyB,YAAY;AAEzEC,wBAAA;AAAA,IACI;AAAA,IACA;AAAA,MACI,OAAO,CAAC,SAAS;AACP,cAAA,UAAUC,yBAAAA,SAAS,KAAK,GAAG;AAC3B,cAAA,UAAU,aAAa,OAAO;AACpC,YAAI,CAAC,SAAS;AACV,gBAAM,IAAI;AAAA,YACN,oDAAoD,OAAO;AAAA,UAC/D;AAAA,QAAA;AAEJ,2BAAmB,MAAM,OAAO;AAAA,MAAA;AAAA,IAExC;AAAA,IACA,EAAE,MAAM,sBAAsB;AAAA,EAClC;AACJ;ACrCa,MAAA,kCAIT,SAAS,iCAAiC,SAAS;AACnD,QAAM,EAAE,eAAe,GAAG,IAAI,WAAW,CAAC;AACpC,QAAA,wBAAwBF,sBAAAA,MAAM,yBAAyB,YAAY;AAEzE,SAAO,CAAC,SAAS;AACb,QAAI,OAAO,KAAK,YAAY,EAAE,WAAW,GAAG;AAChC,cAAA;AAAA,QACJ;AAAA,MACJ;AAAA,IAAA;AAGJC,0BAAA;AAAA,MACI;AAAA,MACA;AAAA,QACI,OAAO,CAAC,SAAS;AACP,gBAAA,UAAUC,yBAAAA,SAAS,KAAK,GAAG;AAC3B,gBAAA,UAAU,aAAa,OAAO;AACpC,cAAI,CAAC,SAAS;AACV,kBAAM,IAAI;AAAA,cACN,oDAAoD,OAAO;AAAA,YAC/D;AAAA,UAAA;AAEJ,6BAAmB,MAAM,OAAO;AAAA,QAAA;AAAA,MAExC;AAAA,MACA,EAAE,MAAM,sBAAsB;AAAA,IAClC;AAAA,EACJ;AACJ;;;;"} \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-util-environments/index.d.ts b/node_modules/@unified-latex/unified-latex-util-environments/index.d.ts new file mode 100644 index 0000000..8123fb2 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-util-environments/index.d.ts @@ -0,0 +1,31 @@ +import * as Ast from '@unified-latex/unified-latex-types'; +import { EnvInfo } from '@unified-latex/unified-latex-types'; +import { EnvInfoRecord } from '@unified-latex/unified-latex-types'; +import { Plugin as Plugin_2 } from 'unified'; + +declare type PluginOptions = { + environments: EnvInfoRecord; +} | undefined; + +/** + * Performs any needed processing on the environment (as specified by `envInfo`) + * including attaching arguments and possibly manipulating the environment's body. + */ +export declare function processEnvironment(envNode: Ast.Environment, envInfo: EnvInfo): void; + +/** + * Recursively search for and process the specified environments. Arguments are + * consumed according to the `signature` specified. The body is processed + * with the specified `processContent` function (if given). Any specified `renderInfo` + * is attached to the environment node. + */ +export declare function processEnvironments(tree: Ast.Ast, environments: EnvInfoRecord): void; + +/** + * Unified plugin to process environment content and attach arguments. + * + * @param environments An object whose keys are environment names and values contains information about the environment and its argument signature. + */ +export declare const unifiedLatexProcessEnvironments: Plugin_2; + +export { } diff --git a/node_modules/@unified-latex/unified-latex-util-environments/index.js b/node_modules/@unified-latex/unified-latex-util-environments/index.js new file mode 100644 index 0000000..31908b1 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-util-environments/index.js @@ -0,0 +1,67 @@ +import { updateRenderInfo } from "@unified-latex/unified-latex-util-render-info"; +import { gobbleArguments } from "@unified-latex/unified-latex-util-arguments"; +import { match } from "@unified-latex/unified-latex-util-match"; +import { visit } from "@unified-latex/unified-latex-util-visit"; +import { printRaw } from "@unified-latex/unified-latex-util-print-raw"; +function processEnvironment(envNode, envInfo) { + if (envInfo.signature && envNode.args == null) { + const { args } = gobbleArguments(envNode.content, envInfo.signature); + envNode.args = args; + } + updateRenderInfo(envNode, envInfo.renderInfo); + if (typeof envInfo.processContent === "function") { + envNode.content = envInfo.processContent(envNode.content); + } +} +function processEnvironments(tree, environments) { + const isRelevantEnvironment = match.createEnvironmentMatcher(environments); + visit( + tree, + { + leave: (node) => { + const envName = printRaw(node.env); + const envInfo = environments[envName]; + if (!envInfo) { + throw new Error( + `Could not find environment info for environment "${envName}"` + ); + } + processEnvironment(node, envInfo); + } + }, + { test: isRelevantEnvironment } + ); +} +const unifiedLatexProcessEnvironments = function unifiedLatexAttachMacroArguments(options) { + const { environments = {} } = options || {}; + const isRelevantEnvironment = match.createEnvironmentMatcher(environments); + return (tree) => { + if (Object.keys(environments).length === 0) { + console.warn( + "Attempting to attach macro arguments but no macros are specified." + ); + } + visit( + tree, + { + leave: (node) => { + const envName = printRaw(node.env); + const envInfo = environments[envName]; + if (!envInfo) { + throw new Error( + `Could not find environment info for environment "${envName}"` + ); + } + processEnvironment(node, envInfo); + } + }, + { test: isRelevantEnvironment } + ); + }; +}; +export { + processEnvironment, + processEnvironments, + unifiedLatexProcessEnvironments +}; +//# sourceMappingURL=index.js.map diff --git a/node_modules/@unified-latex/unified-latex-util-environments/index.js.map b/node_modules/@unified-latex/unified-latex-util-environments/index.js.map new file mode 100644 index 0000000..80dcb77 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-util-environments/index.js.map @@ -0,0 +1 @@ +{"version":3,"file":"index.js","sources":["../libs/process-environment.ts","../libs/unified-latex-process-environment.ts"],"sourcesContent":["import * as Ast from \"@unified-latex/unified-latex-types\";\nimport { EnvInfo, EnvInfoRecord } from \"@unified-latex/unified-latex-types\";\nimport { updateRenderInfo } from \"@unified-latex/unified-latex-util-render-info\";\nimport { gobbleArguments } from \"@unified-latex/unified-latex-util-arguments\";\nimport { match } from \"@unified-latex/unified-latex-util-match\";\nimport { visit } from \"@unified-latex/unified-latex-util-visit\";\nimport { printRaw } from \"@unified-latex/unified-latex-util-print-raw\";\n\n/**\n * Performs any needed processing on the environment (as specified by `envInfo`)\n * including attaching arguments and possibly manipulating the environment's body.\n */\nexport function processEnvironment(envNode: Ast.Environment, envInfo: EnvInfo) {\n if (envInfo.signature && envNode.args == null) {\n const { args } = gobbleArguments(envNode.content, envInfo.signature);\n envNode.args = args;\n }\n\n updateRenderInfo(envNode, envInfo.renderInfo);\n if (typeof envInfo.processContent === \"function\") {\n envNode.content = envInfo.processContent(envNode.content);\n }\n}\n\n/**\n * Recursively search for and process the specified environments. Arguments are\n * consumed according to the `signature` specified. The body is processed\n * with the specified `processContent` function (if given). Any specified `renderInfo`\n * is attached to the environment node.\n */\nexport function processEnvironments(\n tree: Ast.Ast,\n environments: EnvInfoRecord\n) {\n const isRelevantEnvironment = match.createEnvironmentMatcher(environments);\n\n visit(\n tree,\n {\n leave: (node) => {\n const envName = printRaw(node.env);\n const envInfo = environments[envName];\n if (!envInfo) {\n throw new Error(\n `Could not find environment info for environment \"${envName}\"`\n );\n }\n processEnvironment(node, envInfo);\n },\n },\n { test: isRelevantEnvironment }\n );\n}\n","import * as Ast from \"@unified-latex/unified-latex-types\";\nimport { EnvInfoRecord } from \"@unified-latex/unified-latex-types\";\nimport { Plugin } from \"unified\";\nimport { visit } from \"@unified-latex/unified-latex-util-visit\";\nimport { match } from \"@unified-latex/unified-latex-util-match\";\nimport { processEnvironment } from \"./process-environment\";\nimport { printRaw } from \"@unified-latex/unified-latex-util-print-raw\";\n\ntype PluginOptions = { environments: EnvInfoRecord } | undefined;\n\n/**\n * Unified plugin to process environment content and attach arguments.\n *\n * @param environments An object whose keys are environment names and values contains information about the environment and its argument signature.\n */\nexport const unifiedLatexProcessEnvironments: Plugin<\n PluginOptions[],\n Ast.Root,\n Ast.Root\n> = function unifiedLatexAttachMacroArguments(options) {\n const { environments = {} } = options || {};\n const isRelevantEnvironment = match.createEnvironmentMatcher(environments);\n\n return (tree) => {\n if (Object.keys(environments).length === 0) {\n console.warn(\n \"Attempting to attach macro arguments but no macros are specified.\"\n );\n }\n\n visit(\n tree,\n {\n leave: (node) => {\n const envName = printRaw(node.env);\n const envInfo = environments[envName];\n if (!envInfo) {\n throw new Error(\n `Could not find environment info for environment \"${envName}\"`\n );\n }\n processEnvironment(node, envInfo);\n },\n },\n { test: isRelevantEnvironment }\n );\n };\n};\n"],"names":[],"mappings":";;;;;AAYgB,SAAA,mBAAmB,SAA0B,SAAkB;AAC3E,MAAI,QAAQ,aAAa,QAAQ,QAAQ,MAAM;AAC3C,UAAM,EAAE,KAAK,IAAI,gBAAgB,QAAQ,SAAS,QAAQ,SAAS;AACnE,YAAQ,OAAO;AAAA,EAAA;AAGF,mBAAA,SAAS,QAAQ,UAAU;AACxC,MAAA,OAAO,QAAQ,mBAAmB,YAAY;AAC9C,YAAQ,UAAU,QAAQ,eAAe,QAAQ,OAAO;AAAA,EAAA;AAEhE;AAQgB,SAAA,oBACZ,MACA,cACF;AACQ,QAAA,wBAAwB,MAAM,yBAAyB,YAAY;AAEzE;AAAA,IACI;AAAA,IACA;AAAA,MACI,OAAO,CAAC,SAAS;AACP,cAAA,UAAU,SAAS,KAAK,GAAG;AAC3B,cAAA,UAAU,aAAa,OAAO;AACpC,YAAI,CAAC,SAAS;AACV,gBAAM,IAAI;AAAA,YACN,oDAAoD,OAAO;AAAA,UAC/D;AAAA,QAAA;AAEJ,2BAAmB,MAAM,OAAO;AAAA,MAAA;AAAA,IAExC;AAAA,IACA,EAAE,MAAM,sBAAsB;AAAA,EAClC;AACJ;ACrCa,MAAA,kCAIT,SAAS,iCAAiC,SAAS;AACnD,QAAM,EAAE,eAAe,GAAG,IAAI,WAAW,CAAC;AACpC,QAAA,wBAAwB,MAAM,yBAAyB,YAAY;AAEzE,SAAO,CAAC,SAAS;AACb,QAAI,OAAO,KAAK,YAAY,EAAE,WAAW,GAAG;AAChC,cAAA;AAAA,QACJ;AAAA,MACJ;AAAA,IAAA;AAGJ;AAAA,MACI;AAAA,MACA;AAAA,QACI,OAAO,CAAC,SAAS;AACP,gBAAA,UAAU,SAAS,KAAK,GAAG;AAC3B,gBAAA,UAAU,aAAa,OAAO;AACpC,cAAI,CAAC,SAAS;AACV,kBAAM,IAAI;AAAA,cACN,oDAAoD,OAAO;AAAA,YAC/D;AAAA,UAAA;AAEJ,6BAAmB,MAAM,OAAO;AAAA,QAAA;AAAA,MAExC;AAAA,MACA,EAAE,MAAM,sBAAsB;AAAA,IAClC;AAAA,EACJ;AACJ;"} \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-util-environments/package.json b/node_modules/@unified-latex/unified-latex-util-environments/package.json new file mode 100644 index 0000000..54c5d4b --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-util-environments/package.json @@ -0,0 +1,57 @@ +{ + "name": "@unified-latex/unified-latex-util-environments", + "version": "1.8.2", + "description": "Tools for manipulating unified-latex ASTs", + "main": "index.js", + "type": "module", + "dependencies": { + "@unified-latex/unified-latex-types": "^1.8.0", + "@unified-latex/unified-latex-util-arguments": "^1.8.2", + "@unified-latex/unified-latex-util-match": "^1.8.0", + "@unified-latex/unified-latex-util-print-raw": "^1.8.0", + "@unified-latex/unified-latex-util-render-info": "^1.8.2", + "@unified-latex/unified-latex-util-visit": "^1.8.2", + "unified": "^10.1.2" + }, + "repository": { + "type": "git", + "url": "git+https://github.com/siefkenj/unified-latex.git" + }, + "keywords": [ + "pegjs", + "latex", + "parser", + "prettier", + "unified-latex", + "unified" + ], + "author": "Jason Siefken", + "license": "MIT", + "bugs": { + "url": "https://github.com/siefkenj/unified-latex/issues" + }, + "homepage": "https://github.com/siefkenj/unified-latex#readme", + "exports": { + ".": { + "import": "./index.js", + "require": "./index.cjs", + "types": "./index.d.ts" + }, + "./*js": "./*js", + "./*": { + "import": "./*/index.js", + "require": "./*/index.cjs", + "types": "./*/index.d.ts" + }, + "./*/index": { + "import": "./*/index.js", + "require": "./*/index.cjs" + } + }, + "files": [ + "**/*ts", + "**/*js", + "**/*.map", + "**/*.json" + ] +} \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-util-match/README.md b/node_modules/@unified-latex/unified-latex-util-match/README.md new file mode 100644 index 0000000..df4a426 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-util-match/README.md @@ -0,0 +1,28 @@ + + + + +# unified-latex-util-match + +## What is this? + +Functions to match different `Ast.Node` types in a `unified-latex` Abstract Syntax Tree (AST). + +## When should I use this? + +If you need a type-guard to ensure a node is of a certain type; for example, during a call to `unified-latex-until-visit`. + +## Install + +```bash +npm install @unified-latex/unified-latex-util-match +``` + +This package contains both esm and commonjs exports. To explicitly access the esm export, +import the `.js` file. To explicitly access the commonjs export, import the `.cjs` file. + +# Constants + +| Name | Type | Description | +| :------ | :---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :------------------------------------------- | +| `match` | `{ macro(node: any, macroName?: string): node is Ast.Macro; anyMacro(node: any): node is Ast.Macro; environment(node: any, envName?: string): node is Ast.Environment; ... 12 more ...; createEnvironmentMatcher: (macros: string[] \| Record) => Ast.TypeGuard; }` | Functions to match different types of nodes. | diff --git a/node_modules/@unified-latex/unified-latex-util-match/index.cjs b/node_modules/@unified-latex/unified-latex-util-match/index.cjs new file mode 100644 index 0000000..f3ba43d --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-util-match/index.cjs @@ -0,0 +1,169 @@ +"use strict"; +Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" }); +const unifiedLatexUtilPrintRaw = require("@unified-latex/unified-latex-util-print-raw"); +function createMacroMatcher(macros) { + const macrosHash = Array.isArray(macros) ? macros.length > 0 ? typeof macros[0] === "string" ? Object.fromEntries( + macros.map((macro2) => { + if (typeof macro2 !== "string") { + throw new Error("Wrong branch of map function"); + } + return [macro2, {}]; + }) + ) : Object.fromEntries( + macros.map((macro2) => { + if (typeof macro2 === "string") { + throw new Error("Wrong branch of map function"); + } + if (macro2.escapeToken != null) { + return [ + macro2.content, + { escapeToken: macro2.escapeToken } + ]; + } + return [macro2.content, {}]; + }) + ) : {} : macros; + return function matchAgainstMacros(node) { + if (node == null || node.type !== "macro") { + return false; + } + const spec = macrosHash[node.content]; + if (!spec) { + return false; + } + if (typeof spec === "object" && "escapeToken" in spec) { + return spec.escapeToken == null || spec.escapeToken === node.escapeToken; + } + return true; + }; +} +function createEnvironmentMatcher(macros) { + const environmentsHash = Array.isArray(macros) ? Object.fromEntries( + macros.map((str) => { + return [str, {}]; + }) + ) : macros; + return function matchAgainstEnvironments(node) { + if (!match.anyEnvironment(node)) { + return false; + } + const envName = unifiedLatexUtilPrintRaw.printRaw(node.env); + const spec = environmentsHash[envName]; + if (!spec) { + return false; + } + return true; + }; +} +const match = { + macro(node, macroName) { + if (node == null) { + return false; + } + return node.type === "macro" && (macroName == null || node.content === macroName); + }, + anyMacro(node) { + return match.macro(node); + }, + environment(node, envName) { + if (node == null) { + return false; + } + return (node.type === "environment" || node.type === "mathenv") && (envName == null || unifiedLatexUtilPrintRaw.printRaw(node.env) === envName); + }, + anyEnvironment(node) { + return match.environment(node); + }, + comment(node) { + if (node == null) { + return false; + } + return node.type === "comment"; + }, + parbreak(node) { + if (node == null) { + return false; + } + return node.type === "parbreak"; + }, + whitespace(node) { + if (node == null) { + return false; + } + return node.type === "whitespace"; + }, + /** + * Matches whitespace or a comment with leading whitespace. + */ + whitespaceLike(node) { + if (node == null) { + return false; + } + return node.type === "whitespace" || node.type === "whitespace" && node.leadingWhitespace === true; + }, + string(node, value) { + if (node == null) { + return false; + } + return node.type === "string" && (value == null || node.content === value); + }, + anyString(node) { + return match.string(node); + }, + group(node) { + if (node == null) { + return false; + } + return node.type === "group"; + }, + argument(node) { + if (node == null) { + return false; + } + return node.type === "argument"; + }, + blankArgument(node) { + if (!match.argument(node)) { + return false; + } + return node.openMark === "" && node.closeMark === "" && node.content.length === 0; + }, + math(node) { + if (node == null) { + return false; + } + return node.type === "displaymath" || node.type === "inlinemath"; + }, + createMacroMatcher, + createEnvironmentMatcher +}; +const { + anyEnvironment, + anyMacro, + anyString, + argument, + blankArgument, + comment, + environment, + group, + macro, + math, + parbreak, + string, + whitespace +} = match; +exports.anyEnvironment = anyEnvironment; +exports.anyMacro = anyMacro; +exports.anyString = anyString; +exports.argument = argument; +exports.blankArgument = blankArgument; +exports.comment = comment; +exports.environment = environment; +exports.group = group; +exports.macro = macro; +exports.match = match; +exports.math = math; +exports.parbreak = parbreak; +exports.string = string; +exports.whitespace = whitespace; +//# sourceMappingURL=index.cjs.map diff --git a/node_modules/@unified-latex/unified-latex-util-match/index.cjs.map b/node_modules/@unified-latex/unified-latex-util-match/index.cjs.map new file mode 100644 index 0000000..5d1500c --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-util-match/index.cjs.map @@ -0,0 +1 @@ +{"version":3,"file":"index.cjs","sources":["../libs/match.ts"],"sourcesContent":["import * as Ast from \"@unified-latex/unified-latex-types\";\nimport {\n EnvInfo,\n MacroInfo,\n MacroInfoRecord,\n} from \"@unified-latex/unified-latex-types\";\nimport { printRaw } from \"@unified-latex/unified-latex-util-print-raw\";\n\n/**\n * Creates a macro matching function that uses a `SpecialMacroSpec` or list of macros\n * and generates a hash for quick lookup.\n */\nfunction createMacroMatcher(\n macros: Ast.Macro[] | S[] | Record\n) {\n // We first make sure we have a record type with keys being the macro's contents\n const macrosHash: Record = Array.isArray(macros)\n ? macros.length > 0\n ? typeof macros[0] === \"string\"\n ? Object.fromEntries(\n macros.map((macro) => {\n if (typeof macro !== \"string\") {\n throw new Error(\"Wrong branch of map function\");\n }\n return [macro, {}] as [string, MacroInfo];\n })\n )\n : Object.fromEntries(\n macros.map((macro) => {\n if (typeof macro === \"string\") {\n throw new Error(\"Wrong branch of map function\");\n }\n if (macro.escapeToken != null) {\n return [\n macro.content,\n { escapeToken: macro.escapeToken },\n ] as [string, MacroInfo];\n }\n return [macro.content, {}] as [string, MacroInfo];\n })\n )\n : {}\n : macros;\n\n return function matchAgainstMacros(node: any | Ast.Macro) {\n if (node == null || node.type !== \"macro\") {\n return false;\n }\n // At this point we have a macro type\n const spec = macrosHash[node.content];\n if (!spec) {\n return false;\n }\n\n if (typeof spec === \"object\" && \"escapeToken\" in spec) {\n return (\n (spec as MacroInfoRecord).escapeToken == null ||\n (spec as MacroInfoRecord).escapeToken === node.escapeToken\n );\n }\n return true;\n } as Ast.TypeGuard;\n}\n\n/**\n * Creates a macro matching function that uses a `SpecialMacroSpec` or list of macros\n * and generates a hash for quick lookup.\n */\nfunction createEnvironmentMatcher(macros: string[] | Record) {\n // We first make sure we have a record type with keys being the macro's contents\n const environmentsHash = Array.isArray(macros)\n ? Object.fromEntries(\n macros.map((str) => {\n return [str, {}] as [string, EnvInfo];\n })\n )\n : macros;\n\n return function matchAgainstEnvironments(node: any | Ast.Environment) {\n if (!match.anyEnvironment(node)) {\n return false;\n }\n // At this point we have an environment type\n const envName = printRaw(node.env);\n const spec = environmentsHash[envName];\n if (!spec) {\n return false;\n }\n\n return true;\n } as Ast.TypeGuard;\n}\n\n/**\n * Functions to match different types of nodes.\n */\nexport const match = {\n macro(node: any, macroName?: string): node is Ast.Macro {\n if (node == null) {\n return false;\n }\n return (\n node.type === \"macro\" &&\n (macroName == null || node.content === macroName)\n );\n },\n anyMacro(node: any): node is Ast.Macro {\n return match.macro(node);\n },\n environment(node: any, envName?: string): node is Ast.Environment {\n if (node == null) {\n return false;\n }\n return (\n (node.type === \"environment\" || node.type === \"mathenv\") &&\n (envName == null || printRaw(node.env) === envName)\n );\n },\n anyEnvironment(node: any): node is Ast.Environment {\n return match.environment(node);\n },\n comment(node: any): node is Ast.Comment {\n if (node == null) {\n return false;\n }\n return node.type === \"comment\";\n },\n parbreak(node: any): node is Ast.Parbreak {\n if (node == null) {\n return false;\n }\n return node.type === \"parbreak\";\n },\n whitespace(node: any): node is Ast.Whitespace {\n if (node == null) {\n return false;\n }\n return node.type === \"whitespace\";\n },\n /**\n * Matches whitespace or a comment with leading whitespace.\n */\n whitespaceLike(\n node: any\n ): node is Ast.Whitespace | (Ast.Comment & { leadingWhitespace: true }) {\n if (node == null) {\n return false;\n }\n return (\n node.type === \"whitespace\" ||\n (node.type === \"whitespace\" && node.leadingWhitespace === true)\n );\n },\n string(node: any, value?: string): node is Ast.String {\n if (node == null) {\n return false;\n }\n return (\n node.type === \"string\" && (value == null || node.content === value)\n );\n },\n anyString(node: any): node is Ast.String {\n return match.string(node);\n },\n group(node: any): node is Ast.Group {\n if (node == null) {\n return false;\n }\n return node.type === \"group\";\n },\n argument(node: any): node is Ast.Argument {\n if (node == null) {\n return false;\n }\n return node.type === \"argument\";\n },\n blankArgument(node: any): boolean {\n if (!match.argument(node)) {\n return false;\n }\n return (\n node.openMark === \"\" &&\n node.closeMark === \"\" &&\n node.content.length === 0\n );\n },\n math(node: any): node is Ast.DisplayMath | Ast.InlineMath {\n if (node == null) {\n return false;\n }\n return node.type === \"displaymath\" || node.type === \"inlinemath\";\n },\n createMacroMatcher,\n createEnvironmentMatcher,\n};\n\nexport const {\n anyEnvironment,\n anyMacro,\n anyString,\n argument,\n blankArgument,\n comment,\n environment,\n group,\n macro,\n math,\n parbreak,\n string,\n whitespace,\n} = match;\n"],"names":["macro","printRaw"],"mappings":"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"} \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-util-match/index.d.ts b/node_modules/@unified-latex/unified-latex-util-match/index.d.ts new file mode 100644 index 0000000..475c1eb --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-util-match/index.d.ts @@ -0,0 +1,70 @@ +import * as Ast from '@unified-latex/unified-latex-types'; + +export declare const anyEnvironment: (node: any) => node is Ast.Environment; + +export declare const anyMacro: (node: any) => node is Ast.Macro; + +export declare const anyString: (node: any) => node is Ast.String; + +export declare const argument: (node: any) => node is Ast.Argument; + +export declare const blankArgument: (node: any) => boolean; + +export declare const comment: (node: any) => node is Ast.Comment; + +/** + * Creates a macro matching function that uses a `SpecialMacroSpec` or list of macros + * and generates a hash for quick lookup. + */ +declare function createEnvironmentMatcher(macros: string[] | Record): Ast.TypeGuard; + +/** + * Creates a macro matching function that uses a `SpecialMacroSpec` or list of macros + * and generates a hash for quick lookup. + */ +declare function createMacroMatcher(macros: Ast.Macro[] | S[] | Record): Ast.TypeGuard; + +export declare const environment: (node: any, envName?: string) => node is Ast.Environment; + +export declare const group: (node: any) => node is Ast.Group; + +export declare const macro: (node: any, macroName?: string) => node is Ast.Macro; + +/** + * Functions to match different types of nodes. + */ +export declare const match: { + macro(node: any, macroName?: string): node is Ast.Macro; + anyMacro(node: any): node is Ast.Macro; + environment(node: any, envName?: string): node is Ast.Environment; + anyEnvironment(node: any): node is Ast.Environment; + comment(node: any): node is Ast.Comment; + parbreak(node: any): node is Ast.Parbreak; + whitespace(node: any): node is Ast.Whitespace; + /** + * Matches whitespace or a comment with leading whitespace. + */ + whitespaceLike(node: any): node is Ast.Whitespace | (Ast.Comment & { + leadingWhitespace: true; + }); + string(node: any, value?: string): node is Ast.String; + anyString(node: any): node is Ast.String; + group(node: any): node is Ast.Group; + argument(node: any): node is Ast.Argument; + blankArgument(node: any): boolean; + math(node: any): node is Ast.DisplayMath | Ast.InlineMath; + createMacroMatcher: typeof createMacroMatcher; + createEnvironmentMatcher: typeof createEnvironmentMatcher; +}; + +export declare const math: (node: any) => node is Ast.DisplayMath | Ast.InlineMath; + +export declare const parbreak: (node: any) => node is Ast.Parbreak; + +export declare const string: (node: any, value?: string) => node is Ast.String; + +export declare const whitespace: (node: any) => node is Ast.Whitespace; + +export { } diff --git a/node_modules/@unified-latex/unified-latex-util-match/index.js b/node_modules/@unified-latex/unified-latex-util-match/index.js new file mode 100644 index 0000000..afcd83b --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-util-match/index.js @@ -0,0 +1,169 @@ +import { printRaw } from "@unified-latex/unified-latex-util-print-raw"; +function createMacroMatcher(macros) { + const macrosHash = Array.isArray(macros) ? macros.length > 0 ? typeof macros[0] === "string" ? Object.fromEntries( + macros.map((macro2) => { + if (typeof macro2 !== "string") { + throw new Error("Wrong branch of map function"); + } + return [macro2, {}]; + }) + ) : Object.fromEntries( + macros.map((macro2) => { + if (typeof macro2 === "string") { + throw new Error("Wrong branch of map function"); + } + if (macro2.escapeToken != null) { + return [ + macro2.content, + { escapeToken: macro2.escapeToken } + ]; + } + return [macro2.content, {}]; + }) + ) : {} : macros; + return function matchAgainstMacros(node) { + if (node == null || node.type !== "macro") { + return false; + } + const spec = macrosHash[node.content]; + if (!spec) { + return false; + } + if (typeof spec === "object" && "escapeToken" in spec) { + return spec.escapeToken == null || spec.escapeToken === node.escapeToken; + } + return true; + }; +} +function createEnvironmentMatcher(macros) { + const environmentsHash = Array.isArray(macros) ? Object.fromEntries( + macros.map((str) => { + return [str, {}]; + }) + ) : macros; + return function matchAgainstEnvironments(node) { + if (!match.anyEnvironment(node)) { + return false; + } + const envName = printRaw(node.env); + const spec = environmentsHash[envName]; + if (!spec) { + return false; + } + return true; + }; +} +const match = { + macro(node, macroName) { + if (node == null) { + return false; + } + return node.type === "macro" && (macroName == null || node.content === macroName); + }, + anyMacro(node) { + return match.macro(node); + }, + environment(node, envName) { + if (node == null) { + return false; + } + return (node.type === "environment" || node.type === "mathenv") && (envName == null || printRaw(node.env) === envName); + }, + anyEnvironment(node) { + return match.environment(node); + }, + comment(node) { + if (node == null) { + return false; + } + return node.type === "comment"; + }, + parbreak(node) { + if (node == null) { + return false; + } + return node.type === "parbreak"; + }, + whitespace(node) { + if (node == null) { + return false; + } + return node.type === "whitespace"; + }, + /** + * Matches whitespace or a comment with leading whitespace. + */ + whitespaceLike(node) { + if (node == null) { + return false; + } + return node.type === "whitespace" || node.type === "whitespace" && node.leadingWhitespace === true; + }, + string(node, value) { + if (node == null) { + return false; + } + return node.type === "string" && (value == null || node.content === value); + }, + anyString(node) { + return match.string(node); + }, + group(node) { + if (node == null) { + return false; + } + return node.type === "group"; + }, + argument(node) { + if (node == null) { + return false; + } + return node.type === "argument"; + }, + blankArgument(node) { + if (!match.argument(node)) { + return false; + } + return node.openMark === "" && node.closeMark === "" && node.content.length === 0; + }, + math(node) { + if (node == null) { + return false; + } + return node.type === "displaymath" || node.type === "inlinemath"; + }, + createMacroMatcher, + createEnvironmentMatcher +}; +const { + anyEnvironment, + anyMacro, + anyString, + argument, + blankArgument, + comment, + environment, + group, + macro, + math, + parbreak, + string, + whitespace +} = match; +export { + anyEnvironment, + anyMacro, + anyString, + argument, + blankArgument, + comment, + environment, + group, + macro, + match, + math, + parbreak, + string, + whitespace +}; +//# sourceMappingURL=index.js.map diff --git a/node_modules/@unified-latex/unified-latex-util-match/index.js.map b/node_modules/@unified-latex/unified-latex-util-match/index.js.map new file mode 100644 index 0000000..6a8127d --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-util-match/index.js.map @@ -0,0 +1 @@ +{"version":3,"file":"index.js","sources":["../libs/match.ts"],"sourcesContent":["import * as Ast from \"@unified-latex/unified-latex-types\";\nimport {\n EnvInfo,\n MacroInfo,\n MacroInfoRecord,\n} from \"@unified-latex/unified-latex-types\";\nimport { printRaw } from \"@unified-latex/unified-latex-util-print-raw\";\n\n/**\n * Creates a macro matching function that uses a `SpecialMacroSpec` or list of macros\n * and generates a hash for quick lookup.\n */\nfunction createMacroMatcher(\n macros: Ast.Macro[] | S[] | Record\n) {\n // We first make sure we have a record type with keys being the macro's contents\n const macrosHash: Record = Array.isArray(macros)\n ? macros.length > 0\n ? typeof macros[0] === \"string\"\n ? Object.fromEntries(\n macros.map((macro) => {\n if (typeof macro !== \"string\") {\n throw new Error(\"Wrong branch of map function\");\n }\n return [macro, {}] as [string, MacroInfo];\n })\n )\n : Object.fromEntries(\n macros.map((macro) => {\n if (typeof macro === \"string\") {\n throw new Error(\"Wrong branch of map function\");\n }\n if (macro.escapeToken != null) {\n return [\n macro.content,\n { escapeToken: macro.escapeToken },\n ] as [string, MacroInfo];\n }\n return [macro.content, {}] as [string, MacroInfo];\n })\n )\n : {}\n : macros;\n\n return function matchAgainstMacros(node: any | Ast.Macro) {\n if (node == null || node.type !== \"macro\") {\n return false;\n }\n // At this point we have a macro type\n const spec = macrosHash[node.content];\n if (!spec) {\n return false;\n }\n\n if (typeof spec === \"object\" && \"escapeToken\" in spec) {\n return (\n (spec as MacroInfoRecord).escapeToken == null ||\n (spec as MacroInfoRecord).escapeToken === node.escapeToken\n );\n }\n return true;\n } as Ast.TypeGuard;\n}\n\n/**\n * Creates a macro matching function that uses a `SpecialMacroSpec` or list of macros\n * and generates a hash for quick lookup.\n */\nfunction createEnvironmentMatcher(macros: string[] | Record) {\n // We first make sure we have a record type with keys being the macro's contents\n const environmentsHash = Array.isArray(macros)\n ? Object.fromEntries(\n macros.map((str) => {\n return [str, {}] as [string, EnvInfo];\n })\n )\n : macros;\n\n return function matchAgainstEnvironments(node: any | Ast.Environment) {\n if (!match.anyEnvironment(node)) {\n return false;\n }\n // At this point we have an environment type\n const envName = printRaw(node.env);\n const spec = environmentsHash[envName];\n if (!spec) {\n return false;\n }\n\n return true;\n } as Ast.TypeGuard;\n}\n\n/**\n * Functions to match different types of nodes.\n */\nexport const match = {\n macro(node: any, macroName?: string): node is Ast.Macro {\n if (node == null) {\n return false;\n }\n return (\n node.type === \"macro\" &&\n (macroName == null || node.content === macroName)\n );\n },\n anyMacro(node: any): node is Ast.Macro {\n return match.macro(node);\n },\n environment(node: any, envName?: string): node is Ast.Environment {\n if (node == null) {\n return false;\n }\n return (\n (node.type === \"environment\" || node.type === \"mathenv\") &&\n (envName == null || printRaw(node.env) === envName)\n );\n },\n anyEnvironment(node: any): node is Ast.Environment {\n return match.environment(node);\n },\n comment(node: any): node is Ast.Comment {\n if (node == null) {\n return false;\n }\n return node.type === \"comment\";\n },\n parbreak(node: any): node is Ast.Parbreak {\n if (node == null) {\n return false;\n }\n return node.type === \"parbreak\";\n },\n whitespace(node: any): node is Ast.Whitespace {\n if (node == null) {\n return false;\n }\n return node.type === \"whitespace\";\n },\n /**\n * Matches whitespace or a comment with leading whitespace.\n */\n whitespaceLike(\n node: any\n ): node is Ast.Whitespace | (Ast.Comment & { leadingWhitespace: true }) {\n if (node == null) {\n return false;\n }\n return (\n node.type === \"whitespace\" ||\n (node.type === \"whitespace\" && node.leadingWhitespace === true)\n );\n },\n string(node: any, value?: string): node is Ast.String {\n if (node == null) {\n return false;\n }\n return (\n node.type === \"string\" && (value == null || node.content === value)\n );\n },\n anyString(node: any): node is Ast.String {\n return match.string(node);\n },\n group(node: any): node is Ast.Group {\n if (node == null) {\n return false;\n }\n return node.type === \"group\";\n },\n argument(node: any): node is Ast.Argument {\n if (node == null) {\n return false;\n }\n return node.type === \"argument\";\n },\n blankArgument(node: any): boolean {\n if (!match.argument(node)) {\n return false;\n }\n return (\n node.openMark === \"\" &&\n node.closeMark === \"\" &&\n node.content.length === 0\n );\n },\n math(node: any): node is Ast.DisplayMath | Ast.InlineMath {\n if (node == null) {\n return false;\n }\n return node.type === \"displaymath\" || node.type === \"inlinemath\";\n },\n createMacroMatcher,\n createEnvironmentMatcher,\n};\n\nexport const {\n anyEnvironment,\n anyMacro,\n anyString,\n argument,\n blankArgument,\n comment,\n environment,\n group,\n macro,\n math,\n parbreak,\n string,\n whitespace,\n} = match;\n"],"names":["macro"],"mappings":"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"} \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-util-match/package.json b/node_modules/@unified-latex/unified-latex-util-match/package.json new file mode 100644 index 0000000..9d07d50 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-util-match/package.json @@ -0,0 +1,52 @@ +{ + "name": "@unified-latex/unified-latex-util-match", + "version": "1.8.0", + "description": "Match nodes in a unified-latex AST", + "main": "index.js", + "type": "module", + "dependencies": { + "@unified-latex/unified-latex-types": "^1.8.0", + "@unified-latex/unified-latex-util-print-raw": "^1.8.0" + }, + "repository": { + "type": "git", + "url": "git+https://github.com/siefkenj/unified-latex.git" + }, + "keywords": [ + "pegjs", + "latex", + "parser", + "prettier", + "unified-latex", + "unified" + ], + "author": "Jason Siefken", + "license": "MIT", + "bugs": { + "url": "https://github.com/siefkenj/unified-latex/issues" + }, + "homepage": "https://github.com/siefkenj/unified-latex#readme", + "exports": { + ".": { + "import": "./index.js", + "require": "./index.cjs", + "types": "./index.d.ts" + }, + "./*js": "./*js", + "./*": { + "import": "./*/index.js", + "require": "./*/index.cjs", + "types": "./*/index.d.ts" + }, + "./*/index": { + "import": "./*/index.js", + "require": "./*/index.cjs" + } + }, + "files": [ + "**/*ts", + "**/*js", + "**/*.map", + "**/*.json" + ] +} \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-util-parse/README.md b/node_modules/@unified-latex/unified-latex-util-parse/README.md new file mode 100644 index 0000000..5fadbb8 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-util-parse/README.md @@ -0,0 +1,317 @@ + + + + +# unified-latex-util-parse + +## What is this? + +Functions parse strings to a `unified-latex` Abstract Syntax Tree (AST). + +## When should I use this? + +If you have a string that you would like to parse to a `unified-latex` `Ast.Ast`, or +if you are building a plugin for `unified()` that manipulates LaTeX. + +## Install + +```bash +npm install @unified-latex/unified-latex-util-parse +``` + +This package contains both esm and commonjs exports. To explicitly access the esm export, +import the `.js` file. To explicitly access the commonjs export, import the `.cjs` file. + +# Plugins + +## `unifiedLatexAstComplier` + +Unified complier plugin that passes through a LaTeX AST without modification. + +### Usage + +`unified().use(unifiedLatexAstComplier)` + +### Type + +`Plugin` + +```typescript +function unifiedLatexAstComplier(): void; +``` + +## `unifiedLatexFromString` + +Parse a string to a LaTeX AST. + +### Usage + +`unified().use(unifiedLatexFromString[, options])` + +#### options + +```typescript +{ mode?: "math" | "regular"; macros?: MacroInfoRecord; environments?: EnvInfoRecord; flags?: { atLetter?: boolean; expl3?: boolean; autodetectExpl3AndAtLetter?: boolean; }; } +``` + +### Type + +`Plugin<{ mode?: "math" | "regular"; macros?: MacroInfoRecord; environments?: EnvInfoRecord; flags?: { atLetter?: boolean; expl3?: boolean; autodetectExpl3AndAtLetter?: boolean; }; }[], string, Ast.Root>` + +```typescript +function unifiedLatexFromString(options: { + mode?: "math" | "regular"; + macros?: MacroInfoRecord; + environments?: EnvInfoRecord; + flags?: { + atLetter?: boolean; + expl3?: boolean; + autodetectExpl3AndAtLetter?: boolean; + }; +}): void; +``` + +## `unifiedLatexFromStringMinimal` + +Parse a string to a LaTeX AST with no post processing. For example, +no macro arguments will be attached, etc. + +### Usage + +`unified().use(unifiedLatexFromStringMinimal[, options])` + +#### options + +```typescript +PluginOptions +``` + +### Type + +`Plugin` + +```typescript +function unifiedLatexFromStringMinimal(options: PluginOptions): void; +``` + +## `unifiedLatexProcessAtLetterAndExplMacros` + +Unified plugin to reprocess macros names to possibly include `@`, `_`, or `:`. +This plugin detects the `\makeatletter` and `\ExplSyntaxOn` commands and reprocesses macro names +inside of those blocks to include those characters. + +### Usage + +`unified().use(unifiedLatexProcessAtLetterAndExplMacros[, options])` + +#### options + +```typescript +{ atLetter?: boolean; expl3?: boolean; autodetectExpl3AndAtLetter?: boolean; } +``` + +### Type + +`Plugin<{ atLetter?: boolean; expl3?: boolean; autodetectExpl3AndAtLetter?: boolean; }[], Ast.Root, Ast.Root>` + +```typescript +function unifiedLatexProcessAtLetterAndExplMacros(options: { + atLetter?: boolean; + expl3?: boolean; + autodetectExpl3AndAtLetter?: boolean; +}): (tree: Ast.Root) => void; +``` + +## `unifiedLatexProcessMacrosAndEnvironmentsWithMathReparse` + +Unified plugin to process macros and environments. Any environments that contain math content +are reparsed (if needed) in math mode. + +### Usage + +`unified().use(unifiedLatexProcessMacrosAndEnvironmentsWithMathReparse[, options])` + +#### options + +```typescript +{ environments: EnvInfoRecord; macros: MacroInfoRecord; } +``` + +### Type + +`Plugin<{ environments: EnvInfoRecord; macros: MacroInfoRecord; }[], Ast.Root, Ast.Root>` + +```typescript +function unifiedLatexProcessMacrosAndEnvironmentsWithMathReparse(options: { + environments: EnvInfoRecord; + macros: MacroInfoRecord; +}): (tree: Ast.Root) => void; +``` + +## `unifiedLatexReparseMath` + +Reparse math environments/macro contents that should have been parsed in math mode but weren't. + +### Usage + +`unified().use(unifiedLatexReparseMath[, options])` + +#### options + +```typescript +{ mathEnvs: string[]; mathMacros: string[]; } +``` + +### Type + +`Plugin<{ mathEnvs: string[]; mathMacros: string[]; }[], Ast.Root, Ast.Root>` + +```typescript +function unifiedLatexReparseMath(options: { + mathEnvs: string[]; + mathMacros: string[]; +}): (tree: Ast.Root) => void; +``` + +# Functions + +## `getParser(options)` + +Returns the default `unified-latex` parser, or create a new one with the +provided `unifiedLatexFromString` options + +```typescript +function getParser(options: { + mode?: "math" | "regular"; + macros?: Ast.MacroInfoRecord; + environments?: Ast.EnvInfoRecord; + flags?: { + atLetter?: boolean; + expl3?: boolean; + autodetectExpl3AndAtLetter?: boolean; + }; +}): FrozenProcessor; +``` + +**Parameters** + +| Param | Type | Description | +| :------ | :-------------------------------- | -------------------------------------------------- | +| options | Omitted | Plugin options of `unifiedLatexFromString` plugin. | + +## `parse(str)` + +Parse the string into an AST. + +```typescript +function parse(str: String): Ast.Root; +``` + +**Parameters** + +| Param | Type | +| :---- | :------- | +| str | `String` | + +## `parseMath(str)` + +Parse `str` into an AST. Parsing starts in math mode and a list of +nodes is returned (instead of a "root" node). + +```typescript +function parseMath(str: string | Ast.Ast): Ast.Node[]; +``` + +**Parameters** + +| Param | Type | +| :---- | :------------------ | +| str | `string \| Ast.Ast` | + +## `parseMathMinimal(str)` + +Parse `str` to an AST with minimal processing. E.g., macro +arguments are not attached to macros, etc. when parsed with this +function. + +The parsing assumes a math-mode context, so, for example, `^` and `_` are +parsed as macros (even though arguments are not attached to them). + +```typescript +function parseMathMinimal(str: String): Ast.Node[]; +``` + +**Parameters** + +| Param | Type | +| :---- | :------- | +| str | `String` | + +## `parseMinimal(str)` + +Parse `str` to an AST with minimal processing. E.g., macro +arguments are not attached to macros, etc. when parsed with this +function. + +```typescript +function parseMinimal(str: String): Ast.Root; +``` + +**Parameters** + +| Param | Type | +| :---- | :------- | +| str | `String` | + +`unifiedLatexReparseMathConstructPlugin({ + mathEnvs, + mathMacros, +})` +--- + +Construct the inner function for the `unifiedLatexReparseMath` plugin. This function should not be used by libraries. + +```typescript +function unifiedLatexReparseMathConstructPlugin({ + mathEnvs, + mathMacros, +}: { + mathEnvs: string[]; + mathMacros: string[]; +}): (tree: Ast.Root) => void; +``` + +**Parameters** + +| Param | Type | +| :-------------------------------------------- | :-------------------------------- | +| { mathEnvs, mathMacros, } | Omitted | + +# Types + +## `PluginOptions` + +```typescript +export type PluginOptions = + | { + mode?: "math" | "regular"; + macros?: MacroInfoRecord; + environments?: EnvInfoRecord; + flags?: { + /** + * Whether to parse macros as if `\makeatletter` is set (i.e., parse `@` as a regular macro character) + */ + atLetter?: boolean; + /** + * Whether to parse macros as if `\ExplSyntaxOn` is set (i.e., parse `_` and `:` as a regular macro character) + */ + expl3?: boolean; + /** + * Attempt to autodetect whether there are macros that look like they should contain `@`, `_`, or `:`. + * Defaults to `false`. + */ + autodetectExpl3AndAtLetter?: boolean; + }; + } + | undefined; +``` diff --git a/node_modules/@unified-latex/unified-latex-util-parse/index.cjs b/node_modules/@unified-latex/unified-latex-util-parse/index.cjs new file mode 100644 index 0000000..cbe3ed4 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-util-parse/index.cjs @@ -0,0 +1,1389 @@ +"use strict"; +Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" }); +const unifiedLatexCtan = require("@unified-latex/unified-latex-ctan"); +const unifiedLatexUtilTrim = require("@unified-latex/unified-latex-util-trim"); +const unifiedLatexUtilPegjs = require("@unified-latex/unified-latex-util-pegjs"); +const unifiedLatexUtilVisit = require("@unified-latex/unified-latex-util-visit"); +const unifiedLatexUtilMatch = require("@unified-latex/unified-latex-util-match"); +const unifiedLatexUtilPrintRaw = require("@unified-latex/unified-latex-util-print-raw"); +const unifiedLatexUtilArguments = require("@unified-latex/unified-latex-util-arguments"); +const unifiedLatexUtilEnvironments = require("@unified-latex/unified-latex-util-environments"); +const unifiedLatexUtilCatcode = require("@unified-latex/unified-latex-util-catcode"); +const unifiedLatexAstComplier = function unifiedLatexAstComplier2() { + Object.assign(this, { Compiler: (x) => x }); +}; +function bail(error) { + if (error) { + throw error; + } +} +function getDefaultExportFromCjs(x) { + return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, "default") ? x["default"] : x; +} +/*! + * Determine if an object is a Buffer + * + * @author Feross Aboukhadijeh + * @license MIT + */ +var isBuffer$1; +var hasRequiredIsBuffer; +function requireIsBuffer() { + if (hasRequiredIsBuffer) return isBuffer$1; + hasRequiredIsBuffer = 1; + isBuffer$1 = function isBuffer2(obj) { + return obj != null && obj.constructor != null && typeof obj.constructor.isBuffer === "function" && obj.constructor.isBuffer(obj); + }; + return isBuffer$1; +} +var isBufferExports = requireIsBuffer(); +const isBuffer = /* @__PURE__ */ getDefaultExportFromCjs(isBufferExports); +var extend$1; +var hasRequiredExtend; +function requireExtend() { + if (hasRequiredExtend) return extend$1; + hasRequiredExtend = 1; + var hasOwn = Object.prototype.hasOwnProperty; + var toStr = Object.prototype.toString; + var defineProperty = Object.defineProperty; + var gOPD = Object.getOwnPropertyDescriptor; + var isArray = function isArray2(arr) { + if (typeof Array.isArray === "function") { + return Array.isArray(arr); + } + return toStr.call(arr) === "[object Array]"; + }; + var isPlainObject2 = function isPlainObject3(obj) { + if (!obj || toStr.call(obj) !== "[object Object]") { + return false; + } + var hasOwnConstructor = hasOwn.call(obj, "constructor"); + var hasIsPrototypeOf = obj.constructor && obj.constructor.prototype && hasOwn.call(obj.constructor.prototype, "isPrototypeOf"); + if (obj.constructor && !hasOwnConstructor && !hasIsPrototypeOf) { + return false; + } + var key; + for (key in obj) { + } + return typeof key === "undefined" || hasOwn.call(obj, key); + }; + var setProperty = function setProperty2(target, options) { + if (defineProperty && options.name === "__proto__") { + defineProperty(target, options.name, { + enumerable: true, + configurable: true, + value: options.newValue, + writable: true + }); + } else { + target[options.name] = options.newValue; + } + }; + var getProperty = function getProperty2(obj, name) { + if (name === "__proto__") { + if (!hasOwn.call(obj, name)) { + return void 0; + } else if (gOPD) { + return gOPD(obj, name).value; + } + } + return obj[name]; + }; + extend$1 = function extend2() { + var options, name, src, copy, copyIsArray, clone; + var target = arguments[0]; + var i = 1; + var length = arguments.length; + var deep = false; + if (typeof target === "boolean") { + deep = target; + target = arguments[1] || {}; + i = 2; + } + if (target == null || typeof target !== "object" && typeof target !== "function") { + target = {}; + } + for (; i < length; ++i) { + options = arguments[i]; + if (options != null) { + for (name in options) { + src = getProperty(target, name); + copy = getProperty(options, name); + if (target !== copy) { + if (deep && copy && (isPlainObject2(copy) || (copyIsArray = isArray(copy)))) { + if (copyIsArray) { + copyIsArray = false; + clone = src && isArray(src) ? src : []; + } else { + clone = src && isPlainObject2(src) ? src : {}; + } + setProperty(target, { name, newValue: extend2(deep, clone, copy) }); + } else if (typeof copy !== "undefined") { + setProperty(target, { name, newValue: copy }); + } + } + } + } + } + return target; + }; + return extend$1; +} +var extendExports = requireExtend(); +const extend = /* @__PURE__ */ getDefaultExportFromCjs(extendExports); +function isPlainObject(value) { + if (typeof value !== "object" || value === null) { + return false; + } + const prototype = Object.getPrototypeOf(value); + return (prototype === null || prototype === Object.prototype || Object.getPrototypeOf(prototype) === null) && !(Symbol.toStringTag in value) && !(Symbol.iterator in value); +} +function trough() { + const fns = []; + const pipeline = { run, use }; + return pipeline; + function run(...values) { + let middlewareIndex = -1; + const callback = values.pop(); + if (typeof callback !== "function") { + throw new TypeError("Expected function as last argument, not " + callback); + } + next(null, ...values); + function next(error, ...output) { + const fn = fns[++middlewareIndex]; + let index2 = -1; + if (error) { + callback(error); + return; + } + while (++index2 < values.length) { + if (output[index2] === null || output[index2] === void 0) { + output[index2] = values[index2]; + } + } + values = output; + if (fn) { + wrap(fn, next)(...output); + } else { + callback(null, ...output); + } + } + } + function use(middelware) { + if (typeof middelware !== "function") { + throw new TypeError( + "Expected `middelware` to be a function, not " + middelware + ); + } + fns.push(middelware); + return pipeline; + } +} +function wrap(middleware, callback) { + let called; + return wrapped; + function wrapped(...parameters) { + const fnExpectsCallback = middleware.length > parameters.length; + let result; + if (fnExpectsCallback) { + parameters.push(done); + } + try { + result = middleware.apply(this, parameters); + } catch (error) { + const exception = ( + /** @type {Error} */ + error + ); + if (fnExpectsCallback && called) { + throw exception; + } + return done(exception); + } + if (!fnExpectsCallback) { + if (result && result.then && typeof result.then === "function") { + result.then(then, done); + } else if (result instanceof Error) { + done(result); + } else { + then(result); + } + } + } + function done(error, ...output) { + if (!called) { + called = true; + callback(error, ...output); + } + } + function then(value) { + done(null, value); + } +} +function stringifyPosition(value) { + if (!value || typeof value !== "object") { + return ""; + } + if ("position" in value || "type" in value) { + return position(value.position); + } + if ("start" in value || "end" in value) { + return position(value); + } + if ("line" in value || "column" in value) { + return point(value); + } + return ""; +} +function point(point2) { + return index(point2 && point2.line) + ":" + index(point2 && point2.column); +} +function position(pos) { + return point(pos && pos.start) + "-" + point(pos && pos.end); +} +function index(value) { + return value && typeof value === "number" ? value : 1; +} +class VFileMessage extends Error { + /** + * Create a message for `reason` at `place` from `origin`. + * + * When an error is passed in as `reason`, the `stack` is copied. + * + * @param {string | Error | VFileMessage} reason + * Reason for message, uses the stack and message of the error if given. + * + * > 👉 **Note**: you should use markdown. + * @param {Node | NodeLike | Position | Point | null | undefined} [place] + * Place in file where the message occurred. + * @param {string | null | undefined} [origin] + * Place in code where the message originates (example: + * `'my-package:my-rule'` or `'my-rule'`). + * @returns + * Instance of `VFileMessage`. + */ + // To do: next major: expose `undefined` everywhere instead of `null`. + constructor(reason, place, origin) { + const parts = [null, null]; + let position2 = { + // @ts-expect-error: we always follows the structure of `position`. + start: { line: null, column: null }, + // @ts-expect-error: " + end: { line: null, column: null } + }; + super(); + if (typeof place === "string") { + origin = place; + place = void 0; + } + if (typeof origin === "string") { + const index2 = origin.indexOf(":"); + if (index2 === -1) { + parts[1] = origin; + } else { + parts[0] = origin.slice(0, index2); + parts[1] = origin.slice(index2 + 1); + } + } + if (place) { + if ("type" in place || "position" in place) { + if (place.position) { + position2 = place.position; + } + } else if ("start" in place || "end" in place) { + position2 = place; + } else if ("line" in place || "column" in place) { + position2.start = place; + } + } + this.name = stringifyPosition(place) || "1:1"; + this.message = typeof reason === "object" ? reason.message : reason; + this.stack = ""; + if (typeof reason === "object" && reason.stack) { + this.stack = reason.stack; + } + this.reason = this.message; + this.fatal; + this.line = position2.start.line; + this.column = position2.start.column; + this.position = position2; + this.source = parts[0]; + this.ruleId = parts[1]; + this.file; + this.actual; + this.expected; + this.url; + this.note; + } +} +VFileMessage.prototype.file = ""; +VFileMessage.prototype.name = ""; +VFileMessage.prototype.reason = ""; +VFileMessage.prototype.message = ""; +VFileMessage.prototype.stack = ""; +VFileMessage.prototype.fatal = null; +VFileMessage.prototype.column = null; +VFileMessage.prototype.line = null; +VFileMessage.prototype.source = null; +VFileMessage.prototype.ruleId = null; +VFileMessage.prototype.position = null; +const path = { basename, dirname, extname, join, sep: "/" }; +function basename(path2, ext) { + if (ext !== void 0 && typeof ext !== "string") { + throw new TypeError('"ext" argument must be a string'); + } + assertPath$1(path2); + let start = 0; + let end = -1; + let index2 = path2.length; + let seenNonSlash; + if (ext === void 0 || ext.length === 0 || ext.length > path2.length) { + while (index2--) { + if (path2.charCodeAt(index2) === 47) { + if (seenNonSlash) { + start = index2 + 1; + break; + } + } else if (end < 0) { + seenNonSlash = true; + end = index2 + 1; + } + } + return end < 0 ? "" : path2.slice(start, end); + } + if (ext === path2) { + return ""; + } + let firstNonSlashEnd = -1; + let extIndex = ext.length - 1; + while (index2--) { + if (path2.charCodeAt(index2) === 47) { + if (seenNonSlash) { + start = index2 + 1; + break; + } + } else { + if (firstNonSlashEnd < 0) { + seenNonSlash = true; + firstNonSlashEnd = index2 + 1; + } + if (extIndex > -1) { + if (path2.charCodeAt(index2) === ext.charCodeAt(extIndex--)) { + if (extIndex < 0) { + end = index2; + } + } else { + extIndex = -1; + end = firstNonSlashEnd; + } + } + } + } + if (start === end) { + end = firstNonSlashEnd; + } else if (end < 0) { + end = path2.length; + } + return path2.slice(start, end); +} +function dirname(path2) { + assertPath$1(path2); + if (path2.length === 0) { + return "."; + } + let end = -1; + let index2 = path2.length; + let unmatchedSlash; + while (--index2) { + if (path2.charCodeAt(index2) === 47) { + if (unmatchedSlash) { + end = index2; + break; + } + } else if (!unmatchedSlash) { + unmatchedSlash = true; + } + } + return end < 0 ? path2.charCodeAt(0) === 47 ? "/" : "." : end === 1 && path2.charCodeAt(0) === 47 ? "//" : path2.slice(0, end); +} +function extname(path2) { + assertPath$1(path2); + let index2 = path2.length; + let end = -1; + let startPart = 0; + let startDot = -1; + let preDotState = 0; + let unmatchedSlash; + while (index2--) { + const code = path2.charCodeAt(index2); + if (code === 47) { + if (unmatchedSlash) { + startPart = index2 + 1; + break; + } + continue; + } + if (end < 0) { + unmatchedSlash = true; + end = index2 + 1; + } + if (code === 46) { + if (startDot < 0) { + startDot = index2; + } else if (preDotState !== 1) { + preDotState = 1; + } + } else if (startDot > -1) { + preDotState = -1; + } + } + if (startDot < 0 || end < 0 || // We saw a non-dot character immediately before the dot. + preDotState === 0 || // The (right-most) trimmed path component is exactly `..`. + preDotState === 1 && startDot === end - 1 && startDot === startPart + 1) { + return ""; + } + return path2.slice(startDot, end); +} +function join(...segments) { + let index2 = -1; + let joined; + while (++index2 < segments.length) { + assertPath$1(segments[index2]); + if (segments[index2]) { + joined = joined === void 0 ? segments[index2] : joined + "/" + segments[index2]; + } + } + return joined === void 0 ? "." : normalize(joined); +} +function normalize(path2) { + assertPath$1(path2); + const absolute = path2.charCodeAt(0) === 47; + let value = normalizeString(path2, !absolute); + if (value.length === 0 && !absolute) { + value = "."; + } + if (value.length > 0 && path2.charCodeAt(path2.length - 1) === 47) { + value += "/"; + } + return absolute ? "/" + value : value; +} +function normalizeString(path2, allowAboveRoot) { + let result = ""; + let lastSegmentLength = 0; + let lastSlash = -1; + let dots = 0; + let index2 = -1; + let code; + let lastSlashIndex; + while (++index2 <= path2.length) { + if (index2 < path2.length) { + code = path2.charCodeAt(index2); + } else if (code === 47) { + break; + } else { + code = 47; + } + if (code === 47) { + if (lastSlash === index2 - 1 || dots === 1) ; + else if (lastSlash !== index2 - 1 && dots === 2) { + if (result.length < 2 || lastSegmentLength !== 2 || result.charCodeAt(result.length - 1) !== 46 || result.charCodeAt(result.length - 2) !== 46) { + if (result.length > 2) { + lastSlashIndex = result.lastIndexOf("/"); + if (lastSlashIndex !== result.length - 1) { + if (lastSlashIndex < 0) { + result = ""; + lastSegmentLength = 0; + } else { + result = result.slice(0, lastSlashIndex); + lastSegmentLength = result.length - 1 - result.lastIndexOf("/"); + } + lastSlash = index2; + dots = 0; + continue; + } + } else if (result.length > 0) { + result = ""; + lastSegmentLength = 0; + lastSlash = index2; + dots = 0; + continue; + } + } + if (allowAboveRoot) { + result = result.length > 0 ? result + "/.." : ".."; + lastSegmentLength = 2; + } + } else { + if (result.length > 0) { + result += "/" + path2.slice(lastSlash + 1, index2); + } else { + result = path2.slice(lastSlash + 1, index2); + } + lastSegmentLength = index2 - lastSlash - 1; + } + lastSlash = index2; + dots = 0; + } else if (code === 46 && dots > -1) { + dots++; + } else { + dots = -1; + } + } + return result; +} +function assertPath$1(path2) { + if (typeof path2 !== "string") { + throw new TypeError( + "Path must be a string. Received " + JSON.stringify(path2) + ); + } +} +const proc = { cwd }; +function cwd() { + return "/"; +} +function isUrl(fileUrlOrPath) { + return fileUrlOrPath !== null && typeof fileUrlOrPath === "object" && // @ts-expect-error: indexable. + fileUrlOrPath.href && // @ts-expect-error: indexable. + fileUrlOrPath.origin; +} +function urlToPath(path2) { + if (typeof path2 === "string") { + path2 = new URL(path2); + } else if (!isUrl(path2)) { + const error = new TypeError( + 'The "path" argument must be of type string or an instance of URL. Received `' + path2 + "`" + ); + error.code = "ERR_INVALID_ARG_TYPE"; + throw error; + } + if (path2.protocol !== "file:") { + const error = new TypeError("The URL must be of scheme file"); + error.code = "ERR_INVALID_URL_SCHEME"; + throw error; + } + return getPathFromURLPosix(path2); +} +function getPathFromURLPosix(url) { + if (url.hostname !== "") { + const error = new TypeError( + 'File URL host must be "localhost" or empty on darwin' + ); + error.code = "ERR_INVALID_FILE_URL_HOST"; + throw error; + } + const pathname = url.pathname; + let index2 = -1; + while (++index2 < pathname.length) { + if (pathname.charCodeAt(index2) === 37 && pathname.charCodeAt(index2 + 1) === 50) { + const third = pathname.charCodeAt(index2 + 2); + if (third === 70 || third === 102) { + const error = new TypeError( + "File URL path must not include encoded / characters" + ); + error.code = "ERR_INVALID_FILE_URL_PATH"; + throw error; + } + } + } + return decodeURIComponent(pathname); +} +const order = ["history", "path", "basename", "stem", "extname", "dirname"]; +class VFile { + /** + * Create a new virtual file. + * + * `options` is treated as: + * + * * `string` or `Buffer` — `{value: options}` + * * `URL` — `{path: options}` + * * `VFile` — shallow copies its data over to the new file + * * `object` — all fields are shallow copied over to the new file + * + * Path related fields are set in the following order (least specific to + * most specific): `history`, `path`, `basename`, `stem`, `extname`, + * `dirname`. + * + * You cannot set `dirname` or `extname` without setting either `history`, + * `path`, `basename`, or `stem` too. + * + * @param {Compatible | null | undefined} [value] + * File value. + * @returns + * New instance. + */ + constructor(value) { + let options; + if (!value) { + options = {}; + } else if (typeof value === "string" || buffer(value)) { + options = { value }; + } else if (isUrl(value)) { + options = { path: value }; + } else { + options = value; + } + this.data = {}; + this.messages = []; + this.history = []; + this.cwd = proc.cwd(); + this.value; + this.stored; + this.result; + this.map; + let index2 = -1; + while (++index2 < order.length) { + const prop2 = order[index2]; + if (prop2 in options && options[prop2] !== void 0 && options[prop2] !== null) { + this[prop2] = prop2 === "history" ? [...options[prop2]] : options[prop2]; + } + } + let prop; + for (prop in options) { + if (!order.includes(prop)) { + this[prop] = options[prop]; + } + } + } + /** + * Get the full path (example: `'~/index.min.js'`). + * + * @returns {string} + */ + get path() { + return this.history[this.history.length - 1]; + } + /** + * Set the full path (example: `'~/index.min.js'`). + * + * Cannot be nullified. + * You can set a file URL (a `URL` object with a `file:` protocol) which will + * be turned into a path with `url.fileURLToPath`. + * + * @param {string | URL} path + */ + set path(path2) { + if (isUrl(path2)) { + path2 = urlToPath(path2); + } + assertNonEmpty(path2, "path"); + if (this.path !== path2) { + this.history.push(path2); + } + } + /** + * Get the parent path (example: `'~'`). + */ + get dirname() { + return typeof this.path === "string" ? path.dirname(this.path) : void 0; + } + /** + * Set the parent path (example: `'~'`). + * + * Cannot be set if there’s no `path` yet. + */ + set dirname(dirname2) { + assertPath(this.basename, "dirname"); + this.path = path.join(dirname2 || "", this.basename); + } + /** + * Get the basename (including extname) (example: `'index.min.js'`). + */ + get basename() { + return typeof this.path === "string" ? path.basename(this.path) : void 0; + } + /** + * Set basename (including extname) (`'index.min.js'`). + * + * Cannot contain path separators (`'/'` on unix, macOS, and browsers, `'\'` + * on windows). + * Cannot be nullified (use `file.path = file.dirname` instead). + */ + set basename(basename2) { + assertNonEmpty(basename2, "basename"); + assertPart(basename2, "basename"); + this.path = path.join(this.dirname || "", basename2); + } + /** + * Get the extname (including dot) (example: `'.js'`). + */ + get extname() { + return typeof this.path === "string" ? path.extname(this.path) : void 0; + } + /** + * Set the extname (including dot) (example: `'.js'`). + * + * Cannot contain path separators (`'/'` on unix, macOS, and browsers, `'\'` + * on windows). + * Cannot be set if there’s no `path` yet. + */ + set extname(extname2) { + assertPart(extname2, "extname"); + assertPath(this.dirname, "extname"); + if (extname2) { + if (extname2.charCodeAt(0) !== 46) { + throw new Error("`extname` must start with `.`"); + } + if (extname2.includes(".", 1)) { + throw new Error("`extname` cannot contain multiple dots"); + } + } + this.path = path.join(this.dirname, this.stem + (extname2 || "")); + } + /** + * Get the stem (basename w/o extname) (example: `'index.min'`). + */ + get stem() { + return typeof this.path === "string" ? path.basename(this.path, this.extname) : void 0; + } + /** + * Set the stem (basename w/o extname) (example: `'index.min'`). + * + * Cannot contain path separators (`'/'` on unix, macOS, and browsers, `'\'` + * on windows). + * Cannot be nullified (use `file.path = file.dirname` instead). + */ + set stem(stem) { + assertNonEmpty(stem, "stem"); + assertPart(stem, "stem"); + this.path = path.join(this.dirname || "", stem + (this.extname || "")); + } + /** + * Serialize the file. + * + * @param {BufferEncoding | null | undefined} [encoding='utf8'] + * Character encoding to understand `value` as when it’s a `Buffer` + * (default: `'utf8'`). + * @returns {string} + * Serialized file. + */ + toString(encoding) { + return (this.value || "").toString(encoding || void 0); + } + /** + * Create a warning message associated with the file. + * + * Its `fatal` is set to `false` and `file` is set to the current file path. + * Its added to `file.messages`. + * + * @param {string | Error | VFileMessage} reason + * Reason for message, uses the stack and message of the error if given. + * @param {Node | NodeLike | Position | Point | null | undefined} [place] + * Place in file where the message occurred. + * @param {string | null | undefined} [origin] + * Place in code where the message originates (example: + * `'my-package:my-rule'` or `'my-rule'`). + * @returns {VFileMessage} + * Message. + */ + message(reason, place, origin) { + const message = new VFileMessage(reason, place, origin); + if (this.path) { + message.name = this.path + ":" + message.name; + message.file = this.path; + } + message.fatal = false; + this.messages.push(message); + return message; + } + /** + * Create an info message associated with the file. + * + * Its `fatal` is set to `null` and `file` is set to the current file path. + * Its added to `file.messages`. + * + * @param {string | Error | VFileMessage} reason + * Reason for message, uses the stack and message of the error if given. + * @param {Node | NodeLike | Position | Point | null | undefined} [place] + * Place in file where the message occurred. + * @param {string | null | undefined} [origin] + * Place in code where the message originates (example: + * `'my-package:my-rule'` or `'my-rule'`). + * @returns {VFileMessage} + * Message. + */ + info(reason, place, origin) { + const message = this.message(reason, place, origin); + message.fatal = null; + return message; + } + /** + * Create a fatal error associated with the file. + * + * Its `fatal` is set to `true` and `file` is set to the current file path. + * Its added to `file.messages`. + * + * > 👉 **Note**: a fatal error means that a file is no longer processable. + * + * @param {string | Error | VFileMessage} reason + * Reason for message, uses the stack and message of the error if given. + * @param {Node | NodeLike | Position | Point | null | undefined} [place] + * Place in file where the message occurred. + * @param {string | null | undefined} [origin] + * Place in code where the message originates (example: + * `'my-package:my-rule'` or `'my-rule'`). + * @returns {never} + * Message. + * @throws {VFileMessage} + * Message. + */ + fail(reason, place, origin) { + const message = this.message(reason, place, origin); + message.fatal = true; + throw message; + } +} +function assertPart(part, name) { + if (part && part.includes(path.sep)) { + throw new Error( + "`" + name + "` cannot be a path: did not expect `" + path.sep + "`" + ); + } +} +function assertNonEmpty(part, name) { + if (!part) { + throw new Error("`" + name + "` cannot be empty"); + } +} +function assertPath(path2, name) { + if (!path2) { + throw new Error("Setting `" + name + "` requires `path` to be set too"); + } +} +function buffer(value) { + return isBuffer(value); +} +const unified = base().freeze(); +const own = {}.hasOwnProperty; +function base() { + const transformers = trough(); + const attachers = []; + let namespace = {}; + let frozen; + let freezeIndex = -1; + processor.data = data; + processor.Parser = void 0; + processor.Compiler = void 0; + processor.freeze = freeze; + processor.attachers = attachers; + processor.use = use; + processor.parse = parse2; + processor.stringify = stringify; + processor.run = run; + processor.runSync = runSync; + processor.process = process; + processor.processSync = processSync; + return processor; + function processor() { + const destination = base(); + let index2 = -1; + while (++index2 < attachers.length) { + destination.use(...attachers[index2]); + } + destination.data(extend(true, {}, namespace)); + return destination; + } + function data(key, value) { + if (typeof key === "string") { + if (arguments.length === 2) { + assertUnfrozen("data", frozen); + namespace[key] = value; + return processor; + } + return own.call(namespace, key) && namespace[key] || null; + } + if (key) { + assertUnfrozen("data", frozen); + namespace = key; + return processor; + } + return namespace; + } + function freeze() { + if (frozen) { + return processor; + } + while (++freezeIndex < attachers.length) { + const [attacher, ...options] = attachers[freezeIndex]; + if (options[0] === false) { + continue; + } + if (options[0] === true) { + options[0] = void 0; + } + const transformer = attacher.call(processor, ...options); + if (typeof transformer === "function") { + transformers.use(transformer); + } + } + frozen = true; + freezeIndex = Number.POSITIVE_INFINITY; + return processor; + } + function use(value, ...options) { + let settings; + assertUnfrozen("use", frozen); + if (value === null || value === void 0) ; + else if (typeof value === "function") { + addPlugin(value, ...options); + } else if (typeof value === "object") { + if (Array.isArray(value)) { + addList(value); + } else { + addPreset(value); + } + } else { + throw new TypeError("Expected usable value, not `" + value + "`"); + } + if (settings) { + namespace.settings = Object.assign(namespace.settings || {}, settings); + } + return processor; + function add(value2) { + if (typeof value2 === "function") { + addPlugin(value2); + } else if (typeof value2 === "object") { + if (Array.isArray(value2)) { + const [plugin, ...options2] = value2; + addPlugin(plugin, ...options2); + } else { + addPreset(value2); + } + } else { + throw new TypeError("Expected usable value, not `" + value2 + "`"); + } + } + function addPreset(result) { + addList(result.plugins); + if (result.settings) { + settings = Object.assign(settings || {}, result.settings); + } + } + function addList(plugins) { + let index2 = -1; + if (plugins === null || plugins === void 0) ; + else if (Array.isArray(plugins)) { + while (++index2 < plugins.length) { + const thing = plugins[index2]; + add(thing); + } + } else { + throw new TypeError("Expected a list of plugins, not `" + plugins + "`"); + } + } + function addPlugin(plugin, value2) { + let index2 = -1; + let entry; + while (++index2 < attachers.length) { + if (attachers[index2][0] === plugin) { + entry = attachers[index2]; + break; + } + } + if (entry) { + if (isPlainObject(entry[1]) && isPlainObject(value2)) { + value2 = extend(true, entry[1], value2); + } + entry[1] = value2; + } else { + attachers.push([...arguments]); + } + } + } + function parse2(doc) { + processor.freeze(); + const file = vfile(doc); + const Parser = processor.Parser; + assertParser("parse", Parser); + if (newable(Parser, "parse")) { + return new Parser(String(file), file).parse(); + } + return Parser(String(file), file); + } + function stringify(node, doc) { + processor.freeze(); + const file = vfile(doc); + const Compiler = processor.Compiler; + assertCompiler("stringify", Compiler); + assertNode(node); + if (newable(Compiler, "compile")) { + return new Compiler(node, file).compile(); + } + return Compiler(node, file); + } + function run(node, doc, callback) { + assertNode(node); + processor.freeze(); + if (!callback && typeof doc === "function") { + callback = doc; + doc = void 0; + } + if (!callback) { + return new Promise(executor); + } + executor(null, callback); + function executor(resolve, reject) { + transformers.run(node, vfile(doc), done); + function done(error, tree, file) { + tree = tree || node; + if (error) { + reject(error); + } else if (resolve) { + resolve(tree); + } else { + callback(null, tree, file); + } + } + } + } + function runSync(node, file) { + let result; + let complete; + processor.run(node, file, done); + assertDone("runSync", "run", complete); + return result; + function done(error, tree) { + bail(error); + result = tree; + complete = true; + } + } + function process(doc, callback) { + processor.freeze(); + assertParser("process", processor.Parser); + assertCompiler("process", processor.Compiler); + if (!callback) { + return new Promise(executor); + } + executor(null, callback); + function executor(resolve, reject) { + const file = vfile(doc); + processor.run(processor.parse(file), file, (error, tree, file2) => { + if (error || !tree || !file2) { + done(error); + } else { + const result = processor.stringify(tree, file2); + if (result === void 0 || result === null) ; + else if (looksLikeAVFileValue(result)) { + file2.value = result; + } else { + file2.result = result; + } + done(error, file2); + } + }); + function done(error, file2) { + if (error || !file2) { + reject(error); + } else if (resolve) { + resolve(file2); + } else { + callback(null, file2); + } + } + } + } + function processSync(doc) { + let complete; + processor.freeze(); + assertParser("processSync", processor.Parser); + assertCompiler("processSync", processor.Compiler); + const file = vfile(doc); + processor.process(file, done); + assertDone("processSync", "process", complete); + return file; + function done(error) { + complete = true; + bail(error); + } + } +} +function newable(value, name) { + return typeof value === "function" && // Prototypes do exist. + // type-coverage:ignore-next-line + value.prototype && // A function with keys in its prototype is probably a constructor. + // Classes’ prototype methods are not enumerable, so we check if some value + // exists in the prototype. + // type-coverage:ignore-next-line + (keys(value.prototype) || name in value.prototype); +} +function keys(value) { + let key; + for (key in value) { + if (own.call(value, key)) { + return true; + } + } + return false; +} +function assertParser(name, value) { + if (typeof value !== "function") { + throw new TypeError("Cannot `" + name + "` without `Parser`"); + } +} +function assertCompiler(name, value) { + if (typeof value !== "function") { + throw new TypeError("Cannot `" + name + "` without `Compiler`"); + } +} +function assertUnfrozen(name, frozen) { + if (frozen) { + throw new Error( + "Cannot call `" + name + "` on a frozen processor.\nCreate a new processor first, by calling it: use `processor()` instead of `processor`." + ); + } +} +function assertNode(node) { + if (!isPlainObject(node) || typeof node.type !== "string") { + throw new TypeError("Expected node, got `" + node + "`"); + } +} +function assertDone(name, asyncName, complete) { + if (!complete) { + throw new Error( + "`" + name + "` finished async. Use `" + asyncName + "` instead" + ); + } +} +function vfile(value) { + return looksLikeAVFile(value) ? value : new VFile(value); +} +function looksLikeAVFile(value) { + return Boolean( + value && typeof value === "object" && "message" in value && "messages" in value + ); +} +function looksLikeAVFileValue(value) { + return typeof value === "string" || isBuffer(value); +} +function parseMinimal(str) { + return unifiedLatexUtilPegjs.LatexPegParser.parse(str); +} +function parseMathMinimal(str) { + return unifiedLatexUtilPegjs.LatexPegParser.parse(str, { startRule: "math" }); +} +const unifiedLatexFromStringMinimal = function unifiedLatexFromStringMinimal2(options) { + const parser2 = (str) => { + if ((options == null ? void 0 : options.mode) === "math") { + return { + type: "root", + content: parseMathMinimal(str), + _renderInfo: { inMathMode: true } + }; + } + return parseMinimal(str); + }; + Object.assign(this, { Parser: parser2 }); +}; +const unifiedLatexReparseMath = function unifiedLatexReparseMath2(options) { + const { mathEnvs = [], mathMacros = [] } = options || {}; + return unifiedLatexReparseMathConstructPlugin({ mathMacros, mathEnvs }); +}; +function unifiedLatexReparseMathConstructPlugin({ + mathEnvs, + mathMacros +}) { + const isMathEnvironment = unifiedLatexUtilMatch.match.createEnvironmentMatcher(mathEnvs); + const isMathMacro = unifiedLatexUtilMatch.match.createMacroMatcher(mathMacros); + return (tree) => { + unifiedLatexUtilVisit.visit( + tree, + (node) => { + if (unifiedLatexUtilMatch.match.anyMacro(node)) { + for (const arg of node.args || []) { + if (arg.content.length > 0 && !wasParsedInMathMode(arg.content)) { + arg.content = parseMathMinimal( + unifiedLatexUtilPrintRaw.printRaw(arg.content) + ); + } + } + } + if (unifiedLatexUtilMatch.match.anyEnvironment(node)) { + if (!wasParsedInMathMode(node.content)) { + node.content = parseMathMinimal(unifiedLatexUtilPrintRaw.printRaw(node.content)); + } + } + }, + { + test: (node) => isMathEnvironment(node) || isMathMacro(node) + } + ); + }; +} +function wasParsedInMathMode(nodes) { + return !nodes.some( + (node) => ( + // If there are multi-char strings or ^ and _ have been parsed as strings, we know + // that we were not parsed in math mode. + unifiedLatexUtilMatch.match.anyString(node) && node.content.length > 1 || unifiedLatexUtilMatch.match.string(node, "^") || unifiedLatexUtilMatch.match.string(node, "_") + ) + ); +} +const unifiedLatexProcessMacrosAndEnvironmentsWithMathReparse = function unifiedLatexProcessMacrosAndEnvironmentsWithMathReparse2(options) { + const { environments = {}, macros = {} } = options || {}; + const mathMacros = Object.fromEntries( + Object.entries(macros).filter( + ([_, info]) => { + var _a; + return ((_a = info.renderInfo) == null ? void 0 : _a.inMathMode) === true; + } + ) + ); + const mathEnvs = Object.fromEntries( + Object.entries(environments).filter( + ([_, info]) => { + var _a; + return ((_a = info.renderInfo) == null ? void 0 : _a.inMathMode) === true; + } + ) + ); + const mathReparser = unifiedLatexReparseMathConstructPlugin({ + mathEnvs: Object.keys(mathEnvs), + mathMacros: Object.keys(mathMacros) + }); + const isRelevantEnvironment = unifiedLatexUtilMatch.match.createEnvironmentMatcher(environments); + const isRelevantMathEnvironment = unifiedLatexUtilMatch.match.createEnvironmentMatcher(mathEnvs); + return (tree) => { + unifiedLatexUtilVisit.visit( + tree, + { + enter: (nodes) => { + if (!Array.isArray(nodes)) { + return; + } + unifiedLatexUtilArguments.attachMacroArgsInArray(nodes, mathMacros); + }, + leave: (node) => { + if (!isRelevantMathEnvironment(node)) { + return; + } + const envName = unifiedLatexUtilPrintRaw.printRaw(node.env); + const envInfo = environments[envName]; + if (!envInfo) { + throw new Error( + `Could not find environment info for environment "${envName}"` + ); + } + unifiedLatexUtilEnvironments.processEnvironment(node, envInfo); + } + }, + { includeArrays: true } + ); + mathReparser(tree); + unifiedLatexUtilVisit.visit( + tree, + { + enter: (nodes) => { + if (!Array.isArray(nodes)) { + return; + } + unifiedLatexUtilArguments.attachMacroArgsInArray(nodes, macros); + }, + leave: (node) => { + if (!isRelevantEnvironment(node)) { + return; + } + const envName = unifiedLatexUtilPrintRaw.printRaw(node.env); + const envInfo = environments[envName]; + if (!envInfo) { + throw new Error( + `Could not find environment info for environment "${envName}"` + ); + } + unifiedLatexUtilEnvironments.processEnvironment(node, envInfo); + } + }, + { includeArrays: true } + ); + }; +}; +const unifiedLatexProcessAtLetterAndExplMacros = function unifiedLatexProcessAtLetterAndExplMacros2(options) { + let { + atLetter = false, + expl3 = false, + autodetectExpl3AndAtLetter = false + } = options || {}; + return (tree) => { + unifiedLatexUtilCatcode.reparseExpl3AndAtLetterRegions(tree); + if (atLetter || expl3) { + autodetectExpl3AndAtLetter = false; + } + if (autodetectExpl3AndAtLetter) { + atLetter = unifiedLatexUtilCatcode.hasReparsableMacroNames(tree, "@"); + expl3 = unifiedLatexUtilCatcode.hasReparsableMacroNames(tree, "_"); + } + const charSet = /* @__PURE__ */ new Set(); + if (atLetter) { + charSet.add("@"); + } + if (expl3) { + charSet.add(":"); + charSet.add("_"); + } + if (charSet.size > 0) { + unifiedLatexUtilCatcode.reparseMacroNames(tree, charSet); + } + }; +}; +const unifiedLatexFromString = function unifiedLatexFromString2(options) { + const { + mode = "regular", + macros = {}, + environments = {}, + flags: { + atLetter = false, + expl3 = false, + autodetectExpl3AndAtLetter = false + } = {} + } = options || {}; + const allMacroInfo = Object.assign( + {}, + ...Object.values(unifiedLatexCtan.macroInfo), + macros + ); + const allEnvInfo = Object.assign( + {}, + ...Object.values(unifiedLatexCtan.environmentInfo), + environments + ); + const fullParser = unified().use(unifiedLatexFromStringMinimal, { mode }).use(unifiedLatexProcessAtLetterAndExplMacros, { + atLetter, + expl3, + autodetectExpl3AndAtLetter + }).use(unifiedLatexProcessMacrosAndEnvironmentsWithMathReparse, { + macros: allMacroInfo, + environments: allEnvInfo + }).use(unifiedLatexUtilTrim.unifiedLatexTrimEnvironmentContents).use(unifiedLatexUtilTrim.unifiedLatexTrimRoot).use(unifiedLatexAstComplier); + const parser2 = (str) => { + const file = fullParser.processSync({ value: str }); + return file.result; + }; + Object.assign(this, { Parser: parser2 }); +}; +let parser = unified().use(unifiedLatexFromString).freeze(); +function parse(str) { + return parser.parse(str); +} +function getParser(options) { + return options ? unified().use(unifiedLatexFromString, options).freeze() : parser; +} +function parseMath(str) { + if (typeof str !== "string") { + str = unifiedLatexUtilPrintRaw.printRaw(str); + } + const file = unified().use(unifiedLatexFromString, { mode: "math" }).use(unifiedLatexAstComplier).processSync({ value: str }); + return file.result.content; +} +exports.getParser = getParser; +exports.parse = parse; +exports.parseMath = parseMath; +exports.parseMathMinimal = parseMathMinimal; +exports.parseMinimal = parseMinimal; +exports.unifiedLatexAstComplier = unifiedLatexAstComplier; +exports.unifiedLatexFromString = unifiedLatexFromString; +exports.unifiedLatexFromStringMinimal = unifiedLatexFromStringMinimal; +exports.unifiedLatexProcessAtLetterAndExplMacros = unifiedLatexProcessAtLetterAndExplMacros; +exports.unifiedLatexProcessMacrosAndEnvironmentsWithMathReparse = unifiedLatexProcessMacrosAndEnvironmentsWithMathReparse; +exports.unifiedLatexReparseMath = unifiedLatexReparseMath; +exports.unifiedLatexReparseMathConstructPlugin = unifiedLatexReparseMathConstructPlugin; +//# sourceMappingURL=index.cjs.map diff --git a/node_modules/@unified-latex/unified-latex-util-parse/index.cjs.map b/node_modules/@unified-latex/unified-latex-util-parse/index.cjs.map new file mode 100644 index 0000000..600eaf5 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-util-parse/index.cjs.map @@ -0,0 +1 @@ +{"version":3,"file":"index.cjs","sources":["../libs/compiler-ast.ts","../../../node_modules/bail/index.js","../../../node_modules/is-buffer/index.js","../../../node_modules/extend/index.js","../node_modules/is-plain-obj/index.js","../../../node_modules/trough/lib/index.js","../node_modules/unist-util-stringify-position/lib/index.js","../node_modules/vfile-message/lib/index.js","../node_modules/vfile/lib/minpath.browser.js","../node_modules/vfile/lib/minproc.browser.js","../node_modules/vfile/lib/minurl.shared.js","../node_modules/vfile/lib/minurl.browser.js","../node_modules/vfile/lib/index.js","../node_modules/unified/lib/index.js","../libs/parse-minimal.ts","../libs/plugin-from-string-minimal.ts","../libs/reparse-math.ts","../libs/process-macros-and-environments.ts","../libs/process-at-letter-and-expl-macros.ts","../libs/plugin-from-string.ts","../libs/parse.ts","../libs/parse-math.ts"],"sourcesContent":["import { Plugin } from \"unified\";\nimport * as Ast from \"@unified-latex/unified-latex-types\";\n\n/**\n * Unified complier plugin that passes through a LaTeX AST without modification.\n */\nexport const unifiedLatexAstComplier: Plugin =\n function unifiedLatexAstComplier() {\n Object.assign(this, { Compiler: (x: Ast.Root) => x });\n };\n","/**\n * Throw a given error.\n *\n * @param {Error|null|undefined} [error]\n * Maybe error.\n * @returns {asserts error is null|undefined}\n */\nexport function bail(error) {\n if (error) {\n throw error\n }\n}\n","/*!\n * Determine if an object is a Buffer\n *\n * @author Feross Aboukhadijeh \n * @license MIT\n */\n\nmodule.exports = function isBuffer (obj) {\n return obj != null && obj.constructor != null &&\n typeof obj.constructor.isBuffer === 'function' && obj.constructor.isBuffer(obj)\n}\n","'use strict';\n\nvar hasOwn = Object.prototype.hasOwnProperty;\nvar toStr = Object.prototype.toString;\nvar defineProperty = Object.defineProperty;\nvar gOPD = Object.getOwnPropertyDescriptor;\n\nvar isArray = function isArray(arr) {\n\tif (typeof Array.isArray === 'function') {\n\t\treturn Array.isArray(arr);\n\t}\n\n\treturn toStr.call(arr) === '[object Array]';\n};\n\nvar isPlainObject = function isPlainObject(obj) {\n\tif (!obj || toStr.call(obj) !== '[object Object]') {\n\t\treturn false;\n\t}\n\n\tvar hasOwnConstructor = hasOwn.call(obj, 'constructor');\n\tvar hasIsPrototypeOf = obj.constructor && obj.constructor.prototype && hasOwn.call(obj.constructor.prototype, 'isPrototypeOf');\n\t// Not own constructor property must be Object\n\tif (obj.constructor && !hasOwnConstructor && !hasIsPrototypeOf) {\n\t\treturn false;\n\t}\n\n\t// Own properties are enumerated firstly, so to speed up,\n\t// if last one is own, then all properties are own.\n\tvar key;\n\tfor (key in obj) { /**/ }\n\n\treturn typeof key === 'undefined' || hasOwn.call(obj, key);\n};\n\n// If name is '__proto__', and Object.defineProperty is available, define __proto__ as an own property on target\nvar setProperty = function setProperty(target, options) {\n\tif (defineProperty && options.name === '__proto__') {\n\t\tdefineProperty(target, options.name, {\n\t\t\tenumerable: true,\n\t\t\tconfigurable: true,\n\t\t\tvalue: options.newValue,\n\t\t\twritable: true\n\t\t});\n\t} else {\n\t\ttarget[options.name] = options.newValue;\n\t}\n};\n\n// Return undefined instead of __proto__ if '__proto__' is not an own property\nvar getProperty = function getProperty(obj, name) {\n\tif (name === '__proto__') {\n\t\tif (!hasOwn.call(obj, name)) {\n\t\t\treturn void 0;\n\t\t} else if (gOPD) {\n\t\t\t// In early versions of node, obj['__proto__'] is buggy when obj has\n\t\t\t// __proto__ as an own property. Object.getOwnPropertyDescriptor() works.\n\t\t\treturn gOPD(obj, name).value;\n\t\t}\n\t}\n\n\treturn obj[name];\n};\n\nmodule.exports = function extend() {\n\tvar options, name, src, copy, copyIsArray, clone;\n\tvar target = arguments[0];\n\tvar i = 1;\n\tvar length = arguments.length;\n\tvar deep = false;\n\n\t// Handle a deep copy situation\n\tif (typeof target === 'boolean') {\n\t\tdeep = target;\n\t\ttarget = arguments[1] || {};\n\t\t// skip the boolean and the target\n\t\ti = 2;\n\t}\n\tif (target == null || (typeof target !== 'object' && typeof target !== 'function')) {\n\t\ttarget = {};\n\t}\n\n\tfor (; i < length; ++i) {\n\t\toptions = arguments[i];\n\t\t// Only deal with non-null/undefined values\n\t\tif (options != null) {\n\t\t\t// Extend the base object\n\t\t\tfor (name in options) {\n\t\t\t\tsrc = getProperty(target, name);\n\t\t\t\tcopy = getProperty(options, name);\n\n\t\t\t\t// Prevent never-ending loop\n\t\t\t\tif (target !== copy) {\n\t\t\t\t\t// Recurse if we're merging plain objects or arrays\n\t\t\t\t\tif (deep && copy && (isPlainObject(copy) || (copyIsArray = isArray(copy)))) {\n\t\t\t\t\t\tif (copyIsArray) {\n\t\t\t\t\t\t\tcopyIsArray = false;\n\t\t\t\t\t\t\tclone = src && isArray(src) ? src : [];\n\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\tclone = src && isPlainObject(src) ? src : {};\n\t\t\t\t\t\t}\n\n\t\t\t\t\t\t// Never move original objects, clone them\n\t\t\t\t\t\tsetProperty(target, { name: name, newValue: extend(deep, clone, copy) });\n\n\t\t\t\t\t// Don't bring in undefined values\n\t\t\t\t\t} else if (typeof copy !== 'undefined') {\n\t\t\t\t\t\tsetProperty(target, { name: name, newValue: copy });\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\t// Return the modified object\n\treturn target;\n};\n","export default function isPlainObject(value) {\n\tif (typeof value !== 'object' || value === null) {\n\t\treturn false;\n\t}\n\n\tconst prototype = Object.getPrototypeOf(value);\n\treturn (prototype === null || prototype === Object.prototype || Object.getPrototypeOf(prototype) === null) && !(Symbol.toStringTag in value) && !(Symbol.iterator in value);\n}\n","// To do: remove `void`s\n// To do: remove `null` from output of our APIs, allow it as user APIs.\n\n/**\n * @typedef {(error?: Error | null | undefined, ...output: Array) => void} Callback\n * Callback.\n *\n * @typedef {(...input: Array) => any} Middleware\n * Ware.\n *\n * @typedef Pipeline\n * Pipeline.\n * @property {Run} run\n * Run the pipeline.\n * @property {Use} use\n * Add middleware.\n *\n * @typedef {(...input: Array) => void} Run\n * Call all middleware.\n *\n * Calls `done` on completion with either an error or the output of the\n * last middleware.\n *\n * > 👉 **Note**: as the length of input defines whether async functions get a\n * > `next` function,\n * > it’s recommended to keep `input` at one value normally.\n\n *\n * @typedef {(fn: Middleware) => Pipeline} Use\n * Add middleware.\n */\n\n/**\n * Create new middleware.\n *\n * @returns {Pipeline}\n * Pipeline.\n */\nexport function trough() {\n /** @type {Array} */\n const fns = []\n /** @type {Pipeline} */\n const pipeline = {run, use}\n\n return pipeline\n\n /** @type {Run} */\n function run(...values) {\n let middlewareIndex = -1\n /** @type {Callback} */\n const callback = values.pop()\n\n if (typeof callback !== 'function') {\n throw new TypeError('Expected function as last argument, not ' + callback)\n }\n\n next(null, ...values)\n\n /**\n * Run the next `fn`, or we’re done.\n *\n * @param {Error | null | undefined} error\n * @param {Array} output\n */\n function next(error, ...output) {\n const fn = fns[++middlewareIndex]\n let index = -1\n\n if (error) {\n callback(error)\n return\n }\n\n // Copy non-nullish input into values.\n while (++index < values.length) {\n if (output[index] === null || output[index] === undefined) {\n output[index] = values[index]\n }\n }\n\n // Save the newly created `output` for the next call.\n values = output\n\n // Next or done.\n if (fn) {\n wrap(fn, next)(...output)\n } else {\n callback(null, ...output)\n }\n }\n }\n\n /** @type {Use} */\n function use(middelware) {\n if (typeof middelware !== 'function') {\n throw new TypeError(\n 'Expected `middelware` to be a function, not ' + middelware\n )\n }\n\n fns.push(middelware)\n return pipeline\n }\n}\n\n/**\n * Wrap `middleware` into a uniform interface.\n *\n * You can pass all input to the resulting function.\n * `callback` is then called with the output of `middleware`.\n *\n * If `middleware` accepts more arguments than the later given in input,\n * an extra `done` function is passed to it after that input,\n * which must be called by `middleware`.\n *\n * The first value in `input` is the main input value.\n * All other input values are the rest input values.\n * The values given to `callback` are the input values,\n * merged with every non-nullish output value.\n *\n * * if `middleware` throws an error,\n * returns a promise that is rejected,\n * or calls the given `done` function with an error,\n * `callback` is called with that error\n * * if `middleware` returns a value or returns a promise that is resolved,\n * that value is the main output value\n * * if `middleware` calls `done`,\n * all non-nullish values except for the first one (the error) overwrite the\n * output values\n *\n * @param {Middleware} middleware\n * Function to wrap.\n * @param {Callback} callback\n * Callback called with the output of `middleware`.\n * @returns {Run}\n * Wrapped middleware.\n */\nexport function wrap(middleware, callback) {\n /** @type {boolean} */\n let called\n\n return wrapped\n\n /**\n * Call `middleware`.\n * @this {any}\n * @param {Array} parameters\n * @returns {void}\n */\n function wrapped(...parameters) {\n const fnExpectsCallback = middleware.length > parameters.length\n /** @type {any} */\n let result\n\n if (fnExpectsCallback) {\n parameters.push(done)\n }\n\n try {\n result = middleware.apply(this, parameters)\n } catch (error) {\n const exception = /** @type {Error} */ (error)\n\n // Well, this is quite the pickle.\n // `middleware` received a callback and called it synchronously, but that\n // threw an error.\n // The only thing left to do is to throw the thing instead.\n if (fnExpectsCallback && called) {\n throw exception\n }\n\n return done(exception)\n }\n\n if (!fnExpectsCallback) {\n if (result && result.then && typeof result.then === 'function') {\n result.then(then, done)\n } else if (result instanceof Error) {\n done(result)\n } else {\n then(result)\n }\n }\n }\n\n /**\n * Call `callback`, only once.\n *\n * @type {Callback}\n */\n function done(error, ...output) {\n if (!called) {\n called = true\n callback(error, ...output)\n }\n }\n\n /**\n * Call `done` with one value.\n *\n * @param {any} [value]\n */\n function then(value) {\n done(null, value)\n }\n}\n","/**\n * @typedef {import('unist').Node} Node\n * @typedef {import('unist').Point} Point\n * @typedef {import('unist').Position} Position\n */\n\n/**\n * @typedef NodeLike\n * @property {string} type\n * @property {PositionLike | null | undefined} [position]\n *\n * @typedef PositionLike\n * @property {PointLike | null | undefined} [start]\n * @property {PointLike | null | undefined} [end]\n *\n * @typedef PointLike\n * @property {number | null | undefined} [line]\n * @property {number | null | undefined} [column]\n * @property {number | null | undefined} [offset]\n */\n\n/**\n * Serialize the positional info of a point, position (start and end points),\n * or node.\n *\n * @param {Node | NodeLike | Position | PositionLike | Point | PointLike | null | undefined} [value]\n * Node, position, or point.\n * @returns {string}\n * Pretty printed positional info of a node (`string`).\n *\n * In the format of a range `ls:cs-le:ce` (when given `node` or `position`)\n * or a point `l:c` (when given `point`), where `l` stands for line, `c` for\n * column, `s` for `start`, and `e` for end.\n * An empty string (`''`) is returned if the given value is neither `node`,\n * `position`, nor `point`.\n */\nexport function stringifyPosition(value) {\n // Nothing.\n if (!value || typeof value !== 'object') {\n return ''\n }\n\n // Node.\n if ('position' in value || 'type' in value) {\n return position(value.position)\n }\n\n // Position.\n if ('start' in value || 'end' in value) {\n return position(value)\n }\n\n // Point.\n if ('line' in value || 'column' in value) {\n return point(value)\n }\n\n // ?\n return ''\n}\n\n/**\n * @param {Point | PointLike | null | undefined} point\n * @returns {string}\n */\nfunction point(point) {\n return index(point && point.line) + ':' + index(point && point.column)\n}\n\n/**\n * @param {Position | PositionLike | null | undefined} pos\n * @returns {string}\n */\nfunction position(pos) {\n return point(pos && pos.start) + '-' + point(pos && pos.end)\n}\n\n/**\n * @param {number | null | undefined} value\n * @returns {number}\n */\nfunction index(value) {\n return value && typeof value === 'number' ? value : 1\n}\n","/**\n * @typedef {import('unist').Node} Node\n * @typedef {import('unist').Position} Position\n * @typedef {import('unist').Point} Point\n * @typedef {object & {type: string, position?: Position | undefined}} NodeLike\n */\n\nimport {stringifyPosition} from 'unist-util-stringify-position'\n\n/**\n * Message.\n */\nexport class VFileMessage extends Error {\n /**\n * Create a message for `reason` at `place` from `origin`.\n *\n * When an error is passed in as `reason`, the `stack` is copied.\n *\n * @param {string | Error | VFileMessage} reason\n * Reason for message, uses the stack and message of the error if given.\n *\n * > 👉 **Note**: you should use markdown.\n * @param {Node | NodeLike | Position | Point | null | undefined} [place]\n * Place in file where the message occurred.\n * @param {string | null | undefined} [origin]\n * Place in code where the message originates (example:\n * `'my-package:my-rule'` or `'my-rule'`).\n * @returns\n * Instance of `VFileMessage`.\n */\n // To do: next major: expose `undefined` everywhere instead of `null`.\n constructor(reason, place, origin) {\n /** @type {[string | null, string | null]} */\n const parts = [null, null]\n /** @type {Position} */\n let position = {\n // @ts-expect-error: we always follows the structure of `position`.\n start: {line: null, column: null},\n // @ts-expect-error: \"\n end: {line: null, column: null}\n }\n\n super()\n\n if (typeof place === 'string') {\n origin = place\n place = undefined\n }\n\n if (typeof origin === 'string') {\n const index = origin.indexOf(':')\n\n if (index === -1) {\n parts[1] = origin\n } else {\n parts[0] = origin.slice(0, index)\n parts[1] = origin.slice(index + 1)\n }\n }\n\n if (place) {\n // Node.\n if ('type' in place || 'position' in place) {\n if (place.position) {\n // To do: next major: deep clone.\n // @ts-expect-error: looks like a position.\n position = place.position\n }\n }\n // Position.\n else if ('start' in place || 'end' in place) {\n // @ts-expect-error: looks like a position.\n // To do: next major: deep clone.\n position = place\n }\n // Point.\n else if ('line' in place || 'column' in place) {\n // To do: next major: deep clone.\n position.start = place\n }\n }\n\n // Fields from `Error`.\n /**\n * Serialized positional info of error.\n *\n * On normal errors, this would be something like `ParseError`, buit in\n * `VFile` messages we use this space to show where an error happened.\n */\n this.name = stringifyPosition(place) || '1:1'\n\n /**\n * Reason for message.\n *\n * @type {string}\n */\n this.message = typeof reason === 'object' ? reason.message : reason\n\n /**\n * Stack of message.\n *\n * This is used by normal errors to show where something happened in\n * programming code, irrelevant for `VFile` messages,\n *\n * @type {string}\n */\n this.stack = ''\n\n if (typeof reason === 'object' && reason.stack) {\n this.stack = reason.stack\n }\n\n /**\n * Reason for message.\n *\n * > 👉 **Note**: you should use markdown.\n *\n * @type {string}\n */\n this.reason = this.message\n\n /* eslint-disable no-unused-expressions */\n /**\n * State of problem.\n *\n * * `true` — marks associated file as no longer processable (error)\n * * `false` — necessitates a (potential) change (warning)\n * * `null | undefined` — for things that might not need changing (info)\n *\n * @type {boolean | null | undefined}\n */\n this.fatal\n\n /**\n * Starting line of error.\n *\n * @type {number | null}\n */\n this.line = position.start.line\n\n /**\n * Starting column of error.\n *\n * @type {number | null}\n */\n this.column = position.start.column\n\n /**\n * Full unist position.\n *\n * @type {Position | null}\n */\n this.position = position\n\n /**\n * Namespace of message (example: `'my-package'`).\n *\n * @type {string | null}\n */\n this.source = parts[0]\n\n /**\n * Category of message (example: `'my-rule'`).\n *\n * @type {string | null}\n */\n this.ruleId = parts[1]\n\n /**\n * Path of a file (used throughout the `VFile` ecosystem).\n *\n * @type {string | null}\n */\n this.file\n\n // The following fields are “well known”.\n // Not standard.\n // Feel free to add other non-standard fields to your messages.\n\n /**\n * Specify the source value that’s being reported, which is deemed\n * incorrect.\n *\n * @type {string | null}\n */\n this.actual\n\n /**\n * Suggest acceptable values that can be used instead of `actual`.\n *\n * @type {Array | null}\n */\n this.expected\n\n /**\n * Link to docs for the message.\n *\n * > 👉 **Note**: this must be an absolute URL that can be passed as `x`\n * > to `new URL(x)`.\n *\n * @type {string | null}\n */\n this.url\n\n /**\n * Long form description of the message (you should use markdown).\n *\n * @type {string | null}\n */\n this.note\n /* eslint-enable no-unused-expressions */\n }\n}\n\nVFileMessage.prototype.file = ''\nVFileMessage.prototype.name = ''\nVFileMessage.prototype.reason = ''\nVFileMessage.prototype.message = ''\nVFileMessage.prototype.stack = ''\nVFileMessage.prototype.fatal = null\nVFileMessage.prototype.column = null\nVFileMessage.prototype.line = null\nVFileMessage.prototype.source = null\nVFileMessage.prototype.ruleId = null\nVFileMessage.prototype.position = null\n","// A derivative work based on:\n// .\n// Which is licensed:\n//\n// MIT License\n//\n// Copyright (c) 2013 James Halliday\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy of\n// this software and associated documentation files (the \"Software\"), to deal in\n// the Software without restriction, including without limitation the rights to\n// use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of\n// the Software, and to permit persons to whom the Software is furnished to do so,\n// subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in all\n// copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS\n// FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR\n// COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER\n// IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN\n// CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.\n// A derivative work based on:\n//\n// Parts of that are extracted from Node’s internal `path` module:\n// .\n// Which is licensed:\n//\n// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\nexport const path = {basename, dirname, extname, join, sep: '/'}\n\n/* eslint-disable max-depth, complexity */\n\n/**\n * Get the basename from a path.\n *\n * @param {string} path\n * File path.\n * @param {string | undefined} [ext]\n * Extension to strip.\n * @returns {string}\n * Stem or basename.\n */\nfunction basename(path, ext) {\n if (ext !== undefined && typeof ext !== 'string') {\n throw new TypeError('\"ext\" argument must be a string')\n }\n\n assertPath(path)\n let start = 0\n let end = -1\n let index = path.length\n /** @type {boolean | undefined} */\n let seenNonSlash\n\n if (ext === undefined || ext.length === 0 || ext.length > path.length) {\n while (index--) {\n if (path.charCodeAt(index) === 47 /* `/` */) {\n // If we reached a path separator that was not part of a set of path\n // separators at the end of the string, stop now.\n if (seenNonSlash) {\n start = index + 1\n break\n }\n } else if (end < 0) {\n // We saw the first non-path separator, mark this as the end of our\n // path component.\n seenNonSlash = true\n end = index + 1\n }\n }\n\n return end < 0 ? '' : path.slice(start, end)\n }\n\n if (ext === path) {\n return ''\n }\n\n let firstNonSlashEnd = -1\n let extIndex = ext.length - 1\n\n while (index--) {\n if (path.charCodeAt(index) === 47 /* `/` */) {\n // If we reached a path separator that was not part of a set of path\n // separators at the end of the string, stop now.\n if (seenNonSlash) {\n start = index + 1\n break\n }\n } else {\n if (firstNonSlashEnd < 0) {\n // We saw the first non-path separator, remember this index in case\n // we need it if the extension ends up not matching.\n seenNonSlash = true\n firstNonSlashEnd = index + 1\n }\n\n if (extIndex > -1) {\n // Try to match the explicit extension.\n if (path.charCodeAt(index) === ext.charCodeAt(extIndex--)) {\n if (extIndex < 0) {\n // We matched the extension, so mark this as the end of our path\n // component\n end = index\n }\n } else {\n // Extension does not match, so our result is the entire path\n // component\n extIndex = -1\n end = firstNonSlashEnd\n }\n }\n }\n }\n\n if (start === end) {\n end = firstNonSlashEnd\n } else if (end < 0) {\n end = path.length\n }\n\n return path.slice(start, end)\n}\n\n/**\n * Get the dirname from a path.\n *\n * @param {string} path\n * File path.\n * @returns {string}\n * File path.\n */\nfunction dirname(path) {\n assertPath(path)\n\n if (path.length === 0) {\n return '.'\n }\n\n let end = -1\n let index = path.length\n /** @type {boolean | undefined} */\n let unmatchedSlash\n\n // Prefix `--` is important to not run on `0`.\n while (--index) {\n if (path.charCodeAt(index) === 47 /* `/` */) {\n if (unmatchedSlash) {\n end = index\n break\n }\n } else if (!unmatchedSlash) {\n // We saw the first non-path separator\n unmatchedSlash = true\n }\n }\n\n return end < 0\n ? path.charCodeAt(0) === 47 /* `/` */\n ? '/'\n : '.'\n : end === 1 && path.charCodeAt(0) === 47 /* `/` */\n ? '//'\n : path.slice(0, end)\n}\n\n/**\n * Get an extname from a path.\n *\n * @param {string} path\n * File path.\n * @returns {string}\n * Extname.\n */\nfunction extname(path) {\n assertPath(path)\n\n let index = path.length\n\n let end = -1\n let startPart = 0\n let startDot = -1\n // Track the state of characters (if any) we see before our first dot and\n // after any path separator we find.\n let preDotState = 0\n /** @type {boolean | undefined} */\n let unmatchedSlash\n\n while (index--) {\n const code = path.charCodeAt(index)\n\n if (code === 47 /* `/` */) {\n // If we reached a path separator that was not part of a set of path\n // separators at the end of the string, stop now.\n if (unmatchedSlash) {\n startPart = index + 1\n break\n }\n\n continue\n }\n\n if (end < 0) {\n // We saw the first non-path separator, mark this as the end of our\n // extension.\n unmatchedSlash = true\n end = index + 1\n }\n\n if (code === 46 /* `.` */) {\n // If this is our first dot, mark it as the start of our extension.\n if (startDot < 0) {\n startDot = index\n } else if (preDotState !== 1) {\n preDotState = 1\n }\n } else if (startDot > -1) {\n // We saw a non-dot and non-path separator before our dot, so we should\n // have a good chance at having a non-empty extension.\n preDotState = -1\n }\n }\n\n if (\n startDot < 0 ||\n end < 0 ||\n // We saw a non-dot character immediately before the dot.\n preDotState === 0 ||\n // The (right-most) trimmed path component is exactly `..`.\n (preDotState === 1 && startDot === end - 1 && startDot === startPart + 1)\n ) {\n return ''\n }\n\n return path.slice(startDot, end)\n}\n\n/**\n * Join segments from a path.\n *\n * @param {Array} segments\n * Path segments.\n * @returns {string}\n * File path.\n */\nfunction join(...segments) {\n let index = -1\n /** @type {string | undefined} */\n let joined\n\n while (++index < segments.length) {\n assertPath(segments[index])\n\n if (segments[index]) {\n joined =\n joined === undefined ? segments[index] : joined + '/' + segments[index]\n }\n }\n\n return joined === undefined ? '.' : normalize(joined)\n}\n\n/**\n * Normalize a basic file path.\n *\n * @param {string} path\n * File path.\n * @returns {string}\n * File path.\n */\n// Note: `normalize` is not exposed as `path.normalize`, so some code is\n// manually removed from it.\nfunction normalize(path) {\n assertPath(path)\n\n const absolute = path.charCodeAt(0) === 47 /* `/` */\n\n // Normalize the path according to POSIX rules.\n let value = normalizeString(path, !absolute)\n\n if (value.length === 0 && !absolute) {\n value = '.'\n }\n\n if (value.length > 0 && path.charCodeAt(path.length - 1) === 47 /* / */) {\n value += '/'\n }\n\n return absolute ? '/' + value : value\n}\n\n/**\n * Resolve `.` and `..` elements in a path with directory names.\n *\n * @param {string} path\n * File path.\n * @param {boolean} allowAboveRoot\n * Whether `..` can move above root.\n * @returns {string}\n * File path.\n */\nfunction normalizeString(path, allowAboveRoot) {\n let result = ''\n let lastSegmentLength = 0\n let lastSlash = -1\n let dots = 0\n let index = -1\n /** @type {number | undefined} */\n let code\n /** @type {number} */\n let lastSlashIndex\n\n while (++index <= path.length) {\n if (index < path.length) {\n code = path.charCodeAt(index)\n } else if (code === 47 /* `/` */) {\n break\n } else {\n code = 47 /* `/` */\n }\n\n if (code === 47 /* `/` */) {\n if (lastSlash === index - 1 || dots === 1) {\n // Empty.\n } else if (lastSlash !== index - 1 && dots === 2) {\n if (\n result.length < 2 ||\n lastSegmentLength !== 2 ||\n result.charCodeAt(result.length - 1) !== 46 /* `.` */ ||\n result.charCodeAt(result.length - 2) !== 46 /* `.` */\n ) {\n if (result.length > 2) {\n lastSlashIndex = result.lastIndexOf('/')\n\n if (lastSlashIndex !== result.length - 1) {\n if (lastSlashIndex < 0) {\n result = ''\n lastSegmentLength = 0\n } else {\n result = result.slice(0, lastSlashIndex)\n lastSegmentLength = result.length - 1 - result.lastIndexOf('/')\n }\n\n lastSlash = index\n dots = 0\n continue\n }\n } else if (result.length > 0) {\n result = ''\n lastSegmentLength = 0\n lastSlash = index\n dots = 0\n continue\n }\n }\n\n if (allowAboveRoot) {\n result = result.length > 0 ? result + '/..' : '..'\n lastSegmentLength = 2\n }\n } else {\n if (result.length > 0) {\n result += '/' + path.slice(lastSlash + 1, index)\n } else {\n result = path.slice(lastSlash + 1, index)\n }\n\n lastSegmentLength = index - lastSlash - 1\n }\n\n lastSlash = index\n dots = 0\n } else if (code === 46 /* `.` */ && dots > -1) {\n dots++\n } else {\n dots = -1\n }\n }\n\n return result\n}\n\n/**\n * Make sure `path` is a string.\n *\n * @param {string} path\n * File path.\n * @returns {asserts path is string}\n * Nothing.\n */\nfunction assertPath(path) {\n if (typeof path !== 'string') {\n throw new TypeError(\n 'Path must be a string. Received ' + JSON.stringify(path)\n )\n }\n}\n\n/* eslint-enable max-depth, complexity */\n","// Somewhat based on:\n// .\n// But I don’t think one tiny line of code can be copyrighted. 😅\nexport const proc = {cwd}\n\nfunction cwd() {\n return '/'\n}\n","/**\n * @typedef URL\n * @property {string} hash\n * @property {string} host\n * @property {string} hostname\n * @property {string} href\n * @property {string} origin\n * @property {string} password\n * @property {string} pathname\n * @property {string} port\n * @property {string} protocol\n * @property {string} search\n * @property {any} searchParams\n * @property {string} username\n * @property {() => string} toString\n * @property {() => string} toJSON\n */\n\n/**\n * Check if `fileUrlOrPath` looks like a URL.\n *\n * @param {unknown} fileUrlOrPath\n * File path or URL.\n * @returns {fileUrlOrPath is URL}\n * Whether it’s a URL.\n */\n// From: \nexport function isUrl(fileUrlOrPath) {\n return (\n fileUrlOrPath !== null &&\n typeof fileUrlOrPath === 'object' &&\n // @ts-expect-error: indexable.\n fileUrlOrPath.href &&\n // @ts-expect-error: indexable.\n fileUrlOrPath.origin\n )\n}\n","/// \n\nimport {isUrl} from './minurl.shared.js'\n\n// See: \n\n/**\n * @param {string | URL} path\n * File URL.\n * @returns {string}\n * File URL.\n */\nexport function urlToPath(path) {\n if (typeof path === 'string') {\n path = new URL(path)\n } else if (!isUrl(path)) {\n /** @type {NodeJS.ErrnoException} */\n const error = new TypeError(\n 'The \"path\" argument must be of type string or an instance of URL. Received `' +\n path +\n '`'\n )\n error.code = 'ERR_INVALID_ARG_TYPE'\n throw error\n }\n\n if (path.protocol !== 'file:') {\n /** @type {NodeJS.ErrnoException} */\n const error = new TypeError('The URL must be of scheme file')\n error.code = 'ERR_INVALID_URL_SCHEME'\n throw error\n }\n\n return getPathFromURLPosix(path)\n}\n\n/**\n * Get a path from a POSIX URL.\n *\n * @param {URL} url\n * URL.\n * @returns {string}\n * File path.\n */\nfunction getPathFromURLPosix(url) {\n if (url.hostname !== '') {\n /** @type {NodeJS.ErrnoException} */\n const error = new TypeError(\n 'File URL host must be \"localhost\" or empty on darwin'\n )\n error.code = 'ERR_INVALID_FILE_URL_HOST'\n throw error\n }\n\n const pathname = url.pathname\n let index = -1\n\n while (++index < pathname.length) {\n if (\n pathname.charCodeAt(index) === 37 /* `%` */ &&\n pathname.charCodeAt(index + 1) === 50 /* `2` */\n ) {\n const third = pathname.charCodeAt(index + 2)\n if (third === 70 /* `F` */ || third === 102 /* `f` */) {\n /** @type {NodeJS.ErrnoException} */\n const error = new TypeError(\n 'File URL path must not include encoded / characters'\n )\n error.code = 'ERR_INVALID_FILE_URL_PATH'\n throw error\n }\n }\n }\n\n return decodeURIComponent(pathname)\n}\n\nexport {isUrl} from './minurl.shared.js'\n","/**\n * @typedef {import('unist').Node} Node\n * @typedef {import('unist').Position} Position\n * @typedef {import('unist').Point} Point\n * @typedef {import('./minurl.shared.js').URL} URL\n * @typedef {import('../index.js').Data} Data\n * @typedef {import('../index.js').Value} Value\n */\n\n/**\n * @typedef {Record & {type: string, position?: Position | undefined}} NodeLike\n *\n * @typedef {'ascii' | 'utf8' | 'utf-8' | 'utf16le' | 'ucs2' | 'ucs-2' | 'base64' | 'base64url' | 'latin1' | 'binary' | 'hex'} BufferEncoding\n * Encodings supported by the buffer class.\n *\n * This is a copy of the types from Node, copied to prevent Node globals from\n * being needed.\n * Copied from: \n *\n * @typedef {Options | URL | Value | VFile} Compatible\n * Things that can be passed to the constructor.\n *\n * @typedef VFileCoreOptions\n * Set multiple values.\n * @property {Value | null | undefined} [value]\n * Set `value`.\n * @property {string | null | undefined} [cwd]\n * Set `cwd`.\n * @property {Array | null | undefined} [history]\n * Set `history`.\n * @property {URL | string | null | undefined} [path]\n * Set `path`.\n * @property {string | null | undefined} [basename]\n * Set `basename`.\n * @property {string | null | undefined} [stem]\n * Set `stem`.\n * @property {string | null | undefined} [extname]\n * Set `extname`.\n * @property {string | null | undefined} [dirname]\n * Set `dirname`.\n * @property {Data | null | undefined} [data]\n * Set `data`.\n *\n * @typedef Map\n * Raw source map.\n *\n * See:\n * .\n * @property {number} version\n * Which version of the source map spec this map is following.\n * @property {Array} sources\n * An array of URLs to the original source files.\n * @property {Array} names\n * An array of identifiers which can be referenced by individual mappings.\n * @property {string | undefined} [sourceRoot]\n * The URL root from which all sources are relative.\n * @property {Array | undefined} [sourcesContent]\n * An array of contents of the original source files.\n * @property {string} mappings\n * A string of base64 VLQs which contain the actual mappings.\n * @property {string} file\n * The generated file this source map is associated with.\n *\n * @typedef {{[key: string]: unknown} & VFileCoreOptions} Options\n * Configuration.\n *\n * A bunch of keys that will be shallow copied over to the new file.\n *\n * @typedef {Record} ReporterSettings\n * Configuration for reporters.\n */\n\n/**\n * @template {ReporterSettings} Settings\n * Options type.\n * @callback Reporter\n * Type for a reporter.\n * @param {Array} files\n * Files to report.\n * @param {Settings} options\n * Configuration.\n * @returns {string}\n * Report.\n */\n\nimport bufferLike from 'is-buffer'\nimport {VFileMessage} from 'vfile-message'\nimport {path} from './minpath.js'\nimport {proc} from './minproc.js'\nimport {urlToPath, isUrl} from './minurl.js'\n\n/**\n * Order of setting (least specific to most), we need this because otherwise\n * `{stem: 'a', path: '~/b.js'}` would throw, as a path is needed before a\n * stem can be set.\n *\n * @type {Array<'basename' | 'dirname' | 'extname' | 'history' | 'path' | 'stem'>}\n */\nconst order = ['history', 'path', 'basename', 'stem', 'extname', 'dirname']\n\nexport class VFile {\n /**\n * Create a new virtual file.\n *\n * `options` is treated as:\n *\n * * `string` or `Buffer` — `{value: options}`\n * * `URL` — `{path: options}`\n * * `VFile` — shallow copies its data over to the new file\n * * `object` — all fields are shallow copied over to the new file\n *\n * Path related fields are set in the following order (least specific to\n * most specific): `history`, `path`, `basename`, `stem`, `extname`,\n * `dirname`.\n *\n * You cannot set `dirname` or `extname` without setting either `history`,\n * `path`, `basename`, or `stem` too.\n *\n * @param {Compatible | null | undefined} [value]\n * File value.\n * @returns\n * New instance.\n */\n constructor(value) {\n /** @type {Options | VFile} */\n let options\n\n if (!value) {\n options = {}\n } else if (typeof value === 'string' || buffer(value)) {\n options = {value}\n } else if (isUrl(value)) {\n options = {path: value}\n } else {\n options = value\n }\n\n /**\n * Place to store custom information (default: `{}`).\n *\n * It’s OK to store custom data directly on the file but moving it to\n * `data` is recommended.\n *\n * @type {Data}\n */\n this.data = {}\n\n /**\n * List of messages associated with the file.\n *\n * @type {Array}\n */\n this.messages = []\n\n /**\n * List of filepaths the file moved between.\n *\n * The first is the original path and the last is the current path.\n *\n * @type {Array}\n */\n this.history = []\n\n /**\n * Base of `path` (default: `process.cwd()` or `'/'` in browsers).\n *\n * @type {string}\n */\n this.cwd = proc.cwd()\n\n /* eslint-disable no-unused-expressions */\n /**\n * Raw value.\n *\n * @type {Value}\n */\n this.value\n\n // The below are non-standard, they are “well-known”.\n // As in, used in several tools.\n\n /**\n * Whether a file was saved to disk.\n *\n * This is used by vfile reporters.\n *\n * @type {boolean}\n */\n this.stored\n\n /**\n * Custom, non-string, compiled, representation.\n *\n * This is used by unified to store non-string results.\n * One example is when turning markdown into React nodes.\n *\n * @type {unknown}\n */\n this.result\n\n /**\n * Source map.\n *\n * This type is equivalent to the `RawSourceMap` type from the `source-map`\n * module.\n *\n * @type {Map | null | undefined}\n */\n this.map\n /* eslint-enable no-unused-expressions */\n\n // Set path related properties in the correct order.\n let index = -1\n\n while (++index < order.length) {\n const prop = order[index]\n\n // Note: we specifically use `in` instead of `hasOwnProperty` to accept\n // `vfile`s too.\n if (\n prop in options &&\n options[prop] !== undefined &&\n options[prop] !== null\n ) {\n // @ts-expect-error: TS doesn’t understand basic reality.\n this[prop] = prop === 'history' ? [...options[prop]] : options[prop]\n }\n }\n\n /** @type {string} */\n let prop\n\n // Set non-path related properties.\n for (prop in options) {\n // @ts-expect-error: fine to set other things.\n if (!order.includes(prop)) {\n // @ts-expect-error: fine to set other things.\n this[prop] = options[prop]\n }\n }\n }\n\n /**\n * Get the full path (example: `'~/index.min.js'`).\n *\n * @returns {string}\n */\n get path() {\n return this.history[this.history.length - 1]\n }\n\n /**\n * Set the full path (example: `'~/index.min.js'`).\n *\n * Cannot be nullified.\n * You can set a file URL (a `URL` object with a `file:` protocol) which will\n * be turned into a path with `url.fileURLToPath`.\n *\n * @param {string | URL} path\n */\n set path(path) {\n if (isUrl(path)) {\n path = urlToPath(path)\n }\n\n assertNonEmpty(path, 'path')\n\n if (this.path !== path) {\n this.history.push(path)\n }\n }\n\n /**\n * Get the parent path (example: `'~'`).\n */\n get dirname() {\n return typeof this.path === 'string' ? path.dirname(this.path) : undefined\n }\n\n /**\n * Set the parent path (example: `'~'`).\n *\n * Cannot be set if there’s no `path` yet.\n */\n set dirname(dirname) {\n assertPath(this.basename, 'dirname')\n this.path = path.join(dirname || '', this.basename)\n }\n\n /**\n * Get the basename (including extname) (example: `'index.min.js'`).\n */\n get basename() {\n return typeof this.path === 'string' ? path.basename(this.path) : undefined\n }\n\n /**\n * Set basename (including extname) (`'index.min.js'`).\n *\n * Cannot contain path separators (`'/'` on unix, macOS, and browsers, `'\\'`\n * on windows).\n * Cannot be nullified (use `file.path = file.dirname` instead).\n */\n set basename(basename) {\n assertNonEmpty(basename, 'basename')\n assertPart(basename, 'basename')\n this.path = path.join(this.dirname || '', basename)\n }\n\n /**\n * Get the extname (including dot) (example: `'.js'`).\n */\n get extname() {\n return typeof this.path === 'string' ? path.extname(this.path) : undefined\n }\n\n /**\n * Set the extname (including dot) (example: `'.js'`).\n *\n * Cannot contain path separators (`'/'` on unix, macOS, and browsers, `'\\'`\n * on windows).\n * Cannot be set if there’s no `path` yet.\n */\n set extname(extname) {\n assertPart(extname, 'extname')\n assertPath(this.dirname, 'extname')\n\n if (extname) {\n if (extname.charCodeAt(0) !== 46 /* `.` */) {\n throw new Error('`extname` must start with `.`')\n }\n\n if (extname.includes('.', 1)) {\n throw new Error('`extname` cannot contain multiple dots')\n }\n }\n\n this.path = path.join(this.dirname, this.stem + (extname || ''))\n }\n\n /**\n * Get the stem (basename w/o extname) (example: `'index.min'`).\n */\n get stem() {\n return typeof this.path === 'string'\n ? path.basename(this.path, this.extname)\n : undefined\n }\n\n /**\n * Set the stem (basename w/o extname) (example: `'index.min'`).\n *\n * Cannot contain path separators (`'/'` on unix, macOS, and browsers, `'\\'`\n * on windows).\n * Cannot be nullified (use `file.path = file.dirname` instead).\n */\n set stem(stem) {\n assertNonEmpty(stem, 'stem')\n assertPart(stem, 'stem')\n this.path = path.join(this.dirname || '', stem + (this.extname || ''))\n }\n\n /**\n * Serialize the file.\n *\n * @param {BufferEncoding | null | undefined} [encoding='utf8']\n * Character encoding to understand `value` as when it’s a `Buffer`\n * (default: `'utf8'`).\n * @returns {string}\n * Serialized file.\n */\n toString(encoding) {\n return (this.value || '').toString(encoding || undefined)\n }\n\n /**\n * Create a warning message associated with the file.\n *\n * Its `fatal` is set to `false` and `file` is set to the current file path.\n * Its added to `file.messages`.\n *\n * @param {string | Error | VFileMessage} reason\n * Reason for message, uses the stack and message of the error if given.\n * @param {Node | NodeLike | Position | Point | null | undefined} [place]\n * Place in file where the message occurred.\n * @param {string | null | undefined} [origin]\n * Place in code where the message originates (example:\n * `'my-package:my-rule'` or `'my-rule'`).\n * @returns {VFileMessage}\n * Message.\n */\n message(reason, place, origin) {\n const message = new VFileMessage(reason, place, origin)\n\n if (this.path) {\n message.name = this.path + ':' + message.name\n message.file = this.path\n }\n\n message.fatal = false\n\n this.messages.push(message)\n\n return message\n }\n\n /**\n * Create an info message associated with the file.\n *\n * Its `fatal` is set to `null` and `file` is set to the current file path.\n * Its added to `file.messages`.\n *\n * @param {string | Error | VFileMessage} reason\n * Reason for message, uses the stack and message of the error if given.\n * @param {Node | NodeLike | Position | Point | null | undefined} [place]\n * Place in file where the message occurred.\n * @param {string | null | undefined} [origin]\n * Place in code where the message originates (example:\n * `'my-package:my-rule'` or `'my-rule'`).\n * @returns {VFileMessage}\n * Message.\n */\n info(reason, place, origin) {\n const message = this.message(reason, place, origin)\n\n message.fatal = null\n\n return message\n }\n\n /**\n * Create a fatal error associated with the file.\n *\n * Its `fatal` is set to `true` and `file` is set to the current file path.\n * Its added to `file.messages`.\n *\n * > 👉 **Note**: a fatal error means that a file is no longer processable.\n *\n * @param {string | Error | VFileMessage} reason\n * Reason for message, uses the stack and message of the error if given.\n * @param {Node | NodeLike | Position | Point | null | undefined} [place]\n * Place in file where the message occurred.\n * @param {string | null | undefined} [origin]\n * Place in code where the message originates (example:\n * `'my-package:my-rule'` or `'my-rule'`).\n * @returns {never}\n * Message.\n * @throws {VFileMessage}\n * Message.\n */\n fail(reason, place, origin) {\n const message = this.message(reason, place, origin)\n\n message.fatal = true\n\n throw message\n }\n}\n\n/**\n * Assert that `part` is not a path (as in, does not contain `path.sep`).\n *\n * @param {string | null | undefined} part\n * File path part.\n * @param {string} name\n * Part name.\n * @returns {void}\n * Nothing.\n */\nfunction assertPart(part, name) {\n if (part && part.includes(path.sep)) {\n throw new Error(\n '`' + name + '` cannot be a path: did not expect `' + path.sep + '`'\n )\n }\n}\n\n/**\n * Assert that `part` is not empty.\n *\n * @param {string | undefined} part\n * Thing.\n * @param {string} name\n * Part name.\n * @returns {asserts part is string}\n * Nothing.\n */\nfunction assertNonEmpty(part, name) {\n if (!part) {\n throw new Error('`' + name + '` cannot be empty')\n }\n}\n\n/**\n * Assert `path` exists.\n *\n * @param {string | undefined} path\n * Path.\n * @param {string} name\n * Dependency name.\n * @returns {asserts path is string}\n * Nothing.\n */\nfunction assertPath(path, name) {\n if (!path) {\n throw new Error('Setting `' + name + '` requires `path` to be set too')\n }\n}\n\n/**\n * Assert `value` is a buffer.\n *\n * @param {unknown} value\n * thing.\n * @returns {value is Buffer}\n * Whether `value` is a Node.js buffer.\n */\nfunction buffer(value) {\n return bufferLike(value)\n}\n","/**\n * @typedef {import('unist').Node} Node\n * @typedef {import('vfile').VFileCompatible} VFileCompatible\n * @typedef {import('vfile').VFileValue} VFileValue\n * @typedef {import('..').Processor} Processor\n * @typedef {import('..').Plugin} Plugin\n * @typedef {import('..').Preset} Preset\n * @typedef {import('..').Pluggable} Pluggable\n * @typedef {import('..').PluggableList} PluggableList\n * @typedef {import('..').Transformer} Transformer\n * @typedef {import('..').Parser} Parser\n * @typedef {import('..').Compiler} Compiler\n * @typedef {import('..').RunCallback} RunCallback\n * @typedef {import('..').ProcessCallback} ProcessCallback\n *\n * @typedef Context\n * @property {Node} tree\n * @property {VFile} file\n */\n\nimport {bail} from 'bail'\nimport isBuffer from 'is-buffer'\nimport extend from 'extend'\nimport isPlainObj from 'is-plain-obj'\nimport {trough} from 'trough'\nimport {VFile} from 'vfile'\n\n// Expose a frozen processor.\nexport const unified = base().freeze()\n\nconst own = {}.hasOwnProperty\n\n// Function to create the first processor.\n/**\n * @returns {Processor}\n */\nfunction base() {\n const transformers = trough()\n /** @type {Processor['attachers']} */\n const attachers = []\n /** @type {Record} */\n let namespace = {}\n /** @type {boolean|undefined} */\n let frozen\n let freezeIndex = -1\n\n // Data management.\n // @ts-expect-error: overloads are handled.\n processor.data = data\n processor.Parser = undefined\n processor.Compiler = undefined\n\n // Lock.\n processor.freeze = freeze\n\n // Plugins.\n processor.attachers = attachers\n // @ts-expect-error: overloads are handled.\n processor.use = use\n\n // API.\n processor.parse = parse\n processor.stringify = stringify\n // @ts-expect-error: overloads are handled.\n processor.run = run\n processor.runSync = runSync\n // @ts-expect-error: overloads are handled.\n processor.process = process\n processor.processSync = processSync\n\n // Expose.\n return processor\n\n // Create a new processor based on the processor in the current scope.\n /** @type {Processor} */\n function processor() {\n const destination = base()\n let index = -1\n\n while (++index < attachers.length) {\n destination.use(...attachers[index])\n }\n\n destination.data(extend(true, {}, namespace))\n\n return destination\n }\n\n /**\n * @param {string|Record} [key]\n * @param {unknown} [value]\n * @returns {unknown}\n */\n function data(key, value) {\n if (typeof key === 'string') {\n // Set `key`.\n if (arguments.length === 2) {\n assertUnfrozen('data', frozen)\n namespace[key] = value\n return processor\n }\n\n // Get `key`.\n return (own.call(namespace, key) && namespace[key]) || null\n }\n\n // Set space.\n if (key) {\n assertUnfrozen('data', frozen)\n namespace = key\n return processor\n }\n\n // Get space.\n return namespace\n }\n\n /** @type {Processor['freeze']} */\n function freeze() {\n if (frozen) {\n return processor\n }\n\n while (++freezeIndex < attachers.length) {\n const [attacher, ...options] = attachers[freezeIndex]\n\n if (options[0] === false) {\n continue\n }\n\n if (options[0] === true) {\n options[0] = undefined\n }\n\n /** @type {Transformer|void} */\n const transformer = attacher.call(processor, ...options)\n\n if (typeof transformer === 'function') {\n transformers.use(transformer)\n }\n }\n\n frozen = true\n freezeIndex = Number.POSITIVE_INFINITY\n\n return processor\n }\n\n /**\n * @param {Pluggable|null|undefined} [value]\n * @param {...unknown} options\n * @returns {Processor}\n */\n function use(value, ...options) {\n /** @type {Record|undefined} */\n let settings\n\n assertUnfrozen('use', frozen)\n\n if (value === null || value === undefined) {\n // Empty.\n } else if (typeof value === 'function') {\n addPlugin(value, ...options)\n } else if (typeof value === 'object') {\n if (Array.isArray(value)) {\n addList(value)\n } else {\n addPreset(value)\n }\n } else {\n throw new TypeError('Expected usable value, not `' + value + '`')\n }\n\n if (settings) {\n namespace.settings = Object.assign(namespace.settings || {}, settings)\n }\n\n return processor\n\n /**\n * @param {import('..').Pluggable} value\n * @returns {void}\n */\n function add(value) {\n if (typeof value === 'function') {\n addPlugin(value)\n } else if (typeof value === 'object') {\n if (Array.isArray(value)) {\n const [plugin, ...options] = value\n addPlugin(plugin, ...options)\n } else {\n addPreset(value)\n }\n } else {\n throw new TypeError('Expected usable value, not `' + value + '`')\n }\n }\n\n /**\n * @param {Preset} result\n * @returns {void}\n */\n function addPreset(result) {\n addList(result.plugins)\n\n if (result.settings) {\n settings = Object.assign(settings || {}, result.settings)\n }\n }\n\n /**\n * @param {PluggableList|null|undefined} [plugins]\n * @returns {void}\n */\n function addList(plugins) {\n let index = -1\n\n if (plugins === null || plugins === undefined) {\n // Empty.\n } else if (Array.isArray(plugins)) {\n while (++index < plugins.length) {\n const thing = plugins[index]\n add(thing)\n }\n } else {\n throw new TypeError('Expected a list of plugins, not `' + plugins + '`')\n }\n }\n\n /**\n * @param {Plugin} plugin\n * @param {...unknown} [value]\n * @returns {void}\n */\n function addPlugin(plugin, value) {\n let index = -1\n /** @type {Processor['attachers'][number]|undefined} */\n let entry\n\n while (++index < attachers.length) {\n if (attachers[index][0] === plugin) {\n entry = attachers[index]\n break\n }\n }\n\n if (entry) {\n if (isPlainObj(entry[1]) && isPlainObj(value)) {\n value = extend(true, entry[1], value)\n }\n\n entry[1] = value\n } else {\n // @ts-expect-error: fine.\n attachers.push([...arguments])\n }\n }\n }\n\n /** @type {Processor['parse']} */\n function parse(doc) {\n processor.freeze()\n const file = vfile(doc)\n const Parser = processor.Parser\n assertParser('parse', Parser)\n\n if (newable(Parser, 'parse')) {\n // @ts-expect-error: `newable` checks this.\n return new Parser(String(file), file).parse()\n }\n\n // @ts-expect-error: `newable` checks this.\n return Parser(String(file), file) // eslint-disable-line new-cap\n }\n\n /** @type {Processor['stringify']} */\n function stringify(node, doc) {\n processor.freeze()\n const file = vfile(doc)\n const Compiler = processor.Compiler\n assertCompiler('stringify', Compiler)\n assertNode(node)\n\n if (newable(Compiler, 'compile')) {\n // @ts-expect-error: `newable` checks this.\n return new Compiler(node, file).compile()\n }\n\n // @ts-expect-error: `newable` checks this.\n return Compiler(node, file) // eslint-disable-line new-cap\n }\n\n /**\n * @param {Node} node\n * @param {VFileCompatible|RunCallback} [doc]\n * @param {RunCallback} [callback]\n * @returns {Promise|void}\n */\n function run(node, doc, callback) {\n assertNode(node)\n processor.freeze()\n\n if (!callback && typeof doc === 'function') {\n callback = doc\n doc = undefined\n }\n\n if (!callback) {\n return new Promise(executor)\n }\n\n executor(null, callback)\n\n /**\n * @param {null|((node: Node) => void)} resolve\n * @param {(error: Error) => void} reject\n * @returns {void}\n */\n function executor(resolve, reject) {\n // @ts-expect-error: `doc` can’t be a callback anymore, we checked.\n transformers.run(node, vfile(doc), done)\n\n /**\n * @param {Error|null} error\n * @param {Node} tree\n * @param {VFile} file\n * @returns {void}\n */\n function done(error, tree, file) {\n tree = tree || node\n if (error) {\n reject(error)\n } else if (resolve) {\n resolve(tree)\n } else {\n // @ts-expect-error: `callback` is defined if `resolve` is not.\n callback(null, tree, file)\n }\n }\n }\n }\n\n /** @type {Processor['runSync']} */\n function runSync(node, file) {\n /** @type {Node|undefined} */\n let result\n /** @type {boolean|undefined} */\n let complete\n\n processor.run(node, file, done)\n\n assertDone('runSync', 'run', complete)\n\n // @ts-expect-error: we either bailed on an error or have a tree.\n return result\n\n /**\n * @param {Error|null} [error]\n * @param {Node} [tree]\n * @returns {void}\n */\n function done(error, tree) {\n bail(error)\n result = tree\n complete = true\n }\n }\n\n /**\n * @param {VFileCompatible} doc\n * @param {ProcessCallback} [callback]\n * @returns {Promise|undefined}\n */\n function process(doc, callback) {\n processor.freeze()\n assertParser('process', processor.Parser)\n assertCompiler('process', processor.Compiler)\n\n if (!callback) {\n return new Promise(executor)\n }\n\n executor(null, callback)\n\n /**\n * @param {null|((file: VFile) => void)} resolve\n * @param {(error?: Error|null|undefined) => void} reject\n * @returns {void}\n */\n function executor(resolve, reject) {\n const file = vfile(doc)\n\n processor.run(processor.parse(file), file, (error, tree, file) => {\n if (error || !tree || !file) {\n done(error)\n } else {\n /** @type {unknown} */\n const result = processor.stringify(tree, file)\n\n if (result === undefined || result === null) {\n // Empty.\n } else if (looksLikeAVFileValue(result)) {\n file.value = result\n } else {\n file.result = result\n }\n\n done(error, file)\n }\n })\n\n /**\n * @param {Error|null|undefined} [error]\n * @param {VFile|undefined} [file]\n * @returns {void}\n */\n function done(error, file) {\n if (error || !file) {\n reject(error)\n } else if (resolve) {\n resolve(file)\n } else {\n // @ts-expect-error: `callback` is defined if `resolve` is not.\n callback(null, file)\n }\n }\n }\n }\n\n /** @type {Processor['processSync']} */\n function processSync(doc) {\n /** @type {boolean|undefined} */\n let complete\n\n processor.freeze()\n assertParser('processSync', processor.Parser)\n assertCompiler('processSync', processor.Compiler)\n\n const file = vfile(doc)\n\n processor.process(file, done)\n\n assertDone('processSync', 'process', complete)\n\n return file\n\n /**\n * @param {Error|null|undefined} [error]\n * @returns {void}\n */\n function done(error) {\n complete = true\n bail(error)\n }\n }\n}\n\n/**\n * Check if `value` is a constructor.\n *\n * @param {unknown} value\n * @param {string} name\n * @returns {boolean}\n */\nfunction newable(value, name) {\n return (\n typeof value === 'function' &&\n // Prototypes do exist.\n // type-coverage:ignore-next-line\n value.prototype &&\n // A function with keys in its prototype is probably a constructor.\n // Classes’ prototype methods are not enumerable, so we check if some value\n // exists in the prototype.\n // type-coverage:ignore-next-line\n (keys(value.prototype) || name in value.prototype)\n )\n}\n\n/**\n * Check if `value` is an object with keys.\n *\n * @param {Record} value\n * @returns {boolean}\n */\nfunction keys(value) {\n /** @type {string} */\n let key\n\n for (key in value) {\n if (own.call(value, key)) {\n return true\n }\n }\n\n return false\n}\n\n/**\n * Assert a parser is available.\n *\n * @param {string} name\n * @param {unknown} value\n * @returns {asserts value is Parser}\n */\nfunction assertParser(name, value) {\n if (typeof value !== 'function') {\n throw new TypeError('Cannot `' + name + '` without `Parser`')\n }\n}\n\n/**\n * Assert a compiler is available.\n *\n * @param {string} name\n * @param {unknown} value\n * @returns {asserts value is Compiler}\n */\nfunction assertCompiler(name, value) {\n if (typeof value !== 'function') {\n throw new TypeError('Cannot `' + name + '` without `Compiler`')\n }\n}\n\n/**\n * Assert the processor is not frozen.\n *\n * @param {string} name\n * @param {unknown} frozen\n * @returns {asserts frozen is false}\n */\nfunction assertUnfrozen(name, frozen) {\n if (frozen) {\n throw new Error(\n 'Cannot call `' +\n name +\n '` on a frozen processor.\\nCreate a new processor first, by calling it: use `processor()` instead of `processor`.'\n )\n }\n}\n\n/**\n * Assert `node` is a unist node.\n *\n * @param {unknown} node\n * @returns {asserts node is Node}\n */\nfunction assertNode(node) {\n // `isPlainObj` unfortunately uses `any` instead of `unknown`.\n // type-coverage:ignore-next-line\n if (!isPlainObj(node) || typeof node.type !== 'string') {\n throw new TypeError('Expected node, got `' + node + '`')\n // Fine.\n }\n}\n\n/**\n * Assert that `complete` is `true`.\n *\n * @param {string} name\n * @param {string} asyncName\n * @param {unknown} complete\n * @returns {asserts complete is true}\n */\nfunction assertDone(name, asyncName, complete) {\n if (!complete) {\n throw new Error(\n '`' + name + '` finished async. Use `' + asyncName + '` instead'\n )\n }\n}\n\n/**\n * @param {VFileCompatible} [value]\n * @returns {VFile}\n */\nfunction vfile(value) {\n return looksLikeAVFile(value) ? value : new VFile(value)\n}\n\n/**\n * @param {VFileCompatible} [value]\n * @returns {value is VFile}\n */\nfunction looksLikeAVFile(value) {\n return Boolean(\n value &&\n typeof value === 'object' &&\n 'message' in value &&\n 'messages' in value\n )\n}\n\n/**\n * @param {unknown} [value]\n * @returns {value is VFileValue}\n */\nfunction looksLikeAVFileValue(value) {\n return typeof value === 'string' || isBuffer(value)\n}\n","import { LatexPegParser } from \"@unified-latex/unified-latex-util-pegjs\";\nimport * as Ast from \"@unified-latex/unified-latex-types\";\n\n/**\n * Parse `str` to an AST with minimal processing. E.g., macro\n * arguments are not attached to macros, etc. when parsed with this\n * function.\n */\nexport function parseMinimal(str: string): Ast.Root {\n return LatexPegParser.parse(str);\n}\n\n/**\n * Parse `str` to an AST with minimal processing. E.g., macro\n * arguments are not attached to macros, etc. when parsed with this\n * function.\n *\n * The parsing assumes a math-mode context, so, for example, `^` and `_` are\n * parsed as macros (even though arguments are not attached to them).\n */\nexport function parseMathMinimal(str: string): Ast.Node[] {\n return LatexPegParser.parse(str, { startRule: \"math\" });\n}\n","import { Plugin, Parser } from \"unified\";\nimport * as Ast from \"@unified-latex/unified-latex-types\";\nimport { parseMathMinimal, parseMinimal } from \"./parse-minimal\";\n\ntype PluginOptions = {\n /**\n * Whether the text will be parsed assuming math mode or not.\n */\n mode: \"math\" | \"regular\";\n} | void;\n\n/**\n * Parse a string to a LaTeX AST with no post processing. For example,\n * no macro arguments will be attached, etc.\n */\nexport const unifiedLatexFromStringMinimal: Plugin<\n PluginOptions[],\n string,\n Ast.Root\n> = function unifiedLatexFromStringMinimal(options) {\n const parser: Parser = (str) => {\n if (options?.mode === \"math\") {\n return {\n type: \"root\",\n content: parseMathMinimal(str),\n _renderInfo: { inMathMode: true },\n };\n }\n return parseMinimal(str);\n };\n\n Object.assign(this, { Parser: parser });\n};\n","import { Plugin } from \"unified\";\nimport * as Ast from \"@unified-latex/unified-latex-types\";\nimport { match } from \"@unified-latex/unified-latex-util-match\";\nimport { printRaw } from \"@unified-latex/unified-latex-util-print-raw\";\nimport { visit } from \"@unified-latex/unified-latex-util-visit\";\nimport { parseMathMinimal } from \"./parse-minimal\";\n\ntype PluginOptions =\n | {\n /**\n * List of environments whose body should be parsed in math mode\n */\n mathEnvs: string[];\n /**\n * List of macros whose bodies should be parsed in math mode\n */\n mathMacros: string[];\n }\n | undefined;\n\n/**\n * Reparse math environments/macro contents that should have been parsed in math mode but weren't.\n */\nexport const unifiedLatexReparseMath: Plugin<\n PluginOptions[],\n Ast.Root,\n Ast.Root\n> = function unifiedLatexReparseMath(options) {\n const { mathEnvs = [], mathMacros = [] } = options || {};\n\n return unifiedLatexReparseMathConstructPlugin({ mathMacros, mathEnvs });\n};\n\n/**\n * Construct the inner function for the `unifiedLatexReparseMath` plugin. This function should not be used by libraries.\n */\nexport function unifiedLatexReparseMathConstructPlugin({\n mathEnvs,\n mathMacros,\n}: {\n mathEnvs: string[];\n mathMacros: string[];\n}) {\n const isMathEnvironment = match.createEnvironmentMatcher(mathEnvs);\n const isMathMacro = match.createMacroMatcher(mathMacros);\n\n return (tree: Ast.Root) => {\n visit(\n tree,\n (node) => {\n if (match.anyMacro(node)) {\n for (const arg of node.args || []) {\n if (\n arg.content.length > 0 &&\n !wasParsedInMathMode(arg.content)\n ) {\n arg.content = parseMathMinimal(\n printRaw(arg.content)\n );\n }\n }\n }\n if (match.anyEnvironment(node)) {\n if (!wasParsedInMathMode(node.content)) {\n node.content = parseMathMinimal(printRaw(node.content));\n }\n }\n },\n {\n test: (node) => isMathEnvironment(node) || isMathMacro(node),\n }\n );\n };\n}\n\n/**\n * Use a heuristic to decide whether a string was parsed in math mode. The heuristic\n * looks for strings of length greater than 1 or the failure for \"_\" and \"^\" to be parsed\n * as a macro.\n */\nfunction wasParsedInMathMode(nodes: Ast.Node[]): boolean {\n return !nodes.some(\n (node) =>\n // If there are multi-char strings or ^ and _ have been parsed as strings, we know\n // that we were not parsed in math mode.\n (match.anyString(node) && node.content.length > 1) ||\n match.string(node, \"^\") ||\n match.string(node, \"_\")\n );\n}\n","import * as Ast from \"@unified-latex/unified-latex-types\";\nimport {\n EnvInfoRecord,\n MacroInfoRecord,\n} from \"@unified-latex/unified-latex-types\";\nimport { Plugin } from \"unified\";\nimport { visit } from \"@unified-latex/unified-latex-util-visit\";\nimport { match } from \"@unified-latex/unified-latex-util-match\";\nimport { printRaw } from \"@unified-latex/unified-latex-util-print-raw\";\nimport { unifiedLatexReparseMathConstructPlugin } from \"./reparse-math\";\nimport { attachMacroArgsInArray } from \"@unified-latex/unified-latex-util-arguments\";\nimport { processEnvironment } from \"@unified-latex/unified-latex-util-environments\";\n\ntype PluginOptions =\n | { environments: EnvInfoRecord; macros: MacroInfoRecord }\n | undefined;\n\n/**\n * Unified plugin to process macros and environments. Any environments that contain math content\n * are reparsed (if needed) in math mode.\n */\nexport const unifiedLatexProcessMacrosAndEnvironmentsWithMathReparse: Plugin<\n PluginOptions[],\n Ast.Root,\n Ast.Root\n> = function unifiedLatexProcessMacrosAndEnvironmentsWithMathReparse(options) {\n const { environments = {}, macros = {} } = options || {};\n\n const mathMacros = Object.fromEntries(\n Object.entries(macros).filter(\n ([_, info]) => info.renderInfo?.inMathMode === true\n )\n );\n const mathEnvs = Object.fromEntries(\n Object.entries(environments).filter(\n ([_, info]) => info.renderInfo?.inMathMode === true\n )\n );\n\n const mathReparser = unifiedLatexReparseMathConstructPlugin({\n mathEnvs: Object.keys(mathEnvs),\n mathMacros: Object.keys(mathMacros),\n });\n\n const isRelevantEnvironment = match.createEnvironmentMatcher(environments);\n const isRelevantMathEnvironment = match.createEnvironmentMatcher(mathEnvs);\n\n return (tree) => {\n // First we attach all arguments/process all nodes/environments that have math content\n visit(\n tree,\n {\n enter: (nodes) => {\n if (!Array.isArray(nodes)) {\n return;\n }\n attachMacroArgsInArray(nodes, mathMacros);\n },\n leave: (node) => {\n if (!isRelevantMathEnvironment(node)) {\n return;\n }\n const envName = printRaw(node.env);\n const envInfo = environments[envName];\n if (!envInfo) {\n throw new Error(\n `Could not find environment info for environment \"${envName}\"`\n );\n }\n processEnvironment(node, envInfo);\n },\n },\n { includeArrays: true }\n );\n\n // Next we reparse macros/envs that may not have been parsed in math mode\n mathReparser(tree);\n\n // Now we attach all arguments/process all environment bodies\n visit(\n tree,\n {\n enter: (nodes) => {\n if (!Array.isArray(nodes)) {\n return;\n }\n attachMacroArgsInArray(nodes, macros);\n },\n leave: (node) => {\n if (!isRelevantEnvironment(node)) {\n return;\n }\n const envName = printRaw(node.env);\n const envInfo = environments[envName];\n if (!envInfo) {\n throw new Error(\n `Could not find environment info for environment \"${envName}\"`\n );\n }\n processEnvironment(node, envInfo);\n },\n },\n { includeArrays: true }\n );\n };\n};\n","import * as Ast from \"@unified-latex/unified-latex-types\";\nimport { Plugin } from \"unified\";\nimport { reparseExpl3AndAtLetterRegions } from \"@unified-latex/unified-latex-util-catcode\";\nimport {\n hasReparsableMacroNames,\n reparseMacroNames,\n} from \"@unified-latex/unified-latex-util-catcode\";\n\ntype PluginOptions =\n | {\n /**\n * Whether to parse macros as if `\\makeatletter` is set (i.e., parse `@` as a regular macro character).\n * If this option is true, it disables autodetect.\n */\n atLetter?: boolean;\n /**\n * Whether to parse macros as if `\\ExplSyntaxOn` is set (i.e., parse `_` and `:` as a regular macro character)\n * If this option is true, it disables autodetect.\n */\n expl3?: boolean;\n /**\n * Attempt to autodetect whether there are macros that look like they should contain `@`, `_`, or `:`.\n * Defaults to `true`.\n */\n autodetectExpl3AndAtLetter?: boolean;\n }\n | undefined;\n\n/**\n * Unified plugin to reprocess macros names to possibly include `@`, `_`, or `:`.\n * This plugin detects the `\\makeatletter` and `\\ExplSyntaxOn` commands and reprocesses macro names\n * inside of those blocks to include those characters.\n */\nexport const unifiedLatexProcessAtLetterAndExplMacros: Plugin<\n PluginOptions[],\n Ast.Root,\n Ast.Root\n> = function unifiedLatexProcessAtLetterAndExplMacros(options) {\n let {\n atLetter = false,\n expl3 = false,\n autodetectExpl3AndAtLetter = false,\n } = options || {};\n\n return (tree) => {\n // First we reparse based on explicit \\makeatletter and \\ExplSyntaxOn macros\n reparseExpl3AndAtLetterRegions(tree);\n if (atLetter || expl3) {\n autodetectExpl3AndAtLetter = false;\n }\n if (autodetectExpl3AndAtLetter) {\n atLetter = hasReparsableMacroNames(tree, \"@\");\n // We don't check for the `:` here because it could be prone to misidentification.\n expl3 = hasReparsableMacroNames(tree, \"_\");\n }\n const charSet: Set = new Set();\n if (atLetter) {\n charSet.add(\"@\");\n }\n if (expl3) {\n charSet.add(\":\");\n charSet.add(\"_\");\n }\n\n if (charSet.size > 0) {\n reparseMacroNames(tree, charSet);\n }\n };\n};\n","import { Plugin, Parser, unified } from \"unified\";\nimport { environmentInfo, macroInfo } from \"@unified-latex/unified-latex-ctan\";\nimport * as Ast from \"@unified-latex/unified-latex-types\";\nimport {\n EnvInfoRecord,\n MacroInfoRecord,\n} from \"@unified-latex/unified-latex-types\";\nimport {\n unifiedLatexTrimEnvironmentContents,\n unifiedLatexTrimRoot,\n} from \"@unified-latex/unified-latex-util-trim\";\nimport { unifiedLatexAstComplier } from \"./compiler-ast\";\nimport { unifiedLatexFromStringMinimal } from \"./plugin-from-string-minimal\";\nimport { unifiedLatexProcessMacrosAndEnvironmentsWithMathReparse } from \"./process-macros-and-environments\";\nimport { unifiedLatexProcessAtLetterAndExplMacros } from \"./process-at-letter-and-expl-macros\";\n\nexport type PluginOptions =\n | {\n mode?: \"math\" | \"regular\";\n macros?: MacroInfoRecord;\n environments?: EnvInfoRecord;\n flags?: {\n /**\n * Whether to parse macros as if `\\makeatletter` is set (i.e., parse `@` as a regular macro character)\n */\n atLetter?: boolean;\n /**\n * Whether to parse macros as if `\\ExplSyntaxOn` is set (i.e., parse `_` and `:` as a regular macro character)\n */\n expl3?: boolean;\n /**\n * Attempt to autodetect whether there are macros that look like they should contain `@`, `_`, or `:`.\n * Defaults to `false`.\n */\n autodetectExpl3AndAtLetter?: boolean;\n };\n }\n | undefined;\n\n/**\n * Parse a string to a LaTeX AST.\n */\nexport const unifiedLatexFromString: Plugin =\n function unifiedLatexFromString(options) {\n const {\n mode = \"regular\",\n macros = {},\n environments = {},\n flags: {\n atLetter = false,\n expl3 = false,\n autodetectExpl3AndAtLetter = false,\n } = {},\n } = options || {};\n\n // Build up a parsing plugin with only unified components\n const allMacroInfo: MacroInfoRecord = Object.assign(\n {},\n ...Object.values(macroInfo),\n macros\n );\n const allEnvInfo: EnvInfoRecord = Object.assign(\n {},\n ...Object.values(environmentInfo),\n environments\n );\n\n // Build up a parser that will perform all the needed steps\n const fullParser = unified()\n .use(unifiedLatexFromStringMinimal, { mode })\n .use(unifiedLatexProcessAtLetterAndExplMacros, {\n atLetter,\n expl3,\n autodetectExpl3AndAtLetter,\n })\n // Math environments that aren't hardcoded into the PEG grammar need to be re-parsed,\n // so do a minimal pass first with just those environments.\n .use(unifiedLatexProcessMacrosAndEnvironmentsWithMathReparse, {\n macros: allMacroInfo,\n environments: allEnvInfo,\n })\n .use(unifiedLatexTrimEnvironmentContents)\n .use(unifiedLatexTrimRoot)\n .use(unifiedLatexAstComplier);\n\n const parser: Parser = (str) => {\n const file = fullParser.processSync({ value: str });\n return file.result;\n };\n\n Object.assign(this, { Parser: parser });\n };\n","import * as Ast from \"@unified-latex/unified-latex-types\";\nimport { type FrozenProcessor, unified } from \"unified\";\nimport { unifiedLatexFromString } from \"./plugin-from-string\";\nimport type { PluginOptions } from \"./plugin-from-string\";\n\nlet parser = unified().use(unifiedLatexFromString).freeze();\n\n/**\n * Parse the string into an AST.\n */\nexport function parse(str: string): Ast.Root {\n return parser.parse(str);\n}\n\n/**\n * Returns the default `unified-latex` parser, or create a new one with the\n * provided `unifiedLatexFromString` options\n * @param options Plugin options of `unifiedLatexFromString` plugin.\n * @returns The default `unified-latex` parser if `options` is `undefined`, or a\n * newly created `unified-latex` parser with the provided `options`.\n */\nexport function getParser(\n options?: PluginOptions\n): FrozenProcessor {\n return options\n ? unified().use(unifiedLatexFromString, options).freeze()\n : parser;\n}\n","import { unified } from \"unified\";\nimport * as Ast from \"@unified-latex/unified-latex-types\";\nimport { printRaw } from \"@unified-latex/unified-latex-util-print-raw\";\nimport { unifiedLatexAstComplier } from \"./compiler-ast\";\nimport { unifiedLatexFromString } from \"./plugin-from-string\";\n\n/**\n * Parse `str` into an AST. Parsing starts in math mode and a list of\n * nodes is returned (instead of a \"root\" node).\n */\nexport function parseMath(str: string | Ast.Ast): Ast.Node[] {\n if (typeof str !== \"string\") {\n str = printRaw(str);\n }\n const file = unified()\n .use(unifiedLatexFromString, { mode: \"math\" })\n .use(unifiedLatexAstComplier)\n .processSync({ value: str });\n return (file.result as Ast.Root).content;\n}\n"],"names":["unifiedLatexAstComplier","isBuffer","isArray","isPlainObject","setProperty","getProperty","extend","index","point","position","path","assertPath","prop","dirname","basename","extname","bufferLike","parse","value","options","isPlainObj","file","LatexPegParser","unifiedLatexFromStringMinimal","parser","unifiedLatexReparseMath","match","visit","printRaw","unifiedLatexProcessMacrosAndEnvironmentsWithMathReparse","attachMacroArgsInArray","processEnvironment","unifiedLatexProcessAtLetterAndExplMacros","reparseExpl3AndAtLetterRegions","hasReparsableMacroNames","reparseMacroNames","unifiedLatexFromString","macroInfo","environmentInfo","unifiedLatexTrimEnvironmentContents","unifiedLatexTrimRoot"],"mappings":"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","x_google_ignoreList":[1,2,3,4,5,6,7,8,9,10,11,12,13]} \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-util-parse/index.d.ts b/node_modules/@unified-latex/unified-latex-util-parse/index.d.ts new file mode 100644 index 0000000..92f1179 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-util-parse/index.d.ts @@ -0,0 +1,148 @@ +import * as Ast from '@unified-latex/unified-latex-types'; +import { EnvInfoRecord } from '@unified-latex/unified-latex-types'; +import { FrozenProcessor } from 'unified'; +import { MacroInfoRecord } from '@unified-latex/unified-latex-types'; +import { Plugin as Plugin_2 } from 'unified'; + +/** + * Returns the default `unified-latex` parser, or create a new one with the + * provided `unifiedLatexFromString` options + * @param options Plugin options of `unifiedLatexFromString` plugin. + * @returns The default `unified-latex` parser if `options` is `undefined`, or a + * newly created `unified-latex` parser with the provided `options`. + */ +export declare function getParser(options?: PluginOptions): FrozenProcessor; + +/** + * Parse the string into an AST. + */ +export declare function parse(str: string): Ast.Root; + +/** + * Parse `str` into an AST. Parsing starts in math mode and a list of + * nodes is returned (instead of a "root" node). + */ +export declare function parseMath(str: string | Ast.Ast): Ast.Node[]; + +/** + * Parse `str` to an AST with minimal processing. E.g., macro + * arguments are not attached to macros, etc. when parsed with this + * function. + * + * The parsing assumes a math-mode context, so, for example, `^` and `_` are + * parsed as macros (even though arguments are not attached to them). + */ +export declare function parseMathMinimal(str: string): Ast.Node[]; + +/** + * Parse `str` to an AST with minimal processing. E.g., macro + * arguments are not attached to macros, etc. when parsed with this + * function. + */ +export declare function parseMinimal(str: string): Ast.Root; + +export declare type PluginOptions = { + mode?: "math" | "regular"; + macros?: MacroInfoRecord; + environments?: EnvInfoRecord; + flags?: { + /** + * Whether to parse macros as if `\makeatletter` is set (i.e., parse `@` as a regular macro character) + */ + atLetter?: boolean; + /** + * Whether to parse macros as if `\ExplSyntaxOn` is set (i.e., parse `_` and `:` as a regular macro character) + */ + expl3?: boolean; + /** + * Attempt to autodetect whether there are macros that look like they should contain `@`, `_`, or `:`. + * Defaults to `false`. + */ + autodetectExpl3AndAtLetter?: boolean; + }; +} | undefined; + +declare type PluginOptions_2 = { + /** + * Whether the text will be parsed assuming math mode or not. + */ + mode: "math" | "regular"; +} | void; + +declare type PluginOptions_3 = { + /** + * Whether to parse macros as if `\makeatletter` is set (i.e., parse `@` as a regular macro character). + * If this option is true, it disables autodetect. + */ + atLetter?: boolean; + /** + * Whether to parse macros as if `\ExplSyntaxOn` is set (i.e., parse `_` and `:` as a regular macro character) + * If this option is true, it disables autodetect. + */ + expl3?: boolean; + /** + * Attempt to autodetect whether there are macros that look like they should contain `@`, `_`, or `:`. + * Defaults to `true`. + */ + autodetectExpl3AndAtLetter?: boolean; +} | undefined; + +declare type PluginOptions_4 = { + environments: EnvInfoRecord; + macros: MacroInfoRecord; +} | undefined; + +declare type PluginOptions_5 = { + /** + * List of environments whose body should be parsed in math mode + */ + mathEnvs: string[]; + /** + * List of macros whose bodies should be parsed in math mode + */ + mathMacros: string[]; +} | undefined; + +/** + * Unified complier plugin that passes through a LaTeX AST without modification. + */ +export declare const unifiedLatexAstComplier: Plugin_2; + +/** + * Parse a string to a LaTeX AST. + */ +export declare const unifiedLatexFromString: Plugin_2; + +/** + * Parse a string to a LaTeX AST with no post processing. For example, + * no macro arguments will be attached, etc. + */ +export declare const unifiedLatexFromStringMinimal: Plugin_2; + +/** + * Unified plugin to reprocess macros names to possibly include `@`, `_`, or `:`. + * This plugin detects the `\makeatletter` and `\ExplSyntaxOn` commands and reprocesses macro names + * inside of those blocks to include those characters. + */ +export declare const unifiedLatexProcessAtLetterAndExplMacros: Plugin_2; + +/** + * Unified plugin to process macros and environments. Any environments that contain math content + * are reparsed (if needed) in math mode. + */ +export declare const unifiedLatexProcessMacrosAndEnvironmentsWithMathReparse: Plugin_2; + +/** + * Reparse math environments/macro contents that should have been parsed in math mode but weren't. + */ +export declare const unifiedLatexReparseMath: Plugin_2; + +/** + * Construct the inner function for the `unifiedLatexReparseMath` plugin. This function should not be used by libraries. + */ +export declare function unifiedLatexReparseMathConstructPlugin({ mathEnvs, mathMacros, }: { + mathEnvs: string[]; + mathMacros: string[]; +}): (tree: Ast.Root) => void; + +export { } diff --git a/node_modules/@unified-latex/unified-latex-util-parse/index.js b/node_modules/@unified-latex/unified-latex-util-parse/index.js new file mode 100644 index 0000000..7405d7d --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-util-parse/index.js @@ -0,0 +1,246 @@ +import { unified } from "unified"; +import { macroInfo, environmentInfo } from "@unified-latex/unified-latex-ctan"; +import { unifiedLatexTrimEnvironmentContents, unifiedLatexTrimRoot } from "@unified-latex/unified-latex-util-trim"; +import { LatexPegParser } from "@unified-latex/unified-latex-util-pegjs"; +import { visit } from "@unified-latex/unified-latex-util-visit"; +import { match } from "@unified-latex/unified-latex-util-match"; +import { printRaw } from "@unified-latex/unified-latex-util-print-raw"; +import { attachMacroArgsInArray } from "@unified-latex/unified-latex-util-arguments"; +import { processEnvironment } from "@unified-latex/unified-latex-util-environments"; +import { reparseExpl3AndAtLetterRegions, hasReparsableMacroNames, reparseMacroNames } from "@unified-latex/unified-latex-util-catcode"; +const unifiedLatexAstComplier = function unifiedLatexAstComplier2() { + Object.assign(this, { Compiler: (x) => x }); +}; +function parseMinimal(str) { + return LatexPegParser.parse(str); +} +function parseMathMinimal(str) { + return LatexPegParser.parse(str, { startRule: "math" }); +} +const unifiedLatexFromStringMinimal = function unifiedLatexFromStringMinimal2(options) { + const parser2 = (str) => { + if ((options == null ? void 0 : options.mode) === "math") { + return { + type: "root", + content: parseMathMinimal(str), + _renderInfo: { inMathMode: true } + }; + } + return parseMinimal(str); + }; + Object.assign(this, { Parser: parser2 }); +}; +const unifiedLatexReparseMath = function unifiedLatexReparseMath2(options) { + const { mathEnvs = [], mathMacros = [] } = options || {}; + return unifiedLatexReparseMathConstructPlugin({ mathMacros, mathEnvs }); +}; +function unifiedLatexReparseMathConstructPlugin({ + mathEnvs, + mathMacros +}) { + const isMathEnvironment = match.createEnvironmentMatcher(mathEnvs); + const isMathMacro = match.createMacroMatcher(mathMacros); + return (tree) => { + visit( + tree, + (node) => { + if (match.anyMacro(node)) { + for (const arg of node.args || []) { + if (arg.content.length > 0 && !wasParsedInMathMode(arg.content)) { + arg.content = parseMathMinimal( + printRaw(arg.content) + ); + } + } + } + if (match.anyEnvironment(node)) { + if (!wasParsedInMathMode(node.content)) { + node.content = parseMathMinimal(printRaw(node.content)); + } + } + }, + { + test: (node) => isMathEnvironment(node) || isMathMacro(node) + } + ); + }; +} +function wasParsedInMathMode(nodes) { + return !nodes.some( + (node) => ( + // If there are multi-char strings or ^ and _ have been parsed as strings, we know + // that we were not parsed in math mode. + match.anyString(node) && node.content.length > 1 || match.string(node, "^") || match.string(node, "_") + ) + ); +} +const unifiedLatexProcessMacrosAndEnvironmentsWithMathReparse = function unifiedLatexProcessMacrosAndEnvironmentsWithMathReparse2(options) { + const { environments = {}, macros = {} } = options || {}; + const mathMacros = Object.fromEntries( + Object.entries(macros).filter( + ([_, info]) => { + var _a; + return ((_a = info.renderInfo) == null ? void 0 : _a.inMathMode) === true; + } + ) + ); + const mathEnvs = Object.fromEntries( + Object.entries(environments).filter( + ([_, info]) => { + var _a; + return ((_a = info.renderInfo) == null ? void 0 : _a.inMathMode) === true; + } + ) + ); + const mathReparser = unifiedLatexReparseMathConstructPlugin({ + mathEnvs: Object.keys(mathEnvs), + mathMacros: Object.keys(mathMacros) + }); + const isRelevantEnvironment = match.createEnvironmentMatcher(environments); + const isRelevantMathEnvironment = match.createEnvironmentMatcher(mathEnvs); + return (tree) => { + visit( + tree, + { + enter: (nodes) => { + if (!Array.isArray(nodes)) { + return; + } + attachMacroArgsInArray(nodes, mathMacros); + }, + leave: (node) => { + if (!isRelevantMathEnvironment(node)) { + return; + } + const envName = printRaw(node.env); + const envInfo = environments[envName]; + if (!envInfo) { + throw new Error( + `Could not find environment info for environment "${envName}"` + ); + } + processEnvironment(node, envInfo); + } + }, + { includeArrays: true } + ); + mathReparser(tree); + visit( + tree, + { + enter: (nodes) => { + if (!Array.isArray(nodes)) { + return; + } + attachMacroArgsInArray(nodes, macros); + }, + leave: (node) => { + if (!isRelevantEnvironment(node)) { + return; + } + const envName = printRaw(node.env); + const envInfo = environments[envName]; + if (!envInfo) { + throw new Error( + `Could not find environment info for environment "${envName}"` + ); + } + processEnvironment(node, envInfo); + } + }, + { includeArrays: true } + ); + }; +}; +const unifiedLatexProcessAtLetterAndExplMacros = function unifiedLatexProcessAtLetterAndExplMacros2(options) { + let { + atLetter = false, + expl3 = false, + autodetectExpl3AndAtLetter = false + } = options || {}; + return (tree) => { + reparseExpl3AndAtLetterRegions(tree); + if (atLetter || expl3) { + autodetectExpl3AndAtLetter = false; + } + if (autodetectExpl3AndAtLetter) { + atLetter = hasReparsableMacroNames(tree, "@"); + expl3 = hasReparsableMacroNames(tree, "_"); + } + const charSet = /* @__PURE__ */ new Set(); + if (atLetter) { + charSet.add("@"); + } + if (expl3) { + charSet.add(":"); + charSet.add("_"); + } + if (charSet.size > 0) { + reparseMacroNames(tree, charSet); + } + }; +}; +const unifiedLatexFromString = function unifiedLatexFromString2(options) { + const { + mode = "regular", + macros = {}, + environments = {}, + flags: { + atLetter = false, + expl3 = false, + autodetectExpl3AndAtLetter = false + } = {} + } = options || {}; + const allMacroInfo = Object.assign( + {}, + ...Object.values(macroInfo), + macros + ); + const allEnvInfo = Object.assign( + {}, + ...Object.values(environmentInfo), + environments + ); + const fullParser = unified().use(unifiedLatexFromStringMinimal, { mode }).use(unifiedLatexProcessAtLetterAndExplMacros, { + atLetter, + expl3, + autodetectExpl3AndAtLetter + }).use(unifiedLatexProcessMacrosAndEnvironmentsWithMathReparse, { + macros: allMacroInfo, + environments: allEnvInfo + }).use(unifiedLatexTrimEnvironmentContents).use(unifiedLatexTrimRoot).use(unifiedLatexAstComplier); + const parser2 = (str) => { + const file = fullParser.processSync({ value: str }); + return file.result; + }; + Object.assign(this, { Parser: parser2 }); +}; +let parser = unified().use(unifiedLatexFromString).freeze(); +function parse(str) { + return parser.parse(str); +} +function getParser(options) { + return options ? unified().use(unifiedLatexFromString, options).freeze() : parser; +} +function parseMath(str) { + if (typeof str !== "string") { + str = printRaw(str); + } + const file = unified().use(unifiedLatexFromString, { mode: "math" }).use(unifiedLatexAstComplier).processSync({ value: str }); + return file.result.content; +} +export { + getParser, + parse, + parseMath, + parseMathMinimal, + parseMinimal, + unifiedLatexAstComplier, + unifiedLatexFromString, + unifiedLatexFromStringMinimal, + unifiedLatexProcessAtLetterAndExplMacros, + unifiedLatexProcessMacrosAndEnvironmentsWithMathReparse, + unifiedLatexReparseMath, + unifiedLatexReparseMathConstructPlugin +}; +//# sourceMappingURL=index.js.map diff --git a/node_modules/@unified-latex/unified-latex-util-parse/index.js.map b/node_modules/@unified-latex/unified-latex-util-parse/index.js.map new file mode 100644 index 0000000..b8425aa --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-util-parse/index.js.map @@ -0,0 +1 @@ +{"version":3,"file":"index.js","sources":["../libs/compiler-ast.ts","../libs/parse-minimal.ts","../libs/plugin-from-string-minimal.ts","../libs/reparse-math.ts","../libs/process-macros-and-environments.ts","../libs/process-at-letter-and-expl-macros.ts","../libs/plugin-from-string.ts","../libs/parse.ts","../libs/parse-math.ts"],"sourcesContent":["import { Plugin } from \"unified\";\nimport * as Ast from \"@unified-latex/unified-latex-types\";\n\n/**\n * Unified complier plugin that passes through a LaTeX AST without modification.\n */\nexport const unifiedLatexAstComplier: Plugin =\n function unifiedLatexAstComplier() {\n Object.assign(this, { Compiler: (x: Ast.Root) => x });\n };\n","import { LatexPegParser } from \"@unified-latex/unified-latex-util-pegjs\";\nimport * as Ast from \"@unified-latex/unified-latex-types\";\n\n/**\n * Parse `str` to an AST with minimal processing. E.g., macro\n * arguments are not attached to macros, etc. when parsed with this\n * function.\n */\nexport function parseMinimal(str: string): Ast.Root {\n return LatexPegParser.parse(str);\n}\n\n/**\n * Parse `str` to an AST with minimal processing. E.g., macro\n * arguments are not attached to macros, etc. when parsed with this\n * function.\n *\n * The parsing assumes a math-mode context, so, for example, `^` and `_` are\n * parsed as macros (even though arguments are not attached to them).\n */\nexport function parseMathMinimal(str: string): Ast.Node[] {\n return LatexPegParser.parse(str, { startRule: \"math\" });\n}\n","import { Plugin, Parser } from \"unified\";\nimport * as Ast from \"@unified-latex/unified-latex-types\";\nimport { parseMathMinimal, parseMinimal } from \"./parse-minimal\";\n\ntype PluginOptions = {\n /**\n * Whether the text will be parsed assuming math mode or not.\n */\n mode: \"math\" | \"regular\";\n} | void;\n\n/**\n * Parse a string to a LaTeX AST with no post processing. For example,\n * no macro arguments will be attached, etc.\n */\nexport const unifiedLatexFromStringMinimal: Plugin<\n PluginOptions[],\n string,\n Ast.Root\n> = function unifiedLatexFromStringMinimal(options) {\n const parser: Parser = (str) => {\n if (options?.mode === \"math\") {\n return {\n type: \"root\",\n content: parseMathMinimal(str),\n _renderInfo: { inMathMode: true },\n };\n }\n return parseMinimal(str);\n };\n\n Object.assign(this, { Parser: parser });\n};\n","import { Plugin } from \"unified\";\nimport * as Ast from \"@unified-latex/unified-latex-types\";\nimport { match } from \"@unified-latex/unified-latex-util-match\";\nimport { printRaw } from \"@unified-latex/unified-latex-util-print-raw\";\nimport { visit } from \"@unified-latex/unified-latex-util-visit\";\nimport { parseMathMinimal } from \"./parse-minimal\";\n\ntype PluginOptions =\n | {\n /**\n * List of environments whose body should be parsed in math mode\n */\n mathEnvs: string[];\n /**\n * List of macros whose bodies should be parsed in math mode\n */\n mathMacros: string[];\n }\n | undefined;\n\n/**\n * Reparse math environments/macro contents that should have been parsed in math mode but weren't.\n */\nexport const unifiedLatexReparseMath: Plugin<\n PluginOptions[],\n Ast.Root,\n Ast.Root\n> = function unifiedLatexReparseMath(options) {\n const { mathEnvs = [], mathMacros = [] } = options || {};\n\n return unifiedLatexReparseMathConstructPlugin({ mathMacros, mathEnvs });\n};\n\n/**\n * Construct the inner function for the `unifiedLatexReparseMath` plugin. This function should not be used by libraries.\n */\nexport function unifiedLatexReparseMathConstructPlugin({\n mathEnvs,\n mathMacros,\n}: {\n mathEnvs: string[];\n mathMacros: string[];\n}) {\n const isMathEnvironment = match.createEnvironmentMatcher(mathEnvs);\n const isMathMacro = match.createMacroMatcher(mathMacros);\n\n return (tree: Ast.Root) => {\n visit(\n tree,\n (node) => {\n if (match.anyMacro(node)) {\n for (const arg of node.args || []) {\n if (\n arg.content.length > 0 &&\n !wasParsedInMathMode(arg.content)\n ) {\n arg.content = parseMathMinimal(\n printRaw(arg.content)\n );\n }\n }\n }\n if (match.anyEnvironment(node)) {\n if (!wasParsedInMathMode(node.content)) {\n node.content = parseMathMinimal(printRaw(node.content));\n }\n }\n },\n {\n test: (node) => isMathEnvironment(node) || isMathMacro(node),\n }\n );\n };\n}\n\n/**\n * Use a heuristic to decide whether a string was parsed in math mode. The heuristic\n * looks for strings of length greater than 1 or the failure for \"_\" and \"^\" to be parsed\n * as a macro.\n */\nfunction wasParsedInMathMode(nodes: Ast.Node[]): boolean {\n return !nodes.some(\n (node) =>\n // If there are multi-char strings or ^ and _ have been parsed as strings, we know\n // that we were not parsed in math mode.\n (match.anyString(node) && node.content.length > 1) ||\n match.string(node, \"^\") ||\n match.string(node, \"_\")\n );\n}\n","import * as Ast from \"@unified-latex/unified-latex-types\";\nimport {\n EnvInfoRecord,\n MacroInfoRecord,\n} from \"@unified-latex/unified-latex-types\";\nimport { Plugin } from \"unified\";\nimport { visit } from \"@unified-latex/unified-latex-util-visit\";\nimport { match } from \"@unified-latex/unified-latex-util-match\";\nimport { printRaw } from \"@unified-latex/unified-latex-util-print-raw\";\nimport { unifiedLatexReparseMathConstructPlugin } from \"./reparse-math\";\nimport { attachMacroArgsInArray } from \"@unified-latex/unified-latex-util-arguments\";\nimport { processEnvironment } from \"@unified-latex/unified-latex-util-environments\";\n\ntype PluginOptions =\n | { environments: EnvInfoRecord; macros: MacroInfoRecord }\n | undefined;\n\n/**\n * Unified plugin to process macros and environments. Any environments that contain math content\n * are reparsed (if needed) in math mode.\n */\nexport const unifiedLatexProcessMacrosAndEnvironmentsWithMathReparse: Plugin<\n PluginOptions[],\n Ast.Root,\n Ast.Root\n> = function unifiedLatexProcessMacrosAndEnvironmentsWithMathReparse(options) {\n const { environments = {}, macros = {} } = options || {};\n\n const mathMacros = Object.fromEntries(\n Object.entries(macros).filter(\n ([_, info]) => info.renderInfo?.inMathMode === true\n )\n );\n const mathEnvs = Object.fromEntries(\n Object.entries(environments).filter(\n ([_, info]) => info.renderInfo?.inMathMode === true\n )\n );\n\n const mathReparser = unifiedLatexReparseMathConstructPlugin({\n mathEnvs: Object.keys(mathEnvs),\n mathMacros: Object.keys(mathMacros),\n });\n\n const isRelevantEnvironment = match.createEnvironmentMatcher(environments);\n const isRelevantMathEnvironment = match.createEnvironmentMatcher(mathEnvs);\n\n return (tree) => {\n // First we attach all arguments/process all nodes/environments that have math content\n visit(\n tree,\n {\n enter: (nodes) => {\n if (!Array.isArray(nodes)) {\n return;\n }\n attachMacroArgsInArray(nodes, mathMacros);\n },\n leave: (node) => {\n if (!isRelevantMathEnvironment(node)) {\n return;\n }\n const envName = printRaw(node.env);\n const envInfo = environments[envName];\n if (!envInfo) {\n throw new Error(\n `Could not find environment info for environment \"${envName}\"`\n );\n }\n processEnvironment(node, envInfo);\n },\n },\n { includeArrays: true }\n );\n\n // Next we reparse macros/envs that may not have been parsed in math mode\n mathReparser(tree);\n\n // Now we attach all arguments/process all environment bodies\n visit(\n tree,\n {\n enter: (nodes) => {\n if (!Array.isArray(nodes)) {\n return;\n }\n attachMacroArgsInArray(nodes, macros);\n },\n leave: (node) => {\n if (!isRelevantEnvironment(node)) {\n return;\n }\n const envName = printRaw(node.env);\n const envInfo = environments[envName];\n if (!envInfo) {\n throw new Error(\n `Could not find environment info for environment \"${envName}\"`\n );\n }\n processEnvironment(node, envInfo);\n },\n },\n { includeArrays: true }\n );\n };\n};\n","import * as Ast from \"@unified-latex/unified-latex-types\";\nimport { Plugin } from \"unified\";\nimport { reparseExpl3AndAtLetterRegions } from \"@unified-latex/unified-latex-util-catcode\";\nimport {\n hasReparsableMacroNames,\n reparseMacroNames,\n} from \"@unified-latex/unified-latex-util-catcode\";\n\ntype PluginOptions =\n | {\n /**\n * Whether to parse macros as if `\\makeatletter` is set (i.e., parse `@` as a regular macro character).\n * If this option is true, it disables autodetect.\n */\n atLetter?: boolean;\n /**\n * Whether to parse macros as if `\\ExplSyntaxOn` is set (i.e., parse `_` and `:` as a regular macro character)\n * If this option is true, it disables autodetect.\n */\n expl3?: boolean;\n /**\n * Attempt to autodetect whether there are macros that look like they should contain `@`, `_`, or `:`.\n * Defaults to `true`.\n */\n autodetectExpl3AndAtLetter?: boolean;\n }\n | undefined;\n\n/**\n * Unified plugin to reprocess macros names to possibly include `@`, `_`, or `:`.\n * This plugin detects the `\\makeatletter` and `\\ExplSyntaxOn` commands and reprocesses macro names\n * inside of those blocks to include those characters.\n */\nexport const unifiedLatexProcessAtLetterAndExplMacros: Plugin<\n PluginOptions[],\n Ast.Root,\n Ast.Root\n> = function unifiedLatexProcessAtLetterAndExplMacros(options) {\n let {\n atLetter = false,\n expl3 = false,\n autodetectExpl3AndAtLetter = false,\n } = options || {};\n\n return (tree) => {\n // First we reparse based on explicit \\makeatletter and \\ExplSyntaxOn macros\n reparseExpl3AndAtLetterRegions(tree);\n if (atLetter || expl3) {\n autodetectExpl3AndAtLetter = false;\n }\n if (autodetectExpl3AndAtLetter) {\n atLetter = hasReparsableMacroNames(tree, \"@\");\n // We don't check for the `:` here because it could be prone to misidentification.\n expl3 = hasReparsableMacroNames(tree, \"_\");\n }\n const charSet: Set = new Set();\n if (atLetter) {\n charSet.add(\"@\");\n }\n if (expl3) {\n charSet.add(\":\");\n charSet.add(\"_\");\n }\n\n if (charSet.size > 0) {\n reparseMacroNames(tree, charSet);\n }\n };\n};\n","import { Plugin, Parser, unified } from \"unified\";\nimport { environmentInfo, macroInfo } from \"@unified-latex/unified-latex-ctan\";\nimport * as Ast from \"@unified-latex/unified-latex-types\";\nimport {\n EnvInfoRecord,\n MacroInfoRecord,\n} from \"@unified-latex/unified-latex-types\";\nimport {\n unifiedLatexTrimEnvironmentContents,\n unifiedLatexTrimRoot,\n} from \"@unified-latex/unified-latex-util-trim\";\nimport { unifiedLatexAstComplier } from \"./compiler-ast\";\nimport { unifiedLatexFromStringMinimal } from \"./plugin-from-string-minimal\";\nimport { unifiedLatexProcessMacrosAndEnvironmentsWithMathReparse } from \"./process-macros-and-environments\";\nimport { unifiedLatexProcessAtLetterAndExplMacros } from \"./process-at-letter-and-expl-macros\";\n\nexport type PluginOptions =\n | {\n mode?: \"math\" | \"regular\";\n macros?: MacroInfoRecord;\n environments?: EnvInfoRecord;\n flags?: {\n /**\n * Whether to parse macros as if `\\makeatletter` is set (i.e., parse `@` as a regular macro character)\n */\n atLetter?: boolean;\n /**\n * Whether to parse macros as if `\\ExplSyntaxOn` is set (i.e., parse `_` and `:` as a regular macro character)\n */\n expl3?: boolean;\n /**\n * Attempt to autodetect whether there are macros that look like they should contain `@`, `_`, or `:`.\n * Defaults to `false`.\n */\n autodetectExpl3AndAtLetter?: boolean;\n };\n }\n | undefined;\n\n/**\n * Parse a string to a LaTeX AST.\n */\nexport const unifiedLatexFromString: Plugin =\n function unifiedLatexFromString(options) {\n const {\n mode = \"regular\",\n macros = {},\n environments = {},\n flags: {\n atLetter = false,\n expl3 = false,\n autodetectExpl3AndAtLetter = false,\n } = {},\n } = options || {};\n\n // Build up a parsing plugin with only unified components\n const allMacroInfo: MacroInfoRecord = Object.assign(\n {},\n ...Object.values(macroInfo),\n macros\n );\n const allEnvInfo: EnvInfoRecord = Object.assign(\n {},\n ...Object.values(environmentInfo),\n environments\n );\n\n // Build up a parser that will perform all the needed steps\n const fullParser = unified()\n .use(unifiedLatexFromStringMinimal, { mode })\n .use(unifiedLatexProcessAtLetterAndExplMacros, {\n atLetter,\n expl3,\n autodetectExpl3AndAtLetter,\n })\n // Math environments that aren't hardcoded into the PEG grammar need to be re-parsed,\n // so do a minimal pass first with just those environments.\n .use(unifiedLatexProcessMacrosAndEnvironmentsWithMathReparse, {\n macros: allMacroInfo,\n environments: allEnvInfo,\n })\n .use(unifiedLatexTrimEnvironmentContents)\n .use(unifiedLatexTrimRoot)\n .use(unifiedLatexAstComplier);\n\n const parser: Parser = (str) => {\n const file = fullParser.processSync({ value: str });\n return file.result;\n };\n\n Object.assign(this, { Parser: parser });\n };\n","import * as Ast from \"@unified-latex/unified-latex-types\";\nimport { type FrozenProcessor, unified } from \"unified\";\nimport { unifiedLatexFromString } from \"./plugin-from-string\";\nimport type { PluginOptions } from \"./plugin-from-string\";\n\nlet parser = unified().use(unifiedLatexFromString).freeze();\n\n/**\n * Parse the string into an AST.\n */\nexport function parse(str: string): Ast.Root {\n return parser.parse(str);\n}\n\n/**\n * Returns the default `unified-latex` parser, or create a new one with the\n * provided `unifiedLatexFromString` options\n * @param options Plugin options of `unifiedLatexFromString` plugin.\n * @returns The default `unified-latex` parser if `options` is `undefined`, or a\n * newly created `unified-latex` parser with the provided `options`.\n */\nexport function getParser(\n options?: PluginOptions\n): FrozenProcessor {\n return options\n ? unified().use(unifiedLatexFromString, options).freeze()\n : parser;\n}\n","import { unified } from \"unified\";\nimport * as Ast from \"@unified-latex/unified-latex-types\";\nimport { printRaw } from \"@unified-latex/unified-latex-util-print-raw\";\nimport { unifiedLatexAstComplier } from \"./compiler-ast\";\nimport { unifiedLatexFromString } from \"./plugin-from-string\";\n\n/**\n * Parse `str` into an AST. Parsing starts in math mode and a list of\n * nodes is returned (instead of a \"root\" node).\n */\nexport function parseMath(str: string | Ast.Ast): Ast.Node[] {\n if (typeof str !== \"string\") {\n str = printRaw(str);\n }\n const file = unified()\n .use(unifiedLatexFromString, { mode: \"math\" })\n .use(unifiedLatexAstComplier)\n .processSync({ value: str });\n return (file.result as Ast.Root).content;\n}\n"],"names":["unifiedLatexAstComplier","unifiedLatexFromStringMinimal","parser","unifiedLatexReparseMath","unifiedLatexProcessMacrosAndEnvironmentsWithMathReparse","unifiedLatexProcessAtLetterAndExplMacros","unifiedLatexFromString"],"mappings":"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"} \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-util-parse/package.json b/node_modules/@unified-latex/unified-latex-util-parse/package.json new file mode 100644 index 0000000..cd99234 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-util-parse/package.json @@ -0,0 +1,61 @@ +{ + "name": "@unified-latex/unified-latex-util-parse", + "version": "1.8.2", + "description": "Tools for manipulating unified-latex ASTs", + "main": "index.js", + "type": "module", + "dependencies": { + "@unified-latex/unified-latex-ctan": "^1.8.2", + "@unified-latex/unified-latex-types": "^1.8.0", + "@unified-latex/unified-latex-util-arguments": "^1.8.2", + "@unified-latex/unified-latex-util-catcode": "^1.8.2", + "@unified-latex/unified-latex-util-environments": "^1.8.2", + "@unified-latex/unified-latex-util-match": "^1.8.0", + "@unified-latex/unified-latex-util-pegjs": "^1.8.1", + "@unified-latex/unified-latex-util-print-raw": "^1.8.0", + "@unified-latex/unified-latex-util-trim": "^1.8.2", + "@unified-latex/unified-latex-util-visit": "^1.8.2", + "unified": "^10.1.2" + }, + "repository": { + "type": "git", + "url": "git+https://github.com/siefkenj/unified-latex.git" + }, + "keywords": [ + "pegjs", + "latex", + "parser", + "prettier", + "unified-latex", + "unified" + ], + "author": "Jason Siefken", + "license": "MIT", + "bugs": { + "url": "https://github.com/siefkenj/unified-latex/issues" + }, + "homepage": "https://github.com/siefkenj/unified-latex#readme", + "exports": { + ".": { + "import": "./index.js", + "require": "./index.cjs", + "types": "./index.d.ts" + }, + "./*js": "./*js", + "./*": { + "import": "./*/index.js", + "require": "./*/index.cjs", + "types": "./*/index.d.ts" + }, + "./*/index": { + "import": "./*/index.js", + "require": "./*/index.cjs" + } + }, + "files": [ + "**/*ts", + "**/*js", + "**/*.map", + "**/*.json" + ] +} \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-util-pegjs/README.md b/node_modules/@unified-latex/unified-latex-util-pegjs/README.md new file mode 100644 index 0000000..4290482 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-util-pegjs/README.md @@ -0,0 +1,60 @@ + + + + +# unified-latex-util-pegjs + +## What is this? + +Pegjs grammars to help parse strings into a `unified-latex` Abstract Syntax Tree (AST). Note, +because of the dynamic nature of LaTeX, to get a full AST with arguments attached to macros, etc., +the tree is parsed multiple times. + +Also included are functions to decorate a `Ast.Node[]` array so that Pegjs can process it as if it were +a string. This allows for complex second-pass parsing. + +## When should I use this? + +If you are building libraries to parse specific LaTeX syntax (e.g., to parse `tabular` environments or +`systeme` environments, etc.). + +## Install + +```bash +npm install @unified-latex/unified-latex-util-pegjs +``` + +This package contains both esm and commonjs exports. To explicitly access the esm export, +import the `.js` file. To explicitly access the commonjs export, import the `.cjs` file. + +# Functions + +## `decorateArrayForPegjs(array)` + +Pegjs operates on strings. However, strings and arrays are very similar! +This function adds `charAt`, `charCodeAt`, and `substring` methods to +`array` so that `array` can then be fed to a Pegjs generated parser. + +```typescript +function decorateArrayForPegjs(array: any[]): StringlikeArray; +``` + +**Parameters** + +| Param | Type | +| :---- | :------ | +| array | `any[]` | + +## `splitStringsIntoSingleChars(nodes)` + +Splits all multi-character strings into strings that are all single characters. + +```typescript +function splitStringsIntoSingleChars(nodes: Ast.Node[]): Ast.Node[]; +``` + +**Parameters** + +| Param | Type | +| :---- | :----------- | +| nodes | `Ast.Node[]` | diff --git a/node_modules/@unified-latex/unified-latex-util-pegjs/index.cjs b/node_modules/@unified-latex/unified-latex-util-pegjs/index.cjs new file mode 100644 index 0000000..9eea025 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-util-pegjs/index.cjs @@ -0,0 +1,16700 @@ +"use strict"; +Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" }); +const unifiedLatexUtilMatch = require("@unified-latex/unified-latex-util-match"); +function decorateArrayForPegjs(array) { + array.charAt = function(i) { + return this[i]; + }; + array.charCodeAt = () => 0; + array.substring = function(i, j) { + return this.slice(i, j); + }; + array.replace = function(a, b) { + const ret = JSON.stringify(this); + return ret.replace(a, b); + }; + return array; +} +function splitStringsIntoSingleChars(nodes) { + return nodes.flatMap( + (node) => unifiedLatexUtilMatch.match.anyString(node) ? Array.from(node.content).map((c) => ({ + type: "string", + content: c + })) : node + ); +} +const _LatexPegParser = ( + // Generated by Peggy 3.0.2. + // + // https://peggyjs.org/ + function() { + function peg$subclass(child, parent) { + function C() { + this.constructor = child; + } + C.prototype = parent.prototype; + child.prototype = new C(); + } + function peg$SyntaxError(message, expected, found, location) { + var self = Error.call(this, message); + if (Object.setPrototypeOf) { + Object.setPrototypeOf(self, peg$SyntaxError.prototype); + } + self.expected = expected; + self.found = found; + self.location = location; + self.name = "SyntaxError"; + return self; + } + peg$subclass(peg$SyntaxError, Error); + function peg$padEnd(str, targetLength, padString) { + padString = padString || " "; + if (str.length > targetLength) { + return str; + } + targetLength -= str.length; + padString += padString.repeat(targetLength); + return str + padString.slice(0, targetLength); + } + peg$SyntaxError.prototype.format = function(sources) { + var str = "Error: " + this.message; + if (this.location) { + var src = null; + var k; + for (k = 0; k < sources.length; k++) { + if (sources[k].source === this.location.source) { + src = sources[k].text.split(/\r\n|\n|\r/g); + break; + } + } + var s = this.location.start; + var offset_s = this.location.source && typeof this.location.source.offset === "function" ? this.location.source.offset(s) : s; + var loc = this.location.source + ":" + offset_s.line + ":" + offset_s.column; + if (src) { + var e = this.location.end; + var filler = peg$padEnd("", offset_s.line.toString().length, " "); + var line = src[s.line - 1]; + var last = s.line === e.line ? e.column : line.length + 1; + var hatLen = last - s.column || 1; + str += "\n --> " + loc + "\n" + filler + " |\n" + offset_s.line + " | " + line + "\n" + filler + " | " + peg$padEnd("", s.column - 1, " ") + peg$padEnd("", hatLen, "^"); + } else { + str += "\n at " + loc; + } + } + return str; + }; + peg$SyntaxError.buildMessage = function(expected, found) { + var DESCRIBE_EXPECTATION_FNS = { + literal: function(expectation) { + return '"' + literalEscape(expectation.text) + '"'; + }, + class: function(expectation) { + var escapedParts = expectation.parts.map(function(part) { + return Array.isArray(part) ? classEscape(part[0]) + "-" + classEscape(part[1]) : classEscape(part); + }); + return "[" + (expectation.inverted ? "^" : "") + escapedParts.join("") + "]"; + }, + any: function() { + return "any character"; + }, + end: function() { + return "end of input"; + }, + other: function(expectation) { + return expectation.description; + } + }; + function hex(ch) { + return ch.charCodeAt(0).toString(16).toUpperCase(); + } + function literalEscape(s) { + return s.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\0/g, "\\0").replace(/\t/g, "\\t").replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/[\x00-\x0F]/g, function(ch) { + return "\\x0" + hex(ch); + }).replace(/[\x10-\x1F\x7F-\x9F]/g, function(ch) { + return "\\x" + hex(ch); + }); + } + function classEscape(s) { + return s.replace(/\\/g, "\\\\").replace(/\]/g, "\\]").replace(/\^/g, "\\^").replace(/-/g, "\\-").replace(/\0/g, "\\0").replace(/\t/g, "\\t").replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/[\x00-\x0F]/g, function(ch) { + return "\\x0" + hex(ch); + }).replace(/[\x10-\x1F\x7F-\x9F]/g, function(ch) { + return "\\x" + hex(ch); + }); + } + function describeExpectation(expectation) { + return DESCRIBE_EXPECTATION_FNS[expectation.type](expectation); + } + function describeExpected(expected2) { + var descriptions = expected2.map(describeExpectation); + var i, j; + descriptions.sort(); + if (descriptions.length > 0) { + for (i = 1, j = 1; i < descriptions.length; i++) { + if (descriptions[i - 1] !== descriptions[i]) { + descriptions[j] = descriptions[i]; + j++; + } + } + descriptions.length = j; + } + switch (descriptions.length) { + case 1: + return descriptions[0]; + case 2: + return descriptions[0] + " or " + descriptions[1]; + default: + return descriptions.slice(0, -1).join(", ") + ", or " + descriptions[descriptions.length - 1]; + } + } + function describeFound(found2) { + return found2 ? '"' + literalEscape(found2) + '"' : "end of input"; + } + return "Expected " + describeExpected(expected) + " but " + describeFound(found) + " found."; + }; + function peg$parse(input, options) { + options = options !== void 0 ? options : {}; + var peg$FAILED = {}; + var peg$source = options.grammarSource; + var peg$startRuleFunctions = { document: peg$parsedocument, math: peg$parsemath }; + var peg$startRuleFunction = peg$parsedocument; + var peg$c0 = "%"; + var peg$c1 = "."; + var peg$c2 = "verb*"; + var peg$c3 = "verb"; + var peg$c4 = "["; + var peg$c5 = "]"; + var peg$c6 = "lstinline"; + var peg$c7 = "mintinline"; + var peg$c8 = "mint"; + var peg$c9 = "minted"; + var peg$c10 = "verbatim*"; + var peg$c11 = "verbatim"; + var peg$c12 = "filecontents*"; + var peg$c13 = "filecontents"; + var peg$c14 = "comment"; + var peg$c15 = "lstlisting"; + var peg$c16 = "("; + var peg$c17 = ")"; + var peg$c18 = "begin"; + var peg$c19 = "end"; + var peg$c20 = "equation*"; + var peg$c21 = "equation"; + var peg$c22 = "align*"; + var peg$c23 = "align"; + var peg$c24 = "alignat*"; + var peg$c25 = "alignat"; + var peg$c26 = "gather*"; + var peg$c27 = "gather"; + var peg$c28 = "multline*"; + var peg$c29 = "multline"; + var peg$c30 = "flalign*"; + var peg$c31 = "flalign"; + var peg$c32 = "split"; + var peg$c33 = "math"; + var peg$c34 = "displaymath"; + var peg$c35 = "\\"; + var peg$c36 = "{"; + var peg$c37 = "}"; + var peg$c38 = "$"; + var peg$c39 = "&"; + var peg$c40 = "\r"; + var peg$c41 = "\n"; + var peg$c42 = "\r\n"; + var peg$c43 = "#"; + var peg$c44 = "^"; + var peg$c45 = "_"; + var peg$c46 = "\0"; + var peg$r0 = /^[^ \t\n\r]/; + var peg$r1 = /^[ \t]/; + var peg$r2 = /^[a-zA-Z]/; + var peg$r3 = /^[0-9]/; + var peg$r4 = /^[.,;:\-*\/()!?=+<>[\]`'"~]/; + var peg$e0 = peg$otherExpectation("document"); + var peg$e1 = peg$otherExpectation("math"); + var peg$e2 = peg$otherExpectation("token"); + var peg$e3 = peg$anyExpectation(); + var peg$e4 = peg$otherExpectation("parbreak"); + var peg$e5 = peg$otherExpectation("math token"); + var peg$e6 = peg$otherExpectation("nonchar token"); + var peg$e7 = peg$literalExpectation("%", false); + var peg$e8 = peg$otherExpectation("whitespace"); + var peg$e9 = peg$otherExpectation("number"); + var peg$e10 = peg$literalExpectation(".", false); + var peg$e11 = peg$otherExpectation("special macro"); + var peg$e12 = peg$literalExpectation("verb*", false); + var peg$e13 = peg$literalExpectation("verb", false); + var peg$e14 = peg$literalExpectation("[", false); + var peg$e15 = peg$literalExpectation("]", false); + var peg$e16 = peg$classExpectation([" ", " ", "\n", "\r"], true, false); + var peg$e17 = peg$otherExpectation("verbatim listings"); + var peg$e18 = peg$literalExpectation("lstinline", false); + var peg$e19 = peg$otherExpectation("verbatim minted"); + var peg$e20 = peg$literalExpectation("mintinline", false); + var peg$e21 = peg$literalExpectation("mint", false); + var peg$e22 = peg$otherExpectation("verbatim minted environment"); + var peg$e23 = peg$literalExpectation("minted", false); + var peg$e24 = peg$otherExpectation("verbatim environment"); + var peg$e25 = peg$literalExpectation("verbatim*", false); + var peg$e26 = peg$literalExpectation("verbatim", false); + var peg$e27 = peg$literalExpectation("filecontents*", false); + var peg$e28 = peg$literalExpectation("filecontents", false); + var peg$e29 = peg$literalExpectation("comment", false); + var peg$e30 = peg$literalExpectation("lstlisting", false); + var peg$e31 = peg$otherExpectation("macro"); + var peg$e32 = peg$otherExpectation("group"); + var peg$e33 = peg$otherExpectation("environment"); + var peg$e34 = peg$otherExpectation("math environment"); + var peg$e36 = peg$literalExpectation("(", false); + var peg$e37 = peg$literalExpectation(")", false); + var peg$e38 = peg$literalExpectation("begin", false); + var peg$e39 = peg$literalExpectation("end", false); + var peg$e40 = peg$literalExpectation("equation*", false); + var peg$e41 = peg$literalExpectation("equation", false); + var peg$e42 = peg$literalExpectation("align*", false); + var peg$e43 = peg$literalExpectation("align", false); + var peg$e44 = peg$literalExpectation("alignat*", false); + var peg$e45 = peg$literalExpectation("alignat", false); + var peg$e46 = peg$literalExpectation("gather*", false); + var peg$e47 = peg$literalExpectation("gather", false); + var peg$e48 = peg$literalExpectation("multline*", false); + var peg$e49 = peg$literalExpectation("multline", false); + var peg$e50 = peg$literalExpectation("flalign*", false); + var peg$e51 = peg$literalExpectation("flalign", false); + var peg$e52 = peg$literalExpectation("split", false); + var peg$e53 = peg$literalExpectation("math", false); + var peg$e54 = peg$literalExpectation("displaymath", false); + var peg$e55 = peg$otherExpectation("escape"); + var peg$e56 = peg$literalExpectation("\\", false); + var peg$e57 = peg$literalExpectation("{", false); + var peg$e58 = peg$literalExpectation("}", false); + var peg$e59 = peg$literalExpectation("$", false); + var peg$e60 = peg$literalExpectation("&", false); + var peg$e61 = peg$otherExpectation("newline"); + var peg$e62 = peg$literalExpectation("\r", false); + var peg$e63 = peg$literalExpectation("\n", false); + var peg$e64 = peg$literalExpectation("\r\n", false); + var peg$e65 = peg$literalExpectation("#", false); + var peg$e66 = peg$literalExpectation("^", false); + var peg$e67 = peg$literalExpectation("_", false); + var peg$e68 = peg$literalExpectation("\0", false); + var peg$e69 = peg$classExpectation([" ", " "], false, false); + var peg$e70 = peg$otherExpectation("letter"); + var peg$e71 = peg$classExpectation([["a", "z"], ["A", "Z"]], false, false); + var peg$e72 = peg$otherExpectation("digit"); + var peg$e73 = peg$classExpectation([["0", "9"]], false, false); + var peg$e74 = peg$otherExpectation("punctuation"); + var peg$e75 = peg$classExpectation([".", ",", ";", ":", "-", "*", "/", "(", ")", "!", "?", "=", "+", "<", ">", "[", "]", "`", "'", '"', "~"], false, false); + var peg$e76 = peg$otherExpectation("full comment"); + var peg$e77 = peg$otherExpectation("comment"); + var peg$f0 = function(content) { + return createNode("root", { content: content.flatMap((x) => x) }); + }; + var peg$f1 = function(t) { + return t; + }; + var peg$f2 = function(eq) { + return createNode("inlinemath", { content: eq.flatMap((x) => x) }); + }; + var peg$f3 = function(s) { + return createNode("string", { content: s }); + }; + var peg$f4 = function(s) { + return createNode("string", { content: s }); + }; + var peg$f5 = function() { + return createNode("parbreak"); + }; + var peg$f6 = function(x) { + return x; + }; + var peg$f7 = function(x) { + return x; + }; + var peg$f8 = function() { + return createNode("macro", { content: "^", escapeToken: "" }); + }; + var peg$f9 = function() { + return createNode("macro", { content: "_", escapeToken: "" }); + }; + var peg$f10 = function(s) { + return createNode("string", { content: s }); + }; + var peg$f11 = function() { + return createNode("whitespace"); + }; + var peg$f12 = function(a, b) { + return a.join("") + "." + b.join(""); + }; + var peg$f13 = function(b) { + return "." + b.join(""); + }; + var peg$f14 = function(a) { + return a.join("") + "."; + }; + var peg$f15 = function(s) { + return createNode("string", { content: s }); + }; + var peg$f16 = function(env, e, end) { + return end == e; + }; + var peg$f17 = function(env, e, x) { + return x; + }; + var peg$f18 = function(env, e, x, end) { + return end == e; + }; + var peg$f19 = function(env, e, x) { + return createNode("verb", { + env, + escape: e, + content: x.join("") + }); + }; + var peg$f20 = function(x) { + return x; + }; + var peg$f21 = function(x) { + return createNode("displaymath", { content: x.flatMap((x2) => x2) }); + }; + var peg$f22 = function(x) { + return x; + }; + var peg$f23 = function(x) { + return createNode("inlinemath", { content: x.flatMap((x2) => x2) }); + }; + var peg$f24 = function(x) { + return x; + }; + var peg$f25 = function(x) { + return createNode("displaymath", { content: x.flatMap((x2) => x2) }); + }; + var peg$f26 = function(end) { + return end.type === "string" && end.content === "]"; + }; + var peg$f27 = function(x) { + return x; + }; + var peg$f28 = function(o) { + return [ + createNode("string", { content: "[" }), + ...o, + createNode("string", { content: "]" }) + ]; + }; + var peg$f29 = function(x) { + return x; + }; + var peg$f30 = function(v) { + return createNode("group", { + content: createNode("string", { content: v.join("") }) + }); + }; + var peg$f31 = function(d, end) { + return end == d; + }; + var peg$f32 = function(d, x) { + return x; + }; + var peg$f33 = function(d, v, end) { + return end == d; + }; + var peg$f34 = function(d, v) { + return [ + createNode("string", { content: d }), + createNode("string", { content: v.join("") }), + createNode("string", { content: d }) + ]; + }; + var peg$f35 = function(macro, option, verbatim) { + return [ + createNode("macro", { content: macro }), + ...option || [], + ...[].concat(verbatim) + ]; + }; + var peg$f36 = function(macro, option, language, verbatim) { + return [ + createNode("macro", { content: macro }), + ...option || [], + language, + ...[].concat(verbatim) + ]; + }; + var peg$f37 = function(env, option, language, end_env) { + return compare_env({ content: [env] }, end_env); + }; + var peg$f38 = function(env, option, language, body) { + const content = [ + ...option || [], + language, + { type: "string", content: body } + ]; + return createNode("environment", { + env, + content + }); + }; + var peg$f39 = function(env, end_env) { + return compare_env({ content: [env] }, end_env); + }; + var peg$f40 = function(env, x) { + return x; + }; + var peg$f41 = function(env, body) { + return createNode("verbatim", { + env, + content: body + }); + }; + var peg$f42 = function(n) { + return n.join(""); + }; + var peg$f43 = function(n) { + return n; + }; + var peg$f44 = function(m) { + return createNode("macro", { content: m }); + }; + var peg$f45 = function(c) { + return c; + }; + var peg$f46 = function(x) { + return createNode("group", { content: x.flatMap((x2) => x2) }); + }; + var peg$f47 = function(g) { + return text().slice(1, -1); + }; + var peg$f48 = function(env, env_comment, end_env) { + return compare_env(env, end_env); + }; + var peg$f49 = function(env, env_comment, x) { + return x; + }; + var peg$f50 = function(env, env_comment, body) { + body = body.flatMap((x) => x); + return createNode("environment", { + env, + content: env_comment ? [env_comment, ...body] : body + }); + }; + var peg$f51 = function(env, env_comment, end_env) { + return compare_env({ content: [env] }, end_env); + }; + var peg$f52 = function(env, env_comment, x) { + return x; + }; + var peg$f53 = function(env, env_comment, body) { + body = body.flatMap((x) => x); + return createNode("mathenv", { + env, + content: env_comment ? [env_comment, ...body] : body + }); + }; + var peg$f56 = function(e) { + return createNode("string", { content: e }); + }; + var peg$f57 = function() { + return createNode("string", { content: "\\" }); + }; + var peg$f58 = function(s) { + return createNode("string", { content: s }); + }; + var peg$f59 = function(s) { + return createNode("string", { content: s }); + }; + var peg$f60 = function(s) { + return createNode("string", { content: s }); + }; + var peg$f61 = function(s) { + return createNode("string", { content: s }); + }; + var peg$f62 = function(s) { + return createNode("string", { content: s }); + }; + var peg$f63 = function(s) { + return createNode("string", { content: s }); + }; + var peg$f64 = function(s) { + return createNode("string", { content: s }); + }; + var peg$f65 = function() { + return " "; + }; + var peg$f66 = function(p) { + return createNode("string", { content: p }); + }; + var peg$f67 = function(leading_sp, comment) { + return createNode("comment", { + ...comment, + sameline: false, + leadingWhitespace: leading_sp.length > 0 + }); + }; + var peg$f68 = function(spaces, x) { + return createNode("comment", { + ...x, + sameline: true, + leadingWhitespace: spaces.length > 0 + }); + }; + var peg$f69 = function(c) { + return c; + }; + var peg$f70 = function(c) { + return { content: c.join(""), suffixParbreak: true }; + }; + var peg$f71 = function(c) { + return c; + }; + var peg$f72 = function(c) { + return { content: c.join("") }; + }; + var peg$f73 = function() { + var loc = location(); + return loc.start.column === 1; + }; + var peg$currPos = 0; + var peg$savedPos = 0; + var peg$posDetailsCache = [{ line: 1, column: 1 }]; + var peg$maxFailPos = 0; + var peg$maxFailExpected = []; + var peg$silentFails = 0; + var peg$resultsCache = {}; + var peg$result; + if ("startRule" in options) { + if (!(options.startRule in peg$startRuleFunctions)) { + throw new Error(`Can't start parsing from rule "` + options.startRule + '".'); + } + peg$startRuleFunction = peg$startRuleFunctions[options.startRule]; + } + function text() { + return input.substring(peg$savedPos, peg$currPos); + } + function location() { + return peg$computeLocation(peg$savedPos, peg$currPos); + } + function peg$literalExpectation(text2, ignoreCase) { + return { type: "literal", text: text2, ignoreCase }; + } + function peg$classExpectation(parts, inverted, ignoreCase) { + return { type: "class", parts, inverted, ignoreCase }; + } + function peg$anyExpectation() { + return { type: "any" }; + } + function peg$endExpectation() { + return { type: "end" }; + } + function peg$otherExpectation(description) { + return { type: "other", description }; + } + function peg$computePosDetails(pos) { + var details = peg$posDetailsCache[pos]; + var p; + if (details) { + return details; + } else { + p = pos - 1; + while (!peg$posDetailsCache[p]) { + p--; + } + details = peg$posDetailsCache[p]; + details = { + line: details.line, + column: details.column + }; + while (p < pos) { + if (input.charCodeAt(p) === 10) { + details.line++; + details.column = 1; + } else { + details.column++; + } + p++; + } + peg$posDetailsCache[pos] = details; + return details; + } + } + function peg$computeLocation(startPos, endPos, offset2) { + var startPosDetails = peg$computePosDetails(startPos); + var endPosDetails = peg$computePosDetails(endPos); + var res = { + source: peg$source, + start: { + offset: startPos, + line: startPosDetails.line, + column: startPosDetails.column + }, + end: { + offset: endPos, + line: endPosDetails.line, + column: endPosDetails.column + } + }; + return res; + } + function peg$fail(expected2) { + if (peg$currPos < peg$maxFailPos) { + return; + } + if (peg$currPos > peg$maxFailPos) { + peg$maxFailPos = peg$currPos; + peg$maxFailExpected = []; + } + peg$maxFailExpected.push(expected2); + } + function peg$buildStructuredError(expected2, found, location2) { + return new peg$SyntaxError( + peg$SyntaxError.buildMessage(expected2, found), + expected2, + found, + location2 + ); + } + function peg$parsedocument() { + var s0, s1, s2; + var key = peg$currPos * 52 + 0; + var cached = peg$resultsCache[key]; + if (cached) { + peg$currPos = cached.nextPos; + return cached.result; + } + peg$silentFails++; + s0 = peg$currPos; + s1 = []; + s2 = peg$parsetoken(); + while (s2 !== peg$FAILED) { + s1.push(s2); + s2 = peg$parsetoken(); + } + peg$savedPos = s0; + s1 = peg$f0(s1); + s0 = s1; + peg$silentFails--; + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 }; + return s0; + } + function peg$parsemath() { + var s0, s1; + var key = peg$currPos * 52 + 1; + var cached = peg$resultsCache[key]; + if (cached) { + peg$currPos = cached.nextPos; + return cached.result; + } + peg$silentFails++; + s0 = []; + s1 = peg$parsemath_token(); + while (s1 !== peg$FAILED) { + s0.push(s1); + s1 = peg$parsemath_token(); + } + peg$silentFails--; + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e1); + } + peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 }; + return s0; + } + function peg$parsetoken() { + var s0, s1, s2, s3, s4, s5; + var key = peg$currPos * 52 + 2; + var cached = peg$resultsCache[key]; + if (cached) { + peg$currPos = cached.nextPos; + return cached.result; + } + peg$silentFails++; + s0 = peg$parsespecial_macro(); + if (s0 === peg$FAILED) { + s0 = peg$parsemacro(); + if (s0 === peg$FAILED) { + s0 = peg$parsefull_comment(); + if (s0 === peg$FAILED) { + s0 = peg$parsegroup(); + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$parsemath_shift(); + if (s1 !== peg$FAILED) { + s2 = []; + s3 = peg$currPos; + s4 = peg$currPos; + peg$silentFails++; + s5 = peg$parsemath_shift(); + peg$silentFails--; + if (s5 === peg$FAILED) { + s4 = void 0; + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + if (s4 !== peg$FAILED) { + s5 = peg$parsemath_token(); + if (s5 !== peg$FAILED) { + peg$savedPos = s3; + s3 = peg$f1(s5); + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + if (s3 !== peg$FAILED) { + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$currPos; + s4 = peg$currPos; + peg$silentFails++; + s5 = peg$parsemath_shift(); + peg$silentFails--; + if (s5 === peg$FAILED) { + s4 = void 0; + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + if (s4 !== peg$FAILED) { + s5 = peg$parsemath_token(); + if (s5 !== peg$FAILED) { + peg$savedPos = s3; + s3 = peg$f1(s5); + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s3 = peg$parsemath_shift(); + if (s3 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f2(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$parsealignment_tab(); + if (s0 === peg$FAILED) { + s0 = peg$parseparbreak(); + if (s0 === peg$FAILED) { + s0 = peg$parsemacro_parameter(); + if (s0 === peg$FAILED) { + s0 = peg$parseignore(); + if (s0 === peg$FAILED) { + s0 = peg$parsenumber(); + if (s0 === peg$FAILED) { + s0 = peg$parsewhitespace(); + if (s0 === peg$FAILED) { + s0 = peg$parsepunctuation(); + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$currPos; + s2 = []; + s3 = peg$currPos; + s4 = peg$currPos; + peg$silentFails++; + s5 = peg$parsenonchar_token(); + peg$silentFails--; + if (s5 === peg$FAILED) { + s4 = void 0; + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + if (s4 !== peg$FAILED) { + if (input.length > peg$currPos) { + s5 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s5 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s5 !== peg$FAILED) { + s4 = [s4, s5]; + s3 = s4; + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + if (s3 !== peg$FAILED) { + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$currPos; + s4 = peg$currPos; + peg$silentFails++; + s5 = peg$parsenonchar_token(); + peg$silentFails--; + if (s5 === peg$FAILED) { + s4 = void 0; + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + if (s4 !== peg$FAILED) { + if (input.length > peg$currPos) { + s5 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s5 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s5 !== peg$FAILED) { + s4 = [s4, s5]; + s3 = s4; + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s1 = input.substring(s1, peg$currPos); + } else { + s1 = s2; + } + if (s1 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$f3(s1); + } + s0 = s1; + if (s0 === peg$FAILED) { + s0 = peg$parsebegin_group(); + if (s0 === peg$FAILED) { + s0 = peg$parseend_group(); + if (s0 === peg$FAILED) { + s0 = peg$parsemath_shift(); + if (s0 === peg$FAILED) { + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s1 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$f4(s1); + } + s0 = s1; + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e2); + } + } + peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 }; + return s0; + } + function peg$parseparbreak() { + var s0, s1, s2, s3, s4, s5, s6, s7; + var key = peg$currPos * 52 + 3; + var cached = peg$resultsCache[key]; + if (cached) { + peg$currPos = cached.nextPos; + return cached.result; + } + peg$silentFails++; + s0 = peg$currPos; + s1 = peg$currPos; + s2 = []; + s3 = peg$parsesp(); + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$parsesp(); + } + s3 = peg$parsenl(); + if (s3 !== peg$FAILED) { + s4 = []; + s5 = peg$currPos; + s6 = []; + s7 = peg$parsesp(); + while (s7 !== peg$FAILED) { + s6.push(s7); + s7 = peg$parsesp(); + } + s7 = peg$parsenl(); + if (s7 !== peg$FAILED) { + s6 = [s6, s7]; + s5 = s6; + } else { + peg$currPos = s5; + s5 = peg$FAILED; + } + if (s5 !== peg$FAILED) { + while (s5 !== peg$FAILED) { + s4.push(s5); + s5 = peg$currPos; + s6 = []; + s7 = peg$parsesp(); + while (s7 !== peg$FAILED) { + s6.push(s7); + s7 = peg$parsesp(); + } + s7 = peg$parsenl(); + if (s7 !== peg$FAILED) { + s6 = [s6, s7]; + s5 = s6; + } else { + peg$currPos = s5; + s5 = peg$FAILED; + } + } + } else { + s4 = peg$FAILED; + } + if (s4 !== peg$FAILED) { + s5 = []; + s6 = peg$parsesp(); + while (s6 !== peg$FAILED) { + s5.push(s6); + s6 = peg$parsesp(); + } + s6 = peg$currPos; + peg$silentFails++; + s7 = peg$parsecomment_start(); + peg$silentFails--; + if (s7 === peg$FAILED) { + s6 = void 0; + } else { + peg$currPos = s6; + s6 = peg$FAILED; + } + if (s6 !== peg$FAILED) { + s2 = [s2, s3, s4, s5, s6]; + s1 = s2; + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + if (s1 === peg$FAILED) { + s1 = peg$currPos; + s2 = []; + s3 = peg$parsesp(); + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$parsesp(); + } + s3 = peg$parsenl(); + if (s3 !== peg$FAILED) { + s4 = []; + s5 = peg$currPos; + s6 = []; + s7 = peg$parsesp(); + while (s7 !== peg$FAILED) { + s6.push(s7); + s7 = peg$parsesp(); + } + s7 = peg$parsenl(); + if (s7 !== peg$FAILED) { + s6 = [s6, s7]; + s5 = s6; + } else { + peg$currPos = s5; + s5 = peg$FAILED; + } + if (s5 !== peg$FAILED) { + while (s5 !== peg$FAILED) { + s4.push(s5); + s5 = peg$currPos; + s6 = []; + s7 = peg$parsesp(); + while (s7 !== peg$FAILED) { + s6.push(s7); + s7 = peg$parsesp(); + } + s7 = peg$parsenl(); + if (s7 !== peg$FAILED) { + s6 = [s6, s7]; + s5 = s6; + } else { + peg$currPos = s5; + s5 = peg$FAILED; + } + } + } else { + s4 = peg$FAILED; + } + if (s4 !== peg$FAILED) { + s2 = [s2, s3, s4]; + s1 = s2; + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + } + if (s1 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$f5(); + } + s0 = s1; + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e4); + } + } + peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 }; + return s0; + } + function peg$parsemath_token() { + var s0, s1, s2, s3, s4; + var key = peg$currPos * 52 + 4; + var cached = peg$resultsCache[key]; + if (cached) { + peg$currPos = cached.nextPos; + return cached.result; + } + peg$silentFails++; + s0 = peg$parsespecial_macro(); + if (s0 === peg$FAILED) { + s0 = peg$parsemacro(); + if (s0 === peg$FAILED) { + s0 = peg$parsefull_comment(); + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = []; + s2 = peg$parsewhitespace(); + while (s2 !== peg$FAILED) { + s1.push(s2); + s2 = peg$parsewhitespace(); + } + s2 = peg$parsegroup(); + if (s2 !== peg$FAILED) { + s3 = []; + s4 = peg$parsewhitespace(); + while (s4 !== peg$FAILED) { + s3.push(s4); + s4 = peg$parsewhitespace(); + } + peg$savedPos = s0; + s0 = peg$f6(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = []; + s2 = peg$parsewhitespace(); + while (s2 !== peg$FAILED) { + s1.push(s2); + s2 = peg$parsewhitespace(); + } + s2 = peg$parsealignment_tab(); + if (s2 !== peg$FAILED) { + s3 = []; + s4 = peg$parsewhitespace(); + while (s4 !== peg$FAILED) { + s3.push(s4); + s4 = peg$parsewhitespace(); + } + peg$savedPos = s0; + s0 = peg$f7(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$parsemacro_parameter(); + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = []; + s2 = peg$parsewhitespace(); + while (s2 !== peg$FAILED) { + s1.push(s2); + s2 = peg$parsewhitespace(); + } + s2 = peg$parsesuperscript(); + if (s2 !== peg$FAILED) { + s3 = []; + s4 = peg$parsewhitespace(); + while (s4 !== peg$FAILED) { + s3.push(s4); + s4 = peg$parsewhitespace(); + } + peg$savedPos = s0; + s0 = peg$f8(); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = []; + s2 = peg$parsewhitespace(); + while (s2 !== peg$FAILED) { + s1.push(s2); + s2 = peg$parsewhitespace(); + } + s2 = peg$parsesubscript(); + if (s2 !== peg$FAILED) { + s3 = []; + s4 = peg$parsewhitespace(); + while (s4 !== peg$FAILED) { + s3.push(s4); + s4 = peg$parsewhitespace(); + } + peg$savedPos = s0; + s0 = peg$f9(); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$parseignore(); + if (s0 === peg$FAILED) { + s0 = peg$parsewhitespace(); + if (s0 === peg$FAILED) { + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s1 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$f10(s1); + } + s0 = s1; + } + } + } + } + } + } + } + } + } + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e5); + } + } + peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 }; + return s0; + } + function peg$parsenonchar_token() { + var s0; + var key = peg$currPos * 52 + 5; + var cached = peg$resultsCache[key]; + if (cached) { + peg$currPos = cached.nextPos; + return cached.result; + } + peg$silentFails++; + s0 = peg$parseescape(); + if (s0 === peg$FAILED) { + if (input.charCodeAt(peg$currPos) === 37) { + s0 = peg$c0; + peg$currPos++; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e7); + } + } + if (s0 === peg$FAILED) { + s0 = peg$parsebegin_group(); + if (s0 === peg$FAILED) { + s0 = peg$parseend_group(); + if (s0 === peg$FAILED) { + s0 = peg$parsemath_shift(); + if (s0 === peg$FAILED) { + s0 = peg$parsealignment_tab(); + if (s0 === peg$FAILED) { + s0 = peg$parsenl(); + if (s0 === peg$FAILED) { + s0 = peg$parsemacro_parameter(); + if (s0 === peg$FAILED) { + s0 = peg$parseignore(); + if (s0 === peg$FAILED) { + s0 = peg$parsesp(); + if (s0 === peg$FAILED) { + s0 = peg$parsepunctuation(); + if (s0 === peg$FAILED) { + s0 = peg$parseEOF(); + } + } + } + } + } + } + } + } + } + } + } + peg$silentFails--; + if (s0 === peg$FAILED) { + if (peg$silentFails === 0) { + peg$fail(peg$e6); + } + } + peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 }; + return s0; + } + function peg$parsewhitespace() { + var s0, s1, s2, s3, s4, s5, s6, s7; + var key = peg$currPos * 52 + 6; + var cached = peg$resultsCache[key]; + if (cached) { + peg$currPos = cached.nextPos; + return cached.result; + } + peg$silentFails++; + s0 = peg$currPos; + s1 = peg$currPos; + s2 = peg$parsenl(); + if (s2 !== peg$FAILED) { + s3 = []; + s4 = peg$parsesp(); + while (s4 !== peg$FAILED) { + s3.push(s4); + s4 = peg$parsesp(); + } + s2 = [s2, s3]; + s1 = s2; + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + if (s1 === peg$FAILED) { + s1 = peg$currPos; + s2 = []; + s3 = peg$parsesp(); + if (s3 !== peg$FAILED) { + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$parsesp(); + } + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s3 = peg$parsenl(); + if (s3 !== peg$FAILED) { + s4 = peg$currPos; + peg$silentFails++; + s5 = peg$parsecomment_start(); + peg$silentFails--; + if (s5 === peg$FAILED) { + s4 = void 0; + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + if (s4 !== peg$FAILED) { + s5 = []; + s6 = peg$parsesp(); + while (s6 !== peg$FAILED) { + s5.push(s6); + s6 = peg$parsesp(); + } + s6 = peg$currPos; + peg$silentFails++; + s7 = peg$parsenl(); + peg$silentFails--; + if (s7 === peg$FAILED) { + s6 = void 0; + } else { + peg$currPos = s6; + s6 = peg$FAILED; + } + if (s6 !== peg$FAILED) { + s2 = [s2, s3, s4, s5, s6]; + s1 = s2; + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + if (s1 === peg$FAILED) { + s1 = []; + s2 = peg$parsesp(); + if (s2 !== peg$FAILED) { + while (s2 !== peg$FAILED) { + s1.push(s2); + s2 = peg$parsesp(); + } + } else { + s1 = peg$FAILED; + } + } + } + if (s1 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$f11(); + } + s0 = s1; + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e8); + } + } + peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 }; + return s0; + } + function peg$parsenumber() { + var s0, s1, s2, s3, s4, s5; + var key = peg$currPos * 52 + 7; + var cached = peg$resultsCache[key]; + if (cached) { + peg$currPos = cached.nextPos; + return cached.result; + } + peg$silentFails++; + s0 = peg$currPos; + s1 = peg$currPos; + s2 = []; + s3 = peg$parsenum(); + if (s3 !== peg$FAILED) { + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$parsenum(); + } + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + if (input.charCodeAt(peg$currPos) === 46) { + s3 = peg$c1; + peg$currPos++; + } else { + s3 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e10); + } + } + if (s3 !== peg$FAILED) { + s4 = []; + s5 = peg$parsenum(); + if (s5 !== peg$FAILED) { + while (s5 !== peg$FAILED) { + s4.push(s5); + s5 = peg$parsenum(); + } + } else { + s4 = peg$FAILED; + } + if (s4 !== peg$FAILED) { + peg$savedPos = s1; + s1 = peg$f12(s2, s4); + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + if (s1 === peg$FAILED) { + s1 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 46) { + s2 = peg$c1; + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e10); + } + } + if (s2 !== peg$FAILED) { + s3 = []; + s4 = peg$parsenum(); + if (s4 !== peg$FAILED) { + while (s4 !== peg$FAILED) { + s3.push(s4); + s4 = peg$parsenum(); + } + } else { + s3 = peg$FAILED; + } + if (s3 !== peg$FAILED) { + peg$savedPos = s1; + s1 = peg$f13(s3); + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + if (s1 === peg$FAILED) { + s1 = peg$currPos; + s2 = []; + s3 = peg$parsenum(); + if (s3 !== peg$FAILED) { + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$parsenum(); + } + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + if (input.charCodeAt(peg$currPos) === 46) { + s3 = peg$c1; + peg$currPos++; + } else { + s3 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e10); + } + } + if (s3 !== peg$FAILED) { + peg$savedPos = s1; + s1 = peg$f14(s2); + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + } + } + if (s1 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$f15(s1); + } + s0 = s1; + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e9); + } + } + peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 }; + return s0; + } + function peg$parsespecial_macro() { + var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9; + var key = peg$currPos * 52 + 8; + var cached = peg$resultsCache[key]; + if (cached) { + peg$currPos = cached.nextPos; + return cached.result; + } + peg$silentFails++; + s0 = peg$currPos; + s1 = peg$parseescape(); + if (s1 !== peg$FAILED) { + if (input.substr(peg$currPos, 5) === peg$c2) { + s2 = peg$c2; + peg$currPos += 5; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e12); + } + } + if (s2 === peg$FAILED) { + if (input.substr(peg$currPos, 4) === peg$c3) { + s2 = peg$c3; + peg$currPos += 4; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e13); + } + } + } + if (s2 !== peg$FAILED) { + if (input.length > peg$currPos) { + s3 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s3 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s3 !== peg$FAILED) { + s4 = []; + s5 = peg$currPos; + s6 = peg$currPos; + peg$silentFails++; + s7 = peg$currPos; + if (input.length > peg$currPos) { + s8 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s8 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s8 !== peg$FAILED) { + peg$savedPos = peg$currPos; + s9 = peg$f16(s2, s3, s8); + if (s9) { + s9 = void 0; + } else { + s9 = peg$FAILED; + } + if (s9 !== peg$FAILED) { + s8 = [s8, s9]; + s7 = s8; + } else { + peg$currPos = s7; + s7 = peg$FAILED; + } + } else { + peg$currPos = s7; + s7 = peg$FAILED; + } + peg$silentFails--; + if (s7 === peg$FAILED) { + s6 = void 0; + } else { + peg$currPos = s6; + s6 = peg$FAILED; + } + if (s6 !== peg$FAILED) { + if (input.length > peg$currPos) { + s7 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s7 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s7 !== peg$FAILED) { + peg$savedPos = s5; + s5 = peg$f17(s2, s3, s7); + } else { + peg$currPos = s5; + s5 = peg$FAILED; + } + } else { + peg$currPos = s5; + s5 = peg$FAILED; + } + while (s5 !== peg$FAILED) { + s4.push(s5); + s5 = peg$currPos; + s6 = peg$currPos; + peg$silentFails++; + s7 = peg$currPos; + if (input.length > peg$currPos) { + s8 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s8 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s8 !== peg$FAILED) { + peg$savedPos = peg$currPos; + s9 = peg$f16(s2, s3, s8); + if (s9) { + s9 = void 0; + } else { + s9 = peg$FAILED; + } + if (s9 !== peg$FAILED) { + s8 = [s8, s9]; + s7 = s8; + } else { + peg$currPos = s7; + s7 = peg$FAILED; + } + } else { + peg$currPos = s7; + s7 = peg$FAILED; + } + peg$silentFails--; + if (s7 === peg$FAILED) { + s6 = void 0; + } else { + peg$currPos = s6; + s6 = peg$FAILED; + } + if (s6 !== peg$FAILED) { + if (input.length > peg$currPos) { + s7 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s7 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s7 !== peg$FAILED) { + peg$savedPos = s5; + s5 = peg$f17(s2, s3, s7); + } else { + peg$currPos = s5; + s5 = peg$FAILED; + } + } else { + peg$currPos = s5; + s5 = peg$FAILED; + } + } + s5 = peg$currPos; + if (input.length > peg$currPos) { + s6 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s6 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s6 !== peg$FAILED) { + peg$savedPos = peg$currPos; + s7 = peg$f18(s2, s3, s4, s6); + if (s7) { + s7 = void 0; + } else { + s7 = peg$FAILED; + } + if (s7 !== peg$FAILED) { + s6 = [s6, s7]; + s5 = s6; + } else { + peg$currPos = s5; + s5 = peg$FAILED; + } + } else { + peg$currPos = s5; + s5 = peg$FAILED; + } + if (s5 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f19(s2, s3, s4); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$parseverbatim_listings(); + if (s0 === peg$FAILED) { + s0 = peg$parseverbatim_minted(); + if (s0 === peg$FAILED) { + s0 = peg$parseverbatim_minted_environment(); + if (s0 === peg$FAILED) { + s0 = peg$parseverbatim_environment(); + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$parsebegin_display_math(); + if (s1 !== peg$FAILED) { + s2 = []; + s3 = peg$currPos; + s4 = peg$currPos; + peg$silentFails++; + s5 = peg$parseend_display_math(); + peg$silentFails--; + if (s5 === peg$FAILED) { + s4 = void 0; + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + if (s4 !== peg$FAILED) { + s5 = peg$parsemath_token(); + if (s5 !== peg$FAILED) { + peg$savedPos = s3; + s3 = peg$f20(s5); + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$currPos; + s4 = peg$currPos; + peg$silentFails++; + s5 = peg$parseend_display_math(); + peg$silentFails--; + if (s5 === peg$FAILED) { + s4 = void 0; + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + if (s4 !== peg$FAILED) { + s5 = peg$parsemath_token(); + if (s5 !== peg$FAILED) { + peg$savedPos = s3; + s3 = peg$f20(s5); + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } + s3 = peg$parseend_display_math(); + if (s3 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f21(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$parsebegin_inline_math(); + if (s1 !== peg$FAILED) { + s2 = []; + s3 = peg$currPos; + s4 = peg$currPos; + peg$silentFails++; + s5 = peg$parseend_inline_math(); + peg$silentFails--; + if (s5 === peg$FAILED) { + s4 = void 0; + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + if (s4 !== peg$FAILED) { + s5 = peg$parsemath_token(); + if (s5 !== peg$FAILED) { + peg$savedPos = s3; + s3 = peg$f22(s5); + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$currPos; + s4 = peg$currPos; + peg$silentFails++; + s5 = peg$parseend_inline_math(); + peg$silentFails--; + if (s5 === peg$FAILED) { + s4 = void 0; + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + if (s4 !== peg$FAILED) { + s5 = peg$parsemath_token(); + if (s5 !== peg$FAILED) { + peg$savedPos = s3; + s3 = peg$f22(s5); + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } + s3 = peg$parseend_inline_math(); + if (s3 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f23(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$parsemath_shift(); + if (s1 !== peg$FAILED) { + s2 = peg$parsemath_shift(); + if (s2 !== peg$FAILED) { + s3 = []; + s4 = peg$currPos; + s5 = peg$currPos; + peg$silentFails++; + s6 = peg$currPos; + s7 = peg$parsemath_shift(); + if (s7 !== peg$FAILED) { + s8 = peg$parsemath_shift(); + if (s8 !== peg$FAILED) { + s7 = [s7, s8]; + s6 = s7; + } else { + peg$currPos = s6; + s6 = peg$FAILED; + } + } else { + peg$currPos = s6; + s6 = peg$FAILED; + } + peg$silentFails--; + if (s6 === peg$FAILED) { + s5 = void 0; + } else { + peg$currPos = s5; + s5 = peg$FAILED; + } + if (s5 !== peg$FAILED) { + s6 = peg$parsemath_token(); + if (s6 !== peg$FAILED) { + peg$savedPos = s4; + s4 = peg$f24(s6); + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + while (s4 !== peg$FAILED) { + s3.push(s4); + s4 = peg$currPos; + s5 = peg$currPos; + peg$silentFails++; + s6 = peg$currPos; + s7 = peg$parsemath_shift(); + if (s7 !== peg$FAILED) { + s8 = peg$parsemath_shift(); + if (s8 !== peg$FAILED) { + s7 = [s7, s8]; + s6 = s7; + } else { + peg$currPos = s6; + s6 = peg$FAILED; + } + } else { + peg$currPos = s6; + s6 = peg$FAILED; + } + peg$silentFails--; + if (s6 === peg$FAILED) { + s5 = void 0; + } else { + peg$currPos = s5; + s5 = peg$FAILED; + } + if (s5 !== peg$FAILED) { + s6 = peg$parsemath_token(); + if (s6 !== peg$FAILED) { + peg$savedPos = s4; + s4 = peg$f24(s6); + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + } + s4 = peg$parsemath_shift(); + if (s4 !== peg$FAILED) { + s5 = peg$parsemath_shift(); + if (s5 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f25(s3); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$parsemath_environment(); + if (s0 === peg$FAILED) { + s0 = peg$parseenvironment(); + } + } + } + } + } + } + } + } + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e11); + } + } + peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 }; + return s0; + } + function peg$parsesquare_bracket_argument() { + var s0, s1, s2, s3, s4, s5, s6, s7; + var key = peg$currPos * 52 + 9; + var cached = peg$resultsCache[key]; + if (cached) { + peg$currPos = cached.nextPos; + return cached.result; + } + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 91) { + s1 = peg$c4; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e14); + } + } + if (s1 !== peg$FAILED) { + s2 = []; + s3 = peg$currPos; + s4 = peg$currPos; + peg$silentFails++; + s5 = peg$currPos; + s6 = peg$parsetoken(); + if (s6 !== peg$FAILED) { + peg$savedPos = peg$currPos; + s7 = peg$f26(s6); + if (s7) { + s7 = void 0; + } else { + s7 = peg$FAILED; + } + if (s7 !== peg$FAILED) { + s6 = [s6, s7]; + s5 = s6; + } else { + peg$currPos = s5; + s5 = peg$FAILED; + } + } else { + peg$currPos = s5; + s5 = peg$FAILED; + } + peg$silentFails--; + if (s5 === peg$FAILED) { + s4 = void 0; + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + if (s4 !== peg$FAILED) { + s5 = peg$parsetoken(); + if (s5 !== peg$FAILED) { + peg$savedPos = s3; + s3 = peg$f27(s5); + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$currPos; + s4 = peg$currPos; + peg$silentFails++; + s5 = peg$currPos; + s6 = peg$parsetoken(); + if (s6 !== peg$FAILED) { + peg$savedPos = peg$currPos; + s7 = peg$f26(s6); + if (s7) { + s7 = void 0; + } else { + s7 = peg$FAILED; + } + if (s7 !== peg$FAILED) { + s6 = [s6, s7]; + s5 = s6; + } else { + peg$currPos = s5; + s5 = peg$FAILED; + } + } else { + peg$currPos = s5; + s5 = peg$FAILED; + } + peg$silentFails--; + if (s5 === peg$FAILED) { + s4 = void 0; + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + if (s4 !== peg$FAILED) { + s5 = peg$parsetoken(); + if (s5 !== peg$FAILED) { + peg$savedPos = s3; + s3 = peg$f27(s5); + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } + if (input.charCodeAt(peg$currPos) === 93) { + s3 = peg$c5; + peg$currPos++; + } else { + s3 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e15); + } + } + if (s3 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f28(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 }; + return s0; + } + function peg$parseverbatim_group() { + var s0, s1, s2, s3, s4, s5; + var key = peg$currPos * 52 + 10; + var cached = peg$resultsCache[key]; + if (cached) { + peg$currPos = cached.nextPos; + return cached.result; + } + s0 = peg$currPos; + s1 = peg$parsebegin_group(); + if (s1 !== peg$FAILED) { + s2 = []; + s3 = peg$currPos; + s4 = peg$currPos; + peg$silentFails++; + s5 = peg$parseend_group(); + peg$silentFails--; + if (s5 === peg$FAILED) { + s4 = void 0; + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + if (s4 !== peg$FAILED) { + if (input.length > peg$currPos) { + s5 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s5 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s5 !== peg$FAILED) { + peg$savedPos = s3; + s3 = peg$f29(s5); + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$currPos; + s4 = peg$currPos; + peg$silentFails++; + s5 = peg$parseend_group(); + peg$silentFails--; + if (s5 === peg$FAILED) { + s4 = void 0; + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + if (s4 !== peg$FAILED) { + if (input.length > peg$currPos) { + s5 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s5 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s5 !== peg$FAILED) { + peg$savedPos = s3; + s3 = peg$f29(s5); + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } + s3 = peg$parseend_group(); + if (s3 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f30(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 }; + return s0; + } + function peg$parseverbatim_delimited_by_char() { + var s0, s1, s2, s3, s4, s5, s6, s7; + var key = peg$currPos * 52 + 11; + var cached = peg$resultsCache[key]; + if (cached) { + peg$currPos = cached.nextPos; + return cached.result; + } + s0 = peg$currPos; + if (peg$r0.test(input.charAt(peg$currPos))) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e16); + } + } + if (s1 !== peg$FAILED) { + s2 = []; + s3 = peg$currPos; + s4 = peg$currPos; + peg$silentFails++; + s5 = peg$currPos; + if (input.length > peg$currPos) { + s6 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s6 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s6 !== peg$FAILED) { + peg$savedPos = peg$currPos; + s7 = peg$f31(s1, s6); + if (s7) { + s7 = void 0; + } else { + s7 = peg$FAILED; + } + if (s7 !== peg$FAILED) { + s6 = [s6, s7]; + s5 = s6; + } else { + peg$currPos = s5; + s5 = peg$FAILED; + } + } else { + peg$currPos = s5; + s5 = peg$FAILED; + } + peg$silentFails--; + if (s5 === peg$FAILED) { + s4 = void 0; + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + if (s4 !== peg$FAILED) { + if (input.length > peg$currPos) { + s5 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s5 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s5 !== peg$FAILED) { + peg$savedPos = s3; + s3 = peg$f32(s1, s5); + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$currPos; + s4 = peg$currPos; + peg$silentFails++; + s5 = peg$currPos; + if (input.length > peg$currPos) { + s6 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s6 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s6 !== peg$FAILED) { + peg$savedPos = peg$currPos; + s7 = peg$f31(s1, s6); + if (s7) { + s7 = void 0; + } else { + s7 = peg$FAILED; + } + if (s7 !== peg$FAILED) { + s6 = [s6, s7]; + s5 = s6; + } else { + peg$currPos = s5; + s5 = peg$FAILED; + } + } else { + peg$currPos = s5; + s5 = peg$FAILED; + } + peg$silentFails--; + if (s5 === peg$FAILED) { + s4 = void 0; + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + if (s4 !== peg$FAILED) { + if (input.length > peg$currPos) { + s5 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s5 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s5 !== peg$FAILED) { + peg$savedPos = s3; + s3 = peg$f32(s1, s5); + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } + s3 = peg$currPos; + if (input.length > peg$currPos) { + s4 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s4 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s4 !== peg$FAILED) { + peg$savedPos = peg$currPos; + s5 = peg$f33(s1, s2, s4); + if (s5) { + s5 = void 0; + } else { + s5 = peg$FAILED; + } + if (s5 !== peg$FAILED) { + s4 = [s4, s5]; + s3 = s4; + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + if (s3 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f34(s1, s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 }; + return s0; + } + function peg$parseverbatim_listings() { + var s0, s1, s2, s3, s4; + var key = peg$currPos * 52 + 12; + var cached = peg$resultsCache[key]; + if (cached) { + peg$currPos = cached.nextPos; + return cached.result; + } + peg$silentFails++; + s0 = peg$currPos; + s1 = peg$parseescape(); + if (s1 !== peg$FAILED) { + if (input.substr(peg$currPos, 9) === peg$c6) { + s2 = peg$c6; + peg$currPos += 9; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e18); + } + } + if (s2 !== peg$FAILED) { + s3 = peg$parsesquare_bracket_argument(); + if (s3 === peg$FAILED) { + s3 = null; + } + s4 = peg$parseverbatim_group(); + if (s4 === peg$FAILED) { + s4 = peg$parseverbatim_delimited_by_char(); + } + if (s4 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f35(s2, s3, s4); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e17); + } + } + peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 }; + return s0; + } + function peg$parseverbatim_minted() { + var s0, s1, s2, s3, s4, s5; + var key = peg$currPos * 52 + 13; + var cached = peg$resultsCache[key]; + if (cached) { + peg$currPos = cached.nextPos; + return cached.result; + } + peg$silentFails++; + s0 = peg$currPos; + s1 = peg$parseescape(); + if (s1 !== peg$FAILED) { + if (input.substr(peg$currPos, 10) === peg$c7) { + s2 = peg$c7; + peg$currPos += 10; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e20); + } + } + if (s2 === peg$FAILED) { + if (input.substr(peg$currPos, 4) === peg$c8) { + s2 = peg$c8; + peg$currPos += 4; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e21); + } + } + } + if (s2 !== peg$FAILED) { + s3 = peg$parsesquare_bracket_argument(); + if (s3 === peg$FAILED) { + s3 = null; + } + s4 = peg$parsegroup(); + if (s4 !== peg$FAILED) { + s5 = peg$parseverbatim_group(); + if (s5 === peg$FAILED) { + s5 = peg$parseverbatim_delimited_by_char(); + } + if (s5 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f36(s2, s3, s4, s5); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e19); + } + } + peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 }; + return s0; + } + function peg$parseverbatim_minted_environment() { + var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14; + var key = peg$currPos * 52 + 14; + var cached = peg$resultsCache[key]; + if (cached) { + peg$currPos = cached.nextPos; + return cached.result; + } + peg$silentFails++; + s0 = peg$currPos; + s1 = peg$parsebegin_env(); + if (s1 !== peg$FAILED) { + s2 = peg$parsebegin_group(); + if (s2 !== peg$FAILED) { + if (input.substr(peg$currPos, 6) === peg$c9) { + s3 = peg$c9; + peg$currPos += 6; + } else { + s3 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e23); + } + } + if (s3 !== peg$FAILED) { + s4 = peg$parseend_group(); + if (s4 !== peg$FAILED) { + s5 = peg$parsesquare_bracket_argument(); + if (s5 === peg$FAILED) { + s5 = null; + } + s6 = peg$parsegroup(); + if (s6 !== peg$FAILED) { + s7 = peg$currPos; + s8 = []; + s9 = peg$currPos; + s10 = peg$currPos; + peg$silentFails++; + s11 = peg$currPos; + s12 = peg$parseend_env(); + if (s12 !== peg$FAILED) { + s13 = peg$parsegroup(); + if (s13 !== peg$FAILED) { + peg$savedPos = peg$currPos; + s14 = peg$f37(s3, s5, s6, s13); + if (s14) { + s14 = void 0; + } else { + s14 = peg$FAILED; + } + if (s14 !== peg$FAILED) { + s12 = [s12, s13, s14]; + s11 = s12; + } else { + peg$currPos = s11; + s11 = peg$FAILED; + } + } else { + peg$currPos = s11; + s11 = peg$FAILED; + } + } else { + peg$currPos = s11; + s11 = peg$FAILED; + } + peg$silentFails--; + if (s11 === peg$FAILED) { + s10 = void 0; + } else { + peg$currPos = s10; + s10 = peg$FAILED; + } + if (s10 !== peg$FAILED) { + if (input.length > peg$currPos) { + s11 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s11 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s11 !== peg$FAILED) { + s10 = [s10, s11]; + s9 = s10; + } else { + peg$currPos = s9; + s9 = peg$FAILED; + } + } else { + peg$currPos = s9; + s9 = peg$FAILED; + } + while (s9 !== peg$FAILED) { + s8.push(s9); + s9 = peg$currPos; + s10 = peg$currPos; + peg$silentFails++; + s11 = peg$currPos; + s12 = peg$parseend_env(); + if (s12 !== peg$FAILED) { + s13 = peg$parsegroup(); + if (s13 !== peg$FAILED) { + peg$savedPos = peg$currPos; + s14 = peg$f37(s3, s5, s6, s13); + if (s14) { + s14 = void 0; + } else { + s14 = peg$FAILED; + } + if (s14 !== peg$FAILED) { + s12 = [s12, s13, s14]; + s11 = s12; + } else { + peg$currPos = s11; + s11 = peg$FAILED; + } + } else { + peg$currPos = s11; + s11 = peg$FAILED; + } + } else { + peg$currPos = s11; + s11 = peg$FAILED; + } + peg$silentFails--; + if (s11 === peg$FAILED) { + s10 = void 0; + } else { + peg$currPos = s10; + s10 = peg$FAILED; + } + if (s10 !== peg$FAILED) { + if (input.length > peg$currPos) { + s11 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s11 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s11 !== peg$FAILED) { + s10 = [s10, s11]; + s9 = s10; + } else { + peg$currPos = s9; + s9 = peg$FAILED; + } + } else { + peg$currPos = s9; + s9 = peg$FAILED; + } + } + s7 = input.substring(s7, peg$currPos); + s8 = peg$parseend_env(); + if (s8 !== peg$FAILED) { + s9 = peg$parsebegin_group(); + if (s9 !== peg$FAILED) { + if (input.substr(peg$currPos, 6) === peg$c9) { + s10 = peg$c9; + peg$currPos += 6; + } else { + s10 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e23); + } + } + if (s10 !== peg$FAILED) { + s11 = peg$parseend_group(); + if (s11 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f38(s3, s5, s6, s7); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e22); + } + } + peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 }; + return s0; + } + function peg$parseverbatim_environment() { + var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12; + var key = peg$currPos * 52 + 15; + var cached = peg$resultsCache[key]; + if (cached) { + peg$currPos = cached.nextPos; + return cached.result; + } + peg$silentFails++; + s0 = peg$currPos; + s1 = peg$parsebegin_env(); + if (s1 !== peg$FAILED) { + s2 = peg$parsebegin_group(); + if (s2 !== peg$FAILED) { + s3 = peg$parseverbatim_env_name(); + if (s3 !== peg$FAILED) { + s4 = peg$parseend_group(); + if (s4 !== peg$FAILED) { + s5 = peg$currPos; + s6 = []; + s7 = peg$currPos; + s8 = peg$currPos; + peg$silentFails++; + s9 = peg$currPos; + s10 = peg$parseend_env(); + if (s10 !== peg$FAILED) { + s11 = peg$parsegroup(); + if (s11 !== peg$FAILED) { + peg$savedPos = peg$currPos; + s12 = peg$f39(s3, s11); + if (s12) { + s12 = void 0; + } else { + s12 = peg$FAILED; + } + if (s12 !== peg$FAILED) { + s10 = [s10, s11, s12]; + s9 = s10; + } else { + peg$currPos = s9; + s9 = peg$FAILED; + } + } else { + peg$currPos = s9; + s9 = peg$FAILED; + } + } else { + peg$currPos = s9; + s9 = peg$FAILED; + } + peg$silentFails--; + if (s9 === peg$FAILED) { + s8 = void 0; + } else { + peg$currPos = s8; + s8 = peg$FAILED; + } + if (s8 !== peg$FAILED) { + if (input.length > peg$currPos) { + s9 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s9 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s9 !== peg$FAILED) { + peg$savedPos = s7; + s7 = peg$f40(s3, s9); + } else { + peg$currPos = s7; + s7 = peg$FAILED; + } + } else { + peg$currPos = s7; + s7 = peg$FAILED; + } + while (s7 !== peg$FAILED) { + s6.push(s7); + s7 = peg$currPos; + s8 = peg$currPos; + peg$silentFails++; + s9 = peg$currPos; + s10 = peg$parseend_env(); + if (s10 !== peg$FAILED) { + s11 = peg$parsegroup(); + if (s11 !== peg$FAILED) { + peg$savedPos = peg$currPos; + s12 = peg$f39(s3, s11); + if (s12) { + s12 = void 0; + } else { + s12 = peg$FAILED; + } + if (s12 !== peg$FAILED) { + s10 = [s10, s11, s12]; + s9 = s10; + } else { + peg$currPos = s9; + s9 = peg$FAILED; + } + } else { + peg$currPos = s9; + s9 = peg$FAILED; + } + } else { + peg$currPos = s9; + s9 = peg$FAILED; + } + peg$silentFails--; + if (s9 === peg$FAILED) { + s8 = void 0; + } else { + peg$currPos = s8; + s8 = peg$FAILED; + } + if (s8 !== peg$FAILED) { + if (input.length > peg$currPos) { + s9 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s9 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s9 !== peg$FAILED) { + peg$savedPos = s7; + s7 = peg$f40(s3, s9); + } else { + peg$currPos = s7; + s7 = peg$FAILED; + } + } else { + peg$currPos = s7; + s7 = peg$FAILED; + } + } + s5 = input.substring(s5, peg$currPos); + s6 = peg$parseend_env(); + if (s6 !== peg$FAILED) { + s7 = peg$parsebegin_group(); + if (s7 !== peg$FAILED) { + s8 = peg$parseverbatim_env_name(); + if (s8 !== peg$FAILED) { + s9 = peg$parseend_group(); + if (s9 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f41(s3, s5); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e24); + } + } + peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 }; + return s0; + } + function peg$parseverbatim_env_name() { + var s0; + var key = peg$currPos * 52 + 16; + var cached = peg$resultsCache[key]; + if (cached) { + peg$currPos = cached.nextPos; + return cached.result; + } + if (input.substr(peg$currPos, 9) === peg$c10) { + s0 = peg$c10; + peg$currPos += 9; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e25); + } + } + if (s0 === peg$FAILED) { + if (input.substr(peg$currPos, 8) === peg$c11) { + s0 = peg$c11; + peg$currPos += 8; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e26); + } + } + if (s0 === peg$FAILED) { + if (input.substr(peg$currPos, 13) === peg$c12) { + s0 = peg$c12; + peg$currPos += 13; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e27); + } + } + if (s0 === peg$FAILED) { + if (input.substr(peg$currPos, 12) === peg$c13) { + s0 = peg$c13; + peg$currPos += 12; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e28); + } + } + if (s0 === peg$FAILED) { + if (input.substr(peg$currPos, 7) === peg$c14) { + s0 = peg$c14; + peg$currPos += 7; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e29); + } + } + if (s0 === peg$FAILED) { + if (input.substr(peg$currPos, 10) === peg$c15) { + s0 = peg$c15; + peg$currPos += 10; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e30); + } + } + } + } + } + } + } + peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 }; + return s0; + } + function peg$parsemacro() { + var s0, s1, s2, s3, s4; + var key = peg$currPos * 52 + 17; + var cached = peg$resultsCache[key]; + if (cached) { + peg$currPos = cached.nextPos; + return cached.result; + } + peg$silentFails++; + s0 = peg$currPos; + s1 = peg$currPos; + s2 = peg$parseescape(); + if (s2 !== peg$FAILED) { + s3 = []; + s4 = peg$parsechar(); + if (s4 !== peg$FAILED) { + while (s4 !== peg$FAILED) { + s3.push(s4); + s4 = peg$parsechar(); + } + } else { + s3 = peg$FAILED; + } + if (s3 !== peg$FAILED) { + peg$savedPos = s1; + s1 = peg$f42(s3); + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + if (s1 === peg$FAILED) { + s1 = peg$currPos; + s2 = peg$parseescape(); + if (s2 !== peg$FAILED) { + if (input.length > peg$currPos) { + s3 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s3 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s3 !== peg$FAILED) { + peg$savedPos = s1; + s1 = peg$f43(s3); + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + } + if (s1 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$f44(s1); + } + s0 = s1; + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e31); + } + } + peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 }; + return s0; + } + function peg$parsegroup() { + var s0, s1, s2, s3, s4, s5; + var key = peg$currPos * 52 + 18; + var cached = peg$resultsCache[key]; + if (cached) { + peg$currPos = cached.nextPos; + return cached.result; + } + peg$silentFails++; + s0 = peg$currPos; + s1 = peg$parsebegin_group(); + if (s1 !== peg$FAILED) { + s2 = []; + s3 = peg$currPos; + s4 = peg$currPos; + peg$silentFails++; + s5 = peg$parseend_group(); + peg$silentFails--; + if (s5 === peg$FAILED) { + s4 = void 0; + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + if (s4 !== peg$FAILED) { + s5 = peg$parsetoken(); + if (s5 !== peg$FAILED) { + peg$savedPos = s3; + s3 = peg$f45(s5); + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$currPos; + s4 = peg$currPos; + peg$silentFails++; + s5 = peg$parseend_group(); + peg$silentFails--; + if (s5 === peg$FAILED) { + s4 = void 0; + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + if (s4 !== peg$FAILED) { + s5 = peg$parsetoken(); + if (s5 !== peg$FAILED) { + peg$savedPos = s3; + s3 = peg$f45(s5); + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } + s3 = peg$parseend_group(); + if (s3 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f46(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e32); + } + } + peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 }; + return s0; + } + function peg$parsegroup_contents_as_string() { + var s0, s1; + var key = peg$currPos * 52 + 19; + var cached = peg$resultsCache[key]; + if (cached) { + peg$currPos = cached.nextPos; + return cached.result; + } + s0 = peg$currPos; + s1 = peg$parsegroup(); + if (s1 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$f47(); + } + s0 = s1; + peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 }; + return s0; + } + function peg$parseenvironment() { + var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10; + var key = peg$currPos * 52 + 20; + var cached = peg$resultsCache[key]; + if (cached) { + peg$currPos = cached.nextPos; + return cached.result; + } + peg$silentFails++; + s0 = peg$currPos; + s1 = peg$parsebegin_env(); + if (s1 !== peg$FAILED) { + s2 = peg$parsegroup_contents_as_string(); + if (s2 !== peg$FAILED) { + s3 = peg$parsesameline_comment(); + if (s3 === peg$FAILED) { + s3 = null; + } + s4 = []; + s5 = peg$currPos; + s6 = peg$currPos; + peg$silentFails++; + s7 = peg$currPos; + s8 = peg$parseend_env(); + if (s8 !== peg$FAILED) { + s9 = peg$parsegroup_contents_as_string(); + if (s9 !== peg$FAILED) { + peg$savedPos = peg$currPos; + s10 = peg$f48(s2, s3, s9); + if (s10) { + s10 = void 0; + } else { + s10 = peg$FAILED; + } + if (s10 !== peg$FAILED) { + s8 = [s8, s9, s10]; + s7 = s8; + } else { + peg$currPos = s7; + s7 = peg$FAILED; + } + } else { + peg$currPos = s7; + s7 = peg$FAILED; + } + } else { + peg$currPos = s7; + s7 = peg$FAILED; + } + peg$silentFails--; + if (s7 === peg$FAILED) { + s6 = void 0; + } else { + peg$currPos = s6; + s6 = peg$FAILED; + } + if (s6 !== peg$FAILED) { + s7 = peg$parsetoken(); + if (s7 !== peg$FAILED) { + peg$savedPos = s5; + s5 = peg$f49(s2, s3, s7); + } else { + peg$currPos = s5; + s5 = peg$FAILED; + } + } else { + peg$currPos = s5; + s5 = peg$FAILED; + } + while (s5 !== peg$FAILED) { + s4.push(s5); + s5 = peg$currPos; + s6 = peg$currPos; + peg$silentFails++; + s7 = peg$currPos; + s8 = peg$parseend_env(); + if (s8 !== peg$FAILED) { + s9 = peg$parsegroup_contents_as_string(); + if (s9 !== peg$FAILED) { + peg$savedPos = peg$currPos; + s10 = peg$f48(s2, s3, s9); + if (s10) { + s10 = void 0; + } else { + s10 = peg$FAILED; + } + if (s10 !== peg$FAILED) { + s8 = [s8, s9, s10]; + s7 = s8; + } else { + peg$currPos = s7; + s7 = peg$FAILED; + } + } else { + peg$currPos = s7; + s7 = peg$FAILED; + } + } else { + peg$currPos = s7; + s7 = peg$FAILED; + } + peg$silentFails--; + if (s7 === peg$FAILED) { + s6 = void 0; + } else { + peg$currPos = s6; + s6 = peg$FAILED; + } + if (s6 !== peg$FAILED) { + s7 = peg$parsetoken(); + if (s7 !== peg$FAILED) { + peg$savedPos = s5; + s5 = peg$f49(s2, s3, s7); + } else { + peg$currPos = s5; + s5 = peg$FAILED; + } + } else { + peg$currPos = s5; + s5 = peg$FAILED; + } + } + s5 = peg$parseend_env(); + if (s5 !== peg$FAILED) { + s6 = peg$parsegroup_contents_as_string(); + if (s6 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f50(s2, s3, s4); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e33); + } + } + peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 }; + return s0; + } + function peg$parsemath_environment() { + var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12; + var key = peg$currPos * 52 + 21; + var cached = peg$resultsCache[key]; + if (cached) { + peg$currPos = cached.nextPos; + return cached.result; + } + peg$silentFails++; + s0 = peg$currPos; + s1 = peg$parsebegin_env(); + if (s1 !== peg$FAILED) { + s2 = peg$parsebegin_group(); + if (s2 !== peg$FAILED) { + s3 = peg$parsemath_env_name(); + if (s3 !== peg$FAILED) { + s4 = peg$parseend_group(); + if (s4 !== peg$FAILED) { + s5 = peg$parsesameline_comment(); + if (s5 === peg$FAILED) { + s5 = null; + } + s6 = []; + s7 = peg$currPos; + s8 = peg$currPos; + peg$silentFails++; + s9 = peg$currPos; + s10 = peg$parseend_env(); + if (s10 !== peg$FAILED) { + s11 = peg$parsegroup(); + if (s11 !== peg$FAILED) { + peg$savedPos = peg$currPos; + s12 = peg$f51(s3, s5, s11); + if (s12) { + s12 = void 0; + } else { + s12 = peg$FAILED; + } + if (s12 !== peg$FAILED) { + s10 = [s10, s11, s12]; + s9 = s10; + } else { + peg$currPos = s9; + s9 = peg$FAILED; + } + } else { + peg$currPos = s9; + s9 = peg$FAILED; + } + } else { + peg$currPos = s9; + s9 = peg$FAILED; + } + peg$silentFails--; + if (s9 === peg$FAILED) { + s8 = void 0; + } else { + peg$currPos = s8; + s8 = peg$FAILED; + } + if (s8 !== peg$FAILED) { + s9 = peg$parsemath_token(); + if (s9 !== peg$FAILED) { + peg$savedPos = s7; + s7 = peg$f52(s3, s5, s9); + } else { + peg$currPos = s7; + s7 = peg$FAILED; + } + } else { + peg$currPos = s7; + s7 = peg$FAILED; + } + while (s7 !== peg$FAILED) { + s6.push(s7); + s7 = peg$currPos; + s8 = peg$currPos; + peg$silentFails++; + s9 = peg$currPos; + s10 = peg$parseend_env(); + if (s10 !== peg$FAILED) { + s11 = peg$parsegroup(); + if (s11 !== peg$FAILED) { + peg$savedPos = peg$currPos; + s12 = peg$f51(s3, s5, s11); + if (s12) { + s12 = void 0; + } else { + s12 = peg$FAILED; + } + if (s12 !== peg$FAILED) { + s10 = [s10, s11, s12]; + s9 = s10; + } else { + peg$currPos = s9; + s9 = peg$FAILED; + } + } else { + peg$currPos = s9; + s9 = peg$FAILED; + } + } else { + peg$currPos = s9; + s9 = peg$FAILED; + } + peg$silentFails--; + if (s9 === peg$FAILED) { + s8 = void 0; + } else { + peg$currPos = s8; + s8 = peg$FAILED; + } + if (s8 !== peg$FAILED) { + s9 = peg$parsemath_token(); + if (s9 !== peg$FAILED) { + peg$savedPos = s7; + s7 = peg$f52(s3, s5, s9); + } else { + peg$currPos = s7; + s7 = peg$FAILED; + } + } else { + peg$currPos = s7; + s7 = peg$FAILED; + } + } + s7 = peg$parseend_env(); + if (s7 !== peg$FAILED) { + s8 = peg$parsebegin_group(); + if (s8 !== peg$FAILED) { + s9 = peg$parsemath_env_name(); + if (s9 !== peg$FAILED) { + s10 = peg$parseend_group(); + if (s10 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f53(s3, s5, s6); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e34); + } + } + peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 }; + return s0; + } + function peg$parsebegin_display_math() { + var s0, s1, s2; + var key = peg$currPos * 52 + 23; + var cached = peg$resultsCache[key]; + if (cached) { + peg$currPos = cached.nextPos; + return cached.result; + } + s0 = peg$currPos; + s1 = peg$parseescape(); + if (s1 !== peg$FAILED) { + if (input.charCodeAt(peg$currPos) === 91) { + s2 = peg$c4; + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e14); + } + } + if (s2 !== peg$FAILED) { + s1 = [s1, s2]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 }; + return s0; + } + function peg$parseend_display_math() { + var s0, s1, s2; + var key = peg$currPos * 52 + 24; + var cached = peg$resultsCache[key]; + if (cached) { + peg$currPos = cached.nextPos; + return cached.result; + } + s0 = peg$currPos; + s1 = peg$parseescape(); + if (s1 !== peg$FAILED) { + if (input.charCodeAt(peg$currPos) === 93) { + s2 = peg$c5; + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e15); + } + } + if (s2 !== peg$FAILED) { + s1 = [s1, s2]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 }; + return s0; + } + function peg$parsebegin_inline_math() { + var s0, s1, s2; + var key = peg$currPos * 52 + 25; + var cached = peg$resultsCache[key]; + if (cached) { + peg$currPos = cached.nextPos; + return cached.result; + } + s0 = peg$currPos; + s1 = peg$parseescape(); + if (s1 !== peg$FAILED) { + if (input.charCodeAt(peg$currPos) === 40) { + s2 = peg$c16; + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e36); + } + } + if (s2 !== peg$FAILED) { + s1 = [s1, s2]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 }; + return s0; + } + function peg$parseend_inline_math() { + var s0, s1, s2; + var key = peg$currPos * 52 + 26; + var cached = peg$resultsCache[key]; + if (cached) { + peg$currPos = cached.nextPos; + return cached.result; + } + s0 = peg$currPos; + s1 = peg$parseescape(); + if (s1 !== peg$FAILED) { + if (input.charCodeAt(peg$currPos) === 41) { + s2 = peg$c17; + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e37); + } + } + if (s2 !== peg$FAILED) { + s1 = [s1, s2]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 }; + return s0; + } + function peg$parsebegin_env() { + var s0, s1, s2; + var key = peg$currPos * 52 + 27; + var cached = peg$resultsCache[key]; + if (cached) { + peg$currPos = cached.nextPos; + return cached.result; + } + s0 = peg$currPos; + s1 = peg$parseescape(); + if (s1 !== peg$FAILED) { + if (input.substr(peg$currPos, 5) === peg$c18) { + s2 = peg$c18; + peg$currPos += 5; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e38); + } + } + if (s2 !== peg$FAILED) { + s1 = [s1, s2]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 }; + return s0; + } + function peg$parseend_env() { + var s0, s1, s2; + var key = peg$currPos * 52 + 28; + var cached = peg$resultsCache[key]; + if (cached) { + peg$currPos = cached.nextPos; + return cached.result; + } + s0 = peg$currPos; + s1 = peg$parseescape(); + if (s1 !== peg$FAILED) { + if (input.substr(peg$currPos, 3) === peg$c19) { + s2 = peg$c19; + peg$currPos += 3; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e39); + } + } + if (s2 !== peg$FAILED) { + s1 = [s1, s2]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 }; + return s0; + } + function peg$parsemath_env_name() { + var s0, s1; + var key = peg$currPos * 52 + 29; + var cached = peg$resultsCache[key]; + if (cached) { + peg$currPos = cached.nextPos; + return cached.result; + } + s0 = peg$currPos; + if (input.substr(peg$currPos, 9) === peg$c20) { + s1 = peg$c20; + peg$currPos += 9; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e40); + } + } + if (s1 === peg$FAILED) { + if (input.substr(peg$currPos, 8) === peg$c21) { + s1 = peg$c21; + peg$currPos += 8; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e41); + } + } + if (s1 === peg$FAILED) { + if (input.substr(peg$currPos, 6) === peg$c22) { + s1 = peg$c22; + peg$currPos += 6; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e42); + } + } + if (s1 === peg$FAILED) { + if (input.substr(peg$currPos, 5) === peg$c23) { + s1 = peg$c23; + peg$currPos += 5; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e43); + } + } + if (s1 === peg$FAILED) { + if (input.substr(peg$currPos, 8) === peg$c24) { + s1 = peg$c24; + peg$currPos += 8; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e44); + } + } + if (s1 === peg$FAILED) { + if (input.substr(peg$currPos, 7) === peg$c25) { + s1 = peg$c25; + peg$currPos += 7; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e45); + } + } + if (s1 === peg$FAILED) { + if (input.substr(peg$currPos, 7) === peg$c26) { + s1 = peg$c26; + peg$currPos += 7; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e46); + } + } + if (s1 === peg$FAILED) { + if (input.substr(peg$currPos, 6) === peg$c27) { + s1 = peg$c27; + peg$currPos += 6; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e47); + } + } + if (s1 === peg$FAILED) { + if (input.substr(peg$currPos, 9) === peg$c28) { + s1 = peg$c28; + peg$currPos += 9; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e48); + } + } + if (s1 === peg$FAILED) { + if (input.substr(peg$currPos, 8) === peg$c29) { + s1 = peg$c29; + peg$currPos += 8; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e49); + } + } + if (s1 === peg$FAILED) { + if (input.substr(peg$currPos, 8) === peg$c30) { + s1 = peg$c30; + peg$currPos += 8; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e50); + } + } + if (s1 === peg$FAILED) { + if (input.substr(peg$currPos, 7) === peg$c31) { + s1 = peg$c31; + peg$currPos += 7; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e51); + } + } + if (s1 === peg$FAILED) { + if (input.substr(peg$currPos, 5) === peg$c32) { + s1 = peg$c32; + peg$currPos += 5; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e52); + } + } + if (s1 === peg$FAILED) { + if (input.substr(peg$currPos, 4) === peg$c33) { + s1 = peg$c33; + peg$currPos += 4; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e53); + } + } + if (s1 === peg$FAILED) { + if (input.substr(peg$currPos, 11) === peg$c34) { + s1 = peg$c34; + peg$currPos += 11; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e54); + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + if (s1 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$f56(s1); + } + s0 = s1; + peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 }; + return s0; + } + function peg$parseescape() { + var s0, s1; + var key = peg$currPos * 52 + 30; + var cached = peg$resultsCache[key]; + if (cached) { + peg$currPos = cached.nextPos; + return cached.result; + } + peg$silentFails++; + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 92) { + s1 = peg$c35; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e56); + } + } + if (s1 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$f57(); + } + s0 = s1; + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e55); + } + } + peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 }; + return s0; + } + function peg$parsebegin_group() { + var s0, s1; + var key = peg$currPos * 52 + 31; + var cached = peg$resultsCache[key]; + if (cached) { + peg$currPos = cached.nextPos; + return cached.result; + } + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 123) { + s1 = peg$c36; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e57); + } + } + if (s1 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$f58(s1); + } + s0 = s1; + peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 }; + return s0; + } + function peg$parseend_group() { + var s0, s1; + var key = peg$currPos * 52 + 32; + var cached = peg$resultsCache[key]; + if (cached) { + peg$currPos = cached.nextPos; + return cached.result; + } + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 125) { + s1 = peg$c37; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e58); + } + } + if (s1 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$f59(s1); + } + s0 = s1; + peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 }; + return s0; + } + function peg$parsemath_shift() { + var s0, s1; + var key = peg$currPos * 52 + 33; + var cached = peg$resultsCache[key]; + if (cached) { + peg$currPos = cached.nextPos; + return cached.result; + } + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 36) { + s1 = peg$c38; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e59); + } + } + if (s1 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$f60(s1); + } + s0 = s1; + peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 }; + return s0; + } + function peg$parsealignment_tab() { + var s0, s1; + var key = peg$currPos * 52 + 34; + var cached = peg$resultsCache[key]; + if (cached) { + peg$currPos = cached.nextPos; + return cached.result; + } + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 38) { + s1 = peg$c39; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e60); + } + } + if (s1 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$f61(s1); + } + s0 = s1; + peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 }; + return s0; + } + function peg$parsenl() { + var s0, s1, s2; + var key = peg$currPos * 52 + 35; + var cached = peg$resultsCache[key]; + if (cached) { + peg$currPos = cached.nextPos; + return cached.result; + } + peg$silentFails++; + s0 = peg$currPos; + s1 = peg$currPos; + peg$silentFails++; + if (input.charCodeAt(peg$currPos) === 13) { + s2 = peg$c40; + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e62); + } + } + peg$silentFails--; + if (s2 === peg$FAILED) { + s1 = void 0; + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + if (s1 !== peg$FAILED) { + if (input.charCodeAt(peg$currPos) === 10) { + s2 = peg$c41; + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e63); + } + } + if (s2 !== peg$FAILED) { + s1 = [s1, s2]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + if (input.charCodeAt(peg$currPos) === 13) { + s0 = peg$c40; + peg$currPos++; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e62); + } + } + if (s0 === peg$FAILED) { + if (input.substr(peg$currPos, 2) === peg$c42) { + s0 = peg$c42; + peg$currPos += 2; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e64); + } + } + } + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e61); + } + } + peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 }; + return s0; + } + function peg$parsemacro_parameter() { + var s0, s1; + var key = peg$currPos * 52 + 36; + var cached = peg$resultsCache[key]; + if (cached) { + peg$currPos = cached.nextPos; + return cached.result; + } + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 35) { + s1 = peg$c43; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e65); + } + } + if (s1 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$f62(s1); + } + s0 = s1; + peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 }; + return s0; + } + function peg$parsesuperscript() { + var s0, s1; + var key = peg$currPos * 52 + 37; + var cached = peg$resultsCache[key]; + if (cached) { + peg$currPos = cached.nextPos; + return cached.result; + } + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 94) { + s1 = peg$c44; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e66); + } + } + if (s1 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$f63(s1); + } + s0 = s1; + peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 }; + return s0; + } + function peg$parsesubscript() { + var s0, s1; + var key = peg$currPos * 52 + 38; + var cached = peg$resultsCache[key]; + if (cached) { + peg$currPos = cached.nextPos; + return cached.result; + } + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 95) { + s1 = peg$c45; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e67); + } + } + if (s1 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$f64(s1); + } + s0 = s1; + peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 }; + return s0; + } + function peg$parseignore() { + var s0; + var key = peg$currPos * 52 + 39; + var cached = peg$resultsCache[key]; + if (cached) { + peg$currPos = cached.nextPos; + return cached.result; + } + if (input.charCodeAt(peg$currPos) === 0) { + s0 = peg$c46; + peg$currPos++; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e68); + } + } + peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 }; + return s0; + } + function peg$parsesp() { + var s0, s1, s2; + var key = peg$currPos * 52 + 40; + var cached = peg$resultsCache[key]; + if (cached) { + peg$currPos = cached.nextPos; + return cached.result; + } + peg$silentFails++; + s0 = peg$currPos; + s1 = []; + if (peg$r1.test(input.charAt(peg$currPos))) { + s2 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e69); + } + } + if (s2 !== peg$FAILED) { + while (s2 !== peg$FAILED) { + s1.push(s2); + if (peg$r1.test(input.charAt(peg$currPos))) { + s2 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e69); + } + } + } + } else { + s1 = peg$FAILED; + } + if (s1 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$f65(); + } + s0 = s1; + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e8); + } + } + peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 }; + return s0; + } + function peg$parsechar() { + var s0; + var key = peg$currPos * 52 + 41; + var cached = peg$resultsCache[key]; + if (cached) { + peg$currPos = cached.nextPos; + return cached.result; + } + peg$silentFails++; + if (peg$r2.test(input.charAt(peg$currPos))) { + s0 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e71); + } + } + peg$silentFails--; + if (s0 === peg$FAILED) { + if (peg$silentFails === 0) { + peg$fail(peg$e70); + } + } + peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 }; + return s0; + } + function peg$parsenum() { + var s0; + var key = peg$currPos * 52 + 42; + var cached = peg$resultsCache[key]; + if (cached) { + peg$currPos = cached.nextPos; + return cached.result; + } + peg$silentFails++; + if (peg$r3.test(input.charAt(peg$currPos))) { + s0 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e73); + } + } + peg$silentFails--; + if (s0 === peg$FAILED) { + if (peg$silentFails === 0) { + peg$fail(peg$e72); + } + } + peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 }; + return s0; + } + function peg$parsepunctuation() { + var s0, s1; + var key = peg$currPos * 52 + 43; + var cached = peg$resultsCache[key]; + if (cached) { + peg$currPos = cached.nextPos; + return cached.result; + } + peg$silentFails++; + s0 = peg$currPos; + if (peg$r4.test(input.charAt(peg$currPos))) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e75); + } + } + if (s1 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$f66(s1); + } + s0 = s1; + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e74); + } + } + peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 }; + return s0; + } + function peg$parsecomment_start() { + var s0; + var key = peg$currPos * 52 + 44; + var cached = peg$resultsCache[key]; + if (cached) { + peg$currPos = cached.nextPos; + return cached.result; + } + if (input.charCodeAt(peg$currPos) === 37) { + s0 = peg$c0; + peg$currPos++; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e7); + } + } + peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 }; + return s0; + } + function peg$parsefull_comment() { + var s0; + var key = peg$currPos * 52 + 45; + var cached = peg$resultsCache[key]; + if (cached) { + peg$currPos = cached.nextPos; + return cached.result; + } + peg$silentFails++; + s0 = peg$parseownline_comment(); + if (s0 === peg$FAILED) { + s0 = peg$parsesameline_comment(); + } + peg$silentFails--; + if (s0 === peg$FAILED) { + if (peg$silentFails === 0) { + peg$fail(peg$e76); + } + } + peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 }; + return s0; + } + function peg$parseownline_comment() { + var s0, s1, s2, s3; + var key = peg$currPos * 52 + 46; + var cached = peg$resultsCache[key]; + if (cached) { + peg$currPos = cached.nextPos; + return cached.result; + } + s0 = peg$currPos; + s1 = peg$currPos; + s2 = []; + s3 = peg$parsesp(); + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$parsesp(); + } + s3 = peg$parsenl(); + if (s3 !== peg$FAILED) { + s2 = [s2, s3]; + s1 = s2; + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + if (s1 === peg$FAILED) { + s1 = null; + } + s2 = peg$parseleading_sp(); + if (s2 !== peg$FAILED) { + s3 = peg$parsecomment(); + if (s3 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f67(s2, s3); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 }; + return s0; + } + function peg$parsesameline_comment() { + var s0, s1, s2; + var key = peg$currPos * 52 + 47; + var cached = peg$resultsCache[key]; + if (cached) { + peg$currPos = cached.nextPos; + return cached.result; + } + s0 = peg$currPos; + s1 = []; + s2 = peg$parsesp(); + while (s2 !== peg$FAILED) { + s1.push(s2); + s2 = peg$parsesp(); + } + s2 = peg$parsecomment(); + if (s2 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f68(s1, s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 }; + return s0; + } + function peg$parsecomment() { + var s0, s1, s2, s3, s4, s5, s6, s7; + var key = peg$currPos * 52 + 48; + var cached = peg$resultsCache[key]; + if (cached) { + peg$currPos = cached.nextPos; + return cached.result; + } + peg$silentFails++; + s0 = peg$currPos; + s1 = peg$parsecomment_start(); + if (s1 !== peg$FAILED) { + s2 = []; + s3 = peg$currPos; + s4 = peg$currPos; + peg$silentFails++; + s5 = peg$parsenl(); + peg$silentFails--; + if (s5 === peg$FAILED) { + s4 = void 0; + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + if (s4 !== peg$FAILED) { + if (input.length > peg$currPos) { + s5 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s5 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s5 !== peg$FAILED) { + peg$savedPos = s3; + s3 = peg$f69(s5); + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$currPos; + s4 = peg$currPos; + peg$silentFails++; + s5 = peg$parsenl(); + peg$silentFails--; + if (s5 === peg$FAILED) { + s4 = void 0; + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + if (s4 !== peg$FAILED) { + if (input.length > peg$currPos) { + s5 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s5 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s5 !== peg$FAILED) { + peg$savedPos = s3; + s3 = peg$f69(s5); + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } + s3 = peg$currPos; + peg$silentFails++; + s4 = peg$parseparbreak(); + peg$silentFails--; + if (s4 !== peg$FAILED) { + peg$currPos = s3; + s3 = void 0; + } else { + s3 = peg$FAILED; + } + if (s3 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f70(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$parsecomment_start(); + if (s1 !== peg$FAILED) { + s2 = []; + s3 = peg$currPos; + s4 = peg$currPos; + peg$silentFails++; + s5 = peg$parsenl(); + peg$silentFails--; + if (s5 === peg$FAILED) { + s4 = void 0; + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + if (s4 !== peg$FAILED) { + if (input.length > peg$currPos) { + s5 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s5 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s5 !== peg$FAILED) { + peg$savedPos = s3; + s3 = peg$f71(s5); + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$currPos; + s4 = peg$currPos; + peg$silentFails++; + s5 = peg$parsenl(); + peg$silentFails--; + if (s5 === peg$FAILED) { + s4 = void 0; + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + if (s4 !== peg$FAILED) { + if (input.length > peg$currPos) { + s5 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s5 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s5 !== peg$FAILED) { + peg$savedPos = s3; + s3 = peg$f71(s5); + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } + s3 = peg$currPos; + s4 = peg$parsenl(); + if (s4 !== peg$FAILED) { + s5 = []; + s6 = peg$parsesp(); + while (s6 !== peg$FAILED) { + s5.push(s6); + s6 = peg$parsesp(); + } + s6 = peg$currPos; + peg$silentFails++; + s7 = peg$parsecomment_start(); + peg$silentFails--; + if (s7 === peg$FAILED) { + s6 = void 0; + } else { + peg$currPos = s6; + s6 = peg$FAILED; + } + if (s6 !== peg$FAILED) { + s4 = [s4, s5, s6]; + s3 = s4; + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + if (s3 === peg$FAILED) { + s3 = peg$parsenl(); + if (s3 === peg$FAILED) { + s3 = peg$parseEOF(); + } + } + if (s3 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f72(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e77); + } + } + peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 }; + return s0; + } + function peg$parseleading_sp() { + var s0, s1, s2, s3, s4; + var key = peg$currPos * 52 + 49; + var cached = peg$resultsCache[key]; + if (cached) { + peg$currPos = cached.nextPos; + return cached.result; + } + s0 = peg$currPos; + s1 = peg$currPos; + s2 = peg$parsestart_of_line(); + if (s2 !== peg$FAILED) { + s3 = []; + s4 = peg$parsesp(); + while (s4 !== peg$FAILED) { + s3.push(s4); + s4 = peg$parsesp(); + } + s2 = [s2, s3]; + s1 = s2; + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + if (s1 !== peg$FAILED) { + s0 = input.substring(s0, peg$currPos); + } else { + s0 = s1; + } + peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 }; + return s0; + } + function peg$parsestart_of_line() { + var s0; + var key = peg$currPos * 52 + 50; + var cached = peg$resultsCache[key]; + if (cached) { + peg$currPos = cached.nextPos; + return cached.result; + } + peg$savedPos = peg$currPos; + s0 = peg$f73(); + if (s0) { + s0 = void 0; + } else { + s0 = peg$FAILED; + } + peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 }; + return s0; + } + function peg$parseEOF() { + var s0, s1; + var key = peg$currPos * 52 + 51; + var cached = peg$resultsCache[key]; + if (cached) { + peg$currPos = cached.nextPos; + return cached.result; + } + s0 = peg$currPos; + peg$silentFails++; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + peg$silentFails--; + if (s1 === peg$FAILED) { + s0 = void 0; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 }; + return s0; + } + function toString(e) { + if (typeof e === "string") { + return e; + } + if (typeof e.content === "string") { + return e.content; + } + if (e && e.type === "whitespace") { + return " "; + } + return e; + } + function compare_env(g1, g2) { + const g1Name = typeof g1 === "string" ? g1 : g1.content.map(toString).join(""); + const g2Name = typeof g2 === "string" ? g2 : g2.content.map(toString).join(""); + return g1Name === g2Name; + } + function createNode(type, extra = {}) { + return { type, ...extra, position: location() }; + } + peg$result = peg$startRuleFunction(); + if (peg$result !== peg$FAILED && peg$currPos === input.length) { + return peg$result; + } else { + if (peg$result !== peg$FAILED && peg$currPos < input.length) { + peg$fail(peg$endExpectation()); + } + throw peg$buildStructuredError( + peg$maxFailExpected, + peg$maxFailPos < input.length ? input.charAt(peg$maxFailPos) : null, + peg$maxFailPos < input.length ? peg$computeLocation(peg$maxFailPos, peg$maxFailPos + 1) : peg$computeLocation(peg$maxFailPos, peg$maxFailPos) + ); + } + } + return { + SyntaxError: peg$SyntaxError, + parse: peg$parse + }; + }() +); +const _AlignEnvironmentPegParser = ( + // Generated by Peggy 3.0.2. + // + // https://peggyjs.org/ + function() { + function peg$subclass(child, parent) { + function C() { + this.constructor = child; + } + C.prototype = parent.prototype; + child.prototype = new C(); + } + function peg$SyntaxError(message, expected, found, location) { + var self = Error.call(this, message); + if (Object.setPrototypeOf) { + Object.setPrototypeOf(self, peg$SyntaxError.prototype); + } + self.expected = expected; + self.found = found; + self.location = location; + self.name = "SyntaxError"; + return self; + } + peg$subclass(peg$SyntaxError, Error); + function peg$padEnd(str, targetLength, padString) { + padString = padString || " "; + if (str.length > targetLength) { + return str; + } + targetLength -= str.length; + padString += padString.repeat(targetLength); + return str + padString.slice(0, targetLength); + } + peg$SyntaxError.prototype.format = function(sources) { + var str = "Error: " + this.message; + if (this.location) { + var src = null; + var k; + for (k = 0; k < sources.length; k++) { + if (sources[k].source === this.location.source) { + src = sources[k].text.split(/\r\n|\n|\r/g); + break; + } + } + var s = this.location.start; + var offset_s = this.location.source && typeof this.location.source.offset === "function" ? this.location.source.offset(s) : s; + var loc = this.location.source + ":" + offset_s.line + ":" + offset_s.column; + if (src) { + var e = this.location.end; + var filler = peg$padEnd("", offset_s.line.toString().length, " "); + var line = src[s.line - 1]; + var last = s.line === e.line ? e.column : line.length + 1; + var hatLen = last - s.column || 1; + str += "\n --> " + loc + "\n" + filler + " |\n" + offset_s.line + " | " + line + "\n" + filler + " | " + peg$padEnd("", s.column - 1, " ") + peg$padEnd("", hatLen, "^"); + } else { + str += "\n at " + loc; + } + } + return str; + }; + peg$SyntaxError.buildMessage = function(expected, found) { + var DESCRIBE_EXPECTATION_FNS = { + literal: function(expectation) { + return '"' + literalEscape(expectation.text) + '"'; + }, + class: function(expectation) { + var escapedParts = expectation.parts.map(function(part) { + return Array.isArray(part) ? classEscape(part[0]) + "-" + classEscape(part[1]) : classEscape(part); + }); + return "[" + (expectation.inverted ? "^" : "") + escapedParts.join("") + "]"; + }, + any: function() { + return "any character"; + }, + end: function() { + return "end of input"; + }, + other: function(expectation) { + return expectation.description; + } + }; + function hex(ch) { + return ch.charCodeAt(0).toString(16).toUpperCase(); + } + function literalEscape(s) { + return s.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\0/g, "\\0").replace(/\t/g, "\\t").replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/[\x00-\x0F]/g, function(ch) { + return "\\x0" + hex(ch); + }).replace(/[\x10-\x1F\x7F-\x9F]/g, function(ch) { + return "\\x" + hex(ch); + }); + } + function classEscape(s) { + return s.replace(/\\/g, "\\\\").replace(/\]/g, "\\]").replace(/\^/g, "\\^").replace(/-/g, "\\-").replace(/\0/g, "\\0").replace(/\t/g, "\\t").replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/[\x00-\x0F]/g, function(ch) { + return "\\x0" + hex(ch); + }).replace(/[\x10-\x1F\x7F-\x9F]/g, function(ch) { + return "\\x" + hex(ch); + }); + } + function describeExpectation(expectation) { + return DESCRIBE_EXPECTATION_FNS[expectation.type](expectation); + } + function describeExpected(expected2) { + var descriptions = expected2.map(describeExpectation); + var i, j; + descriptions.sort(); + if (descriptions.length > 0) { + for (i = 1, j = 1; i < descriptions.length; i++) { + if (descriptions[i - 1] !== descriptions[i]) { + descriptions[j] = descriptions[i]; + j++; + } + } + descriptions.length = j; + } + switch (descriptions.length) { + case 1: + return descriptions[0]; + case 2: + return descriptions[0] + " or " + descriptions[1]; + default: + return descriptions.slice(0, -1).join(", ") + ", or " + descriptions[descriptions.length - 1]; + } + } + function describeFound(found2) { + return found2 ? '"' + literalEscape(found2) + '"' : "end of input"; + } + return "Expected " + describeExpected(expected) + " but " + describeFound(found) + " found."; + }; + function peg$parse(input, options) { + options = options !== void 0 ? options : {}; + var peg$FAILED = {}; + var peg$source = options.grammarSource; + var peg$startRuleFunctions = { body: peg$parsebody }; + var peg$startRuleFunction = peg$parsebody; + var peg$e0 = peg$anyExpectation(); + var peg$f0 = function() { + return []; + }; + var peg$f1 = function(x) { + return { cells: [], colSeps: [], ...x }; + }; + var peg$f2 = function(rowItems, rowSep, trailingComment) { + return { ...rowItems, rowSep, trailingComment }; + }; + var peg$f3 = function(rowItems, trailingComment) { + return { ...rowItems, rowSep: null, trailingComment }; + }; + var peg$f4 = function(x) { + return x; + }; + var peg$f5 = function(x) { + return { + cells: [], + colSeps: [], + rowSep: null, + trailingComment: x + }; + }; + var peg$f6 = function(x) { + return x; + }; + var peg$f7 = function(colSep, cell) { + return { colSep, cell }; + }; + var peg$f8 = function(colSep) { + return { colSep }; + }; + var peg$f9 = function(a, b) { + return processRow(a, b); + }; + var peg$f10 = function(b) { + return processRow(null, b); + }; + var peg$f11 = function(tok) { + return options.isSameLineComment(tok); + }; + var peg$f12 = function(tok) { + return tok; + }; + var peg$f13 = function(tok) { + return options.isOwnLineComment(tok); + }; + var peg$f14 = function(tok) { + return tok; + }; + var peg$f15 = function(tok) { + return options.isWhitespace(tok); + }; + var peg$f16 = function(tok) { + return tok; + }; + var peg$f17 = function(tok) { + return options.isRowSep(tok); + }; + var peg$f18 = function(tok) { + return tok; + }; + var peg$f19 = function(tok) { + return options.isColSep(tok); + }; + var peg$f20 = function(tok) { + return tok; + }; + var peg$currPos = 0; + var peg$posDetailsCache = [{ line: 1, column: 1 }]; + var peg$maxFailPos = 0; + var peg$maxFailExpected = []; + var peg$silentFails = 0; + var peg$result; + if ("startRule" in options) { + if (!(options.startRule in peg$startRuleFunctions)) { + throw new Error(`Can't start parsing from rule "` + options.startRule + '".'); + } + peg$startRuleFunction = peg$startRuleFunctions[options.startRule]; + } + function peg$anyExpectation() { + return { type: "any" }; + } + function peg$endExpectation() { + return { type: "end" }; + } + function peg$computePosDetails(pos) { + var details = peg$posDetailsCache[pos]; + var p; + if (details) { + return details; + } else { + p = pos - 1; + while (!peg$posDetailsCache[p]) { + p--; + } + details = peg$posDetailsCache[p]; + details = { + line: details.line, + column: details.column + }; + while (p < pos) { + if (input.charCodeAt(p) === 10) { + details.line++; + details.column = 1; + } else { + details.column++; + } + p++; + } + peg$posDetailsCache[pos] = details; + return details; + } + } + function peg$computeLocation(startPos, endPos, offset2) { + var startPosDetails = peg$computePosDetails(startPos); + var endPosDetails = peg$computePosDetails(endPos); + var res = { + source: peg$source, + start: { + offset: startPos, + line: startPosDetails.line, + column: startPosDetails.column + }, + end: { + offset: endPos, + line: endPosDetails.line, + column: endPosDetails.column + } + }; + return res; + } + function peg$fail(expected2) { + if (peg$currPos < peg$maxFailPos) { + return; + } + if (peg$currPos > peg$maxFailPos) { + peg$maxFailPos = peg$currPos; + peg$maxFailExpected = []; + } + peg$maxFailExpected.push(expected2); + } + function peg$buildStructuredError(expected2, found, location2) { + return new peg$SyntaxError( + peg$SyntaxError.buildMessage(expected2, found), + expected2, + found, + location2 + ); + } + function peg$parsebody() { + var s0, s1; + s0 = []; + s1 = peg$parsecomment_only_line(); + if (s1 === peg$FAILED) { + s1 = peg$parserow_with_end(); + if (s1 === peg$FAILED) { + s1 = peg$parserow_without_end(); + } + } + if (s1 !== peg$FAILED) { + while (s1 !== peg$FAILED) { + s0.push(s1); + s1 = peg$parsecomment_only_line(); + if (s1 === peg$FAILED) { + s1 = peg$parserow_with_end(); + if (s1 === peg$FAILED) { + s1 = peg$parserow_without_end(); + } + } + } + } else { + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$parseEOL(); + if (s1 !== peg$FAILED) { + s1 = peg$f0(); + } + s0 = s1; + } + return s0; + } + function peg$parserow_with_end() { + var s0, s1, s2, s3; + s0 = peg$currPos; + s1 = peg$currPos; + s2 = peg$parserow_items(); + if (s2 === peg$FAILED) { + s2 = null; + } + s2 = peg$f1(s2); + s1 = s2; + s2 = peg$parserow_sep(); + if (s2 !== peg$FAILED) { + s3 = peg$parsetrailing_comment(); + if (s3 === peg$FAILED) { + s3 = null; + } + s0 = peg$f2(s1, s2, s3); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parserow_without_end() { + var s0, s1, s2; + s0 = peg$currPos; + s1 = peg$parserow_items(); + if (s1 !== peg$FAILED) { + s2 = peg$parsetrailing_comment(); + if (s2 === peg$FAILED) { + s2 = null; + } + s0 = peg$f3(s1, s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsetrailing_comment() { + var s0, s1, s2; + s0 = peg$currPos; + s1 = []; + s2 = peg$parsewhitespace(); + while (s2 !== peg$FAILED) { + s1.push(s2); + s2 = peg$parsewhitespace(); + } + s2 = peg$parsesame_line_comment(); + if (s2 !== peg$FAILED) { + s0 = peg$f4(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsecomment_only_line() { + var s0, s1, s2; + s0 = peg$currPos; + s1 = []; + s2 = peg$parsewhitespace(); + while (s2 !== peg$FAILED) { + s1.push(s2); + s2 = peg$parsewhitespace(); + } + s2 = peg$parseown_line_comment(); + if (s2 !== peg$FAILED) { + s0 = peg$f5(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsetoken() { + var s0, s1, s2; + s0 = peg$currPos; + s1 = peg$currPos; + peg$silentFails++; + s2 = peg$parserow_sep(); + if (s2 === peg$FAILED) { + s2 = peg$parsecol_sep(); + if (s2 === peg$FAILED) { + s2 = peg$parsetrailing_comment(); + if (s2 === peg$FAILED) { + s2 = peg$parseown_line_comment(); + } + } + } + peg$silentFails--; + if (s2 === peg$FAILED) { + s1 = void 0; + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + if (s1 !== peg$FAILED) { + if (input.length > peg$currPos) { + s2 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s2 !== peg$FAILED) { + s0 = peg$f6(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsecell() { + var s0, s1, s2; + s0 = peg$currPos; + s1 = []; + s2 = peg$parsetoken(); + if (s2 !== peg$FAILED) { + while (s2 !== peg$FAILED) { + s1.push(s2); + s2 = peg$parsetoken(); + } + } else { + s1 = peg$FAILED; + } + if (s1 !== peg$FAILED) { + s0 = input.substring(s0, peg$currPos); + } else { + s0 = s1; + } + return s0; + } + function peg$parseseparated_cell() { + var s0, s1, s2; + s0 = peg$currPos; + s1 = peg$parsecol_sep(); + if (s1 !== peg$FAILED) { + s2 = peg$parsecell(); + if (s2 !== peg$FAILED) { + s0 = peg$f7(s1, s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$parsecol_sep(); + if (s1 !== peg$FAILED) { + s1 = peg$f8(s1); + } + s0 = s1; + } + return s0; + } + function peg$parserow_items() { + var s0, s1, s2, s3; + s0 = peg$currPos; + s1 = peg$parsecell(); + if (s1 !== peg$FAILED) { + s2 = []; + s3 = peg$parseseparated_cell(); + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$parseseparated_cell(); + } + s0 = peg$f9(s1, s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = []; + s2 = peg$parseseparated_cell(); + if (s2 !== peg$FAILED) { + while (s2 !== peg$FAILED) { + s1.push(s2); + s2 = peg$parseseparated_cell(); + } + } else { + s1 = peg$FAILED; + } + if (s1 !== peg$FAILED) { + s1 = peg$f10(s1); + } + s0 = s1; + } + return s0; + } + function peg$parsesame_line_comment() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f11(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s0 = peg$f12(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parseown_line_comment() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f13(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s0 = peg$f14(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsewhitespace() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f15(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s0 = peg$f16(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parserow_sep() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f17(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s0 = peg$f18(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsecol_sep() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f19(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s0 = peg$f20(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parseEOL() { + var s0, s1; + s0 = peg$currPos; + peg$silentFails++; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + peg$silentFails--; + if (s1 === peg$FAILED) { + s0 = void 0; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function processRow(leadCell, otherCells) { + const cells = [leadCell || []]; + const seps = []; + for (const x of otherCells) { + cells.push(x.cell || []); + seps.push(x.colSep); + } + return { cells, colSeps: seps }; + } + if (!options.isWhitespace) { + try { + Object.assign( + options, + createMatchers(["\\", "hline", "cr"], ["&"]) + ); + } catch (e) { + console.warn("Error when initializing parser", e); + } + } + peg$result = peg$startRuleFunction(); + if (peg$result !== peg$FAILED && peg$currPos === input.length) { + return peg$result; + } else { + if (peg$result !== peg$FAILED && peg$currPos < input.length) { + peg$fail(peg$endExpectation()); + } + throw peg$buildStructuredError( + peg$maxFailExpected, + peg$maxFailPos < input.length ? input.charAt(peg$maxFailPos) : null, + peg$maxFailPos < input.length ? peg$computeLocation(peg$maxFailPos, peg$maxFailPos + 1) : peg$computeLocation(peg$maxFailPos, peg$maxFailPos) + ); + } + } + return { + SyntaxError: peg$SyntaxError, + parse: peg$parse + }; + }() +); +const _ArgSpecPegParser = ( + // Generated by Peggy 3.0.2. + // + // https://peggyjs.org/ + function() { + function peg$subclass(child, parent) { + function C() { + this.constructor = child; + } + C.prototype = parent.prototype; + child.prototype = new C(); + } + function peg$SyntaxError(message, expected, found, location) { + var self = Error.call(this, message); + if (Object.setPrototypeOf) { + Object.setPrototypeOf(self, peg$SyntaxError.prototype); + } + self.expected = expected; + self.found = found; + self.location = location; + self.name = "SyntaxError"; + return self; + } + peg$subclass(peg$SyntaxError, Error); + function peg$padEnd(str, targetLength, padString) { + padString = padString || " "; + if (str.length > targetLength) { + return str; + } + targetLength -= str.length; + padString += padString.repeat(targetLength); + return str + padString.slice(0, targetLength); + } + peg$SyntaxError.prototype.format = function(sources) { + var str = "Error: " + this.message; + if (this.location) { + var src = null; + var k; + for (k = 0; k < sources.length; k++) { + if (sources[k].source === this.location.source) { + src = sources[k].text.split(/\r\n|\n|\r/g); + break; + } + } + var s = this.location.start; + var offset_s = this.location.source && typeof this.location.source.offset === "function" ? this.location.source.offset(s) : s; + var loc = this.location.source + ":" + offset_s.line + ":" + offset_s.column; + if (src) { + var e = this.location.end; + var filler = peg$padEnd("", offset_s.line.toString().length, " "); + var line = src[s.line - 1]; + var last = s.line === e.line ? e.column : line.length + 1; + var hatLen = last - s.column || 1; + str += "\n --> " + loc + "\n" + filler + " |\n" + offset_s.line + " | " + line + "\n" + filler + " | " + peg$padEnd("", s.column - 1, " ") + peg$padEnd("", hatLen, "^"); + } else { + str += "\n at " + loc; + } + } + return str; + }; + peg$SyntaxError.buildMessage = function(expected, found) { + var DESCRIBE_EXPECTATION_FNS = { + literal: function(expectation) { + return '"' + literalEscape(expectation.text) + '"'; + }, + class: function(expectation) { + var escapedParts = expectation.parts.map(function(part) { + return Array.isArray(part) ? classEscape(part[0]) + "-" + classEscape(part[1]) : classEscape(part); + }); + return "[" + (expectation.inverted ? "^" : "") + escapedParts.join("") + "]"; + }, + any: function() { + return "any character"; + }, + end: function() { + return "end of input"; + }, + other: function(expectation) { + return expectation.description; + } + }; + function hex(ch) { + return ch.charCodeAt(0).toString(16).toUpperCase(); + } + function literalEscape(s) { + return s.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\0/g, "\\0").replace(/\t/g, "\\t").replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/[\x00-\x0F]/g, function(ch) { + return "\\x0" + hex(ch); + }).replace(/[\x10-\x1F\x7F-\x9F]/g, function(ch) { + return "\\x" + hex(ch); + }); + } + function classEscape(s) { + return s.replace(/\\/g, "\\\\").replace(/\]/g, "\\]").replace(/\^/g, "\\^").replace(/-/g, "\\-").replace(/\0/g, "\\0").replace(/\t/g, "\\t").replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/[\x00-\x0F]/g, function(ch) { + return "\\x0" + hex(ch); + }).replace(/[\x10-\x1F\x7F-\x9F]/g, function(ch) { + return "\\x" + hex(ch); + }); + } + function describeExpectation(expectation) { + return DESCRIBE_EXPECTATION_FNS[expectation.type](expectation); + } + function describeExpected(expected2) { + var descriptions = expected2.map(describeExpectation); + var i, j; + descriptions.sort(); + if (descriptions.length > 0) { + for (i = 1, j = 1; i < descriptions.length; i++) { + if (descriptions[i - 1] !== descriptions[i]) { + descriptions[j] = descriptions[i]; + j++; + } + } + descriptions.length = j; + } + switch (descriptions.length) { + case 1: + return descriptions[0]; + case 2: + return descriptions[0] + " or " + descriptions[1]; + default: + return descriptions.slice(0, -1).join(", ") + ", or " + descriptions[descriptions.length - 1]; + } + } + function describeFound(found2) { + return found2 ? '"' + literalEscape(found2) + '"' : "end of input"; + } + return "Expected " + describeExpected(expected) + " but " + describeFound(found) + " found."; + }; + function peg$parse(input, options) { + options = options !== void 0 ? options : {}; + var peg$FAILED = {}; + var peg$source = options.grammarSource; + var peg$startRuleFunctions = { args_spec_list: peg$parseargs_spec_list }; + var peg$startRuleFunction = peg$parseargs_spec_list; + var peg$c1 = "v"; + var peg$c2 = "b"; + var peg$c3 = "!"; + var peg$c4 = "D"; + var peg$c5 = "d"; + var peg$c6 = "s"; + var peg$c7 = "O"; + var peg$c8 = "o"; + var peg$c9 = "e"; + var peg$c10 = "E"; + var peg$c11 = "t"; + var peg$c12 = "R"; + var peg$c13 = "r"; + var peg$c14 = "u"; + var peg$c15 = "m"; + var peg$c16 = "{"; + var peg$c17 = "}"; + var peg$c18 = " "; + var peg$c19 = "\n"; + var peg$c20 = "\r"; + var peg$c21 = "\\"; + var peg$r0 = /^[{ ]/; + var peg$r1 = /^[a-zA-Z]/; + var peg$r2 = /^[{}]/; + var peg$e0 = peg$literalExpectation("+", false); + var peg$e1 = peg$literalExpectation("v", false); + var peg$e2 = peg$anyExpectation(); + var peg$e3 = peg$literalExpectation("b", false); + var peg$e4 = peg$literalExpectation("!", false); + var peg$e5 = peg$literalExpectation("D", false); + var peg$e6 = peg$literalExpectation("d", false); + var peg$e7 = peg$literalExpectation("s", false); + var peg$e8 = peg$literalExpectation("O", false); + var peg$e9 = peg$literalExpectation("o", false); + var peg$e10 = peg$literalExpectation("e", false); + var peg$e11 = peg$literalExpectation("E", false); + var peg$e12 = peg$literalExpectation("t", false); + var peg$e13 = peg$literalExpectation("R", false); + var peg$e14 = peg$literalExpectation("r", false); + var peg$e15 = peg$literalExpectation("u", false); + var peg$e16 = peg$classExpectation(["{", " "], false, false); + var peg$e17 = peg$literalExpectation("m", false); + var peg$e18 = peg$literalExpectation("{", false); + var peg$e19 = peg$literalExpectation("}", false); + var peg$e20 = peg$literalExpectation(" ", false); + var peg$e21 = peg$literalExpectation("\n", false); + var peg$e22 = peg$literalExpectation("\r", false); + var peg$e23 = peg$literalExpectation("\\", false); + var peg$e24 = peg$classExpectation([["a", "z"], ["A", "Z"]], false, false); + var peg$e25 = peg$classExpectation(["{", "}"], false, false); + var peg$f0 = function(x) { + return x; + }; + var peg$f1 = function(spec) { + return spec; + }; + var peg$f2 = function(spec) { + return spec; + }; + var peg$f3 = function(openBrace) { + return createNode("verbatim", { openBrace, closeBrace: openBrace }); + }; + var peg$f4 = function() { + return createNode("body"); + }; + var peg$f5 = function(leading_bang, spec) { + return leading_bang ? { ...spec, noLeadingWhitespace: true } : spec; + }; + var peg$f6 = function(braceSpec, defaultArg) { + return createNode("optional", { ...braceSpec, defaultArg }); + }; + var peg$f7 = function(braceSpec) { + return createNode("optional", braceSpec); + }; + var peg$f8 = function() { + return createNode("optionalStar"); + }; + var peg$f9 = function(g) { + return createNode("optional", { defaultArg: g }); + }; + var peg$f10 = function() { + return createNode("optional"); + }; + var peg$f11 = function(args) { + return createNode("embellishment", { + embellishmentTokens: args + }); + }; + var peg$f12 = function(args, g) { + return createNode("embellishment", { + embellishmentTokens: args, + defaultArg: g + }); + }; + var peg$f13 = function(tok) { + return createNode("optionalToken", { token: tok }); + }; + var peg$f14 = function(braceSpec, defaultArg) { + return createNode("mandatory", { ...braceSpec, defaultArg }); + }; + var peg$f15 = function(braceSpec) { + return createNode("mandatory", braceSpec); + }; + var peg$f16 = function(stopTokens) { + return createNode("until", { stopTokens }); + }; + var peg$f17 = function(x) { + return [x]; + }; + var peg$f18 = function(g) { + return g.content; + }; + var peg$f19 = function() { + return createNode("mandatory"); + }; + var peg$f20 = function(openBrace, closeBrace) { + return { openBrace, closeBrace }; + }; + var peg$f21 = function(g) { + return g.content.map(groupToStr).join(""); + }; + var peg$f22 = function(t) { + return [t]; + }; + var peg$f23 = function(args) { + return args.filter((a) => !a.match(/^\s*$/)); + }; + var peg$f24 = function(content) { + return { type: "group", content }; + }; + var peg$f25 = function() { + return ""; + }; + var peg$currPos = 0; + var peg$posDetailsCache = [{ line: 1, column: 1 }]; + var peg$maxFailPos = 0; + var peg$maxFailExpected = []; + var peg$silentFails = 0; + var peg$result; + if ("startRule" in options) { + if (!(options.startRule in peg$startRuleFunctions)) { + throw new Error(`Can't start parsing from rule "` + options.startRule + '".'); + } + peg$startRuleFunction = peg$startRuleFunctions[options.startRule]; + } + function peg$literalExpectation(text2, ignoreCase) { + return { type: "literal", text: text2, ignoreCase }; + } + function peg$classExpectation(parts, inverted, ignoreCase) { + return { type: "class", parts, inverted, ignoreCase }; + } + function peg$anyExpectation() { + return { type: "any" }; + } + function peg$endExpectation() { + return { type: "end" }; + } + function peg$computePosDetails(pos) { + var details = peg$posDetailsCache[pos]; + var p; + if (details) { + return details; + } else { + p = pos - 1; + while (!peg$posDetailsCache[p]) { + p--; + } + details = peg$posDetailsCache[p]; + details = { + line: details.line, + column: details.column + }; + while (p < pos) { + if (input.charCodeAt(p) === 10) { + details.line++; + details.column = 1; + } else { + details.column++; + } + p++; + } + peg$posDetailsCache[pos] = details; + return details; + } + } + function peg$computeLocation(startPos, endPos, offset2) { + var startPosDetails = peg$computePosDetails(startPos); + var endPosDetails = peg$computePosDetails(endPos); + var res = { + source: peg$source, + start: { + offset: startPos, + line: startPosDetails.line, + column: startPosDetails.column + }, + end: { + offset: endPos, + line: endPosDetails.line, + column: endPosDetails.column + } + }; + return res; + } + function peg$fail(expected2) { + if (peg$currPos < peg$maxFailPos) { + return; + } + if (peg$currPos > peg$maxFailPos) { + peg$maxFailPos = peg$currPos; + peg$maxFailExpected = []; + } + peg$maxFailExpected.push(expected2); + } + function peg$buildStructuredError(expected2, found, location2) { + return new peg$SyntaxError( + peg$SyntaxError.buildMessage(expected2, found), + expected2, + found, + location2 + ); + } + function peg$parseargs_spec_list() { + var s0, s1, s2, s4; + s0 = peg$currPos; + s1 = []; + s2 = peg$currPos; + peg$parsewhitespace(); + s4 = peg$parsearg_spec(); + if (s4 !== peg$FAILED) { + s2 = peg$f0(s4); + } else { + peg$currPos = s2; + s2 = peg$FAILED; + } + while (s2 !== peg$FAILED) { + s1.push(s2); + s2 = peg$currPos; + peg$parsewhitespace(); + s4 = peg$parsearg_spec(); + if (s4 !== peg$FAILED) { + s2 = peg$f0(s4); + } else { + peg$currPos = s2; + s2 = peg$FAILED; + } + } + s2 = peg$parsewhitespace(); + s0 = peg$f1(s1); + return s0; + } + function peg$parsearg_spec() { + var s0, s2; + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 43) { + peg$currPos++; + } else { + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + s2 = peg$parseoptional(); + if (s2 === peg$FAILED) { + s2 = peg$parsemandatory(); + if (s2 === peg$FAILED) { + s2 = peg$parseverbatim(); + if (s2 === peg$FAILED) { + s2 = peg$parserequired(); + if (s2 === peg$FAILED) { + s2 = peg$parsebody(); + if (s2 === peg$FAILED) { + s2 = peg$parseuntil(); + } + } + } + } + } + if (s2 !== peg$FAILED) { + s0 = peg$f2(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parseverbatim() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 118) { + s1 = peg$c1; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e1); + } + } + if (s1 !== peg$FAILED) { + if (input.length > peg$currPos) { + s2 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e2); + } + } + if (s2 !== peg$FAILED) { + s0 = peg$f3(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsebody() { + var s0, s1; + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 98) { + s1 = peg$c2; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s1 !== peg$FAILED) { + s1 = peg$f4(); + } + s0 = s1; + return s0; + } + function peg$parseoptional() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 33) { + s1 = peg$c3; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e4); + } + } + if (s1 === peg$FAILED) { + s1 = null; + } + s2 = peg$parseoptional_star(); + if (s2 === peg$FAILED) { + s2 = peg$parseoptional_standard(); + if (s2 === peg$FAILED) { + s2 = peg$parseoptional_delimited(); + if (s2 === peg$FAILED) { + s2 = peg$parseoptional_embellishment(); + if (s2 === peg$FAILED) { + s2 = peg$parseoptional_token(); + } + } + } + } + if (s2 !== peg$FAILED) { + s0 = peg$f5(s1, s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parseoptional_delimited() { + var s0, s1, s2, s3; + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 68) { + s1 = peg$c4; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e5); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$parsebrace_spec(); + s3 = peg$parsearg(); + if (s3 !== peg$FAILED) { + s0 = peg$f6(s2, s3); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 100) { + s1 = peg$c5; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e6); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$parsebrace_spec(); + s0 = peg$f7(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } + return s0; + } + function peg$parseoptional_star() { + var s0, s1; + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 115) { + s1 = peg$c6; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e7); + } + } + if (s1 !== peg$FAILED) { + s1 = peg$f8(); + } + s0 = s1; + return s0; + } + function peg$parseoptional_standard() { + var s0, s1, s3; + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 79) { + s1 = peg$c7; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e8); + } + } + if (s1 !== peg$FAILED) { + peg$parsewhitespace(); + s3 = peg$parsearg(); + if (s3 !== peg$FAILED) { + s0 = peg$f9(s3); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 111) { + s1 = peg$c8; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e9); + } + } + if (s1 !== peg$FAILED) { + s1 = peg$f10(); + } + s0 = s1; + } + return s0; + } + function peg$parseoptional_embellishment() { + var s0, s1, s3, s5; + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 101) { + s1 = peg$c9; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e10); + } + } + if (s1 !== peg$FAILED) { + peg$parsewhitespace(); + s3 = peg$parseargs(); + if (s3 !== peg$FAILED) { + s0 = peg$f11(s3); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 69) { + s1 = peg$c10; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e11); + } + } + if (s1 !== peg$FAILED) { + peg$parsewhitespace(); + s3 = peg$parseargs(); + if (s3 !== peg$FAILED) { + peg$parsewhitespace(); + s5 = peg$parseargs(); + if (s5 !== peg$FAILED) { + s0 = peg$f12(s3, s5); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } + return s0; + } + function peg$parseoptional_token() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 116) { + s1 = peg$c11; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e12); + } + } + if (s1 !== peg$FAILED) { + if (input.length > peg$currPos) { + s2 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e2); + } + } + if (s2 !== peg$FAILED) { + s0 = peg$f13(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parserequired() { + var s0, s1, s2, s3; + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 82) { + s1 = peg$c12; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e13); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$parsebrace_spec(); + s3 = peg$parsearg(); + if (s3 !== peg$FAILED) { + s0 = peg$f14(s2, s3); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 114) { + s1 = peg$c13; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e14); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$parsebrace_spec(); + s0 = peg$f15(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } + return s0; + } + function peg$parseuntil() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 117) { + s1 = peg$c14; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e15); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$parseuntil_stop_token(); + if (s2 !== peg$FAILED) { + s0 = peg$f16(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parseuntil_stop_token() { + var s0, s1, s2; + s0 = peg$currPos; + s1 = peg$currPos; + peg$silentFails++; + if (peg$r0.test(input.charAt(peg$currPos))) { + s2 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e16); + } + } + peg$silentFails--; + if (s2 === peg$FAILED) { + s1 = void 0; + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + if (s1 !== peg$FAILED) { + if (input.length > peg$currPos) { + s2 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e2); + } + } + if (s2 !== peg$FAILED) { + s0 = peg$f17(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$parsebraced_group(); + if (s1 !== peg$FAILED) { + s1 = peg$f18(s1); + } + s0 = s1; + } + return s0; + } + function peg$parsemandatory() { + var s0, s1; + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 109) { + s1 = peg$c15; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e17); + } + } + if (s1 !== peg$FAILED) { + s1 = peg$f19(); + } + s0 = s1; + return s0; + } + function peg$parsebrace_spec() { + var s0, s1, s2, s3, s4, s5; + s0 = peg$currPos; + s1 = peg$currPos; + s2 = peg$currPos; + s3 = peg$currPos; + peg$silentFails++; + s4 = peg$parsewhitespace_token(); + peg$silentFails--; + if (s4 === peg$FAILED) { + s3 = void 0; + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + if (s3 !== peg$FAILED) { + s4 = peg$parsemacro(); + if (s4 === peg$FAILED) { + if (input.length > peg$currPos) { + s4 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s4 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e2); + } + } + } + if (s4 !== peg$FAILED) { + s3 = [s3, s4]; + s2 = s3; + } else { + peg$currPos = s2; + s2 = peg$FAILED; + } + } else { + peg$currPos = s2; + s2 = peg$FAILED; + } + if (s2 === peg$FAILED) { + s2 = null; + } + s1 = input.substring(s1, peg$currPos); + s2 = peg$currPos; + s3 = peg$currPos; + s4 = peg$currPos; + peg$silentFails++; + s5 = peg$parsewhitespace_token(); + peg$silentFails--; + if (s5 === peg$FAILED) { + s4 = void 0; + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + if (s4 !== peg$FAILED) { + s5 = peg$parsemacro(); + if (s5 === peg$FAILED) { + if (input.length > peg$currPos) { + s5 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s5 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e2); + } + } + } + if (s5 !== peg$FAILED) { + s4 = [s4, s5]; + s3 = s4; + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + if (s3 === peg$FAILED) { + s3 = null; + } + s2 = input.substring(s2, peg$currPos); + s0 = peg$f20(s1, s2); + return s0; + } + function peg$parsearg() { + var s0, s1; + s0 = peg$parsetoken(); + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$parsebraced_group(); + if (s1 !== peg$FAILED) { + s1 = peg$f21(s1); + } + s0 = s1; + } + return s0; + } + function peg$parseargs() { + var s0, s1, s2, s3; + s0 = peg$currPos; + s1 = peg$parsetoken(); + if (s1 !== peg$FAILED) { + s1 = peg$f22(s1); + } + s0 = s1; + if (s0 === peg$FAILED) { + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 123) { + s1 = peg$c16; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e18); + } + } + if (s1 !== peg$FAILED) { + s2 = []; + s3 = peg$parsearg(); + if (s3 === peg$FAILED) { + s3 = peg$parsewhitespace_token(); + } + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$parsearg(); + if (s3 === peg$FAILED) { + s3 = peg$parsewhitespace_token(); + } + } + if (input.charCodeAt(peg$currPos) === 125) { + s3 = peg$c17; + peg$currPos++; + } else { + s3 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e19); + } + } + if (s3 !== peg$FAILED) { + s0 = peg$f23(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } + return s0; + } + function peg$parsebraced_group() { + var s0, s1, s2, s3, s4, s5, s6, s7; + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 123) { + s1 = peg$c16; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e18); + } + } + if (s1 !== peg$FAILED) { + s2 = []; + s3 = peg$currPos; + s4 = peg$currPos; + s5 = peg$currPos; + peg$silentFails++; + if (input.charCodeAt(peg$currPos) === 125) { + s6 = peg$c17; + peg$currPos++; + } else { + s6 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e19); + } + } + peg$silentFails--; + if (s6 === peg$FAILED) { + s5 = void 0; + } else { + peg$currPos = s5; + s5 = peg$FAILED; + } + if (s5 !== peg$FAILED) { + s6 = peg$currPos; + peg$silentFails++; + s7 = peg$parsebraced_group(); + peg$silentFails--; + if (s7 === peg$FAILED) { + s6 = void 0; + } else { + peg$currPos = s6; + s6 = peg$FAILED; + } + if (s6 !== peg$FAILED) { + s7 = peg$parsetoken(); + if (s7 === peg$FAILED) { + s7 = peg$parsewhitespace_token(); + } + if (s7 !== peg$FAILED) { + s5 = [s5, s6, s7]; + s4 = s5; + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + if (s4 !== peg$FAILED) { + s3 = input.substring(s3, peg$currPos); + } else { + s3 = s4; + } + if (s3 === peg$FAILED) { + s3 = peg$parsebraced_group(); + } + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$currPos; + s4 = peg$currPos; + s5 = peg$currPos; + peg$silentFails++; + if (input.charCodeAt(peg$currPos) === 125) { + s6 = peg$c17; + peg$currPos++; + } else { + s6 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e19); + } + } + peg$silentFails--; + if (s6 === peg$FAILED) { + s5 = void 0; + } else { + peg$currPos = s5; + s5 = peg$FAILED; + } + if (s5 !== peg$FAILED) { + s6 = peg$currPos; + peg$silentFails++; + s7 = peg$parsebraced_group(); + peg$silentFails--; + if (s7 === peg$FAILED) { + s6 = void 0; + } else { + peg$currPos = s6; + s6 = peg$FAILED; + } + if (s6 !== peg$FAILED) { + s7 = peg$parsetoken(); + if (s7 === peg$FAILED) { + s7 = peg$parsewhitespace_token(); + } + if (s7 !== peg$FAILED) { + s5 = [s5, s6, s7]; + s4 = s5; + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + if (s4 !== peg$FAILED) { + s3 = input.substring(s3, peg$currPos); + } else { + s3 = s4; + } + if (s3 === peg$FAILED) { + s3 = peg$parsebraced_group(); + } + } + if (input.charCodeAt(peg$currPos) === 125) { + s3 = peg$c17; + peg$currPos++; + } else { + s3 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e19); + } + } + if (s3 !== peg$FAILED) { + s0 = peg$f24(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsewhitespace() { + var s0, s1, s2; + s0 = peg$currPos; + s1 = []; + s2 = peg$parsewhitespace_token(); + while (s2 !== peg$FAILED) { + s1.push(s2); + s2 = peg$parsewhitespace_token(); + } + s1 = peg$f25(); + s0 = s1; + return s0; + } + function peg$parsewhitespace_token() { + var s0; + if (input.charCodeAt(peg$currPos) === 32) { + s0 = peg$c18; + peg$currPos++; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e20); + } + } + if (s0 === peg$FAILED) { + if (input.charCodeAt(peg$currPos) === 10) { + s0 = peg$c19; + peg$currPos++; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e21); + } + } + if (s0 === peg$FAILED) { + if (input.charCodeAt(peg$currPos) === 13) { + s0 = peg$c20; + peg$currPos++; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e22); + } + } + } + } + return s0; + } + function peg$parsemacro() { + var s0, s1, s2, s3, s4; + s0 = peg$currPos; + s1 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 92) { + s2 = peg$c21; + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e23); + } + } + if (s2 !== peg$FAILED) { + s3 = []; + if (peg$r1.test(input.charAt(peg$currPos))) { + s4 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s4 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e24); + } + } + if (s4 !== peg$FAILED) { + while (s4 !== peg$FAILED) { + s3.push(s4); + if (peg$r1.test(input.charAt(peg$currPos))) { + s4 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s4 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e24); + } + } + } + } else { + s3 = peg$FAILED; + } + if (s3 !== peg$FAILED) { + s2 = [s2, s3]; + s1 = s2; + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + if (s1 !== peg$FAILED) { + s0 = input.substring(s0, peg$currPos); + } else { + s0 = s1; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 92) { + s2 = peg$c21; + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e23); + } + } + if (s2 !== peg$FAILED) { + s3 = peg$currPos; + peg$silentFails++; + if (peg$r1.test(input.charAt(peg$currPos))) { + s4 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s4 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e24); + } + } + peg$silentFails--; + if (s4 === peg$FAILED) { + s3 = void 0; + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + if (s3 !== peg$FAILED) { + if (input.length > peg$currPos) { + s4 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s4 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e2); + } + } + if (s4 !== peg$FAILED) { + s2 = [s2, s3, s4]; + s1 = s2; + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + if (s1 !== peg$FAILED) { + s0 = input.substring(s0, peg$currPos); + } else { + s0 = s1; + } + } + return s0; + } + function peg$parsetoken() { + var s0, s1, s2, s3; + s0 = peg$parsemacro(); + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$currPos; + peg$silentFails++; + if (peg$r2.test(input.charAt(peg$currPos))) { + s2 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e25); + } + } + peg$silentFails--; + if (s2 === peg$FAILED) { + s1 = void 0; + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + if (s1 !== peg$FAILED) { + s2 = peg$currPos; + peg$silentFails++; + s3 = peg$parsewhitespace_token(); + peg$silentFails--; + if (s3 === peg$FAILED) { + s2 = void 0; + } else { + peg$currPos = s2; + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + if (input.length > peg$currPos) { + s3 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s3 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e2); + } + } + if (s3 !== peg$FAILED) { + s0 = s3; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } + return s0; + } + const DEFAULT_OPTIONS = { + optional: { openBrace: "[", closeBrace: "]" }, + mandatory: { openBrace: "{", closeBrace: "}" } + }; + function createNode(type, options2) { + const computedOptions = DEFAULT_OPTIONS[type] || {}; + return { type, ...computedOptions, ...options2 }; + } + function groupToStr(node) { + if (typeof node !== "object" || !node) { + return node; + } + if (node.type === "group") { + return `{${node.content.map(groupToStr).join("")}}`; + } + return node; + } + peg$result = peg$startRuleFunction(); + if (peg$result !== peg$FAILED && peg$currPos === input.length) { + return peg$result; + } else { + if (peg$result !== peg$FAILED && peg$currPos < input.length) { + peg$fail(peg$endExpectation()); + } + throw peg$buildStructuredError( + peg$maxFailExpected, + peg$maxFailPos < input.length ? input.charAt(peg$maxFailPos) : null, + peg$maxFailPos < input.length ? peg$computeLocation(peg$maxFailPos, peg$maxFailPos + 1) : peg$computeLocation(peg$maxFailPos, peg$maxFailPos) + ); + } + } + return { + SyntaxError: peg$SyntaxError, + parse: peg$parse + }; + }() +); +const _PgfkeysPegParser = ( + // Generated by Peggy 3.0.2. + // + // https://peggyjs.org/ + function() { + function peg$subclass(child, parent) { + function C() { + this.constructor = child; + } + C.prototype = parent.prototype; + child.prototype = new C(); + } + function peg$SyntaxError(message, expected, found, location) { + var self = Error.call(this, message); + if (Object.setPrototypeOf) { + Object.setPrototypeOf(self, peg$SyntaxError.prototype); + } + self.expected = expected; + self.found = found; + self.location = location; + self.name = "SyntaxError"; + return self; + } + peg$subclass(peg$SyntaxError, Error); + function peg$padEnd(str, targetLength, padString) { + padString = padString || " "; + if (str.length > targetLength) { + return str; + } + targetLength -= str.length; + padString += padString.repeat(targetLength); + return str + padString.slice(0, targetLength); + } + peg$SyntaxError.prototype.format = function(sources) { + var str = "Error: " + this.message; + if (this.location) { + var src = null; + var k; + for (k = 0; k < sources.length; k++) { + if (sources[k].source === this.location.source) { + src = sources[k].text.split(/\r\n|\n|\r/g); + break; + } + } + var s = this.location.start; + var offset_s = this.location.source && typeof this.location.source.offset === "function" ? this.location.source.offset(s) : s; + var loc = this.location.source + ":" + offset_s.line + ":" + offset_s.column; + if (src) { + var e = this.location.end; + var filler = peg$padEnd("", offset_s.line.toString().length, " "); + var line = src[s.line - 1]; + var last = s.line === e.line ? e.column : line.length + 1; + var hatLen = last - s.column || 1; + str += "\n --> " + loc + "\n" + filler + " |\n" + offset_s.line + " | " + line + "\n" + filler + " | " + peg$padEnd("", s.column - 1, " ") + peg$padEnd("", hatLen, "^"); + } else { + str += "\n at " + loc; + } + } + return str; + }; + peg$SyntaxError.buildMessage = function(expected, found) { + var DESCRIBE_EXPECTATION_FNS = { + literal: function(expectation) { + return '"' + literalEscape(expectation.text) + '"'; + }, + class: function(expectation) { + var escapedParts = expectation.parts.map(function(part) { + return Array.isArray(part) ? classEscape(part[0]) + "-" + classEscape(part[1]) : classEscape(part); + }); + return "[" + (expectation.inverted ? "^" : "") + escapedParts.join("") + "]"; + }, + any: function() { + return "any character"; + }, + end: function() { + return "end of input"; + }, + other: function(expectation) { + return expectation.description; + } + }; + function hex(ch) { + return ch.charCodeAt(0).toString(16).toUpperCase(); + } + function literalEscape(s) { + return s.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\0/g, "\\0").replace(/\t/g, "\\t").replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/[\x00-\x0F]/g, function(ch) { + return "\\x0" + hex(ch); + }).replace(/[\x10-\x1F\x7F-\x9F]/g, function(ch) { + return "\\x" + hex(ch); + }); + } + function classEscape(s) { + return s.replace(/\\/g, "\\\\").replace(/\]/g, "\\]").replace(/\^/g, "\\^").replace(/-/g, "\\-").replace(/\0/g, "\\0").replace(/\t/g, "\\t").replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/[\x00-\x0F]/g, function(ch) { + return "\\x0" + hex(ch); + }).replace(/[\x10-\x1F\x7F-\x9F]/g, function(ch) { + return "\\x" + hex(ch); + }); + } + function describeExpectation(expectation) { + return DESCRIBE_EXPECTATION_FNS[expectation.type](expectation); + } + function describeExpected(expected2) { + var descriptions = expected2.map(describeExpectation); + var i, j; + descriptions.sort(); + if (descriptions.length > 0) { + for (i = 1, j = 1; i < descriptions.length; i++) { + if (descriptions[i - 1] !== descriptions[i]) { + descriptions[j] = descriptions[i]; + j++; + } + } + descriptions.length = j; + } + switch (descriptions.length) { + case 1: + return descriptions[0]; + case 2: + return descriptions[0] + " or " + descriptions[1]; + default: + return descriptions.slice(0, -1).join(", ") + ", or " + descriptions[descriptions.length - 1]; + } + } + function describeFound(found2) { + return found2 ? '"' + literalEscape(found2) + '"' : "end of input"; + } + return "Expected " + describeExpected(expected) + " but " + describeFound(found) + " found."; + }; + function peg$parse(input, options) { + options = options !== void 0 ? options : {}; + var peg$FAILED = {}; + var peg$source = options.grammarSource; + var peg$startRuleFunctions = { body: peg$parsebody }; + var peg$startRuleFunction = peg$parsebody; + var peg$e0 = peg$anyExpectation(); + var peg$f0 = function() { + return []; + }; + var peg$f1 = function(rowItems, trailingComment) { + return { + itemParts: [], + ...rowItems, + trailingComment, + trailingComma: true + }; + }; + var peg$f2 = function(rowItems, trailingComment) { + return { ...rowItems, trailingComment }; + }; + var peg$f3 = function(a, b) { + return processItem(a, b); + }; + var peg$f4 = function(b) { + return processItem(null, b); + }; + var peg$f5 = function(cell) { + return { cell }; + }; + var peg$f6 = function() { + return {}; + }; + var peg$f7 = function(part) { + return part; + }; + var peg$f8 = function(x) { + return x; + }; + var peg$f9 = function(space, x) { + return { + trailingComment: x, + leadingParbreak: space.parbreak > 0 + }; + }; + var peg$f10 = function(list) { + return { + whitespace: list.filter((x) => options.isWhitespace(x)).length, + parbreak: list.filter((x) => options.isParbreak(x)).length + }; + }; + var peg$f11 = function() { + return !options.allowParenGroups; + }; + var peg$f12 = function(tok) { + return options.isSameLineComment(tok); + }; + var peg$f13 = function(tok) { + return tok; + }; + var peg$f14 = function(tok) { + return options.isOwnLineComment(tok); + }; + var peg$f15 = function(tok) { + return tok; + }; + var peg$f16 = function(tok) { + return options.isWhitespace(tok); + }; + var peg$f17 = function(tok) { + return tok; + }; + var peg$f18 = function(tok) { + return options.isParbreak(tok); + }; + var peg$f19 = function(tok) { + return tok; + }; + var peg$f20 = function(tok) { + return options.isComma(tok); + }; + var peg$f21 = function(tok) { + return tok; + }; + var peg$f22 = function(tok) { + return options.isEquals(tok); + }; + var peg$f23 = function(tok) { + return tok; + }; + var peg$f24 = function(tok) { + return options.isChar(tok, "("); + }; + var peg$f25 = function(tok) { + return tok; + }; + var peg$f26 = function(tok) { + return options.isChar(tok, ")"); + }; + var peg$f27 = function(tok) { + return tok; + }; + var peg$currPos = 0; + var peg$posDetailsCache = [{ line: 1, column: 1 }]; + var peg$maxFailPos = 0; + var peg$maxFailExpected = []; + var peg$silentFails = 0; + var peg$result; + if ("startRule" in options) { + if (!(options.startRule in peg$startRuleFunctions)) { + throw new Error(`Can't start parsing from rule "` + options.startRule + '".'); + } + peg$startRuleFunction = peg$startRuleFunctions[options.startRule]; + } + function peg$anyExpectation() { + return { type: "any" }; + } + function peg$endExpectation() { + return { type: "end" }; + } + function peg$computePosDetails(pos) { + var details = peg$posDetailsCache[pos]; + var p; + if (details) { + return details; + } else { + p = pos - 1; + while (!peg$posDetailsCache[p]) { + p--; + } + details = peg$posDetailsCache[p]; + details = { + line: details.line, + column: details.column + }; + while (p < pos) { + if (input.charCodeAt(p) === 10) { + details.line++; + details.column = 1; + } else { + details.column++; + } + p++; + } + peg$posDetailsCache[pos] = details; + return details; + } + } + function peg$computeLocation(startPos, endPos, offset2) { + var startPosDetails = peg$computePosDetails(startPos); + var endPosDetails = peg$computePosDetails(endPos); + var res = { + source: peg$source, + start: { + offset: startPos, + line: startPosDetails.line, + column: startPosDetails.column + }, + end: { + offset: endPos, + line: endPosDetails.line, + column: endPosDetails.column + } + }; + return res; + } + function peg$fail(expected2) { + if (peg$currPos < peg$maxFailPos) { + return; + } + if (peg$currPos > peg$maxFailPos) { + peg$maxFailPos = peg$currPos; + peg$maxFailExpected = []; + } + peg$maxFailExpected.push(expected2); + } + function peg$buildStructuredError(expected2, found, location2) { + return new peg$SyntaxError( + peg$SyntaxError.buildMessage(expected2, found), + expected2, + found, + location2 + ); + } + function peg$parsebody() { + var s0, s1, s2; + s0 = []; + s1 = peg$parsecomment_only_line(); + if (s1 === peg$FAILED) { + s1 = peg$parseitem_with_end(); + if (s1 === peg$FAILED) { + s1 = peg$parseitem_without_end(); + } + } + if (s1 !== peg$FAILED) { + while (s1 !== peg$FAILED) { + s0.push(s1); + s1 = peg$parsecomment_only_line(); + if (s1 === peg$FAILED) { + s1 = peg$parseitem_with_end(); + if (s1 === peg$FAILED) { + s1 = peg$parseitem_without_end(); + } + } + } + } else { + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = []; + s2 = peg$parsewhitespace(); + while (s2 !== peg$FAILED) { + s1.push(s2); + s2 = peg$parsewhitespace(); + } + s2 = peg$parseEOL(); + if (s2 !== peg$FAILED) { + s0 = peg$f0(); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } + return s0; + } + function peg$parseitem_with_end() { + var s0, s2, s4, s5, s6, s7, s8; + s0 = peg$currPos; + peg$parsewhitespace_or_parbreaks(); + s2 = peg$parserow_items(); + if (s2 === peg$FAILED) { + s2 = null; + } + peg$parsewhitespace_or_parbreaks(); + s4 = peg$parseitem_sep(); + if (s4 !== peg$FAILED) { + s5 = []; + s6 = peg$parsewhitespace(); + while (s6 !== peg$FAILED) { + s5.push(s6); + s6 = peg$parsewhitespace(); + } + s6 = peg$parsetrailing_comment(); + if (s6 === peg$FAILED) { + s6 = null; + } + s7 = []; + s8 = peg$parsewhitespace(); + while (s8 !== peg$FAILED) { + s7.push(s8); + s8 = peg$parsewhitespace(); + } + s0 = peg$f1(s2, s6); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parseitem_without_end() { + var s0, s2, s3; + s0 = peg$currPos; + peg$parsewhitespace_or_parbreaks(); + s2 = peg$parserow_items(); + if (s2 !== peg$FAILED) { + s3 = peg$parsetrailing_comment(); + if (s3 === peg$FAILED) { + s3 = null; + } + s0 = peg$f2(s2, s3); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parserow_items() { + var s0, s1, s2, s3; + s0 = peg$currPos; + s1 = peg$parseitem_part(); + if (s1 !== peg$FAILED) { + s2 = []; + s3 = peg$parseseparated_part(); + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$parseseparated_part(); + } + s0 = peg$f3(s1, s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = []; + s2 = peg$parseseparated_part(); + if (s2 !== peg$FAILED) { + while (s2 !== peg$FAILED) { + s1.push(s2); + s2 = peg$parseseparated_part(); + } + } else { + s1 = peg$FAILED; + } + if (s1 !== peg$FAILED) { + s1 = peg$f4(s1); + } + s0 = s1; + } + return s0; + } + function peg$parseseparated_part() { + var s0, s1, s2, s3, s4; + s0 = peg$currPos; + s1 = []; + s2 = peg$parseparbreak(); + while (s2 !== peg$FAILED) { + s1.push(s2); + s2 = peg$parseparbreak(); + } + s2 = peg$parseequals(); + if (s2 !== peg$FAILED) { + s3 = []; + s4 = peg$parseparbreak(); + while (s4 !== peg$FAILED) { + s3.push(s4); + s4 = peg$parseparbreak(); + } + s4 = peg$parseitem_part(); + if (s4 !== peg$FAILED) { + s0 = peg$f5(s4); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = []; + s2 = peg$parseparbreak(); + while (s2 !== peg$FAILED) { + s1.push(s2); + s2 = peg$parseparbreak(); + } + s2 = peg$parseequals(); + if (s2 !== peg$FAILED) { + s0 = peg$f6(); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } + return s0; + } + function peg$parseitem_part() { + var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9; + s0 = peg$currPos; + s1 = []; + s2 = peg$parsewhitespace(); + while (s2 !== peg$FAILED) { + s1.push(s2); + s2 = peg$parsewhitespace(); + } + s2 = peg$currPos; + s3 = []; + s4 = peg$parsenon_whitespace_non_parbreak_token(); + if (s4 === peg$FAILED) { + s4 = peg$currPos; + s5 = peg$parsewhitespace(); + if (s5 === peg$FAILED) { + s5 = peg$parseparbreak(); + } + if (s5 !== peg$FAILED) { + s6 = peg$currPos; + peg$silentFails++; + s7 = peg$currPos; + s8 = []; + s9 = peg$parsewhitespace(); + if (s9 === peg$FAILED) { + s9 = peg$parseparbreak(); + } + while (s9 !== peg$FAILED) { + s8.push(s9); + s9 = peg$parsewhitespace(); + if (s9 === peg$FAILED) { + s9 = peg$parseparbreak(); + } + } + s9 = peg$parsenon_whitespace_non_parbreak_token(); + if (s9 !== peg$FAILED) { + s8 = [s8, s9]; + s7 = s8; + } else { + peg$currPos = s7; + s7 = peg$FAILED; + } + peg$silentFails--; + if (s7 !== peg$FAILED) { + peg$currPos = s6; + s6 = void 0; + } else { + s6 = peg$FAILED; + } + if (s6 !== peg$FAILED) { + s5 = [s5, s6]; + s4 = s5; + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + } + if (s4 !== peg$FAILED) { + while (s4 !== peg$FAILED) { + s3.push(s4); + s4 = peg$parsenon_whitespace_non_parbreak_token(); + if (s4 === peg$FAILED) { + s4 = peg$currPos; + s5 = peg$parsewhitespace(); + if (s5 === peg$FAILED) { + s5 = peg$parseparbreak(); + } + if (s5 !== peg$FAILED) { + s6 = peg$currPos; + peg$silentFails++; + s7 = peg$currPos; + s8 = []; + s9 = peg$parsewhitespace(); + if (s9 === peg$FAILED) { + s9 = peg$parseparbreak(); + } + while (s9 !== peg$FAILED) { + s8.push(s9); + s9 = peg$parsewhitespace(); + if (s9 === peg$FAILED) { + s9 = peg$parseparbreak(); + } + } + s9 = peg$parsenon_whitespace_non_parbreak_token(); + if (s9 !== peg$FAILED) { + s8 = [s8, s9]; + s7 = s8; + } else { + peg$currPos = s7; + s7 = peg$FAILED; + } + peg$silentFails--; + if (s7 !== peg$FAILED) { + peg$currPos = s6; + s6 = void 0; + } else { + s6 = peg$FAILED; + } + if (s6 !== peg$FAILED) { + s5 = [s5, s6]; + s4 = s5; + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + } + } + } else { + s3 = peg$FAILED; + } + if (s3 !== peg$FAILED) { + s2 = input.substring(s2, peg$currPos); + } else { + s2 = s3; + } + if (s2 !== peg$FAILED) { + s3 = []; + s4 = peg$parsewhitespace(); + while (s4 !== peg$FAILED) { + s3.push(s4); + s4 = peg$parsewhitespace(); + } + s0 = peg$f7(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsetrailing_comment() { + var s0, s1, s2; + s0 = peg$currPos; + s1 = []; + s2 = peg$parsewhitespace(); + while (s2 !== peg$FAILED) { + s1.push(s2); + s2 = peg$parsewhitespace(); + } + s2 = peg$parsesame_line_comment(); + if (s2 !== peg$FAILED) { + s0 = peg$f8(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsecomment_only_line() { + var s0, s1, s2; + s0 = peg$currPos; + s1 = peg$parsewhitespace_or_parbreaks(); + s2 = peg$parseown_line_comment(); + if (s2 !== peg$FAILED) { + s0 = peg$f9(s1, s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsetoken() { + var s0, s1, s2, s3; + s0 = peg$currPos; + s1 = peg$currPos; + s2 = peg$currPos; + peg$silentFails++; + s3 = peg$parsenon_token(); + peg$silentFails--; + if (s3 === peg$FAILED) { + s2 = void 0; + } else { + peg$currPos = s2; + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + if (input.length > peg$currPos) { + s3 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s3 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s3 !== peg$FAILED) { + s2 = [s2, s3]; + s1 = s2; + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + if (s1 !== peg$FAILED) { + s0 = input.substring(s0, peg$currPos); + } else { + s0 = s1; + } + return s0; + } + function peg$parsenon_whitespace_non_parbreak_token() { + var s0, s1, s2, s3; + s0 = peg$currPos; + s1 = peg$currPos; + s2 = peg$currPos; + peg$silentFails++; + s3 = peg$parsewhitespace(); + if (s3 === peg$FAILED) { + s3 = peg$parseparbreak(); + } + peg$silentFails--; + if (s3 === peg$FAILED) { + s2 = void 0; + } else { + peg$currPos = s2; + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s3 = peg$parseparen_block(); + if (s3 === peg$FAILED) { + s3 = peg$parsetoken(); + } + if (s3 !== peg$FAILED) { + s2 = [s2, s3]; + s1 = s2; + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + if (s1 !== peg$FAILED) { + s0 = input.substring(s0, peg$currPos); + } else { + s0 = s1; + } + return s0; + } + function peg$parsenon_token() { + var s0; + s0 = peg$parseitem_sep(); + if (s0 === peg$FAILED) { + s0 = peg$parseequals(); + if (s0 === peg$FAILED) { + s0 = peg$parsetrailing_comment(); + if (s0 === peg$FAILED) { + s0 = peg$parseown_line_comment(); + } + } + } + return s0; + } + function peg$parsewhitespace_or_parbreaks() { + var s0, s1, s2; + s0 = peg$currPos; + s1 = []; + s2 = peg$parsewhitespace(); + if (s2 === peg$FAILED) { + s2 = peg$parseparbreak(); + } + while (s2 !== peg$FAILED) { + s1.push(s2); + s2 = peg$parsewhitespace(); + if (s2 === peg$FAILED) { + s2 = peg$parseparbreak(); + } + } + s1 = peg$f10(s1); + s0 = s1; + return s0; + } + function peg$parseparen_block() { + var s0, s1, s2, s3, s4, s5, s6, s7, s8; + s0 = peg$currPos; + s1 = peg$f11(); + if (s1) { + s1 = peg$FAILED; + } else { + s1 = void 0; + } + if (s1 !== peg$FAILED) { + s2 = peg$currPos; + s3 = peg$currPos; + s4 = peg$parseopen_paren(); + if (s4 !== peg$FAILED) { + s5 = []; + s6 = peg$currPos; + s7 = peg$currPos; + peg$silentFails++; + s8 = peg$parseclose_paren(); + peg$silentFails--; + if (s8 === peg$FAILED) { + s7 = void 0; + } else { + peg$currPos = s7; + s7 = peg$FAILED; + } + if (s7 !== peg$FAILED) { + if (input.length > peg$currPos) { + s8 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s8 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s8 !== peg$FAILED) { + s7 = [s7, s8]; + s6 = s7; + } else { + peg$currPos = s6; + s6 = peg$FAILED; + } + } else { + peg$currPos = s6; + s6 = peg$FAILED; + } + while (s6 !== peg$FAILED) { + s5.push(s6); + s6 = peg$currPos; + s7 = peg$currPos; + peg$silentFails++; + s8 = peg$parseclose_paren(); + peg$silentFails--; + if (s8 === peg$FAILED) { + s7 = void 0; + } else { + peg$currPos = s7; + s7 = peg$FAILED; + } + if (s7 !== peg$FAILED) { + if (input.length > peg$currPos) { + s8 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s8 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s8 !== peg$FAILED) { + s7 = [s7, s8]; + s6 = s7; + } else { + peg$currPos = s6; + s6 = peg$FAILED; + } + } else { + peg$currPos = s6; + s6 = peg$FAILED; + } + } + s6 = peg$parseclose_paren(); + if (s6 !== peg$FAILED) { + s4 = [s4, s5, s6]; + s3 = s4; + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + if (s3 !== peg$FAILED) { + s2 = input.substring(s2, peg$currPos); + } else { + s2 = s3; + } + if (s2 !== peg$FAILED) { + s1 = [s1, s2]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsesame_line_comment() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f12(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s0 = peg$f13(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parseown_line_comment() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f14(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s0 = peg$f15(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsewhitespace() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f16(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s0 = peg$f17(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parseparbreak() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f18(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s0 = peg$f19(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parseitem_sep() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f20(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s0 = peg$f21(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parseequals() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f22(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s0 = peg$f23(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parseopen_paren() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f24(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s0 = peg$f25(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parseclose_paren() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f26(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s0 = peg$f27(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parseEOL() { + var s0, s1; + s0 = peg$currPos; + peg$silentFails++; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + peg$silentFails--; + if (s1 === peg$FAILED) { + s0 = void 0; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function processItem(leadCell, otherCells) { + const cells = [leadCell || []]; + for (const x of otherCells) { + cells.push(x.cell || []); + } + return { itemParts: cells }; + } + if (!options.isWhitespace) { + try { + Object.assign(options, { + isChar: (node, char) => node.type === "string" && node.content === char, + isComma(node) { + return node.type === "string" && node.content === ","; + }, + isEquals(node) { + return node.type === "string" && node.content === "="; + }, + isParbreak(node) { + return node.type === "parbreak"; + }, + isWhitespace(node) { + return node.type === "whitespace"; + }, + isSameLineComment: (node) => node.type === "comment" && node.sameline, + isOwnLineComment: (node) => node.type === "comment" && !node.sameline, + isComment: (node) => node.type === "comment", + allowParenGroups: true + }); + } catch (e) { + console.warn("Error when initializing parser", e); + } + } + peg$result = peg$startRuleFunction(); + if (peg$result !== peg$FAILED && peg$currPos === input.length) { + return peg$result; + } else { + if (peg$result !== peg$FAILED && peg$currPos < input.length) { + peg$fail(peg$endExpectation()); + } + throw peg$buildStructuredError( + peg$maxFailExpected, + peg$maxFailPos < input.length ? input.charAt(peg$maxFailPos) : null, + peg$maxFailPos < input.length ? peg$computeLocation(peg$maxFailPos, peg$maxFailPos + 1) : peg$computeLocation(peg$maxFailPos, peg$maxFailPos) + ); + } + } + return { + SyntaxError: peg$SyntaxError, + parse: peg$parse + }; + }() +); +const _MacroSubstitutionPegParser = ( + // Generated by Peggy 3.0.2. + // + // https://peggyjs.org/ + function() { + function peg$subclass(child, parent) { + function C() { + this.constructor = child; + } + C.prototype = parent.prototype; + child.prototype = new C(); + } + function peg$SyntaxError(message, expected, found, location) { + var self = Error.call(this, message); + if (Object.setPrototypeOf) { + Object.setPrototypeOf(self, peg$SyntaxError.prototype); + } + self.expected = expected; + self.found = found; + self.location = location; + self.name = "SyntaxError"; + return self; + } + peg$subclass(peg$SyntaxError, Error); + function peg$padEnd(str, targetLength, padString) { + padString = padString || " "; + if (str.length > targetLength) { + return str; + } + targetLength -= str.length; + padString += padString.repeat(targetLength); + return str + padString.slice(0, targetLength); + } + peg$SyntaxError.prototype.format = function(sources) { + var str = "Error: " + this.message; + if (this.location) { + var src = null; + var k; + for (k = 0; k < sources.length; k++) { + if (sources[k].source === this.location.source) { + src = sources[k].text.split(/\r\n|\n|\r/g); + break; + } + } + var s = this.location.start; + var offset_s = this.location.source && typeof this.location.source.offset === "function" ? this.location.source.offset(s) : s; + var loc = this.location.source + ":" + offset_s.line + ":" + offset_s.column; + if (src) { + var e = this.location.end; + var filler = peg$padEnd("", offset_s.line.toString().length, " "); + var line = src[s.line - 1]; + var last = s.line === e.line ? e.column : line.length + 1; + var hatLen = last - s.column || 1; + str += "\n --> " + loc + "\n" + filler + " |\n" + offset_s.line + " | " + line + "\n" + filler + " | " + peg$padEnd("", s.column - 1, " ") + peg$padEnd("", hatLen, "^"); + } else { + str += "\n at " + loc; + } + } + return str; + }; + peg$SyntaxError.buildMessage = function(expected, found) { + var DESCRIBE_EXPECTATION_FNS = { + literal: function(expectation) { + return '"' + literalEscape(expectation.text) + '"'; + }, + class: function(expectation) { + var escapedParts = expectation.parts.map(function(part) { + return Array.isArray(part) ? classEscape(part[0]) + "-" + classEscape(part[1]) : classEscape(part); + }); + return "[" + (expectation.inverted ? "^" : "") + escapedParts.join("") + "]"; + }, + any: function() { + return "any character"; + }, + end: function() { + return "end of input"; + }, + other: function(expectation) { + return expectation.description; + } + }; + function hex(ch) { + return ch.charCodeAt(0).toString(16).toUpperCase(); + } + function literalEscape(s) { + return s.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\0/g, "\\0").replace(/\t/g, "\\t").replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/[\x00-\x0F]/g, function(ch) { + return "\\x0" + hex(ch); + }).replace(/[\x10-\x1F\x7F-\x9F]/g, function(ch) { + return "\\x" + hex(ch); + }); + } + function classEscape(s) { + return s.replace(/\\/g, "\\\\").replace(/\]/g, "\\]").replace(/\^/g, "\\^").replace(/-/g, "\\-").replace(/\0/g, "\\0").replace(/\t/g, "\\t").replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/[\x00-\x0F]/g, function(ch) { + return "\\x0" + hex(ch); + }).replace(/[\x10-\x1F\x7F-\x9F]/g, function(ch) { + return "\\x" + hex(ch); + }); + } + function describeExpectation(expectation) { + return DESCRIBE_EXPECTATION_FNS[expectation.type](expectation); + } + function describeExpected(expected2) { + var descriptions = expected2.map(describeExpectation); + var i, j; + descriptions.sort(); + if (descriptions.length > 0) { + for (i = 1, j = 1; i < descriptions.length; i++) { + if (descriptions[i - 1] !== descriptions[i]) { + descriptions[j] = descriptions[i]; + j++; + } + } + descriptions.length = j; + } + switch (descriptions.length) { + case 1: + return descriptions[0]; + case 2: + return descriptions[0] + " or " + descriptions[1]; + default: + return descriptions.slice(0, -1).join(", ") + ", or " + descriptions[descriptions.length - 1]; + } + } + function describeFound(found2) { + return found2 ? '"' + literalEscape(found2) + '"' : "end of input"; + } + return "Expected " + describeExpected(expected) + " but " + describeFound(found) + " found."; + }; + function peg$parse(input, options) { + options = options !== void 0 ? options : {}; + var peg$FAILED = {}; + var peg$source = options.grammarSource; + var peg$startRuleFunctions = { body: peg$parsebody }; + var peg$startRuleFunction = peg$parsebody; + var peg$e0 = peg$anyExpectation(); + var peg$f0 = function(e) { + return [].concat(...e).filter((n) => !!n); + }; + var peg$f1 = function() { + return []; + }; + var peg$f2 = function(tok) { + return options.isHash(tok); + }; + var peg$f3 = function(tok) { + return tok; + }; + var peg$f4 = function(tok) { + return options.isNumber(tok); + }; + var peg$f5 = function(tok) { + return tok; + }; + var peg$f6 = function() { + return { type: "string", content: "#" }; + }; + var peg$f7 = function(num) { + const split = options.splitNumber(num); + return [{ type: "hash_number", number: split.number }, split.rest]; + }; + var peg$currPos = 0; + var peg$posDetailsCache = [{ line: 1, column: 1 }]; + var peg$maxFailPos = 0; + var peg$maxFailExpected = []; + var peg$silentFails = 0; + var peg$result; + if ("startRule" in options) { + if (!(options.startRule in peg$startRuleFunctions)) { + throw new Error(`Can't start parsing from rule "` + options.startRule + '".'); + } + peg$startRuleFunction = peg$startRuleFunctions[options.startRule]; + } + function peg$anyExpectation() { + return { type: "any" }; + } + function peg$endExpectation() { + return { type: "end" }; + } + function peg$computePosDetails(pos) { + var details = peg$posDetailsCache[pos]; + var p; + if (details) { + return details; + } else { + p = pos - 1; + while (!peg$posDetailsCache[p]) { + p--; + } + details = peg$posDetailsCache[p]; + details = { + line: details.line, + column: details.column + }; + while (p < pos) { + if (input.charCodeAt(p) === 10) { + details.line++; + details.column = 1; + } else { + details.column++; + } + p++; + } + peg$posDetailsCache[pos] = details; + return details; + } + } + function peg$computeLocation(startPos, endPos, offset2) { + var startPosDetails = peg$computePosDetails(startPos); + var endPosDetails = peg$computePosDetails(endPos); + var res = { + source: peg$source, + start: { + offset: startPos, + line: startPosDetails.line, + column: startPosDetails.column + }, + end: { + offset: endPos, + line: endPosDetails.line, + column: endPosDetails.column + } + }; + return res; + } + function peg$fail(expected2) { + if (peg$currPos < peg$maxFailPos) { + return; + } + if (peg$currPos > peg$maxFailPos) { + peg$maxFailPos = peg$currPos; + peg$maxFailExpected = []; + } + peg$maxFailExpected.push(expected2); + } + function peg$buildStructuredError(expected2, found, location2) { + return new peg$SyntaxError( + peg$SyntaxError.buildMessage(expected2, found), + expected2, + found, + location2 + ); + } + function peg$parsebody() { + var s0, s1, s2; + s0 = peg$currPos; + s1 = []; + s2 = peg$parsedouble_hash(); + if (s2 === peg$FAILED) { + s2 = peg$parsehash_number(); + if (s2 === peg$FAILED) { + if (input.length > peg$currPos) { + s2 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + } + } + if (s2 !== peg$FAILED) { + while (s2 !== peg$FAILED) { + s1.push(s2); + s2 = peg$parsedouble_hash(); + if (s2 === peg$FAILED) { + s2 = peg$parsehash_number(); + if (s2 === peg$FAILED) { + if (input.length > peg$currPos) { + s2 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + } + } + } + } else { + s1 = peg$FAILED; + } + if (s1 !== peg$FAILED) { + s1 = peg$f0(s1); + } + s0 = s1; + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$parseEOL(); + if (s1 !== peg$FAILED) { + s1 = peg$f1(); + } + s0 = s1; + } + return s0; + } + function peg$parsehash() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f2(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s0 = peg$f3(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsenumber() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f4(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s0 = peg$f5(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsedouble_hash() { + var s0, s1, s2; + s0 = peg$currPos; + s1 = peg$parsehash(); + if (s1 !== peg$FAILED) { + s2 = peg$parsehash(); + if (s2 !== peg$FAILED) { + s0 = peg$f6(); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsehash_number() { + var s0, s1, s2; + s0 = peg$currPos; + s1 = peg$parsehash(); + if (s1 !== peg$FAILED) { + s2 = peg$parsenumber(); + if (s2 !== peg$FAILED) { + s0 = peg$f7(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parseEOL() { + var s0, s1; + s0 = peg$currPos; + peg$silentFails++; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + peg$silentFails--; + if (s1 === peg$FAILED) { + s0 = void 0; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + if (!options.isHash) { + try { + Object.assign(options, { + isHash: (node) => node.type === "string" && node.content === "#", + isNumber: (node) => node.type === "string" && 0 < +node.content.charAt(0), + splitNumber: (node) => { + const number = +node.content.charAt(0); + if (node.content.length > 1) { + return { + number, + rest: { + type: "string", + content: node.content.slice(1) + } + }; + } + return { number }; + } + }); + } catch (e) { + console.warn("Error when initializing parser", e); + } + } + peg$result = peg$startRuleFunction(); + if (peg$result !== peg$FAILED && peg$currPos === input.length) { + return peg$result; + } else { + if (peg$result !== peg$FAILED && peg$currPos < input.length) { + peg$fail(peg$endExpectation()); + } + throw peg$buildStructuredError( + peg$maxFailExpected, + peg$maxFailPos < input.length ? input.charAt(peg$maxFailPos) : null, + peg$maxFailPos < input.length ? peg$computeLocation(peg$maxFailPos, peg$maxFailPos + 1) : peg$computeLocation(peg$maxFailPos, peg$maxFailPos) + ); + } + } + return { + SyntaxError: peg$SyntaxError, + parse: peg$parse + }; + }() +); +const _LigaturesPegParser = ( + // Generated by Peggy 3.0.2. + // + // https://peggyjs.org/ + function() { + function peg$subclass(child, parent) { + function C() { + this.constructor = child; + } + C.prototype = parent.prototype; + child.prototype = new C(); + } + function peg$SyntaxError(message, expected, found, location) { + var self = Error.call(this, message); + if (Object.setPrototypeOf) { + Object.setPrototypeOf(self, peg$SyntaxError.prototype); + } + self.expected = expected; + self.found = found; + self.location = location; + self.name = "SyntaxError"; + return self; + } + peg$subclass(peg$SyntaxError, Error); + function peg$padEnd(str, targetLength, padString) { + padString = padString || " "; + if (str.length > targetLength) { + return str; + } + targetLength -= str.length; + padString += padString.repeat(targetLength); + return str + padString.slice(0, targetLength); + } + peg$SyntaxError.prototype.format = function(sources) { + var str = "Error: " + this.message; + if (this.location) { + var src = null; + var k; + for (k = 0; k < sources.length; k++) { + if (sources[k].source === this.location.source) { + src = sources[k].text.split(/\r\n|\n|\r/g); + break; + } + } + var s = this.location.start; + var offset_s = this.location.source && typeof this.location.source.offset === "function" ? this.location.source.offset(s) : s; + var loc = this.location.source + ":" + offset_s.line + ":" + offset_s.column; + if (src) { + var e = this.location.end; + var filler = peg$padEnd("", offset_s.line.toString().length, " "); + var line = src[s.line - 1]; + var last = s.line === e.line ? e.column : line.length + 1; + var hatLen = last - s.column || 1; + str += "\n --> " + loc + "\n" + filler + " |\n" + offset_s.line + " | " + line + "\n" + filler + " | " + peg$padEnd("", s.column - 1, " ") + peg$padEnd("", hatLen, "^"); + } else { + str += "\n at " + loc; + } + } + return str; + }; + peg$SyntaxError.buildMessage = function(expected, found) { + var DESCRIBE_EXPECTATION_FNS = { + literal: function(expectation) { + return '"' + literalEscape(expectation.text) + '"'; + }, + class: function(expectation) { + var escapedParts = expectation.parts.map(function(part) { + return Array.isArray(part) ? classEscape(part[0]) + "-" + classEscape(part[1]) : classEscape(part); + }); + return "[" + (expectation.inverted ? "^" : "") + escapedParts.join("") + "]"; + }, + any: function() { + return "any character"; + }, + end: function() { + return "end of input"; + }, + other: function(expectation) { + return expectation.description; + } + }; + function hex(ch) { + return ch.charCodeAt(0).toString(16).toUpperCase(); + } + function literalEscape(s) { + return s.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\0/g, "\\0").replace(/\t/g, "\\t").replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/[\x00-\x0F]/g, function(ch) { + return "\\x0" + hex(ch); + }).replace(/[\x10-\x1F\x7F-\x9F]/g, function(ch) { + return "\\x" + hex(ch); + }); + } + function classEscape(s) { + return s.replace(/\\/g, "\\\\").replace(/\]/g, "\\]").replace(/\^/g, "\\^").replace(/-/g, "\\-").replace(/\0/g, "\\0").replace(/\t/g, "\\t").replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/[\x00-\x0F]/g, function(ch) { + return "\\x0" + hex(ch); + }).replace(/[\x10-\x1F\x7F-\x9F]/g, function(ch) { + return "\\x" + hex(ch); + }); + } + function describeExpectation(expectation) { + return DESCRIBE_EXPECTATION_FNS[expectation.type](expectation); + } + function describeExpected(expected2) { + var descriptions = expected2.map(describeExpectation); + var i, j; + descriptions.sort(); + if (descriptions.length > 0) { + for (i = 1, j = 1; i < descriptions.length; i++) { + if (descriptions[i - 1] !== descriptions[i]) { + descriptions[j] = descriptions[i]; + j++; + } + } + descriptions.length = j; + } + switch (descriptions.length) { + case 1: + return descriptions[0]; + case 2: + return descriptions[0] + " or " + descriptions[1]; + default: + return descriptions.slice(0, -1).join(", ") + ", or " + descriptions[descriptions.length - 1]; + } + } + function describeFound(found2) { + return found2 ? '"' + literalEscape(found2) + '"' : "end of input"; + } + return "Expected " + describeExpected(expected) + " but " + describeFound(found) + " found."; + }; + function peg$parse(input, options) { + options = options !== void 0 ? options : {}; + var peg$FAILED = {}; + var peg$source = options.grammarSource; + var peg$startRuleFunctions = { body: peg$parsebody }; + var peg$startRuleFunction = peg$parsebody; + var peg$e0 = peg$anyExpectation(); + var peg$f0 = function(e) { + return [].concat(...e).filter((n) => !!n); + }; + var peg$f1 = function() { + return []; + }; + var peg$f2 = function(toks) { + return options.isRecognized(toks); + }; + var peg$f3 = function(toks) { + return options.isRecognized(toks); + }; + var peg$f4 = function(tok1, tok2) { + const split = options.split(tok2); + return options.isRecognized([tok1, split[0]]); + }; + var peg$f5 = function(tok1, tok2) { + const split = options.split(tok2); + return [options.isRecognized([tok1, split[0]]), split[1]]; + }; + var peg$f6 = function(tok1, tok2) { + return options.isRecognized([tok1, tok2]); + }; + var peg$f7 = function(tok1, tok2) { + return options.isRecognized([tok1, tok2]); + }; + var peg$f8 = function(toks) { + return options.isRecognized(toks); + }; + var peg$f9 = function(toks) { + return options.isRecognized(toks); + }; + var peg$f10 = function(tok) { + return options.isRecognized([tok]); + }; + var peg$f11 = function(tok) { + return options.isRecognized([tok]); + }; + var peg$f12 = function(tok) { + return options.isMacro(tok); + }; + var peg$f13 = function(tok) { + return tok; + }; + var peg$f14 = function(tok) { + return options.isWhitespace(tok); + }; + var peg$f15 = function(tok) { + return tok; + }; + var peg$f16 = function(tok) { + return options.isSplitable(tok); + }; + var peg$f17 = function(tok) { + return tok; + }; + var peg$currPos = 0; + var peg$posDetailsCache = [{ line: 1, column: 1 }]; + var peg$maxFailPos = 0; + var peg$maxFailExpected = []; + var peg$silentFails = 0; + var peg$result; + if ("startRule" in options) { + if (!(options.startRule in peg$startRuleFunctions)) { + throw new Error(`Can't start parsing from rule "` + options.startRule + '".'); + } + peg$startRuleFunction = peg$startRuleFunctions[options.startRule]; + } + function peg$anyExpectation() { + return { type: "any" }; + } + function peg$endExpectation() { + return { type: "end" }; + } + function peg$computePosDetails(pos) { + var details = peg$posDetailsCache[pos]; + var p; + if (details) { + return details; + } else { + p = pos - 1; + while (!peg$posDetailsCache[p]) { + p--; + } + details = peg$posDetailsCache[p]; + details = { + line: details.line, + column: details.column + }; + while (p < pos) { + if (input.charCodeAt(p) === 10) { + details.line++; + details.column = 1; + } else { + details.column++; + } + p++; + } + peg$posDetailsCache[pos] = details; + return details; + } + } + function peg$computeLocation(startPos, endPos, offset2) { + var startPosDetails = peg$computePosDetails(startPos); + var endPosDetails = peg$computePosDetails(endPos); + var res = { + source: peg$source, + start: { + offset: startPos, + line: startPosDetails.line, + column: startPosDetails.column + }, + end: { + offset: endPos, + line: endPosDetails.line, + column: endPosDetails.column + } + }; + return res; + } + function peg$fail(expected2) { + if (peg$currPos < peg$maxFailPos) { + return; + } + if (peg$currPos > peg$maxFailPos) { + peg$maxFailPos = peg$currPos; + peg$maxFailExpected = []; + } + peg$maxFailExpected.push(expected2); + } + function peg$buildStructuredError(expected2, found, location2) { + return new peg$SyntaxError( + peg$SyntaxError.buildMessage(expected2, found), + expected2, + found, + location2 + ); + } + function peg$parsebody() { + var s0, s1, s2; + s0 = peg$currPos; + s1 = []; + s2 = peg$parsetriple_ligature(); + if (s2 === peg$FAILED) { + s2 = peg$parsedouble_ligature(); + if (s2 === peg$FAILED) { + s2 = peg$parsemono_ligature(); + if (s2 === peg$FAILED) { + if (input.length > peg$currPos) { + s2 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + } + } + } + if (s2 !== peg$FAILED) { + while (s2 !== peg$FAILED) { + s1.push(s2); + s2 = peg$parsetriple_ligature(); + if (s2 === peg$FAILED) { + s2 = peg$parsedouble_ligature(); + if (s2 === peg$FAILED) { + s2 = peg$parsemono_ligature(); + if (s2 === peg$FAILED) { + if (input.length > peg$currPos) { + s2 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + } + } + } + } + } else { + s1 = peg$FAILED; + } + if (s1 !== peg$FAILED) { + s1 = peg$f0(s1); + } + s0 = s1; + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$parseEOL(); + if (s1 !== peg$FAILED) { + s1 = peg$f1(); + } + s0 = s1; + } + return s0; + } + function peg$parsetriple_ligature() { + var s0, s1, s2, s3, s4; + s0 = peg$currPos; + s1 = peg$currPos; + if (input.length > peg$currPos) { + s2 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s2 !== peg$FAILED) { + if (input.length > peg$currPos) { + s3 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s3 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s3 !== peg$FAILED) { + if (input.length > peg$currPos) { + s4 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s4 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s4 !== peg$FAILED) { + s2 = [s2, s3, s4]; + s1 = s2; + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + if (s1 !== peg$FAILED) { + s2 = peg$f2(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s0 = peg$f3(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsedouble_ligature() { + var s0; + s0 = peg$parsedouble_macro_ligature(); + if (s0 === peg$FAILED) { + s0 = peg$parsedouble_macro_ligature_extracted(); + if (s0 === peg$FAILED) { + s0 = peg$parsedouble_char_ligature(); + } + } + return s0; + } + function peg$parsedouble_macro_ligature_extracted() { + var s0, s1, s2, s3, s4; + s0 = peg$currPos; + s1 = peg$parsemacro(); + if (s1 !== peg$FAILED) { + s2 = []; + s3 = peg$parsewhitespace(); + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$parsewhitespace(); + } + s3 = peg$parsesplitable(); + if (s3 !== peg$FAILED) { + s4 = peg$f4(s1, s3); + if (s4) { + s4 = void 0; + } else { + s4 = peg$FAILED; + } + if (s4 !== peg$FAILED) { + s0 = peg$f5(s1, s3); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsedouble_macro_ligature() { + var s0, s1, s2, s3, s4; + s0 = peg$currPos; + s1 = peg$parsemacro(); + if (s1 !== peg$FAILED) { + s2 = []; + s3 = peg$parsewhitespace(); + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$parsewhitespace(); + } + if (input.length > peg$currPos) { + s3 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s3 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s3 !== peg$FAILED) { + s4 = peg$f6(s1, s3); + if (s4) { + s4 = void 0; + } else { + s4 = peg$FAILED; + } + if (s4 !== peg$FAILED) { + s0 = peg$f7(s1, s3); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsedouble_char_ligature() { + var s0, s1, s2, s3; + s0 = peg$currPos; + s1 = peg$currPos; + if (input.length > peg$currPos) { + s2 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s2 !== peg$FAILED) { + if (input.length > peg$currPos) { + s3 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s3 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s3 !== peg$FAILED) { + s2 = [s2, s3]; + s1 = s2; + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + if (s1 !== peg$FAILED) { + s2 = peg$f8(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s0 = peg$f9(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsemono_ligature() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f10(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s0 = peg$f11(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsemacro() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f12(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s0 = peg$f13(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsewhitespace() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f14(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s0 = peg$f15(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsesplitable() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f16(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s0 = peg$f17(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parseEOL() { + var s0, s1; + s0 = peg$currPos; + peg$silentFails++; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + peg$silentFails--; + if (s1 === peg$FAILED) { + s0 = void 0; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + if (!options.isWhitespace) { + try { + Object.assign(options, { + isMacro: (node) => node.type === "macro", + isWhitespace: (node) => node.type === "whitespace", + isRecognized: (nodes) => { + if (nodes.length == 2 && nodes[0].content === "^" && nodes[1].content === "o") { + return { type: "string", content: "ô" }; + } + return null; + }, + isSplitable: (node) => node.type === "string" && node.content.length > 1, + split: (node) => [ + { type: "string", content: node.content.charAt(0) }, + { type: "string", content: node.content.slice(1) } + ] + }); + } catch (e) { + console.warn("Error when initializing parser", e); + } + } + peg$result = peg$startRuleFunction(); + if (peg$result !== peg$FAILED && peg$currPos === input.length) { + return peg$result; + } else { + if (peg$result !== peg$FAILED && peg$currPos < input.length) { + peg$fail(peg$endExpectation()); + } + throw peg$buildStructuredError( + peg$maxFailExpected, + peg$maxFailPos < input.length ? input.charAt(peg$maxFailPos) : null, + peg$maxFailPos < input.length ? peg$computeLocation(peg$maxFailPos, peg$maxFailPos + 1) : peg$computeLocation(peg$maxFailPos, peg$maxFailPos) + ); + } + } + return { + SyntaxError: peg$SyntaxError, + parse: peg$parse + }; + }() +); +const _XColorPegParser = ( + // Generated by Peggy 3.0.2. + // + // https://peggyjs.org/ + function() { + function peg$subclass(child, parent) { + function C() { + this.constructor = child; + } + C.prototype = parent.prototype; + child.prototype = new C(); + } + function peg$SyntaxError(message, expected, found, location) { + var self = Error.call(this, message); + if (Object.setPrototypeOf) { + Object.setPrototypeOf(self, peg$SyntaxError.prototype); + } + self.expected = expected; + self.found = found; + self.location = location; + self.name = "SyntaxError"; + return self; + } + peg$subclass(peg$SyntaxError, Error); + function peg$padEnd(str, targetLength, padString) { + padString = padString || " "; + if (str.length > targetLength) { + return str; + } + targetLength -= str.length; + padString += padString.repeat(targetLength); + return str + padString.slice(0, targetLength); + } + peg$SyntaxError.prototype.format = function(sources) { + var str = "Error: " + this.message; + if (this.location) { + var src = null; + var k; + for (k = 0; k < sources.length; k++) { + if (sources[k].source === this.location.source) { + src = sources[k].text.split(/\r\n|\n|\r/g); + break; + } + } + var s = this.location.start; + var offset_s = this.location.source && typeof this.location.source.offset === "function" ? this.location.source.offset(s) : s; + var loc = this.location.source + ":" + offset_s.line + ":" + offset_s.column; + if (src) { + var e = this.location.end; + var filler = peg$padEnd("", offset_s.line.toString().length, " "); + var line = src[s.line - 1]; + var last = s.line === e.line ? e.column : line.length + 1; + var hatLen = last - s.column || 1; + str += "\n --> " + loc + "\n" + filler + " |\n" + offset_s.line + " | " + line + "\n" + filler + " | " + peg$padEnd("", s.column - 1, " ") + peg$padEnd("", hatLen, "^"); + } else { + str += "\n at " + loc; + } + } + return str; + }; + peg$SyntaxError.buildMessage = function(expected, found) { + var DESCRIBE_EXPECTATION_FNS = { + literal: function(expectation) { + return '"' + literalEscape(expectation.text) + '"'; + }, + class: function(expectation) { + var escapedParts = expectation.parts.map(function(part) { + return Array.isArray(part) ? classEscape(part[0]) + "-" + classEscape(part[1]) : classEscape(part); + }); + return "[" + (expectation.inverted ? "^" : "") + escapedParts.join("") + "]"; + }, + any: function() { + return "any character"; + }, + end: function() { + return "end of input"; + }, + other: function(expectation) { + return expectation.description; + } + }; + function hex(ch) { + return ch.charCodeAt(0).toString(16).toUpperCase(); + } + function literalEscape(s) { + return s.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\0/g, "\\0").replace(/\t/g, "\\t").replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/[\x00-\x0F]/g, function(ch) { + return "\\x0" + hex(ch); + }).replace(/[\x10-\x1F\x7F-\x9F]/g, function(ch) { + return "\\x" + hex(ch); + }); + } + function classEscape(s) { + return s.replace(/\\/g, "\\\\").replace(/\]/g, "\\]").replace(/\^/g, "\\^").replace(/-/g, "\\-").replace(/\0/g, "\\0").replace(/\t/g, "\\t").replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/[\x00-\x0F]/g, function(ch) { + return "\\x0" + hex(ch); + }).replace(/[\x10-\x1F\x7F-\x9F]/g, function(ch) { + return "\\x" + hex(ch); + }); + } + function describeExpectation(expectation) { + return DESCRIBE_EXPECTATION_FNS[expectation.type](expectation); + } + function describeExpected(expected2) { + var descriptions = expected2.map(describeExpectation); + var i, j; + descriptions.sort(); + if (descriptions.length > 0) { + for (i = 1, j = 1; i < descriptions.length; i++) { + if (descriptions[i - 1] !== descriptions[i]) { + descriptions[j] = descriptions[i]; + j++; + } + } + descriptions.length = j; + } + switch (descriptions.length) { + case 1: + return descriptions[0]; + case 2: + return descriptions[0] + " or " + descriptions[1]; + default: + return descriptions.slice(0, -1).join(", ") + ", or " + descriptions[descriptions.length - 1]; + } + } + function describeFound(found2) { + return found2 ? '"' + literalEscape(found2) + '"' : "end of input"; + } + return "Expected " + describeExpected(expected) + " but " + describeFound(found) + " found."; + }; + function peg$parse(input, options) { + options = options !== void 0 ? options : {}; + var peg$FAILED = {}; + var peg$source = options.grammarSource; + var peg$startRuleFunctions = { start: peg$parsestart }; + var peg$startRuleFunction = peg$parsestart; + var peg$c0 = ";"; + var peg$c1 = ","; + var peg$c2 = ":"; + var peg$c3 = "/"; + var peg$c4 = ">"; + var peg$c5 = "!"; + var peg$c6 = "."; + var peg$c7 = "!!["; + var peg$c8 = "]"; + var peg$c9 = "!!"; + var peg$c10 = "+"; + var peg$c11 = "-"; + var peg$r0 = /^[a-zA-Z0-9]/; + var peg$r1 = /^[0-9]/; + var peg$r2 = /^[ \t\n\r]/; + var peg$r3 = /^[0-9a-fA-F]/; + var peg$e0 = peg$anyExpectation(); + var peg$e1 = peg$literalExpectation(";", false); + var peg$e2 = peg$literalExpectation(",", false); + var peg$e3 = peg$otherExpectation("model list"); + var peg$e4 = peg$literalExpectation(":", false); + var peg$e5 = peg$literalExpectation("/", false); + var peg$e6 = peg$otherExpectation("model"); + var peg$e7 = peg$otherExpectation("color spec list"); + var peg$e8 = peg$otherExpectation("color spec"); + var peg$e9 = peg$otherExpectation("color"); + var peg$e10 = peg$otherExpectation("function expression"); + var peg$e11 = peg$literalExpectation(">", false); + var peg$e12 = peg$otherExpectation("function"); + var peg$e13 = peg$otherExpectation("extended expression"); + var peg$e14 = peg$otherExpectation("core model"); + var peg$e15 = peg$otherExpectation("expr"); + var peg$e16 = peg$literalExpectation("!", false); + var peg$e17 = peg$otherExpectation("mix expr"); + var peg$e18 = peg$otherExpectation("name"); + var peg$e19 = peg$literalExpectation(".", false); + var peg$e20 = peg$classExpectation([["a", "z"], ["A", "Z"], ["0", "9"]], false, false); + var peg$e21 = peg$otherExpectation("postfix"); + var peg$e22 = peg$literalExpectation("!![", false); + var peg$e23 = peg$literalExpectation("]", false); + var peg$e24 = peg$literalExpectation("!!", false); + var peg$e25 = peg$otherExpectation("prefix"); + var peg$e26 = peg$otherExpectation("plus"); + var peg$e27 = peg$literalExpectation("+", false); + var peg$e28 = peg$otherExpectation("minus"); + var peg$e29 = peg$literalExpectation("-", false); + var peg$e30 = peg$otherExpectation("num"); + var peg$e31 = peg$classExpectation([["0", "9"]], false, false); + var peg$e32 = peg$otherExpectation("positive float"); + var peg$e33 = peg$otherExpectation("divisor"); + var peg$e34 = peg$otherExpectation("int"); + var peg$e36 = peg$classExpectation([" ", " ", "\n", "\r"], false, false); + var peg$e37 = peg$classExpectation([["0", "9"], ["a", "f"], ["A", "F"]], false, false); + var peg$f0 = function(m) { + return m; + }; + var peg$f1 = function(m) { + return m; + }; + var peg$f2 = function(m) { + return m; + }; + var peg$f3 = function(m) { + return m; + }; + var peg$f4 = function(m) { + return m; + }; + var peg$f5 = function(a) { + return { type: "invalid_spec", content: a }; + }; + var peg$f6 = function(f, c) { + return c; + }; + var peg$f7 = function(f, r) { + return { type: "color_set", content: [f].concat(r) }; + }; + var peg$f8 = function(n, s) { + return { type: "color_set_item", name: n, spec_list: s }; + }; + var peg$f9 = function(c, m) { + return { type: "model_list", contents: m, core_model: c }; + }; + var peg$f10 = function(m) { + return { type: "model_list", contents: m, core_model: null }; + }; + var peg$f11 = function(m, a) { + return a; + }; + var peg$f12 = function(m, r) { + return [m].concat(r); + }; + var peg$f13 = function(s, a) { + return a; + }; + var peg$f14 = function(s, r) { + return { type: "spec_list", content: [s].concat(r) }; + }; + var peg$f15 = function(c) { + return { type: "hex_spec", content: [c] }; + }; + var peg$f16 = function(c, d) { + return d; + }; + var peg$f17 = function(c, d) { + return d; + }; + var peg$f18 = function(c, r) { + return { type: "num_spec", content: r ? [c].concat(r) : [c] }; + }; + var peg$f19 = function(c, fs) { + return { type: "color", color: c, functions: fs }; + }; + var peg$f20 = function(f, n) { + return n; + }; + var peg$f21 = function(f, args) { + return { type: "function", name: f, args }; + }; + var peg$f22 = function(core, d, e, es) { + return { + type: "extended_expr", + core_model: core, + div: d, + expressions: [e].concat(es) + }; + }; + var peg$f23 = function(core, e, es) { + return { + type: "extended_expr", + core_model: core, + div: null, + expressions: [e].concat(es) + }; + }; + var peg$f24 = function(e, d) { + return { type: "weighted_expr", color: e, weight: d }; + }; + var peg$f25 = function(e) { + return e; + }; + var peg$f26 = function(p, n, e, po) { + return { + type: "expr", + prefix: p, + name: n, + mix_expr: e, + postfix: po + }; + }; + var peg$f27 = function(p, n) { + return { type: "complete_mix", mix_percent: p, name: n }; + }; + var peg$f28 = function(p) { + return { type: "partial_mix", mix_percent: p }; + }; + var peg$f29 = function(c, p) { + return c.concat(p || []); + }; + var peg$f30 = function(n) { + return { type: "postfix", num: n }; + }; + var peg$f31 = function(p) { + return { type: "postfix", plusses: p }; + }; + var peg$f32 = function(n) { + return parseInt(n, 10); + }; + var peg$f33 = function(n) { + return parseFloat(n); + }; + var peg$f34 = function(n) { + return n; + }; + var peg$f35 = function(n) { + return -n; + }; + var peg$f36 = function(m, n) { + return m ? -n : n; + }; + var peg$f37 = function(h) { + return h.toUpperCase(); + }; + var peg$currPos = 0; + var peg$posDetailsCache = [{ line: 1, column: 1 }]; + var peg$maxFailPos = 0; + var peg$maxFailExpected = []; + var peg$silentFails = 0; + var peg$result; + if ("startRule" in options) { + if (!(options.startRule in peg$startRuleFunctions)) { + throw new Error(`Can't start parsing from rule "` + options.startRule + '".'); + } + peg$startRuleFunction = peg$startRuleFunctions[options.startRule]; + } + function peg$literalExpectation(text2, ignoreCase) { + return { type: "literal", text: text2, ignoreCase }; + } + function peg$classExpectation(parts, inverted, ignoreCase) { + return { type: "class", parts, inverted, ignoreCase }; + } + function peg$anyExpectation() { + return { type: "any" }; + } + function peg$endExpectation() { + return { type: "end" }; + } + function peg$otherExpectation(description) { + return { type: "other", description }; + } + function peg$computePosDetails(pos) { + var details = peg$posDetailsCache[pos]; + var p; + if (details) { + return details; + } else { + p = pos - 1; + while (!peg$posDetailsCache[p]) { + p--; + } + details = peg$posDetailsCache[p]; + details = { + line: details.line, + column: details.column + }; + while (p < pos) { + if (input.charCodeAt(p) === 10) { + details.line++; + details.column = 1; + } else { + details.column++; + } + p++; + } + peg$posDetailsCache[pos] = details; + return details; + } + } + function peg$computeLocation(startPos, endPos, offset2) { + var startPosDetails = peg$computePosDetails(startPos); + var endPosDetails = peg$computePosDetails(endPos); + var res = { + source: peg$source, + start: { + offset: startPos, + line: startPosDetails.line, + column: startPosDetails.column + }, + end: { + offset: endPos, + line: endPosDetails.line, + column: endPosDetails.column + } + }; + return res; + } + function peg$fail(expected2) { + if (peg$currPos < peg$maxFailPos) { + return; + } + if (peg$currPos > peg$maxFailPos) { + peg$maxFailPos = peg$currPos; + peg$maxFailExpected = []; + } + peg$maxFailExpected.push(expected2); + } + function peg$buildStructuredError(expected2, found, location2) { + return new peg$SyntaxError( + peg$SyntaxError.buildMessage(expected2, found), + expected2, + found, + location2 + ); + } + function peg$parsestart() { + var s0, s1, s2, s3; + s0 = peg$currPos; + s1 = peg$parsespec(); + if (s1 !== peg$FAILED) { + s2 = peg$parseEOL(); + if (s2 !== peg$FAILED) { + s0 = peg$f0(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$parsespec_list(); + if (s1 !== peg$FAILED) { + s2 = peg$parseEOL(); + if (s2 !== peg$FAILED) { + s0 = peg$f1(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$parsecolor(); + if (s1 !== peg$FAILED) { + s2 = peg$parseEOL(); + if (s2 !== peg$FAILED) { + s0 = peg$f2(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$parsemodel_list(); + if (s1 !== peg$FAILED) { + s2 = peg$parseEOL(); + if (s2 !== peg$FAILED) { + s0 = peg$f3(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$parsecolor_set_spec(); + if (s1 !== peg$FAILED) { + s2 = peg$parseEOL(); + if (s2 !== peg$FAILED) { + s0 = peg$f4(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$currPos; + s2 = []; + if (input.length > peg$currPos) { + s3 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s3 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + while (s3 !== peg$FAILED) { + s2.push(s3); + if (input.length > peg$currPos) { + s3 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s3 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + } + s1 = input.substring(s1, peg$currPos); + s1 = peg$f5(s1); + s0 = s1; + } + } + } + } + } + return s0; + } + function peg$parsecolor_set_spec() { + var s0, s1, s2, s3, s4, s5; + s0 = peg$currPos; + s1 = peg$parsecolor_set_item(); + if (s1 !== peg$FAILED) { + s2 = []; + s3 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 59) { + s4 = peg$c0; + peg$currPos++; + } else { + s4 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e1); + } + } + if (s4 !== peg$FAILED) { + s5 = peg$parsecolor_set_item(); + if (s5 !== peg$FAILED) { + s3 = peg$f6(s1, s5); + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 59) { + s4 = peg$c0; + peg$currPos++; + } else { + s4 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e1); + } + } + if (s4 !== peg$FAILED) { + s5 = peg$parsecolor_set_item(); + if (s5 !== peg$FAILED) { + s3 = peg$f6(s1, s5); + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } + s0 = peg$f7(s1, s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsecolor_set_item() { + var s0, s1, s2, s3; + s0 = peg$currPos; + s1 = peg$parsename(); + if (s1 !== peg$FAILED) { + if (input.charCodeAt(peg$currPos) === 44) { + s2 = peg$c1; + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e2); + } + } + if (s2 !== peg$FAILED) { + s3 = peg$parsespec_list(); + if (s3 !== peg$FAILED) { + s0 = peg$f8(s1, s3); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsemodel_list() { + var s0, s1, s2, s3; + peg$silentFails++; + s0 = peg$currPos; + s1 = peg$parsecore_model(); + if (s1 !== peg$FAILED) { + if (input.charCodeAt(peg$currPos) === 58) { + s2 = peg$c2; + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e4); + } + } + if (s2 !== peg$FAILED) { + s3 = peg$parsemodel_list_tail(); + if (s3 !== peg$FAILED) { + s0 = peg$f9(s1, s3); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$parsemodel_list_tail(); + if (s1 !== peg$FAILED) { + s1 = peg$f10(s1); + } + s0 = s1; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + return s0; + } + function peg$parsemodel_list_tail() { + var s0, s1, s2, s3, s4, s5; + s0 = peg$currPos; + s1 = peg$parsemodel(); + if (s1 !== peg$FAILED) { + s2 = []; + s3 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 47) { + s4 = peg$c3; + peg$currPos++; + } else { + s4 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e5); + } + } + if (s4 !== peg$FAILED) { + s5 = peg$parsemodel(); + if (s5 !== peg$FAILED) { + s3 = peg$f11(s1, s5); + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 47) { + s4 = peg$c3; + peg$currPos++; + } else { + s4 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e5); + } + } + if (s4 !== peg$FAILED) { + s5 = peg$parsemodel(); + if (s5 !== peg$FAILED) { + s3 = peg$f11(s1, s5); + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } + s0 = peg$f12(s1, s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsemodel() { + var s0; + peg$silentFails++; + s0 = peg$parsecore_model(); + peg$silentFails--; + if (s0 === peg$FAILED) { + if (peg$silentFails === 0) { + peg$fail(peg$e6); + } + } + return s0; + } + function peg$parsespec_list() { + var s0, s1, s2, s3, s4, s5; + peg$silentFails++; + s0 = peg$currPos; + s1 = peg$parsespec(); + if (s1 !== peg$FAILED) { + s2 = []; + s3 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 47) { + s4 = peg$c3; + peg$currPos++; + } else { + s4 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e5); + } + } + if (s4 !== peg$FAILED) { + s5 = peg$parsespec(); + if (s5 !== peg$FAILED) { + s3 = peg$f13(s1, s5); + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 47) { + s4 = peg$c3; + peg$currPos++; + } else { + s4 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e5); + } + } + if (s4 !== peg$FAILED) { + s5 = peg$parsespec(); + if (s5 !== peg$FAILED) { + s3 = peg$f13(s1, s5); + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } + s0 = peg$f14(s1, s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e7); + } + } + return s0; + } + function peg$parsespec() { + var s0, s1, s2, s3, s4, s5, s6, s7, s8; + peg$silentFails++; + s0 = peg$currPos; + s1 = peg$currPos; + s2 = peg$currPos; + s3 = peg$parsehex(); + if (s3 !== peg$FAILED) { + s4 = peg$parsehex(); + if (s4 !== peg$FAILED) { + s5 = peg$parsehex(); + if (s5 !== peg$FAILED) { + s6 = peg$parsehex(); + if (s6 !== peg$FAILED) { + s7 = peg$parsehex(); + if (s7 !== peg$FAILED) { + s8 = peg$parsehex(); + if (s8 !== peg$FAILED) { + s3 = [s3, s4, s5, s6, s7, s8]; + s2 = s3; + } else { + peg$currPos = s2; + s2 = peg$FAILED; + } + } else { + peg$currPos = s2; + s2 = peg$FAILED; + } + } else { + peg$currPos = s2; + s2 = peg$FAILED; + } + } else { + peg$currPos = s2; + s2 = peg$FAILED; + } + } else { + peg$currPos = s2; + s2 = peg$FAILED; + } + } else { + peg$currPos = s2; + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s1 = input.substring(s1, peg$currPos); + } else { + s1 = s2; + } + if (s1 !== peg$FAILED) { + s1 = peg$f15(s1); + } + s0 = s1; + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$parsedec(); + if (s1 !== peg$FAILED) { + s2 = []; + s3 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 44) { + s4 = peg$c1; + peg$currPos++; + } else { + s4 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e2); + } + } + if (s4 !== peg$FAILED) { + s5 = peg$parsedec(); + if (s5 !== peg$FAILED) { + s3 = peg$f16(s1, s5); + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + if (s3 !== peg$FAILED) { + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 44) { + s4 = peg$c1; + peg$currPos++; + } else { + s4 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e2); + } + } + if (s4 !== peg$FAILED) { + s5 = peg$parsedec(); + if (s5 !== peg$FAILED) { + s3 = peg$f16(s1, s5); + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } + } else { + s2 = peg$FAILED; + } + if (s2 === peg$FAILED) { + s2 = []; + s3 = peg$currPos; + s4 = peg$parsesp(); + if (s4 !== peg$FAILED) { + s5 = peg$parsedec(); + if (s5 !== peg$FAILED) { + s3 = peg$f17(s1, s5); + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + if (s3 !== peg$FAILED) { + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$currPos; + s4 = peg$parsesp(); + if (s4 !== peg$FAILED) { + s5 = peg$parsedec(); + if (s5 !== peg$FAILED) { + s3 = peg$f17(s1, s5); + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } + } else { + s2 = peg$FAILED; + } + } + if (s2 === peg$FAILED) { + s2 = null; + } + s0 = peg$f18(s1, s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e8); + } + } + return s0; + } + function peg$parsecolor() { + var s0, s1, s2, s3; + peg$silentFails++; + s0 = peg$currPos; + s1 = peg$parsecolor_expr(); + if (s1 !== peg$FAILED) { + s2 = []; + s3 = peg$parsefunc_expr(); + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$parsefunc_expr(); + } + s0 = peg$f19(s1, s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e9); + } + } + return s0; + } + function peg$parsecolor_expr() { + var s0; + s0 = peg$parseext_expr(); + if (s0 === peg$FAILED) { + s0 = peg$parseexpr(); + if (s0 === peg$FAILED) { + s0 = peg$parsename(); + } + } + return s0; + } + function peg$parsefunc_expr() { + var s0, s1, s2, s3, s4, s5, s6; + peg$silentFails++; + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 62) { + s1 = peg$c4; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e11); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$parsefunction(); + if (s2 !== peg$FAILED) { + s3 = []; + s4 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 44) { + s5 = peg$c1; + peg$currPos++; + } else { + s5 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e2); + } + } + if (s5 !== peg$FAILED) { + s6 = peg$parseint(); + if (s6 !== peg$FAILED) { + s4 = peg$f20(s2, s6); + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + while (s4 !== peg$FAILED) { + s3.push(s4); + s4 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 44) { + s5 = peg$c1; + peg$currPos++; + } else { + s5 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e2); + } + } + if (s5 !== peg$FAILED) { + s6 = peg$parseint(); + if (s6 !== peg$FAILED) { + s4 = peg$f20(s2, s6); + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + } + s0 = peg$f21(s2, s3); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e10); + } + } + return s0; + } + function peg$parsefunction() { + var s0; + peg$silentFails++; + s0 = peg$parsename(); + peg$silentFails--; + if (s0 === peg$FAILED) { + if (peg$silentFails === 0) { + peg$fail(peg$e12); + } + } + return s0; + } + function peg$parseext_expr() { + var s0, s1, s2, s3, s4, s5, s6, s7; + peg$silentFails++; + s0 = peg$currPos; + s1 = peg$parsecore_model(); + if (s1 !== peg$FAILED) { + if (input.charCodeAt(peg$currPos) === 44) { + s2 = peg$c1; + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e2); + } + } + if (s2 !== peg$FAILED) { + s3 = peg$parsediv(); + if (s3 !== peg$FAILED) { + if (input.charCodeAt(peg$currPos) === 58) { + s4 = peg$c2; + peg$currPos++; + } else { + s4 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e4); + } + } + if (s4 !== peg$FAILED) { + s5 = peg$parseweighted_expr(); + if (s5 !== peg$FAILED) { + s6 = []; + s7 = peg$parseadditional_weighted_expr(); + while (s7 !== peg$FAILED) { + s6.push(s7); + s7 = peg$parseadditional_weighted_expr(); + } + s0 = peg$f22(s1, s3, s5, s6); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$parsecore_model(); + if (s1 !== peg$FAILED) { + if (input.charCodeAt(peg$currPos) === 58) { + s2 = peg$c2; + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e4); + } + } + if (s2 !== peg$FAILED) { + s3 = peg$parseweighted_expr(); + if (s3 !== peg$FAILED) { + s4 = []; + s5 = peg$parseadditional_weighted_expr(); + while (s5 !== peg$FAILED) { + s4.push(s5); + s5 = peg$parseadditional_weighted_expr(); + } + s0 = peg$f23(s1, s3, s4); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e13); + } + } + return s0; + } + function peg$parseweighted_expr() { + var s0, s1, s2, s3; + s0 = peg$currPos; + s1 = peg$parseexpr(); + if (s1 !== peg$FAILED) { + if (input.charCodeAt(peg$currPos) === 44) { + s2 = peg$c1; + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e2); + } + } + if (s2 !== peg$FAILED) { + s3 = peg$parsedec(); + if (s3 !== peg$FAILED) { + s0 = peg$f24(s1, s3); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parseadditional_weighted_expr() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 59) { + s1 = peg$c0; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e1); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$parseweighted_expr(); + if (s2 !== peg$FAILED) { + s0 = peg$f25(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsecore_model() { + var s0; + peg$silentFails++; + s0 = peg$parsename(); + peg$silentFails--; + if (s0 === peg$FAILED) { + if (peg$silentFails === 0) { + peg$fail(peg$e14); + } + } + return s0; + } + function peg$parseexpr() { + var s0, s1, s2, s3, s4; + peg$silentFails++; + s0 = peg$currPos; + s1 = peg$parseprefix(); + s2 = peg$parsename(); + if (s2 !== peg$FAILED) { + s3 = peg$parsemix_expr(); + s4 = peg$parsepostfix(); + if (s4 === peg$FAILED) { + s4 = null; + } + s0 = peg$f26(s1, s2, s3, s4); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e15); + } + } + return s0; + } + function peg$parsecomplete_mix() { + var s0, s1, s2, s3, s4; + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 33) { + s1 = peg$c5; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e16); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$parsepct(); + if (s2 !== peg$FAILED) { + if (input.charCodeAt(peg$currPos) === 33) { + s3 = peg$c5; + peg$currPos++; + } else { + s3 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e16); + } + } + if (s3 !== peg$FAILED) { + s4 = peg$parsename(); + if (s4 !== peg$FAILED) { + s0 = peg$f27(s2, s4); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsepartial_mix() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 33) { + s1 = peg$c5; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e16); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$parsepct(); + if (s2 !== peg$FAILED) { + s0 = peg$f28(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsemix_expr() { + var s0, s1, s2; + peg$silentFails++; + s0 = peg$currPos; + s1 = []; + s2 = peg$parsecomplete_mix(); + while (s2 !== peg$FAILED) { + s1.push(s2); + s2 = peg$parsecomplete_mix(); + } + s2 = peg$parsepartial_mix(); + if (s2 === peg$FAILED) { + s2 = null; + } + s0 = peg$f29(s1, s2); + peg$silentFails--; + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e17); + } + return s0; + } + function peg$parsename() { + var s0, s1, s2; + peg$silentFails++; + if (input.charCodeAt(peg$currPos) === 46) { + s0 = peg$c6; + peg$currPos++; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e19); + } + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = []; + if (peg$r0.test(input.charAt(peg$currPos))) { + s2 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e20); + } + } + if (s2 !== peg$FAILED) { + while (s2 !== peg$FAILED) { + s1.push(s2); + if (peg$r0.test(input.charAt(peg$currPos))) { + s2 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e20); + } + } + } + } else { + s1 = peg$FAILED; + } + if (s1 !== peg$FAILED) { + s0 = input.substring(s0, peg$currPos); + } else { + s0 = s1; + } + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e18); + } + } + return s0; + } + function peg$parsepostfix() { + var s0, s1, s2, s3, s4; + peg$silentFails++; + s0 = peg$currPos; + if (input.substr(peg$currPos, 3) === peg$c7) { + s1 = peg$c7; + peg$currPos += 3; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e22); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$parsenum(); + if (s2 !== peg$FAILED) { + if (input.charCodeAt(peg$currPos) === 93) { + s3 = peg$c8; + peg$currPos++; + } else { + s3 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e23); + } + } + if (s3 !== peg$FAILED) { + s0 = peg$f30(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + if (input.substr(peg$currPos, 2) === peg$c9) { + s1 = peg$c9; + peg$currPos += 2; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e24); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$currPos; + s3 = []; + s4 = peg$parseplus(); + if (s4 !== peg$FAILED) { + while (s4 !== peg$FAILED) { + s3.push(s4); + s4 = peg$parseplus(); + } + } else { + s3 = peg$FAILED; + } + if (s3 !== peg$FAILED) { + s2 = input.substring(s2, peg$currPos); + } else { + s2 = s3; + } + if (s2 !== peg$FAILED) { + s0 = peg$f31(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e21); + } + } + return s0; + } + function peg$parseprefix() { + var s0; + peg$silentFails++; + s0 = peg$parseminus(); + if (s0 === peg$FAILED) { + s0 = null; + } + peg$silentFails--; + if (peg$silentFails === 0) { + peg$fail(peg$e25); + } + return s0; + } + function peg$parseplus() { + var s0, s1, s2; + peg$silentFails++; + s0 = peg$currPos; + s1 = []; + if (input.charCodeAt(peg$currPos) === 43) { + s2 = peg$c10; + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e27); + } + } + if (s2 !== peg$FAILED) { + while (s2 !== peg$FAILED) { + s1.push(s2); + if (input.charCodeAt(peg$currPos) === 43) { + s2 = peg$c10; + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e27); + } + } + } + } else { + s1 = peg$FAILED; + } + if (s1 !== peg$FAILED) { + s0 = input.substring(s0, peg$currPos); + } else { + s0 = s1; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e26); + } + } + return s0; + } + function peg$parseminus() { + var s0, s1, s2; + peg$silentFails++; + s0 = peg$currPos; + s1 = []; + if (input.charCodeAt(peg$currPos) === 45) { + s2 = peg$c11; + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e29); + } + } + if (s2 !== peg$FAILED) { + while (s2 !== peg$FAILED) { + s1.push(s2); + if (input.charCodeAt(peg$currPos) === 45) { + s2 = peg$c11; + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e29); + } + } + } + } else { + s1 = peg$FAILED; + } + if (s1 !== peg$FAILED) { + s0 = input.substring(s0, peg$currPos); + } else { + s0 = s1; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e28); + } + } + return s0; + } + function peg$parsenum() { + var s0, s1, s2, s3; + peg$silentFails++; + s0 = peg$currPos; + s1 = peg$currPos; + s2 = []; + if (peg$r1.test(input.charAt(peg$currPos))) { + s3 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s3 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e31); + } + } + if (s3 !== peg$FAILED) { + while (s3 !== peg$FAILED) { + s2.push(s3); + if (peg$r1.test(input.charAt(peg$currPos))) { + s3 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s3 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e31); + } + } + } + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s1 = input.substring(s1, peg$currPos); + } else { + s1 = s2; + } + if (s1 !== peg$FAILED) { + s1 = peg$f32(s1); + } + s0 = s1; + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e30); + } + } + return s0; + } + function peg$parsepct() { + var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9; + peg$silentFails++; + s0 = peg$currPos; + s1 = peg$currPos; + s2 = peg$currPos; + s3 = peg$currPos; + s4 = []; + if (peg$r1.test(input.charAt(peg$currPos))) { + s5 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s5 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e31); + } + } + if (s5 !== peg$FAILED) { + while (s5 !== peg$FAILED) { + s4.push(s5); + if (peg$r1.test(input.charAt(peg$currPos))) { + s5 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s5 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e31); + } + } + } + } else { + s4 = peg$FAILED; + } + if (s4 !== peg$FAILED) { + s3 = input.substring(s3, peg$currPos); + } else { + s3 = s4; + } + if (s3 !== peg$FAILED) { + s4 = peg$currPos; + s5 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 46) { + s6 = peg$c6; + peg$currPos++; + } else { + s6 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e19); + } + } + if (s6 !== peg$FAILED) { + s7 = peg$currPos; + s8 = []; + if (peg$r1.test(input.charAt(peg$currPos))) { + s9 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s9 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e31); + } + } + while (s9 !== peg$FAILED) { + s8.push(s9); + if (peg$r1.test(input.charAt(peg$currPos))) { + s9 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s9 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e31); + } + } + } + s7 = input.substring(s7, peg$currPos); + s6 = [s6, s7]; + s5 = s6; + } else { + peg$currPos = s5; + s5 = peg$FAILED; + } + if (s5 === peg$FAILED) { + s5 = null; + } + s4 = input.substring(s4, peg$currPos); + s3 = [s3, s4]; + s2 = s3; + } else { + peg$currPos = s2; + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s1 = input.substring(s1, peg$currPos); + } else { + s1 = s2; + } + if (s1 === peg$FAILED) { + s1 = peg$currPos; + s2 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 46) { + s3 = peg$c6; + peg$currPos++; + } else { + s3 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e19); + } + } + if (s3 !== peg$FAILED) { + s4 = peg$currPos; + s5 = []; + if (peg$r1.test(input.charAt(peg$currPos))) { + s6 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s6 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e31); + } + } + if (s6 !== peg$FAILED) { + while (s6 !== peg$FAILED) { + s5.push(s6); + if (peg$r1.test(input.charAt(peg$currPos))) { + s6 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s6 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e31); + } + } + } + } else { + s5 = peg$FAILED; + } + if (s5 !== peg$FAILED) { + s4 = input.substring(s4, peg$currPos); + } else { + s4 = s5; + } + if (s4 !== peg$FAILED) { + s3 = [s3, s4]; + s2 = s3; + } else { + peg$currPos = s2; + s2 = peg$FAILED; + } + } else { + peg$currPos = s2; + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s1 = input.substring(s1, peg$currPos); + } else { + s1 = s2; + } + } + if (s1 !== peg$FAILED) { + s1 = peg$f33(s1); + } + s0 = s1; + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e32); + } + } + return s0; + } + function peg$parsediv() { + var s0; + peg$silentFails++; + s0 = peg$parsepct(); + peg$silentFails--; + if (s0 === peg$FAILED) { + if (peg$silentFails === 0) { + peg$fail(peg$e33); + } + } + return s0; + } + function peg$parsedec() { + var s0, s1, s2; + s0 = peg$parsepct(); + if (s0 === peg$FAILED) { + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 43) { + s1 = peg$c10; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e27); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$parsepct(); + if (s2 !== peg$FAILED) { + s0 = peg$f34(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 45) { + s1 = peg$c11; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e29); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$parsepct(); + if (s2 !== peg$FAILED) { + s0 = peg$f35(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } + } + return s0; + } + function peg$parseint() { + var s0, s1, s2; + peg$silentFails++; + s0 = peg$currPos; + s1 = peg$parseminus(); + if (s1 === peg$FAILED) { + s1 = null; + } + s2 = peg$parsenum(); + if (s2 !== peg$FAILED) { + s0 = peg$f36(s1, s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e34); + } + } + return s0; + } + function peg$parsesp() { + var s0, s1; + s0 = []; + if (peg$r2.test(input.charAt(peg$currPos))) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e36); + } + } + if (s1 !== peg$FAILED) { + while (s1 !== peg$FAILED) { + s0.push(s1); + if (peg$r2.test(input.charAt(peg$currPos))) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e36); + } + } + } + } else { + s0 = peg$FAILED; + } + return s0; + } + function peg$parsehex() { + var s0, s1; + s0 = peg$currPos; + if (peg$r3.test(input.charAt(peg$currPos))) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e37); + } + } + if (s1 !== peg$FAILED) { + s1 = peg$f37(s1); + } + s0 = s1; + return s0; + } + function peg$parseEOL() { + var s0, s1; + s0 = peg$currPos; + peg$silentFails++; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + peg$silentFails--; + if (s1 === peg$FAILED) { + s0 = void 0; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + peg$result = peg$startRuleFunction(); + if (peg$result !== peg$FAILED && peg$currPos === input.length) { + return peg$result; + } else { + if (peg$result !== peg$FAILED && peg$currPos < input.length) { + peg$fail(peg$endExpectation()); + } + throw peg$buildStructuredError( + peg$maxFailExpected, + peg$maxFailPos < input.length ? input.charAt(peg$maxFailPos) : null, + peg$maxFailPos < input.length ? peg$computeLocation(peg$maxFailPos, peg$maxFailPos + 1) : peg$computeLocation(peg$maxFailPos, peg$maxFailPos) + ); + } + } + return { + SyntaxError: peg$SyntaxError, + parse: peg$parse + }; + }() +); +const _TabularPegParser = ( + // Generated by Peggy 3.0.2. + // + // https://peggyjs.org/ + function() { + function peg$subclass(child, parent) { + function C() { + this.constructor = child; + } + C.prototype = parent.prototype; + child.prototype = new C(); + } + function peg$SyntaxError(message, expected, found, location) { + var self = Error.call(this, message); + if (Object.setPrototypeOf) { + Object.setPrototypeOf(self, peg$SyntaxError.prototype); + } + self.expected = expected; + self.found = found; + self.location = location; + self.name = "SyntaxError"; + return self; + } + peg$subclass(peg$SyntaxError, Error); + function peg$padEnd(str, targetLength, padString) { + padString = padString || " "; + if (str.length > targetLength) { + return str; + } + targetLength -= str.length; + padString += padString.repeat(targetLength); + return str + padString.slice(0, targetLength); + } + peg$SyntaxError.prototype.format = function(sources) { + var str = "Error: " + this.message; + if (this.location) { + var src = null; + var k; + for (k = 0; k < sources.length; k++) { + if (sources[k].source === this.location.source) { + src = sources[k].text.split(/\r\n|\n|\r/g); + break; + } + } + var s = this.location.start; + var offset_s = this.location.source && typeof this.location.source.offset === "function" ? this.location.source.offset(s) : s; + var loc = this.location.source + ":" + offset_s.line + ":" + offset_s.column; + if (src) { + var e = this.location.end; + var filler = peg$padEnd("", offset_s.line.toString().length, " "); + var line = src[s.line - 1]; + var last = s.line === e.line ? e.column : line.length + 1; + var hatLen = last - s.column || 1; + str += "\n --> " + loc + "\n" + filler + " |\n" + offset_s.line + " | " + line + "\n" + filler + " | " + peg$padEnd("", s.column - 1, " ") + peg$padEnd("", hatLen, "^"); + } else { + str += "\n at " + loc; + } + } + return str; + }; + peg$SyntaxError.buildMessage = function(expected, found) { + var DESCRIBE_EXPECTATION_FNS = { + literal: function(expectation) { + return '"' + literalEscape(expectation.text) + '"'; + }, + class: function(expectation) { + var escapedParts = expectation.parts.map(function(part) { + return Array.isArray(part) ? classEscape(part[0]) + "-" + classEscape(part[1]) : classEscape(part); + }); + return "[" + (expectation.inverted ? "^" : "") + escapedParts.join("") + "]"; + }, + any: function() { + return "any character"; + }, + end: function() { + return "end of input"; + }, + other: function(expectation) { + return expectation.description; + } + }; + function hex(ch) { + return ch.charCodeAt(0).toString(16).toUpperCase(); + } + function literalEscape(s) { + return s.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\0/g, "\\0").replace(/\t/g, "\\t").replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/[\x00-\x0F]/g, function(ch) { + return "\\x0" + hex(ch); + }).replace(/[\x10-\x1F\x7F-\x9F]/g, function(ch) { + return "\\x" + hex(ch); + }); + } + function classEscape(s) { + return s.replace(/\\/g, "\\\\").replace(/\]/g, "\\]").replace(/\^/g, "\\^").replace(/-/g, "\\-").replace(/\0/g, "\\0").replace(/\t/g, "\\t").replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/[\x00-\x0F]/g, function(ch) { + return "\\x0" + hex(ch); + }).replace(/[\x10-\x1F\x7F-\x9F]/g, function(ch) { + return "\\x" + hex(ch); + }); + } + function describeExpectation(expectation) { + return DESCRIBE_EXPECTATION_FNS[expectation.type](expectation); + } + function describeExpected(expected2) { + var descriptions = expected2.map(describeExpectation); + var i, j; + descriptions.sort(); + if (descriptions.length > 0) { + for (i = 1, j = 1; i < descriptions.length; i++) { + if (descriptions[i - 1] !== descriptions[i]) { + descriptions[j] = descriptions[i]; + j++; + } + } + descriptions.length = j; + } + switch (descriptions.length) { + case 1: + return descriptions[0]; + case 2: + return descriptions[0] + " or " + descriptions[1]; + default: + return descriptions.slice(0, -1).join(", ") + ", or " + descriptions[descriptions.length - 1]; + } + } + function describeFound(found2) { + return found2 ? '"' + literalEscape(found2) + '"' : "end of input"; + } + return "Expected " + describeExpected(expected) + " but " + describeFound(found) + " found."; + }; + function peg$parse(input, options) { + options = options !== void 0 ? options : {}; + var peg$FAILED = {}; + var peg$source = options.grammarSource; + var peg$startRuleFunctions = { body: peg$parsebody }; + var peg$startRuleFunction = peg$parsebody; + var peg$e0 = peg$otherExpectation("decl_start"); + var peg$e1 = peg$otherExpectation("decl_end"); + var peg$e2 = peg$otherExpectation("vert"); + var peg$e3 = peg$anyExpectation(); + var peg$e4 = peg$otherExpectation("l"); + var peg$e5 = peg$otherExpectation("r"); + var peg$e6 = peg$otherExpectation("c"); + var peg$e7 = peg$otherExpectation("p"); + var peg$e8 = peg$otherExpectation("m"); + var peg$e9 = peg$otherExpectation("b"); + var peg$e10 = peg$otherExpectation("w"); + var peg$e11 = peg$otherExpectation("W"); + var peg$e12 = peg$otherExpectation("X"); + var peg$e13 = peg$otherExpectation("!"); + var peg$e14 = peg$otherExpectation("@"); + var peg$e15 = peg$otherExpectation("<"); + var peg$e16 = peg$otherExpectation(">"); + var peg$e17 = peg$otherExpectation("group"); + var peg$e18 = peg$otherExpectation("whitespace"); + var peg$f0 = function(c) { + return c; + }; + var peg$f1 = function(cols) { + return cols; + }; + var peg$f2 = function() { + return []; + }; + var peg$f3 = function(divs1, start, a, end, divs2) { + return { + type: "column", + pre_dividers: divs1, + post_dividers: divs2, + before_start_code: start, + before_end_code: end, + alignment: a + }; + }; + var peg$f4 = function() { + return { + type: "vert_divider" + }; + }; + var peg$f5 = function(b, g) { + return { + type: "bang_divider", + content: g[0].content + }; + }; + var peg$f6 = function(g) { + return { + type: "at_divider", + content: g[0].content + }; + }; + var peg$f7 = function(div) { + return div; + }; + var peg$f8 = function(g) { + return { type: "decl_code", code: g[0].content }; + }; + var peg$f9 = function(g) { + return { type: "decl_code", code: g[0].content }; + }; + var peg$f10 = function() { + return { type: "alignment", alignment: "left" }; + }; + var peg$f11 = function() { + return { type: "alignment", alignment: "center" }; + }; + var peg$f12 = function() { + return { type: "alignment", alignment: "right" }; + }; + var peg$f13 = function() { + return { type: "alignment", alignment: "X" }; + }; + var peg$f14 = function() { + return "top"; + }; + var peg$f15 = function() { + return "default"; + }; + var peg$f16 = function() { + return "bottom"; + }; + var peg$f17 = function(a, g) { + return { + type: "alignment", + alignment: "parbox", + baseline: a, + size: g[0].content + }; + }; + var peg$f18 = function(g1, g2) { + return { + type: "alignment", + alignment: "parbox", + baseline: g1[0].content, + size: g2[0].content + }; + }; + var peg$f19 = function(tok) { + return options.matchChar(tok, "|"); + }; + var peg$f20 = function(tok) { + return options.matchChar(tok, "l"); + }; + var peg$f21 = function(tok) { + return options.matchChar(tok, "r"); + }; + var peg$f22 = function(tok) { + return options.matchChar(tok, "c"); + }; + var peg$f23 = function(tok) { + return options.matchChar(tok, "p"); + }; + var peg$f24 = function(tok) { + return options.matchChar(tok, "m"); + }; + var peg$f25 = function(tok) { + return options.matchChar(tok, "b"); + }; + var peg$f26 = function(tok) { + return options.matchChar(tok, "w"); + }; + var peg$f27 = function(tok) { + return options.matchChar(tok, "W"); + }; + var peg$f28 = function(tok) { + return options.matchChar(tok, "X"); + }; + var peg$f29 = function(tok) { + return options.matchChar(tok, "!"); + }; + var peg$f30 = function(tok) { + return options.matchChar(tok, "@"); + }; + var peg$f31 = function(tok) { + return options.matchChar(tok, "<"); + }; + var peg$f32 = function(tok) { + return options.matchChar(tok, ">"); + }; + var peg$f33 = function(tok) { + return options.isGroup(tok); + }; + var peg$f34 = function(tok) { + return options.isWhitespace(tok); + }; + var peg$currPos = 0; + var peg$posDetailsCache = [{ line: 1, column: 1 }]; + var peg$maxFailPos = 0; + var peg$maxFailExpected = []; + var peg$silentFails = 0; + var peg$result; + if ("startRule" in options) { + if (!(options.startRule in peg$startRuleFunctions)) { + throw new Error(`Can't start parsing from rule "` + options.startRule + '".'); + } + peg$startRuleFunction = peg$startRuleFunctions[options.startRule]; + } + function peg$anyExpectation() { + return { type: "any" }; + } + function peg$endExpectation() { + return { type: "end" }; + } + function peg$otherExpectation(description) { + return { type: "other", description }; + } + function peg$computePosDetails(pos) { + var details = peg$posDetailsCache[pos]; + var p; + if (details) { + return details; + } else { + p = pos - 1; + while (!peg$posDetailsCache[p]) { + p--; + } + details = peg$posDetailsCache[p]; + details = { + line: details.line, + column: details.column + }; + while (p < pos) { + if (input.charCodeAt(p) === 10) { + details.line++; + details.column = 1; + } else { + details.column++; + } + p++; + } + peg$posDetailsCache[pos] = details; + return details; + } + } + function peg$computeLocation(startPos, endPos, offset2) { + var startPosDetails = peg$computePosDetails(startPos); + var endPosDetails = peg$computePosDetails(endPos); + var res = { + source: peg$source, + start: { + offset: startPos, + line: startPosDetails.line, + column: startPosDetails.column + }, + end: { + offset: endPos, + line: endPosDetails.line, + column: endPosDetails.column + } + }; + return res; + } + function peg$fail(expected2) { + if (peg$currPos < peg$maxFailPos) { + return; + } + if (peg$currPos > peg$maxFailPos) { + peg$maxFailPos = peg$currPos; + peg$maxFailExpected = []; + } + peg$maxFailExpected.push(expected2); + } + function peg$buildStructuredError(expected2, found, location2) { + return new peg$SyntaxError( + peg$SyntaxError.buildMessage(expected2, found), + expected2, + found, + location2 + ); + } + function peg$parsebody() { + var s0, s1, s2, s3, s4, s5; + s0 = peg$currPos; + s1 = []; + s2 = peg$currPos; + s3 = peg$parsecolumn(); + if (s3 !== peg$FAILED) { + s4 = []; + s5 = peg$parse_(); + while (s5 !== peg$FAILED) { + s4.push(s5); + s5 = peg$parse_(); + } + s2 = peg$f0(s3); + } else { + peg$currPos = s2; + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + while (s2 !== peg$FAILED) { + s1.push(s2); + s2 = peg$currPos; + s3 = peg$parsecolumn(); + if (s3 !== peg$FAILED) { + s4 = []; + s5 = peg$parse_(); + while (s5 !== peg$FAILED) { + s4.push(s5); + s5 = peg$parse_(); + } + s2 = peg$f0(s3); + } else { + peg$currPos = s2; + s2 = peg$FAILED; + } + } + } else { + s1 = peg$FAILED; + } + if (s1 !== peg$FAILED) { + s1 = peg$f1(s1); + } + s0 = s1; + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$parseEOL(); + if (s1 !== peg$FAILED) { + s1 = peg$f2(); + } + s0 = s1; + } + return s0; + } + function peg$parsecolumn() { + var s0, s1, s2, s3, s4, s5, s6; + s0 = peg$currPos; + s1 = []; + s2 = peg$parsecolumn_divider(); + while (s2 !== peg$FAILED) { + s1.push(s2); + s2 = peg$parsecolumn_divider(); + } + s2 = peg$parsedecl_start(); + if (s2 === peg$FAILED) { + s2 = null; + } + s3 = peg$parsealignment(); + if (s3 !== peg$FAILED) { + s4 = peg$parsedecl_end(); + if (s4 === peg$FAILED) { + s4 = null; + } + s5 = []; + s6 = peg$parsecolumn_divider(); + while (s6 !== peg$FAILED) { + s5.push(s6); + s6 = peg$parsecolumn_divider(); + } + s0 = peg$f3(s1, s2, s3, s4, s5); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsecolumn_divider() { + var s0, s1, s2, s3, s4; + s0 = peg$currPos; + s1 = []; + s2 = peg$parse_(); + while (s2 !== peg$FAILED) { + s1.push(s2); + s2 = peg$parse_(); + } + s2 = peg$currPos; + s3 = peg$parsevert(); + if (s3 !== peg$FAILED) { + s3 = peg$f4(); + } + s2 = s3; + if (s2 === peg$FAILED) { + s2 = peg$currPos; + s3 = peg$parsebang(); + if (s3 !== peg$FAILED) { + s4 = peg$parsegroup(); + if (s4 !== peg$FAILED) { + s2 = peg$f5(s3, s4); + } else { + peg$currPos = s2; + s2 = peg$FAILED; + } + } else { + peg$currPos = s2; + s2 = peg$FAILED; + } + if (s2 === peg$FAILED) { + s2 = peg$currPos; + s3 = peg$parseat(); + if (s3 !== peg$FAILED) { + s4 = peg$parsegroup(); + if (s4 !== peg$FAILED) { + s2 = peg$f6(s4); + } else { + peg$currPos = s2; + s2 = peg$FAILED; + } + } else { + peg$currPos = s2; + s2 = peg$FAILED; + } + } + } + if (s2 !== peg$FAILED) { + s3 = []; + s4 = peg$parse_(); + while (s4 !== peg$FAILED) { + s3.push(s4); + s4 = peg$parse_(); + } + s0 = peg$f7(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsedecl_start() { + var s0, s1, s2; + peg$silentFails++; + s0 = peg$currPos; + s1 = peg$parsegreater(); + if (s1 !== peg$FAILED) { + s2 = peg$parsegroup(); + if (s2 !== peg$FAILED) { + s0 = peg$f8(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + return s0; + } + function peg$parsedecl_end() { + var s0, s1, s2; + peg$silentFails++; + s0 = peg$currPos; + s1 = peg$parseless(); + if (s1 !== peg$FAILED) { + s2 = peg$parsegroup(); + if (s2 !== peg$FAILED) { + s0 = peg$f9(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e1); + } + } + return s0; + } + function peg$parsealignment() { + var s0, s1, s2, s3, s4, s5; + s0 = peg$currPos; + s1 = peg$parsel(); + if (s1 !== peg$FAILED) { + s1 = peg$f10(); + } + s0 = s1; + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$parsec(); + if (s1 !== peg$FAILED) { + s1 = peg$f11(); + } + s0 = s1; + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$parser(); + if (s1 !== peg$FAILED) { + s1 = peg$f12(); + } + s0 = s1; + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$parseX(); + if (s1 !== peg$FAILED) { + s1 = peg$f13(); + } + s0 = s1; + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$currPos; + s2 = peg$parsep(); + if (s2 !== peg$FAILED) { + s2 = peg$f14(); + } + s1 = s2; + if (s1 === peg$FAILED) { + s1 = peg$currPos; + s2 = peg$parsem(); + if (s2 !== peg$FAILED) { + s2 = peg$f15(); + } + s1 = s2; + if (s1 === peg$FAILED) { + s1 = peg$currPos; + s2 = peg$parseb(); + if (s2 !== peg$FAILED) { + s2 = peg$f16(); + } + s1 = s2; + } + } + if (s1 !== peg$FAILED) { + s2 = []; + s3 = peg$parse_(); + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$parse_(); + } + s3 = peg$parsegroup(); + if (s3 !== peg$FAILED) { + s0 = peg$f17(s1, s3); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$parsew(); + if (s1 === peg$FAILED) { + s1 = peg$parseW(); + } + if (s1 !== peg$FAILED) { + s2 = []; + s3 = peg$parse_(); + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$parse_(); + } + s3 = peg$parsegroup(); + if (s3 !== peg$FAILED) { + s4 = []; + s5 = peg$parse_(); + while (s5 !== peg$FAILED) { + s4.push(s5); + s5 = peg$parse_(); + } + s5 = peg$parsegroup(); + if (s5 !== peg$FAILED) { + s0 = peg$f18(s3, s5); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } + } + } + } + } + return s0; + } + function peg$parsevert() { + var s0, s1, s2; + peg$silentFails++; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f19(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s1 = [s1, s2]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e2); + } + } + return s0; + } + function peg$parsel() { + var s0, s1, s2; + peg$silentFails++; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f20(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s1 = [s1, s2]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e4); + } + } + return s0; + } + function peg$parser() { + var s0, s1, s2; + peg$silentFails++; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f21(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s1 = [s1, s2]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e5); + } + } + return s0; + } + function peg$parsec() { + var s0, s1, s2; + peg$silentFails++; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f22(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s1 = [s1, s2]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e6); + } + } + return s0; + } + function peg$parsep() { + var s0, s1, s2; + peg$silentFails++; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f23(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s1 = [s1, s2]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e7); + } + } + return s0; + } + function peg$parsem() { + var s0, s1, s2; + peg$silentFails++; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f24(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s1 = [s1, s2]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e8); + } + } + return s0; + } + function peg$parseb() { + var s0, s1, s2; + peg$silentFails++; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f25(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s1 = [s1, s2]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e9); + } + } + return s0; + } + function peg$parsew() { + var s0, s1, s2; + peg$silentFails++; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f26(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s1 = [s1, s2]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e10); + } + } + return s0; + } + function peg$parseW() { + var s0, s1, s2; + peg$silentFails++; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f27(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s1 = [s1, s2]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e11); + } + } + return s0; + } + function peg$parseX() { + var s0, s1, s2; + peg$silentFails++; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f28(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s1 = [s1, s2]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e12); + } + } + return s0; + } + function peg$parsebang() { + var s0, s1, s2; + peg$silentFails++; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f29(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s1 = [s1, s2]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e13); + } + } + return s0; + } + function peg$parseat() { + var s0, s1, s2; + peg$silentFails++; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f30(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s1 = [s1, s2]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e14); + } + } + return s0; + } + function peg$parseless() { + var s0, s1, s2; + peg$silentFails++; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f31(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s1 = [s1, s2]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e15); + } + } + return s0; + } + function peg$parsegreater() { + var s0, s1, s2; + peg$silentFails++; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f32(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s1 = [s1, s2]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e16); + } + } + return s0; + } + function peg$parsegroup() { + var s0, s1, s2; + peg$silentFails++; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f33(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s1 = [s1, s2]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e17); + } + } + return s0; + } + function peg$parse_() { + var s0, s1, s2; + peg$silentFails++; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f34(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s1 = [s1, s2]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e18); + } + } + return s0; + } + function peg$parseEOL() { + var s0, s1; + s0 = peg$currPos; + peg$silentFails++; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + peg$silentFails--; + if (s1 === peg$FAILED) { + s0 = void 0; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + if (!options.isHash) { + try { + Object.assign(options, { + matchChar: (node, char) => node.type === "string" && node.content === char, + isGroup: (node) => node.type === "group", + isWhitespace: (node) => node.type === "whitespace" + }); + } catch (e) { + console.warn("Error when initializing parser", e); + } + } + peg$result = peg$startRuleFunction(); + if (peg$result !== peg$FAILED && peg$currPos === input.length) { + return peg$result; + } else { + if (peg$result !== peg$FAILED && peg$currPos < input.length) { + peg$fail(peg$endExpectation()); + } + throw peg$buildStructuredError( + peg$maxFailExpected, + peg$maxFailPos < input.length ? input.charAt(peg$maxFailPos) : null, + peg$maxFailPos < input.length ? peg$computeLocation(peg$maxFailPos, peg$maxFailPos + 1) : peg$computeLocation(peg$maxFailPos, peg$maxFailPos) + ); + } + } + return { + SyntaxError: peg$SyntaxError, + parse: peg$parse + }; + }() +); +const _SystemePegParser = ( + // Generated by Peggy 3.0.2. + // + // https://peggyjs.org/ + function() { + function peg$subclass(child, parent) { + function C() { + this.constructor = child; + } + C.prototype = parent.prototype; + child.prototype = new C(); + } + function peg$SyntaxError(message, expected, found, location) { + var self = Error.call(this, message); + if (Object.setPrototypeOf) { + Object.setPrototypeOf(self, peg$SyntaxError.prototype); + } + self.expected = expected; + self.found = found; + self.location = location; + self.name = "SyntaxError"; + return self; + } + peg$subclass(peg$SyntaxError, Error); + function peg$padEnd(str, targetLength, padString) { + padString = padString || " "; + if (str.length > targetLength) { + return str; + } + targetLength -= str.length; + padString += padString.repeat(targetLength); + return str + padString.slice(0, targetLength); + } + peg$SyntaxError.prototype.format = function(sources) { + var str = "Error: " + this.message; + if (this.location) { + var src = null; + var k; + for (k = 0; k < sources.length; k++) { + if (sources[k].source === this.location.source) { + src = sources[k].text.split(/\r\n|\n|\r/g); + break; + } + } + var s = this.location.start; + var offset_s = this.location.source && typeof this.location.source.offset === "function" ? this.location.source.offset(s) : s; + var loc = this.location.source + ":" + offset_s.line + ":" + offset_s.column; + if (src) { + var e = this.location.end; + var filler = peg$padEnd("", offset_s.line.toString().length, " "); + var line = src[s.line - 1]; + var last = s.line === e.line ? e.column : line.length + 1; + var hatLen = last - s.column || 1; + str += "\n --> " + loc + "\n" + filler + " |\n" + offset_s.line + " | " + line + "\n" + filler + " | " + peg$padEnd("", s.column - 1, " ") + peg$padEnd("", hatLen, "^"); + } else { + str += "\n at " + loc; + } + } + return str; + }; + peg$SyntaxError.buildMessage = function(expected, found) { + var DESCRIBE_EXPECTATION_FNS = { + literal: function(expectation) { + return '"' + literalEscape(expectation.text) + '"'; + }, + class: function(expectation) { + var escapedParts = expectation.parts.map(function(part) { + return Array.isArray(part) ? classEscape(part[0]) + "-" + classEscape(part[1]) : classEscape(part); + }); + return "[" + (expectation.inverted ? "^" : "") + escapedParts.join("") + "]"; + }, + any: function() { + return "any character"; + }, + end: function() { + return "end of input"; + }, + other: function(expectation) { + return expectation.description; + } + }; + function hex(ch) { + return ch.charCodeAt(0).toString(16).toUpperCase(); + } + function literalEscape(s) { + return s.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\0/g, "\\0").replace(/\t/g, "\\t").replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/[\x00-\x0F]/g, function(ch) { + return "\\x0" + hex(ch); + }).replace(/[\x10-\x1F\x7F-\x9F]/g, function(ch) { + return "\\x" + hex(ch); + }); + } + function classEscape(s) { + return s.replace(/\\/g, "\\\\").replace(/\]/g, "\\]").replace(/\^/g, "\\^").replace(/-/g, "\\-").replace(/\0/g, "\\0").replace(/\t/g, "\\t").replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/[\x00-\x0F]/g, function(ch) { + return "\\x0" + hex(ch); + }).replace(/[\x10-\x1F\x7F-\x9F]/g, function(ch) { + return "\\x" + hex(ch); + }); + } + function describeExpectation(expectation) { + return DESCRIBE_EXPECTATION_FNS[expectation.type](expectation); + } + function describeExpected(expected2) { + var descriptions = expected2.map(describeExpectation); + var i, j; + descriptions.sort(); + if (descriptions.length > 0) { + for (i = 1, j = 1; i < descriptions.length; i++) { + if (descriptions[i - 1] !== descriptions[i]) { + descriptions[j] = descriptions[i]; + j++; + } + } + descriptions.length = j; + } + switch (descriptions.length) { + case 1: + return descriptions[0]; + case 2: + return descriptions[0] + " or " + descriptions[1]; + default: + return descriptions.slice(0, -1).join(", ") + ", or " + descriptions[descriptions.length - 1]; + } + } + function describeFound(found2) { + return found2 ? '"' + literalEscape(found2) + '"' : "end of input"; + } + return "Expected " + describeExpected(expected) + " but " + describeFound(found) + " found."; + }; + function peg$parse(input, options) { + options = options !== void 0 ? options : {}; + var peg$FAILED = {}; + var peg$source = options.grammarSource; + var peg$startRuleFunctions = { body: peg$parsebody }; + var peg$startRuleFunction = peg$parsebody; + var peg$e1 = peg$otherExpectation("item"); + var peg$e2 = peg$anyExpectation(); + var peg$e3 = peg$otherExpectation("equation"); + var peg$e4 = peg$otherExpectation("trailing comment"); + var peg$e5 = peg$otherExpectation("comment only line"); + var peg$e6 = peg$otherExpectation("non-var token"); + var peg$e7 = peg$otherExpectation("token"); + var peg$e8 = peg$otherExpectation("same line comment"); + var peg$e9 = peg$otherExpectation("own line comment"); + var peg$e10 = peg$otherExpectation(","); + var peg$e11 = peg$otherExpectation("@"); + var peg$e12 = peg$otherExpectation("variable token"); + var peg$e13 = peg$otherExpectation("+/-"); + var peg$e14 = peg$otherExpectation("="); + var peg$f0 = function(a, b) { + return a.concat(b ? b : []); + }; + var peg$f1 = function() { + return []; + }; + var peg$f3 = function(op, a, b, c) { + return { type: "item", op, variable: b, content: a.concat(b, c) }; + }; + var peg$f4 = function(op, a) { + return { type: "item", op, variable: null, content: a }; + }; + var peg$f5 = function(line, sep, comment) { + return { ...line, sep: [].concat(sep), trailingComment: comment }; + }; + var peg$f6 = function(line, comment) { + return { ...line, trailingComment: comment }; + }; + var peg$f7 = function(eq, ann) { + return { + type: "line", + equation: eq, + annotation: ann, + sep: null + }; + }; + var peg$f8 = function(at, ann) { + return at ? { type: "annotation", marker: at, content: ann } : null; + }; + var peg$f9 = function(left, eq, right) { + return { type: "equation", left, right, equals: eq }; + }; + var peg$f10 = function(x) { + return x; + }; + var peg$f11 = function(x) { + return { + type: "line", + trailingComment: x + }; + }; + var peg$f12 = function(v, s) { + return [v].concat(s ? s : []); + }; + var peg$f13 = function(t) { + return t; + }; + var peg$f14 = function(x) { + return x; + }; + var peg$f15 = function(x) { + return x; + }; + var peg$f16 = function(tok) { + return options.isSameLineComment(tok); + }; + var peg$f17 = function(tok) { + return tok; + }; + var peg$f18 = function(tok) { + return options.isOwnLineComment(tok); + }; + var peg$f19 = function(tok) { + return tok; + }; + var peg$f20 = function(tok) { + return options.isWhitespace(tok); + }; + var peg$f21 = function(tok) { + return tok; + }; + var peg$f22 = function(tok) { + return options.isSep(tok); + }; + var peg$f23 = function(tok) { + return tok; + }; + var peg$f24 = function(tok) { + return options.isAt(tok); + }; + var peg$f25 = function(tok) { + return tok; + }; + var peg$f26 = function(tok) { + return options.isVar(tok); + }; + var peg$f27 = function(tok) { + return tok; + }; + var peg$f28 = function(tok) { + return options.isOperation(tok); + }; + var peg$f29 = function(tok) { + return tok; + }; + var peg$f30 = function(tok) { + return options.isEquals(tok); + }; + var peg$f31 = function(tok) { + return tok; + }; + var peg$f32 = function(tok) { + return options.isSubscript(tok); + }; + var peg$f33 = function(tok) { + return tok; + }; + var peg$currPos = 0; + var peg$posDetailsCache = [{ line: 1, column: 1 }]; + var peg$maxFailPos = 0; + var peg$maxFailExpected = []; + var peg$silentFails = 0; + var peg$result; + if ("startRule" in options) { + if (!(options.startRule in peg$startRuleFunctions)) { + throw new Error(`Can't start parsing from rule "` + options.startRule + '".'); + } + peg$startRuleFunction = peg$startRuleFunctions[options.startRule]; + } + function peg$anyExpectation() { + return { type: "any" }; + } + function peg$endExpectation() { + return { type: "end" }; + } + function peg$otherExpectation(description) { + return { type: "other", description }; + } + function peg$computePosDetails(pos) { + var details = peg$posDetailsCache[pos]; + var p; + if (details) { + return details; + } else { + p = pos - 1; + while (!peg$posDetailsCache[p]) { + p--; + } + details = peg$posDetailsCache[p]; + details = { + line: details.line, + column: details.column + }; + while (p < pos) { + if (input.charCodeAt(p) === 10) { + details.line++; + details.column = 1; + } else { + details.column++; + } + p++; + } + peg$posDetailsCache[pos] = details; + return details; + } + } + function peg$computeLocation(startPos, endPos, offset2) { + var startPosDetails = peg$computePosDetails(startPos); + var endPosDetails = peg$computePosDetails(endPos); + var res = { + source: peg$source, + start: { + offset: startPos, + line: startPosDetails.line, + column: startPosDetails.column + }, + end: { + offset: endPos, + line: endPosDetails.line, + column: endPosDetails.column + } + }; + return res; + } + function peg$fail(expected2) { + if (peg$currPos < peg$maxFailPos) { + return; + } + if (peg$currPos > peg$maxFailPos) { + peg$maxFailPos = peg$currPos; + peg$maxFailExpected = []; + } + peg$maxFailExpected.push(expected2); + } + function peg$buildStructuredError(expected2, found, location2) { + return new peg$SyntaxError( + peg$SyntaxError.buildMessage(expected2, found), + expected2, + found, + location2 + ); + } + function peg$parsebody() { + var s0, s1, s2; + s0 = peg$currPos; + s1 = []; + s2 = peg$parsecomment_only_line(); + if (s2 === peg$FAILED) { + s2 = peg$parseline_with_sep(); + if (s2 === peg$FAILED) { + s2 = peg$parsepartial_line_with_comment(); + } + } + while (s2 !== peg$FAILED) { + s1.push(s2); + s2 = peg$parsecomment_only_line(); + if (s2 === peg$FAILED) { + s2 = peg$parseline_with_sep(); + if (s2 === peg$FAILED) { + s2 = peg$parsepartial_line_with_comment(); + } + } + } + s2 = peg$parseline_without_sep(); + if (s2 === peg$FAILED) { + s2 = peg$parseEOL(); + } + if (s2 !== peg$FAILED) { + s0 = peg$f0(s1, s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$parseEOL(); + if (s1 !== peg$FAILED) { + s1 = peg$f1(); + } + s0 = s1; + } + return s0; + } + function peg$parseitem() { + var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9; + peg$silentFails++; + s0 = peg$currPos; + s1 = peg$parseoperation(); + if (s1 === peg$FAILED) { + s1 = null; + } + s2 = []; + s3 = peg$parse_(); + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$parse_(); + } + s3 = []; + s4 = peg$parsenon_var_token(); + while (s4 !== peg$FAILED) { + s3.push(s4); + s4 = peg$parsenon_var_token(); + } + s4 = []; + s5 = peg$parse_(); + while (s5 !== peg$FAILED) { + s4.push(s5); + s5 = peg$parse_(); + } + s5 = peg$parsevar(); + if (s5 !== peg$FAILED) { + s6 = []; + s7 = peg$parse_(); + while (s7 !== peg$FAILED) { + s6.push(s7); + s7 = peg$parse_(); + } + s7 = []; + s8 = peg$parsetoken(); + while (s8 !== peg$FAILED) { + s7.push(s8); + s8 = peg$parsetoken(); + } + s8 = []; + s9 = peg$parse_(); + while (s9 !== peg$FAILED) { + s8.push(s9); + s9 = peg$parse_(); + } + s0 = peg$f3(s1, s3, s5, s7); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$parseoperation(); + if (s1 === peg$FAILED) { + s1 = null; + } + s2 = []; + s3 = peg$parse_(); + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$parse_(); + } + s3 = []; + s4 = peg$parsenon_var_token(); + if (s4 !== peg$FAILED) { + while (s4 !== peg$FAILED) { + s3.push(s4); + s4 = peg$parsenon_var_token(); + } + } else { + s3 = peg$FAILED; + } + if (s3 !== peg$FAILED) { + s4 = []; + s5 = peg$parse_(); + while (s5 !== peg$FAILED) { + s4.push(s5); + s5 = peg$parse_(); + } + s0 = peg$f4(s1, s3); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e1); + } + } + return s0; + } + function peg$parseline_with_sep() { + var s0, s1, s2, s3; + s0 = peg$currPos; + s1 = peg$parseline_without_sep(); + if (s1 !== peg$FAILED) { + s2 = peg$parsesep(); + if (s2 !== peg$FAILED) { + s3 = peg$parsetrailing_comment(); + if (s3 === peg$FAILED) { + s3 = null; + } + s0 = peg$f5(s1, s2, s3); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsepartial_line_with_comment() { + var s0, s1, s2; + s0 = peg$currPos; + s1 = peg$parseline_without_sep(); + if (s1 !== peg$FAILED) { + s2 = peg$parsetrailing_comment(); + if (s2 !== peg$FAILED) { + s0 = peg$f6(s1, s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parseline_without_sep() { + var s0, s1, s2, s3; + s0 = peg$currPos; + s1 = peg$currPos; + peg$silentFails++; + if (input.length > peg$currPos) { + s2 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e2); + } + } + peg$silentFails--; + if (s2 !== peg$FAILED) { + peg$currPos = s1; + s1 = void 0; + } else { + s1 = peg$FAILED; + } + if (s1 !== peg$FAILED) { + s2 = peg$parseequation(); + s3 = peg$parseannotation(); + if (s3 === peg$FAILED) { + s3 = null; + } + s0 = peg$f7(s2, s3); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parseannotation() { + var s0, s1, s2, s3; + s0 = peg$currPos; + s1 = peg$parseat(); + if (s1 !== peg$FAILED) { + s2 = []; + s3 = peg$parsenon_sep_token(); + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$parsenon_sep_token(); + } + s0 = peg$f8(s1, s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parseequation() { + var s0, s1, s2, s3, s4; + peg$silentFails++; + s0 = peg$currPos; + s1 = []; + s2 = peg$parseitem(); + while (s2 !== peg$FAILED) { + s1.push(s2); + s2 = peg$parseitem(); + } + s2 = peg$parseequals(); + if (s2 === peg$FAILED) { + s2 = null; + } + s3 = []; + s4 = peg$parsetoken(); + if (s4 === peg$FAILED) { + s4 = peg$parseoperation(); + } + while (s4 !== peg$FAILED) { + s3.push(s4); + s4 = peg$parsetoken(); + if (s4 === peg$FAILED) { + s4 = peg$parseoperation(); + } + } + s0 = peg$f9(s1, s2, s3); + peg$silentFails--; + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + return s0; + } + function peg$parsetrailing_comment() { + var s0, s1, s2; + peg$silentFails++; + s0 = peg$currPos; + s1 = []; + s2 = peg$parse_(); + while (s2 !== peg$FAILED) { + s1.push(s2); + s2 = peg$parse_(); + } + s2 = peg$parsesame_line_comment(); + if (s2 !== peg$FAILED) { + s0 = peg$f10(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e4); + } + } + return s0; + } + function peg$parsecomment_only_line() { + var s0, s1, s2; + peg$silentFails++; + s0 = peg$currPos; + s1 = []; + s2 = peg$parse_(); + while (s2 !== peg$FAILED) { + s1.push(s2); + s2 = peg$parse_(); + } + s2 = peg$parseown_line_comment(); + if (s2 !== peg$FAILED) { + s0 = peg$f11(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e5); + } + } + return s0; + } + function peg$parsevar() { + var s0, s1, s2, s3; + s0 = peg$currPos; + s1 = peg$parsevar_token(); + if (s1 !== peg$FAILED) { + s2 = []; + s3 = peg$parse_(); + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$parse_(); + } + s3 = peg$parsesubscript(); + if (s3 === peg$FAILED) { + s3 = null; + } + s0 = peg$f12(s1, s3); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsenon_var_token() { + var s0, s1, s2; + peg$silentFails++; + s0 = peg$currPos; + s1 = peg$currPos; + peg$silentFails++; + s2 = peg$parsevar(); + peg$silentFails--; + if (s2 === peg$FAILED) { + s1 = void 0; + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + if (s1 !== peg$FAILED) { + s2 = peg$parsetoken(); + if (s2 !== peg$FAILED) { + s0 = peg$f13(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e6); + } + } + return s0; + } + function peg$parsenon_sep_token() { + var s0, s1, s2; + s0 = peg$currPos; + s1 = peg$currPos; + peg$silentFails++; + s2 = peg$parsesep(); + if (s2 === peg$FAILED) { + s2 = peg$parsetrailing_comment(); + if (s2 === peg$FAILED) { + s2 = peg$parseown_line_comment(); + } + } + peg$silentFails--; + if (s2 === peg$FAILED) { + s1 = void 0; + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + if (s1 !== peg$FAILED) { + if (input.length > peg$currPos) { + s2 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e2); + } + } + if (s2 !== peg$FAILED) { + s0 = peg$f14(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsetoken() { + var s0, s1, s2; + peg$silentFails++; + s0 = peg$currPos; + s1 = peg$currPos; + peg$silentFails++; + s2 = peg$parsesep(); + if (s2 === peg$FAILED) { + s2 = peg$parseat(); + if (s2 === peg$FAILED) { + s2 = peg$parseoperation(); + if (s2 === peg$FAILED) { + s2 = peg$parseequals(); + if (s2 === peg$FAILED) { + s2 = peg$parsetrailing_comment(); + if (s2 === peg$FAILED) { + s2 = peg$parseown_line_comment(); + } + } + } + } + } + peg$silentFails--; + if (s2 === peg$FAILED) { + s1 = void 0; + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + if (s1 !== peg$FAILED) { + if (input.length > peg$currPos) { + s2 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e2); + } + } + if (s2 !== peg$FAILED) { + s0 = peg$f15(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e7); + } + } + return s0; + } + function peg$parsesame_line_comment() { + var s0, s1, s2; + peg$silentFails++; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e2); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f16(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s0 = peg$f17(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e8); + } + } + return s0; + } + function peg$parseown_line_comment() { + var s0, s1, s2; + peg$silentFails++; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e2); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f18(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s0 = peg$f19(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e9); + } + } + return s0; + } + function peg$parse_() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e2); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f20(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s0 = peg$f21(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsesep() { + var s0, s1, s2; + peg$silentFails++; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e2); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f22(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s0 = peg$f23(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e10); + } + } + return s0; + } + function peg$parseat() { + var s0, s1, s2; + peg$silentFails++; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e2); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f24(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s0 = peg$f25(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e11); + } + } + return s0; + } + function peg$parsevar_token() { + var s0, s1, s2; + peg$silentFails++; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e2); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f26(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s0 = peg$f27(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e12); + } + } + return s0; + } + function peg$parseoperation() { + var s0, s1, s2, s3, s4; + peg$silentFails++; + s0 = peg$currPos; + s1 = []; + s2 = peg$parse_(); + while (s2 !== peg$FAILED) { + s1.push(s2); + s2 = peg$parse_(); + } + if (input.length > peg$currPos) { + s2 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e2); + } + } + if (s2 !== peg$FAILED) { + s3 = []; + s4 = peg$parse_(); + while (s4 !== peg$FAILED) { + s3.push(s4); + s4 = peg$parse_(); + } + s4 = peg$f28(s2); + if (s4) { + s4 = void 0; + } else { + s4 = peg$FAILED; + } + if (s4 !== peg$FAILED) { + s0 = peg$f29(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e13); + } + } + return s0; + } + function peg$parseequals() { + var s0, s1, s2; + peg$silentFails++; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e2); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f30(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s0 = peg$f31(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e14); + } + } + return s0; + } + function peg$parsesubscript() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e2); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f32(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s0 = peg$f33(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parseEOL() { + var s0, s1; + s0 = peg$currPos; + peg$silentFails++; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e2); + } + } + peg$silentFails--; + if (s1 === peg$FAILED) { + s0 = void 0; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + if (!options.isWhitespace) { + try { + Object.assign(options, { + isSep: (node) => node.type === "string" && node.content === ",", + isVar: (node) => node.type === "string" && node.content.match(/[a-zA-Z]/), + isOperation: (node) => node.type === "string" && node.content.match(/[+-]/), + isEquals: (node) => node.type === "string" && node.content === "=", + isAt: (node) => node.type === "string" && node.content === "@", + isSubscript: (node) => node.content === "_", + isWhitespace: (node) => node.type === "whitespace", + isSameLineComment: (node) => node.type === "comment" && node.sameline, + isOwnLineComment: (node) => node.type === "comment" && !node.sameline + }); + } catch (e) { + console.warn("Error when initializing parser", e); + } + } + peg$result = peg$startRuleFunction(); + if (peg$result !== peg$FAILED && peg$currPos === input.length) { + return peg$result; + } else { + if (peg$result !== peg$FAILED && peg$currPos < input.length) { + peg$fail(peg$endExpectation()); + } + throw peg$buildStructuredError( + peg$maxFailExpected, + peg$maxFailPos < input.length ? input.charAt(peg$maxFailPos) : null, + peg$maxFailPos < input.length ? peg$computeLocation(peg$maxFailPos, peg$maxFailPos + 1) : peg$computeLocation(peg$maxFailPos, peg$maxFailPos) + ); + } + } + return { + SyntaxError: peg$SyntaxError, + parse: peg$parse + }; + }() +); +const _GluePegParser = ( + // Generated by Peggy 3.0.2. + // + // https://peggyjs.org/ + function() { + function peg$subclass(child, parent) { + function C() { + this.constructor = child; + } + C.prototype = parent.prototype; + child.prototype = new C(); + } + function peg$SyntaxError(message, expected, found, location) { + var self = Error.call(this, message); + if (Object.setPrototypeOf) { + Object.setPrototypeOf(self, peg$SyntaxError.prototype); + } + self.expected = expected; + self.found = found; + self.location = location; + self.name = "SyntaxError"; + return self; + } + peg$subclass(peg$SyntaxError, Error); + function peg$padEnd(str, targetLength, padString) { + padString = padString || " "; + if (str.length > targetLength) { + return str; + } + targetLength -= str.length; + padString += padString.repeat(targetLength); + return str + padString.slice(0, targetLength); + } + peg$SyntaxError.prototype.format = function(sources) { + var str = "Error: " + this.message; + if (this.location) { + var src = null; + var k; + for (k = 0; k < sources.length; k++) { + if (sources[k].source === this.location.source) { + src = sources[k].text.split(/\r\n|\n|\r/g); + break; + } + } + var s = this.location.start; + var offset_s = this.location.source && typeof this.location.source.offset === "function" ? this.location.source.offset(s) : s; + var loc = this.location.source + ":" + offset_s.line + ":" + offset_s.column; + if (src) { + var e = this.location.end; + var filler = peg$padEnd("", offset_s.line.toString().length, " "); + var line = src[s.line - 1]; + var last = s.line === e.line ? e.column : line.length + 1; + var hatLen = last - s.column || 1; + str += "\n --> " + loc + "\n" + filler + " |\n" + offset_s.line + " | " + line + "\n" + filler + " | " + peg$padEnd("", s.column - 1, " ") + peg$padEnd("", hatLen, "^"); + } else { + str += "\n at " + loc; + } + } + return str; + }; + peg$SyntaxError.buildMessage = function(expected, found) { + var DESCRIBE_EXPECTATION_FNS = { + literal: function(expectation) { + return '"' + literalEscape(expectation.text) + '"'; + }, + class: function(expectation) { + var escapedParts = expectation.parts.map(function(part) { + return Array.isArray(part) ? classEscape(part[0]) + "-" + classEscape(part[1]) : classEscape(part); + }); + return "[" + (expectation.inverted ? "^" : "") + escapedParts.join("") + "]"; + }, + any: function() { + return "any character"; + }, + end: function() { + return "end of input"; + }, + other: function(expectation) { + return expectation.description; + } + }; + function hex(ch) { + return ch.charCodeAt(0).toString(16).toUpperCase(); + } + function literalEscape(s) { + return s.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\0/g, "\\0").replace(/\t/g, "\\t").replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/[\x00-\x0F]/g, function(ch) { + return "\\x0" + hex(ch); + }).replace(/[\x10-\x1F\x7F-\x9F]/g, function(ch) { + return "\\x" + hex(ch); + }); + } + function classEscape(s) { + return s.replace(/\\/g, "\\\\").replace(/\]/g, "\\]").replace(/\^/g, "\\^").replace(/-/g, "\\-").replace(/\0/g, "\\0").replace(/\t/g, "\\t").replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/[\x00-\x0F]/g, function(ch) { + return "\\x0" + hex(ch); + }).replace(/[\x10-\x1F\x7F-\x9F]/g, function(ch) { + return "\\x" + hex(ch); + }); + } + function describeExpectation(expectation) { + return DESCRIBE_EXPECTATION_FNS[expectation.type](expectation); + } + function describeExpected(expected2) { + var descriptions = expected2.map(describeExpectation); + var i, j; + descriptions.sort(); + if (descriptions.length > 0) { + for (i = 1, j = 1; i < descriptions.length; i++) { + if (descriptions[i - 1] !== descriptions[i]) { + descriptions[j] = descriptions[i]; + j++; + } + } + descriptions.length = j; + } + switch (descriptions.length) { + case 1: + return descriptions[0]; + case 2: + return descriptions[0] + " or " + descriptions[1]; + default: + return descriptions.slice(0, -1).join(", ") + ", or " + descriptions[descriptions.length - 1]; + } + } + function describeFound(found2) { + return found2 ? '"' + literalEscape(found2) + '"' : "end of input"; + } + return "Expected " + describeExpected(expected) + " but " + describeFound(found) + " found."; + }; + function peg$parse(input, options) { + options = options !== void 0 ? options : {}; + var peg$FAILED = {}; + var peg$source = options.grammarSource; + var peg$startRuleFunctions = { root: peg$parseroot }; + var peg$startRuleFunction = peg$parseroot; + var peg$c0 = "plus"; + var peg$c1 = "minus"; + var peg$c2 = "pt"; + var peg$c3 = "mm"; + var peg$c4 = "cm"; + var peg$c5 = "in"; + var peg$c6 = "ex"; + var peg$c7 = "em"; + var peg$c8 = "bp"; + var peg$c9 = "pc"; + var peg$c10 = "dd"; + var peg$c11 = "cc"; + var peg$c12 = "nd"; + var peg$c13 = "nc"; + var peg$c14 = "sp"; + var peg$c15 = "filll"; + var peg$c16 = "fill"; + var peg$c17 = "fil"; + var peg$c18 = "."; + var peg$c19 = "+"; + var peg$c20 = "-"; + var peg$r0 = /^[0-9]/; + var peg$e0 = peg$anyExpectation(); + var peg$e1 = peg$literalExpectation("plus", false); + var peg$e2 = peg$literalExpectation("minus", false); + var peg$e3 = peg$literalExpectation("pt", false); + var peg$e4 = peg$literalExpectation("mm", false); + var peg$e5 = peg$literalExpectation("cm", false); + var peg$e6 = peg$literalExpectation("in", false); + var peg$e7 = peg$literalExpectation("ex", false); + var peg$e8 = peg$literalExpectation("em", false); + var peg$e9 = peg$literalExpectation("bp", false); + var peg$e10 = peg$literalExpectation("pc", false); + var peg$e11 = peg$literalExpectation("dd", false); + var peg$e12 = peg$literalExpectation("cc", false); + var peg$e13 = peg$literalExpectation("nd", false); + var peg$e14 = peg$literalExpectation("nc", false); + var peg$e15 = peg$literalExpectation("sp", false); + var peg$e16 = peg$literalExpectation("filll", false); + var peg$e17 = peg$literalExpectation("fill", false); + var peg$e18 = peg$literalExpectation("fil", false); + var peg$e19 = peg$otherExpectation("number"); + var peg$e20 = peg$classExpectation([["0", "9"]], false, false); + var peg$e21 = peg$literalExpectation(".", false); + var peg$e22 = peg$literalExpectation("+", false); + var peg$e23 = peg$literalExpectation("-", false); + var peg$f0 = function(b, st, sh) { + return { + type: "glue", + fixed: b, + stretchable: st, + shrinkable: sh, + position: location() + }; + }; + var peg$f1 = function(glue) { + return glue; + }; + var peg$f2 = function(n, u) { + return { type: "dim", value: n, unit: u }; + }; + var peg$f3 = function(n, u) { + return { type: "dim", value: n, unit: u }; + }; + var peg$f4 = function(n, u) { + return { type: "dim", value: n, unit: u }; + }; + var peg$f5 = function(n) { + return parseFloat(n); + }; + var peg$currPos = 0; + var peg$savedPos = 0; + var peg$posDetailsCache = [{ line: 1, column: 1 }]; + var peg$maxFailPos = 0; + var peg$maxFailExpected = []; + var peg$silentFails = 0; + var peg$result; + if ("startRule" in options) { + if (!(options.startRule in peg$startRuleFunctions)) { + throw new Error(`Can't start parsing from rule "` + options.startRule + '".'); + } + peg$startRuleFunction = peg$startRuleFunctions[options.startRule]; + } + function location() { + return peg$computeLocation(peg$savedPos, peg$currPos); + } + function peg$literalExpectation(text2, ignoreCase) { + return { type: "literal", text: text2, ignoreCase }; + } + function peg$classExpectation(parts, inverted, ignoreCase) { + return { type: "class", parts, inverted, ignoreCase }; + } + function peg$anyExpectation() { + return { type: "any" }; + } + function peg$endExpectation() { + return { type: "end" }; + } + function peg$otherExpectation(description) { + return { type: "other", description }; + } + function peg$computePosDetails(pos) { + var details = peg$posDetailsCache[pos]; + var p; + if (details) { + return details; + } else { + p = pos - 1; + while (!peg$posDetailsCache[p]) { + p--; + } + details = peg$posDetailsCache[p]; + details = { + line: details.line, + column: details.column + }; + while (p < pos) { + if (input.charCodeAt(p) === 10) { + details.line++; + details.column = 1; + } else { + details.column++; + } + p++; + } + peg$posDetailsCache[pos] = details; + return details; + } + } + function peg$computeLocation(startPos, endPos, offset2) { + var startPosDetails = peg$computePosDetails(startPos); + var endPosDetails = peg$computePosDetails(endPos); + var res = { + source: peg$source, + start: { + offset: startPos, + line: startPosDetails.line, + column: startPosDetails.column + }, + end: { + offset: endPos, + line: endPosDetails.line, + column: endPosDetails.column + } + }; + return res; + } + function peg$fail(expected2) { + if (peg$currPos < peg$maxFailPos) { + return; + } + if (peg$currPos > peg$maxFailPos) { + peg$maxFailPos = peg$currPos; + peg$maxFailExpected = []; + } + peg$maxFailExpected.push(expected2); + } + function peg$buildStructuredError(expected2, found, location2) { + return new peg$SyntaxError( + peg$SyntaxError.buildMessage(expected2, found), + expected2, + found, + location2 + ); + } + function peg$parseroot() { + var s0, s1, s2, s3, s4; + s0 = peg$currPos; + s1 = peg$currPos; + s2 = peg$parsebase(); + if (s2 !== peg$FAILED) { + s3 = peg$parsestretchable(); + if (s3 === peg$FAILED) { + s3 = null; + } + s4 = peg$parseshrinkable(); + if (s4 === peg$FAILED) { + s4 = null; + } + peg$savedPos = s1; + s1 = peg$f0(s2, s3, s4); + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + if (s1 !== peg$FAILED) { + s2 = []; + if (input.length > peg$currPos) { + s3 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s3 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + while (s3 !== peg$FAILED) { + s2.push(s3); + if (input.length > peg$currPos) { + s3 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s3 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + } + peg$savedPos = s0; + s0 = peg$f1(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsebase() { + var s0, s1, s2; + s0 = peg$currPos; + s1 = peg$parsenumber(); + if (s1 !== peg$FAILED) { + s2 = peg$parseunit(); + if (s2 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f2(s1, s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsestretchable() { + var s0, s1, s2, s3; + s0 = peg$currPos; + if (input.substr(peg$currPos, 4) === peg$c0) { + s1 = peg$c0; + peg$currPos += 4; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e1); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$parsenumber(); + if (s2 !== peg$FAILED) { + s3 = peg$parserubber_unit(); + if (s3 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f3(s2, s3); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parseshrinkable() { + var s0, s1, s2, s3; + s0 = peg$currPos; + if (input.substr(peg$currPos, 5) === peg$c1) { + s1 = peg$c1; + peg$currPos += 5; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e2); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$parsenumber(); + if (s2 !== peg$FAILED) { + s3 = peg$parserubber_unit(); + if (s3 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f4(s2, s3); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parseunit() { + var s0; + if (input.substr(peg$currPos, 2) === peg$c2) { + s0 = peg$c2; + peg$currPos += 2; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s0 === peg$FAILED) { + if (input.substr(peg$currPos, 2) === peg$c3) { + s0 = peg$c3; + peg$currPos += 2; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e4); + } + } + if (s0 === peg$FAILED) { + if (input.substr(peg$currPos, 2) === peg$c4) { + s0 = peg$c4; + peg$currPos += 2; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e5); + } + } + if (s0 === peg$FAILED) { + if (input.substr(peg$currPos, 2) === peg$c5) { + s0 = peg$c5; + peg$currPos += 2; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e6); + } + } + if (s0 === peg$FAILED) { + if (input.substr(peg$currPos, 2) === peg$c6) { + s0 = peg$c6; + peg$currPos += 2; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e7); + } + } + if (s0 === peg$FAILED) { + if (input.substr(peg$currPos, 2) === peg$c7) { + s0 = peg$c7; + peg$currPos += 2; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e8); + } + } + if (s0 === peg$FAILED) { + if (input.substr(peg$currPos, 2) === peg$c8) { + s0 = peg$c8; + peg$currPos += 2; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e9); + } + } + if (s0 === peg$FAILED) { + if (input.substr(peg$currPos, 2) === peg$c9) { + s0 = peg$c9; + peg$currPos += 2; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e10); + } + } + if (s0 === peg$FAILED) { + if (input.substr(peg$currPos, 2) === peg$c10) { + s0 = peg$c10; + peg$currPos += 2; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e11); + } + } + if (s0 === peg$FAILED) { + if (input.substr(peg$currPos, 2) === peg$c11) { + s0 = peg$c11; + peg$currPos += 2; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e12); + } + } + if (s0 === peg$FAILED) { + if (input.substr(peg$currPos, 2) === peg$c12) { + s0 = peg$c12; + peg$currPos += 2; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e13); + } + } + if (s0 === peg$FAILED) { + if (input.substr(peg$currPos, 2) === peg$c13) { + s0 = peg$c13; + peg$currPos += 2; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e14); + } + } + if (s0 === peg$FAILED) { + if (input.substr(peg$currPos, 2) === peg$c14) { + s0 = peg$c14; + peg$currPos += 2; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e15); + } + } + } + } + } + } + } + } + } + } + } + } + } + } + return s0; + } + function peg$parserubber_unit() { + var s0; + s0 = peg$parseunit(); + if (s0 === peg$FAILED) { + if (input.substr(peg$currPos, 5) === peg$c15) { + s0 = peg$c15; + peg$currPos += 5; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e16); + } + } + if (s0 === peg$FAILED) { + if (input.substr(peg$currPos, 4) === peg$c16) { + s0 = peg$c16; + peg$currPos += 4; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e17); + } + } + if (s0 === peg$FAILED) { + if (input.substr(peg$currPos, 3) === peg$c17) { + s0 = peg$c17; + peg$currPos += 3; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e18); + } + } + } + } + } + return s0; + } + function peg$parsenumber() { + var s0, s1, s2, s3, s4, s5, s6, s7, s8; + peg$silentFails++; + s0 = peg$currPos; + s1 = peg$currPos; + s2 = peg$currPos; + s3 = peg$parsesign(); + if (s3 === peg$FAILED) { + s3 = null; + } + s4 = peg$currPos; + s5 = []; + if (peg$r0.test(input.charAt(peg$currPos))) { + s6 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s6 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e20); + } + } + while (s6 !== peg$FAILED) { + s5.push(s6); + if (peg$r0.test(input.charAt(peg$currPos))) { + s6 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s6 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e20); + } + } + } + if (input.charCodeAt(peg$currPos) === 46) { + s6 = peg$c18; + peg$currPos++; + } else { + s6 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e21); + } + } + if (s6 !== peg$FAILED) { + s7 = []; + if (peg$r0.test(input.charAt(peg$currPos))) { + s8 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s8 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e20); + } + } + if (s8 !== peg$FAILED) { + while (s8 !== peg$FAILED) { + s7.push(s8); + if (peg$r0.test(input.charAt(peg$currPos))) { + s8 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s8 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e20); + } + } + } + } else { + s7 = peg$FAILED; + } + if (s7 !== peg$FAILED) { + s5 = [s5, s6, s7]; + s4 = s5; + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + if (s4 === peg$FAILED) { + s4 = []; + if (peg$r0.test(input.charAt(peg$currPos))) { + s5 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s5 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e20); + } + } + if (s5 !== peg$FAILED) { + while (s5 !== peg$FAILED) { + s4.push(s5); + if (peg$r0.test(input.charAt(peg$currPos))) { + s5 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s5 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e20); + } + } + } + } else { + s4 = peg$FAILED; + } + } + if (s4 !== peg$FAILED) { + s3 = [s3, s4]; + s2 = s3; + } else { + peg$currPos = s2; + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s1 = input.substring(s1, peg$currPos); + } else { + s1 = s2; + } + if (s1 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$f5(s1); + } + s0 = s1; + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e19); + } + } + return s0; + } + function peg$parsesign() { + var s0; + if (input.charCodeAt(peg$currPos) === 43) { + s0 = peg$c19; + peg$currPos++; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e22); + } + } + if (s0 === peg$FAILED) { + if (input.charCodeAt(peg$currPos) === 45) { + s0 = peg$c20; + peg$currPos++; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e23); + } + } + } + return s0; + } + peg$result = peg$startRuleFunction(); + if (peg$result !== peg$FAILED && peg$currPos === input.length) { + return peg$result; + } else { + if (peg$result !== peg$FAILED && peg$currPos < input.length) { + peg$fail(peg$endExpectation()); + } + throw peg$buildStructuredError( + peg$maxFailExpected, + peg$maxFailPos < input.length ? input.charAt(peg$maxFailPos) : null, + peg$maxFailPos < input.length ? peg$computeLocation(peg$maxFailPos, peg$maxFailPos + 1) : peg$computeLocation(peg$maxFailPos, peg$maxFailPos) + ); + } + } + return { + SyntaxError: peg$SyntaxError, + parse: peg$parse + }; + }() +); +const _TikzPegParser = ( + // Generated by Peggy 3.0.2. + // + // https://peggyjs.org/ + function() { + function peg$subclass(child, parent) { + function C() { + this.constructor = child; + } + C.prototype = parent.prototype; + child.prototype = new C(); + } + function peg$SyntaxError(message, expected, found, location) { + var self = Error.call(this, message); + if (Object.setPrototypeOf) { + Object.setPrototypeOf(self, peg$SyntaxError.prototype); + } + self.expected = expected; + self.found = found; + self.location = location; + self.name = "SyntaxError"; + return self; + } + peg$subclass(peg$SyntaxError, Error); + function peg$padEnd(str, targetLength, padString) { + padString = padString || " "; + if (str.length > targetLength) { + return str; + } + targetLength -= str.length; + padString += padString.repeat(targetLength); + return str + padString.slice(0, targetLength); + } + peg$SyntaxError.prototype.format = function(sources) { + var str = "Error: " + this.message; + if (this.location) { + var src = null; + var k; + for (k = 0; k < sources.length; k++) { + if (sources[k].source === this.location.source) { + src = sources[k].text.split(/\r\n|\n|\r/g); + break; + } + } + var s = this.location.start; + var offset_s = this.location.source && typeof this.location.source.offset === "function" ? this.location.source.offset(s) : s; + var loc = this.location.source + ":" + offset_s.line + ":" + offset_s.column; + if (src) { + var e = this.location.end; + var filler = peg$padEnd("", offset_s.line.toString().length, " "); + var line = src[s.line - 1]; + var last = s.line === e.line ? e.column : line.length + 1; + var hatLen = last - s.column || 1; + str += "\n --> " + loc + "\n" + filler + " |\n" + offset_s.line + " | " + line + "\n" + filler + " | " + peg$padEnd("", s.column - 1, " ") + peg$padEnd("", hatLen, "^"); + } else { + str += "\n at " + loc; + } + } + return str; + }; + peg$SyntaxError.buildMessage = function(expected, found) { + var DESCRIBE_EXPECTATION_FNS = { + literal: function(expectation) { + return '"' + literalEscape(expectation.text) + '"'; + }, + class: function(expectation) { + var escapedParts = expectation.parts.map(function(part) { + return Array.isArray(part) ? classEscape(part[0]) + "-" + classEscape(part[1]) : classEscape(part); + }); + return "[" + (expectation.inverted ? "^" : "") + escapedParts.join("") + "]"; + }, + any: function() { + return "any character"; + }, + end: function() { + return "end of input"; + }, + other: function(expectation) { + return expectation.description; + } + }; + function hex(ch) { + return ch.charCodeAt(0).toString(16).toUpperCase(); + } + function literalEscape(s) { + return s.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\0/g, "\\0").replace(/\t/g, "\\t").replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/[\x00-\x0F]/g, function(ch) { + return "\\x0" + hex(ch); + }).replace(/[\x10-\x1F\x7F-\x9F]/g, function(ch) { + return "\\x" + hex(ch); + }); + } + function classEscape(s) { + return s.replace(/\\/g, "\\\\").replace(/\]/g, "\\]").replace(/\^/g, "\\^").replace(/-/g, "\\-").replace(/\0/g, "\\0").replace(/\t/g, "\\t").replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/[\x00-\x0F]/g, function(ch) { + return "\\x0" + hex(ch); + }).replace(/[\x10-\x1F\x7F-\x9F]/g, function(ch) { + return "\\x" + hex(ch); + }); + } + function describeExpectation(expectation) { + return DESCRIBE_EXPECTATION_FNS[expectation.type](expectation); + } + function describeExpected(expected2) { + var descriptions = expected2.map(describeExpectation); + var i, j; + descriptions.sort(); + if (descriptions.length > 0) { + for (i = 1, j = 1; i < descriptions.length; i++) { + if (descriptions[i - 1] !== descriptions[i]) { + descriptions[j] = descriptions[i]; + j++; + } + } + descriptions.length = j; + } + switch (descriptions.length) { + case 1: + return descriptions[0]; + case 2: + return descriptions[0] + " or " + descriptions[1]; + default: + return descriptions.slice(0, -1).join(", ") + ", or " + descriptions[descriptions.length - 1]; + } + } + function describeFound(found2) { + return found2 ? '"' + literalEscape(found2) + '"' : "end of input"; + } + return "Expected " + describeExpected(expected) + " but " + describeFound(found) + " found."; + }; + function peg$parse(input, options) { + options = options !== void 0 ? options : {}; + var peg$FAILED = {}; + var peg$source = options.grammarSource; + var peg$startRuleFunctions = { path_spec: peg$parsepath_spec, foreach_body: peg$parseforeach_body }; + var peg$startRuleFunction = peg$parsepath_spec; + var peg$e0 = peg$anyExpectation(); + var peg$e3 = peg$otherExpectation("comment"); + var peg$e4 = peg$otherExpectation("floating comment"); + var peg$e5 = peg$otherExpectation("operation"); + var peg$e6 = peg$otherExpectation("="); + var peg$f0 = function(v) { + return v; + }; + var peg$f1 = function(ops) { + return { type: "path_spec", content: ops }; + }; + var peg$f2 = function(c1, op, comment) { + return { op, comment }; + }; + var peg$f3 = function(c1, ops, c2, body) { + const comments = [c1, ...ops.map((x) => x.comment), c2].filter( + (x) => x + ); + const attribute = ops.map((x) => x.op.content.content).join(" "); + return { + type: "animation", + comments, + attribute, + content: body.content + }; + }; + var peg$f4 = function(start, b) { + return { ...b, start, type: "foreach" }; + }; + var peg$f5 = function(c1, variables, options2, c2, c3, list, c4, command) { + const comments = [c1, c2, c3, c4].filter((x) => x); + return { + type: "foreach_body", + variables, + options: options2 && options2.content, + list, + command, + comments + }; + }; + var peg$f6 = function(c1, options2, c2, body) { + const comments = [c1, c2].filter((x) => x); + return { + type: "svg_operation", + options: options2 && options2.content, + content: body, + comments + }; + }; + var peg$f7 = function(c1, c2, coord, c3, c4, x) { + return { coord: x, comment: c4 }; + }; + var peg$f8 = function(c1, c2, coord, c3, a, c5) { + const comments = [c1, c2, c3, a && a.comment, c5].filter((x) => x); + return { + type: "curve_to", + controls: a ? [coord, a.coord] : [coord], + comments + }; + }; + var peg$f9 = function() { + return { type: "line_to", command: "|-" }; + }; + var peg$f10 = function() { + return { type: "line_to", command: "-|" }; + }; + var peg$f11 = function() { + return { type: "line_to", command: "--" }; + }; + var peg$f12 = function(prefix, content) { + return { type: "coordinate", content, prefix }; + }; + var peg$f13 = function(content) { + return { type: "square_brace_group", content }; + }; + var peg$f14 = function(v) { + return { type: "unknown", content: v }; + }; + var peg$f19 = function(tok) { + return options.isComment(tok); + }; + var peg$f20 = function(tok) { + return tok; + }; + var peg$f21 = function(tok) { + return options.isWhitespace(tok); + }; + var peg$f22 = function(tok) { + return tok; + }; + var peg$f23 = function(c) { + return c; + }; + var peg$f24 = function(tok) { + return options.isOperation(tok); + }; + var peg$f25 = function(tok) { + return { type: "operation", content: tok }; + }; + var peg$f26 = function(tok) { + return options.isChar(tok, "="); + }; + var peg$f27 = function(tok) { + return tok; + }; + var peg$f28 = function(tok) { + return options.isChar(tok, "["); + }; + var peg$f29 = function(tok) { + return tok; + }; + var peg$f30 = function(tok) { + return options.isChar(tok, "]"); + }; + var peg$f31 = function(tok) { + return tok; + }; + var peg$f32 = function(tok) { + return options.isChar(tok, "("); + }; + var peg$f33 = function(tok) { + return tok; + }; + var peg$f34 = function(tok) { + return options.isChar(tok, ")"); + }; + var peg$f35 = function(tok) { + return tok; + }; + var peg$f36 = function(tok) { + return options.isChar(tok, "+"); + }; + var peg$f37 = function(tok) { + return tok; + }; + var peg$f38 = function(tok) { + return options.isChar(tok, "-"); + }; + var peg$f39 = function(tok) { + return tok; + }; + var peg$f40 = function(tok) { + return options.isChar(tok, "|"); + }; + var peg$f41 = function(tok) { + return tok; + }; + var peg$f42 = function(tok) { + return options.isChar(tok, "."); + }; + var peg$f43 = function(tok) { + return tok; + }; + var peg$f44 = function(tok) { + return options.isChar(tok, "controls"); + }; + var peg$f45 = function(tok) { + return tok; + }; + var peg$f46 = function(tok) { + return options.isChar(tok, "and"); + }; + var peg$f47 = function(tok) { + return tok; + }; + var peg$f48 = function(tok) { + return options.isChar(tok, "svg"); + }; + var peg$f49 = function(tok) { + return tok; + }; + var peg$f50 = function(tok) { + return options.isGroup(tok); + }; + var peg$f51 = function(tok) { + return tok; + }; + var peg$f52 = function(tok) { + return options.isAnyMacro(tok); + }; + var peg$f53 = function(tok) { + return tok; + }; + var peg$f54 = function(tok) { + return options.isChar(tok, "foreach"); + }; + var peg$f55 = function(tok) { + return tok; + }; + var peg$f56 = function(tok) { + return options.isMacro(tok, "foreach"); + }; + var peg$f57 = function(tok) { + return tok; + }; + var peg$f58 = function(tok) { + return options.isChar(tok, "in"); + }; + var peg$f59 = function(tok) { + return tok; + }; + var peg$f60 = function(tok) { + return options.isChar(tok, ":"); + }; + var peg$f61 = function(tok) { + return tok; + }; + var peg$currPos = 0; + var peg$posDetailsCache = [{ line: 1, column: 1 }]; + var peg$maxFailPos = 0; + var peg$maxFailExpected = []; + var peg$silentFails = 0; + var peg$result; + if ("startRule" in options) { + if (!(options.startRule in peg$startRuleFunctions)) { + throw new Error(`Can't start parsing from rule "` + options.startRule + '".'); + } + peg$startRuleFunction = peg$startRuleFunctions[options.startRule]; + } + function peg$anyExpectation() { + return { type: "any" }; + } + function peg$endExpectation() { + return { type: "end" }; + } + function peg$otherExpectation(description) { + return { type: "other", description }; + } + function peg$computePosDetails(pos) { + var details = peg$posDetailsCache[pos]; + var p; + if (details) { + return details; + } else { + p = pos - 1; + while (!peg$posDetailsCache[p]) { + p--; + } + details = peg$posDetailsCache[p]; + details = { + line: details.line, + column: details.column + }; + while (p < pos) { + if (input.charCodeAt(p) === 10) { + details.line++; + details.column = 1; + } else { + details.column++; + } + p++; + } + peg$posDetailsCache[pos] = details; + return details; + } + } + function peg$computeLocation(startPos, endPos, offset2) { + var startPosDetails = peg$computePosDetails(startPos); + var endPosDetails = peg$computePosDetails(endPos); + var res = { + source: peg$source, + start: { + offset: startPos, + line: startPosDetails.line, + column: startPosDetails.column + }, + end: { + offset: endPos, + line: endPosDetails.line, + column: endPosDetails.column + } + }; + return res; + } + function peg$fail(expected2) { + if (peg$currPos < peg$maxFailPos) { + return; + } + if (peg$currPos > peg$maxFailPos) { + peg$maxFailPos = peg$currPos; + peg$maxFailExpected = []; + } + peg$maxFailExpected.push(expected2); + } + function peg$buildStructuredError(expected2, found, location2) { + return new peg$SyntaxError( + peg$SyntaxError.buildMessage(expected2, found), + expected2, + found, + location2 + ); + } + function peg$parsepath_spec() { + var s0, s1, s2, s3, s4, s5; + s0 = peg$currPos; + s1 = []; + s2 = peg$currPos; + s3 = peg$parsesquare_brace_group(); + if (s3 === peg$FAILED) { + s3 = peg$parsecoordinate(); + if (s3 === peg$FAILED) { + s3 = peg$parsecurve_to(); + if (s3 === peg$FAILED) { + s3 = peg$parseline_to(); + if (s3 === peg$FAILED) { + s3 = peg$parsesvg(); + if (s3 === peg$FAILED) { + s3 = peg$parseforeach(); + if (s3 === peg$FAILED) { + s3 = peg$parseoperation(); + if (s3 === peg$FAILED) { + s3 = peg$parsecomment(); + if (s3 === peg$FAILED) { + s3 = peg$parseanimation(); + if (s3 === peg$FAILED) { + s3 = peg$parseunknown(); + } + } + } + } + } + } + } + } + } + if (s3 !== peg$FAILED) { + s4 = []; + s5 = peg$parse_(); + while (s5 !== peg$FAILED) { + s4.push(s5); + s5 = peg$parse_(); + } + s2 = peg$f0(s3); + } else { + peg$currPos = s2; + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + while (s2 !== peg$FAILED) { + s1.push(s2); + s2 = peg$currPos; + s3 = peg$parsesquare_brace_group(); + if (s3 === peg$FAILED) { + s3 = peg$parsecoordinate(); + if (s3 === peg$FAILED) { + s3 = peg$parsecurve_to(); + if (s3 === peg$FAILED) { + s3 = peg$parseline_to(); + if (s3 === peg$FAILED) { + s3 = peg$parsesvg(); + if (s3 === peg$FAILED) { + s3 = peg$parseforeach(); + if (s3 === peg$FAILED) { + s3 = peg$parseoperation(); + if (s3 === peg$FAILED) { + s3 = peg$parsecomment(); + if (s3 === peg$FAILED) { + s3 = peg$parseanimation(); + if (s3 === peg$FAILED) { + s3 = peg$parseunknown(); + } + } + } + } + } + } + } + } + } + if (s3 !== peg$FAILED) { + s4 = []; + s5 = peg$parse_(); + while (s5 !== peg$FAILED) { + s4.push(s5); + s5 = peg$parse_(); + } + s2 = peg$f0(s3); + } else { + peg$currPos = s2; + s2 = peg$FAILED; + } + } + } else { + s1 = peg$FAILED; + } + if (s1 !== peg$FAILED) { + s1 = peg$f1(s1); + } + s0 = s1; + return s0; + } + function peg$parseanimation() { + var s0, s1, s2, s3, s4, s5, s6; + s0 = peg$currPos; + s1 = peg$parsecolon(); + if (s1 !== peg$FAILED) { + s2 = peg$parse_comment_(); + s3 = []; + s4 = peg$currPos; + s5 = peg$parseoperation(); + if (s5 !== peg$FAILED) { + s6 = peg$parse_comment_(); + s4 = peg$f2(s2, s5, s6); + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + if (s4 !== peg$FAILED) { + while (s4 !== peg$FAILED) { + s3.push(s4); + s4 = peg$currPos; + s5 = peg$parseoperation(); + if (s5 !== peg$FAILED) { + s6 = peg$parse_comment_(); + s4 = peg$f2(s2, s5, s6); + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + } + } else { + s3 = peg$FAILED; + } + if (s3 !== peg$FAILED) { + s4 = peg$parseequals(); + if (s4 !== peg$FAILED) { + s5 = peg$parse_comment_(); + s6 = peg$parsegroup(); + if (s6 !== peg$FAILED) { + s0 = peg$f3(s2, s3, s5, s6); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parseforeach() { + var s0, s1, s2; + s0 = peg$currPos; + s1 = peg$parseforeach_keyword(); + if (s1 === peg$FAILED) { + s1 = peg$parseforeach_macro(); + } + if (s1 !== peg$FAILED) { + s2 = peg$parseforeach_body(); + if (s2 !== peg$FAILED) { + s0 = peg$f4(s1, s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parseforeach_body() { + var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9; + s0 = peg$currPos; + s1 = peg$parse_comment_(); + s2 = peg$currPos; + s3 = []; + s4 = peg$currPos; + s5 = peg$currPos; + peg$silentFails++; + s6 = peg$parsein_keyword(); + if (s6 === peg$FAILED) { + s6 = peg$parsesquare_brace_group(); + } + peg$silentFails--; + if (s6 === peg$FAILED) { + s5 = void 0; + } else { + peg$currPos = s5; + s5 = peg$FAILED; + } + if (s5 !== peg$FAILED) { + if (input.length > peg$currPos) { + s6 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s6 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s6 !== peg$FAILED) { + s5 = [s5, s6]; + s4 = s5; + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + while (s4 !== peg$FAILED) { + s3.push(s4); + s4 = peg$currPos; + s5 = peg$currPos; + peg$silentFails++; + s6 = peg$parsein_keyword(); + if (s6 === peg$FAILED) { + s6 = peg$parsesquare_brace_group(); + } + peg$silentFails--; + if (s6 === peg$FAILED) { + s5 = void 0; + } else { + peg$currPos = s5; + s5 = peg$FAILED; + } + if (s5 !== peg$FAILED) { + if (input.length > peg$currPos) { + s6 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s6 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s6 !== peg$FAILED) { + s5 = [s5, s6]; + s4 = s5; + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + } + s2 = input.substring(s2, peg$currPos); + s3 = peg$parsesquare_brace_group(); + if (s3 === peg$FAILED) { + s3 = null; + } + s4 = peg$parse_comment_(); + s5 = peg$parsein_keyword(); + if (s5 !== peg$FAILED) { + s6 = peg$parse_comment_(); + s7 = peg$parsegroup(); + if (s7 === peg$FAILED) { + s7 = peg$parsemacro(); + } + if (s7 !== peg$FAILED) { + s8 = peg$parse_comment_(); + s9 = peg$parseforeach(); + if (s9 === peg$FAILED) { + s9 = peg$parsegroup(); + if (s9 === peg$FAILED) { + s9 = peg$parsemacro(); + } + } + if (s9 !== peg$FAILED) { + s0 = peg$f5(s1, s2, s3, s4, s6, s7, s8, s9); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsesvg() { + var s0, s1, s2, s3, s4, s5; + s0 = peg$currPos; + s1 = peg$parsesvg_keyword(); + if (s1 !== peg$FAILED) { + s2 = peg$parse_comment_(); + s3 = peg$parsesquare_brace_group(); + if (s3 === peg$FAILED) { + s3 = null; + } + s4 = peg$parse_comment_(); + s5 = peg$parsegroup(); + if (s5 !== peg$FAILED) { + s0 = peg$f6(s2, s3, s4, s5); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsecurve_to() { + var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10; + s0 = peg$currPos; + s1 = peg$parsedotdot(); + if (s1 !== peg$FAILED) { + s2 = peg$parse_comment_(); + s3 = peg$parsecontrols_keyword(); + if (s3 !== peg$FAILED) { + s4 = peg$parse_comment_(); + s5 = peg$parsecoordinate(); + if (s5 !== peg$FAILED) { + s6 = peg$parse_comment_(); + s7 = peg$currPos; + s8 = peg$parseand_keyword(); + if (s8 !== peg$FAILED) { + s9 = peg$parse_comment_(); + s10 = peg$parsecoordinate(); + if (s10 !== peg$FAILED) { + s7 = peg$f7(s2, s4, s5, s6, s9, s10); + } else { + peg$currPos = s7; + s7 = peg$FAILED; + } + } else { + peg$currPos = s7; + s7 = peg$FAILED; + } + if (s7 === peg$FAILED) { + s7 = null; + } + s8 = peg$parse_comment_(); + s9 = peg$parsedotdot(); + if (s9 !== peg$FAILED) { + s0 = peg$f8(s2, s4, s5, s6, s7, s8); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parseline_to() { + var s0, s1, s2; + s0 = peg$currPos; + s1 = peg$parsepipe(); + if (s1 !== peg$FAILED) { + s2 = peg$parseminus(); + if (s2 !== peg$FAILED) { + s0 = peg$f9(); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$parseminus(); + if (s1 !== peg$FAILED) { + s2 = peg$parsepipe(); + if (s2 !== peg$FAILED) { + s0 = peg$f10(); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$parseminus(); + if (s1 !== peg$FAILED) { + s2 = peg$parseminus(); + if (s2 !== peg$FAILED) { + s0 = peg$f11(); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } + } + return s0; + } + function peg$parsecoordinate() { + var s0, s1, s2, s3, s4, s5, s6, s7; + s0 = peg$currPos; + s1 = peg$currPos; + s2 = peg$currPos; + s3 = peg$parseplus(); + if (s3 !== peg$FAILED) { + s4 = peg$parseplus(); + if (s4 === peg$FAILED) { + s4 = null; + } + s3 = [s3, s4]; + s2 = s3; + } else { + peg$currPos = s2; + s2 = peg$FAILED; + } + if (s2 === peg$FAILED) { + s2 = null; + } + s1 = input.substring(s1, peg$currPos); + s2 = peg$parseopen_paren(); + if (s2 !== peg$FAILED) { + s3 = peg$currPos; + s4 = []; + s5 = peg$currPos; + s6 = peg$currPos; + peg$silentFails++; + s7 = peg$parseclose_paren(); + peg$silentFails--; + if (s7 === peg$FAILED) { + s6 = void 0; + } else { + peg$currPos = s6; + s6 = peg$FAILED; + } + if (s6 !== peg$FAILED) { + if (input.length > peg$currPos) { + s7 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s7 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s7 !== peg$FAILED) { + s6 = [s6, s7]; + s5 = s6; + } else { + peg$currPos = s5; + s5 = peg$FAILED; + } + } else { + peg$currPos = s5; + s5 = peg$FAILED; + } + while (s5 !== peg$FAILED) { + s4.push(s5); + s5 = peg$currPos; + s6 = peg$currPos; + peg$silentFails++; + s7 = peg$parseclose_paren(); + peg$silentFails--; + if (s7 === peg$FAILED) { + s6 = void 0; + } else { + peg$currPos = s6; + s6 = peg$FAILED; + } + if (s6 !== peg$FAILED) { + if (input.length > peg$currPos) { + s7 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s7 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s7 !== peg$FAILED) { + s6 = [s6, s7]; + s5 = s6; + } else { + peg$currPos = s5; + s5 = peg$FAILED; + } + } else { + peg$currPos = s5; + s5 = peg$FAILED; + } + } + s3 = input.substring(s3, peg$currPos); + s4 = peg$parseclose_paren(); + if (s4 !== peg$FAILED) { + s0 = peg$f12(s1, s3); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsesquare_brace_group() { + var s0, s1, s2, s3, s4, s5, s6; + s0 = peg$currPos; + s1 = peg$parseopen_square_brace(); + if (s1 !== peg$FAILED) { + s2 = peg$currPos; + s3 = []; + s4 = peg$currPos; + s5 = peg$currPos; + peg$silentFails++; + s6 = peg$parseclose_square_brace(); + peg$silentFails--; + if (s6 === peg$FAILED) { + s5 = void 0; + } else { + peg$currPos = s5; + s5 = peg$FAILED; + } + if (s5 !== peg$FAILED) { + if (input.length > peg$currPos) { + s6 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s6 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s6 !== peg$FAILED) { + s5 = [s5, s6]; + s4 = s5; + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + while (s4 !== peg$FAILED) { + s3.push(s4); + s4 = peg$currPos; + s5 = peg$currPos; + peg$silentFails++; + s6 = peg$parseclose_square_brace(); + peg$silentFails--; + if (s6 === peg$FAILED) { + s5 = void 0; + } else { + peg$currPos = s5; + s5 = peg$FAILED; + } + if (s5 !== peg$FAILED) { + if (input.length > peg$currPos) { + s6 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s6 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s6 !== peg$FAILED) { + s5 = [s5, s6]; + s4 = s5; + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + } + s2 = input.substring(s2, peg$currPos); + s3 = peg$parseclose_square_brace(); + if (s3 !== peg$FAILED) { + s0 = peg$f13(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsedotdot() { + var s0, s1, s2; + s0 = peg$currPos; + s1 = peg$parsedot(); + if (s1 !== peg$FAILED) { + s2 = peg$parsedot(); + if (s2 !== peg$FAILED) { + s1 = [s1, s2]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parseunknown() { + var s0, s1; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + s1 = peg$f14(s1); + } + s0 = s1; + return s0; + } + function peg$parsecomment() { + var s0, s1, s2; + peg$silentFails++; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f19(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s0 = peg$f20(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + return s0; + } + function peg$parse_() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f21(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s0 = peg$f22(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parse_comment_() { + var s0, s1, s2, s3, s4; + peg$silentFails++; + s0 = peg$currPos; + s1 = []; + s2 = peg$parse_(); + while (s2 !== peg$FAILED) { + s1.push(s2); + s2 = peg$parse_(); + } + s2 = peg$parsecomment(); + if (s2 === peg$FAILED) { + s2 = null; + } + s3 = []; + s4 = peg$parse_(); + while (s4 !== peg$FAILED) { + s3.push(s4); + s4 = peg$parse_(); + } + s0 = peg$f23(s2); + peg$silentFails--; + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e4); + } + return s0; + } + function peg$parseoperation() { + var s0, s1, s2; + peg$silentFails++; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f24(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s0 = peg$f25(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e5); + } + } + return s0; + } + function peg$parseequals() { + var s0, s1, s2; + peg$silentFails++; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f26(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s0 = peg$f27(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e6); + } + } + return s0; + } + function peg$parseopen_square_brace() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f28(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s0 = peg$f29(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parseclose_square_brace() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f30(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s0 = peg$f31(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parseopen_paren() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f32(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s0 = peg$f33(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parseclose_paren() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f34(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s0 = peg$f35(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parseplus() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f36(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s0 = peg$f37(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parseminus() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f38(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s0 = peg$f39(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsepipe() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f40(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s0 = peg$f41(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsedot() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f42(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s0 = peg$f43(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsecontrols_keyword() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f44(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s0 = peg$f45(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parseand_keyword() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f46(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s0 = peg$f47(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsesvg_keyword() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f48(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s0 = peg$f49(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsegroup() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f50(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s0 = peg$f51(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsemacro() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f52(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s0 = peg$f53(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parseforeach_keyword() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f54(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s0 = peg$f55(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parseforeach_macro() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f56(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s0 = peg$f57(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsein_keyword() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f58(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s0 = peg$f59(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsecolon() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f60(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s0 = peg$f61(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + if (!options.isWhitespace) { + try { + Object.assign(options, { + isChar: (node, char) => node.type === "string" && node.content === char, + isOperation: (node) => node.type === "string" && node.content.match(/[a-zA-Z]/), + isWhitespace: (node) => node.type === "whitespace" || node.type === "parbreak", + isSameLineComment: (node) => node.type === "comment" && node.sameline, + isOwnLineComment: (node) => node.type === "comment" && !node.sameline, + isComment: (node) => node.type === "comment", + isGroup: (node) => node.type === "group", + isMacro: (node, name) => node.type === "macro" && node.content === name, + isAnyMacro: (node) => node.type === "macro" + }); + } catch (e) { + console.warn("Error when initializing parser", e); + } + } + peg$result = peg$startRuleFunction(); + if (peg$result !== peg$FAILED && peg$currPos === input.length) { + return peg$result; + } else { + if (peg$result !== peg$FAILED && peg$currPos < input.length) { + peg$fail(peg$endExpectation()); + } + throw peg$buildStructuredError( + peg$maxFailExpected, + peg$maxFailPos < input.length ? input.charAt(peg$maxFailPos) : null, + peg$maxFailPos < input.length ? peg$computeLocation(peg$maxFailPos, peg$maxFailPos + 1) : peg$computeLocation(peg$maxFailPos, peg$maxFailPos) + ); + } + } + return { + SyntaxError: peg$SyntaxError, + parse: peg$parse + }; + }() +); +const LatexPegParser = _LatexPegParser; +const AlignEnvironmentPegParser = _AlignEnvironmentPegParser; +const ArgSpecPegParser = _ArgSpecPegParser; +const PgfkeysPegParser = _PgfkeysPegParser; +const MacroSubstitutionPegParser = _MacroSubstitutionPegParser; +const LigaturesPegParser = _LigaturesPegParser; +const XColorPegParser = _XColorPegParser; +const TabularPegParser = _TabularPegParser; +const SystemePegParser = _SystemePegParser; +const GluePegParser = _GluePegParser; +const TikzPegParser = _TikzPegParser; +exports.AlignEnvironmentPegParser = AlignEnvironmentPegParser; +exports.ArgSpecPegParser = ArgSpecPegParser; +exports.GluePegParser = GluePegParser; +exports.LatexPegParser = LatexPegParser; +exports.LigaturesPegParser = LigaturesPegParser; +exports.MacroSubstitutionPegParser = MacroSubstitutionPegParser; +exports.PgfkeysPegParser = PgfkeysPegParser; +exports.SystemePegParser = SystemePegParser; +exports.TabularPegParser = TabularPegParser; +exports.TikzPegParser = TikzPegParser; +exports.XColorPegParser = XColorPegParser; +exports.decorateArrayForPegjs = decorateArrayForPegjs; +exports.splitStringsIntoSingleChars = splitStringsIntoSingleChars; +//# sourceMappingURL=index.cjs.map diff --git a/node_modules/@unified-latex/unified-latex-util-pegjs/index.cjs.map b/node_modules/@unified-latex/unified-latex-util-pegjs/index.cjs.map new file mode 100644 index 0000000..2edc814 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-util-pegjs/index.cjs.map @@ -0,0 +1 @@ +{"version":3,"file":"index.cjs","sources":["../libs/decorate-array-for-pegjs.ts","../libs/split-strings.ts","../grammars/latex.pegjs","../grammars/align-environment.pegjs","../grammars/xparse-argspec.pegjs","../grammars/pgfkeys.pegjs","../grammars/macro-substitutions.pegjs","../grammars/ligatures.pegjs","../grammars/xcolor-expressions.pegjs","../grammars/tabular-spec.pegjs","../grammars/systeme-environment.pegjs","../grammars/tex-glue.pegjs","../grammars/tikz.pegjs","../libs/pegjs-parsers.ts"],"sourcesContent":["type StringlikeArray = any[] & string;\n\n/**\n * Pegjs operates on strings. However, strings and arrays are very similar!\n * This function adds `charAt`, `charCodeAt`, and `substring` methods to\n * `array` so that `array` can then be fed to a Pegjs generated parser.\n *\n * @param {[object]} array\n * @returns {[object]}\n */\nexport function decorateArrayForPegjs(array: any[]): StringlikeArray {\n (array as any).charAt = function (i: number) {\n return this[i];\n };\n // We don't have a hope of imitating `charCodeAt`, so\n // make it something that won't interfere\n (array as any).charCodeAt = () => 0;\n (array as any).substring = function (i: number, j: number) {\n return this.slice(i, j);\n };\n // This function is called when reporting an error,\n // so we convert back to a string.\n (array as any).replace = function (a: string, b: string) {\n const ret = JSON.stringify(this);\n return ret.replace(a, b);\n };\n return array as StringlikeArray;\n}\n","import * as Ast from \"@unified-latex/unified-latex-types\";\nimport { match } from \"@unified-latex/unified-latex-util-match\";\n\n/**\n * Splits all multi-character strings into strings that are all single characters.\n */\nexport function splitStringsIntoSingleChars(nodes: Ast.Node[]): Ast.Node[] {\n return nodes.flatMap((node) =>\n match.anyString(node)\n ? (Array.from(node.content).map((c) => ({\n type: \"string\",\n content: c,\n })) as Ast.Node[])\n : node\n );\n}\n","export default (\n // Generated by Peggy 3.0.2.\n //\n // https://peggyjs.org/\n function() {\n \"use strict\";\n function peg$subclass(child, parent) {\n function C() {\n this.constructor = child;\n }\n C.prototype = parent.prototype;\n child.prototype = new C();\n }\n function peg$SyntaxError(message, expected, found, location) {\n var self = Error.call(this, message);\n if (Object.setPrototypeOf) {\n Object.setPrototypeOf(self, peg$SyntaxError.prototype);\n }\n self.expected = expected;\n self.found = found;\n self.location = location;\n self.name = \"SyntaxError\";\n return self;\n }\n peg$subclass(peg$SyntaxError, Error);\n function peg$padEnd(str, targetLength, padString) {\n padString = padString || \" \";\n if (str.length > targetLength) {\n return str;\n }\n targetLength -= str.length;\n padString += padString.repeat(targetLength);\n return str + padString.slice(0, targetLength);\n }\n peg$SyntaxError.prototype.format = function(sources) {\n var str = \"Error: \" + this.message;\n if (this.location) {\n var src = null;\n var k;\n for (k = 0; k < sources.length; k++) {\n if (sources[k].source === this.location.source) {\n src = sources[k].text.split(/\\r\\n|\\n|\\r/g);\n break;\n }\n }\n var s = this.location.start;\n var offset_s = this.location.source && typeof this.location.source.offset === \"function\" ? this.location.source.offset(s) : s;\n var loc = this.location.source + \":\" + offset_s.line + \":\" + offset_s.column;\n if (src) {\n var e = this.location.end;\n var filler = peg$padEnd(\"\", offset_s.line.toString().length, \" \");\n var line = src[s.line - 1];\n var last = s.line === e.line ? e.column : line.length + 1;\n var hatLen = last - s.column || 1;\n str += \"\\n --> \" + loc + \"\\n\" + filler + \" |\\n\" + offset_s.line + \" | \" + line + \"\\n\" + filler + \" | \" + peg$padEnd(\"\", s.column - 1, \" \") + peg$padEnd(\"\", hatLen, \"^\");\n } else {\n str += \"\\n at \" + loc;\n }\n }\n return str;\n };\n peg$SyntaxError.buildMessage = function(expected, found) {\n var DESCRIBE_EXPECTATION_FNS = {\n literal: function(expectation) {\n return '\"' + literalEscape(expectation.text) + '\"';\n },\n class: function(expectation) {\n var escapedParts = expectation.parts.map(function(part) {\n return Array.isArray(part) ? classEscape(part[0]) + \"-\" + classEscape(part[1]) : classEscape(part);\n });\n return \"[\" + (expectation.inverted ? \"^\" : \"\") + escapedParts.join(\"\") + \"]\";\n },\n any: function() {\n return \"any character\";\n },\n end: function() {\n return \"end of input\";\n },\n other: function(expectation) {\n return expectation.description;\n }\n };\n function hex(ch) {\n return ch.charCodeAt(0).toString(16).toUpperCase();\n }\n function literalEscape(s) {\n return s.replace(/\\\\/g, \"\\\\\\\\\").replace(/\"/g, '\\\\\"').replace(/\\0/g, \"\\\\0\").replace(/\\t/g, \"\\\\t\").replace(/\\n/g, \"\\\\n\").replace(/\\r/g, \"\\\\r\").replace(/[\\x00-\\x0F]/g, function(ch) {\n return \"\\\\x0\" + hex(ch);\n }).replace(/[\\x10-\\x1F\\x7F-\\x9F]/g, function(ch) {\n return \"\\\\x\" + hex(ch);\n });\n }\n function classEscape(s) {\n return s.replace(/\\\\/g, \"\\\\\\\\\").replace(/\\]/g, \"\\\\]\").replace(/\\^/g, \"\\\\^\").replace(/-/g, \"\\\\-\").replace(/\\0/g, \"\\\\0\").replace(/\\t/g, \"\\\\t\").replace(/\\n/g, \"\\\\n\").replace(/\\r/g, \"\\\\r\").replace(/[\\x00-\\x0F]/g, function(ch) {\n return \"\\\\x0\" + hex(ch);\n }).replace(/[\\x10-\\x1F\\x7F-\\x9F]/g, function(ch) {\n return \"\\\\x\" + hex(ch);\n });\n }\n function describeExpectation(expectation) {\n return DESCRIBE_EXPECTATION_FNS[expectation.type](expectation);\n }\n function describeExpected(expected2) {\n var descriptions = expected2.map(describeExpectation);\n var i, j;\n descriptions.sort();\n if (descriptions.length > 0) {\n for (i = 1, j = 1; i < descriptions.length; i++) {\n if (descriptions[i - 1] !== descriptions[i]) {\n descriptions[j] = descriptions[i];\n j++;\n }\n }\n descriptions.length = j;\n }\n switch (descriptions.length) {\n case 1:\n return descriptions[0];\n case 2:\n return descriptions[0] + \" or \" + descriptions[1];\n default:\n return descriptions.slice(0, -1).join(\", \") + \", or \" + descriptions[descriptions.length - 1];\n }\n }\n function describeFound(found2) {\n return found2 ? '\"' + literalEscape(found2) + '\"' : \"end of input\";\n }\n return \"Expected \" + describeExpected(expected) + \" but \" + describeFound(found) + \" found.\";\n };\n function peg$parse(input, options) {\n options = options !== void 0 ? options : {};\n var peg$FAILED = {};\n var peg$source = options.grammarSource;\n var peg$startRuleFunctions = { document: peg$parsedocument, math: peg$parsemath };\n var peg$startRuleFunction = peg$parsedocument;\n var peg$c0 = \"%\";\n var peg$c1 = \".\";\n var peg$c2 = \"verb*\";\n var peg$c3 = \"verb\";\n var peg$c4 = \"[\";\n var peg$c5 = \"]\";\n var peg$c6 = \"lstinline\";\n var peg$c7 = \"mintinline\";\n var peg$c8 = \"mint\";\n var peg$c9 = \"minted\";\n var peg$c10 = \"verbatim*\";\n var peg$c11 = \"verbatim\";\n var peg$c12 = \"filecontents*\";\n var peg$c13 = \"filecontents\";\n var peg$c14 = \"comment\";\n var peg$c15 = \"lstlisting\";\n var peg$c16 = \"(\";\n var peg$c17 = \")\";\n var peg$c18 = \"begin\";\n var peg$c19 = \"end\";\n var peg$c20 = \"equation*\";\n var peg$c21 = \"equation\";\n var peg$c22 = \"align*\";\n var peg$c23 = \"align\";\n var peg$c24 = \"alignat*\";\n var peg$c25 = \"alignat\";\n var peg$c26 = \"gather*\";\n var peg$c27 = \"gather\";\n var peg$c28 = \"multline*\";\n var peg$c29 = \"multline\";\n var peg$c30 = \"flalign*\";\n var peg$c31 = \"flalign\";\n var peg$c32 = \"split\";\n var peg$c33 = \"math\";\n var peg$c34 = \"displaymath\";\n var peg$c35 = \"\\\\\";\n var peg$c36 = \"{\";\n var peg$c37 = \"}\";\n var peg$c38 = \"$\";\n var peg$c39 = \"&\";\n var peg$c40 = \"\\r\";\n var peg$c41 = \"\\n\";\n var peg$c42 = \"\\r\\n\";\n var peg$c43 = \"#\";\n var peg$c44 = \"^\";\n var peg$c45 = \"_\";\n var peg$c46 = \"\\0\";\n var peg$r0 = /^[^ \\t\\n\\r]/;\n var peg$r1 = /^[ \\t]/;\n var peg$r2 = /^[a-zA-Z]/;\n var peg$r3 = /^[0-9]/;\n var peg$r4 = /^[.,;:\\-*\\/()!?=+<>[\\]`'\"~]/;\n var peg$e0 = peg$otherExpectation(\"document\");\n var peg$e1 = peg$otherExpectation(\"math\");\n var peg$e2 = peg$otherExpectation(\"token\");\n var peg$e3 = peg$anyExpectation();\n var peg$e4 = peg$otherExpectation(\"parbreak\");\n var peg$e5 = peg$otherExpectation(\"math token\");\n var peg$e6 = peg$otherExpectation(\"nonchar token\");\n var peg$e7 = peg$literalExpectation(\"%\", false);\n var peg$e8 = peg$otherExpectation(\"whitespace\");\n var peg$e9 = peg$otherExpectation(\"number\");\n var peg$e10 = peg$literalExpectation(\".\", false);\n var peg$e11 = peg$otherExpectation(\"special macro\");\n var peg$e12 = peg$literalExpectation(\"verb*\", false);\n var peg$e13 = peg$literalExpectation(\"verb\", false);\n var peg$e14 = peg$literalExpectation(\"[\", false);\n var peg$e15 = peg$literalExpectation(\"]\", false);\n var peg$e16 = peg$classExpectation([\" \", \"\t\", \"\\n\", \"\\r\"], true, false);\n var peg$e17 = peg$otherExpectation(\"verbatim listings\");\n var peg$e18 = peg$literalExpectation(\"lstinline\", false);\n var peg$e19 = peg$otherExpectation(\"verbatim minted\");\n var peg$e20 = peg$literalExpectation(\"mintinline\", false);\n var peg$e21 = peg$literalExpectation(\"mint\", false);\n var peg$e22 = peg$otherExpectation(\"verbatim minted environment\");\n var peg$e23 = peg$literalExpectation(\"minted\", false);\n var peg$e24 = peg$otherExpectation(\"verbatim environment\");\n var peg$e25 = peg$literalExpectation(\"verbatim*\", false);\n var peg$e26 = peg$literalExpectation(\"verbatim\", false);\n var peg$e27 = peg$literalExpectation(\"filecontents*\", false);\n var peg$e28 = peg$literalExpectation(\"filecontents\", false);\n var peg$e29 = peg$literalExpectation(\"comment\", false);\n var peg$e30 = peg$literalExpectation(\"lstlisting\", false);\n var peg$e31 = peg$otherExpectation(\"macro\");\n var peg$e32 = peg$otherExpectation(\"group\");\n var peg$e33 = peg$otherExpectation(\"environment\");\n var peg$e34 = peg$otherExpectation(\"math environment\");\n var peg$e35 = peg$otherExpectation(\"math group\");\n var peg$e36 = peg$literalExpectation(\"(\", false);\n var peg$e37 = peg$literalExpectation(\")\", false);\n var peg$e38 = peg$literalExpectation(\"begin\", false);\n var peg$e39 = peg$literalExpectation(\"end\", false);\n var peg$e40 = peg$literalExpectation(\"equation*\", false);\n var peg$e41 = peg$literalExpectation(\"equation\", false);\n var peg$e42 = peg$literalExpectation(\"align*\", false);\n var peg$e43 = peg$literalExpectation(\"align\", false);\n var peg$e44 = peg$literalExpectation(\"alignat*\", false);\n var peg$e45 = peg$literalExpectation(\"alignat\", false);\n var peg$e46 = peg$literalExpectation(\"gather*\", false);\n var peg$e47 = peg$literalExpectation(\"gather\", false);\n var peg$e48 = peg$literalExpectation(\"multline*\", false);\n var peg$e49 = peg$literalExpectation(\"multline\", false);\n var peg$e50 = peg$literalExpectation(\"flalign*\", false);\n var peg$e51 = peg$literalExpectation(\"flalign\", false);\n var peg$e52 = peg$literalExpectation(\"split\", false);\n var peg$e53 = peg$literalExpectation(\"math\", false);\n var peg$e54 = peg$literalExpectation(\"displaymath\", false);\n var peg$e55 = peg$otherExpectation(\"escape\");\n var peg$e56 = peg$literalExpectation(\"\\\\\", false);\n var peg$e57 = peg$literalExpectation(\"{\", false);\n var peg$e58 = peg$literalExpectation(\"}\", false);\n var peg$e59 = peg$literalExpectation(\"$\", false);\n var peg$e60 = peg$literalExpectation(\"&\", false);\n var peg$e61 = peg$otherExpectation(\"newline\");\n var peg$e62 = peg$literalExpectation(\"\\r\", false);\n var peg$e63 = peg$literalExpectation(\"\\n\", false);\n var peg$e64 = peg$literalExpectation(\"\\r\\n\", false);\n var peg$e65 = peg$literalExpectation(\"#\", false);\n var peg$e66 = peg$literalExpectation(\"^\", false);\n var peg$e67 = peg$literalExpectation(\"_\", false);\n var peg$e68 = peg$literalExpectation(\"\\0\", false);\n var peg$e69 = peg$classExpectation([\" \", \"\t\"], false, false);\n var peg$e70 = peg$otherExpectation(\"letter\");\n var peg$e71 = peg$classExpectation([[\"a\", \"z\"], [\"A\", \"Z\"]], false, false);\n var peg$e72 = peg$otherExpectation(\"digit\");\n var peg$e73 = peg$classExpectation([[\"0\", \"9\"]], false, false);\n var peg$e74 = peg$otherExpectation(\"punctuation\");\n var peg$e75 = peg$classExpectation([\".\", \",\", \";\", \":\", \"-\", \"*\", \"/\", \"(\", \")\", \"!\", \"?\", \"=\", \"+\", \"<\", \">\", \"[\", \"]\", \"`\", \"'\", '\"', \"~\"], false, false);\n var peg$e76 = peg$otherExpectation(\"full comment\");\n var peg$e77 = peg$otherExpectation(\"comment\");\n var peg$f0 = function(content) {\n return createNode(\"root\", { content: content.flatMap((x) => x) });\n };\n var peg$f1 = function(t) {\n return t;\n };\n var peg$f2 = function(eq) {\n return createNode(\"inlinemath\", { content: eq.flatMap((x) => x) });\n };\n var peg$f3 = function(s) {\n return createNode(\"string\", { content: s });\n };\n var peg$f4 = function(s) {\n return createNode(\"string\", { content: s });\n };\n var peg$f5 = function() {\n return createNode(\"parbreak\");\n };\n var peg$f6 = function(x) {\n return x;\n };\n var peg$f7 = function(x) {\n return x;\n };\n var peg$f8 = function() {\n return createNode(\"macro\", { content: \"^\", escapeToken: \"\" });\n };\n var peg$f9 = function() {\n return createNode(\"macro\", { content: \"_\", escapeToken: \"\" });\n };\n var peg$f10 = function(s) {\n return createNode(\"string\", { content: s });\n };\n var peg$f11 = function() {\n return createNode(\"whitespace\");\n };\n var peg$f12 = function(a, b) {\n return a.join(\"\") + \".\" + b.join(\"\");\n };\n var peg$f13 = function(b) {\n return \".\" + b.join(\"\");\n };\n var peg$f14 = function(a) {\n return a.join(\"\") + \".\";\n };\n var peg$f15 = function(s) {\n return createNode(\"string\", { content: s });\n };\n var peg$f16 = function(env, e, end) {\n return end == e;\n };\n var peg$f17 = function(env, e, x) {\n return x;\n };\n var peg$f18 = function(env, e, x, end) {\n return end == e;\n };\n var peg$f19 = function(env, e, x) {\n return createNode(\"verb\", {\n env,\n escape: e,\n content: x.join(\"\")\n });\n };\n var peg$f20 = function(x) {\n return x;\n };\n var peg$f21 = function(x) {\n return createNode(\"displaymath\", { content: x.flatMap((x2) => x2) });\n };\n var peg$f22 = function(x) {\n return x;\n };\n var peg$f23 = function(x) {\n return createNode(\"inlinemath\", { content: x.flatMap((x2) => x2) });\n };\n var peg$f24 = function(x) {\n return x;\n };\n var peg$f25 = function(x) {\n return createNode(\"displaymath\", { content: x.flatMap((x2) => x2) });\n };\n var peg$f26 = function(end) {\n return end.type === \"string\" && end.content === \"]\";\n };\n var peg$f27 = function(x) {\n return x;\n };\n var peg$f28 = function(o) {\n return [\n createNode(\"string\", { content: \"[\" }),\n ...o,\n createNode(\"string\", { content: \"]\" })\n ];\n };\n var peg$f29 = function(x) {\n return x;\n };\n var peg$f30 = function(v) {\n return createNode(\"group\", {\n content: createNode(\"string\", { content: v.join(\"\") })\n });\n };\n var peg$f31 = function(d, end) {\n return end == d;\n };\n var peg$f32 = function(d, x) {\n return x;\n };\n var peg$f33 = function(d, v, end) {\n return end == d;\n };\n var peg$f34 = function(d, v) {\n return [\n createNode(\"string\", { content: d }),\n createNode(\"string\", { content: v.join(\"\") }),\n createNode(\"string\", { content: d })\n ];\n };\n var peg$f35 = function(macro, option, verbatim) {\n return [\n createNode(\"macro\", { content: macro }),\n ...option || [],\n ...[].concat(verbatim)\n ];\n };\n var peg$f36 = function(macro, option, language, verbatim) {\n return [\n createNode(\"macro\", { content: macro }),\n ...option || [],\n language,\n ...[].concat(verbatim)\n ];\n };\n var peg$f37 = function(env, option, language, end_env) {\n return compare_env({ content: [env] }, end_env);\n };\n var peg$f38 = function(env, option, language, body) {\n const content = [\n ...option || [],\n language,\n { type: \"string\", content: body }\n ];\n return createNode(\"environment\", {\n env,\n content\n });\n };\n var peg$f39 = function(env, end_env) {\n return compare_env({ content: [env] }, end_env);\n };\n var peg$f40 = function(env, x) {\n return x;\n };\n var peg$f41 = function(env, body) {\n return createNode(\"verbatim\", {\n env,\n content: body\n });\n };\n var peg$f42 = function(n) {\n return n.join(\"\");\n };\n var peg$f43 = function(n) {\n return n;\n };\n var peg$f44 = function(m) {\n return createNode(\"macro\", { content: m });\n };\n var peg$f45 = function(c) {\n return c;\n };\n var peg$f46 = function(x) {\n return createNode(\"group\", { content: x.flatMap((x2) => x2) });\n };\n var peg$f47 = function(g) {\n return text().slice(1, -1);\n };\n var peg$f48 = function(env, env_comment, end_env) {\n return compare_env(env, end_env);\n };\n var peg$f49 = function(env, env_comment, x) {\n return x;\n };\n var peg$f50 = function(env, env_comment, body) {\n body = body.flatMap((x) => x);\n return createNode(\"environment\", {\n env,\n content: env_comment ? [env_comment, ...body] : body\n });\n };\n var peg$f51 = function(env, env_comment, end_env) {\n return compare_env({ content: [env] }, end_env);\n };\n var peg$f52 = function(env, env_comment, x) {\n return x;\n };\n var peg$f53 = function(env, env_comment, body) {\n body = body.flatMap((x) => x);\n return createNode(\"mathenv\", {\n env,\n content: env_comment ? [env_comment, ...body] : body\n });\n };\n var peg$f54 = function(c) {\n return c;\n };\n var peg$f55 = function(x) {\n return createNode(\"group\", { content: x.flatMap((x2) => x2) });\n };\n var peg$f56 = function(e) {\n return createNode(\"string\", { content: e });\n };\n var peg$f57 = function() {\n return createNode(\"string\", { content: \"\\\\\" });\n };\n var peg$f58 = function(s) {\n return createNode(\"string\", { content: s });\n };\n var peg$f59 = function(s) {\n return createNode(\"string\", { content: s });\n };\n var peg$f60 = function(s) {\n return createNode(\"string\", { content: s });\n };\n var peg$f61 = function(s) {\n return createNode(\"string\", { content: s });\n };\n var peg$f62 = function(s) {\n return createNode(\"string\", { content: s });\n };\n var peg$f63 = function(s) {\n return createNode(\"string\", { content: s });\n };\n var peg$f64 = function(s) {\n return createNode(\"string\", { content: s });\n };\n var peg$f65 = function() {\n return \" \";\n };\n var peg$f66 = function(p) {\n return createNode(\"string\", { content: p });\n };\n var peg$f67 = function(leading_sp, comment) {\n return createNode(\"comment\", {\n ...comment,\n sameline: false,\n leadingWhitespace: leading_sp.length > 0\n });\n };\n var peg$f68 = function(spaces, x) {\n return createNode(\"comment\", {\n ...x,\n sameline: true,\n leadingWhitespace: spaces.length > 0\n });\n };\n var peg$f69 = function(c) {\n return c;\n };\n var peg$f70 = function(c) {\n return { content: c.join(\"\"), suffixParbreak: true };\n };\n var peg$f71 = function(c) {\n return c;\n };\n var peg$f72 = function(c) {\n return { content: c.join(\"\") };\n };\n var peg$f73 = function() {\n var loc = location();\n return loc.start.column === 1;\n };\n var peg$currPos = 0;\n var peg$savedPos = 0;\n var peg$posDetailsCache = [{ line: 1, column: 1 }];\n var peg$maxFailPos = 0;\n var peg$maxFailExpected = [];\n var peg$silentFails = 0;\n var peg$resultsCache = {};\n var peg$result;\n if (\"startRule\" in options) {\n if (!(options.startRule in peg$startRuleFunctions)) {\n throw new Error(`Can't start parsing from rule \"` + options.startRule + '\".');\n }\n peg$startRuleFunction = peg$startRuleFunctions[options.startRule];\n }\n function text() {\n return input.substring(peg$savedPos, peg$currPos);\n }\n function offset() {\n return peg$savedPos;\n }\n function range() {\n return {\n source: peg$source,\n start: peg$savedPos,\n end: peg$currPos\n };\n }\n function location() {\n return peg$computeLocation(peg$savedPos, peg$currPos);\n }\n function expected(description, location2) {\n location2 = location2 !== void 0 ? location2 : peg$computeLocation(peg$savedPos, peg$currPos);\n throw peg$buildStructuredError(\n [peg$otherExpectation(description)],\n input.substring(peg$savedPos, peg$currPos),\n location2\n );\n }\n function error(message, location2) {\n location2 = location2 !== void 0 ? location2 : peg$computeLocation(peg$savedPos, peg$currPos);\n throw peg$buildSimpleError(message, location2);\n }\n function peg$literalExpectation(text2, ignoreCase) {\n return { type: \"literal\", text: text2, ignoreCase };\n }\n function peg$classExpectation(parts, inverted, ignoreCase) {\n return { type: \"class\", parts, inverted, ignoreCase };\n }\n function peg$anyExpectation() {\n return { type: \"any\" };\n }\n function peg$endExpectation() {\n return { type: \"end\" };\n }\n function peg$otherExpectation(description) {\n return { type: \"other\", description };\n }\n function peg$computePosDetails(pos) {\n var details = peg$posDetailsCache[pos];\n var p;\n if (details) {\n return details;\n } else {\n p = pos - 1;\n while (!peg$posDetailsCache[p]) {\n p--;\n }\n details = peg$posDetailsCache[p];\n details = {\n line: details.line,\n column: details.column\n };\n while (p < pos) {\n if (input.charCodeAt(p) === 10) {\n details.line++;\n details.column = 1;\n } else {\n details.column++;\n }\n p++;\n }\n peg$posDetailsCache[pos] = details;\n return details;\n }\n }\n function peg$computeLocation(startPos, endPos, offset2) {\n var startPosDetails = peg$computePosDetails(startPos);\n var endPosDetails = peg$computePosDetails(endPos);\n var res = {\n source: peg$source,\n start: {\n offset: startPos,\n line: startPosDetails.line,\n column: startPosDetails.column\n },\n end: {\n offset: endPos,\n line: endPosDetails.line,\n column: endPosDetails.column\n }\n };\n if (offset2 && peg$source && typeof peg$source.offset === \"function\") {\n res.start = peg$source.offset(res.start);\n res.end = peg$source.offset(res.end);\n }\n return res;\n }\n function peg$fail(expected2) {\n if (peg$currPos < peg$maxFailPos) {\n return;\n }\n if (peg$currPos > peg$maxFailPos) {\n peg$maxFailPos = peg$currPos;\n peg$maxFailExpected = [];\n }\n peg$maxFailExpected.push(expected2);\n }\n function peg$buildSimpleError(message, location2) {\n return new peg$SyntaxError(message, null, null, location2);\n }\n function peg$buildStructuredError(expected2, found, location2) {\n return new peg$SyntaxError(\n peg$SyntaxError.buildMessage(expected2, found),\n expected2,\n found,\n location2\n );\n }\n function peg$parsedocument() {\n var s0, s1, s2;\n var key = peg$currPos * 52 + 0;\n var cached = peg$resultsCache[key];\n if (cached) {\n peg$currPos = cached.nextPos;\n return cached.result;\n }\n peg$silentFails++;\n s0 = peg$currPos;\n s1 = [];\n s2 = peg$parsetoken();\n while (s2 !== peg$FAILED) {\n s1.push(s2);\n s2 = peg$parsetoken();\n }\n peg$savedPos = s0;\n s1 = peg$f0(s1);\n s0 = s1;\n peg$silentFails--;\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };\n return s0;\n }\n function peg$parsemath() {\n var s0, s1;\n var key = peg$currPos * 52 + 1;\n var cached = peg$resultsCache[key];\n if (cached) {\n peg$currPos = cached.nextPos;\n return cached.result;\n }\n peg$silentFails++;\n s0 = [];\n s1 = peg$parsemath_token();\n while (s1 !== peg$FAILED) {\n s0.push(s1);\n s1 = peg$parsemath_token();\n }\n peg$silentFails--;\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e1);\n }\n peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };\n return s0;\n }\n function peg$parsetoken() {\n var s0, s1, s2, s3, s4, s5;\n var key = peg$currPos * 52 + 2;\n var cached = peg$resultsCache[key];\n if (cached) {\n peg$currPos = cached.nextPos;\n return cached.result;\n }\n peg$silentFails++;\n s0 = peg$parsespecial_macro();\n if (s0 === peg$FAILED) {\n s0 = peg$parsemacro();\n if (s0 === peg$FAILED) {\n s0 = peg$parsefull_comment();\n if (s0 === peg$FAILED) {\n s0 = peg$parsegroup();\n if (s0 === peg$FAILED) {\n s0 = peg$currPos;\n s1 = peg$parsemath_shift();\n if (s1 !== peg$FAILED) {\n s2 = [];\n s3 = peg$currPos;\n s4 = peg$currPos;\n peg$silentFails++;\n s5 = peg$parsemath_shift();\n peg$silentFails--;\n if (s5 === peg$FAILED) {\n s4 = void 0;\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n if (s4 !== peg$FAILED) {\n s5 = peg$parsemath_token();\n if (s5 !== peg$FAILED) {\n peg$savedPos = s3;\n s3 = peg$f1(s5);\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n if (s3 !== peg$FAILED) {\n while (s3 !== peg$FAILED) {\n s2.push(s3);\n s3 = peg$currPos;\n s4 = peg$currPos;\n peg$silentFails++;\n s5 = peg$parsemath_shift();\n peg$silentFails--;\n if (s5 === peg$FAILED) {\n s4 = void 0;\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n if (s4 !== peg$FAILED) {\n s5 = peg$parsemath_token();\n if (s5 !== peg$FAILED) {\n peg$savedPos = s3;\n s3 = peg$f1(s5);\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n }\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n s3 = peg$parsemath_shift();\n if (s3 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f2(s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n if (s0 === peg$FAILED) {\n s0 = peg$parsealignment_tab();\n if (s0 === peg$FAILED) {\n s0 = peg$parseparbreak();\n if (s0 === peg$FAILED) {\n s0 = peg$parsemacro_parameter();\n if (s0 === peg$FAILED) {\n s0 = peg$parseignore();\n if (s0 === peg$FAILED) {\n s0 = peg$parsenumber();\n if (s0 === peg$FAILED) {\n s0 = peg$parsewhitespace();\n if (s0 === peg$FAILED) {\n s0 = peg$parsepunctuation();\n if (s0 === peg$FAILED) {\n s0 = peg$currPos;\n s1 = peg$currPos;\n s2 = [];\n s3 = peg$currPos;\n s4 = peg$currPos;\n peg$silentFails++;\n s5 = peg$parsenonchar_token();\n peg$silentFails--;\n if (s5 === peg$FAILED) {\n s4 = void 0;\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n if (s4 !== peg$FAILED) {\n if (input.length > peg$currPos) {\n s5 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s5 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e3);\n }\n }\n if (s5 !== peg$FAILED) {\n s4 = [s4, s5];\n s3 = s4;\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n if (s3 !== peg$FAILED) {\n while (s3 !== peg$FAILED) {\n s2.push(s3);\n s3 = peg$currPos;\n s4 = peg$currPos;\n peg$silentFails++;\n s5 = peg$parsenonchar_token();\n peg$silentFails--;\n if (s5 === peg$FAILED) {\n s4 = void 0;\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n if (s4 !== peg$FAILED) {\n if (input.length > peg$currPos) {\n s5 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s5 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e3);\n }\n }\n if (s5 !== peg$FAILED) {\n s4 = [s4, s5];\n s3 = s4;\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n }\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n s1 = input.substring(s1, peg$currPos);\n } else {\n s1 = s2;\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = s0;\n s1 = peg$f3(s1);\n }\n s0 = s1;\n if (s0 === peg$FAILED) {\n s0 = peg$parsebegin_group();\n if (s0 === peg$FAILED) {\n s0 = peg$parseend_group();\n if (s0 === peg$FAILED) {\n s0 = peg$parsemath_shift();\n if (s0 === peg$FAILED) {\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e3);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = s0;\n s1 = peg$f4(s1);\n }\n s0 = s1;\n }\n }\n }\n }\n }\n }\n }\n }\n }\n }\n }\n }\n }\n }\n }\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e2);\n }\n }\n peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };\n return s0;\n }\n function peg$parseparbreak() {\n var s0, s1, s2, s3, s4, s5, s6, s7;\n var key = peg$currPos * 52 + 3;\n var cached = peg$resultsCache[key];\n if (cached) {\n peg$currPos = cached.nextPos;\n return cached.result;\n }\n peg$silentFails++;\n s0 = peg$currPos;\n s1 = peg$currPos;\n s2 = [];\n s3 = peg$parsesp();\n while (s3 !== peg$FAILED) {\n s2.push(s3);\n s3 = peg$parsesp();\n }\n s3 = peg$parsenl();\n if (s3 !== peg$FAILED) {\n s4 = [];\n s5 = peg$currPos;\n s6 = [];\n s7 = peg$parsesp();\n while (s7 !== peg$FAILED) {\n s6.push(s7);\n s7 = peg$parsesp();\n }\n s7 = peg$parsenl();\n if (s7 !== peg$FAILED) {\n s6 = [s6, s7];\n s5 = s6;\n } else {\n peg$currPos = s5;\n s5 = peg$FAILED;\n }\n if (s5 !== peg$FAILED) {\n while (s5 !== peg$FAILED) {\n s4.push(s5);\n s5 = peg$currPos;\n s6 = [];\n s7 = peg$parsesp();\n while (s7 !== peg$FAILED) {\n s6.push(s7);\n s7 = peg$parsesp();\n }\n s7 = peg$parsenl();\n if (s7 !== peg$FAILED) {\n s6 = [s6, s7];\n s5 = s6;\n } else {\n peg$currPos = s5;\n s5 = peg$FAILED;\n }\n }\n } else {\n s4 = peg$FAILED;\n }\n if (s4 !== peg$FAILED) {\n s5 = [];\n s6 = peg$parsesp();\n while (s6 !== peg$FAILED) {\n s5.push(s6);\n s6 = peg$parsesp();\n }\n s6 = peg$currPos;\n peg$silentFails++;\n s7 = peg$parsecomment_start();\n peg$silentFails--;\n if (s7 === peg$FAILED) {\n s6 = void 0;\n } else {\n peg$currPos = s6;\n s6 = peg$FAILED;\n }\n if (s6 !== peg$FAILED) {\n s2 = [s2, s3, s4, s5, s6];\n s1 = s2;\n } else {\n peg$currPos = s1;\n s1 = peg$FAILED;\n }\n } else {\n peg$currPos = s1;\n s1 = peg$FAILED;\n }\n } else {\n peg$currPos = s1;\n s1 = peg$FAILED;\n }\n if (s1 === peg$FAILED) {\n s1 = peg$currPos;\n s2 = [];\n s3 = peg$parsesp();\n while (s3 !== peg$FAILED) {\n s2.push(s3);\n s3 = peg$parsesp();\n }\n s3 = peg$parsenl();\n if (s3 !== peg$FAILED) {\n s4 = [];\n s5 = peg$currPos;\n s6 = [];\n s7 = peg$parsesp();\n while (s7 !== peg$FAILED) {\n s6.push(s7);\n s7 = peg$parsesp();\n }\n s7 = peg$parsenl();\n if (s7 !== peg$FAILED) {\n s6 = [s6, s7];\n s5 = s6;\n } else {\n peg$currPos = s5;\n s5 = peg$FAILED;\n }\n if (s5 !== peg$FAILED) {\n while (s5 !== peg$FAILED) {\n s4.push(s5);\n s5 = peg$currPos;\n s6 = [];\n s7 = peg$parsesp();\n while (s7 !== peg$FAILED) {\n s6.push(s7);\n s7 = peg$parsesp();\n }\n s7 = peg$parsenl();\n if (s7 !== peg$FAILED) {\n s6 = [s6, s7];\n s5 = s6;\n } else {\n peg$currPos = s5;\n s5 = peg$FAILED;\n }\n }\n } else {\n s4 = peg$FAILED;\n }\n if (s4 !== peg$FAILED) {\n s2 = [s2, s3, s4];\n s1 = s2;\n } else {\n peg$currPos = s1;\n s1 = peg$FAILED;\n }\n } else {\n peg$currPos = s1;\n s1 = peg$FAILED;\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = s0;\n s1 = peg$f5();\n }\n s0 = s1;\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e4);\n }\n }\n peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };\n return s0;\n }\n function peg$parsemath_token() {\n var s0, s1, s2, s3, s4;\n var key = peg$currPos * 52 + 4;\n var cached = peg$resultsCache[key];\n if (cached) {\n peg$currPos = cached.nextPos;\n return cached.result;\n }\n peg$silentFails++;\n s0 = peg$parsespecial_macro();\n if (s0 === peg$FAILED) {\n s0 = peg$parsemacro();\n if (s0 === peg$FAILED) {\n s0 = peg$parsefull_comment();\n if (s0 === peg$FAILED) {\n s0 = peg$currPos;\n s1 = [];\n s2 = peg$parsewhitespace();\n while (s2 !== peg$FAILED) {\n s1.push(s2);\n s2 = peg$parsewhitespace();\n }\n s2 = peg$parsegroup();\n if (s2 !== peg$FAILED) {\n s3 = [];\n s4 = peg$parsewhitespace();\n while (s4 !== peg$FAILED) {\n s3.push(s4);\n s4 = peg$parsewhitespace();\n }\n peg$savedPos = s0;\n s0 = peg$f6(s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n if (s0 === peg$FAILED) {\n s0 = peg$currPos;\n s1 = [];\n s2 = peg$parsewhitespace();\n while (s2 !== peg$FAILED) {\n s1.push(s2);\n s2 = peg$parsewhitespace();\n }\n s2 = peg$parsealignment_tab();\n if (s2 !== peg$FAILED) {\n s3 = [];\n s4 = peg$parsewhitespace();\n while (s4 !== peg$FAILED) {\n s3.push(s4);\n s4 = peg$parsewhitespace();\n }\n peg$savedPos = s0;\n s0 = peg$f7(s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n if (s0 === peg$FAILED) {\n s0 = peg$parsemacro_parameter();\n if (s0 === peg$FAILED) {\n s0 = peg$currPos;\n s1 = [];\n s2 = peg$parsewhitespace();\n while (s2 !== peg$FAILED) {\n s1.push(s2);\n s2 = peg$parsewhitespace();\n }\n s2 = peg$parsesuperscript();\n if (s2 !== peg$FAILED) {\n s3 = [];\n s4 = peg$parsewhitespace();\n while (s4 !== peg$FAILED) {\n s3.push(s4);\n s4 = peg$parsewhitespace();\n }\n peg$savedPos = s0;\n s0 = peg$f8();\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n if (s0 === peg$FAILED) {\n s0 = peg$currPos;\n s1 = [];\n s2 = peg$parsewhitespace();\n while (s2 !== peg$FAILED) {\n s1.push(s2);\n s2 = peg$parsewhitespace();\n }\n s2 = peg$parsesubscript();\n if (s2 !== peg$FAILED) {\n s3 = [];\n s4 = peg$parsewhitespace();\n while (s4 !== peg$FAILED) {\n s3.push(s4);\n s4 = peg$parsewhitespace();\n }\n peg$savedPos = s0;\n s0 = peg$f9();\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n if (s0 === peg$FAILED) {\n s0 = peg$parseignore();\n if (s0 === peg$FAILED) {\n s0 = peg$parsewhitespace();\n if (s0 === peg$FAILED) {\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e3);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = s0;\n s1 = peg$f10(s1);\n }\n s0 = s1;\n }\n }\n }\n }\n }\n }\n }\n }\n }\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e5);\n }\n }\n peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };\n return s0;\n }\n function peg$parsenonchar_token() {\n var s0, s1;\n var key = peg$currPos * 52 + 5;\n var cached = peg$resultsCache[key];\n if (cached) {\n peg$currPos = cached.nextPos;\n return cached.result;\n }\n peg$silentFails++;\n s0 = peg$parseescape();\n if (s0 === peg$FAILED) {\n if (input.charCodeAt(peg$currPos) === 37) {\n s0 = peg$c0;\n peg$currPos++;\n } else {\n s0 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e7);\n }\n }\n if (s0 === peg$FAILED) {\n s0 = peg$parsebegin_group();\n if (s0 === peg$FAILED) {\n s0 = peg$parseend_group();\n if (s0 === peg$FAILED) {\n s0 = peg$parsemath_shift();\n if (s0 === peg$FAILED) {\n s0 = peg$parsealignment_tab();\n if (s0 === peg$FAILED) {\n s0 = peg$parsenl();\n if (s0 === peg$FAILED) {\n s0 = peg$parsemacro_parameter();\n if (s0 === peg$FAILED) {\n s0 = peg$parseignore();\n if (s0 === peg$FAILED) {\n s0 = peg$parsesp();\n if (s0 === peg$FAILED) {\n s0 = peg$parsepunctuation();\n if (s0 === peg$FAILED) {\n s0 = peg$parseEOF();\n }\n }\n }\n }\n }\n }\n }\n }\n }\n }\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e6);\n }\n }\n peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };\n return s0;\n }\n function peg$parsewhitespace() {\n var s0, s1, s2, s3, s4, s5, s6, s7;\n var key = peg$currPos * 52 + 6;\n var cached = peg$resultsCache[key];\n if (cached) {\n peg$currPos = cached.nextPos;\n return cached.result;\n }\n peg$silentFails++;\n s0 = peg$currPos;\n s1 = peg$currPos;\n s2 = peg$parsenl();\n if (s2 !== peg$FAILED) {\n s3 = [];\n s4 = peg$parsesp();\n while (s4 !== peg$FAILED) {\n s3.push(s4);\n s4 = peg$parsesp();\n }\n s2 = [s2, s3];\n s1 = s2;\n } else {\n peg$currPos = s1;\n s1 = peg$FAILED;\n }\n if (s1 === peg$FAILED) {\n s1 = peg$currPos;\n s2 = [];\n s3 = peg$parsesp();\n if (s3 !== peg$FAILED) {\n while (s3 !== peg$FAILED) {\n s2.push(s3);\n s3 = peg$parsesp();\n }\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n s3 = peg$parsenl();\n if (s3 !== peg$FAILED) {\n s4 = peg$currPos;\n peg$silentFails++;\n s5 = peg$parsecomment_start();\n peg$silentFails--;\n if (s5 === peg$FAILED) {\n s4 = void 0;\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n if (s4 !== peg$FAILED) {\n s5 = [];\n s6 = peg$parsesp();\n while (s6 !== peg$FAILED) {\n s5.push(s6);\n s6 = peg$parsesp();\n }\n s6 = peg$currPos;\n peg$silentFails++;\n s7 = peg$parsenl();\n peg$silentFails--;\n if (s7 === peg$FAILED) {\n s6 = void 0;\n } else {\n peg$currPos = s6;\n s6 = peg$FAILED;\n }\n if (s6 !== peg$FAILED) {\n s2 = [s2, s3, s4, s5, s6];\n s1 = s2;\n } else {\n peg$currPos = s1;\n s1 = peg$FAILED;\n }\n } else {\n peg$currPos = s1;\n s1 = peg$FAILED;\n }\n } else {\n peg$currPos = s1;\n s1 = peg$FAILED;\n }\n } else {\n peg$currPos = s1;\n s1 = peg$FAILED;\n }\n if (s1 === peg$FAILED) {\n s1 = [];\n s2 = peg$parsesp();\n if (s2 !== peg$FAILED) {\n while (s2 !== peg$FAILED) {\n s1.push(s2);\n s2 = peg$parsesp();\n }\n } else {\n s1 = peg$FAILED;\n }\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = s0;\n s1 = peg$f11();\n }\n s0 = s1;\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e8);\n }\n }\n peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };\n return s0;\n }\n function peg$parsenumber() {\n var s0, s1, s2, s3, s4, s5;\n var key = peg$currPos * 52 + 7;\n var cached = peg$resultsCache[key];\n if (cached) {\n peg$currPos = cached.nextPos;\n return cached.result;\n }\n peg$silentFails++;\n s0 = peg$currPos;\n s1 = peg$currPos;\n s2 = [];\n s3 = peg$parsenum();\n if (s3 !== peg$FAILED) {\n while (s3 !== peg$FAILED) {\n s2.push(s3);\n s3 = peg$parsenum();\n }\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n if (input.charCodeAt(peg$currPos) === 46) {\n s3 = peg$c1;\n peg$currPos++;\n } else {\n s3 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e10);\n }\n }\n if (s3 !== peg$FAILED) {\n s4 = [];\n s5 = peg$parsenum();\n if (s5 !== peg$FAILED) {\n while (s5 !== peg$FAILED) {\n s4.push(s5);\n s5 = peg$parsenum();\n }\n } else {\n s4 = peg$FAILED;\n }\n if (s4 !== peg$FAILED) {\n peg$savedPos = s1;\n s1 = peg$f12(s2, s4);\n } else {\n peg$currPos = s1;\n s1 = peg$FAILED;\n }\n } else {\n peg$currPos = s1;\n s1 = peg$FAILED;\n }\n } else {\n peg$currPos = s1;\n s1 = peg$FAILED;\n }\n if (s1 === peg$FAILED) {\n s1 = peg$currPos;\n if (input.charCodeAt(peg$currPos) === 46) {\n s2 = peg$c1;\n peg$currPos++;\n } else {\n s2 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e10);\n }\n }\n if (s2 !== peg$FAILED) {\n s3 = [];\n s4 = peg$parsenum();\n if (s4 !== peg$FAILED) {\n while (s4 !== peg$FAILED) {\n s3.push(s4);\n s4 = peg$parsenum();\n }\n } else {\n s3 = peg$FAILED;\n }\n if (s3 !== peg$FAILED) {\n peg$savedPos = s1;\n s1 = peg$f13(s3);\n } else {\n peg$currPos = s1;\n s1 = peg$FAILED;\n }\n } else {\n peg$currPos = s1;\n s1 = peg$FAILED;\n }\n if (s1 === peg$FAILED) {\n s1 = peg$currPos;\n s2 = [];\n s3 = peg$parsenum();\n if (s3 !== peg$FAILED) {\n while (s3 !== peg$FAILED) {\n s2.push(s3);\n s3 = peg$parsenum();\n }\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n if (input.charCodeAt(peg$currPos) === 46) {\n s3 = peg$c1;\n peg$currPos++;\n } else {\n s3 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e10);\n }\n }\n if (s3 !== peg$FAILED) {\n peg$savedPos = s1;\n s1 = peg$f14(s2);\n } else {\n peg$currPos = s1;\n s1 = peg$FAILED;\n }\n } else {\n peg$currPos = s1;\n s1 = peg$FAILED;\n }\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = s0;\n s1 = peg$f15(s1);\n }\n s0 = s1;\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e9);\n }\n }\n peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };\n return s0;\n }\n function peg$parsespecial_macro() {\n var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;\n var key = peg$currPos * 52 + 8;\n var cached = peg$resultsCache[key];\n if (cached) {\n peg$currPos = cached.nextPos;\n return cached.result;\n }\n peg$silentFails++;\n s0 = peg$currPos;\n s1 = peg$parseescape();\n if (s1 !== peg$FAILED) {\n if (input.substr(peg$currPos, 5) === peg$c2) {\n s2 = peg$c2;\n peg$currPos += 5;\n } else {\n s2 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e12);\n }\n }\n if (s2 === peg$FAILED) {\n if (input.substr(peg$currPos, 4) === peg$c3) {\n s2 = peg$c3;\n peg$currPos += 4;\n } else {\n s2 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e13);\n }\n }\n }\n if (s2 !== peg$FAILED) {\n if (input.length > peg$currPos) {\n s3 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s3 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e3);\n }\n }\n if (s3 !== peg$FAILED) {\n s4 = [];\n s5 = peg$currPos;\n s6 = peg$currPos;\n peg$silentFails++;\n s7 = peg$currPos;\n if (input.length > peg$currPos) {\n s8 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s8 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e3);\n }\n }\n if (s8 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s9 = peg$f16(s2, s3, s8);\n if (s9) {\n s9 = void 0;\n } else {\n s9 = peg$FAILED;\n }\n if (s9 !== peg$FAILED) {\n s8 = [s8, s9];\n s7 = s8;\n } else {\n peg$currPos = s7;\n s7 = peg$FAILED;\n }\n } else {\n peg$currPos = s7;\n s7 = peg$FAILED;\n }\n peg$silentFails--;\n if (s7 === peg$FAILED) {\n s6 = void 0;\n } else {\n peg$currPos = s6;\n s6 = peg$FAILED;\n }\n if (s6 !== peg$FAILED) {\n if (input.length > peg$currPos) {\n s7 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s7 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e3);\n }\n }\n if (s7 !== peg$FAILED) {\n peg$savedPos = s5;\n s5 = peg$f17(s2, s3, s7);\n } else {\n peg$currPos = s5;\n s5 = peg$FAILED;\n }\n } else {\n peg$currPos = s5;\n s5 = peg$FAILED;\n }\n while (s5 !== peg$FAILED) {\n s4.push(s5);\n s5 = peg$currPos;\n s6 = peg$currPos;\n peg$silentFails++;\n s7 = peg$currPos;\n if (input.length > peg$currPos) {\n s8 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s8 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e3);\n }\n }\n if (s8 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s9 = peg$f16(s2, s3, s8);\n if (s9) {\n s9 = void 0;\n } else {\n s9 = peg$FAILED;\n }\n if (s9 !== peg$FAILED) {\n s8 = [s8, s9];\n s7 = s8;\n } else {\n peg$currPos = s7;\n s7 = peg$FAILED;\n }\n } else {\n peg$currPos = s7;\n s7 = peg$FAILED;\n }\n peg$silentFails--;\n if (s7 === peg$FAILED) {\n s6 = void 0;\n } else {\n peg$currPos = s6;\n s6 = peg$FAILED;\n }\n if (s6 !== peg$FAILED) {\n if (input.length > peg$currPos) {\n s7 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s7 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e3);\n }\n }\n if (s7 !== peg$FAILED) {\n peg$savedPos = s5;\n s5 = peg$f17(s2, s3, s7);\n } else {\n peg$currPos = s5;\n s5 = peg$FAILED;\n }\n } else {\n peg$currPos = s5;\n s5 = peg$FAILED;\n }\n }\n s5 = peg$currPos;\n if (input.length > peg$currPos) {\n s6 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s6 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e3);\n }\n }\n if (s6 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s7 = peg$f18(s2, s3, s4, s6);\n if (s7) {\n s7 = void 0;\n } else {\n s7 = peg$FAILED;\n }\n if (s7 !== peg$FAILED) {\n s6 = [s6, s7];\n s5 = s6;\n } else {\n peg$currPos = s5;\n s5 = peg$FAILED;\n }\n } else {\n peg$currPos = s5;\n s5 = peg$FAILED;\n }\n if (s5 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f19(s2, s3, s4);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n if (s0 === peg$FAILED) {\n s0 = peg$parseverbatim_listings();\n if (s0 === peg$FAILED) {\n s0 = peg$parseverbatim_minted();\n if (s0 === peg$FAILED) {\n s0 = peg$parseverbatim_minted_environment();\n if (s0 === peg$FAILED) {\n s0 = peg$parseverbatim_environment();\n if (s0 === peg$FAILED) {\n s0 = peg$currPos;\n s1 = peg$parsebegin_display_math();\n if (s1 !== peg$FAILED) {\n s2 = [];\n s3 = peg$currPos;\n s4 = peg$currPos;\n peg$silentFails++;\n s5 = peg$parseend_display_math();\n peg$silentFails--;\n if (s5 === peg$FAILED) {\n s4 = void 0;\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n if (s4 !== peg$FAILED) {\n s5 = peg$parsemath_token();\n if (s5 !== peg$FAILED) {\n peg$savedPos = s3;\n s3 = peg$f20(s5);\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n while (s3 !== peg$FAILED) {\n s2.push(s3);\n s3 = peg$currPos;\n s4 = peg$currPos;\n peg$silentFails++;\n s5 = peg$parseend_display_math();\n peg$silentFails--;\n if (s5 === peg$FAILED) {\n s4 = void 0;\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n if (s4 !== peg$FAILED) {\n s5 = peg$parsemath_token();\n if (s5 !== peg$FAILED) {\n peg$savedPos = s3;\n s3 = peg$f20(s5);\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n }\n s3 = peg$parseend_display_math();\n if (s3 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f21(s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n if (s0 === peg$FAILED) {\n s0 = peg$currPos;\n s1 = peg$parsebegin_inline_math();\n if (s1 !== peg$FAILED) {\n s2 = [];\n s3 = peg$currPos;\n s4 = peg$currPos;\n peg$silentFails++;\n s5 = peg$parseend_inline_math();\n peg$silentFails--;\n if (s5 === peg$FAILED) {\n s4 = void 0;\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n if (s4 !== peg$FAILED) {\n s5 = peg$parsemath_token();\n if (s5 !== peg$FAILED) {\n peg$savedPos = s3;\n s3 = peg$f22(s5);\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n while (s3 !== peg$FAILED) {\n s2.push(s3);\n s3 = peg$currPos;\n s4 = peg$currPos;\n peg$silentFails++;\n s5 = peg$parseend_inline_math();\n peg$silentFails--;\n if (s5 === peg$FAILED) {\n s4 = void 0;\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n if (s4 !== peg$FAILED) {\n s5 = peg$parsemath_token();\n if (s5 !== peg$FAILED) {\n peg$savedPos = s3;\n s3 = peg$f22(s5);\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n }\n s3 = peg$parseend_inline_math();\n if (s3 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f23(s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n if (s0 === peg$FAILED) {\n s0 = peg$currPos;\n s1 = peg$parsemath_shift();\n if (s1 !== peg$FAILED) {\n s2 = peg$parsemath_shift();\n if (s2 !== peg$FAILED) {\n s3 = [];\n s4 = peg$currPos;\n s5 = peg$currPos;\n peg$silentFails++;\n s6 = peg$currPos;\n s7 = peg$parsemath_shift();\n if (s7 !== peg$FAILED) {\n s8 = peg$parsemath_shift();\n if (s8 !== peg$FAILED) {\n s7 = [s7, s8];\n s6 = s7;\n } else {\n peg$currPos = s6;\n s6 = peg$FAILED;\n }\n } else {\n peg$currPos = s6;\n s6 = peg$FAILED;\n }\n peg$silentFails--;\n if (s6 === peg$FAILED) {\n s5 = void 0;\n } else {\n peg$currPos = s5;\n s5 = peg$FAILED;\n }\n if (s5 !== peg$FAILED) {\n s6 = peg$parsemath_token();\n if (s6 !== peg$FAILED) {\n peg$savedPos = s4;\n s4 = peg$f24(s6);\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n while (s4 !== peg$FAILED) {\n s3.push(s4);\n s4 = peg$currPos;\n s5 = peg$currPos;\n peg$silentFails++;\n s6 = peg$currPos;\n s7 = peg$parsemath_shift();\n if (s7 !== peg$FAILED) {\n s8 = peg$parsemath_shift();\n if (s8 !== peg$FAILED) {\n s7 = [s7, s8];\n s6 = s7;\n } else {\n peg$currPos = s6;\n s6 = peg$FAILED;\n }\n } else {\n peg$currPos = s6;\n s6 = peg$FAILED;\n }\n peg$silentFails--;\n if (s6 === peg$FAILED) {\n s5 = void 0;\n } else {\n peg$currPos = s5;\n s5 = peg$FAILED;\n }\n if (s5 !== peg$FAILED) {\n s6 = peg$parsemath_token();\n if (s6 !== peg$FAILED) {\n peg$savedPos = s4;\n s4 = peg$f24(s6);\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n }\n s4 = peg$parsemath_shift();\n if (s4 !== peg$FAILED) {\n s5 = peg$parsemath_shift();\n if (s5 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f25(s3);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n if (s0 === peg$FAILED) {\n s0 = peg$parsemath_environment();\n if (s0 === peg$FAILED) {\n s0 = peg$parseenvironment();\n }\n }\n }\n }\n }\n }\n }\n }\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e11);\n }\n }\n peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };\n return s0;\n }\n function peg$parsesquare_bracket_argument() {\n var s0, s1, s2, s3, s4, s5, s6, s7;\n var key = peg$currPos * 52 + 9;\n var cached = peg$resultsCache[key];\n if (cached) {\n peg$currPos = cached.nextPos;\n return cached.result;\n }\n s0 = peg$currPos;\n if (input.charCodeAt(peg$currPos) === 91) {\n s1 = peg$c4;\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e14);\n }\n }\n if (s1 !== peg$FAILED) {\n s2 = [];\n s3 = peg$currPos;\n s4 = peg$currPos;\n peg$silentFails++;\n s5 = peg$currPos;\n s6 = peg$parsetoken();\n if (s6 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s7 = peg$f26(s6);\n if (s7) {\n s7 = void 0;\n } else {\n s7 = peg$FAILED;\n }\n if (s7 !== peg$FAILED) {\n s6 = [s6, s7];\n s5 = s6;\n } else {\n peg$currPos = s5;\n s5 = peg$FAILED;\n }\n } else {\n peg$currPos = s5;\n s5 = peg$FAILED;\n }\n peg$silentFails--;\n if (s5 === peg$FAILED) {\n s4 = void 0;\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n if (s4 !== peg$FAILED) {\n s5 = peg$parsetoken();\n if (s5 !== peg$FAILED) {\n peg$savedPos = s3;\n s3 = peg$f27(s5);\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n while (s3 !== peg$FAILED) {\n s2.push(s3);\n s3 = peg$currPos;\n s4 = peg$currPos;\n peg$silentFails++;\n s5 = peg$currPos;\n s6 = peg$parsetoken();\n if (s6 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s7 = peg$f26(s6);\n if (s7) {\n s7 = void 0;\n } else {\n s7 = peg$FAILED;\n }\n if (s7 !== peg$FAILED) {\n s6 = [s6, s7];\n s5 = s6;\n } else {\n peg$currPos = s5;\n s5 = peg$FAILED;\n }\n } else {\n peg$currPos = s5;\n s5 = peg$FAILED;\n }\n peg$silentFails--;\n if (s5 === peg$FAILED) {\n s4 = void 0;\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n if (s4 !== peg$FAILED) {\n s5 = peg$parsetoken();\n if (s5 !== peg$FAILED) {\n peg$savedPos = s3;\n s3 = peg$f27(s5);\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n }\n if (input.charCodeAt(peg$currPos) === 93) {\n s3 = peg$c5;\n peg$currPos++;\n } else {\n s3 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e15);\n }\n }\n if (s3 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f28(s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };\n return s0;\n }\n function peg$parseverbatim_group() {\n var s0, s1, s2, s3, s4, s5;\n var key = peg$currPos * 52 + 10;\n var cached = peg$resultsCache[key];\n if (cached) {\n peg$currPos = cached.nextPos;\n return cached.result;\n }\n s0 = peg$currPos;\n s1 = peg$parsebegin_group();\n if (s1 !== peg$FAILED) {\n s2 = [];\n s3 = peg$currPos;\n s4 = peg$currPos;\n peg$silentFails++;\n s5 = peg$parseend_group();\n peg$silentFails--;\n if (s5 === peg$FAILED) {\n s4 = void 0;\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n if (s4 !== peg$FAILED) {\n if (input.length > peg$currPos) {\n s5 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s5 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e3);\n }\n }\n if (s5 !== peg$FAILED) {\n peg$savedPos = s3;\n s3 = peg$f29(s5);\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n while (s3 !== peg$FAILED) {\n s2.push(s3);\n s3 = peg$currPos;\n s4 = peg$currPos;\n peg$silentFails++;\n s5 = peg$parseend_group();\n peg$silentFails--;\n if (s5 === peg$FAILED) {\n s4 = void 0;\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n if (s4 !== peg$FAILED) {\n if (input.length > peg$currPos) {\n s5 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s5 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e3);\n }\n }\n if (s5 !== peg$FAILED) {\n peg$savedPos = s3;\n s3 = peg$f29(s5);\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n }\n s3 = peg$parseend_group();\n if (s3 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f30(s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };\n return s0;\n }\n function peg$parseverbatim_delimited_by_char() {\n var s0, s1, s2, s3, s4, s5, s6, s7;\n var key = peg$currPos * 52 + 11;\n var cached = peg$resultsCache[key];\n if (cached) {\n peg$currPos = cached.nextPos;\n return cached.result;\n }\n s0 = peg$currPos;\n if (peg$r0.test(input.charAt(peg$currPos))) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e16);\n }\n }\n if (s1 !== peg$FAILED) {\n s2 = [];\n s3 = peg$currPos;\n s4 = peg$currPos;\n peg$silentFails++;\n s5 = peg$currPos;\n if (input.length > peg$currPos) {\n s6 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s6 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e3);\n }\n }\n if (s6 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s7 = peg$f31(s1, s6);\n if (s7) {\n s7 = void 0;\n } else {\n s7 = peg$FAILED;\n }\n if (s7 !== peg$FAILED) {\n s6 = [s6, s7];\n s5 = s6;\n } else {\n peg$currPos = s5;\n s5 = peg$FAILED;\n }\n } else {\n peg$currPos = s5;\n s5 = peg$FAILED;\n }\n peg$silentFails--;\n if (s5 === peg$FAILED) {\n s4 = void 0;\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n if (s4 !== peg$FAILED) {\n if (input.length > peg$currPos) {\n s5 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s5 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e3);\n }\n }\n if (s5 !== peg$FAILED) {\n peg$savedPos = s3;\n s3 = peg$f32(s1, s5);\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n while (s3 !== peg$FAILED) {\n s2.push(s3);\n s3 = peg$currPos;\n s4 = peg$currPos;\n peg$silentFails++;\n s5 = peg$currPos;\n if (input.length > peg$currPos) {\n s6 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s6 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e3);\n }\n }\n if (s6 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s7 = peg$f31(s1, s6);\n if (s7) {\n s7 = void 0;\n } else {\n s7 = peg$FAILED;\n }\n if (s7 !== peg$FAILED) {\n s6 = [s6, s7];\n s5 = s6;\n } else {\n peg$currPos = s5;\n s5 = peg$FAILED;\n }\n } else {\n peg$currPos = s5;\n s5 = peg$FAILED;\n }\n peg$silentFails--;\n if (s5 === peg$FAILED) {\n s4 = void 0;\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n if (s4 !== peg$FAILED) {\n if (input.length > peg$currPos) {\n s5 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s5 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e3);\n }\n }\n if (s5 !== peg$FAILED) {\n peg$savedPos = s3;\n s3 = peg$f32(s1, s5);\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n }\n s3 = peg$currPos;\n if (input.length > peg$currPos) {\n s4 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s4 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e3);\n }\n }\n if (s4 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s5 = peg$f33(s1, s2, s4);\n if (s5) {\n s5 = void 0;\n } else {\n s5 = peg$FAILED;\n }\n if (s5 !== peg$FAILED) {\n s4 = [s4, s5];\n s3 = s4;\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n if (s3 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f34(s1, s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };\n return s0;\n }\n function peg$parseverbatim_listings() {\n var s0, s1, s2, s3, s4;\n var key = peg$currPos * 52 + 12;\n var cached = peg$resultsCache[key];\n if (cached) {\n peg$currPos = cached.nextPos;\n return cached.result;\n }\n peg$silentFails++;\n s0 = peg$currPos;\n s1 = peg$parseescape();\n if (s1 !== peg$FAILED) {\n if (input.substr(peg$currPos, 9) === peg$c6) {\n s2 = peg$c6;\n peg$currPos += 9;\n } else {\n s2 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e18);\n }\n }\n if (s2 !== peg$FAILED) {\n s3 = peg$parsesquare_bracket_argument();\n if (s3 === peg$FAILED) {\n s3 = null;\n }\n s4 = peg$parseverbatim_group();\n if (s4 === peg$FAILED) {\n s4 = peg$parseverbatim_delimited_by_char();\n }\n if (s4 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f35(s2, s3, s4);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e17);\n }\n }\n peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };\n return s0;\n }\n function peg$parseverbatim_minted() {\n var s0, s1, s2, s3, s4, s5;\n var key = peg$currPos * 52 + 13;\n var cached = peg$resultsCache[key];\n if (cached) {\n peg$currPos = cached.nextPos;\n return cached.result;\n }\n peg$silentFails++;\n s0 = peg$currPos;\n s1 = peg$parseescape();\n if (s1 !== peg$FAILED) {\n if (input.substr(peg$currPos, 10) === peg$c7) {\n s2 = peg$c7;\n peg$currPos += 10;\n } else {\n s2 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e20);\n }\n }\n if (s2 === peg$FAILED) {\n if (input.substr(peg$currPos, 4) === peg$c8) {\n s2 = peg$c8;\n peg$currPos += 4;\n } else {\n s2 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e21);\n }\n }\n }\n if (s2 !== peg$FAILED) {\n s3 = peg$parsesquare_bracket_argument();\n if (s3 === peg$FAILED) {\n s3 = null;\n }\n s4 = peg$parsegroup();\n if (s4 !== peg$FAILED) {\n s5 = peg$parseverbatim_group();\n if (s5 === peg$FAILED) {\n s5 = peg$parseverbatim_delimited_by_char();\n }\n if (s5 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f36(s2, s3, s4, s5);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e19);\n }\n }\n peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };\n return s0;\n }\n function peg$parseverbatim_minted_environment() {\n var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14;\n var key = peg$currPos * 52 + 14;\n var cached = peg$resultsCache[key];\n if (cached) {\n peg$currPos = cached.nextPos;\n return cached.result;\n }\n peg$silentFails++;\n s0 = peg$currPos;\n s1 = peg$parsebegin_env();\n if (s1 !== peg$FAILED) {\n s2 = peg$parsebegin_group();\n if (s2 !== peg$FAILED) {\n if (input.substr(peg$currPos, 6) === peg$c9) {\n s3 = peg$c9;\n peg$currPos += 6;\n } else {\n s3 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e23);\n }\n }\n if (s3 !== peg$FAILED) {\n s4 = peg$parseend_group();\n if (s4 !== peg$FAILED) {\n s5 = peg$parsesquare_bracket_argument();\n if (s5 === peg$FAILED) {\n s5 = null;\n }\n s6 = peg$parsegroup();\n if (s6 !== peg$FAILED) {\n s7 = peg$currPos;\n s8 = [];\n s9 = peg$currPos;\n s10 = peg$currPos;\n peg$silentFails++;\n s11 = peg$currPos;\n s12 = peg$parseend_env();\n if (s12 !== peg$FAILED) {\n s13 = peg$parsegroup();\n if (s13 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s14 = peg$f37(s3, s5, s6, s13);\n if (s14) {\n s14 = void 0;\n } else {\n s14 = peg$FAILED;\n }\n if (s14 !== peg$FAILED) {\n s12 = [s12, s13, s14];\n s11 = s12;\n } else {\n peg$currPos = s11;\n s11 = peg$FAILED;\n }\n } else {\n peg$currPos = s11;\n s11 = peg$FAILED;\n }\n } else {\n peg$currPos = s11;\n s11 = peg$FAILED;\n }\n peg$silentFails--;\n if (s11 === peg$FAILED) {\n s10 = void 0;\n } else {\n peg$currPos = s10;\n s10 = peg$FAILED;\n }\n if (s10 !== peg$FAILED) {\n if (input.length > peg$currPos) {\n s11 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s11 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e3);\n }\n }\n if (s11 !== peg$FAILED) {\n s10 = [s10, s11];\n s9 = s10;\n } else {\n peg$currPos = s9;\n s9 = peg$FAILED;\n }\n } else {\n peg$currPos = s9;\n s9 = peg$FAILED;\n }\n while (s9 !== peg$FAILED) {\n s8.push(s9);\n s9 = peg$currPos;\n s10 = peg$currPos;\n peg$silentFails++;\n s11 = peg$currPos;\n s12 = peg$parseend_env();\n if (s12 !== peg$FAILED) {\n s13 = peg$parsegroup();\n if (s13 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s14 = peg$f37(s3, s5, s6, s13);\n if (s14) {\n s14 = void 0;\n } else {\n s14 = peg$FAILED;\n }\n if (s14 !== peg$FAILED) {\n s12 = [s12, s13, s14];\n s11 = s12;\n } else {\n peg$currPos = s11;\n s11 = peg$FAILED;\n }\n } else {\n peg$currPos = s11;\n s11 = peg$FAILED;\n }\n } else {\n peg$currPos = s11;\n s11 = peg$FAILED;\n }\n peg$silentFails--;\n if (s11 === peg$FAILED) {\n s10 = void 0;\n } else {\n peg$currPos = s10;\n s10 = peg$FAILED;\n }\n if (s10 !== peg$FAILED) {\n if (input.length > peg$currPos) {\n s11 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s11 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e3);\n }\n }\n if (s11 !== peg$FAILED) {\n s10 = [s10, s11];\n s9 = s10;\n } else {\n peg$currPos = s9;\n s9 = peg$FAILED;\n }\n } else {\n peg$currPos = s9;\n s9 = peg$FAILED;\n }\n }\n s7 = input.substring(s7, peg$currPos);\n s8 = peg$parseend_env();\n if (s8 !== peg$FAILED) {\n s9 = peg$parsebegin_group();\n if (s9 !== peg$FAILED) {\n if (input.substr(peg$currPos, 6) === peg$c9) {\n s10 = peg$c9;\n peg$currPos += 6;\n } else {\n s10 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e23);\n }\n }\n if (s10 !== peg$FAILED) {\n s11 = peg$parseend_group();\n if (s11 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f38(s3, s5, s6, s7);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e22);\n }\n }\n peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };\n return s0;\n }\n function peg$parseverbatim_environment() {\n var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12;\n var key = peg$currPos * 52 + 15;\n var cached = peg$resultsCache[key];\n if (cached) {\n peg$currPos = cached.nextPos;\n return cached.result;\n }\n peg$silentFails++;\n s0 = peg$currPos;\n s1 = peg$parsebegin_env();\n if (s1 !== peg$FAILED) {\n s2 = peg$parsebegin_group();\n if (s2 !== peg$FAILED) {\n s3 = peg$parseverbatim_env_name();\n if (s3 !== peg$FAILED) {\n s4 = peg$parseend_group();\n if (s4 !== peg$FAILED) {\n s5 = peg$currPos;\n s6 = [];\n s7 = peg$currPos;\n s8 = peg$currPos;\n peg$silentFails++;\n s9 = peg$currPos;\n s10 = peg$parseend_env();\n if (s10 !== peg$FAILED) {\n s11 = peg$parsegroup();\n if (s11 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s12 = peg$f39(s3, s11);\n if (s12) {\n s12 = void 0;\n } else {\n s12 = peg$FAILED;\n }\n if (s12 !== peg$FAILED) {\n s10 = [s10, s11, s12];\n s9 = s10;\n } else {\n peg$currPos = s9;\n s9 = peg$FAILED;\n }\n } else {\n peg$currPos = s9;\n s9 = peg$FAILED;\n }\n } else {\n peg$currPos = s9;\n s9 = peg$FAILED;\n }\n peg$silentFails--;\n if (s9 === peg$FAILED) {\n s8 = void 0;\n } else {\n peg$currPos = s8;\n s8 = peg$FAILED;\n }\n if (s8 !== peg$FAILED) {\n if (input.length > peg$currPos) {\n s9 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s9 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e3);\n }\n }\n if (s9 !== peg$FAILED) {\n peg$savedPos = s7;\n s7 = peg$f40(s3, s9);\n } else {\n peg$currPos = s7;\n s7 = peg$FAILED;\n }\n } else {\n peg$currPos = s7;\n s7 = peg$FAILED;\n }\n while (s7 !== peg$FAILED) {\n s6.push(s7);\n s7 = peg$currPos;\n s8 = peg$currPos;\n peg$silentFails++;\n s9 = peg$currPos;\n s10 = peg$parseend_env();\n if (s10 !== peg$FAILED) {\n s11 = peg$parsegroup();\n if (s11 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s12 = peg$f39(s3, s11);\n if (s12) {\n s12 = void 0;\n } else {\n s12 = peg$FAILED;\n }\n if (s12 !== peg$FAILED) {\n s10 = [s10, s11, s12];\n s9 = s10;\n } else {\n peg$currPos = s9;\n s9 = peg$FAILED;\n }\n } else {\n peg$currPos = s9;\n s9 = peg$FAILED;\n }\n } else {\n peg$currPos = s9;\n s9 = peg$FAILED;\n }\n peg$silentFails--;\n if (s9 === peg$FAILED) {\n s8 = void 0;\n } else {\n peg$currPos = s8;\n s8 = peg$FAILED;\n }\n if (s8 !== peg$FAILED) {\n if (input.length > peg$currPos) {\n s9 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s9 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e3);\n }\n }\n if (s9 !== peg$FAILED) {\n peg$savedPos = s7;\n s7 = peg$f40(s3, s9);\n } else {\n peg$currPos = s7;\n s7 = peg$FAILED;\n }\n } else {\n peg$currPos = s7;\n s7 = peg$FAILED;\n }\n }\n s5 = input.substring(s5, peg$currPos);\n s6 = peg$parseend_env();\n if (s6 !== peg$FAILED) {\n s7 = peg$parsebegin_group();\n if (s7 !== peg$FAILED) {\n s8 = peg$parseverbatim_env_name();\n if (s8 !== peg$FAILED) {\n s9 = peg$parseend_group();\n if (s9 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f41(s3, s5);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e24);\n }\n }\n peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };\n return s0;\n }\n function peg$parseverbatim_env_name() {\n var s0;\n var key = peg$currPos * 52 + 16;\n var cached = peg$resultsCache[key];\n if (cached) {\n peg$currPos = cached.nextPos;\n return cached.result;\n }\n if (input.substr(peg$currPos, 9) === peg$c10) {\n s0 = peg$c10;\n peg$currPos += 9;\n } else {\n s0 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e25);\n }\n }\n if (s0 === peg$FAILED) {\n if (input.substr(peg$currPos, 8) === peg$c11) {\n s0 = peg$c11;\n peg$currPos += 8;\n } else {\n s0 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e26);\n }\n }\n if (s0 === peg$FAILED) {\n if (input.substr(peg$currPos, 13) === peg$c12) {\n s0 = peg$c12;\n peg$currPos += 13;\n } else {\n s0 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e27);\n }\n }\n if (s0 === peg$FAILED) {\n if (input.substr(peg$currPos, 12) === peg$c13) {\n s0 = peg$c13;\n peg$currPos += 12;\n } else {\n s0 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e28);\n }\n }\n if (s0 === peg$FAILED) {\n if (input.substr(peg$currPos, 7) === peg$c14) {\n s0 = peg$c14;\n peg$currPos += 7;\n } else {\n s0 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e29);\n }\n }\n if (s0 === peg$FAILED) {\n if (input.substr(peg$currPos, 10) === peg$c15) {\n s0 = peg$c15;\n peg$currPos += 10;\n } else {\n s0 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e30);\n }\n }\n }\n }\n }\n }\n }\n peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };\n return s0;\n }\n function peg$parsemacro() {\n var s0, s1, s2, s3, s4;\n var key = peg$currPos * 52 + 17;\n var cached = peg$resultsCache[key];\n if (cached) {\n peg$currPos = cached.nextPos;\n return cached.result;\n }\n peg$silentFails++;\n s0 = peg$currPos;\n s1 = peg$currPos;\n s2 = peg$parseescape();\n if (s2 !== peg$FAILED) {\n s3 = [];\n s4 = peg$parsechar();\n if (s4 !== peg$FAILED) {\n while (s4 !== peg$FAILED) {\n s3.push(s4);\n s4 = peg$parsechar();\n }\n } else {\n s3 = peg$FAILED;\n }\n if (s3 !== peg$FAILED) {\n peg$savedPos = s1;\n s1 = peg$f42(s3);\n } else {\n peg$currPos = s1;\n s1 = peg$FAILED;\n }\n } else {\n peg$currPos = s1;\n s1 = peg$FAILED;\n }\n if (s1 === peg$FAILED) {\n s1 = peg$currPos;\n s2 = peg$parseescape();\n if (s2 !== peg$FAILED) {\n if (input.length > peg$currPos) {\n s3 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s3 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e3);\n }\n }\n if (s3 !== peg$FAILED) {\n peg$savedPos = s1;\n s1 = peg$f43(s3);\n } else {\n peg$currPos = s1;\n s1 = peg$FAILED;\n }\n } else {\n peg$currPos = s1;\n s1 = peg$FAILED;\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = s0;\n s1 = peg$f44(s1);\n }\n s0 = s1;\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e31);\n }\n }\n peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };\n return s0;\n }\n function peg$parsegroup() {\n var s0, s1, s2, s3, s4, s5;\n var key = peg$currPos * 52 + 18;\n var cached = peg$resultsCache[key];\n if (cached) {\n peg$currPos = cached.nextPos;\n return cached.result;\n }\n peg$silentFails++;\n s0 = peg$currPos;\n s1 = peg$parsebegin_group();\n if (s1 !== peg$FAILED) {\n s2 = [];\n s3 = peg$currPos;\n s4 = peg$currPos;\n peg$silentFails++;\n s5 = peg$parseend_group();\n peg$silentFails--;\n if (s5 === peg$FAILED) {\n s4 = void 0;\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n if (s4 !== peg$FAILED) {\n s5 = peg$parsetoken();\n if (s5 !== peg$FAILED) {\n peg$savedPos = s3;\n s3 = peg$f45(s5);\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n while (s3 !== peg$FAILED) {\n s2.push(s3);\n s3 = peg$currPos;\n s4 = peg$currPos;\n peg$silentFails++;\n s5 = peg$parseend_group();\n peg$silentFails--;\n if (s5 === peg$FAILED) {\n s4 = void 0;\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n if (s4 !== peg$FAILED) {\n s5 = peg$parsetoken();\n if (s5 !== peg$FAILED) {\n peg$savedPos = s3;\n s3 = peg$f45(s5);\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n }\n s3 = peg$parseend_group();\n if (s3 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f46(s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e32);\n }\n }\n peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };\n return s0;\n }\n function peg$parsegroup_contents_as_string() {\n var s0, s1;\n var key = peg$currPos * 52 + 19;\n var cached = peg$resultsCache[key];\n if (cached) {\n peg$currPos = cached.nextPos;\n return cached.result;\n }\n s0 = peg$currPos;\n s1 = peg$parsegroup();\n if (s1 !== peg$FAILED) {\n peg$savedPos = s0;\n s1 = peg$f47(s1);\n }\n s0 = s1;\n peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };\n return s0;\n }\n function peg$parseenvironment() {\n var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10;\n var key = peg$currPos * 52 + 20;\n var cached = peg$resultsCache[key];\n if (cached) {\n peg$currPos = cached.nextPos;\n return cached.result;\n }\n peg$silentFails++;\n s0 = peg$currPos;\n s1 = peg$parsebegin_env();\n if (s1 !== peg$FAILED) {\n s2 = peg$parsegroup_contents_as_string();\n if (s2 !== peg$FAILED) {\n s3 = peg$parsesameline_comment();\n if (s3 === peg$FAILED) {\n s3 = null;\n }\n s4 = [];\n s5 = peg$currPos;\n s6 = peg$currPos;\n peg$silentFails++;\n s7 = peg$currPos;\n s8 = peg$parseend_env();\n if (s8 !== peg$FAILED) {\n s9 = peg$parsegroup_contents_as_string();\n if (s9 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s10 = peg$f48(s2, s3, s9);\n if (s10) {\n s10 = void 0;\n } else {\n s10 = peg$FAILED;\n }\n if (s10 !== peg$FAILED) {\n s8 = [s8, s9, s10];\n s7 = s8;\n } else {\n peg$currPos = s7;\n s7 = peg$FAILED;\n }\n } else {\n peg$currPos = s7;\n s7 = peg$FAILED;\n }\n } else {\n peg$currPos = s7;\n s7 = peg$FAILED;\n }\n peg$silentFails--;\n if (s7 === peg$FAILED) {\n s6 = void 0;\n } else {\n peg$currPos = s6;\n s6 = peg$FAILED;\n }\n if (s6 !== peg$FAILED) {\n s7 = peg$parsetoken();\n if (s7 !== peg$FAILED) {\n peg$savedPos = s5;\n s5 = peg$f49(s2, s3, s7);\n } else {\n peg$currPos = s5;\n s5 = peg$FAILED;\n }\n } else {\n peg$currPos = s5;\n s5 = peg$FAILED;\n }\n while (s5 !== peg$FAILED) {\n s4.push(s5);\n s5 = peg$currPos;\n s6 = peg$currPos;\n peg$silentFails++;\n s7 = peg$currPos;\n s8 = peg$parseend_env();\n if (s8 !== peg$FAILED) {\n s9 = peg$parsegroup_contents_as_string();\n if (s9 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s10 = peg$f48(s2, s3, s9);\n if (s10) {\n s10 = void 0;\n } else {\n s10 = peg$FAILED;\n }\n if (s10 !== peg$FAILED) {\n s8 = [s8, s9, s10];\n s7 = s8;\n } else {\n peg$currPos = s7;\n s7 = peg$FAILED;\n }\n } else {\n peg$currPos = s7;\n s7 = peg$FAILED;\n }\n } else {\n peg$currPos = s7;\n s7 = peg$FAILED;\n }\n peg$silentFails--;\n if (s7 === peg$FAILED) {\n s6 = void 0;\n } else {\n peg$currPos = s6;\n s6 = peg$FAILED;\n }\n if (s6 !== peg$FAILED) {\n s7 = peg$parsetoken();\n if (s7 !== peg$FAILED) {\n peg$savedPos = s5;\n s5 = peg$f49(s2, s3, s7);\n } else {\n peg$currPos = s5;\n s5 = peg$FAILED;\n }\n } else {\n peg$currPos = s5;\n s5 = peg$FAILED;\n }\n }\n s5 = peg$parseend_env();\n if (s5 !== peg$FAILED) {\n s6 = peg$parsegroup_contents_as_string();\n if (s6 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f50(s2, s3, s4);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e33);\n }\n }\n peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };\n return s0;\n }\n function peg$parsemath_environment() {\n var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12;\n var key = peg$currPos * 52 + 21;\n var cached = peg$resultsCache[key];\n if (cached) {\n peg$currPos = cached.nextPos;\n return cached.result;\n }\n peg$silentFails++;\n s0 = peg$currPos;\n s1 = peg$parsebegin_env();\n if (s1 !== peg$FAILED) {\n s2 = peg$parsebegin_group();\n if (s2 !== peg$FAILED) {\n s3 = peg$parsemath_env_name();\n if (s3 !== peg$FAILED) {\n s4 = peg$parseend_group();\n if (s4 !== peg$FAILED) {\n s5 = peg$parsesameline_comment();\n if (s5 === peg$FAILED) {\n s5 = null;\n }\n s6 = [];\n s7 = peg$currPos;\n s8 = peg$currPos;\n peg$silentFails++;\n s9 = peg$currPos;\n s10 = peg$parseend_env();\n if (s10 !== peg$FAILED) {\n s11 = peg$parsegroup();\n if (s11 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s12 = peg$f51(s3, s5, s11);\n if (s12) {\n s12 = void 0;\n } else {\n s12 = peg$FAILED;\n }\n if (s12 !== peg$FAILED) {\n s10 = [s10, s11, s12];\n s9 = s10;\n } else {\n peg$currPos = s9;\n s9 = peg$FAILED;\n }\n } else {\n peg$currPos = s9;\n s9 = peg$FAILED;\n }\n } else {\n peg$currPos = s9;\n s9 = peg$FAILED;\n }\n peg$silentFails--;\n if (s9 === peg$FAILED) {\n s8 = void 0;\n } else {\n peg$currPos = s8;\n s8 = peg$FAILED;\n }\n if (s8 !== peg$FAILED) {\n s9 = peg$parsemath_token();\n if (s9 !== peg$FAILED) {\n peg$savedPos = s7;\n s7 = peg$f52(s3, s5, s9);\n } else {\n peg$currPos = s7;\n s7 = peg$FAILED;\n }\n } else {\n peg$currPos = s7;\n s7 = peg$FAILED;\n }\n while (s7 !== peg$FAILED) {\n s6.push(s7);\n s7 = peg$currPos;\n s8 = peg$currPos;\n peg$silentFails++;\n s9 = peg$currPos;\n s10 = peg$parseend_env();\n if (s10 !== peg$FAILED) {\n s11 = peg$parsegroup();\n if (s11 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s12 = peg$f51(s3, s5, s11);\n if (s12) {\n s12 = void 0;\n } else {\n s12 = peg$FAILED;\n }\n if (s12 !== peg$FAILED) {\n s10 = [s10, s11, s12];\n s9 = s10;\n } else {\n peg$currPos = s9;\n s9 = peg$FAILED;\n }\n } else {\n peg$currPos = s9;\n s9 = peg$FAILED;\n }\n } else {\n peg$currPos = s9;\n s9 = peg$FAILED;\n }\n peg$silentFails--;\n if (s9 === peg$FAILED) {\n s8 = void 0;\n } else {\n peg$currPos = s8;\n s8 = peg$FAILED;\n }\n if (s8 !== peg$FAILED) {\n s9 = peg$parsemath_token();\n if (s9 !== peg$FAILED) {\n peg$savedPos = s7;\n s7 = peg$f52(s3, s5, s9);\n } else {\n peg$currPos = s7;\n s7 = peg$FAILED;\n }\n } else {\n peg$currPos = s7;\n s7 = peg$FAILED;\n }\n }\n s7 = peg$parseend_env();\n if (s7 !== peg$FAILED) {\n s8 = peg$parsebegin_group();\n if (s8 !== peg$FAILED) {\n s9 = peg$parsemath_env_name();\n if (s9 !== peg$FAILED) {\n s10 = peg$parseend_group();\n if (s10 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f53(s3, s5, s6);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e34);\n }\n }\n peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };\n return s0;\n }\n function peg$parsemath_group() {\n var s0, s1, s2, s3, s4, s5;\n var key = peg$currPos * 52 + 22;\n var cached = peg$resultsCache[key];\n if (cached) {\n peg$currPos = cached.nextPos;\n return cached.result;\n }\n peg$silentFails++;\n s0 = peg$currPos;\n s1 = peg$parsebegin_group();\n if (s1 !== peg$FAILED) {\n s2 = [];\n s3 = peg$currPos;\n s4 = peg$currPos;\n peg$silentFails++;\n s5 = peg$parseend_group();\n peg$silentFails--;\n if (s5 === peg$FAILED) {\n s4 = void 0;\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n if (s4 !== peg$FAILED) {\n s5 = peg$parsemath_token();\n if (s5 !== peg$FAILED) {\n peg$savedPos = s3;\n s3 = peg$f54(s5);\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n while (s3 !== peg$FAILED) {\n s2.push(s3);\n s3 = peg$currPos;\n s4 = peg$currPos;\n peg$silentFails++;\n s5 = peg$parseend_group();\n peg$silentFails--;\n if (s5 === peg$FAILED) {\n s4 = void 0;\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n if (s4 !== peg$FAILED) {\n s5 = peg$parsemath_token();\n if (s5 !== peg$FAILED) {\n peg$savedPos = s3;\n s3 = peg$f54(s5);\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n }\n s3 = peg$parseend_group();\n if (s3 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f55(s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e35);\n }\n }\n peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };\n return s0;\n }\n function peg$parsebegin_display_math() {\n var s0, s1, s2;\n var key = peg$currPos * 52 + 23;\n var cached = peg$resultsCache[key];\n if (cached) {\n peg$currPos = cached.nextPos;\n return cached.result;\n }\n s0 = peg$currPos;\n s1 = peg$parseescape();\n if (s1 !== peg$FAILED) {\n if (input.charCodeAt(peg$currPos) === 91) {\n s2 = peg$c4;\n peg$currPos++;\n } else {\n s2 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e14);\n }\n }\n if (s2 !== peg$FAILED) {\n s1 = [s1, s2];\n s0 = s1;\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };\n return s0;\n }\n function peg$parseend_display_math() {\n var s0, s1, s2;\n var key = peg$currPos * 52 + 24;\n var cached = peg$resultsCache[key];\n if (cached) {\n peg$currPos = cached.nextPos;\n return cached.result;\n }\n s0 = peg$currPos;\n s1 = peg$parseescape();\n if (s1 !== peg$FAILED) {\n if (input.charCodeAt(peg$currPos) === 93) {\n s2 = peg$c5;\n peg$currPos++;\n } else {\n s2 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e15);\n }\n }\n if (s2 !== peg$FAILED) {\n s1 = [s1, s2];\n s0 = s1;\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };\n return s0;\n }\n function peg$parsebegin_inline_math() {\n var s0, s1, s2;\n var key = peg$currPos * 52 + 25;\n var cached = peg$resultsCache[key];\n if (cached) {\n peg$currPos = cached.nextPos;\n return cached.result;\n }\n s0 = peg$currPos;\n s1 = peg$parseescape();\n if (s1 !== peg$FAILED) {\n if (input.charCodeAt(peg$currPos) === 40) {\n s2 = peg$c16;\n peg$currPos++;\n } else {\n s2 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e36);\n }\n }\n if (s2 !== peg$FAILED) {\n s1 = [s1, s2];\n s0 = s1;\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };\n return s0;\n }\n function peg$parseend_inline_math() {\n var s0, s1, s2;\n var key = peg$currPos * 52 + 26;\n var cached = peg$resultsCache[key];\n if (cached) {\n peg$currPos = cached.nextPos;\n return cached.result;\n }\n s0 = peg$currPos;\n s1 = peg$parseescape();\n if (s1 !== peg$FAILED) {\n if (input.charCodeAt(peg$currPos) === 41) {\n s2 = peg$c17;\n peg$currPos++;\n } else {\n s2 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e37);\n }\n }\n if (s2 !== peg$FAILED) {\n s1 = [s1, s2];\n s0 = s1;\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };\n return s0;\n }\n function peg$parsebegin_env() {\n var s0, s1, s2;\n var key = peg$currPos * 52 + 27;\n var cached = peg$resultsCache[key];\n if (cached) {\n peg$currPos = cached.nextPos;\n return cached.result;\n }\n s0 = peg$currPos;\n s1 = peg$parseescape();\n if (s1 !== peg$FAILED) {\n if (input.substr(peg$currPos, 5) === peg$c18) {\n s2 = peg$c18;\n peg$currPos += 5;\n } else {\n s2 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e38);\n }\n }\n if (s2 !== peg$FAILED) {\n s1 = [s1, s2];\n s0 = s1;\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };\n return s0;\n }\n function peg$parseend_env() {\n var s0, s1, s2;\n var key = peg$currPos * 52 + 28;\n var cached = peg$resultsCache[key];\n if (cached) {\n peg$currPos = cached.nextPos;\n return cached.result;\n }\n s0 = peg$currPos;\n s1 = peg$parseescape();\n if (s1 !== peg$FAILED) {\n if (input.substr(peg$currPos, 3) === peg$c19) {\n s2 = peg$c19;\n peg$currPos += 3;\n } else {\n s2 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e39);\n }\n }\n if (s2 !== peg$FAILED) {\n s1 = [s1, s2];\n s0 = s1;\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };\n return s0;\n }\n function peg$parsemath_env_name() {\n var s0, s1;\n var key = peg$currPos * 52 + 29;\n var cached = peg$resultsCache[key];\n if (cached) {\n peg$currPos = cached.nextPos;\n return cached.result;\n }\n s0 = peg$currPos;\n if (input.substr(peg$currPos, 9) === peg$c20) {\n s1 = peg$c20;\n peg$currPos += 9;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e40);\n }\n }\n if (s1 === peg$FAILED) {\n if (input.substr(peg$currPos, 8) === peg$c21) {\n s1 = peg$c21;\n peg$currPos += 8;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e41);\n }\n }\n if (s1 === peg$FAILED) {\n if (input.substr(peg$currPos, 6) === peg$c22) {\n s1 = peg$c22;\n peg$currPos += 6;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e42);\n }\n }\n if (s1 === peg$FAILED) {\n if (input.substr(peg$currPos, 5) === peg$c23) {\n s1 = peg$c23;\n peg$currPos += 5;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e43);\n }\n }\n if (s1 === peg$FAILED) {\n if (input.substr(peg$currPos, 8) === peg$c24) {\n s1 = peg$c24;\n peg$currPos += 8;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e44);\n }\n }\n if (s1 === peg$FAILED) {\n if (input.substr(peg$currPos, 7) === peg$c25) {\n s1 = peg$c25;\n peg$currPos += 7;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e45);\n }\n }\n if (s1 === peg$FAILED) {\n if (input.substr(peg$currPos, 7) === peg$c26) {\n s1 = peg$c26;\n peg$currPos += 7;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e46);\n }\n }\n if (s1 === peg$FAILED) {\n if (input.substr(peg$currPos, 6) === peg$c27) {\n s1 = peg$c27;\n peg$currPos += 6;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e47);\n }\n }\n if (s1 === peg$FAILED) {\n if (input.substr(peg$currPos, 9) === peg$c28) {\n s1 = peg$c28;\n peg$currPos += 9;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e48);\n }\n }\n if (s1 === peg$FAILED) {\n if (input.substr(peg$currPos, 8) === peg$c29) {\n s1 = peg$c29;\n peg$currPos += 8;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e49);\n }\n }\n if (s1 === peg$FAILED) {\n if (input.substr(peg$currPos, 8) === peg$c30) {\n s1 = peg$c30;\n peg$currPos += 8;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e50);\n }\n }\n if (s1 === peg$FAILED) {\n if (input.substr(peg$currPos, 7) === peg$c31) {\n s1 = peg$c31;\n peg$currPos += 7;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e51);\n }\n }\n if (s1 === peg$FAILED) {\n if (input.substr(peg$currPos, 5) === peg$c32) {\n s1 = peg$c32;\n peg$currPos += 5;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e52);\n }\n }\n if (s1 === peg$FAILED) {\n if (input.substr(peg$currPos, 4) === peg$c33) {\n s1 = peg$c33;\n peg$currPos += 4;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e53);\n }\n }\n if (s1 === peg$FAILED) {\n if (input.substr(peg$currPos, 11) === peg$c34) {\n s1 = peg$c34;\n peg$currPos += 11;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e54);\n }\n }\n }\n }\n }\n }\n }\n }\n }\n }\n }\n }\n }\n }\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = s0;\n s1 = peg$f56(s1);\n }\n s0 = s1;\n peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };\n return s0;\n }\n function peg$parseescape() {\n var s0, s1;\n var key = peg$currPos * 52 + 30;\n var cached = peg$resultsCache[key];\n if (cached) {\n peg$currPos = cached.nextPos;\n return cached.result;\n }\n peg$silentFails++;\n s0 = peg$currPos;\n if (input.charCodeAt(peg$currPos) === 92) {\n s1 = peg$c35;\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e56);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = s0;\n s1 = peg$f57();\n }\n s0 = s1;\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e55);\n }\n }\n peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };\n return s0;\n }\n function peg$parsebegin_group() {\n var s0, s1;\n var key = peg$currPos * 52 + 31;\n var cached = peg$resultsCache[key];\n if (cached) {\n peg$currPos = cached.nextPos;\n return cached.result;\n }\n s0 = peg$currPos;\n if (input.charCodeAt(peg$currPos) === 123) {\n s1 = peg$c36;\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e57);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = s0;\n s1 = peg$f58(s1);\n }\n s0 = s1;\n peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };\n return s0;\n }\n function peg$parseend_group() {\n var s0, s1;\n var key = peg$currPos * 52 + 32;\n var cached = peg$resultsCache[key];\n if (cached) {\n peg$currPos = cached.nextPos;\n return cached.result;\n }\n s0 = peg$currPos;\n if (input.charCodeAt(peg$currPos) === 125) {\n s1 = peg$c37;\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e58);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = s0;\n s1 = peg$f59(s1);\n }\n s0 = s1;\n peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };\n return s0;\n }\n function peg$parsemath_shift() {\n var s0, s1;\n var key = peg$currPos * 52 + 33;\n var cached = peg$resultsCache[key];\n if (cached) {\n peg$currPos = cached.nextPos;\n return cached.result;\n }\n s0 = peg$currPos;\n if (input.charCodeAt(peg$currPos) === 36) {\n s1 = peg$c38;\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e59);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = s0;\n s1 = peg$f60(s1);\n }\n s0 = s1;\n peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };\n return s0;\n }\n function peg$parsealignment_tab() {\n var s0, s1;\n var key = peg$currPos * 52 + 34;\n var cached = peg$resultsCache[key];\n if (cached) {\n peg$currPos = cached.nextPos;\n return cached.result;\n }\n s0 = peg$currPos;\n if (input.charCodeAt(peg$currPos) === 38) {\n s1 = peg$c39;\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e60);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = s0;\n s1 = peg$f61(s1);\n }\n s0 = s1;\n peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };\n return s0;\n }\n function peg$parsenl() {\n var s0, s1, s2;\n var key = peg$currPos * 52 + 35;\n var cached = peg$resultsCache[key];\n if (cached) {\n peg$currPos = cached.nextPos;\n return cached.result;\n }\n peg$silentFails++;\n s0 = peg$currPos;\n s1 = peg$currPos;\n peg$silentFails++;\n if (input.charCodeAt(peg$currPos) === 13) {\n s2 = peg$c40;\n peg$currPos++;\n } else {\n s2 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e62);\n }\n }\n peg$silentFails--;\n if (s2 === peg$FAILED) {\n s1 = void 0;\n } else {\n peg$currPos = s1;\n s1 = peg$FAILED;\n }\n if (s1 !== peg$FAILED) {\n if (input.charCodeAt(peg$currPos) === 10) {\n s2 = peg$c41;\n peg$currPos++;\n } else {\n s2 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e63);\n }\n }\n if (s2 !== peg$FAILED) {\n s1 = [s1, s2];\n s0 = s1;\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n if (s0 === peg$FAILED) {\n if (input.charCodeAt(peg$currPos) === 13) {\n s0 = peg$c40;\n peg$currPos++;\n } else {\n s0 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e62);\n }\n }\n if (s0 === peg$FAILED) {\n if (input.substr(peg$currPos, 2) === peg$c42) {\n s0 = peg$c42;\n peg$currPos += 2;\n } else {\n s0 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e64);\n }\n }\n }\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e61);\n }\n }\n peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };\n return s0;\n }\n function peg$parsemacro_parameter() {\n var s0, s1;\n var key = peg$currPos * 52 + 36;\n var cached = peg$resultsCache[key];\n if (cached) {\n peg$currPos = cached.nextPos;\n return cached.result;\n }\n s0 = peg$currPos;\n if (input.charCodeAt(peg$currPos) === 35) {\n s1 = peg$c43;\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e65);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = s0;\n s1 = peg$f62(s1);\n }\n s0 = s1;\n peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };\n return s0;\n }\n function peg$parsesuperscript() {\n var s0, s1;\n var key = peg$currPos * 52 + 37;\n var cached = peg$resultsCache[key];\n if (cached) {\n peg$currPos = cached.nextPos;\n return cached.result;\n }\n s0 = peg$currPos;\n if (input.charCodeAt(peg$currPos) === 94) {\n s1 = peg$c44;\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e66);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = s0;\n s1 = peg$f63(s1);\n }\n s0 = s1;\n peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };\n return s0;\n }\n function peg$parsesubscript() {\n var s0, s1;\n var key = peg$currPos * 52 + 38;\n var cached = peg$resultsCache[key];\n if (cached) {\n peg$currPos = cached.nextPos;\n return cached.result;\n }\n s0 = peg$currPos;\n if (input.charCodeAt(peg$currPos) === 95) {\n s1 = peg$c45;\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e67);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = s0;\n s1 = peg$f64(s1);\n }\n s0 = s1;\n peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };\n return s0;\n }\n function peg$parseignore() {\n var s0;\n var key = peg$currPos * 52 + 39;\n var cached = peg$resultsCache[key];\n if (cached) {\n peg$currPos = cached.nextPos;\n return cached.result;\n }\n if (input.charCodeAt(peg$currPos) === 0) {\n s0 = peg$c46;\n peg$currPos++;\n } else {\n s0 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e68);\n }\n }\n peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };\n return s0;\n }\n function peg$parsesp() {\n var s0, s1, s2;\n var key = peg$currPos * 52 + 40;\n var cached = peg$resultsCache[key];\n if (cached) {\n peg$currPos = cached.nextPos;\n return cached.result;\n }\n peg$silentFails++;\n s0 = peg$currPos;\n s1 = [];\n if (peg$r1.test(input.charAt(peg$currPos))) {\n s2 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s2 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e69);\n }\n }\n if (s2 !== peg$FAILED) {\n while (s2 !== peg$FAILED) {\n s1.push(s2);\n if (peg$r1.test(input.charAt(peg$currPos))) {\n s2 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s2 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e69);\n }\n }\n }\n } else {\n s1 = peg$FAILED;\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = s0;\n s1 = peg$f65();\n }\n s0 = s1;\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e8);\n }\n }\n peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };\n return s0;\n }\n function peg$parsechar() {\n var s0, s1;\n var key = peg$currPos * 52 + 41;\n var cached = peg$resultsCache[key];\n if (cached) {\n peg$currPos = cached.nextPos;\n return cached.result;\n }\n peg$silentFails++;\n if (peg$r2.test(input.charAt(peg$currPos))) {\n s0 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s0 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e71);\n }\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e70);\n }\n }\n peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };\n return s0;\n }\n function peg$parsenum() {\n var s0, s1;\n var key = peg$currPos * 52 + 42;\n var cached = peg$resultsCache[key];\n if (cached) {\n peg$currPos = cached.nextPos;\n return cached.result;\n }\n peg$silentFails++;\n if (peg$r3.test(input.charAt(peg$currPos))) {\n s0 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s0 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e73);\n }\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e72);\n }\n }\n peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };\n return s0;\n }\n function peg$parsepunctuation() {\n var s0, s1;\n var key = peg$currPos * 52 + 43;\n var cached = peg$resultsCache[key];\n if (cached) {\n peg$currPos = cached.nextPos;\n return cached.result;\n }\n peg$silentFails++;\n s0 = peg$currPos;\n if (peg$r4.test(input.charAt(peg$currPos))) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e75);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = s0;\n s1 = peg$f66(s1);\n }\n s0 = s1;\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e74);\n }\n }\n peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };\n return s0;\n }\n function peg$parsecomment_start() {\n var s0;\n var key = peg$currPos * 52 + 44;\n var cached = peg$resultsCache[key];\n if (cached) {\n peg$currPos = cached.nextPos;\n return cached.result;\n }\n if (input.charCodeAt(peg$currPos) === 37) {\n s0 = peg$c0;\n peg$currPos++;\n } else {\n s0 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e7);\n }\n }\n peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };\n return s0;\n }\n function peg$parsefull_comment() {\n var s0, s1;\n var key = peg$currPos * 52 + 45;\n var cached = peg$resultsCache[key];\n if (cached) {\n peg$currPos = cached.nextPos;\n return cached.result;\n }\n peg$silentFails++;\n s0 = peg$parseownline_comment();\n if (s0 === peg$FAILED) {\n s0 = peg$parsesameline_comment();\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e76);\n }\n }\n peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };\n return s0;\n }\n function peg$parseownline_comment() {\n var s0, s1, s2, s3;\n var key = peg$currPos * 52 + 46;\n var cached = peg$resultsCache[key];\n if (cached) {\n peg$currPos = cached.nextPos;\n return cached.result;\n }\n s0 = peg$currPos;\n s1 = peg$currPos;\n s2 = [];\n s3 = peg$parsesp();\n while (s3 !== peg$FAILED) {\n s2.push(s3);\n s3 = peg$parsesp();\n }\n s3 = peg$parsenl();\n if (s3 !== peg$FAILED) {\n s2 = [s2, s3];\n s1 = s2;\n } else {\n peg$currPos = s1;\n s1 = peg$FAILED;\n }\n if (s1 === peg$FAILED) {\n s1 = null;\n }\n s2 = peg$parseleading_sp();\n if (s2 !== peg$FAILED) {\n s3 = peg$parsecomment();\n if (s3 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f67(s2, s3);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };\n return s0;\n }\n function peg$parsesameline_comment() {\n var s0, s1, s2;\n var key = peg$currPos * 52 + 47;\n var cached = peg$resultsCache[key];\n if (cached) {\n peg$currPos = cached.nextPos;\n return cached.result;\n }\n s0 = peg$currPos;\n s1 = [];\n s2 = peg$parsesp();\n while (s2 !== peg$FAILED) {\n s1.push(s2);\n s2 = peg$parsesp();\n }\n s2 = peg$parsecomment();\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f68(s1, s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };\n return s0;\n }\n function peg$parsecomment() {\n var s0, s1, s2, s3, s4, s5, s6, s7;\n var key = peg$currPos * 52 + 48;\n var cached = peg$resultsCache[key];\n if (cached) {\n peg$currPos = cached.nextPos;\n return cached.result;\n }\n peg$silentFails++;\n s0 = peg$currPos;\n s1 = peg$parsecomment_start();\n if (s1 !== peg$FAILED) {\n s2 = [];\n s3 = peg$currPos;\n s4 = peg$currPos;\n peg$silentFails++;\n s5 = peg$parsenl();\n peg$silentFails--;\n if (s5 === peg$FAILED) {\n s4 = void 0;\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n if (s4 !== peg$FAILED) {\n if (input.length > peg$currPos) {\n s5 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s5 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e3);\n }\n }\n if (s5 !== peg$FAILED) {\n peg$savedPos = s3;\n s3 = peg$f69(s5);\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n while (s3 !== peg$FAILED) {\n s2.push(s3);\n s3 = peg$currPos;\n s4 = peg$currPos;\n peg$silentFails++;\n s5 = peg$parsenl();\n peg$silentFails--;\n if (s5 === peg$FAILED) {\n s4 = void 0;\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n if (s4 !== peg$FAILED) {\n if (input.length > peg$currPos) {\n s5 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s5 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e3);\n }\n }\n if (s5 !== peg$FAILED) {\n peg$savedPos = s3;\n s3 = peg$f69(s5);\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n }\n s3 = peg$currPos;\n peg$silentFails++;\n s4 = peg$parseparbreak();\n peg$silentFails--;\n if (s4 !== peg$FAILED) {\n peg$currPos = s3;\n s3 = void 0;\n } else {\n s3 = peg$FAILED;\n }\n if (s3 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f70(s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n if (s0 === peg$FAILED) {\n s0 = peg$currPos;\n s1 = peg$parsecomment_start();\n if (s1 !== peg$FAILED) {\n s2 = [];\n s3 = peg$currPos;\n s4 = peg$currPos;\n peg$silentFails++;\n s5 = peg$parsenl();\n peg$silentFails--;\n if (s5 === peg$FAILED) {\n s4 = void 0;\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n if (s4 !== peg$FAILED) {\n if (input.length > peg$currPos) {\n s5 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s5 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e3);\n }\n }\n if (s5 !== peg$FAILED) {\n peg$savedPos = s3;\n s3 = peg$f71(s5);\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n while (s3 !== peg$FAILED) {\n s2.push(s3);\n s3 = peg$currPos;\n s4 = peg$currPos;\n peg$silentFails++;\n s5 = peg$parsenl();\n peg$silentFails--;\n if (s5 === peg$FAILED) {\n s4 = void 0;\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n if (s4 !== peg$FAILED) {\n if (input.length > peg$currPos) {\n s5 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s5 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e3);\n }\n }\n if (s5 !== peg$FAILED) {\n peg$savedPos = s3;\n s3 = peg$f71(s5);\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n }\n s3 = peg$currPos;\n s4 = peg$parsenl();\n if (s4 !== peg$FAILED) {\n s5 = [];\n s6 = peg$parsesp();\n while (s6 !== peg$FAILED) {\n s5.push(s6);\n s6 = peg$parsesp();\n }\n s6 = peg$currPos;\n peg$silentFails++;\n s7 = peg$parsecomment_start();\n peg$silentFails--;\n if (s7 === peg$FAILED) {\n s6 = void 0;\n } else {\n peg$currPos = s6;\n s6 = peg$FAILED;\n }\n if (s6 !== peg$FAILED) {\n s4 = [s4, s5, s6];\n s3 = s4;\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n if (s3 === peg$FAILED) {\n s3 = peg$parsenl();\n if (s3 === peg$FAILED) {\n s3 = peg$parseEOF();\n }\n }\n if (s3 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f72(s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e77);\n }\n }\n peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };\n return s0;\n }\n function peg$parseleading_sp() {\n var s0, s1, s2, s3, s4;\n var key = peg$currPos * 52 + 49;\n var cached = peg$resultsCache[key];\n if (cached) {\n peg$currPos = cached.nextPos;\n return cached.result;\n }\n s0 = peg$currPos;\n s1 = peg$currPos;\n s2 = peg$parsestart_of_line();\n if (s2 !== peg$FAILED) {\n s3 = [];\n s4 = peg$parsesp();\n while (s4 !== peg$FAILED) {\n s3.push(s4);\n s4 = peg$parsesp();\n }\n s2 = [s2, s3];\n s1 = s2;\n } else {\n peg$currPos = s1;\n s1 = peg$FAILED;\n }\n if (s1 !== peg$FAILED) {\n s0 = input.substring(s0, peg$currPos);\n } else {\n s0 = s1;\n }\n peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };\n return s0;\n }\n function peg$parsestart_of_line() {\n var s0;\n var key = peg$currPos * 52 + 50;\n var cached = peg$resultsCache[key];\n if (cached) {\n peg$currPos = cached.nextPos;\n return cached.result;\n }\n peg$savedPos = peg$currPos;\n s0 = peg$f73();\n if (s0) {\n s0 = void 0;\n } else {\n s0 = peg$FAILED;\n }\n peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };\n return s0;\n }\n function peg$parseEOF() {\n var s0, s1;\n var key = peg$currPos * 52 + 51;\n var cached = peg$resultsCache[key];\n if (cached) {\n peg$currPos = cached.nextPos;\n return cached.result;\n }\n s0 = peg$currPos;\n peg$silentFails++;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e3);\n }\n }\n peg$silentFails--;\n if (s1 === peg$FAILED) {\n s0 = void 0;\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };\n return s0;\n }\n function toString(e) {\n if (typeof e === \"string\") {\n return e;\n }\n if (typeof e.content === \"string\") {\n return e.content;\n }\n if (e && e.type === \"whitespace\") {\n return \" \";\n }\n return e;\n }\n function compare_env(g1, g2) {\n const g1Name = typeof g1 === \"string\" ? g1 : g1.content.map(toString).join(\"\");\n const g2Name = typeof g2 === \"string\" ? g2 : g2.content.map(toString).join(\"\");\n return g1Name === g2Name;\n }\n function createNode(type, extra = {}) {\n return { type, ...extra, position: location() };\n }\n peg$result = peg$startRuleFunction();\n if (peg$result !== peg$FAILED && peg$currPos === input.length) {\n return peg$result;\n } else {\n if (peg$result !== peg$FAILED && peg$currPos < input.length) {\n peg$fail(peg$endExpectation());\n }\n throw peg$buildStructuredError(\n peg$maxFailExpected,\n peg$maxFailPos < input.length ? input.charAt(peg$maxFailPos) : null,\n peg$maxFailPos < input.length ? peg$computeLocation(peg$maxFailPos, peg$maxFailPos + 1) : peg$computeLocation(peg$maxFailPos, peg$maxFailPos)\n );\n }\n }\n return {\n SyntaxError: peg$SyntaxError,\n parse: peg$parse\n };\n }()\n);\n","export default (\n // Generated by Peggy 3.0.2.\n //\n // https://peggyjs.org/\n function() {\n \"use strict\";\n function peg$subclass(child, parent) {\n function C() {\n this.constructor = child;\n }\n C.prototype = parent.prototype;\n child.prototype = new C();\n }\n function peg$SyntaxError(message, expected, found, location) {\n var self = Error.call(this, message);\n if (Object.setPrototypeOf) {\n Object.setPrototypeOf(self, peg$SyntaxError.prototype);\n }\n self.expected = expected;\n self.found = found;\n self.location = location;\n self.name = \"SyntaxError\";\n return self;\n }\n peg$subclass(peg$SyntaxError, Error);\n function peg$padEnd(str, targetLength, padString) {\n padString = padString || \" \";\n if (str.length > targetLength) {\n return str;\n }\n targetLength -= str.length;\n padString += padString.repeat(targetLength);\n return str + padString.slice(0, targetLength);\n }\n peg$SyntaxError.prototype.format = function(sources) {\n var str = \"Error: \" + this.message;\n if (this.location) {\n var src = null;\n var k;\n for (k = 0; k < sources.length; k++) {\n if (sources[k].source === this.location.source) {\n src = sources[k].text.split(/\\r\\n|\\n|\\r/g);\n break;\n }\n }\n var s = this.location.start;\n var offset_s = this.location.source && typeof this.location.source.offset === \"function\" ? this.location.source.offset(s) : s;\n var loc = this.location.source + \":\" + offset_s.line + \":\" + offset_s.column;\n if (src) {\n var e = this.location.end;\n var filler = peg$padEnd(\"\", offset_s.line.toString().length, \" \");\n var line = src[s.line - 1];\n var last = s.line === e.line ? e.column : line.length + 1;\n var hatLen = last - s.column || 1;\n str += \"\\n --> \" + loc + \"\\n\" + filler + \" |\\n\" + offset_s.line + \" | \" + line + \"\\n\" + filler + \" | \" + peg$padEnd(\"\", s.column - 1, \" \") + peg$padEnd(\"\", hatLen, \"^\");\n } else {\n str += \"\\n at \" + loc;\n }\n }\n return str;\n };\n peg$SyntaxError.buildMessage = function(expected, found) {\n var DESCRIBE_EXPECTATION_FNS = {\n literal: function(expectation) {\n return '\"' + literalEscape(expectation.text) + '\"';\n },\n class: function(expectation) {\n var escapedParts = expectation.parts.map(function(part) {\n return Array.isArray(part) ? classEscape(part[0]) + \"-\" + classEscape(part[1]) : classEscape(part);\n });\n return \"[\" + (expectation.inverted ? \"^\" : \"\") + escapedParts.join(\"\") + \"]\";\n },\n any: function() {\n return \"any character\";\n },\n end: function() {\n return \"end of input\";\n },\n other: function(expectation) {\n return expectation.description;\n }\n };\n function hex(ch) {\n return ch.charCodeAt(0).toString(16).toUpperCase();\n }\n function literalEscape(s) {\n return s.replace(/\\\\/g, \"\\\\\\\\\").replace(/\"/g, '\\\\\"').replace(/\\0/g, \"\\\\0\").replace(/\\t/g, \"\\\\t\").replace(/\\n/g, \"\\\\n\").replace(/\\r/g, \"\\\\r\").replace(/[\\x00-\\x0F]/g, function(ch) {\n return \"\\\\x0\" + hex(ch);\n }).replace(/[\\x10-\\x1F\\x7F-\\x9F]/g, function(ch) {\n return \"\\\\x\" + hex(ch);\n });\n }\n function classEscape(s) {\n return s.replace(/\\\\/g, \"\\\\\\\\\").replace(/\\]/g, \"\\\\]\").replace(/\\^/g, \"\\\\^\").replace(/-/g, \"\\\\-\").replace(/\\0/g, \"\\\\0\").replace(/\\t/g, \"\\\\t\").replace(/\\n/g, \"\\\\n\").replace(/\\r/g, \"\\\\r\").replace(/[\\x00-\\x0F]/g, function(ch) {\n return \"\\\\x0\" + hex(ch);\n }).replace(/[\\x10-\\x1F\\x7F-\\x9F]/g, function(ch) {\n return \"\\\\x\" + hex(ch);\n });\n }\n function describeExpectation(expectation) {\n return DESCRIBE_EXPECTATION_FNS[expectation.type](expectation);\n }\n function describeExpected(expected2) {\n var descriptions = expected2.map(describeExpectation);\n var i, j;\n descriptions.sort();\n if (descriptions.length > 0) {\n for (i = 1, j = 1; i < descriptions.length; i++) {\n if (descriptions[i - 1] !== descriptions[i]) {\n descriptions[j] = descriptions[i];\n j++;\n }\n }\n descriptions.length = j;\n }\n switch (descriptions.length) {\n case 1:\n return descriptions[0];\n case 2:\n return descriptions[0] + \" or \" + descriptions[1];\n default:\n return descriptions.slice(0, -1).join(\", \") + \", or \" + descriptions[descriptions.length - 1];\n }\n }\n function describeFound(found2) {\n return found2 ? '\"' + literalEscape(found2) + '\"' : \"end of input\";\n }\n return \"Expected \" + describeExpected(expected) + \" but \" + describeFound(found) + \" found.\";\n };\n function peg$parse(input, options) {\n options = options !== void 0 ? options : {};\n var peg$FAILED = {};\n var peg$source = options.grammarSource;\n var peg$startRuleFunctions = { body: peg$parsebody };\n var peg$startRuleFunction = peg$parsebody;\n var peg$e0 = peg$anyExpectation();\n var peg$f0 = function() {\n return [];\n };\n var peg$f1 = function(x) {\n return { cells: [], colSeps: [], ...x };\n };\n var peg$f2 = function(rowItems, rowSep, trailingComment) {\n return { ...rowItems, rowSep, trailingComment };\n };\n var peg$f3 = function(rowItems, trailingComment) {\n return { ...rowItems, rowSep: null, trailingComment };\n };\n var peg$f4 = function(x) {\n return x;\n };\n var peg$f5 = function(x) {\n return {\n cells: [],\n colSeps: [],\n rowSep: null,\n trailingComment: x\n };\n };\n var peg$f6 = function(x) {\n return x;\n };\n var peg$f7 = function(colSep, cell) {\n return { colSep, cell };\n };\n var peg$f8 = function(colSep) {\n return { colSep };\n };\n var peg$f9 = function(a, b) {\n return processRow(a, b);\n };\n var peg$f10 = function(b) {\n return processRow(null, b);\n };\n var peg$f11 = function(tok) {\n return options.isSameLineComment(tok);\n };\n var peg$f12 = function(tok) {\n return tok;\n };\n var peg$f13 = function(tok) {\n return options.isOwnLineComment(tok);\n };\n var peg$f14 = function(tok) {\n return tok;\n };\n var peg$f15 = function(tok) {\n return options.isWhitespace(tok);\n };\n var peg$f16 = function(tok) {\n return tok;\n };\n var peg$f17 = function(tok) {\n return options.isRowSep(tok);\n };\n var peg$f18 = function(tok) {\n return tok;\n };\n var peg$f19 = function(tok) {\n return options.isColSep(tok);\n };\n var peg$f20 = function(tok) {\n return tok;\n };\n var peg$currPos = 0;\n var peg$savedPos = 0;\n var peg$posDetailsCache = [{ line: 1, column: 1 }];\n var peg$maxFailPos = 0;\n var peg$maxFailExpected = [];\n var peg$silentFails = 0;\n var peg$result;\n if (\"startRule\" in options) {\n if (!(options.startRule in peg$startRuleFunctions)) {\n throw new Error(`Can't start parsing from rule \"` + options.startRule + '\".');\n }\n peg$startRuleFunction = peg$startRuleFunctions[options.startRule];\n }\n function text() {\n return input.substring(peg$savedPos, peg$currPos);\n }\n function offset() {\n return peg$savedPos;\n }\n function range() {\n return {\n source: peg$source,\n start: peg$savedPos,\n end: peg$currPos\n };\n }\n function location() {\n return peg$computeLocation(peg$savedPos, peg$currPos);\n }\n function expected(description, location2) {\n location2 = location2 !== void 0 ? location2 : peg$computeLocation(peg$savedPos, peg$currPos);\n throw peg$buildStructuredError(\n [peg$otherExpectation(description)],\n input.substring(peg$savedPos, peg$currPos),\n location2\n );\n }\n function error(message, location2) {\n location2 = location2 !== void 0 ? location2 : peg$computeLocation(peg$savedPos, peg$currPos);\n throw peg$buildSimpleError(message, location2);\n }\n function peg$literalExpectation(text2, ignoreCase) {\n return { type: \"literal\", text: text2, ignoreCase };\n }\n function peg$classExpectation(parts, inverted, ignoreCase) {\n return { type: \"class\", parts, inverted, ignoreCase };\n }\n function peg$anyExpectation() {\n return { type: \"any\" };\n }\n function peg$endExpectation() {\n return { type: \"end\" };\n }\n function peg$otherExpectation(description) {\n return { type: \"other\", description };\n }\n function peg$computePosDetails(pos) {\n var details = peg$posDetailsCache[pos];\n var p;\n if (details) {\n return details;\n } else {\n p = pos - 1;\n while (!peg$posDetailsCache[p]) {\n p--;\n }\n details = peg$posDetailsCache[p];\n details = {\n line: details.line,\n column: details.column\n };\n while (p < pos) {\n if (input.charCodeAt(p) === 10) {\n details.line++;\n details.column = 1;\n } else {\n details.column++;\n }\n p++;\n }\n peg$posDetailsCache[pos] = details;\n return details;\n }\n }\n function peg$computeLocation(startPos, endPos, offset2) {\n var startPosDetails = peg$computePosDetails(startPos);\n var endPosDetails = peg$computePosDetails(endPos);\n var res = {\n source: peg$source,\n start: {\n offset: startPos,\n line: startPosDetails.line,\n column: startPosDetails.column\n },\n end: {\n offset: endPos,\n line: endPosDetails.line,\n column: endPosDetails.column\n }\n };\n if (offset2 && peg$source && typeof peg$source.offset === \"function\") {\n res.start = peg$source.offset(res.start);\n res.end = peg$source.offset(res.end);\n }\n return res;\n }\n function peg$fail(expected2) {\n if (peg$currPos < peg$maxFailPos) {\n return;\n }\n if (peg$currPos > peg$maxFailPos) {\n peg$maxFailPos = peg$currPos;\n peg$maxFailExpected = [];\n }\n peg$maxFailExpected.push(expected2);\n }\n function peg$buildSimpleError(message, location2) {\n return new peg$SyntaxError(message, null, null, location2);\n }\n function peg$buildStructuredError(expected2, found, location2) {\n return new peg$SyntaxError(\n peg$SyntaxError.buildMessage(expected2, found),\n expected2,\n found,\n location2\n );\n }\n function peg$parsebody() {\n var s0, s1;\n s0 = [];\n s1 = peg$parsecomment_only_line();\n if (s1 === peg$FAILED) {\n s1 = peg$parserow_with_end();\n if (s1 === peg$FAILED) {\n s1 = peg$parserow_without_end();\n }\n }\n if (s1 !== peg$FAILED) {\n while (s1 !== peg$FAILED) {\n s0.push(s1);\n s1 = peg$parsecomment_only_line();\n if (s1 === peg$FAILED) {\n s1 = peg$parserow_with_end();\n if (s1 === peg$FAILED) {\n s1 = peg$parserow_without_end();\n }\n }\n }\n } else {\n s0 = peg$FAILED;\n }\n if (s0 === peg$FAILED) {\n s0 = peg$currPos;\n s1 = peg$parseEOL();\n if (s1 !== peg$FAILED) {\n peg$savedPos = s0;\n s1 = peg$f0();\n }\n s0 = s1;\n }\n return s0;\n }\n function peg$parserow_with_end() {\n var s0, s1, s2, s3;\n s0 = peg$currPos;\n s1 = peg$currPos;\n s2 = peg$parserow_items();\n if (s2 === peg$FAILED) {\n s2 = null;\n }\n peg$savedPos = s1;\n s2 = peg$f1(s2);\n s1 = s2;\n s2 = peg$parserow_sep();\n if (s2 !== peg$FAILED) {\n s3 = peg$parsetrailing_comment();\n if (s3 === peg$FAILED) {\n s3 = null;\n }\n peg$savedPos = s0;\n s0 = peg$f2(s1, s2, s3);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parserow_without_end() {\n var s0, s1, s2;\n s0 = peg$currPos;\n s1 = peg$parserow_items();\n if (s1 !== peg$FAILED) {\n s2 = peg$parsetrailing_comment();\n if (s2 === peg$FAILED) {\n s2 = null;\n }\n peg$savedPos = s0;\n s0 = peg$f3(s1, s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parsetrailing_comment() {\n var s0, s1, s2;\n s0 = peg$currPos;\n s1 = [];\n s2 = peg$parsewhitespace();\n while (s2 !== peg$FAILED) {\n s1.push(s2);\n s2 = peg$parsewhitespace();\n }\n s2 = peg$parsesame_line_comment();\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f4(s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parsecomment_only_line() {\n var s0, s1, s2;\n s0 = peg$currPos;\n s1 = [];\n s2 = peg$parsewhitespace();\n while (s2 !== peg$FAILED) {\n s1.push(s2);\n s2 = peg$parsewhitespace();\n }\n s2 = peg$parseown_line_comment();\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f5(s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parsetoken() {\n var s0, s1, s2;\n s0 = peg$currPos;\n s1 = peg$currPos;\n peg$silentFails++;\n s2 = peg$parserow_sep();\n if (s2 === peg$FAILED) {\n s2 = peg$parsecol_sep();\n if (s2 === peg$FAILED) {\n s2 = peg$parsetrailing_comment();\n if (s2 === peg$FAILED) {\n s2 = peg$parseown_line_comment();\n }\n }\n }\n peg$silentFails--;\n if (s2 === peg$FAILED) {\n s1 = void 0;\n } else {\n peg$currPos = s1;\n s1 = peg$FAILED;\n }\n if (s1 !== peg$FAILED) {\n if (input.length > peg$currPos) {\n s2 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s2 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f6(s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parsecell() {\n var s0, s1, s2;\n s0 = peg$currPos;\n s1 = [];\n s2 = peg$parsetoken();\n if (s2 !== peg$FAILED) {\n while (s2 !== peg$FAILED) {\n s1.push(s2);\n s2 = peg$parsetoken();\n }\n } else {\n s1 = peg$FAILED;\n }\n if (s1 !== peg$FAILED) {\n s0 = input.substring(s0, peg$currPos);\n } else {\n s0 = s1;\n }\n return s0;\n }\n function peg$parseseparated_cell() {\n var s0, s1, s2;\n s0 = peg$currPos;\n s1 = peg$parsecol_sep();\n if (s1 !== peg$FAILED) {\n s2 = peg$parsecell();\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f7(s1, s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n if (s0 === peg$FAILED) {\n s0 = peg$currPos;\n s1 = peg$parsecol_sep();\n if (s1 !== peg$FAILED) {\n peg$savedPos = s0;\n s1 = peg$f8(s1);\n }\n s0 = s1;\n }\n return s0;\n }\n function peg$parserow_items() {\n var s0, s1, s2, s3;\n s0 = peg$currPos;\n s1 = peg$parsecell();\n if (s1 !== peg$FAILED) {\n s2 = [];\n s3 = peg$parseseparated_cell();\n while (s3 !== peg$FAILED) {\n s2.push(s3);\n s3 = peg$parseseparated_cell();\n }\n peg$savedPos = s0;\n s0 = peg$f9(s1, s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n if (s0 === peg$FAILED) {\n s0 = peg$currPos;\n s1 = [];\n s2 = peg$parseseparated_cell();\n if (s2 !== peg$FAILED) {\n while (s2 !== peg$FAILED) {\n s1.push(s2);\n s2 = peg$parseseparated_cell();\n }\n } else {\n s1 = peg$FAILED;\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = s0;\n s1 = peg$f10(s1);\n }\n s0 = s1;\n }\n return s0;\n }\n function peg$parsesame_line_comment() {\n var s0, s1, s2;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f11(s1);\n if (s2) {\n s2 = void 0;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f12(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parseown_line_comment() {\n var s0, s1, s2;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f13(s1);\n if (s2) {\n s2 = void 0;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f14(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parsewhitespace() {\n var s0, s1, s2;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f15(s1);\n if (s2) {\n s2 = void 0;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f16(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parserow_sep() {\n var s0, s1, s2;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f17(s1);\n if (s2) {\n s2 = void 0;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f18(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parsecol_sep() {\n var s0, s1, s2;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f19(s1);\n if (s2) {\n s2 = void 0;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f20(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parseEOL() {\n var s0, s1;\n s0 = peg$currPos;\n peg$silentFails++;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n peg$silentFails--;\n if (s1 === peg$FAILED) {\n s0 = void 0;\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function processRow(leadCell, otherCells) {\n const cells = [leadCell || []];\n const seps = [];\n for (const x of otherCells) {\n cells.push(x.cell || []);\n seps.push(x.colSep);\n }\n return { cells, colSeps: seps };\n }\n if (!options.isWhitespace) {\n try {\n Object.assign(\n options,\n createMatchers([\"\\\\\", \"hline\", \"cr\"], [\"&\"])\n );\n } catch (e) {\n console.warn(\"Error when initializing parser\", e);\n }\n }\n peg$result = peg$startRuleFunction();\n if (peg$result !== peg$FAILED && peg$currPos === input.length) {\n return peg$result;\n } else {\n if (peg$result !== peg$FAILED && peg$currPos < input.length) {\n peg$fail(peg$endExpectation());\n }\n throw peg$buildStructuredError(\n peg$maxFailExpected,\n peg$maxFailPos < input.length ? input.charAt(peg$maxFailPos) : null,\n peg$maxFailPos < input.length ? peg$computeLocation(peg$maxFailPos, peg$maxFailPos + 1) : peg$computeLocation(peg$maxFailPos, peg$maxFailPos)\n );\n }\n }\n return {\n SyntaxError: peg$SyntaxError,\n parse: peg$parse\n };\n }()\n);\n","export default (\n // Generated by Peggy 3.0.2.\n //\n // https://peggyjs.org/\n function() {\n \"use strict\";\n function peg$subclass(child, parent) {\n function C() {\n this.constructor = child;\n }\n C.prototype = parent.prototype;\n child.prototype = new C();\n }\n function peg$SyntaxError(message, expected, found, location) {\n var self = Error.call(this, message);\n if (Object.setPrototypeOf) {\n Object.setPrototypeOf(self, peg$SyntaxError.prototype);\n }\n self.expected = expected;\n self.found = found;\n self.location = location;\n self.name = \"SyntaxError\";\n return self;\n }\n peg$subclass(peg$SyntaxError, Error);\n function peg$padEnd(str, targetLength, padString) {\n padString = padString || \" \";\n if (str.length > targetLength) {\n return str;\n }\n targetLength -= str.length;\n padString += padString.repeat(targetLength);\n return str + padString.slice(0, targetLength);\n }\n peg$SyntaxError.prototype.format = function(sources) {\n var str = \"Error: \" + this.message;\n if (this.location) {\n var src = null;\n var k;\n for (k = 0; k < sources.length; k++) {\n if (sources[k].source === this.location.source) {\n src = sources[k].text.split(/\\r\\n|\\n|\\r/g);\n break;\n }\n }\n var s = this.location.start;\n var offset_s = this.location.source && typeof this.location.source.offset === \"function\" ? this.location.source.offset(s) : s;\n var loc = this.location.source + \":\" + offset_s.line + \":\" + offset_s.column;\n if (src) {\n var e = this.location.end;\n var filler = peg$padEnd(\"\", offset_s.line.toString().length, \" \");\n var line = src[s.line - 1];\n var last = s.line === e.line ? e.column : line.length + 1;\n var hatLen = last - s.column || 1;\n str += \"\\n --> \" + loc + \"\\n\" + filler + \" |\\n\" + offset_s.line + \" | \" + line + \"\\n\" + filler + \" | \" + peg$padEnd(\"\", s.column - 1, \" \") + peg$padEnd(\"\", hatLen, \"^\");\n } else {\n str += \"\\n at \" + loc;\n }\n }\n return str;\n };\n peg$SyntaxError.buildMessage = function(expected, found) {\n var DESCRIBE_EXPECTATION_FNS = {\n literal: function(expectation) {\n return '\"' + literalEscape(expectation.text) + '\"';\n },\n class: function(expectation) {\n var escapedParts = expectation.parts.map(function(part) {\n return Array.isArray(part) ? classEscape(part[0]) + \"-\" + classEscape(part[1]) : classEscape(part);\n });\n return \"[\" + (expectation.inverted ? \"^\" : \"\") + escapedParts.join(\"\") + \"]\";\n },\n any: function() {\n return \"any character\";\n },\n end: function() {\n return \"end of input\";\n },\n other: function(expectation) {\n return expectation.description;\n }\n };\n function hex(ch) {\n return ch.charCodeAt(0).toString(16).toUpperCase();\n }\n function literalEscape(s) {\n return s.replace(/\\\\/g, \"\\\\\\\\\").replace(/\"/g, '\\\\\"').replace(/\\0/g, \"\\\\0\").replace(/\\t/g, \"\\\\t\").replace(/\\n/g, \"\\\\n\").replace(/\\r/g, \"\\\\r\").replace(/[\\x00-\\x0F]/g, function(ch) {\n return \"\\\\x0\" + hex(ch);\n }).replace(/[\\x10-\\x1F\\x7F-\\x9F]/g, function(ch) {\n return \"\\\\x\" + hex(ch);\n });\n }\n function classEscape(s) {\n return s.replace(/\\\\/g, \"\\\\\\\\\").replace(/\\]/g, \"\\\\]\").replace(/\\^/g, \"\\\\^\").replace(/-/g, \"\\\\-\").replace(/\\0/g, \"\\\\0\").replace(/\\t/g, \"\\\\t\").replace(/\\n/g, \"\\\\n\").replace(/\\r/g, \"\\\\r\").replace(/[\\x00-\\x0F]/g, function(ch) {\n return \"\\\\x0\" + hex(ch);\n }).replace(/[\\x10-\\x1F\\x7F-\\x9F]/g, function(ch) {\n return \"\\\\x\" + hex(ch);\n });\n }\n function describeExpectation(expectation) {\n return DESCRIBE_EXPECTATION_FNS[expectation.type](expectation);\n }\n function describeExpected(expected2) {\n var descriptions = expected2.map(describeExpectation);\n var i, j;\n descriptions.sort();\n if (descriptions.length > 0) {\n for (i = 1, j = 1; i < descriptions.length; i++) {\n if (descriptions[i - 1] !== descriptions[i]) {\n descriptions[j] = descriptions[i];\n j++;\n }\n }\n descriptions.length = j;\n }\n switch (descriptions.length) {\n case 1:\n return descriptions[0];\n case 2:\n return descriptions[0] + \" or \" + descriptions[1];\n default:\n return descriptions.slice(0, -1).join(\", \") + \", or \" + descriptions[descriptions.length - 1];\n }\n }\n function describeFound(found2) {\n return found2 ? '\"' + literalEscape(found2) + '\"' : \"end of input\";\n }\n return \"Expected \" + describeExpected(expected) + \" but \" + describeFound(found) + \" found.\";\n };\n function peg$parse(input, options) {\n options = options !== void 0 ? options : {};\n var peg$FAILED = {};\n var peg$source = options.grammarSource;\n var peg$startRuleFunctions = { args_spec_list: peg$parseargs_spec_list };\n var peg$startRuleFunction = peg$parseargs_spec_list;\n var peg$c0 = \"+\";\n var peg$c1 = \"v\";\n var peg$c2 = \"b\";\n var peg$c3 = \"!\";\n var peg$c4 = \"D\";\n var peg$c5 = \"d\";\n var peg$c6 = \"s\";\n var peg$c7 = \"O\";\n var peg$c8 = \"o\";\n var peg$c9 = \"e\";\n var peg$c10 = \"E\";\n var peg$c11 = \"t\";\n var peg$c12 = \"R\";\n var peg$c13 = \"r\";\n var peg$c14 = \"u\";\n var peg$c15 = \"m\";\n var peg$c16 = \"{\";\n var peg$c17 = \"}\";\n var peg$c18 = \" \";\n var peg$c19 = \"\\n\";\n var peg$c20 = \"\\r\";\n var peg$c21 = \"\\\\\";\n var peg$r0 = /^[{ ]/;\n var peg$r1 = /^[a-zA-Z]/;\n var peg$r2 = /^[{}]/;\n var peg$e0 = peg$literalExpectation(\"+\", false);\n var peg$e1 = peg$literalExpectation(\"v\", false);\n var peg$e2 = peg$anyExpectation();\n var peg$e3 = peg$literalExpectation(\"b\", false);\n var peg$e4 = peg$literalExpectation(\"!\", false);\n var peg$e5 = peg$literalExpectation(\"D\", false);\n var peg$e6 = peg$literalExpectation(\"d\", false);\n var peg$e7 = peg$literalExpectation(\"s\", false);\n var peg$e8 = peg$literalExpectation(\"O\", false);\n var peg$e9 = peg$literalExpectation(\"o\", false);\n var peg$e10 = peg$literalExpectation(\"e\", false);\n var peg$e11 = peg$literalExpectation(\"E\", false);\n var peg$e12 = peg$literalExpectation(\"t\", false);\n var peg$e13 = peg$literalExpectation(\"R\", false);\n var peg$e14 = peg$literalExpectation(\"r\", false);\n var peg$e15 = peg$literalExpectation(\"u\", false);\n var peg$e16 = peg$classExpectation([\"{\", \" \"], false, false);\n var peg$e17 = peg$literalExpectation(\"m\", false);\n var peg$e18 = peg$literalExpectation(\"{\", false);\n var peg$e19 = peg$literalExpectation(\"}\", false);\n var peg$e20 = peg$literalExpectation(\" \", false);\n var peg$e21 = peg$literalExpectation(\"\\n\", false);\n var peg$e22 = peg$literalExpectation(\"\\r\", false);\n var peg$e23 = peg$literalExpectation(\"\\\\\", false);\n var peg$e24 = peg$classExpectation([[\"a\", \"z\"], [\"A\", \"Z\"]], false, false);\n var peg$e25 = peg$classExpectation([\"{\", \"}\"], false, false);\n var peg$f0 = function(x) {\n return x;\n };\n var peg$f1 = function(spec) {\n return spec;\n };\n var peg$f2 = function(spec) {\n return spec;\n };\n var peg$f3 = function(openBrace) {\n return createNode(\"verbatim\", { openBrace, closeBrace: openBrace });\n };\n var peg$f4 = function() {\n return createNode(\"body\");\n };\n var peg$f5 = function(leading_bang, spec) {\n return leading_bang ? { ...spec, noLeadingWhitespace: true } : spec;\n };\n var peg$f6 = function(braceSpec, defaultArg) {\n return createNode(\"optional\", { ...braceSpec, defaultArg });\n };\n var peg$f7 = function(braceSpec) {\n return createNode(\"optional\", braceSpec);\n };\n var peg$f8 = function() {\n return createNode(\"optionalStar\");\n };\n var peg$f9 = function(g) {\n return createNode(\"optional\", { defaultArg: g });\n };\n var peg$f10 = function() {\n return createNode(\"optional\");\n };\n var peg$f11 = function(args) {\n return createNode(\"embellishment\", {\n embellishmentTokens: args\n });\n };\n var peg$f12 = function(args, g) {\n return createNode(\"embellishment\", {\n embellishmentTokens: args,\n defaultArg: g\n });\n };\n var peg$f13 = function(tok) {\n return createNode(\"optionalToken\", { token: tok });\n };\n var peg$f14 = function(braceSpec, defaultArg) {\n return createNode(\"mandatory\", { ...braceSpec, defaultArg });\n };\n var peg$f15 = function(braceSpec) {\n return createNode(\"mandatory\", braceSpec);\n };\n var peg$f16 = function(stopTokens) {\n return createNode(\"until\", { stopTokens });\n };\n var peg$f17 = function(x) {\n return [x];\n };\n var peg$f18 = function(g) {\n return g.content;\n };\n var peg$f19 = function() {\n return createNode(\"mandatory\");\n };\n var peg$f20 = function(openBrace, closeBrace) {\n return { openBrace, closeBrace };\n };\n var peg$f21 = function(g) {\n return g.content.map(groupToStr).join(\"\");\n };\n var peg$f22 = function(t) {\n return [t];\n };\n var peg$f23 = function(args) {\n return args.filter((a) => !a.match(/^\\s*$/));\n };\n var peg$f24 = function(content) {\n return { type: \"group\", content };\n };\n var peg$f25 = function() {\n return \"\";\n };\n var peg$currPos = 0;\n var peg$savedPos = 0;\n var peg$posDetailsCache = [{ line: 1, column: 1 }];\n var peg$maxFailPos = 0;\n var peg$maxFailExpected = [];\n var peg$silentFails = 0;\n var peg$result;\n if (\"startRule\" in options) {\n if (!(options.startRule in peg$startRuleFunctions)) {\n throw new Error(`Can't start parsing from rule \"` + options.startRule + '\".');\n }\n peg$startRuleFunction = peg$startRuleFunctions[options.startRule];\n }\n function text() {\n return input.substring(peg$savedPos, peg$currPos);\n }\n function offset() {\n return peg$savedPos;\n }\n function range() {\n return {\n source: peg$source,\n start: peg$savedPos,\n end: peg$currPos\n };\n }\n function location() {\n return peg$computeLocation(peg$savedPos, peg$currPos);\n }\n function expected(description, location2) {\n location2 = location2 !== void 0 ? location2 : peg$computeLocation(peg$savedPos, peg$currPos);\n throw peg$buildStructuredError(\n [peg$otherExpectation(description)],\n input.substring(peg$savedPos, peg$currPos),\n location2\n );\n }\n function error(message, location2) {\n location2 = location2 !== void 0 ? location2 : peg$computeLocation(peg$savedPos, peg$currPos);\n throw peg$buildSimpleError(message, location2);\n }\n function peg$literalExpectation(text2, ignoreCase) {\n return { type: \"literal\", text: text2, ignoreCase };\n }\n function peg$classExpectation(parts, inverted, ignoreCase) {\n return { type: \"class\", parts, inverted, ignoreCase };\n }\n function peg$anyExpectation() {\n return { type: \"any\" };\n }\n function peg$endExpectation() {\n return { type: \"end\" };\n }\n function peg$otherExpectation(description) {\n return { type: \"other\", description };\n }\n function peg$computePosDetails(pos) {\n var details = peg$posDetailsCache[pos];\n var p;\n if (details) {\n return details;\n } else {\n p = pos - 1;\n while (!peg$posDetailsCache[p]) {\n p--;\n }\n details = peg$posDetailsCache[p];\n details = {\n line: details.line,\n column: details.column\n };\n while (p < pos) {\n if (input.charCodeAt(p) === 10) {\n details.line++;\n details.column = 1;\n } else {\n details.column++;\n }\n p++;\n }\n peg$posDetailsCache[pos] = details;\n return details;\n }\n }\n function peg$computeLocation(startPos, endPos, offset2) {\n var startPosDetails = peg$computePosDetails(startPos);\n var endPosDetails = peg$computePosDetails(endPos);\n var res = {\n source: peg$source,\n start: {\n offset: startPos,\n line: startPosDetails.line,\n column: startPosDetails.column\n },\n end: {\n offset: endPos,\n line: endPosDetails.line,\n column: endPosDetails.column\n }\n };\n if (offset2 && peg$source && typeof peg$source.offset === \"function\") {\n res.start = peg$source.offset(res.start);\n res.end = peg$source.offset(res.end);\n }\n return res;\n }\n function peg$fail(expected2) {\n if (peg$currPos < peg$maxFailPos) {\n return;\n }\n if (peg$currPos > peg$maxFailPos) {\n peg$maxFailPos = peg$currPos;\n peg$maxFailExpected = [];\n }\n peg$maxFailExpected.push(expected2);\n }\n function peg$buildSimpleError(message, location2) {\n return new peg$SyntaxError(message, null, null, location2);\n }\n function peg$buildStructuredError(expected2, found, location2) {\n return new peg$SyntaxError(\n peg$SyntaxError.buildMessage(expected2, found),\n expected2,\n found,\n location2\n );\n }\n function peg$parseargs_spec_list() {\n var s0, s1, s2, s3, s4;\n s0 = peg$currPos;\n s1 = [];\n s2 = peg$currPos;\n s3 = peg$parsewhitespace();\n s4 = peg$parsearg_spec();\n if (s4 !== peg$FAILED) {\n peg$savedPos = s2;\n s2 = peg$f0(s4);\n } else {\n peg$currPos = s2;\n s2 = peg$FAILED;\n }\n while (s2 !== peg$FAILED) {\n s1.push(s2);\n s2 = peg$currPos;\n s3 = peg$parsewhitespace();\n s4 = peg$parsearg_spec();\n if (s4 !== peg$FAILED) {\n peg$savedPos = s2;\n s2 = peg$f0(s4);\n } else {\n peg$currPos = s2;\n s2 = peg$FAILED;\n }\n }\n s2 = peg$parsewhitespace();\n peg$savedPos = s0;\n s0 = peg$f1(s1);\n return s0;\n }\n function peg$parsearg_spec() {\n var s0, s1, s2;\n s0 = peg$currPos;\n if (input.charCodeAt(peg$currPos) === 43) {\n s1 = peg$c0;\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n if (s1 === peg$FAILED) {\n s1 = null;\n }\n s2 = peg$parseoptional();\n if (s2 === peg$FAILED) {\n s2 = peg$parsemandatory();\n if (s2 === peg$FAILED) {\n s2 = peg$parseverbatim();\n if (s2 === peg$FAILED) {\n s2 = peg$parserequired();\n if (s2 === peg$FAILED) {\n s2 = peg$parsebody();\n if (s2 === peg$FAILED) {\n s2 = peg$parseuntil();\n }\n }\n }\n }\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f2(s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parseverbatim() {\n var s0, s1, s2;\n s0 = peg$currPos;\n if (input.charCodeAt(peg$currPos) === 118) {\n s1 = peg$c1;\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e1);\n }\n }\n if (s1 !== peg$FAILED) {\n if (input.length > peg$currPos) {\n s2 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s2 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e2);\n }\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f3(s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parsebody() {\n var s0, s1;\n s0 = peg$currPos;\n if (input.charCodeAt(peg$currPos) === 98) {\n s1 = peg$c2;\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e3);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = s0;\n s1 = peg$f4();\n }\n s0 = s1;\n return s0;\n }\n function peg$parseoptional() {\n var s0, s1, s2;\n s0 = peg$currPos;\n if (input.charCodeAt(peg$currPos) === 33) {\n s1 = peg$c3;\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e4);\n }\n }\n if (s1 === peg$FAILED) {\n s1 = null;\n }\n s2 = peg$parseoptional_star();\n if (s2 === peg$FAILED) {\n s2 = peg$parseoptional_standard();\n if (s2 === peg$FAILED) {\n s2 = peg$parseoptional_delimited();\n if (s2 === peg$FAILED) {\n s2 = peg$parseoptional_embellishment();\n if (s2 === peg$FAILED) {\n s2 = peg$parseoptional_token();\n }\n }\n }\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f5(s1, s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parseoptional_delimited() {\n var s0, s1, s2, s3;\n s0 = peg$currPos;\n if (input.charCodeAt(peg$currPos) === 68) {\n s1 = peg$c4;\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e5);\n }\n }\n if (s1 !== peg$FAILED) {\n s2 = peg$parsebrace_spec();\n s3 = peg$parsearg();\n if (s3 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f6(s2, s3);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n if (s0 === peg$FAILED) {\n s0 = peg$currPos;\n if (input.charCodeAt(peg$currPos) === 100) {\n s1 = peg$c5;\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e6);\n }\n }\n if (s1 !== peg$FAILED) {\n s2 = peg$parsebrace_spec();\n peg$savedPos = s0;\n s0 = peg$f7(s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n }\n return s0;\n }\n function peg$parseoptional_star() {\n var s0, s1;\n s0 = peg$currPos;\n if (input.charCodeAt(peg$currPos) === 115) {\n s1 = peg$c6;\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e7);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = s0;\n s1 = peg$f8();\n }\n s0 = s1;\n return s0;\n }\n function peg$parseoptional_standard() {\n var s0, s1, s2, s3;\n s0 = peg$currPos;\n if (input.charCodeAt(peg$currPos) === 79) {\n s1 = peg$c7;\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e8);\n }\n }\n if (s1 !== peg$FAILED) {\n s2 = peg$parsewhitespace();\n s3 = peg$parsearg();\n if (s3 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f9(s3);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n if (s0 === peg$FAILED) {\n s0 = peg$currPos;\n if (input.charCodeAt(peg$currPos) === 111) {\n s1 = peg$c8;\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e9);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = s0;\n s1 = peg$f10();\n }\n s0 = s1;\n }\n return s0;\n }\n function peg$parseoptional_embellishment() {\n var s0, s1, s2, s3, s4, s5;\n s0 = peg$currPos;\n if (input.charCodeAt(peg$currPos) === 101) {\n s1 = peg$c9;\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e10);\n }\n }\n if (s1 !== peg$FAILED) {\n s2 = peg$parsewhitespace();\n s3 = peg$parseargs();\n if (s3 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f11(s3);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n if (s0 === peg$FAILED) {\n s0 = peg$currPos;\n if (input.charCodeAt(peg$currPos) === 69) {\n s1 = peg$c10;\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e11);\n }\n }\n if (s1 !== peg$FAILED) {\n s2 = peg$parsewhitespace();\n s3 = peg$parseargs();\n if (s3 !== peg$FAILED) {\n s4 = peg$parsewhitespace();\n s5 = peg$parseargs();\n if (s5 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f12(s3, s5);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n }\n return s0;\n }\n function peg$parseoptional_token() {\n var s0, s1, s2;\n s0 = peg$currPos;\n if (input.charCodeAt(peg$currPos) === 116) {\n s1 = peg$c11;\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e12);\n }\n }\n if (s1 !== peg$FAILED) {\n if (input.length > peg$currPos) {\n s2 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s2 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e2);\n }\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f13(s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parserequired() {\n var s0, s1, s2, s3;\n s0 = peg$currPos;\n if (input.charCodeAt(peg$currPos) === 82) {\n s1 = peg$c12;\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e13);\n }\n }\n if (s1 !== peg$FAILED) {\n s2 = peg$parsebrace_spec();\n s3 = peg$parsearg();\n if (s3 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f14(s2, s3);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n if (s0 === peg$FAILED) {\n s0 = peg$currPos;\n if (input.charCodeAt(peg$currPos) === 114) {\n s1 = peg$c13;\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e14);\n }\n }\n if (s1 !== peg$FAILED) {\n s2 = peg$parsebrace_spec();\n peg$savedPos = s0;\n s0 = peg$f15(s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n }\n return s0;\n }\n function peg$parseuntil() {\n var s0, s1, s2;\n s0 = peg$currPos;\n if (input.charCodeAt(peg$currPos) === 117) {\n s1 = peg$c14;\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e15);\n }\n }\n if (s1 !== peg$FAILED) {\n s2 = peg$parseuntil_stop_token();\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f16(s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parseuntil_stop_token() {\n var s0, s1, s2;\n s0 = peg$currPos;\n s1 = peg$currPos;\n peg$silentFails++;\n if (peg$r0.test(input.charAt(peg$currPos))) {\n s2 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s2 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e16);\n }\n }\n peg$silentFails--;\n if (s2 === peg$FAILED) {\n s1 = void 0;\n } else {\n peg$currPos = s1;\n s1 = peg$FAILED;\n }\n if (s1 !== peg$FAILED) {\n if (input.length > peg$currPos) {\n s2 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s2 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e2);\n }\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f17(s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n if (s0 === peg$FAILED) {\n s0 = peg$currPos;\n s1 = peg$parsebraced_group();\n if (s1 !== peg$FAILED) {\n peg$savedPos = s0;\n s1 = peg$f18(s1);\n }\n s0 = s1;\n }\n return s0;\n }\n function peg$parsemandatory() {\n var s0, s1;\n s0 = peg$currPos;\n if (input.charCodeAt(peg$currPos) === 109) {\n s1 = peg$c15;\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e17);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = s0;\n s1 = peg$f19();\n }\n s0 = s1;\n return s0;\n }\n function peg$parsebrace_spec() {\n var s0, s1, s2, s3, s4, s5;\n s0 = peg$currPos;\n s1 = peg$currPos;\n s2 = peg$currPos;\n s3 = peg$currPos;\n peg$silentFails++;\n s4 = peg$parsewhitespace_token();\n peg$silentFails--;\n if (s4 === peg$FAILED) {\n s3 = void 0;\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n if (s3 !== peg$FAILED) {\n s4 = peg$parsemacro();\n if (s4 === peg$FAILED) {\n if (input.length > peg$currPos) {\n s4 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s4 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e2);\n }\n }\n }\n if (s4 !== peg$FAILED) {\n s3 = [s3, s4];\n s2 = s3;\n } else {\n peg$currPos = s2;\n s2 = peg$FAILED;\n }\n } else {\n peg$currPos = s2;\n s2 = peg$FAILED;\n }\n if (s2 === peg$FAILED) {\n s2 = null;\n }\n s1 = input.substring(s1, peg$currPos);\n s2 = peg$currPos;\n s3 = peg$currPos;\n s4 = peg$currPos;\n peg$silentFails++;\n s5 = peg$parsewhitespace_token();\n peg$silentFails--;\n if (s5 === peg$FAILED) {\n s4 = void 0;\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n if (s4 !== peg$FAILED) {\n s5 = peg$parsemacro();\n if (s5 === peg$FAILED) {\n if (input.length > peg$currPos) {\n s5 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s5 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e2);\n }\n }\n }\n if (s5 !== peg$FAILED) {\n s4 = [s4, s5];\n s3 = s4;\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n if (s3 === peg$FAILED) {\n s3 = null;\n }\n s2 = input.substring(s2, peg$currPos);\n peg$savedPos = s0;\n s0 = peg$f20(s1, s2);\n return s0;\n }\n function peg$parsearg() {\n var s0, s1;\n s0 = peg$parsetoken();\n if (s0 === peg$FAILED) {\n s0 = peg$currPos;\n s1 = peg$parsebraced_group();\n if (s1 !== peg$FAILED) {\n peg$savedPos = s0;\n s1 = peg$f21(s1);\n }\n s0 = s1;\n }\n return s0;\n }\n function peg$parseargs() {\n var s0, s1, s2, s3;\n s0 = peg$currPos;\n s1 = peg$parsetoken();\n if (s1 !== peg$FAILED) {\n peg$savedPos = s0;\n s1 = peg$f22(s1);\n }\n s0 = s1;\n if (s0 === peg$FAILED) {\n s0 = peg$currPos;\n if (input.charCodeAt(peg$currPos) === 123) {\n s1 = peg$c16;\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e18);\n }\n }\n if (s1 !== peg$FAILED) {\n s2 = [];\n s3 = peg$parsearg();\n if (s3 === peg$FAILED) {\n s3 = peg$parsewhitespace_token();\n }\n while (s3 !== peg$FAILED) {\n s2.push(s3);\n s3 = peg$parsearg();\n if (s3 === peg$FAILED) {\n s3 = peg$parsewhitespace_token();\n }\n }\n if (input.charCodeAt(peg$currPos) === 125) {\n s3 = peg$c17;\n peg$currPos++;\n } else {\n s3 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e19);\n }\n }\n if (s3 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f23(s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n }\n return s0;\n }\n function peg$parsebraced_group() {\n var s0, s1, s2, s3, s4, s5, s6, s7;\n s0 = peg$currPos;\n if (input.charCodeAt(peg$currPos) === 123) {\n s1 = peg$c16;\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e18);\n }\n }\n if (s1 !== peg$FAILED) {\n s2 = [];\n s3 = peg$currPos;\n s4 = peg$currPos;\n s5 = peg$currPos;\n peg$silentFails++;\n if (input.charCodeAt(peg$currPos) === 125) {\n s6 = peg$c17;\n peg$currPos++;\n } else {\n s6 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e19);\n }\n }\n peg$silentFails--;\n if (s6 === peg$FAILED) {\n s5 = void 0;\n } else {\n peg$currPos = s5;\n s5 = peg$FAILED;\n }\n if (s5 !== peg$FAILED) {\n s6 = peg$currPos;\n peg$silentFails++;\n s7 = peg$parsebraced_group();\n peg$silentFails--;\n if (s7 === peg$FAILED) {\n s6 = void 0;\n } else {\n peg$currPos = s6;\n s6 = peg$FAILED;\n }\n if (s6 !== peg$FAILED) {\n s7 = peg$parsetoken();\n if (s7 === peg$FAILED) {\n s7 = peg$parsewhitespace_token();\n }\n if (s7 !== peg$FAILED) {\n s5 = [s5, s6, s7];\n s4 = s5;\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n if (s4 !== peg$FAILED) {\n s3 = input.substring(s3, peg$currPos);\n } else {\n s3 = s4;\n }\n if (s3 === peg$FAILED) {\n s3 = peg$parsebraced_group();\n }\n while (s3 !== peg$FAILED) {\n s2.push(s3);\n s3 = peg$currPos;\n s4 = peg$currPos;\n s5 = peg$currPos;\n peg$silentFails++;\n if (input.charCodeAt(peg$currPos) === 125) {\n s6 = peg$c17;\n peg$currPos++;\n } else {\n s6 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e19);\n }\n }\n peg$silentFails--;\n if (s6 === peg$FAILED) {\n s5 = void 0;\n } else {\n peg$currPos = s5;\n s5 = peg$FAILED;\n }\n if (s5 !== peg$FAILED) {\n s6 = peg$currPos;\n peg$silentFails++;\n s7 = peg$parsebraced_group();\n peg$silentFails--;\n if (s7 === peg$FAILED) {\n s6 = void 0;\n } else {\n peg$currPos = s6;\n s6 = peg$FAILED;\n }\n if (s6 !== peg$FAILED) {\n s7 = peg$parsetoken();\n if (s7 === peg$FAILED) {\n s7 = peg$parsewhitespace_token();\n }\n if (s7 !== peg$FAILED) {\n s5 = [s5, s6, s7];\n s4 = s5;\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n if (s4 !== peg$FAILED) {\n s3 = input.substring(s3, peg$currPos);\n } else {\n s3 = s4;\n }\n if (s3 === peg$FAILED) {\n s3 = peg$parsebraced_group();\n }\n }\n if (input.charCodeAt(peg$currPos) === 125) {\n s3 = peg$c17;\n peg$currPos++;\n } else {\n s3 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e19);\n }\n }\n if (s3 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f24(s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parsewhitespace() {\n var s0, s1, s2;\n s0 = peg$currPos;\n s1 = [];\n s2 = peg$parsewhitespace_token();\n while (s2 !== peg$FAILED) {\n s1.push(s2);\n s2 = peg$parsewhitespace_token();\n }\n peg$savedPos = s0;\n s1 = peg$f25();\n s0 = s1;\n return s0;\n }\n function peg$parsewhitespace_token() {\n var s0;\n if (input.charCodeAt(peg$currPos) === 32) {\n s0 = peg$c18;\n peg$currPos++;\n } else {\n s0 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e20);\n }\n }\n if (s0 === peg$FAILED) {\n if (input.charCodeAt(peg$currPos) === 10) {\n s0 = peg$c19;\n peg$currPos++;\n } else {\n s0 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e21);\n }\n }\n if (s0 === peg$FAILED) {\n if (input.charCodeAt(peg$currPos) === 13) {\n s0 = peg$c20;\n peg$currPos++;\n } else {\n s0 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e22);\n }\n }\n }\n }\n return s0;\n }\n function peg$parsemacro() {\n var s0, s1, s2, s3, s4;\n s0 = peg$currPos;\n s1 = peg$currPos;\n if (input.charCodeAt(peg$currPos) === 92) {\n s2 = peg$c21;\n peg$currPos++;\n } else {\n s2 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e23);\n }\n }\n if (s2 !== peg$FAILED) {\n s3 = [];\n if (peg$r1.test(input.charAt(peg$currPos))) {\n s4 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s4 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e24);\n }\n }\n if (s4 !== peg$FAILED) {\n while (s4 !== peg$FAILED) {\n s3.push(s4);\n if (peg$r1.test(input.charAt(peg$currPos))) {\n s4 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s4 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e24);\n }\n }\n }\n } else {\n s3 = peg$FAILED;\n }\n if (s3 !== peg$FAILED) {\n s2 = [s2, s3];\n s1 = s2;\n } else {\n peg$currPos = s1;\n s1 = peg$FAILED;\n }\n } else {\n peg$currPos = s1;\n s1 = peg$FAILED;\n }\n if (s1 !== peg$FAILED) {\n s0 = input.substring(s0, peg$currPos);\n } else {\n s0 = s1;\n }\n if (s0 === peg$FAILED) {\n s0 = peg$currPos;\n s1 = peg$currPos;\n if (input.charCodeAt(peg$currPos) === 92) {\n s2 = peg$c21;\n peg$currPos++;\n } else {\n s2 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e23);\n }\n }\n if (s2 !== peg$FAILED) {\n s3 = peg$currPos;\n peg$silentFails++;\n if (peg$r1.test(input.charAt(peg$currPos))) {\n s4 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s4 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e24);\n }\n }\n peg$silentFails--;\n if (s4 === peg$FAILED) {\n s3 = void 0;\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n if (s3 !== peg$FAILED) {\n if (input.length > peg$currPos) {\n s4 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s4 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e2);\n }\n }\n if (s4 !== peg$FAILED) {\n s2 = [s2, s3, s4];\n s1 = s2;\n } else {\n peg$currPos = s1;\n s1 = peg$FAILED;\n }\n } else {\n peg$currPos = s1;\n s1 = peg$FAILED;\n }\n } else {\n peg$currPos = s1;\n s1 = peg$FAILED;\n }\n if (s1 !== peg$FAILED) {\n s0 = input.substring(s0, peg$currPos);\n } else {\n s0 = s1;\n }\n }\n return s0;\n }\n function peg$parsetoken() {\n var s0, s1, s2, s3;\n s0 = peg$parsemacro();\n if (s0 === peg$FAILED) {\n s0 = peg$currPos;\n s1 = peg$currPos;\n peg$silentFails++;\n if (peg$r2.test(input.charAt(peg$currPos))) {\n s2 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s2 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e25);\n }\n }\n peg$silentFails--;\n if (s2 === peg$FAILED) {\n s1 = void 0;\n } else {\n peg$currPos = s1;\n s1 = peg$FAILED;\n }\n if (s1 !== peg$FAILED) {\n s2 = peg$currPos;\n peg$silentFails++;\n s3 = peg$parsewhitespace_token();\n peg$silentFails--;\n if (s3 === peg$FAILED) {\n s2 = void 0;\n } else {\n peg$currPos = s2;\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n if (input.length > peg$currPos) {\n s3 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s3 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e2);\n }\n }\n if (s3 !== peg$FAILED) {\n s0 = s3;\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n }\n return s0;\n }\n const DEFAULT_OPTIONS = {\n optional: { openBrace: \"[\", closeBrace: \"]\" },\n mandatory: { openBrace: \"{\", closeBrace: \"}\" }\n };\n function createNode(type, options2) {\n const computedOptions = DEFAULT_OPTIONS[type] || {};\n return { type, ...computedOptions, ...options2 };\n }\n function groupToStr(node) {\n if (typeof node !== \"object\" || !node) {\n return node;\n }\n if (node.type === \"group\") {\n return `{${node.content.map(groupToStr).join(\"\")}}`;\n }\n return node;\n }\n peg$result = peg$startRuleFunction();\n if (peg$result !== peg$FAILED && peg$currPos === input.length) {\n return peg$result;\n } else {\n if (peg$result !== peg$FAILED && peg$currPos < input.length) {\n peg$fail(peg$endExpectation());\n }\n throw peg$buildStructuredError(\n peg$maxFailExpected,\n peg$maxFailPos < input.length ? input.charAt(peg$maxFailPos) : null,\n peg$maxFailPos < input.length ? peg$computeLocation(peg$maxFailPos, peg$maxFailPos + 1) : peg$computeLocation(peg$maxFailPos, peg$maxFailPos)\n );\n }\n }\n return {\n SyntaxError: peg$SyntaxError,\n parse: peg$parse\n };\n }()\n);\n","export default (\n // Generated by Peggy 3.0.2.\n //\n // https://peggyjs.org/\n function() {\n \"use strict\";\n function peg$subclass(child, parent) {\n function C() {\n this.constructor = child;\n }\n C.prototype = parent.prototype;\n child.prototype = new C();\n }\n function peg$SyntaxError(message, expected, found, location) {\n var self = Error.call(this, message);\n if (Object.setPrototypeOf) {\n Object.setPrototypeOf(self, peg$SyntaxError.prototype);\n }\n self.expected = expected;\n self.found = found;\n self.location = location;\n self.name = \"SyntaxError\";\n return self;\n }\n peg$subclass(peg$SyntaxError, Error);\n function peg$padEnd(str, targetLength, padString) {\n padString = padString || \" \";\n if (str.length > targetLength) {\n return str;\n }\n targetLength -= str.length;\n padString += padString.repeat(targetLength);\n return str + padString.slice(0, targetLength);\n }\n peg$SyntaxError.prototype.format = function(sources) {\n var str = \"Error: \" + this.message;\n if (this.location) {\n var src = null;\n var k;\n for (k = 0; k < sources.length; k++) {\n if (sources[k].source === this.location.source) {\n src = sources[k].text.split(/\\r\\n|\\n|\\r/g);\n break;\n }\n }\n var s = this.location.start;\n var offset_s = this.location.source && typeof this.location.source.offset === \"function\" ? this.location.source.offset(s) : s;\n var loc = this.location.source + \":\" + offset_s.line + \":\" + offset_s.column;\n if (src) {\n var e = this.location.end;\n var filler = peg$padEnd(\"\", offset_s.line.toString().length, \" \");\n var line = src[s.line - 1];\n var last = s.line === e.line ? e.column : line.length + 1;\n var hatLen = last - s.column || 1;\n str += \"\\n --> \" + loc + \"\\n\" + filler + \" |\\n\" + offset_s.line + \" | \" + line + \"\\n\" + filler + \" | \" + peg$padEnd(\"\", s.column - 1, \" \") + peg$padEnd(\"\", hatLen, \"^\");\n } else {\n str += \"\\n at \" + loc;\n }\n }\n return str;\n };\n peg$SyntaxError.buildMessage = function(expected, found) {\n var DESCRIBE_EXPECTATION_FNS = {\n literal: function(expectation) {\n return '\"' + literalEscape(expectation.text) + '\"';\n },\n class: function(expectation) {\n var escapedParts = expectation.parts.map(function(part) {\n return Array.isArray(part) ? classEscape(part[0]) + \"-\" + classEscape(part[1]) : classEscape(part);\n });\n return \"[\" + (expectation.inverted ? \"^\" : \"\") + escapedParts.join(\"\") + \"]\";\n },\n any: function() {\n return \"any character\";\n },\n end: function() {\n return \"end of input\";\n },\n other: function(expectation) {\n return expectation.description;\n }\n };\n function hex(ch) {\n return ch.charCodeAt(0).toString(16).toUpperCase();\n }\n function literalEscape(s) {\n return s.replace(/\\\\/g, \"\\\\\\\\\").replace(/\"/g, '\\\\\"').replace(/\\0/g, \"\\\\0\").replace(/\\t/g, \"\\\\t\").replace(/\\n/g, \"\\\\n\").replace(/\\r/g, \"\\\\r\").replace(/[\\x00-\\x0F]/g, function(ch) {\n return \"\\\\x0\" + hex(ch);\n }).replace(/[\\x10-\\x1F\\x7F-\\x9F]/g, function(ch) {\n return \"\\\\x\" + hex(ch);\n });\n }\n function classEscape(s) {\n return s.replace(/\\\\/g, \"\\\\\\\\\").replace(/\\]/g, \"\\\\]\").replace(/\\^/g, \"\\\\^\").replace(/-/g, \"\\\\-\").replace(/\\0/g, \"\\\\0\").replace(/\\t/g, \"\\\\t\").replace(/\\n/g, \"\\\\n\").replace(/\\r/g, \"\\\\r\").replace(/[\\x00-\\x0F]/g, function(ch) {\n return \"\\\\x0\" + hex(ch);\n }).replace(/[\\x10-\\x1F\\x7F-\\x9F]/g, function(ch) {\n return \"\\\\x\" + hex(ch);\n });\n }\n function describeExpectation(expectation) {\n return DESCRIBE_EXPECTATION_FNS[expectation.type](expectation);\n }\n function describeExpected(expected2) {\n var descriptions = expected2.map(describeExpectation);\n var i, j;\n descriptions.sort();\n if (descriptions.length > 0) {\n for (i = 1, j = 1; i < descriptions.length; i++) {\n if (descriptions[i - 1] !== descriptions[i]) {\n descriptions[j] = descriptions[i];\n j++;\n }\n }\n descriptions.length = j;\n }\n switch (descriptions.length) {\n case 1:\n return descriptions[0];\n case 2:\n return descriptions[0] + \" or \" + descriptions[1];\n default:\n return descriptions.slice(0, -1).join(\", \") + \", or \" + descriptions[descriptions.length - 1];\n }\n }\n function describeFound(found2) {\n return found2 ? '\"' + literalEscape(found2) + '\"' : \"end of input\";\n }\n return \"Expected \" + describeExpected(expected) + \" but \" + describeFound(found) + \" found.\";\n };\n function peg$parse(input, options) {\n options = options !== void 0 ? options : {};\n var peg$FAILED = {};\n var peg$source = options.grammarSource;\n var peg$startRuleFunctions = { body: peg$parsebody };\n var peg$startRuleFunction = peg$parsebody;\n var peg$e0 = peg$anyExpectation();\n var peg$f0 = function() {\n return [];\n };\n var peg$f1 = function(rowItems, trailingComment) {\n return {\n itemParts: [],\n ...rowItems,\n trailingComment,\n trailingComma: true\n };\n };\n var peg$f2 = function(rowItems, trailingComment) {\n return { ...rowItems, trailingComment };\n };\n var peg$f3 = function(a, b) {\n return processItem(a, b);\n };\n var peg$f4 = function(b) {\n return processItem(null, b);\n };\n var peg$f5 = function(cell) {\n return { cell };\n };\n var peg$f6 = function() {\n return {};\n };\n var peg$f7 = function(part) {\n return part;\n };\n var peg$f8 = function(x) {\n return x;\n };\n var peg$f9 = function(space, x) {\n return {\n trailingComment: x,\n leadingParbreak: space.parbreak > 0\n };\n };\n var peg$f10 = function(list) {\n return {\n whitespace: list.filter((x) => options.isWhitespace(x)).length,\n parbreak: list.filter((x) => options.isParbreak(x)).length\n };\n };\n var peg$f11 = function() {\n return !options.allowParenGroups;\n };\n var peg$f12 = function(tok) {\n return options.isSameLineComment(tok);\n };\n var peg$f13 = function(tok) {\n return tok;\n };\n var peg$f14 = function(tok) {\n return options.isOwnLineComment(tok);\n };\n var peg$f15 = function(tok) {\n return tok;\n };\n var peg$f16 = function(tok) {\n return options.isWhitespace(tok);\n };\n var peg$f17 = function(tok) {\n return tok;\n };\n var peg$f18 = function(tok) {\n return options.isParbreak(tok);\n };\n var peg$f19 = function(tok) {\n return tok;\n };\n var peg$f20 = function(tok) {\n return options.isComma(tok);\n };\n var peg$f21 = function(tok) {\n return tok;\n };\n var peg$f22 = function(tok) {\n return options.isEquals(tok);\n };\n var peg$f23 = function(tok) {\n return tok;\n };\n var peg$f24 = function(tok) {\n return options.isChar(tok, \"(\");\n };\n var peg$f25 = function(tok) {\n return tok;\n };\n var peg$f26 = function(tok) {\n return options.isChar(tok, \")\");\n };\n var peg$f27 = function(tok) {\n return tok;\n };\n var peg$currPos = 0;\n var peg$savedPos = 0;\n var peg$posDetailsCache = [{ line: 1, column: 1 }];\n var peg$maxFailPos = 0;\n var peg$maxFailExpected = [];\n var peg$silentFails = 0;\n var peg$result;\n if (\"startRule\" in options) {\n if (!(options.startRule in peg$startRuleFunctions)) {\n throw new Error(`Can't start parsing from rule \"` + options.startRule + '\".');\n }\n peg$startRuleFunction = peg$startRuleFunctions[options.startRule];\n }\n function text() {\n return input.substring(peg$savedPos, peg$currPos);\n }\n function offset() {\n return peg$savedPos;\n }\n function range() {\n return {\n source: peg$source,\n start: peg$savedPos,\n end: peg$currPos\n };\n }\n function location() {\n return peg$computeLocation(peg$savedPos, peg$currPos);\n }\n function expected(description, location2) {\n location2 = location2 !== void 0 ? location2 : peg$computeLocation(peg$savedPos, peg$currPos);\n throw peg$buildStructuredError(\n [peg$otherExpectation(description)],\n input.substring(peg$savedPos, peg$currPos),\n location2\n );\n }\n function error(message, location2) {\n location2 = location2 !== void 0 ? location2 : peg$computeLocation(peg$savedPos, peg$currPos);\n throw peg$buildSimpleError(message, location2);\n }\n function peg$literalExpectation(text2, ignoreCase) {\n return { type: \"literal\", text: text2, ignoreCase };\n }\n function peg$classExpectation(parts, inverted, ignoreCase) {\n return { type: \"class\", parts, inverted, ignoreCase };\n }\n function peg$anyExpectation() {\n return { type: \"any\" };\n }\n function peg$endExpectation() {\n return { type: \"end\" };\n }\n function peg$otherExpectation(description) {\n return { type: \"other\", description };\n }\n function peg$computePosDetails(pos) {\n var details = peg$posDetailsCache[pos];\n var p;\n if (details) {\n return details;\n } else {\n p = pos - 1;\n while (!peg$posDetailsCache[p]) {\n p--;\n }\n details = peg$posDetailsCache[p];\n details = {\n line: details.line,\n column: details.column\n };\n while (p < pos) {\n if (input.charCodeAt(p) === 10) {\n details.line++;\n details.column = 1;\n } else {\n details.column++;\n }\n p++;\n }\n peg$posDetailsCache[pos] = details;\n return details;\n }\n }\n function peg$computeLocation(startPos, endPos, offset2) {\n var startPosDetails = peg$computePosDetails(startPos);\n var endPosDetails = peg$computePosDetails(endPos);\n var res = {\n source: peg$source,\n start: {\n offset: startPos,\n line: startPosDetails.line,\n column: startPosDetails.column\n },\n end: {\n offset: endPos,\n line: endPosDetails.line,\n column: endPosDetails.column\n }\n };\n if (offset2 && peg$source && typeof peg$source.offset === \"function\") {\n res.start = peg$source.offset(res.start);\n res.end = peg$source.offset(res.end);\n }\n return res;\n }\n function peg$fail(expected2) {\n if (peg$currPos < peg$maxFailPos) {\n return;\n }\n if (peg$currPos > peg$maxFailPos) {\n peg$maxFailPos = peg$currPos;\n peg$maxFailExpected = [];\n }\n peg$maxFailExpected.push(expected2);\n }\n function peg$buildSimpleError(message, location2) {\n return new peg$SyntaxError(message, null, null, location2);\n }\n function peg$buildStructuredError(expected2, found, location2) {\n return new peg$SyntaxError(\n peg$SyntaxError.buildMessage(expected2, found),\n expected2,\n found,\n location2\n );\n }\n function peg$parsebody() {\n var s0, s1, s2;\n s0 = [];\n s1 = peg$parsecomment_only_line();\n if (s1 === peg$FAILED) {\n s1 = peg$parseitem_with_end();\n if (s1 === peg$FAILED) {\n s1 = peg$parseitem_without_end();\n }\n }\n if (s1 !== peg$FAILED) {\n while (s1 !== peg$FAILED) {\n s0.push(s1);\n s1 = peg$parsecomment_only_line();\n if (s1 === peg$FAILED) {\n s1 = peg$parseitem_with_end();\n if (s1 === peg$FAILED) {\n s1 = peg$parseitem_without_end();\n }\n }\n }\n } else {\n s0 = peg$FAILED;\n }\n if (s0 === peg$FAILED) {\n s0 = peg$currPos;\n s1 = [];\n s2 = peg$parsewhitespace();\n while (s2 !== peg$FAILED) {\n s1.push(s2);\n s2 = peg$parsewhitespace();\n }\n s2 = peg$parseEOL();\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f0();\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n }\n return s0;\n }\n function peg$parseitem_with_end() {\n var s0, s1, s2, s3, s4, s5, s6, s7, s8;\n s0 = peg$currPos;\n s1 = peg$parsewhitespace_or_parbreaks();\n s2 = peg$parserow_items();\n if (s2 === peg$FAILED) {\n s2 = null;\n }\n s3 = peg$parsewhitespace_or_parbreaks();\n s4 = peg$parseitem_sep();\n if (s4 !== peg$FAILED) {\n s5 = [];\n s6 = peg$parsewhitespace();\n while (s6 !== peg$FAILED) {\n s5.push(s6);\n s6 = peg$parsewhitespace();\n }\n s6 = peg$parsetrailing_comment();\n if (s6 === peg$FAILED) {\n s6 = null;\n }\n s7 = [];\n s8 = peg$parsewhitespace();\n while (s8 !== peg$FAILED) {\n s7.push(s8);\n s8 = peg$parsewhitespace();\n }\n peg$savedPos = s0;\n s0 = peg$f1(s2, s6);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parseitem_without_end() {\n var s0, s1, s2, s3;\n s0 = peg$currPos;\n s1 = peg$parsewhitespace_or_parbreaks();\n s2 = peg$parserow_items();\n if (s2 !== peg$FAILED) {\n s3 = peg$parsetrailing_comment();\n if (s3 === peg$FAILED) {\n s3 = null;\n }\n peg$savedPos = s0;\n s0 = peg$f2(s2, s3);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parserow_items() {\n var s0, s1, s2, s3;\n s0 = peg$currPos;\n s1 = peg$parseitem_part();\n if (s1 !== peg$FAILED) {\n s2 = [];\n s3 = peg$parseseparated_part();\n while (s3 !== peg$FAILED) {\n s2.push(s3);\n s3 = peg$parseseparated_part();\n }\n peg$savedPos = s0;\n s0 = peg$f3(s1, s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n if (s0 === peg$FAILED) {\n s0 = peg$currPos;\n s1 = [];\n s2 = peg$parseseparated_part();\n if (s2 !== peg$FAILED) {\n while (s2 !== peg$FAILED) {\n s1.push(s2);\n s2 = peg$parseseparated_part();\n }\n } else {\n s1 = peg$FAILED;\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = s0;\n s1 = peg$f4(s1);\n }\n s0 = s1;\n }\n return s0;\n }\n function peg$parseseparated_part() {\n var s0, s1, s2, s3, s4;\n s0 = peg$currPos;\n s1 = [];\n s2 = peg$parseparbreak();\n while (s2 !== peg$FAILED) {\n s1.push(s2);\n s2 = peg$parseparbreak();\n }\n s2 = peg$parseequals();\n if (s2 !== peg$FAILED) {\n s3 = [];\n s4 = peg$parseparbreak();\n while (s4 !== peg$FAILED) {\n s3.push(s4);\n s4 = peg$parseparbreak();\n }\n s4 = peg$parseitem_part();\n if (s4 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f5(s4);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n if (s0 === peg$FAILED) {\n s0 = peg$currPos;\n s1 = [];\n s2 = peg$parseparbreak();\n while (s2 !== peg$FAILED) {\n s1.push(s2);\n s2 = peg$parseparbreak();\n }\n s2 = peg$parseequals();\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f6();\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n }\n return s0;\n }\n function peg$parseitem_part() {\n var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;\n s0 = peg$currPos;\n s1 = [];\n s2 = peg$parsewhitespace();\n while (s2 !== peg$FAILED) {\n s1.push(s2);\n s2 = peg$parsewhitespace();\n }\n s2 = peg$currPos;\n s3 = [];\n s4 = peg$parsenon_whitespace_non_parbreak_token();\n if (s4 === peg$FAILED) {\n s4 = peg$currPos;\n s5 = peg$parsewhitespace();\n if (s5 === peg$FAILED) {\n s5 = peg$parseparbreak();\n }\n if (s5 !== peg$FAILED) {\n s6 = peg$currPos;\n peg$silentFails++;\n s7 = peg$currPos;\n s8 = [];\n s9 = peg$parsewhitespace();\n if (s9 === peg$FAILED) {\n s9 = peg$parseparbreak();\n }\n while (s9 !== peg$FAILED) {\n s8.push(s9);\n s9 = peg$parsewhitespace();\n if (s9 === peg$FAILED) {\n s9 = peg$parseparbreak();\n }\n }\n s9 = peg$parsenon_whitespace_non_parbreak_token();\n if (s9 !== peg$FAILED) {\n s8 = [s8, s9];\n s7 = s8;\n } else {\n peg$currPos = s7;\n s7 = peg$FAILED;\n }\n peg$silentFails--;\n if (s7 !== peg$FAILED) {\n peg$currPos = s6;\n s6 = void 0;\n } else {\n s6 = peg$FAILED;\n }\n if (s6 !== peg$FAILED) {\n s5 = [s5, s6];\n s4 = s5;\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n }\n if (s4 !== peg$FAILED) {\n while (s4 !== peg$FAILED) {\n s3.push(s4);\n s4 = peg$parsenon_whitespace_non_parbreak_token();\n if (s4 === peg$FAILED) {\n s4 = peg$currPos;\n s5 = peg$parsewhitespace();\n if (s5 === peg$FAILED) {\n s5 = peg$parseparbreak();\n }\n if (s5 !== peg$FAILED) {\n s6 = peg$currPos;\n peg$silentFails++;\n s7 = peg$currPos;\n s8 = [];\n s9 = peg$parsewhitespace();\n if (s9 === peg$FAILED) {\n s9 = peg$parseparbreak();\n }\n while (s9 !== peg$FAILED) {\n s8.push(s9);\n s9 = peg$parsewhitespace();\n if (s9 === peg$FAILED) {\n s9 = peg$parseparbreak();\n }\n }\n s9 = peg$parsenon_whitespace_non_parbreak_token();\n if (s9 !== peg$FAILED) {\n s8 = [s8, s9];\n s7 = s8;\n } else {\n peg$currPos = s7;\n s7 = peg$FAILED;\n }\n peg$silentFails--;\n if (s7 !== peg$FAILED) {\n peg$currPos = s6;\n s6 = void 0;\n } else {\n s6 = peg$FAILED;\n }\n if (s6 !== peg$FAILED) {\n s5 = [s5, s6];\n s4 = s5;\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n }\n }\n } else {\n s3 = peg$FAILED;\n }\n if (s3 !== peg$FAILED) {\n s2 = input.substring(s2, peg$currPos);\n } else {\n s2 = s3;\n }\n if (s2 !== peg$FAILED) {\n s3 = [];\n s4 = peg$parsewhitespace();\n while (s4 !== peg$FAILED) {\n s3.push(s4);\n s4 = peg$parsewhitespace();\n }\n peg$savedPos = s0;\n s0 = peg$f7(s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parsetrailing_comment() {\n var s0, s1, s2;\n s0 = peg$currPos;\n s1 = [];\n s2 = peg$parsewhitespace();\n while (s2 !== peg$FAILED) {\n s1.push(s2);\n s2 = peg$parsewhitespace();\n }\n s2 = peg$parsesame_line_comment();\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f8(s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parsecomment_only_line() {\n var s0, s1, s2;\n s0 = peg$currPos;\n s1 = peg$parsewhitespace_or_parbreaks();\n s2 = peg$parseown_line_comment();\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f9(s1, s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parsetoken() {\n var s0, s1, s2, s3;\n s0 = peg$currPos;\n s1 = peg$currPos;\n s2 = peg$currPos;\n peg$silentFails++;\n s3 = peg$parsenon_token();\n peg$silentFails--;\n if (s3 === peg$FAILED) {\n s2 = void 0;\n } else {\n peg$currPos = s2;\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n if (input.length > peg$currPos) {\n s3 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s3 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n if (s3 !== peg$FAILED) {\n s2 = [s2, s3];\n s1 = s2;\n } else {\n peg$currPos = s1;\n s1 = peg$FAILED;\n }\n } else {\n peg$currPos = s1;\n s1 = peg$FAILED;\n }\n if (s1 !== peg$FAILED) {\n s0 = input.substring(s0, peg$currPos);\n } else {\n s0 = s1;\n }\n return s0;\n }\n function peg$parsenon_whitespace_non_parbreak_token() {\n var s0, s1, s2, s3;\n s0 = peg$currPos;\n s1 = peg$currPos;\n s2 = peg$currPos;\n peg$silentFails++;\n s3 = peg$parsewhitespace();\n if (s3 === peg$FAILED) {\n s3 = peg$parseparbreak();\n }\n peg$silentFails--;\n if (s3 === peg$FAILED) {\n s2 = void 0;\n } else {\n peg$currPos = s2;\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n s3 = peg$parseparen_block();\n if (s3 === peg$FAILED) {\n s3 = peg$parsetoken();\n }\n if (s3 !== peg$FAILED) {\n s2 = [s2, s3];\n s1 = s2;\n } else {\n peg$currPos = s1;\n s1 = peg$FAILED;\n }\n } else {\n peg$currPos = s1;\n s1 = peg$FAILED;\n }\n if (s1 !== peg$FAILED) {\n s0 = input.substring(s0, peg$currPos);\n } else {\n s0 = s1;\n }\n return s0;\n }\n function peg$parsenon_token() {\n var s0;\n s0 = peg$parseitem_sep();\n if (s0 === peg$FAILED) {\n s0 = peg$parseequals();\n if (s0 === peg$FAILED) {\n s0 = peg$parsetrailing_comment();\n if (s0 === peg$FAILED) {\n s0 = peg$parseown_line_comment();\n }\n }\n }\n return s0;\n }\n function peg$parsewhitespace_or_parbreaks() {\n var s0, s1, s2;\n s0 = peg$currPos;\n s1 = [];\n s2 = peg$parsewhitespace();\n if (s2 === peg$FAILED) {\n s2 = peg$parseparbreak();\n }\n while (s2 !== peg$FAILED) {\n s1.push(s2);\n s2 = peg$parsewhitespace();\n if (s2 === peg$FAILED) {\n s2 = peg$parseparbreak();\n }\n }\n peg$savedPos = s0;\n s1 = peg$f10(s1);\n s0 = s1;\n return s0;\n }\n function peg$parseparen_block() {\n var s0, s1, s2, s3, s4, s5, s6, s7, s8;\n s0 = peg$currPos;\n peg$savedPos = peg$currPos;\n s1 = peg$f11();\n if (s1) {\n s1 = peg$FAILED;\n } else {\n s1 = void 0;\n }\n if (s1 !== peg$FAILED) {\n s2 = peg$currPos;\n s3 = peg$currPos;\n s4 = peg$parseopen_paren();\n if (s4 !== peg$FAILED) {\n s5 = [];\n s6 = peg$currPos;\n s7 = peg$currPos;\n peg$silentFails++;\n s8 = peg$parseclose_paren();\n peg$silentFails--;\n if (s8 === peg$FAILED) {\n s7 = void 0;\n } else {\n peg$currPos = s7;\n s7 = peg$FAILED;\n }\n if (s7 !== peg$FAILED) {\n if (input.length > peg$currPos) {\n s8 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s8 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n if (s8 !== peg$FAILED) {\n s7 = [s7, s8];\n s6 = s7;\n } else {\n peg$currPos = s6;\n s6 = peg$FAILED;\n }\n } else {\n peg$currPos = s6;\n s6 = peg$FAILED;\n }\n while (s6 !== peg$FAILED) {\n s5.push(s6);\n s6 = peg$currPos;\n s7 = peg$currPos;\n peg$silentFails++;\n s8 = peg$parseclose_paren();\n peg$silentFails--;\n if (s8 === peg$FAILED) {\n s7 = void 0;\n } else {\n peg$currPos = s7;\n s7 = peg$FAILED;\n }\n if (s7 !== peg$FAILED) {\n if (input.length > peg$currPos) {\n s8 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s8 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n if (s8 !== peg$FAILED) {\n s7 = [s7, s8];\n s6 = s7;\n } else {\n peg$currPos = s6;\n s6 = peg$FAILED;\n }\n } else {\n peg$currPos = s6;\n s6 = peg$FAILED;\n }\n }\n s6 = peg$parseclose_paren();\n if (s6 !== peg$FAILED) {\n s4 = [s4, s5, s6];\n s3 = s4;\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n if (s3 !== peg$FAILED) {\n s2 = input.substring(s2, peg$currPos);\n } else {\n s2 = s3;\n }\n if (s2 !== peg$FAILED) {\n s1 = [s1, s2];\n s0 = s1;\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parsesame_line_comment() {\n var s0, s1, s2;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f12(s1);\n if (s2) {\n s2 = void 0;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f13(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parseown_line_comment() {\n var s0, s1, s2;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f14(s1);\n if (s2) {\n s2 = void 0;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f15(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parsewhitespace() {\n var s0, s1, s2;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f16(s1);\n if (s2) {\n s2 = void 0;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f17(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parseparbreak() {\n var s0, s1, s2;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f18(s1);\n if (s2) {\n s2 = void 0;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f19(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parseitem_sep() {\n var s0, s1, s2;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f20(s1);\n if (s2) {\n s2 = void 0;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f21(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parseequals() {\n var s0, s1, s2;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f22(s1);\n if (s2) {\n s2 = void 0;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f23(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parseopen_paren() {\n var s0, s1, s2;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f24(s1);\n if (s2) {\n s2 = void 0;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f25(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parseclose_paren() {\n var s0, s1, s2;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f26(s1);\n if (s2) {\n s2 = void 0;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f27(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parseEOL() {\n var s0, s1;\n s0 = peg$currPos;\n peg$silentFails++;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n peg$silentFails--;\n if (s1 === peg$FAILED) {\n s0 = void 0;\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function processItem(leadCell, otherCells) {\n const cells = [leadCell || []];\n for (const x of otherCells) {\n cells.push(x.cell || []);\n }\n return { itemParts: cells };\n }\n if (!options.isWhitespace) {\n try {\n Object.assign(options, {\n isChar: (node, char) => node.type === \"string\" && node.content === char,\n isComma(node) {\n return node.type === \"string\" && node.content === \",\";\n },\n isEquals(node) {\n return node.type === \"string\" && node.content === \"=\";\n },\n isParbreak(node) {\n return node.type === \"parbreak\";\n },\n isWhitespace(node) {\n return node.type === \"whitespace\";\n },\n isSameLineComment: (node) => node.type === \"comment\" && node.sameline,\n isOwnLineComment: (node) => node.type === \"comment\" && !node.sameline,\n isComment: (node) => node.type === \"comment\",\n allowParenGroups: true\n });\n } catch (e) {\n console.warn(\"Error when initializing parser\", e);\n }\n }\n peg$result = peg$startRuleFunction();\n if (peg$result !== peg$FAILED && peg$currPos === input.length) {\n return peg$result;\n } else {\n if (peg$result !== peg$FAILED && peg$currPos < input.length) {\n peg$fail(peg$endExpectation());\n }\n throw peg$buildStructuredError(\n peg$maxFailExpected,\n peg$maxFailPos < input.length ? input.charAt(peg$maxFailPos) : null,\n peg$maxFailPos < input.length ? peg$computeLocation(peg$maxFailPos, peg$maxFailPos + 1) : peg$computeLocation(peg$maxFailPos, peg$maxFailPos)\n );\n }\n }\n return {\n SyntaxError: peg$SyntaxError,\n parse: peg$parse\n };\n }()\n);\n","export default (\n // Generated by Peggy 3.0.2.\n //\n // https://peggyjs.org/\n function() {\n \"use strict\";\n function peg$subclass(child, parent) {\n function C() {\n this.constructor = child;\n }\n C.prototype = parent.prototype;\n child.prototype = new C();\n }\n function peg$SyntaxError(message, expected, found, location) {\n var self = Error.call(this, message);\n if (Object.setPrototypeOf) {\n Object.setPrototypeOf(self, peg$SyntaxError.prototype);\n }\n self.expected = expected;\n self.found = found;\n self.location = location;\n self.name = \"SyntaxError\";\n return self;\n }\n peg$subclass(peg$SyntaxError, Error);\n function peg$padEnd(str, targetLength, padString) {\n padString = padString || \" \";\n if (str.length > targetLength) {\n return str;\n }\n targetLength -= str.length;\n padString += padString.repeat(targetLength);\n return str + padString.slice(0, targetLength);\n }\n peg$SyntaxError.prototype.format = function(sources) {\n var str = \"Error: \" + this.message;\n if (this.location) {\n var src = null;\n var k;\n for (k = 0; k < sources.length; k++) {\n if (sources[k].source === this.location.source) {\n src = sources[k].text.split(/\\r\\n|\\n|\\r/g);\n break;\n }\n }\n var s = this.location.start;\n var offset_s = this.location.source && typeof this.location.source.offset === \"function\" ? this.location.source.offset(s) : s;\n var loc = this.location.source + \":\" + offset_s.line + \":\" + offset_s.column;\n if (src) {\n var e = this.location.end;\n var filler = peg$padEnd(\"\", offset_s.line.toString().length, \" \");\n var line = src[s.line - 1];\n var last = s.line === e.line ? e.column : line.length + 1;\n var hatLen = last - s.column || 1;\n str += \"\\n --> \" + loc + \"\\n\" + filler + \" |\\n\" + offset_s.line + \" | \" + line + \"\\n\" + filler + \" | \" + peg$padEnd(\"\", s.column - 1, \" \") + peg$padEnd(\"\", hatLen, \"^\");\n } else {\n str += \"\\n at \" + loc;\n }\n }\n return str;\n };\n peg$SyntaxError.buildMessage = function(expected, found) {\n var DESCRIBE_EXPECTATION_FNS = {\n literal: function(expectation) {\n return '\"' + literalEscape(expectation.text) + '\"';\n },\n class: function(expectation) {\n var escapedParts = expectation.parts.map(function(part) {\n return Array.isArray(part) ? classEscape(part[0]) + \"-\" + classEscape(part[1]) : classEscape(part);\n });\n return \"[\" + (expectation.inverted ? \"^\" : \"\") + escapedParts.join(\"\") + \"]\";\n },\n any: function() {\n return \"any character\";\n },\n end: function() {\n return \"end of input\";\n },\n other: function(expectation) {\n return expectation.description;\n }\n };\n function hex(ch) {\n return ch.charCodeAt(0).toString(16).toUpperCase();\n }\n function literalEscape(s) {\n return s.replace(/\\\\/g, \"\\\\\\\\\").replace(/\"/g, '\\\\\"').replace(/\\0/g, \"\\\\0\").replace(/\\t/g, \"\\\\t\").replace(/\\n/g, \"\\\\n\").replace(/\\r/g, \"\\\\r\").replace(/[\\x00-\\x0F]/g, function(ch) {\n return \"\\\\x0\" + hex(ch);\n }).replace(/[\\x10-\\x1F\\x7F-\\x9F]/g, function(ch) {\n return \"\\\\x\" + hex(ch);\n });\n }\n function classEscape(s) {\n return s.replace(/\\\\/g, \"\\\\\\\\\").replace(/\\]/g, \"\\\\]\").replace(/\\^/g, \"\\\\^\").replace(/-/g, \"\\\\-\").replace(/\\0/g, \"\\\\0\").replace(/\\t/g, \"\\\\t\").replace(/\\n/g, \"\\\\n\").replace(/\\r/g, \"\\\\r\").replace(/[\\x00-\\x0F]/g, function(ch) {\n return \"\\\\x0\" + hex(ch);\n }).replace(/[\\x10-\\x1F\\x7F-\\x9F]/g, function(ch) {\n return \"\\\\x\" + hex(ch);\n });\n }\n function describeExpectation(expectation) {\n return DESCRIBE_EXPECTATION_FNS[expectation.type](expectation);\n }\n function describeExpected(expected2) {\n var descriptions = expected2.map(describeExpectation);\n var i, j;\n descriptions.sort();\n if (descriptions.length > 0) {\n for (i = 1, j = 1; i < descriptions.length; i++) {\n if (descriptions[i - 1] !== descriptions[i]) {\n descriptions[j] = descriptions[i];\n j++;\n }\n }\n descriptions.length = j;\n }\n switch (descriptions.length) {\n case 1:\n return descriptions[0];\n case 2:\n return descriptions[0] + \" or \" + descriptions[1];\n default:\n return descriptions.slice(0, -1).join(\", \") + \", or \" + descriptions[descriptions.length - 1];\n }\n }\n function describeFound(found2) {\n return found2 ? '\"' + literalEscape(found2) + '\"' : \"end of input\";\n }\n return \"Expected \" + describeExpected(expected) + \" but \" + describeFound(found) + \" found.\";\n };\n function peg$parse(input, options) {\n options = options !== void 0 ? options : {};\n var peg$FAILED = {};\n var peg$source = options.grammarSource;\n var peg$startRuleFunctions = { body: peg$parsebody };\n var peg$startRuleFunction = peg$parsebody;\n var peg$e0 = peg$anyExpectation();\n var peg$f0 = function(e) {\n return [].concat(...e).filter((n) => !!n);\n };\n var peg$f1 = function() {\n return [];\n };\n var peg$f2 = function(tok) {\n return options.isHash(tok);\n };\n var peg$f3 = function(tok) {\n return tok;\n };\n var peg$f4 = function(tok) {\n return options.isNumber(tok);\n };\n var peg$f5 = function(tok) {\n return tok;\n };\n var peg$f6 = function() {\n return { type: \"string\", content: \"#\" };\n };\n var peg$f7 = function(num) {\n const split = options.splitNumber(num);\n return [{ type: \"hash_number\", number: split.number }, split.rest];\n };\n var peg$currPos = 0;\n var peg$savedPos = 0;\n var peg$posDetailsCache = [{ line: 1, column: 1 }];\n var peg$maxFailPos = 0;\n var peg$maxFailExpected = [];\n var peg$silentFails = 0;\n var peg$result;\n if (\"startRule\" in options) {\n if (!(options.startRule in peg$startRuleFunctions)) {\n throw new Error(`Can't start parsing from rule \"` + options.startRule + '\".');\n }\n peg$startRuleFunction = peg$startRuleFunctions[options.startRule];\n }\n function text() {\n return input.substring(peg$savedPos, peg$currPos);\n }\n function offset() {\n return peg$savedPos;\n }\n function range() {\n return {\n source: peg$source,\n start: peg$savedPos,\n end: peg$currPos\n };\n }\n function location() {\n return peg$computeLocation(peg$savedPos, peg$currPos);\n }\n function expected(description, location2) {\n location2 = location2 !== void 0 ? location2 : peg$computeLocation(peg$savedPos, peg$currPos);\n throw peg$buildStructuredError(\n [peg$otherExpectation(description)],\n input.substring(peg$savedPos, peg$currPos),\n location2\n );\n }\n function error(message, location2) {\n location2 = location2 !== void 0 ? location2 : peg$computeLocation(peg$savedPos, peg$currPos);\n throw peg$buildSimpleError(message, location2);\n }\n function peg$literalExpectation(text2, ignoreCase) {\n return { type: \"literal\", text: text2, ignoreCase };\n }\n function peg$classExpectation(parts, inverted, ignoreCase) {\n return { type: \"class\", parts, inverted, ignoreCase };\n }\n function peg$anyExpectation() {\n return { type: \"any\" };\n }\n function peg$endExpectation() {\n return { type: \"end\" };\n }\n function peg$otherExpectation(description) {\n return { type: \"other\", description };\n }\n function peg$computePosDetails(pos) {\n var details = peg$posDetailsCache[pos];\n var p;\n if (details) {\n return details;\n } else {\n p = pos - 1;\n while (!peg$posDetailsCache[p]) {\n p--;\n }\n details = peg$posDetailsCache[p];\n details = {\n line: details.line,\n column: details.column\n };\n while (p < pos) {\n if (input.charCodeAt(p) === 10) {\n details.line++;\n details.column = 1;\n } else {\n details.column++;\n }\n p++;\n }\n peg$posDetailsCache[pos] = details;\n return details;\n }\n }\n function peg$computeLocation(startPos, endPos, offset2) {\n var startPosDetails = peg$computePosDetails(startPos);\n var endPosDetails = peg$computePosDetails(endPos);\n var res = {\n source: peg$source,\n start: {\n offset: startPos,\n line: startPosDetails.line,\n column: startPosDetails.column\n },\n end: {\n offset: endPos,\n line: endPosDetails.line,\n column: endPosDetails.column\n }\n };\n if (offset2 && peg$source && typeof peg$source.offset === \"function\") {\n res.start = peg$source.offset(res.start);\n res.end = peg$source.offset(res.end);\n }\n return res;\n }\n function peg$fail(expected2) {\n if (peg$currPos < peg$maxFailPos) {\n return;\n }\n if (peg$currPos > peg$maxFailPos) {\n peg$maxFailPos = peg$currPos;\n peg$maxFailExpected = [];\n }\n peg$maxFailExpected.push(expected2);\n }\n function peg$buildSimpleError(message, location2) {\n return new peg$SyntaxError(message, null, null, location2);\n }\n function peg$buildStructuredError(expected2, found, location2) {\n return new peg$SyntaxError(\n peg$SyntaxError.buildMessage(expected2, found),\n expected2,\n found,\n location2\n );\n }\n function peg$parsebody() {\n var s0, s1, s2;\n s0 = peg$currPos;\n s1 = [];\n s2 = peg$parsedouble_hash();\n if (s2 === peg$FAILED) {\n s2 = peg$parsehash_number();\n if (s2 === peg$FAILED) {\n if (input.length > peg$currPos) {\n s2 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s2 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n }\n }\n if (s2 !== peg$FAILED) {\n while (s2 !== peg$FAILED) {\n s1.push(s2);\n s2 = peg$parsedouble_hash();\n if (s2 === peg$FAILED) {\n s2 = peg$parsehash_number();\n if (s2 === peg$FAILED) {\n if (input.length > peg$currPos) {\n s2 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s2 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n }\n }\n }\n } else {\n s1 = peg$FAILED;\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = s0;\n s1 = peg$f0(s1);\n }\n s0 = s1;\n if (s0 === peg$FAILED) {\n s0 = peg$currPos;\n s1 = peg$parseEOL();\n if (s1 !== peg$FAILED) {\n peg$savedPos = s0;\n s1 = peg$f1();\n }\n s0 = s1;\n }\n return s0;\n }\n function peg$parsehash() {\n var s0, s1, s2;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f2(s1);\n if (s2) {\n s2 = void 0;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f3(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parsenumber() {\n var s0, s1, s2;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f4(s1);\n if (s2) {\n s2 = void 0;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f5(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parsedouble_hash() {\n var s0, s1, s2;\n s0 = peg$currPos;\n s1 = peg$parsehash();\n if (s1 !== peg$FAILED) {\n s2 = peg$parsehash();\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f6();\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parsehash_number() {\n var s0, s1, s2;\n s0 = peg$currPos;\n s1 = peg$parsehash();\n if (s1 !== peg$FAILED) {\n s2 = peg$parsenumber();\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f7(s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parseEOL() {\n var s0, s1;\n s0 = peg$currPos;\n peg$silentFails++;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n peg$silentFails--;\n if (s1 === peg$FAILED) {\n s0 = void 0;\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n if (!options.isHash) {\n try {\n Object.assign(options, {\n isHash: (node) => node.type === \"string\" && node.content === \"#\",\n isNumber: (node) => node.type === \"string\" && 0 < +node.content.charAt(0),\n splitNumber: (node) => {\n const number = +node.content.charAt(0);\n if (node.content.length > 1) {\n return {\n number,\n rest: {\n type: \"string\",\n content: node.content.slice(1)\n }\n };\n }\n return { number };\n }\n });\n } catch (e) {\n console.warn(\"Error when initializing parser\", e);\n }\n }\n peg$result = peg$startRuleFunction();\n if (peg$result !== peg$FAILED && peg$currPos === input.length) {\n return peg$result;\n } else {\n if (peg$result !== peg$FAILED && peg$currPos < input.length) {\n peg$fail(peg$endExpectation());\n }\n throw peg$buildStructuredError(\n peg$maxFailExpected,\n peg$maxFailPos < input.length ? input.charAt(peg$maxFailPos) : null,\n peg$maxFailPos < input.length ? peg$computeLocation(peg$maxFailPos, peg$maxFailPos + 1) : peg$computeLocation(peg$maxFailPos, peg$maxFailPos)\n );\n }\n }\n return {\n SyntaxError: peg$SyntaxError,\n parse: peg$parse\n };\n }()\n);\n","export default (\n // Generated by Peggy 3.0.2.\n //\n // https://peggyjs.org/\n function() {\n \"use strict\";\n function peg$subclass(child, parent) {\n function C() {\n this.constructor = child;\n }\n C.prototype = parent.prototype;\n child.prototype = new C();\n }\n function peg$SyntaxError(message, expected, found, location) {\n var self = Error.call(this, message);\n if (Object.setPrototypeOf) {\n Object.setPrototypeOf(self, peg$SyntaxError.prototype);\n }\n self.expected = expected;\n self.found = found;\n self.location = location;\n self.name = \"SyntaxError\";\n return self;\n }\n peg$subclass(peg$SyntaxError, Error);\n function peg$padEnd(str, targetLength, padString) {\n padString = padString || \" \";\n if (str.length > targetLength) {\n return str;\n }\n targetLength -= str.length;\n padString += padString.repeat(targetLength);\n return str + padString.slice(0, targetLength);\n }\n peg$SyntaxError.prototype.format = function(sources) {\n var str = \"Error: \" + this.message;\n if (this.location) {\n var src = null;\n var k;\n for (k = 0; k < sources.length; k++) {\n if (sources[k].source === this.location.source) {\n src = sources[k].text.split(/\\r\\n|\\n|\\r/g);\n break;\n }\n }\n var s = this.location.start;\n var offset_s = this.location.source && typeof this.location.source.offset === \"function\" ? this.location.source.offset(s) : s;\n var loc = this.location.source + \":\" + offset_s.line + \":\" + offset_s.column;\n if (src) {\n var e = this.location.end;\n var filler = peg$padEnd(\"\", offset_s.line.toString().length, \" \");\n var line = src[s.line - 1];\n var last = s.line === e.line ? e.column : line.length + 1;\n var hatLen = last - s.column || 1;\n str += \"\\n --> \" + loc + \"\\n\" + filler + \" |\\n\" + offset_s.line + \" | \" + line + \"\\n\" + filler + \" | \" + peg$padEnd(\"\", s.column - 1, \" \") + peg$padEnd(\"\", hatLen, \"^\");\n } else {\n str += \"\\n at \" + loc;\n }\n }\n return str;\n };\n peg$SyntaxError.buildMessage = function(expected, found) {\n var DESCRIBE_EXPECTATION_FNS = {\n literal: function(expectation) {\n return '\"' + literalEscape(expectation.text) + '\"';\n },\n class: function(expectation) {\n var escapedParts = expectation.parts.map(function(part) {\n return Array.isArray(part) ? classEscape(part[0]) + \"-\" + classEscape(part[1]) : classEscape(part);\n });\n return \"[\" + (expectation.inverted ? \"^\" : \"\") + escapedParts.join(\"\") + \"]\";\n },\n any: function() {\n return \"any character\";\n },\n end: function() {\n return \"end of input\";\n },\n other: function(expectation) {\n return expectation.description;\n }\n };\n function hex(ch) {\n return ch.charCodeAt(0).toString(16).toUpperCase();\n }\n function literalEscape(s) {\n return s.replace(/\\\\/g, \"\\\\\\\\\").replace(/\"/g, '\\\\\"').replace(/\\0/g, \"\\\\0\").replace(/\\t/g, \"\\\\t\").replace(/\\n/g, \"\\\\n\").replace(/\\r/g, \"\\\\r\").replace(/[\\x00-\\x0F]/g, function(ch) {\n return \"\\\\x0\" + hex(ch);\n }).replace(/[\\x10-\\x1F\\x7F-\\x9F]/g, function(ch) {\n return \"\\\\x\" + hex(ch);\n });\n }\n function classEscape(s) {\n return s.replace(/\\\\/g, \"\\\\\\\\\").replace(/\\]/g, \"\\\\]\").replace(/\\^/g, \"\\\\^\").replace(/-/g, \"\\\\-\").replace(/\\0/g, \"\\\\0\").replace(/\\t/g, \"\\\\t\").replace(/\\n/g, \"\\\\n\").replace(/\\r/g, \"\\\\r\").replace(/[\\x00-\\x0F]/g, function(ch) {\n return \"\\\\x0\" + hex(ch);\n }).replace(/[\\x10-\\x1F\\x7F-\\x9F]/g, function(ch) {\n return \"\\\\x\" + hex(ch);\n });\n }\n function describeExpectation(expectation) {\n return DESCRIBE_EXPECTATION_FNS[expectation.type](expectation);\n }\n function describeExpected(expected2) {\n var descriptions = expected2.map(describeExpectation);\n var i, j;\n descriptions.sort();\n if (descriptions.length > 0) {\n for (i = 1, j = 1; i < descriptions.length; i++) {\n if (descriptions[i - 1] !== descriptions[i]) {\n descriptions[j] = descriptions[i];\n j++;\n }\n }\n descriptions.length = j;\n }\n switch (descriptions.length) {\n case 1:\n return descriptions[0];\n case 2:\n return descriptions[0] + \" or \" + descriptions[1];\n default:\n return descriptions.slice(0, -1).join(\", \") + \", or \" + descriptions[descriptions.length - 1];\n }\n }\n function describeFound(found2) {\n return found2 ? '\"' + literalEscape(found2) + '\"' : \"end of input\";\n }\n return \"Expected \" + describeExpected(expected) + \" but \" + describeFound(found) + \" found.\";\n };\n function peg$parse(input, options) {\n options = options !== void 0 ? options : {};\n var peg$FAILED = {};\n var peg$source = options.grammarSource;\n var peg$startRuleFunctions = { body: peg$parsebody };\n var peg$startRuleFunction = peg$parsebody;\n var peg$e0 = peg$anyExpectation();\n var peg$f0 = function(e) {\n return [].concat(...e).filter((n) => !!n);\n };\n var peg$f1 = function() {\n return [];\n };\n var peg$f2 = function(toks) {\n return options.isRecognized(toks);\n };\n var peg$f3 = function(toks) {\n return options.isRecognized(toks);\n };\n var peg$f4 = function(tok1, tok2) {\n const split = options.split(tok2);\n return options.isRecognized([tok1, split[0]]);\n };\n var peg$f5 = function(tok1, tok2) {\n const split = options.split(tok2);\n return [options.isRecognized([tok1, split[0]]), split[1]];\n };\n var peg$f6 = function(tok1, tok2) {\n return options.isRecognized([tok1, tok2]);\n };\n var peg$f7 = function(tok1, tok2) {\n return options.isRecognized([tok1, tok2]);\n };\n var peg$f8 = function(toks) {\n return options.isRecognized(toks);\n };\n var peg$f9 = function(toks) {\n return options.isRecognized(toks);\n };\n var peg$f10 = function(tok) {\n return options.isRecognized([tok]);\n };\n var peg$f11 = function(tok) {\n return options.isRecognized([tok]);\n };\n var peg$f12 = function(tok) {\n return options.isMacro(tok);\n };\n var peg$f13 = function(tok) {\n return tok;\n };\n var peg$f14 = function(tok) {\n return options.isWhitespace(tok);\n };\n var peg$f15 = function(tok) {\n return tok;\n };\n var peg$f16 = function(tok) {\n return options.isSplitable(tok);\n };\n var peg$f17 = function(tok) {\n return tok;\n };\n var peg$currPos = 0;\n var peg$savedPos = 0;\n var peg$posDetailsCache = [{ line: 1, column: 1 }];\n var peg$maxFailPos = 0;\n var peg$maxFailExpected = [];\n var peg$silentFails = 0;\n var peg$result;\n if (\"startRule\" in options) {\n if (!(options.startRule in peg$startRuleFunctions)) {\n throw new Error(`Can't start parsing from rule \"` + options.startRule + '\".');\n }\n peg$startRuleFunction = peg$startRuleFunctions[options.startRule];\n }\n function text() {\n return input.substring(peg$savedPos, peg$currPos);\n }\n function offset() {\n return peg$savedPos;\n }\n function range() {\n return {\n source: peg$source,\n start: peg$savedPos,\n end: peg$currPos\n };\n }\n function location() {\n return peg$computeLocation(peg$savedPos, peg$currPos);\n }\n function expected(description, location2) {\n location2 = location2 !== void 0 ? location2 : peg$computeLocation(peg$savedPos, peg$currPos);\n throw peg$buildStructuredError(\n [peg$otherExpectation(description)],\n input.substring(peg$savedPos, peg$currPos),\n location2\n );\n }\n function error(message, location2) {\n location2 = location2 !== void 0 ? location2 : peg$computeLocation(peg$savedPos, peg$currPos);\n throw peg$buildSimpleError(message, location2);\n }\n function peg$literalExpectation(text2, ignoreCase) {\n return { type: \"literal\", text: text2, ignoreCase };\n }\n function peg$classExpectation(parts, inverted, ignoreCase) {\n return { type: \"class\", parts, inverted, ignoreCase };\n }\n function peg$anyExpectation() {\n return { type: \"any\" };\n }\n function peg$endExpectation() {\n return { type: \"end\" };\n }\n function peg$otherExpectation(description) {\n return { type: \"other\", description };\n }\n function peg$computePosDetails(pos) {\n var details = peg$posDetailsCache[pos];\n var p;\n if (details) {\n return details;\n } else {\n p = pos - 1;\n while (!peg$posDetailsCache[p]) {\n p--;\n }\n details = peg$posDetailsCache[p];\n details = {\n line: details.line,\n column: details.column\n };\n while (p < pos) {\n if (input.charCodeAt(p) === 10) {\n details.line++;\n details.column = 1;\n } else {\n details.column++;\n }\n p++;\n }\n peg$posDetailsCache[pos] = details;\n return details;\n }\n }\n function peg$computeLocation(startPos, endPos, offset2) {\n var startPosDetails = peg$computePosDetails(startPos);\n var endPosDetails = peg$computePosDetails(endPos);\n var res = {\n source: peg$source,\n start: {\n offset: startPos,\n line: startPosDetails.line,\n column: startPosDetails.column\n },\n end: {\n offset: endPos,\n line: endPosDetails.line,\n column: endPosDetails.column\n }\n };\n if (offset2 && peg$source && typeof peg$source.offset === \"function\") {\n res.start = peg$source.offset(res.start);\n res.end = peg$source.offset(res.end);\n }\n return res;\n }\n function peg$fail(expected2) {\n if (peg$currPos < peg$maxFailPos) {\n return;\n }\n if (peg$currPos > peg$maxFailPos) {\n peg$maxFailPos = peg$currPos;\n peg$maxFailExpected = [];\n }\n peg$maxFailExpected.push(expected2);\n }\n function peg$buildSimpleError(message, location2) {\n return new peg$SyntaxError(message, null, null, location2);\n }\n function peg$buildStructuredError(expected2, found, location2) {\n return new peg$SyntaxError(\n peg$SyntaxError.buildMessage(expected2, found),\n expected2,\n found,\n location2\n );\n }\n function peg$parsebody() {\n var s0, s1, s2;\n s0 = peg$currPos;\n s1 = [];\n s2 = peg$parsetriple_ligature();\n if (s2 === peg$FAILED) {\n s2 = peg$parsedouble_ligature();\n if (s2 === peg$FAILED) {\n s2 = peg$parsemono_ligature();\n if (s2 === peg$FAILED) {\n if (input.length > peg$currPos) {\n s2 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s2 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n }\n }\n }\n if (s2 !== peg$FAILED) {\n while (s2 !== peg$FAILED) {\n s1.push(s2);\n s2 = peg$parsetriple_ligature();\n if (s2 === peg$FAILED) {\n s2 = peg$parsedouble_ligature();\n if (s2 === peg$FAILED) {\n s2 = peg$parsemono_ligature();\n if (s2 === peg$FAILED) {\n if (input.length > peg$currPos) {\n s2 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s2 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n }\n }\n }\n }\n } else {\n s1 = peg$FAILED;\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = s0;\n s1 = peg$f0(s1);\n }\n s0 = s1;\n if (s0 === peg$FAILED) {\n s0 = peg$currPos;\n s1 = peg$parseEOL();\n if (s1 !== peg$FAILED) {\n peg$savedPos = s0;\n s1 = peg$f1();\n }\n s0 = s1;\n }\n return s0;\n }\n function peg$parsetriple_ligature() {\n var s0, s1, s2, s3, s4;\n s0 = peg$currPos;\n s1 = peg$currPos;\n if (input.length > peg$currPos) {\n s2 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s2 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n if (s2 !== peg$FAILED) {\n if (input.length > peg$currPos) {\n s3 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s3 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n if (s3 !== peg$FAILED) {\n if (input.length > peg$currPos) {\n s4 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s4 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n if (s4 !== peg$FAILED) {\n s2 = [s2, s3, s4];\n s1 = s2;\n } else {\n peg$currPos = s1;\n s1 = peg$FAILED;\n }\n } else {\n peg$currPos = s1;\n s1 = peg$FAILED;\n }\n } else {\n peg$currPos = s1;\n s1 = peg$FAILED;\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f2(s1);\n if (s2) {\n s2 = void 0;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f3(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parsedouble_ligature() {\n var s0;\n s0 = peg$parsedouble_macro_ligature();\n if (s0 === peg$FAILED) {\n s0 = peg$parsedouble_macro_ligature_extracted();\n if (s0 === peg$FAILED) {\n s0 = peg$parsedouble_char_ligature();\n }\n }\n return s0;\n }\n function peg$parsedouble_macro_ligature_extracted() {\n var s0, s1, s2, s3, s4;\n s0 = peg$currPos;\n s1 = peg$parsemacro();\n if (s1 !== peg$FAILED) {\n s2 = [];\n s3 = peg$parsewhitespace();\n while (s3 !== peg$FAILED) {\n s2.push(s3);\n s3 = peg$parsewhitespace();\n }\n s3 = peg$parsesplitable();\n if (s3 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s4 = peg$f4(s1, s3);\n if (s4) {\n s4 = void 0;\n } else {\n s4 = peg$FAILED;\n }\n if (s4 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f5(s1, s3);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parsedouble_macro_ligature() {\n var s0, s1, s2, s3, s4;\n s0 = peg$currPos;\n s1 = peg$parsemacro();\n if (s1 !== peg$FAILED) {\n s2 = [];\n s3 = peg$parsewhitespace();\n while (s3 !== peg$FAILED) {\n s2.push(s3);\n s3 = peg$parsewhitespace();\n }\n if (input.length > peg$currPos) {\n s3 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s3 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n if (s3 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s4 = peg$f6(s1, s3);\n if (s4) {\n s4 = void 0;\n } else {\n s4 = peg$FAILED;\n }\n if (s4 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f7(s1, s3);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parsedouble_char_ligature() {\n var s0, s1, s2, s3;\n s0 = peg$currPos;\n s1 = peg$currPos;\n if (input.length > peg$currPos) {\n s2 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s2 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n if (s2 !== peg$FAILED) {\n if (input.length > peg$currPos) {\n s3 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s3 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n if (s3 !== peg$FAILED) {\n s2 = [s2, s3];\n s1 = s2;\n } else {\n peg$currPos = s1;\n s1 = peg$FAILED;\n }\n } else {\n peg$currPos = s1;\n s1 = peg$FAILED;\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f8(s1);\n if (s2) {\n s2 = void 0;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f9(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parsemono_ligature() {\n var s0, s1, s2;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f10(s1);\n if (s2) {\n s2 = void 0;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f11(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parsemacro() {\n var s0, s1, s2;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f12(s1);\n if (s2) {\n s2 = void 0;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f13(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parsewhitespace() {\n var s0, s1, s2;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f14(s1);\n if (s2) {\n s2 = void 0;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f15(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parsesplitable() {\n var s0, s1, s2;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f16(s1);\n if (s2) {\n s2 = void 0;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f17(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parseEOL() {\n var s0, s1;\n s0 = peg$currPos;\n peg$silentFails++;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n peg$silentFails--;\n if (s1 === peg$FAILED) {\n s0 = void 0;\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n if (!options.isWhitespace) {\n try {\n Object.assign(options, {\n isMacro: (node) => node.type === \"macro\",\n isWhitespace: (node) => node.type === \"whitespace\",\n isRecognized: (nodes) => {\n if (nodes.length == 2 && nodes[0].content === \"^\" && nodes[1].content === \"o\") {\n return { type: \"string\", content: \"\\xF4\" };\n }\n return null;\n },\n isSplitable: (node) => node.type === \"string\" && node.content.length > 1,\n split: (node) => [\n { type: \"string\", content: node.content.charAt(0) },\n { type: \"string\", content: node.content.slice(1) }\n ]\n });\n } catch (e) {\n console.warn(\"Error when initializing parser\", e);\n }\n }\n peg$result = peg$startRuleFunction();\n if (peg$result !== peg$FAILED && peg$currPos === input.length) {\n return peg$result;\n } else {\n if (peg$result !== peg$FAILED && peg$currPos < input.length) {\n peg$fail(peg$endExpectation());\n }\n throw peg$buildStructuredError(\n peg$maxFailExpected,\n peg$maxFailPos < input.length ? input.charAt(peg$maxFailPos) : null,\n peg$maxFailPos < input.length ? peg$computeLocation(peg$maxFailPos, peg$maxFailPos + 1) : peg$computeLocation(peg$maxFailPos, peg$maxFailPos)\n );\n }\n }\n return {\n SyntaxError: peg$SyntaxError,\n parse: peg$parse\n };\n }()\n);\n","export default (\n // Generated by Peggy 3.0.2.\n //\n // https://peggyjs.org/\n function() {\n \"use strict\";\n function peg$subclass(child, parent) {\n function C() {\n this.constructor = child;\n }\n C.prototype = parent.prototype;\n child.prototype = new C();\n }\n function peg$SyntaxError(message, expected, found, location) {\n var self = Error.call(this, message);\n if (Object.setPrototypeOf) {\n Object.setPrototypeOf(self, peg$SyntaxError.prototype);\n }\n self.expected = expected;\n self.found = found;\n self.location = location;\n self.name = \"SyntaxError\";\n return self;\n }\n peg$subclass(peg$SyntaxError, Error);\n function peg$padEnd(str, targetLength, padString) {\n padString = padString || \" \";\n if (str.length > targetLength) {\n return str;\n }\n targetLength -= str.length;\n padString += padString.repeat(targetLength);\n return str + padString.slice(0, targetLength);\n }\n peg$SyntaxError.prototype.format = function(sources) {\n var str = \"Error: \" + this.message;\n if (this.location) {\n var src = null;\n var k;\n for (k = 0; k < sources.length; k++) {\n if (sources[k].source === this.location.source) {\n src = sources[k].text.split(/\\r\\n|\\n|\\r/g);\n break;\n }\n }\n var s = this.location.start;\n var offset_s = this.location.source && typeof this.location.source.offset === \"function\" ? this.location.source.offset(s) : s;\n var loc = this.location.source + \":\" + offset_s.line + \":\" + offset_s.column;\n if (src) {\n var e = this.location.end;\n var filler = peg$padEnd(\"\", offset_s.line.toString().length, \" \");\n var line = src[s.line - 1];\n var last = s.line === e.line ? e.column : line.length + 1;\n var hatLen = last - s.column || 1;\n str += \"\\n --> \" + loc + \"\\n\" + filler + \" |\\n\" + offset_s.line + \" | \" + line + \"\\n\" + filler + \" | \" + peg$padEnd(\"\", s.column - 1, \" \") + peg$padEnd(\"\", hatLen, \"^\");\n } else {\n str += \"\\n at \" + loc;\n }\n }\n return str;\n };\n peg$SyntaxError.buildMessage = function(expected, found) {\n var DESCRIBE_EXPECTATION_FNS = {\n literal: function(expectation) {\n return '\"' + literalEscape(expectation.text) + '\"';\n },\n class: function(expectation) {\n var escapedParts = expectation.parts.map(function(part) {\n return Array.isArray(part) ? classEscape(part[0]) + \"-\" + classEscape(part[1]) : classEscape(part);\n });\n return \"[\" + (expectation.inverted ? \"^\" : \"\") + escapedParts.join(\"\") + \"]\";\n },\n any: function() {\n return \"any character\";\n },\n end: function() {\n return \"end of input\";\n },\n other: function(expectation) {\n return expectation.description;\n }\n };\n function hex(ch) {\n return ch.charCodeAt(0).toString(16).toUpperCase();\n }\n function literalEscape(s) {\n return s.replace(/\\\\/g, \"\\\\\\\\\").replace(/\"/g, '\\\\\"').replace(/\\0/g, \"\\\\0\").replace(/\\t/g, \"\\\\t\").replace(/\\n/g, \"\\\\n\").replace(/\\r/g, \"\\\\r\").replace(/[\\x00-\\x0F]/g, function(ch) {\n return \"\\\\x0\" + hex(ch);\n }).replace(/[\\x10-\\x1F\\x7F-\\x9F]/g, function(ch) {\n return \"\\\\x\" + hex(ch);\n });\n }\n function classEscape(s) {\n return s.replace(/\\\\/g, \"\\\\\\\\\").replace(/\\]/g, \"\\\\]\").replace(/\\^/g, \"\\\\^\").replace(/-/g, \"\\\\-\").replace(/\\0/g, \"\\\\0\").replace(/\\t/g, \"\\\\t\").replace(/\\n/g, \"\\\\n\").replace(/\\r/g, \"\\\\r\").replace(/[\\x00-\\x0F]/g, function(ch) {\n return \"\\\\x0\" + hex(ch);\n }).replace(/[\\x10-\\x1F\\x7F-\\x9F]/g, function(ch) {\n return \"\\\\x\" + hex(ch);\n });\n }\n function describeExpectation(expectation) {\n return DESCRIBE_EXPECTATION_FNS[expectation.type](expectation);\n }\n function describeExpected(expected2) {\n var descriptions = expected2.map(describeExpectation);\n var i, j;\n descriptions.sort();\n if (descriptions.length > 0) {\n for (i = 1, j = 1; i < descriptions.length; i++) {\n if (descriptions[i - 1] !== descriptions[i]) {\n descriptions[j] = descriptions[i];\n j++;\n }\n }\n descriptions.length = j;\n }\n switch (descriptions.length) {\n case 1:\n return descriptions[0];\n case 2:\n return descriptions[0] + \" or \" + descriptions[1];\n default:\n return descriptions.slice(0, -1).join(\", \") + \", or \" + descriptions[descriptions.length - 1];\n }\n }\n function describeFound(found2) {\n return found2 ? '\"' + literalEscape(found2) + '\"' : \"end of input\";\n }\n return \"Expected \" + describeExpected(expected) + \" but \" + describeFound(found) + \" found.\";\n };\n function peg$parse(input, options) {\n options = options !== void 0 ? options : {};\n var peg$FAILED = {};\n var peg$source = options.grammarSource;\n var peg$startRuleFunctions = { start: peg$parsestart };\n var peg$startRuleFunction = peg$parsestart;\n var peg$c0 = \";\";\n var peg$c1 = \",\";\n var peg$c2 = \":\";\n var peg$c3 = \"/\";\n var peg$c4 = \">\";\n var peg$c5 = \"!\";\n var peg$c6 = \".\";\n var peg$c7 = \"!![\";\n var peg$c8 = \"]\";\n var peg$c9 = \"!!\";\n var peg$c10 = \"+\";\n var peg$c11 = \"-\";\n var peg$r0 = /^[a-zA-Z0-9]/;\n var peg$r1 = /^[0-9]/;\n var peg$r2 = /^[ \\t\\n\\r]/;\n var peg$r3 = /^[0-9a-fA-F]/;\n var peg$e0 = peg$anyExpectation();\n var peg$e1 = peg$literalExpectation(\";\", false);\n var peg$e2 = peg$literalExpectation(\",\", false);\n var peg$e3 = peg$otherExpectation(\"model list\");\n var peg$e4 = peg$literalExpectation(\":\", false);\n var peg$e5 = peg$literalExpectation(\"/\", false);\n var peg$e6 = peg$otherExpectation(\"model\");\n var peg$e7 = peg$otherExpectation(\"color spec list\");\n var peg$e8 = peg$otherExpectation(\"color spec\");\n var peg$e9 = peg$otherExpectation(\"color\");\n var peg$e10 = peg$otherExpectation(\"function expression\");\n var peg$e11 = peg$literalExpectation(\">\", false);\n var peg$e12 = peg$otherExpectation(\"function\");\n var peg$e13 = peg$otherExpectation(\"extended expression\");\n var peg$e14 = peg$otherExpectation(\"core model\");\n var peg$e15 = peg$otherExpectation(\"expr\");\n var peg$e16 = peg$literalExpectation(\"!\", false);\n var peg$e17 = peg$otherExpectation(\"mix expr\");\n var peg$e18 = peg$otherExpectation(\"name\");\n var peg$e19 = peg$literalExpectation(\".\", false);\n var peg$e20 = peg$classExpectation([[\"a\", \"z\"], [\"A\", \"Z\"], [\"0\", \"9\"]], false, false);\n var peg$e21 = peg$otherExpectation(\"postfix\");\n var peg$e22 = peg$literalExpectation(\"!![\", false);\n var peg$e23 = peg$literalExpectation(\"]\", false);\n var peg$e24 = peg$literalExpectation(\"!!\", false);\n var peg$e25 = peg$otherExpectation(\"prefix\");\n var peg$e26 = peg$otherExpectation(\"plus\");\n var peg$e27 = peg$literalExpectation(\"+\", false);\n var peg$e28 = peg$otherExpectation(\"minus\");\n var peg$e29 = peg$literalExpectation(\"-\", false);\n var peg$e30 = peg$otherExpectation(\"num\");\n var peg$e31 = peg$classExpectation([[\"0\", \"9\"]], false, false);\n var peg$e32 = peg$otherExpectation(\"positive float\");\n var peg$e33 = peg$otherExpectation(\"divisor\");\n var peg$e34 = peg$otherExpectation(\"int\");\n var peg$e35 = peg$otherExpectation(\"whitespace\");\n var peg$e36 = peg$classExpectation([\" \", \"\t\", \"\\n\", \"\\r\"], false, false);\n var peg$e37 = peg$classExpectation([[\"0\", \"9\"], [\"a\", \"f\"], [\"A\", \"F\"]], false, false);\n var peg$f0 = function(m) {\n return m;\n };\n var peg$f1 = function(m) {\n return m;\n };\n var peg$f2 = function(m) {\n return m;\n };\n var peg$f3 = function(m) {\n return m;\n };\n var peg$f4 = function(m) {\n return m;\n };\n var peg$f5 = function(a) {\n return { type: \"invalid_spec\", content: a };\n };\n var peg$f6 = function(f, c) {\n return c;\n };\n var peg$f7 = function(f, r) {\n return { type: \"color_set\", content: [f].concat(r) };\n };\n var peg$f8 = function(n, s) {\n return { type: \"color_set_item\", name: n, spec_list: s };\n };\n var peg$f9 = function(c, m) {\n return { type: \"model_list\", contents: m, core_model: c };\n };\n var peg$f10 = function(m) {\n return { type: \"model_list\", contents: m, core_model: null };\n };\n var peg$f11 = function(m, a) {\n return a;\n };\n var peg$f12 = function(m, r) {\n return [m].concat(r);\n };\n var peg$f13 = function(s, a) {\n return a;\n };\n var peg$f14 = function(s, r) {\n return { type: \"spec_list\", content: [s].concat(r) };\n };\n var peg$f15 = function(c) {\n return { type: \"hex_spec\", content: [c] };\n };\n var peg$f16 = function(c, d) {\n return d;\n };\n var peg$f17 = function(c, d) {\n return d;\n };\n var peg$f18 = function(c, r) {\n return { type: \"num_spec\", content: r ? [c].concat(r) : [c] };\n };\n var peg$f19 = function(c, fs) {\n return { type: \"color\", color: c, functions: fs };\n };\n var peg$f20 = function(f, n) {\n return n;\n };\n var peg$f21 = function(f, args) {\n return { type: \"function\", name: f, args };\n };\n var peg$f22 = function(core, d, e, es) {\n return {\n type: \"extended_expr\",\n core_model: core,\n div: d,\n expressions: [e].concat(es)\n };\n };\n var peg$f23 = function(core, e, es) {\n return {\n type: \"extended_expr\",\n core_model: core,\n div: null,\n expressions: [e].concat(es)\n };\n };\n var peg$f24 = function(e, d) {\n return { type: \"weighted_expr\", color: e, weight: d };\n };\n var peg$f25 = function(e) {\n return e;\n };\n var peg$f26 = function(p, n, e, po) {\n return {\n type: \"expr\",\n prefix: p,\n name: n,\n mix_expr: e,\n postfix: po\n };\n };\n var peg$f27 = function(p, n) {\n return { type: \"complete_mix\", mix_percent: p, name: n };\n };\n var peg$f28 = function(p) {\n return { type: \"partial_mix\", mix_percent: p };\n };\n var peg$f29 = function(c, p) {\n return c.concat(p || []);\n };\n var peg$f30 = function(n) {\n return { type: \"postfix\", num: n };\n };\n var peg$f31 = function(p) {\n return { type: \"postfix\", plusses: p };\n };\n var peg$f32 = function(n) {\n return parseInt(n, 10);\n };\n var peg$f33 = function(n) {\n return parseFloat(n);\n };\n var peg$f34 = function(n) {\n return n;\n };\n var peg$f35 = function(n) {\n return -n;\n };\n var peg$f36 = function(m, n) {\n return m ? -n : n;\n };\n var peg$f37 = function(h) {\n return h.toUpperCase();\n };\n var peg$currPos = 0;\n var peg$savedPos = 0;\n var peg$posDetailsCache = [{ line: 1, column: 1 }];\n var peg$maxFailPos = 0;\n var peg$maxFailExpected = [];\n var peg$silentFails = 0;\n var peg$result;\n if (\"startRule\" in options) {\n if (!(options.startRule in peg$startRuleFunctions)) {\n throw new Error(`Can't start parsing from rule \"` + options.startRule + '\".');\n }\n peg$startRuleFunction = peg$startRuleFunctions[options.startRule];\n }\n function text() {\n return input.substring(peg$savedPos, peg$currPos);\n }\n function offset() {\n return peg$savedPos;\n }\n function range() {\n return {\n source: peg$source,\n start: peg$savedPos,\n end: peg$currPos\n };\n }\n function location() {\n return peg$computeLocation(peg$savedPos, peg$currPos);\n }\n function expected(description, location2) {\n location2 = location2 !== void 0 ? location2 : peg$computeLocation(peg$savedPos, peg$currPos);\n throw peg$buildStructuredError(\n [peg$otherExpectation(description)],\n input.substring(peg$savedPos, peg$currPos),\n location2\n );\n }\n function error(message, location2) {\n location2 = location2 !== void 0 ? location2 : peg$computeLocation(peg$savedPos, peg$currPos);\n throw peg$buildSimpleError(message, location2);\n }\n function peg$literalExpectation(text2, ignoreCase) {\n return { type: \"literal\", text: text2, ignoreCase };\n }\n function peg$classExpectation(parts, inverted, ignoreCase) {\n return { type: \"class\", parts, inverted, ignoreCase };\n }\n function peg$anyExpectation() {\n return { type: \"any\" };\n }\n function peg$endExpectation() {\n return { type: \"end\" };\n }\n function peg$otherExpectation(description) {\n return { type: \"other\", description };\n }\n function peg$computePosDetails(pos) {\n var details = peg$posDetailsCache[pos];\n var p;\n if (details) {\n return details;\n } else {\n p = pos - 1;\n while (!peg$posDetailsCache[p]) {\n p--;\n }\n details = peg$posDetailsCache[p];\n details = {\n line: details.line,\n column: details.column\n };\n while (p < pos) {\n if (input.charCodeAt(p) === 10) {\n details.line++;\n details.column = 1;\n } else {\n details.column++;\n }\n p++;\n }\n peg$posDetailsCache[pos] = details;\n return details;\n }\n }\n function peg$computeLocation(startPos, endPos, offset2) {\n var startPosDetails = peg$computePosDetails(startPos);\n var endPosDetails = peg$computePosDetails(endPos);\n var res = {\n source: peg$source,\n start: {\n offset: startPos,\n line: startPosDetails.line,\n column: startPosDetails.column\n },\n end: {\n offset: endPos,\n line: endPosDetails.line,\n column: endPosDetails.column\n }\n };\n if (offset2 && peg$source && typeof peg$source.offset === \"function\") {\n res.start = peg$source.offset(res.start);\n res.end = peg$source.offset(res.end);\n }\n return res;\n }\n function peg$fail(expected2) {\n if (peg$currPos < peg$maxFailPos) {\n return;\n }\n if (peg$currPos > peg$maxFailPos) {\n peg$maxFailPos = peg$currPos;\n peg$maxFailExpected = [];\n }\n peg$maxFailExpected.push(expected2);\n }\n function peg$buildSimpleError(message, location2) {\n return new peg$SyntaxError(message, null, null, location2);\n }\n function peg$buildStructuredError(expected2, found, location2) {\n return new peg$SyntaxError(\n peg$SyntaxError.buildMessage(expected2, found),\n expected2,\n found,\n location2\n );\n }\n function peg$parsestart() {\n var s0, s1, s2, s3;\n s0 = peg$currPos;\n s1 = peg$parsespec();\n if (s1 !== peg$FAILED) {\n s2 = peg$parseEOL();\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f0(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n if (s0 === peg$FAILED) {\n s0 = peg$currPos;\n s1 = peg$parsespec_list();\n if (s1 !== peg$FAILED) {\n s2 = peg$parseEOL();\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f1(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n if (s0 === peg$FAILED) {\n s0 = peg$currPos;\n s1 = peg$parsecolor();\n if (s1 !== peg$FAILED) {\n s2 = peg$parseEOL();\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f2(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n if (s0 === peg$FAILED) {\n s0 = peg$currPos;\n s1 = peg$parsemodel_list();\n if (s1 !== peg$FAILED) {\n s2 = peg$parseEOL();\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f3(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n if (s0 === peg$FAILED) {\n s0 = peg$currPos;\n s1 = peg$parsecolor_set_spec();\n if (s1 !== peg$FAILED) {\n s2 = peg$parseEOL();\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f4(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n if (s0 === peg$FAILED) {\n s0 = peg$currPos;\n s1 = peg$currPos;\n s2 = [];\n if (input.length > peg$currPos) {\n s3 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s3 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n while (s3 !== peg$FAILED) {\n s2.push(s3);\n if (input.length > peg$currPos) {\n s3 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s3 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n }\n s1 = input.substring(s1, peg$currPos);\n peg$savedPos = s0;\n s1 = peg$f5(s1);\n s0 = s1;\n }\n }\n }\n }\n }\n return s0;\n }\n function peg$parsecolor_set_spec() {\n var s0, s1, s2, s3, s4, s5;\n s0 = peg$currPos;\n s1 = peg$parsecolor_set_item();\n if (s1 !== peg$FAILED) {\n s2 = [];\n s3 = peg$currPos;\n if (input.charCodeAt(peg$currPos) === 59) {\n s4 = peg$c0;\n peg$currPos++;\n } else {\n s4 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e1);\n }\n }\n if (s4 !== peg$FAILED) {\n s5 = peg$parsecolor_set_item();\n if (s5 !== peg$FAILED) {\n peg$savedPos = s3;\n s3 = peg$f6(s1, s5);\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n while (s3 !== peg$FAILED) {\n s2.push(s3);\n s3 = peg$currPos;\n if (input.charCodeAt(peg$currPos) === 59) {\n s4 = peg$c0;\n peg$currPos++;\n } else {\n s4 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e1);\n }\n }\n if (s4 !== peg$FAILED) {\n s5 = peg$parsecolor_set_item();\n if (s5 !== peg$FAILED) {\n peg$savedPos = s3;\n s3 = peg$f6(s1, s5);\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n }\n peg$savedPos = s0;\n s0 = peg$f7(s1, s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parsecolor_set_item() {\n var s0, s1, s2, s3;\n s0 = peg$currPos;\n s1 = peg$parsename();\n if (s1 !== peg$FAILED) {\n if (input.charCodeAt(peg$currPos) === 44) {\n s2 = peg$c1;\n peg$currPos++;\n } else {\n s2 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e2);\n }\n }\n if (s2 !== peg$FAILED) {\n s3 = peg$parsespec_list();\n if (s3 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f8(s1, s3);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parsemodel_list() {\n var s0, s1, s2, s3;\n peg$silentFails++;\n s0 = peg$currPos;\n s1 = peg$parsecore_model();\n if (s1 !== peg$FAILED) {\n if (input.charCodeAt(peg$currPos) === 58) {\n s2 = peg$c2;\n peg$currPos++;\n } else {\n s2 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e4);\n }\n }\n if (s2 !== peg$FAILED) {\n s3 = peg$parsemodel_list_tail();\n if (s3 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f9(s1, s3);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n if (s0 === peg$FAILED) {\n s0 = peg$currPos;\n s1 = peg$parsemodel_list_tail();\n if (s1 !== peg$FAILED) {\n peg$savedPos = s0;\n s1 = peg$f10(s1);\n }\n s0 = s1;\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e3);\n }\n }\n return s0;\n }\n function peg$parsemodel_list_tail() {\n var s0, s1, s2, s3, s4, s5;\n s0 = peg$currPos;\n s1 = peg$parsemodel();\n if (s1 !== peg$FAILED) {\n s2 = [];\n s3 = peg$currPos;\n if (input.charCodeAt(peg$currPos) === 47) {\n s4 = peg$c3;\n peg$currPos++;\n } else {\n s4 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e5);\n }\n }\n if (s4 !== peg$FAILED) {\n s5 = peg$parsemodel();\n if (s5 !== peg$FAILED) {\n peg$savedPos = s3;\n s3 = peg$f11(s1, s5);\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n while (s3 !== peg$FAILED) {\n s2.push(s3);\n s3 = peg$currPos;\n if (input.charCodeAt(peg$currPos) === 47) {\n s4 = peg$c3;\n peg$currPos++;\n } else {\n s4 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e5);\n }\n }\n if (s4 !== peg$FAILED) {\n s5 = peg$parsemodel();\n if (s5 !== peg$FAILED) {\n peg$savedPos = s3;\n s3 = peg$f11(s1, s5);\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n }\n peg$savedPos = s0;\n s0 = peg$f12(s1, s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parsemodel() {\n var s0, s1;\n peg$silentFails++;\n s0 = peg$parsecore_model();\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e6);\n }\n }\n return s0;\n }\n function peg$parsespec_list() {\n var s0, s1, s2, s3, s4, s5;\n peg$silentFails++;\n s0 = peg$currPos;\n s1 = peg$parsespec();\n if (s1 !== peg$FAILED) {\n s2 = [];\n s3 = peg$currPos;\n if (input.charCodeAt(peg$currPos) === 47) {\n s4 = peg$c3;\n peg$currPos++;\n } else {\n s4 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e5);\n }\n }\n if (s4 !== peg$FAILED) {\n s5 = peg$parsespec();\n if (s5 !== peg$FAILED) {\n peg$savedPos = s3;\n s3 = peg$f13(s1, s5);\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n while (s3 !== peg$FAILED) {\n s2.push(s3);\n s3 = peg$currPos;\n if (input.charCodeAt(peg$currPos) === 47) {\n s4 = peg$c3;\n peg$currPos++;\n } else {\n s4 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e5);\n }\n }\n if (s4 !== peg$FAILED) {\n s5 = peg$parsespec();\n if (s5 !== peg$FAILED) {\n peg$savedPos = s3;\n s3 = peg$f13(s1, s5);\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n }\n peg$savedPos = s0;\n s0 = peg$f14(s1, s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e7);\n }\n }\n return s0;\n }\n function peg$parsespec() {\n var s0, s1, s2, s3, s4, s5, s6, s7, s8;\n peg$silentFails++;\n s0 = peg$currPos;\n s1 = peg$currPos;\n s2 = peg$currPos;\n s3 = peg$parsehex();\n if (s3 !== peg$FAILED) {\n s4 = peg$parsehex();\n if (s4 !== peg$FAILED) {\n s5 = peg$parsehex();\n if (s5 !== peg$FAILED) {\n s6 = peg$parsehex();\n if (s6 !== peg$FAILED) {\n s7 = peg$parsehex();\n if (s7 !== peg$FAILED) {\n s8 = peg$parsehex();\n if (s8 !== peg$FAILED) {\n s3 = [s3, s4, s5, s6, s7, s8];\n s2 = s3;\n } else {\n peg$currPos = s2;\n s2 = peg$FAILED;\n }\n } else {\n peg$currPos = s2;\n s2 = peg$FAILED;\n }\n } else {\n peg$currPos = s2;\n s2 = peg$FAILED;\n }\n } else {\n peg$currPos = s2;\n s2 = peg$FAILED;\n }\n } else {\n peg$currPos = s2;\n s2 = peg$FAILED;\n }\n } else {\n peg$currPos = s2;\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n s1 = input.substring(s1, peg$currPos);\n } else {\n s1 = s2;\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = s0;\n s1 = peg$f15(s1);\n }\n s0 = s1;\n if (s0 === peg$FAILED) {\n s0 = peg$currPos;\n s1 = peg$parsedec();\n if (s1 !== peg$FAILED) {\n s2 = [];\n s3 = peg$currPos;\n if (input.charCodeAt(peg$currPos) === 44) {\n s4 = peg$c1;\n peg$currPos++;\n } else {\n s4 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e2);\n }\n }\n if (s4 !== peg$FAILED) {\n s5 = peg$parsedec();\n if (s5 !== peg$FAILED) {\n peg$savedPos = s3;\n s3 = peg$f16(s1, s5);\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n if (s3 !== peg$FAILED) {\n while (s3 !== peg$FAILED) {\n s2.push(s3);\n s3 = peg$currPos;\n if (input.charCodeAt(peg$currPos) === 44) {\n s4 = peg$c1;\n peg$currPos++;\n } else {\n s4 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e2);\n }\n }\n if (s4 !== peg$FAILED) {\n s5 = peg$parsedec();\n if (s5 !== peg$FAILED) {\n peg$savedPos = s3;\n s3 = peg$f16(s1, s5);\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n }\n } else {\n s2 = peg$FAILED;\n }\n if (s2 === peg$FAILED) {\n s2 = [];\n s3 = peg$currPos;\n s4 = peg$parsesp();\n if (s4 !== peg$FAILED) {\n s5 = peg$parsedec();\n if (s5 !== peg$FAILED) {\n peg$savedPos = s3;\n s3 = peg$f17(s1, s5);\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n if (s3 !== peg$FAILED) {\n while (s3 !== peg$FAILED) {\n s2.push(s3);\n s3 = peg$currPos;\n s4 = peg$parsesp();\n if (s4 !== peg$FAILED) {\n s5 = peg$parsedec();\n if (s5 !== peg$FAILED) {\n peg$savedPos = s3;\n s3 = peg$f17(s1, s5);\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n }\n } else {\n s2 = peg$FAILED;\n }\n }\n if (s2 === peg$FAILED) {\n s2 = null;\n }\n peg$savedPos = s0;\n s0 = peg$f18(s1, s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e8);\n }\n }\n return s0;\n }\n function peg$parsecolor() {\n var s0, s1, s2, s3;\n peg$silentFails++;\n s0 = peg$currPos;\n s1 = peg$parsecolor_expr();\n if (s1 !== peg$FAILED) {\n s2 = [];\n s3 = peg$parsefunc_expr();\n while (s3 !== peg$FAILED) {\n s2.push(s3);\n s3 = peg$parsefunc_expr();\n }\n peg$savedPos = s0;\n s0 = peg$f19(s1, s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e9);\n }\n }\n return s0;\n }\n function peg$parsecolor_expr() {\n var s0;\n s0 = peg$parseext_expr();\n if (s0 === peg$FAILED) {\n s0 = peg$parseexpr();\n if (s0 === peg$FAILED) {\n s0 = peg$parsename();\n }\n }\n return s0;\n }\n function peg$parsefunc_expr() {\n var s0, s1, s2, s3, s4, s5, s6;\n peg$silentFails++;\n s0 = peg$currPos;\n if (input.charCodeAt(peg$currPos) === 62) {\n s1 = peg$c4;\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e11);\n }\n }\n if (s1 !== peg$FAILED) {\n s2 = peg$parsefunction();\n if (s2 !== peg$FAILED) {\n s3 = [];\n s4 = peg$currPos;\n if (input.charCodeAt(peg$currPos) === 44) {\n s5 = peg$c1;\n peg$currPos++;\n } else {\n s5 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e2);\n }\n }\n if (s5 !== peg$FAILED) {\n s6 = peg$parseint();\n if (s6 !== peg$FAILED) {\n peg$savedPos = s4;\n s4 = peg$f20(s2, s6);\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n while (s4 !== peg$FAILED) {\n s3.push(s4);\n s4 = peg$currPos;\n if (input.charCodeAt(peg$currPos) === 44) {\n s5 = peg$c1;\n peg$currPos++;\n } else {\n s5 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e2);\n }\n }\n if (s5 !== peg$FAILED) {\n s6 = peg$parseint();\n if (s6 !== peg$FAILED) {\n peg$savedPos = s4;\n s4 = peg$f20(s2, s6);\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n }\n peg$savedPos = s0;\n s0 = peg$f21(s2, s3);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e10);\n }\n }\n return s0;\n }\n function peg$parsefunction() {\n var s0, s1;\n peg$silentFails++;\n s0 = peg$parsename();\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e12);\n }\n }\n return s0;\n }\n function peg$parseext_expr() {\n var s0, s1, s2, s3, s4, s5, s6, s7;\n peg$silentFails++;\n s0 = peg$currPos;\n s1 = peg$parsecore_model();\n if (s1 !== peg$FAILED) {\n if (input.charCodeAt(peg$currPos) === 44) {\n s2 = peg$c1;\n peg$currPos++;\n } else {\n s2 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e2);\n }\n }\n if (s2 !== peg$FAILED) {\n s3 = peg$parsediv();\n if (s3 !== peg$FAILED) {\n if (input.charCodeAt(peg$currPos) === 58) {\n s4 = peg$c2;\n peg$currPos++;\n } else {\n s4 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e4);\n }\n }\n if (s4 !== peg$FAILED) {\n s5 = peg$parseweighted_expr();\n if (s5 !== peg$FAILED) {\n s6 = [];\n s7 = peg$parseadditional_weighted_expr();\n while (s7 !== peg$FAILED) {\n s6.push(s7);\n s7 = peg$parseadditional_weighted_expr();\n }\n peg$savedPos = s0;\n s0 = peg$f22(s1, s3, s5, s6);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n if (s0 === peg$FAILED) {\n s0 = peg$currPos;\n s1 = peg$parsecore_model();\n if (s1 !== peg$FAILED) {\n if (input.charCodeAt(peg$currPos) === 58) {\n s2 = peg$c2;\n peg$currPos++;\n } else {\n s2 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e4);\n }\n }\n if (s2 !== peg$FAILED) {\n s3 = peg$parseweighted_expr();\n if (s3 !== peg$FAILED) {\n s4 = [];\n s5 = peg$parseadditional_weighted_expr();\n while (s5 !== peg$FAILED) {\n s4.push(s5);\n s5 = peg$parseadditional_weighted_expr();\n }\n peg$savedPos = s0;\n s0 = peg$f23(s1, s3, s4);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e13);\n }\n }\n return s0;\n }\n function peg$parseweighted_expr() {\n var s0, s1, s2, s3;\n s0 = peg$currPos;\n s1 = peg$parseexpr();\n if (s1 !== peg$FAILED) {\n if (input.charCodeAt(peg$currPos) === 44) {\n s2 = peg$c1;\n peg$currPos++;\n } else {\n s2 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e2);\n }\n }\n if (s2 !== peg$FAILED) {\n s3 = peg$parsedec();\n if (s3 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f24(s1, s3);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parseadditional_weighted_expr() {\n var s0, s1, s2;\n s0 = peg$currPos;\n if (input.charCodeAt(peg$currPos) === 59) {\n s1 = peg$c0;\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e1);\n }\n }\n if (s1 !== peg$FAILED) {\n s2 = peg$parseweighted_expr();\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f25(s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parsecore_model() {\n var s0, s1;\n peg$silentFails++;\n s0 = peg$parsename();\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e14);\n }\n }\n return s0;\n }\n function peg$parseexpr() {\n var s0, s1, s2, s3, s4;\n peg$silentFails++;\n s0 = peg$currPos;\n s1 = peg$parseprefix();\n s2 = peg$parsename();\n if (s2 !== peg$FAILED) {\n s3 = peg$parsemix_expr();\n s4 = peg$parsepostfix();\n if (s4 === peg$FAILED) {\n s4 = null;\n }\n peg$savedPos = s0;\n s0 = peg$f26(s1, s2, s3, s4);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e15);\n }\n }\n return s0;\n }\n function peg$parsecomplete_mix() {\n var s0, s1, s2, s3, s4;\n s0 = peg$currPos;\n if (input.charCodeAt(peg$currPos) === 33) {\n s1 = peg$c5;\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e16);\n }\n }\n if (s1 !== peg$FAILED) {\n s2 = peg$parsepct();\n if (s2 !== peg$FAILED) {\n if (input.charCodeAt(peg$currPos) === 33) {\n s3 = peg$c5;\n peg$currPos++;\n } else {\n s3 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e16);\n }\n }\n if (s3 !== peg$FAILED) {\n s4 = peg$parsename();\n if (s4 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f27(s2, s4);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parsepartial_mix() {\n var s0, s1, s2;\n s0 = peg$currPos;\n if (input.charCodeAt(peg$currPos) === 33) {\n s1 = peg$c5;\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e16);\n }\n }\n if (s1 !== peg$FAILED) {\n s2 = peg$parsepct();\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f28(s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parsemix_expr() {\n var s0, s1, s2;\n peg$silentFails++;\n s0 = peg$currPos;\n s1 = [];\n s2 = peg$parsecomplete_mix();\n while (s2 !== peg$FAILED) {\n s1.push(s2);\n s2 = peg$parsecomplete_mix();\n }\n s2 = peg$parsepartial_mix();\n if (s2 === peg$FAILED) {\n s2 = null;\n }\n peg$savedPos = s0;\n s0 = peg$f29(s1, s2);\n peg$silentFails--;\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e17);\n }\n return s0;\n }\n function peg$parsename() {\n var s0, s1, s2;\n peg$silentFails++;\n if (input.charCodeAt(peg$currPos) === 46) {\n s0 = peg$c6;\n peg$currPos++;\n } else {\n s0 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e19);\n }\n }\n if (s0 === peg$FAILED) {\n s0 = peg$currPos;\n s1 = [];\n if (peg$r0.test(input.charAt(peg$currPos))) {\n s2 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s2 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e20);\n }\n }\n if (s2 !== peg$FAILED) {\n while (s2 !== peg$FAILED) {\n s1.push(s2);\n if (peg$r0.test(input.charAt(peg$currPos))) {\n s2 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s2 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e20);\n }\n }\n }\n } else {\n s1 = peg$FAILED;\n }\n if (s1 !== peg$FAILED) {\n s0 = input.substring(s0, peg$currPos);\n } else {\n s0 = s1;\n }\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e18);\n }\n }\n return s0;\n }\n function peg$parsepostfix() {\n var s0, s1, s2, s3, s4;\n peg$silentFails++;\n s0 = peg$currPos;\n if (input.substr(peg$currPos, 3) === peg$c7) {\n s1 = peg$c7;\n peg$currPos += 3;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e22);\n }\n }\n if (s1 !== peg$FAILED) {\n s2 = peg$parsenum();\n if (s2 !== peg$FAILED) {\n if (input.charCodeAt(peg$currPos) === 93) {\n s3 = peg$c8;\n peg$currPos++;\n } else {\n s3 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e23);\n }\n }\n if (s3 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f30(s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n if (s0 === peg$FAILED) {\n s0 = peg$currPos;\n if (input.substr(peg$currPos, 2) === peg$c9) {\n s1 = peg$c9;\n peg$currPos += 2;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e24);\n }\n }\n if (s1 !== peg$FAILED) {\n s2 = peg$currPos;\n s3 = [];\n s4 = peg$parseplus();\n if (s4 !== peg$FAILED) {\n while (s4 !== peg$FAILED) {\n s3.push(s4);\n s4 = peg$parseplus();\n }\n } else {\n s3 = peg$FAILED;\n }\n if (s3 !== peg$FAILED) {\n s2 = input.substring(s2, peg$currPos);\n } else {\n s2 = s3;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f31(s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e21);\n }\n }\n return s0;\n }\n function peg$parseprefix() {\n var s0, s1;\n peg$silentFails++;\n s0 = peg$parseminus();\n if (s0 === peg$FAILED) {\n s0 = null;\n }\n peg$silentFails--;\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e25);\n }\n return s0;\n }\n function peg$parseplus() {\n var s0, s1, s2;\n peg$silentFails++;\n s0 = peg$currPos;\n s1 = [];\n if (input.charCodeAt(peg$currPos) === 43) {\n s2 = peg$c10;\n peg$currPos++;\n } else {\n s2 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e27);\n }\n }\n if (s2 !== peg$FAILED) {\n while (s2 !== peg$FAILED) {\n s1.push(s2);\n if (input.charCodeAt(peg$currPos) === 43) {\n s2 = peg$c10;\n peg$currPos++;\n } else {\n s2 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e27);\n }\n }\n }\n } else {\n s1 = peg$FAILED;\n }\n if (s1 !== peg$FAILED) {\n s0 = input.substring(s0, peg$currPos);\n } else {\n s0 = s1;\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e26);\n }\n }\n return s0;\n }\n function peg$parseminus() {\n var s0, s1, s2;\n peg$silentFails++;\n s0 = peg$currPos;\n s1 = [];\n if (input.charCodeAt(peg$currPos) === 45) {\n s2 = peg$c11;\n peg$currPos++;\n } else {\n s2 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e29);\n }\n }\n if (s2 !== peg$FAILED) {\n while (s2 !== peg$FAILED) {\n s1.push(s2);\n if (input.charCodeAt(peg$currPos) === 45) {\n s2 = peg$c11;\n peg$currPos++;\n } else {\n s2 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e29);\n }\n }\n }\n } else {\n s1 = peg$FAILED;\n }\n if (s1 !== peg$FAILED) {\n s0 = input.substring(s0, peg$currPos);\n } else {\n s0 = s1;\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e28);\n }\n }\n return s0;\n }\n function peg$parsenum() {\n var s0, s1, s2, s3;\n peg$silentFails++;\n s0 = peg$currPos;\n s1 = peg$currPos;\n s2 = [];\n if (peg$r1.test(input.charAt(peg$currPos))) {\n s3 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s3 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e31);\n }\n }\n if (s3 !== peg$FAILED) {\n while (s3 !== peg$FAILED) {\n s2.push(s3);\n if (peg$r1.test(input.charAt(peg$currPos))) {\n s3 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s3 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e31);\n }\n }\n }\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n s1 = input.substring(s1, peg$currPos);\n } else {\n s1 = s2;\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = s0;\n s1 = peg$f32(s1);\n }\n s0 = s1;\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e30);\n }\n }\n return s0;\n }\n function peg$parsepct() {\n var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;\n peg$silentFails++;\n s0 = peg$currPos;\n s1 = peg$currPos;\n s2 = peg$currPos;\n s3 = peg$currPos;\n s4 = [];\n if (peg$r1.test(input.charAt(peg$currPos))) {\n s5 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s5 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e31);\n }\n }\n if (s5 !== peg$FAILED) {\n while (s5 !== peg$FAILED) {\n s4.push(s5);\n if (peg$r1.test(input.charAt(peg$currPos))) {\n s5 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s5 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e31);\n }\n }\n }\n } else {\n s4 = peg$FAILED;\n }\n if (s4 !== peg$FAILED) {\n s3 = input.substring(s3, peg$currPos);\n } else {\n s3 = s4;\n }\n if (s3 !== peg$FAILED) {\n s4 = peg$currPos;\n s5 = peg$currPos;\n if (input.charCodeAt(peg$currPos) === 46) {\n s6 = peg$c6;\n peg$currPos++;\n } else {\n s6 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e19);\n }\n }\n if (s6 !== peg$FAILED) {\n s7 = peg$currPos;\n s8 = [];\n if (peg$r1.test(input.charAt(peg$currPos))) {\n s9 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s9 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e31);\n }\n }\n while (s9 !== peg$FAILED) {\n s8.push(s9);\n if (peg$r1.test(input.charAt(peg$currPos))) {\n s9 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s9 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e31);\n }\n }\n }\n s7 = input.substring(s7, peg$currPos);\n s6 = [s6, s7];\n s5 = s6;\n } else {\n peg$currPos = s5;\n s5 = peg$FAILED;\n }\n if (s5 === peg$FAILED) {\n s5 = null;\n }\n s4 = input.substring(s4, peg$currPos);\n s3 = [s3, s4];\n s2 = s3;\n } else {\n peg$currPos = s2;\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n s1 = input.substring(s1, peg$currPos);\n } else {\n s1 = s2;\n }\n if (s1 === peg$FAILED) {\n s1 = peg$currPos;\n s2 = peg$currPos;\n if (input.charCodeAt(peg$currPos) === 46) {\n s3 = peg$c6;\n peg$currPos++;\n } else {\n s3 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e19);\n }\n }\n if (s3 !== peg$FAILED) {\n s4 = peg$currPos;\n s5 = [];\n if (peg$r1.test(input.charAt(peg$currPos))) {\n s6 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s6 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e31);\n }\n }\n if (s6 !== peg$FAILED) {\n while (s6 !== peg$FAILED) {\n s5.push(s6);\n if (peg$r1.test(input.charAt(peg$currPos))) {\n s6 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s6 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e31);\n }\n }\n }\n } else {\n s5 = peg$FAILED;\n }\n if (s5 !== peg$FAILED) {\n s4 = input.substring(s4, peg$currPos);\n } else {\n s4 = s5;\n }\n if (s4 !== peg$FAILED) {\n s3 = [s3, s4];\n s2 = s3;\n } else {\n peg$currPos = s2;\n s2 = peg$FAILED;\n }\n } else {\n peg$currPos = s2;\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n s1 = input.substring(s1, peg$currPos);\n } else {\n s1 = s2;\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = s0;\n s1 = peg$f33(s1);\n }\n s0 = s1;\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e32);\n }\n }\n return s0;\n }\n function peg$parsediv() {\n var s0, s1;\n peg$silentFails++;\n s0 = peg$parsepct();\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e33);\n }\n }\n return s0;\n }\n function peg$parsedec() {\n var s0, s1, s2;\n s0 = peg$parsepct();\n if (s0 === peg$FAILED) {\n s0 = peg$currPos;\n if (input.charCodeAt(peg$currPos) === 43) {\n s1 = peg$c10;\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e27);\n }\n }\n if (s1 !== peg$FAILED) {\n s2 = peg$parsepct();\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f34(s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n if (s0 === peg$FAILED) {\n s0 = peg$currPos;\n if (input.charCodeAt(peg$currPos) === 45) {\n s1 = peg$c11;\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e29);\n }\n }\n if (s1 !== peg$FAILED) {\n s2 = peg$parsepct();\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f35(s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n }\n }\n return s0;\n }\n function peg$parseint() {\n var s0, s1, s2;\n peg$silentFails++;\n s0 = peg$currPos;\n s1 = peg$parseminus();\n if (s1 === peg$FAILED) {\n s1 = null;\n }\n s2 = peg$parsenum();\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f36(s1, s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e34);\n }\n }\n return s0;\n }\n function peg$parse_() {\n var s0, s1;\n peg$silentFails++;\n s0 = [];\n if (peg$r2.test(input.charAt(peg$currPos))) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e36);\n }\n }\n while (s1 !== peg$FAILED) {\n s0.push(s1);\n if (peg$r2.test(input.charAt(peg$currPos))) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e36);\n }\n }\n }\n peg$silentFails--;\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e35);\n }\n return s0;\n }\n function peg$parsesp() {\n var s0, s1;\n s0 = [];\n if (peg$r2.test(input.charAt(peg$currPos))) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e36);\n }\n }\n if (s1 !== peg$FAILED) {\n while (s1 !== peg$FAILED) {\n s0.push(s1);\n if (peg$r2.test(input.charAt(peg$currPos))) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e36);\n }\n }\n }\n } else {\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parsehex() {\n var s0, s1;\n s0 = peg$currPos;\n if (peg$r3.test(input.charAt(peg$currPos))) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e37);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = s0;\n s1 = peg$f37(s1);\n }\n s0 = s1;\n return s0;\n }\n function peg$parseEOL() {\n var s0, s1;\n s0 = peg$currPos;\n peg$silentFails++;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n peg$silentFails--;\n if (s1 === peg$FAILED) {\n s0 = void 0;\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n peg$result = peg$startRuleFunction();\n if (peg$result !== peg$FAILED && peg$currPos === input.length) {\n return peg$result;\n } else {\n if (peg$result !== peg$FAILED && peg$currPos < input.length) {\n peg$fail(peg$endExpectation());\n }\n throw peg$buildStructuredError(\n peg$maxFailExpected,\n peg$maxFailPos < input.length ? input.charAt(peg$maxFailPos) : null,\n peg$maxFailPos < input.length ? peg$computeLocation(peg$maxFailPos, peg$maxFailPos + 1) : peg$computeLocation(peg$maxFailPos, peg$maxFailPos)\n );\n }\n }\n return {\n SyntaxError: peg$SyntaxError,\n parse: peg$parse\n };\n }()\n);\n","export default (\n // Generated by Peggy 3.0.2.\n //\n // https://peggyjs.org/\n function() {\n \"use strict\";\n function peg$subclass(child, parent) {\n function C() {\n this.constructor = child;\n }\n C.prototype = parent.prototype;\n child.prototype = new C();\n }\n function peg$SyntaxError(message, expected, found, location) {\n var self = Error.call(this, message);\n if (Object.setPrototypeOf) {\n Object.setPrototypeOf(self, peg$SyntaxError.prototype);\n }\n self.expected = expected;\n self.found = found;\n self.location = location;\n self.name = \"SyntaxError\";\n return self;\n }\n peg$subclass(peg$SyntaxError, Error);\n function peg$padEnd(str, targetLength, padString) {\n padString = padString || \" \";\n if (str.length > targetLength) {\n return str;\n }\n targetLength -= str.length;\n padString += padString.repeat(targetLength);\n return str + padString.slice(0, targetLength);\n }\n peg$SyntaxError.prototype.format = function(sources) {\n var str = \"Error: \" + this.message;\n if (this.location) {\n var src = null;\n var k;\n for (k = 0; k < sources.length; k++) {\n if (sources[k].source === this.location.source) {\n src = sources[k].text.split(/\\r\\n|\\n|\\r/g);\n break;\n }\n }\n var s = this.location.start;\n var offset_s = this.location.source && typeof this.location.source.offset === \"function\" ? this.location.source.offset(s) : s;\n var loc = this.location.source + \":\" + offset_s.line + \":\" + offset_s.column;\n if (src) {\n var e = this.location.end;\n var filler = peg$padEnd(\"\", offset_s.line.toString().length, \" \");\n var line = src[s.line - 1];\n var last = s.line === e.line ? e.column : line.length + 1;\n var hatLen = last - s.column || 1;\n str += \"\\n --> \" + loc + \"\\n\" + filler + \" |\\n\" + offset_s.line + \" | \" + line + \"\\n\" + filler + \" | \" + peg$padEnd(\"\", s.column - 1, \" \") + peg$padEnd(\"\", hatLen, \"^\");\n } else {\n str += \"\\n at \" + loc;\n }\n }\n return str;\n };\n peg$SyntaxError.buildMessage = function(expected, found) {\n var DESCRIBE_EXPECTATION_FNS = {\n literal: function(expectation) {\n return '\"' + literalEscape(expectation.text) + '\"';\n },\n class: function(expectation) {\n var escapedParts = expectation.parts.map(function(part) {\n return Array.isArray(part) ? classEscape(part[0]) + \"-\" + classEscape(part[1]) : classEscape(part);\n });\n return \"[\" + (expectation.inverted ? \"^\" : \"\") + escapedParts.join(\"\") + \"]\";\n },\n any: function() {\n return \"any character\";\n },\n end: function() {\n return \"end of input\";\n },\n other: function(expectation) {\n return expectation.description;\n }\n };\n function hex(ch) {\n return ch.charCodeAt(0).toString(16).toUpperCase();\n }\n function literalEscape(s) {\n return s.replace(/\\\\/g, \"\\\\\\\\\").replace(/\"/g, '\\\\\"').replace(/\\0/g, \"\\\\0\").replace(/\\t/g, \"\\\\t\").replace(/\\n/g, \"\\\\n\").replace(/\\r/g, \"\\\\r\").replace(/[\\x00-\\x0F]/g, function(ch) {\n return \"\\\\x0\" + hex(ch);\n }).replace(/[\\x10-\\x1F\\x7F-\\x9F]/g, function(ch) {\n return \"\\\\x\" + hex(ch);\n });\n }\n function classEscape(s) {\n return s.replace(/\\\\/g, \"\\\\\\\\\").replace(/\\]/g, \"\\\\]\").replace(/\\^/g, \"\\\\^\").replace(/-/g, \"\\\\-\").replace(/\\0/g, \"\\\\0\").replace(/\\t/g, \"\\\\t\").replace(/\\n/g, \"\\\\n\").replace(/\\r/g, \"\\\\r\").replace(/[\\x00-\\x0F]/g, function(ch) {\n return \"\\\\x0\" + hex(ch);\n }).replace(/[\\x10-\\x1F\\x7F-\\x9F]/g, function(ch) {\n return \"\\\\x\" + hex(ch);\n });\n }\n function describeExpectation(expectation) {\n return DESCRIBE_EXPECTATION_FNS[expectation.type](expectation);\n }\n function describeExpected(expected2) {\n var descriptions = expected2.map(describeExpectation);\n var i, j;\n descriptions.sort();\n if (descriptions.length > 0) {\n for (i = 1, j = 1; i < descriptions.length; i++) {\n if (descriptions[i - 1] !== descriptions[i]) {\n descriptions[j] = descriptions[i];\n j++;\n }\n }\n descriptions.length = j;\n }\n switch (descriptions.length) {\n case 1:\n return descriptions[0];\n case 2:\n return descriptions[0] + \" or \" + descriptions[1];\n default:\n return descriptions.slice(0, -1).join(\", \") + \", or \" + descriptions[descriptions.length - 1];\n }\n }\n function describeFound(found2) {\n return found2 ? '\"' + literalEscape(found2) + '\"' : \"end of input\";\n }\n return \"Expected \" + describeExpected(expected) + \" but \" + describeFound(found) + \" found.\";\n };\n function peg$parse(input, options) {\n options = options !== void 0 ? options : {};\n var peg$FAILED = {};\n var peg$source = options.grammarSource;\n var peg$startRuleFunctions = { body: peg$parsebody };\n var peg$startRuleFunction = peg$parsebody;\n var peg$e0 = peg$otherExpectation(\"decl_start\");\n var peg$e1 = peg$otherExpectation(\"decl_end\");\n var peg$e2 = peg$otherExpectation(\"vert\");\n var peg$e3 = peg$anyExpectation();\n var peg$e4 = peg$otherExpectation(\"l\");\n var peg$e5 = peg$otherExpectation(\"r\");\n var peg$e6 = peg$otherExpectation(\"c\");\n var peg$e7 = peg$otherExpectation(\"p\");\n var peg$e8 = peg$otherExpectation(\"m\");\n var peg$e9 = peg$otherExpectation(\"b\");\n var peg$e10 = peg$otherExpectation(\"w\");\n var peg$e11 = peg$otherExpectation(\"W\");\n var peg$e12 = peg$otherExpectation(\"X\");\n var peg$e13 = peg$otherExpectation(\"!\");\n var peg$e14 = peg$otherExpectation(\"@\");\n var peg$e15 = peg$otherExpectation(\"<\");\n var peg$e16 = peg$otherExpectation(\">\");\n var peg$e17 = peg$otherExpectation(\"group\");\n var peg$e18 = peg$otherExpectation(\"whitespace\");\n var peg$f0 = function(c) {\n return c;\n };\n var peg$f1 = function(cols) {\n return cols;\n };\n var peg$f2 = function() {\n return [];\n };\n var peg$f3 = function(divs1, start, a, end, divs2) {\n return {\n type: \"column\",\n pre_dividers: divs1,\n post_dividers: divs2,\n before_start_code: start,\n before_end_code: end,\n alignment: a\n };\n };\n var peg$f4 = function() {\n return {\n type: \"vert_divider\"\n };\n };\n var peg$f5 = function(b, g) {\n return {\n type: \"bang_divider\",\n content: g[0].content\n };\n };\n var peg$f6 = function(g) {\n return {\n type: \"at_divider\",\n content: g[0].content\n };\n };\n var peg$f7 = function(div) {\n return div;\n };\n var peg$f8 = function(g) {\n return { type: \"decl_code\", code: g[0].content };\n };\n var peg$f9 = function(g) {\n return { type: \"decl_code\", code: g[0].content };\n };\n var peg$f10 = function() {\n return { type: \"alignment\", alignment: \"left\" };\n };\n var peg$f11 = function() {\n return { type: \"alignment\", alignment: \"center\" };\n };\n var peg$f12 = function() {\n return { type: \"alignment\", alignment: \"right\" };\n };\n var peg$f13 = function() {\n return { type: \"alignment\", alignment: \"X\" };\n };\n var peg$f14 = function() {\n return \"top\";\n };\n var peg$f15 = function() {\n return \"default\";\n };\n var peg$f16 = function() {\n return \"bottom\";\n };\n var peg$f17 = function(a, g) {\n return {\n type: \"alignment\",\n alignment: \"parbox\",\n baseline: a,\n size: g[0].content\n };\n };\n var peg$f18 = function(g1, g2) {\n return {\n type: \"alignment\",\n alignment: \"parbox\",\n baseline: g1[0].content,\n size: g2[0].content\n };\n };\n var peg$f19 = function(tok) {\n return options.matchChar(tok, \"|\");\n };\n var peg$f20 = function(tok) {\n return options.matchChar(tok, \"l\");\n };\n var peg$f21 = function(tok) {\n return options.matchChar(tok, \"r\");\n };\n var peg$f22 = function(tok) {\n return options.matchChar(tok, \"c\");\n };\n var peg$f23 = function(tok) {\n return options.matchChar(tok, \"p\");\n };\n var peg$f24 = function(tok) {\n return options.matchChar(tok, \"m\");\n };\n var peg$f25 = function(tok) {\n return options.matchChar(tok, \"b\");\n };\n var peg$f26 = function(tok) {\n return options.matchChar(tok, \"w\");\n };\n var peg$f27 = function(tok) {\n return options.matchChar(tok, \"W\");\n };\n var peg$f28 = function(tok) {\n return options.matchChar(tok, \"X\");\n };\n var peg$f29 = function(tok) {\n return options.matchChar(tok, \"!\");\n };\n var peg$f30 = function(tok) {\n return options.matchChar(tok, \"@\");\n };\n var peg$f31 = function(tok) {\n return options.matchChar(tok, \"<\");\n };\n var peg$f32 = function(tok) {\n return options.matchChar(tok, \">\");\n };\n var peg$f33 = function(tok) {\n return options.isGroup(tok);\n };\n var peg$f34 = function(tok) {\n return options.isWhitespace(tok);\n };\n var peg$currPos = 0;\n var peg$savedPos = 0;\n var peg$posDetailsCache = [{ line: 1, column: 1 }];\n var peg$maxFailPos = 0;\n var peg$maxFailExpected = [];\n var peg$silentFails = 0;\n var peg$result;\n if (\"startRule\" in options) {\n if (!(options.startRule in peg$startRuleFunctions)) {\n throw new Error(`Can't start parsing from rule \"` + options.startRule + '\".');\n }\n peg$startRuleFunction = peg$startRuleFunctions[options.startRule];\n }\n function text() {\n return input.substring(peg$savedPos, peg$currPos);\n }\n function offset() {\n return peg$savedPos;\n }\n function range() {\n return {\n source: peg$source,\n start: peg$savedPos,\n end: peg$currPos\n };\n }\n function location() {\n return peg$computeLocation(peg$savedPos, peg$currPos);\n }\n function expected(description, location2) {\n location2 = location2 !== void 0 ? location2 : peg$computeLocation(peg$savedPos, peg$currPos);\n throw peg$buildStructuredError(\n [peg$otherExpectation(description)],\n input.substring(peg$savedPos, peg$currPos),\n location2\n );\n }\n function error(message, location2) {\n location2 = location2 !== void 0 ? location2 : peg$computeLocation(peg$savedPos, peg$currPos);\n throw peg$buildSimpleError(message, location2);\n }\n function peg$literalExpectation(text2, ignoreCase) {\n return { type: \"literal\", text: text2, ignoreCase };\n }\n function peg$classExpectation(parts, inverted, ignoreCase) {\n return { type: \"class\", parts, inverted, ignoreCase };\n }\n function peg$anyExpectation() {\n return { type: \"any\" };\n }\n function peg$endExpectation() {\n return { type: \"end\" };\n }\n function peg$otherExpectation(description) {\n return { type: \"other\", description };\n }\n function peg$computePosDetails(pos) {\n var details = peg$posDetailsCache[pos];\n var p;\n if (details) {\n return details;\n } else {\n p = pos - 1;\n while (!peg$posDetailsCache[p]) {\n p--;\n }\n details = peg$posDetailsCache[p];\n details = {\n line: details.line,\n column: details.column\n };\n while (p < pos) {\n if (input.charCodeAt(p) === 10) {\n details.line++;\n details.column = 1;\n } else {\n details.column++;\n }\n p++;\n }\n peg$posDetailsCache[pos] = details;\n return details;\n }\n }\n function peg$computeLocation(startPos, endPos, offset2) {\n var startPosDetails = peg$computePosDetails(startPos);\n var endPosDetails = peg$computePosDetails(endPos);\n var res = {\n source: peg$source,\n start: {\n offset: startPos,\n line: startPosDetails.line,\n column: startPosDetails.column\n },\n end: {\n offset: endPos,\n line: endPosDetails.line,\n column: endPosDetails.column\n }\n };\n if (offset2 && peg$source && typeof peg$source.offset === \"function\") {\n res.start = peg$source.offset(res.start);\n res.end = peg$source.offset(res.end);\n }\n return res;\n }\n function peg$fail(expected2) {\n if (peg$currPos < peg$maxFailPos) {\n return;\n }\n if (peg$currPos > peg$maxFailPos) {\n peg$maxFailPos = peg$currPos;\n peg$maxFailExpected = [];\n }\n peg$maxFailExpected.push(expected2);\n }\n function peg$buildSimpleError(message, location2) {\n return new peg$SyntaxError(message, null, null, location2);\n }\n function peg$buildStructuredError(expected2, found, location2) {\n return new peg$SyntaxError(\n peg$SyntaxError.buildMessage(expected2, found),\n expected2,\n found,\n location2\n );\n }\n function peg$parsebody() {\n var s0, s1, s2, s3, s4, s5;\n s0 = peg$currPos;\n s1 = [];\n s2 = peg$currPos;\n s3 = peg$parsecolumn();\n if (s3 !== peg$FAILED) {\n s4 = [];\n s5 = peg$parse_();\n while (s5 !== peg$FAILED) {\n s4.push(s5);\n s5 = peg$parse_();\n }\n peg$savedPos = s2;\n s2 = peg$f0(s3);\n } else {\n peg$currPos = s2;\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n while (s2 !== peg$FAILED) {\n s1.push(s2);\n s2 = peg$currPos;\n s3 = peg$parsecolumn();\n if (s3 !== peg$FAILED) {\n s4 = [];\n s5 = peg$parse_();\n while (s5 !== peg$FAILED) {\n s4.push(s5);\n s5 = peg$parse_();\n }\n peg$savedPos = s2;\n s2 = peg$f0(s3);\n } else {\n peg$currPos = s2;\n s2 = peg$FAILED;\n }\n }\n } else {\n s1 = peg$FAILED;\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = s0;\n s1 = peg$f1(s1);\n }\n s0 = s1;\n if (s0 === peg$FAILED) {\n s0 = peg$currPos;\n s1 = peg$parseEOL();\n if (s1 !== peg$FAILED) {\n peg$savedPos = s0;\n s1 = peg$f2();\n }\n s0 = s1;\n }\n return s0;\n }\n function peg$parsecolumn() {\n var s0, s1, s2, s3, s4, s5, s6;\n s0 = peg$currPos;\n s1 = [];\n s2 = peg$parsecolumn_divider();\n while (s2 !== peg$FAILED) {\n s1.push(s2);\n s2 = peg$parsecolumn_divider();\n }\n s2 = peg$parsedecl_start();\n if (s2 === peg$FAILED) {\n s2 = null;\n }\n s3 = peg$parsealignment();\n if (s3 !== peg$FAILED) {\n s4 = peg$parsedecl_end();\n if (s4 === peg$FAILED) {\n s4 = null;\n }\n s5 = [];\n s6 = peg$parsecolumn_divider();\n while (s6 !== peg$FAILED) {\n s5.push(s6);\n s6 = peg$parsecolumn_divider();\n }\n peg$savedPos = s0;\n s0 = peg$f3(s1, s2, s3, s4, s5);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parsecolumn_divider() {\n var s0, s1, s2, s3, s4;\n s0 = peg$currPos;\n s1 = [];\n s2 = peg$parse_();\n while (s2 !== peg$FAILED) {\n s1.push(s2);\n s2 = peg$parse_();\n }\n s2 = peg$currPos;\n s3 = peg$parsevert();\n if (s3 !== peg$FAILED) {\n peg$savedPos = s2;\n s3 = peg$f4();\n }\n s2 = s3;\n if (s2 === peg$FAILED) {\n s2 = peg$currPos;\n s3 = peg$parsebang();\n if (s3 !== peg$FAILED) {\n s4 = peg$parsegroup();\n if (s4 !== peg$FAILED) {\n peg$savedPos = s2;\n s2 = peg$f5(s3, s4);\n } else {\n peg$currPos = s2;\n s2 = peg$FAILED;\n }\n } else {\n peg$currPos = s2;\n s2 = peg$FAILED;\n }\n if (s2 === peg$FAILED) {\n s2 = peg$currPos;\n s3 = peg$parseat();\n if (s3 !== peg$FAILED) {\n s4 = peg$parsegroup();\n if (s4 !== peg$FAILED) {\n peg$savedPos = s2;\n s2 = peg$f6(s4);\n } else {\n peg$currPos = s2;\n s2 = peg$FAILED;\n }\n } else {\n peg$currPos = s2;\n s2 = peg$FAILED;\n }\n }\n }\n if (s2 !== peg$FAILED) {\n s3 = [];\n s4 = peg$parse_();\n while (s4 !== peg$FAILED) {\n s3.push(s4);\n s4 = peg$parse_();\n }\n peg$savedPos = s0;\n s0 = peg$f7(s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parsedecl_start() {\n var s0, s1, s2;\n peg$silentFails++;\n s0 = peg$currPos;\n s1 = peg$parsegreater();\n if (s1 !== peg$FAILED) {\n s2 = peg$parsegroup();\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f8(s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n return s0;\n }\n function peg$parsedecl_end() {\n var s0, s1, s2;\n peg$silentFails++;\n s0 = peg$currPos;\n s1 = peg$parseless();\n if (s1 !== peg$FAILED) {\n s2 = peg$parsegroup();\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f9(s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e1);\n }\n }\n return s0;\n }\n function peg$parsealignment() {\n var s0, s1, s2, s3, s4, s5;\n s0 = peg$currPos;\n s1 = peg$parsel();\n if (s1 !== peg$FAILED) {\n peg$savedPos = s0;\n s1 = peg$f10();\n }\n s0 = s1;\n if (s0 === peg$FAILED) {\n s0 = peg$currPos;\n s1 = peg$parsec();\n if (s1 !== peg$FAILED) {\n peg$savedPos = s0;\n s1 = peg$f11();\n }\n s0 = s1;\n if (s0 === peg$FAILED) {\n s0 = peg$currPos;\n s1 = peg$parser();\n if (s1 !== peg$FAILED) {\n peg$savedPos = s0;\n s1 = peg$f12();\n }\n s0 = s1;\n if (s0 === peg$FAILED) {\n s0 = peg$currPos;\n s1 = peg$parseX();\n if (s1 !== peg$FAILED) {\n peg$savedPos = s0;\n s1 = peg$f13();\n }\n s0 = s1;\n if (s0 === peg$FAILED) {\n s0 = peg$currPos;\n s1 = peg$currPos;\n s2 = peg$parsep();\n if (s2 !== peg$FAILED) {\n peg$savedPos = s1;\n s2 = peg$f14();\n }\n s1 = s2;\n if (s1 === peg$FAILED) {\n s1 = peg$currPos;\n s2 = peg$parsem();\n if (s2 !== peg$FAILED) {\n peg$savedPos = s1;\n s2 = peg$f15();\n }\n s1 = s2;\n if (s1 === peg$FAILED) {\n s1 = peg$currPos;\n s2 = peg$parseb();\n if (s2 !== peg$FAILED) {\n peg$savedPos = s1;\n s2 = peg$f16();\n }\n s1 = s2;\n }\n }\n if (s1 !== peg$FAILED) {\n s2 = [];\n s3 = peg$parse_();\n while (s3 !== peg$FAILED) {\n s2.push(s3);\n s3 = peg$parse_();\n }\n s3 = peg$parsegroup();\n if (s3 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f17(s1, s3);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n if (s0 === peg$FAILED) {\n s0 = peg$currPos;\n s1 = peg$parsew();\n if (s1 === peg$FAILED) {\n s1 = peg$parseW();\n }\n if (s1 !== peg$FAILED) {\n s2 = [];\n s3 = peg$parse_();\n while (s3 !== peg$FAILED) {\n s2.push(s3);\n s3 = peg$parse_();\n }\n s3 = peg$parsegroup();\n if (s3 !== peg$FAILED) {\n s4 = [];\n s5 = peg$parse_();\n while (s5 !== peg$FAILED) {\n s4.push(s5);\n s5 = peg$parse_();\n }\n s5 = peg$parsegroup();\n if (s5 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f18(s3, s5);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n }\n }\n }\n }\n }\n return s0;\n }\n function peg$parsevert() {\n var s0, s1, s2;\n peg$silentFails++;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e3);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f19(s1);\n if (s2) {\n s2 = void 0;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n s1 = [s1, s2];\n s0 = s1;\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e2);\n }\n }\n return s0;\n }\n function peg$parsel() {\n var s0, s1, s2;\n peg$silentFails++;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e3);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f20(s1);\n if (s2) {\n s2 = void 0;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n s1 = [s1, s2];\n s0 = s1;\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e4);\n }\n }\n return s0;\n }\n function peg$parser() {\n var s0, s1, s2;\n peg$silentFails++;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e3);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f21(s1);\n if (s2) {\n s2 = void 0;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n s1 = [s1, s2];\n s0 = s1;\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e5);\n }\n }\n return s0;\n }\n function peg$parsec() {\n var s0, s1, s2;\n peg$silentFails++;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e3);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f22(s1);\n if (s2) {\n s2 = void 0;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n s1 = [s1, s2];\n s0 = s1;\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e6);\n }\n }\n return s0;\n }\n function peg$parsep() {\n var s0, s1, s2;\n peg$silentFails++;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e3);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f23(s1);\n if (s2) {\n s2 = void 0;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n s1 = [s1, s2];\n s0 = s1;\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e7);\n }\n }\n return s0;\n }\n function peg$parsem() {\n var s0, s1, s2;\n peg$silentFails++;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e3);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f24(s1);\n if (s2) {\n s2 = void 0;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n s1 = [s1, s2];\n s0 = s1;\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e8);\n }\n }\n return s0;\n }\n function peg$parseb() {\n var s0, s1, s2;\n peg$silentFails++;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e3);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f25(s1);\n if (s2) {\n s2 = void 0;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n s1 = [s1, s2];\n s0 = s1;\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e9);\n }\n }\n return s0;\n }\n function peg$parsew() {\n var s0, s1, s2;\n peg$silentFails++;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e3);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f26(s1);\n if (s2) {\n s2 = void 0;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n s1 = [s1, s2];\n s0 = s1;\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e10);\n }\n }\n return s0;\n }\n function peg$parseW() {\n var s0, s1, s2;\n peg$silentFails++;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e3);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f27(s1);\n if (s2) {\n s2 = void 0;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n s1 = [s1, s2];\n s0 = s1;\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e11);\n }\n }\n return s0;\n }\n function peg$parseX() {\n var s0, s1, s2;\n peg$silentFails++;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e3);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f28(s1);\n if (s2) {\n s2 = void 0;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n s1 = [s1, s2];\n s0 = s1;\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e12);\n }\n }\n return s0;\n }\n function peg$parsebang() {\n var s0, s1, s2;\n peg$silentFails++;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e3);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f29(s1);\n if (s2) {\n s2 = void 0;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n s1 = [s1, s2];\n s0 = s1;\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e13);\n }\n }\n return s0;\n }\n function peg$parseat() {\n var s0, s1, s2;\n peg$silentFails++;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e3);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f30(s1);\n if (s2) {\n s2 = void 0;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n s1 = [s1, s2];\n s0 = s1;\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e14);\n }\n }\n return s0;\n }\n function peg$parseless() {\n var s0, s1, s2;\n peg$silentFails++;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e3);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f31(s1);\n if (s2) {\n s2 = void 0;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n s1 = [s1, s2];\n s0 = s1;\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e15);\n }\n }\n return s0;\n }\n function peg$parsegreater() {\n var s0, s1, s2;\n peg$silentFails++;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e3);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f32(s1);\n if (s2) {\n s2 = void 0;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n s1 = [s1, s2];\n s0 = s1;\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e16);\n }\n }\n return s0;\n }\n function peg$parsegroup() {\n var s0, s1, s2;\n peg$silentFails++;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e3);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f33(s1);\n if (s2) {\n s2 = void 0;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n s1 = [s1, s2];\n s0 = s1;\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e17);\n }\n }\n return s0;\n }\n function peg$parse_() {\n var s0, s1, s2;\n peg$silentFails++;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e3);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f34(s1);\n if (s2) {\n s2 = void 0;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n s1 = [s1, s2];\n s0 = s1;\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e18);\n }\n }\n return s0;\n }\n function peg$parseEOL() {\n var s0, s1;\n s0 = peg$currPos;\n peg$silentFails++;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e3);\n }\n }\n peg$silentFails--;\n if (s1 === peg$FAILED) {\n s0 = void 0;\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n if (!options.isHash) {\n try {\n Object.assign(options, {\n matchChar: (node, char) => node.type === \"string\" && node.content === char,\n isGroup: (node) => node.type === \"group\",\n isWhitespace: (node) => node.type === \"whitespace\"\n });\n } catch (e) {\n console.warn(\"Error when initializing parser\", e);\n }\n }\n peg$result = peg$startRuleFunction();\n if (peg$result !== peg$FAILED && peg$currPos === input.length) {\n return peg$result;\n } else {\n if (peg$result !== peg$FAILED && peg$currPos < input.length) {\n peg$fail(peg$endExpectation());\n }\n throw peg$buildStructuredError(\n peg$maxFailExpected,\n peg$maxFailPos < input.length ? input.charAt(peg$maxFailPos) : null,\n peg$maxFailPos < input.length ? peg$computeLocation(peg$maxFailPos, peg$maxFailPos + 1) : peg$computeLocation(peg$maxFailPos, peg$maxFailPos)\n );\n }\n }\n return {\n SyntaxError: peg$SyntaxError,\n parse: peg$parse\n };\n }()\n);\n","export default (\n // Generated by Peggy 3.0.2.\n //\n // https://peggyjs.org/\n function() {\n \"use strict\";\n function peg$subclass(child, parent) {\n function C() {\n this.constructor = child;\n }\n C.prototype = parent.prototype;\n child.prototype = new C();\n }\n function peg$SyntaxError(message, expected, found, location) {\n var self = Error.call(this, message);\n if (Object.setPrototypeOf) {\n Object.setPrototypeOf(self, peg$SyntaxError.prototype);\n }\n self.expected = expected;\n self.found = found;\n self.location = location;\n self.name = \"SyntaxError\";\n return self;\n }\n peg$subclass(peg$SyntaxError, Error);\n function peg$padEnd(str, targetLength, padString) {\n padString = padString || \" \";\n if (str.length > targetLength) {\n return str;\n }\n targetLength -= str.length;\n padString += padString.repeat(targetLength);\n return str + padString.slice(0, targetLength);\n }\n peg$SyntaxError.prototype.format = function(sources) {\n var str = \"Error: \" + this.message;\n if (this.location) {\n var src = null;\n var k;\n for (k = 0; k < sources.length; k++) {\n if (sources[k].source === this.location.source) {\n src = sources[k].text.split(/\\r\\n|\\n|\\r/g);\n break;\n }\n }\n var s = this.location.start;\n var offset_s = this.location.source && typeof this.location.source.offset === \"function\" ? this.location.source.offset(s) : s;\n var loc = this.location.source + \":\" + offset_s.line + \":\" + offset_s.column;\n if (src) {\n var e = this.location.end;\n var filler = peg$padEnd(\"\", offset_s.line.toString().length, \" \");\n var line = src[s.line - 1];\n var last = s.line === e.line ? e.column : line.length + 1;\n var hatLen = last - s.column || 1;\n str += \"\\n --> \" + loc + \"\\n\" + filler + \" |\\n\" + offset_s.line + \" | \" + line + \"\\n\" + filler + \" | \" + peg$padEnd(\"\", s.column - 1, \" \") + peg$padEnd(\"\", hatLen, \"^\");\n } else {\n str += \"\\n at \" + loc;\n }\n }\n return str;\n };\n peg$SyntaxError.buildMessage = function(expected, found) {\n var DESCRIBE_EXPECTATION_FNS = {\n literal: function(expectation) {\n return '\"' + literalEscape(expectation.text) + '\"';\n },\n class: function(expectation) {\n var escapedParts = expectation.parts.map(function(part) {\n return Array.isArray(part) ? classEscape(part[0]) + \"-\" + classEscape(part[1]) : classEscape(part);\n });\n return \"[\" + (expectation.inverted ? \"^\" : \"\") + escapedParts.join(\"\") + \"]\";\n },\n any: function() {\n return \"any character\";\n },\n end: function() {\n return \"end of input\";\n },\n other: function(expectation) {\n return expectation.description;\n }\n };\n function hex(ch) {\n return ch.charCodeAt(0).toString(16).toUpperCase();\n }\n function literalEscape(s) {\n return s.replace(/\\\\/g, \"\\\\\\\\\").replace(/\"/g, '\\\\\"').replace(/\\0/g, \"\\\\0\").replace(/\\t/g, \"\\\\t\").replace(/\\n/g, \"\\\\n\").replace(/\\r/g, \"\\\\r\").replace(/[\\x00-\\x0F]/g, function(ch) {\n return \"\\\\x0\" + hex(ch);\n }).replace(/[\\x10-\\x1F\\x7F-\\x9F]/g, function(ch) {\n return \"\\\\x\" + hex(ch);\n });\n }\n function classEscape(s) {\n return s.replace(/\\\\/g, \"\\\\\\\\\").replace(/\\]/g, \"\\\\]\").replace(/\\^/g, \"\\\\^\").replace(/-/g, \"\\\\-\").replace(/\\0/g, \"\\\\0\").replace(/\\t/g, \"\\\\t\").replace(/\\n/g, \"\\\\n\").replace(/\\r/g, \"\\\\r\").replace(/[\\x00-\\x0F]/g, function(ch) {\n return \"\\\\x0\" + hex(ch);\n }).replace(/[\\x10-\\x1F\\x7F-\\x9F]/g, function(ch) {\n return \"\\\\x\" + hex(ch);\n });\n }\n function describeExpectation(expectation) {\n return DESCRIBE_EXPECTATION_FNS[expectation.type](expectation);\n }\n function describeExpected(expected2) {\n var descriptions = expected2.map(describeExpectation);\n var i, j;\n descriptions.sort();\n if (descriptions.length > 0) {\n for (i = 1, j = 1; i < descriptions.length; i++) {\n if (descriptions[i - 1] !== descriptions[i]) {\n descriptions[j] = descriptions[i];\n j++;\n }\n }\n descriptions.length = j;\n }\n switch (descriptions.length) {\n case 1:\n return descriptions[0];\n case 2:\n return descriptions[0] + \" or \" + descriptions[1];\n default:\n return descriptions.slice(0, -1).join(\", \") + \", or \" + descriptions[descriptions.length - 1];\n }\n }\n function describeFound(found2) {\n return found2 ? '\"' + literalEscape(found2) + '\"' : \"end of input\";\n }\n return \"Expected \" + describeExpected(expected) + \" but \" + describeFound(found) + \" found.\";\n };\n function peg$parse(input, options) {\n options = options !== void 0 ? options : {};\n var peg$FAILED = {};\n var peg$source = options.grammarSource;\n var peg$startRuleFunctions = { body: peg$parsebody };\n var peg$startRuleFunction = peg$parsebody;\n var peg$e0 = peg$otherExpectation(\"partial item\");\n var peg$e1 = peg$otherExpectation(\"item\");\n var peg$e2 = peg$anyExpectation();\n var peg$e3 = peg$otherExpectation(\"equation\");\n var peg$e4 = peg$otherExpectation(\"trailing comment\");\n var peg$e5 = peg$otherExpectation(\"comment only line\");\n var peg$e6 = peg$otherExpectation(\"non-var token\");\n var peg$e7 = peg$otherExpectation(\"token\");\n var peg$e8 = peg$otherExpectation(\"same line comment\");\n var peg$e9 = peg$otherExpectation(\"own line comment\");\n var peg$e10 = peg$otherExpectation(\",\");\n var peg$e11 = peg$otherExpectation(\"@\");\n var peg$e12 = peg$otherExpectation(\"variable token\");\n var peg$e13 = peg$otherExpectation(\"+/-\");\n var peg$e14 = peg$otherExpectation(\"=\");\n var peg$f0 = function(a, b) {\n return a.concat(b ? b : []);\n };\n var peg$f1 = function() {\n return [];\n };\n var peg$f2 = function(a, b, c) {\n return a.concat(b, c);\n };\n var peg$f3 = function(op, a, b, c) {\n return { type: \"item\", op, variable: b, content: a.concat(b, c) };\n };\n var peg$f4 = function(op, a) {\n return { type: \"item\", op, variable: null, content: a };\n };\n var peg$f5 = function(line, sep, comment) {\n return { ...line, sep: [].concat(sep), trailingComment: comment };\n };\n var peg$f6 = function(line, comment) {\n return { ...line, trailingComment: comment };\n };\n var peg$f7 = function(eq, ann) {\n return {\n type: \"line\",\n equation: eq,\n annotation: ann,\n sep: null\n };\n };\n var peg$f8 = function(at, ann) {\n return at ? { type: \"annotation\", marker: at, content: ann } : null;\n };\n var peg$f9 = function(left, eq, right) {\n return { type: \"equation\", left, right, equals: eq };\n };\n var peg$f10 = function(x) {\n return x;\n };\n var peg$f11 = function(x) {\n return {\n type: \"line\",\n trailingComment: x\n };\n };\n var peg$f12 = function(v, s) {\n return [v].concat(s ? s : []);\n };\n var peg$f13 = function(t) {\n return t;\n };\n var peg$f14 = function(x) {\n return x;\n };\n var peg$f15 = function(x) {\n return x;\n };\n var peg$f16 = function(tok) {\n return options.isSameLineComment(tok);\n };\n var peg$f17 = function(tok) {\n return tok;\n };\n var peg$f18 = function(tok) {\n return options.isOwnLineComment(tok);\n };\n var peg$f19 = function(tok) {\n return tok;\n };\n var peg$f20 = function(tok) {\n return options.isWhitespace(tok);\n };\n var peg$f21 = function(tok) {\n return tok;\n };\n var peg$f22 = function(tok) {\n return options.isSep(tok);\n };\n var peg$f23 = function(tok) {\n return tok;\n };\n var peg$f24 = function(tok) {\n return options.isAt(tok);\n };\n var peg$f25 = function(tok) {\n return tok;\n };\n var peg$f26 = function(tok) {\n return options.isVar(tok);\n };\n var peg$f27 = function(tok) {\n return tok;\n };\n var peg$f28 = function(tok) {\n return options.isOperation(tok);\n };\n var peg$f29 = function(tok) {\n return tok;\n };\n var peg$f30 = function(tok) {\n return options.isEquals(tok);\n };\n var peg$f31 = function(tok) {\n return tok;\n };\n var peg$f32 = function(tok) {\n return options.isSubscript(tok);\n };\n var peg$f33 = function(tok) {\n return tok;\n };\n var peg$currPos = 0;\n var peg$savedPos = 0;\n var peg$posDetailsCache = [{ line: 1, column: 1 }];\n var peg$maxFailPos = 0;\n var peg$maxFailExpected = [];\n var peg$silentFails = 0;\n var peg$result;\n if (\"startRule\" in options) {\n if (!(options.startRule in peg$startRuleFunctions)) {\n throw new Error(`Can't start parsing from rule \"` + options.startRule + '\".');\n }\n peg$startRuleFunction = peg$startRuleFunctions[options.startRule];\n }\n function text() {\n return input.substring(peg$savedPos, peg$currPos);\n }\n function offset() {\n return peg$savedPos;\n }\n function range() {\n return {\n source: peg$source,\n start: peg$savedPos,\n end: peg$currPos\n };\n }\n function location() {\n return peg$computeLocation(peg$savedPos, peg$currPos);\n }\n function expected(description, location2) {\n location2 = location2 !== void 0 ? location2 : peg$computeLocation(peg$savedPos, peg$currPos);\n throw peg$buildStructuredError(\n [peg$otherExpectation(description)],\n input.substring(peg$savedPos, peg$currPos),\n location2\n );\n }\n function error(message, location2) {\n location2 = location2 !== void 0 ? location2 : peg$computeLocation(peg$savedPos, peg$currPos);\n throw peg$buildSimpleError(message, location2);\n }\n function peg$literalExpectation(text2, ignoreCase) {\n return { type: \"literal\", text: text2, ignoreCase };\n }\n function peg$classExpectation(parts, inverted, ignoreCase) {\n return { type: \"class\", parts, inverted, ignoreCase };\n }\n function peg$anyExpectation() {\n return { type: \"any\" };\n }\n function peg$endExpectation() {\n return { type: \"end\" };\n }\n function peg$otherExpectation(description) {\n return { type: \"other\", description };\n }\n function peg$computePosDetails(pos) {\n var details = peg$posDetailsCache[pos];\n var p;\n if (details) {\n return details;\n } else {\n p = pos - 1;\n while (!peg$posDetailsCache[p]) {\n p--;\n }\n details = peg$posDetailsCache[p];\n details = {\n line: details.line,\n column: details.column\n };\n while (p < pos) {\n if (input.charCodeAt(p) === 10) {\n details.line++;\n details.column = 1;\n } else {\n details.column++;\n }\n p++;\n }\n peg$posDetailsCache[pos] = details;\n return details;\n }\n }\n function peg$computeLocation(startPos, endPos, offset2) {\n var startPosDetails = peg$computePosDetails(startPos);\n var endPosDetails = peg$computePosDetails(endPos);\n var res = {\n source: peg$source,\n start: {\n offset: startPos,\n line: startPosDetails.line,\n column: startPosDetails.column\n },\n end: {\n offset: endPos,\n line: endPosDetails.line,\n column: endPosDetails.column\n }\n };\n if (offset2 && peg$source && typeof peg$source.offset === \"function\") {\n res.start = peg$source.offset(res.start);\n res.end = peg$source.offset(res.end);\n }\n return res;\n }\n function peg$fail(expected2) {\n if (peg$currPos < peg$maxFailPos) {\n return;\n }\n if (peg$currPos > peg$maxFailPos) {\n peg$maxFailPos = peg$currPos;\n peg$maxFailExpected = [];\n }\n peg$maxFailExpected.push(expected2);\n }\n function peg$buildSimpleError(message, location2) {\n return new peg$SyntaxError(message, null, null, location2);\n }\n function peg$buildStructuredError(expected2, found, location2) {\n return new peg$SyntaxError(\n peg$SyntaxError.buildMessage(expected2, found),\n expected2,\n found,\n location2\n );\n }\n function peg$parsebody() {\n var s0, s1, s2;\n s0 = peg$currPos;\n s1 = [];\n s2 = peg$parsecomment_only_line();\n if (s2 === peg$FAILED) {\n s2 = peg$parseline_with_sep();\n if (s2 === peg$FAILED) {\n s2 = peg$parsepartial_line_with_comment();\n }\n }\n while (s2 !== peg$FAILED) {\n s1.push(s2);\n s2 = peg$parsecomment_only_line();\n if (s2 === peg$FAILED) {\n s2 = peg$parseline_with_sep();\n if (s2 === peg$FAILED) {\n s2 = peg$parsepartial_line_with_comment();\n }\n }\n }\n s2 = peg$parseline_without_sep();\n if (s2 === peg$FAILED) {\n s2 = peg$parseEOL();\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f0(s1, s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n if (s0 === peg$FAILED) {\n s0 = peg$currPos;\n s1 = peg$parseEOL();\n if (s1 !== peg$FAILED) {\n peg$savedPos = s0;\n s1 = peg$f1();\n }\n s0 = s1;\n }\n return s0;\n }\n function peg$parsepartial_item() {\n var s0, s1, s2, s3, s4, s5, s6, s7, s8;\n peg$silentFails++;\n s0 = peg$currPos;\n s1 = [];\n s2 = peg$parse_();\n while (s2 !== peg$FAILED) {\n s1.push(s2);\n s2 = peg$parse_();\n }\n s2 = [];\n s3 = peg$parsenon_var_token();\n while (s3 !== peg$FAILED) {\n s2.push(s3);\n s3 = peg$parsenon_var_token();\n }\n s3 = [];\n s4 = peg$parse_();\n while (s4 !== peg$FAILED) {\n s3.push(s4);\n s4 = peg$parse_();\n }\n s4 = peg$parsevar();\n if (s4 !== peg$FAILED) {\n s5 = [];\n s6 = peg$parse_();\n while (s6 !== peg$FAILED) {\n s5.push(s6);\n s6 = peg$parse_();\n }\n s6 = [];\n s7 = peg$parsetoken();\n while (s7 !== peg$FAILED) {\n s6.push(s7);\n s7 = peg$parsetoken();\n }\n s7 = [];\n s8 = peg$parse_();\n while (s8 !== peg$FAILED) {\n s7.push(s8);\n s8 = peg$parse_();\n }\n peg$savedPos = s0;\n s0 = peg$f2(s2, s4, s6);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n return s0;\n }\n function peg$parseitem() {\n var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;\n peg$silentFails++;\n s0 = peg$currPos;\n s1 = peg$parseoperation();\n if (s1 === peg$FAILED) {\n s1 = null;\n }\n s2 = [];\n s3 = peg$parse_();\n while (s3 !== peg$FAILED) {\n s2.push(s3);\n s3 = peg$parse_();\n }\n s3 = [];\n s4 = peg$parsenon_var_token();\n while (s4 !== peg$FAILED) {\n s3.push(s4);\n s4 = peg$parsenon_var_token();\n }\n s4 = [];\n s5 = peg$parse_();\n while (s5 !== peg$FAILED) {\n s4.push(s5);\n s5 = peg$parse_();\n }\n s5 = peg$parsevar();\n if (s5 !== peg$FAILED) {\n s6 = [];\n s7 = peg$parse_();\n while (s7 !== peg$FAILED) {\n s6.push(s7);\n s7 = peg$parse_();\n }\n s7 = [];\n s8 = peg$parsetoken();\n while (s8 !== peg$FAILED) {\n s7.push(s8);\n s8 = peg$parsetoken();\n }\n s8 = [];\n s9 = peg$parse_();\n while (s9 !== peg$FAILED) {\n s8.push(s9);\n s9 = peg$parse_();\n }\n peg$savedPos = s0;\n s0 = peg$f3(s1, s3, s5, s7);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n if (s0 === peg$FAILED) {\n s0 = peg$currPos;\n s1 = peg$parseoperation();\n if (s1 === peg$FAILED) {\n s1 = null;\n }\n s2 = [];\n s3 = peg$parse_();\n while (s3 !== peg$FAILED) {\n s2.push(s3);\n s3 = peg$parse_();\n }\n s3 = [];\n s4 = peg$parsenon_var_token();\n if (s4 !== peg$FAILED) {\n while (s4 !== peg$FAILED) {\n s3.push(s4);\n s4 = peg$parsenon_var_token();\n }\n } else {\n s3 = peg$FAILED;\n }\n if (s3 !== peg$FAILED) {\n s4 = [];\n s5 = peg$parse_();\n while (s5 !== peg$FAILED) {\n s4.push(s5);\n s5 = peg$parse_();\n }\n peg$savedPos = s0;\n s0 = peg$f4(s1, s3);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e1);\n }\n }\n return s0;\n }\n function peg$parseline_with_sep() {\n var s0, s1, s2, s3;\n s0 = peg$currPos;\n s1 = peg$parseline_without_sep();\n if (s1 !== peg$FAILED) {\n s2 = peg$parsesep();\n if (s2 !== peg$FAILED) {\n s3 = peg$parsetrailing_comment();\n if (s3 === peg$FAILED) {\n s3 = null;\n }\n peg$savedPos = s0;\n s0 = peg$f5(s1, s2, s3);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parsepartial_line_with_comment() {\n var s0, s1, s2;\n s0 = peg$currPos;\n s1 = peg$parseline_without_sep();\n if (s1 !== peg$FAILED) {\n s2 = peg$parsetrailing_comment();\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f6(s1, s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parseline_without_sep() {\n var s0, s1, s2, s3;\n s0 = peg$currPos;\n s1 = peg$currPos;\n peg$silentFails++;\n if (input.length > peg$currPos) {\n s2 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s2 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e2);\n }\n }\n peg$silentFails--;\n if (s2 !== peg$FAILED) {\n peg$currPos = s1;\n s1 = void 0;\n } else {\n s1 = peg$FAILED;\n }\n if (s1 !== peg$FAILED) {\n s2 = peg$parseequation();\n s3 = peg$parseannotation();\n if (s3 === peg$FAILED) {\n s3 = null;\n }\n peg$savedPos = s0;\n s0 = peg$f7(s2, s3);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parseannotation() {\n var s0, s1, s2, s3;\n s0 = peg$currPos;\n s1 = peg$parseat();\n if (s1 !== peg$FAILED) {\n s2 = [];\n s3 = peg$parsenon_sep_token();\n while (s3 !== peg$FAILED) {\n s2.push(s3);\n s3 = peg$parsenon_sep_token();\n }\n peg$savedPos = s0;\n s0 = peg$f8(s1, s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parseequation() {\n var s0, s1, s2, s3, s4;\n peg$silentFails++;\n s0 = peg$currPos;\n s1 = [];\n s2 = peg$parseitem();\n while (s2 !== peg$FAILED) {\n s1.push(s2);\n s2 = peg$parseitem();\n }\n s2 = peg$parseequals();\n if (s2 === peg$FAILED) {\n s2 = null;\n }\n s3 = [];\n s4 = peg$parsetoken();\n if (s4 === peg$FAILED) {\n s4 = peg$parseoperation();\n }\n while (s4 !== peg$FAILED) {\n s3.push(s4);\n s4 = peg$parsetoken();\n if (s4 === peg$FAILED) {\n s4 = peg$parseoperation();\n }\n }\n peg$savedPos = s0;\n s0 = peg$f9(s1, s2, s3);\n peg$silentFails--;\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e3);\n }\n return s0;\n }\n function peg$parsetrailing_comment() {\n var s0, s1, s2;\n peg$silentFails++;\n s0 = peg$currPos;\n s1 = [];\n s2 = peg$parse_();\n while (s2 !== peg$FAILED) {\n s1.push(s2);\n s2 = peg$parse_();\n }\n s2 = peg$parsesame_line_comment();\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f10(s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e4);\n }\n }\n return s0;\n }\n function peg$parsecomment_only_line() {\n var s0, s1, s2;\n peg$silentFails++;\n s0 = peg$currPos;\n s1 = [];\n s2 = peg$parse_();\n while (s2 !== peg$FAILED) {\n s1.push(s2);\n s2 = peg$parse_();\n }\n s2 = peg$parseown_line_comment();\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f11(s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e5);\n }\n }\n return s0;\n }\n function peg$parsevar() {\n var s0, s1, s2, s3;\n s0 = peg$currPos;\n s1 = peg$parsevar_token();\n if (s1 !== peg$FAILED) {\n s2 = [];\n s3 = peg$parse_();\n while (s3 !== peg$FAILED) {\n s2.push(s3);\n s3 = peg$parse_();\n }\n s3 = peg$parsesubscript();\n if (s3 === peg$FAILED) {\n s3 = null;\n }\n peg$savedPos = s0;\n s0 = peg$f12(s1, s3);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parsenon_var_token() {\n var s0, s1, s2;\n peg$silentFails++;\n s0 = peg$currPos;\n s1 = peg$currPos;\n peg$silentFails++;\n s2 = peg$parsevar();\n peg$silentFails--;\n if (s2 === peg$FAILED) {\n s1 = void 0;\n } else {\n peg$currPos = s1;\n s1 = peg$FAILED;\n }\n if (s1 !== peg$FAILED) {\n s2 = peg$parsetoken();\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f13(s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e6);\n }\n }\n return s0;\n }\n function peg$parsenon_sep_token() {\n var s0, s1, s2;\n s0 = peg$currPos;\n s1 = peg$currPos;\n peg$silentFails++;\n s2 = peg$parsesep();\n if (s2 === peg$FAILED) {\n s2 = peg$parsetrailing_comment();\n if (s2 === peg$FAILED) {\n s2 = peg$parseown_line_comment();\n }\n }\n peg$silentFails--;\n if (s2 === peg$FAILED) {\n s1 = void 0;\n } else {\n peg$currPos = s1;\n s1 = peg$FAILED;\n }\n if (s1 !== peg$FAILED) {\n if (input.length > peg$currPos) {\n s2 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s2 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e2);\n }\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f14(s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parsetoken() {\n var s0, s1, s2;\n peg$silentFails++;\n s0 = peg$currPos;\n s1 = peg$currPos;\n peg$silentFails++;\n s2 = peg$parsesep();\n if (s2 === peg$FAILED) {\n s2 = peg$parseat();\n if (s2 === peg$FAILED) {\n s2 = peg$parseoperation();\n if (s2 === peg$FAILED) {\n s2 = peg$parseequals();\n if (s2 === peg$FAILED) {\n s2 = peg$parsetrailing_comment();\n if (s2 === peg$FAILED) {\n s2 = peg$parseown_line_comment();\n }\n }\n }\n }\n }\n peg$silentFails--;\n if (s2 === peg$FAILED) {\n s1 = void 0;\n } else {\n peg$currPos = s1;\n s1 = peg$FAILED;\n }\n if (s1 !== peg$FAILED) {\n if (input.length > peg$currPos) {\n s2 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s2 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e2);\n }\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f15(s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e7);\n }\n }\n return s0;\n }\n function peg$parsesame_line_comment() {\n var s0, s1, s2;\n peg$silentFails++;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e2);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f16(s1);\n if (s2) {\n s2 = void 0;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f17(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e8);\n }\n }\n return s0;\n }\n function peg$parseown_line_comment() {\n var s0, s1, s2;\n peg$silentFails++;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e2);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f18(s1);\n if (s2) {\n s2 = void 0;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f19(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e9);\n }\n }\n return s0;\n }\n function peg$parse_() {\n var s0, s1, s2;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e2);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f20(s1);\n if (s2) {\n s2 = void 0;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f21(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parsesep() {\n var s0, s1, s2;\n peg$silentFails++;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e2);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f22(s1);\n if (s2) {\n s2 = void 0;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f23(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e10);\n }\n }\n return s0;\n }\n function peg$parseat() {\n var s0, s1, s2;\n peg$silentFails++;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e2);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f24(s1);\n if (s2) {\n s2 = void 0;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f25(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e11);\n }\n }\n return s0;\n }\n function peg$parsevar_token() {\n var s0, s1, s2;\n peg$silentFails++;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e2);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f26(s1);\n if (s2) {\n s2 = void 0;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f27(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e12);\n }\n }\n return s0;\n }\n function peg$parseoperation() {\n var s0, s1, s2, s3, s4;\n peg$silentFails++;\n s0 = peg$currPos;\n s1 = [];\n s2 = peg$parse_();\n while (s2 !== peg$FAILED) {\n s1.push(s2);\n s2 = peg$parse_();\n }\n if (input.length > peg$currPos) {\n s2 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s2 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e2);\n }\n }\n if (s2 !== peg$FAILED) {\n s3 = [];\n s4 = peg$parse_();\n while (s4 !== peg$FAILED) {\n s3.push(s4);\n s4 = peg$parse_();\n }\n peg$savedPos = peg$currPos;\n s4 = peg$f28(s2);\n if (s4) {\n s4 = void 0;\n } else {\n s4 = peg$FAILED;\n }\n if (s4 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f29(s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e13);\n }\n }\n return s0;\n }\n function peg$parseequals() {\n var s0, s1, s2;\n peg$silentFails++;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e2);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f30(s1);\n if (s2) {\n s2 = void 0;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f31(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e14);\n }\n }\n return s0;\n }\n function peg$parsesubscript() {\n var s0, s1, s2;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e2);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f32(s1);\n if (s2) {\n s2 = void 0;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f33(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parseEOL() {\n var s0, s1;\n s0 = peg$currPos;\n peg$silentFails++;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e2);\n }\n }\n peg$silentFails--;\n if (s1 === peg$FAILED) {\n s0 = void 0;\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n if (!options.isWhitespace) {\n try {\n Object.assign(options, {\n isSep: (node) => node.type === \"string\" && node.content === \",\",\n isVar: (node) => node.type === \"string\" && node.content.match(/[a-zA-Z]/),\n isOperation: (node) => node.type === \"string\" && node.content.match(/[+-]/),\n isEquals: (node) => node.type === \"string\" && node.content === \"=\",\n isAt: (node) => node.type === \"string\" && node.content === \"@\",\n isSubscript: (node) => node.content === \"_\",\n isWhitespace: (node) => node.type === \"whitespace\",\n isSameLineComment: (node) => node.type === \"comment\" && node.sameline,\n isOwnLineComment: (node) => node.type === \"comment\" && !node.sameline\n });\n } catch (e) {\n console.warn(\"Error when initializing parser\", e);\n }\n }\n peg$result = peg$startRuleFunction();\n if (peg$result !== peg$FAILED && peg$currPos === input.length) {\n return peg$result;\n } else {\n if (peg$result !== peg$FAILED && peg$currPos < input.length) {\n peg$fail(peg$endExpectation());\n }\n throw peg$buildStructuredError(\n peg$maxFailExpected,\n peg$maxFailPos < input.length ? input.charAt(peg$maxFailPos) : null,\n peg$maxFailPos < input.length ? peg$computeLocation(peg$maxFailPos, peg$maxFailPos + 1) : peg$computeLocation(peg$maxFailPos, peg$maxFailPos)\n );\n }\n }\n return {\n SyntaxError: peg$SyntaxError,\n parse: peg$parse\n };\n }()\n);\n","export default (\n // Generated by Peggy 3.0.2.\n //\n // https://peggyjs.org/\n function() {\n \"use strict\";\n function peg$subclass(child, parent) {\n function C() {\n this.constructor = child;\n }\n C.prototype = parent.prototype;\n child.prototype = new C();\n }\n function peg$SyntaxError(message, expected, found, location) {\n var self = Error.call(this, message);\n if (Object.setPrototypeOf) {\n Object.setPrototypeOf(self, peg$SyntaxError.prototype);\n }\n self.expected = expected;\n self.found = found;\n self.location = location;\n self.name = \"SyntaxError\";\n return self;\n }\n peg$subclass(peg$SyntaxError, Error);\n function peg$padEnd(str, targetLength, padString) {\n padString = padString || \" \";\n if (str.length > targetLength) {\n return str;\n }\n targetLength -= str.length;\n padString += padString.repeat(targetLength);\n return str + padString.slice(0, targetLength);\n }\n peg$SyntaxError.prototype.format = function(sources) {\n var str = \"Error: \" + this.message;\n if (this.location) {\n var src = null;\n var k;\n for (k = 0; k < sources.length; k++) {\n if (sources[k].source === this.location.source) {\n src = sources[k].text.split(/\\r\\n|\\n|\\r/g);\n break;\n }\n }\n var s = this.location.start;\n var offset_s = this.location.source && typeof this.location.source.offset === \"function\" ? this.location.source.offset(s) : s;\n var loc = this.location.source + \":\" + offset_s.line + \":\" + offset_s.column;\n if (src) {\n var e = this.location.end;\n var filler = peg$padEnd(\"\", offset_s.line.toString().length, \" \");\n var line = src[s.line - 1];\n var last = s.line === e.line ? e.column : line.length + 1;\n var hatLen = last - s.column || 1;\n str += \"\\n --> \" + loc + \"\\n\" + filler + \" |\\n\" + offset_s.line + \" | \" + line + \"\\n\" + filler + \" | \" + peg$padEnd(\"\", s.column - 1, \" \") + peg$padEnd(\"\", hatLen, \"^\");\n } else {\n str += \"\\n at \" + loc;\n }\n }\n return str;\n };\n peg$SyntaxError.buildMessage = function(expected, found) {\n var DESCRIBE_EXPECTATION_FNS = {\n literal: function(expectation) {\n return '\"' + literalEscape(expectation.text) + '\"';\n },\n class: function(expectation) {\n var escapedParts = expectation.parts.map(function(part) {\n return Array.isArray(part) ? classEscape(part[0]) + \"-\" + classEscape(part[1]) : classEscape(part);\n });\n return \"[\" + (expectation.inverted ? \"^\" : \"\") + escapedParts.join(\"\") + \"]\";\n },\n any: function() {\n return \"any character\";\n },\n end: function() {\n return \"end of input\";\n },\n other: function(expectation) {\n return expectation.description;\n }\n };\n function hex(ch) {\n return ch.charCodeAt(0).toString(16).toUpperCase();\n }\n function literalEscape(s) {\n return s.replace(/\\\\/g, \"\\\\\\\\\").replace(/\"/g, '\\\\\"').replace(/\\0/g, \"\\\\0\").replace(/\\t/g, \"\\\\t\").replace(/\\n/g, \"\\\\n\").replace(/\\r/g, \"\\\\r\").replace(/[\\x00-\\x0F]/g, function(ch) {\n return \"\\\\x0\" + hex(ch);\n }).replace(/[\\x10-\\x1F\\x7F-\\x9F]/g, function(ch) {\n return \"\\\\x\" + hex(ch);\n });\n }\n function classEscape(s) {\n return s.replace(/\\\\/g, \"\\\\\\\\\").replace(/\\]/g, \"\\\\]\").replace(/\\^/g, \"\\\\^\").replace(/-/g, \"\\\\-\").replace(/\\0/g, \"\\\\0\").replace(/\\t/g, \"\\\\t\").replace(/\\n/g, \"\\\\n\").replace(/\\r/g, \"\\\\r\").replace(/[\\x00-\\x0F]/g, function(ch) {\n return \"\\\\x0\" + hex(ch);\n }).replace(/[\\x10-\\x1F\\x7F-\\x9F]/g, function(ch) {\n return \"\\\\x\" + hex(ch);\n });\n }\n function describeExpectation(expectation) {\n return DESCRIBE_EXPECTATION_FNS[expectation.type](expectation);\n }\n function describeExpected(expected2) {\n var descriptions = expected2.map(describeExpectation);\n var i, j;\n descriptions.sort();\n if (descriptions.length > 0) {\n for (i = 1, j = 1; i < descriptions.length; i++) {\n if (descriptions[i - 1] !== descriptions[i]) {\n descriptions[j] = descriptions[i];\n j++;\n }\n }\n descriptions.length = j;\n }\n switch (descriptions.length) {\n case 1:\n return descriptions[0];\n case 2:\n return descriptions[0] + \" or \" + descriptions[1];\n default:\n return descriptions.slice(0, -1).join(\", \") + \", or \" + descriptions[descriptions.length - 1];\n }\n }\n function describeFound(found2) {\n return found2 ? '\"' + literalEscape(found2) + '\"' : \"end of input\";\n }\n return \"Expected \" + describeExpected(expected) + \" but \" + describeFound(found) + \" found.\";\n };\n function peg$parse(input, options) {\n options = options !== void 0 ? options : {};\n var peg$FAILED = {};\n var peg$source = options.grammarSource;\n var peg$startRuleFunctions = { root: peg$parseroot };\n var peg$startRuleFunction = peg$parseroot;\n var peg$c0 = \"plus\";\n var peg$c1 = \"minus\";\n var peg$c2 = \"pt\";\n var peg$c3 = \"mm\";\n var peg$c4 = \"cm\";\n var peg$c5 = \"in\";\n var peg$c6 = \"ex\";\n var peg$c7 = \"em\";\n var peg$c8 = \"bp\";\n var peg$c9 = \"pc\";\n var peg$c10 = \"dd\";\n var peg$c11 = \"cc\";\n var peg$c12 = \"nd\";\n var peg$c13 = \"nc\";\n var peg$c14 = \"sp\";\n var peg$c15 = \"filll\";\n var peg$c16 = \"fill\";\n var peg$c17 = \"fil\";\n var peg$c18 = \".\";\n var peg$c19 = \"+\";\n var peg$c20 = \"-\";\n var peg$r0 = /^[0-9]/;\n var peg$e0 = peg$anyExpectation();\n var peg$e1 = peg$literalExpectation(\"plus\", false);\n var peg$e2 = peg$literalExpectation(\"minus\", false);\n var peg$e3 = peg$literalExpectation(\"pt\", false);\n var peg$e4 = peg$literalExpectation(\"mm\", false);\n var peg$e5 = peg$literalExpectation(\"cm\", false);\n var peg$e6 = peg$literalExpectation(\"in\", false);\n var peg$e7 = peg$literalExpectation(\"ex\", false);\n var peg$e8 = peg$literalExpectation(\"em\", false);\n var peg$e9 = peg$literalExpectation(\"bp\", false);\n var peg$e10 = peg$literalExpectation(\"pc\", false);\n var peg$e11 = peg$literalExpectation(\"dd\", false);\n var peg$e12 = peg$literalExpectation(\"cc\", false);\n var peg$e13 = peg$literalExpectation(\"nd\", false);\n var peg$e14 = peg$literalExpectation(\"nc\", false);\n var peg$e15 = peg$literalExpectation(\"sp\", false);\n var peg$e16 = peg$literalExpectation(\"filll\", false);\n var peg$e17 = peg$literalExpectation(\"fill\", false);\n var peg$e18 = peg$literalExpectation(\"fil\", false);\n var peg$e19 = peg$otherExpectation(\"number\");\n var peg$e20 = peg$classExpectation([[\"0\", \"9\"]], false, false);\n var peg$e21 = peg$literalExpectation(\".\", false);\n var peg$e22 = peg$literalExpectation(\"+\", false);\n var peg$e23 = peg$literalExpectation(\"-\", false);\n var peg$f0 = function(b, st, sh) {\n return {\n type: \"glue\",\n fixed: b,\n stretchable: st,\n shrinkable: sh,\n position: location()\n };\n };\n var peg$f1 = function(glue) {\n return glue;\n };\n var peg$f2 = function(n, u) {\n return { type: \"dim\", value: n, unit: u };\n };\n var peg$f3 = function(n, u) {\n return { type: \"dim\", value: n, unit: u };\n };\n var peg$f4 = function(n, u) {\n return { type: \"dim\", value: n, unit: u };\n };\n var peg$f5 = function(n) {\n return parseFloat(n);\n };\n var peg$currPos = 0;\n var peg$savedPos = 0;\n var peg$posDetailsCache = [{ line: 1, column: 1 }];\n var peg$maxFailPos = 0;\n var peg$maxFailExpected = [];\n var peg$silentFails = 0;\n var peg$result;\n if (\"startRule\" in options) {\n if (!(options.startRule in peg$startRuleFunctions)) {\n throw new Error(`Can't start parsing from rule \"` + options.startRule + '\".');\n }\n peg$startRuleFunction = peg$startRuleFunctions[options.startRule];\n }\n function text() {\n return input.substring(peg$savedPos, peg$currPos);\n }\n function offset() {\n return peg$savedPos;\n }\n function range() {\n return {\n source: peg$source,\n start: peg$savedPos,\n end: peg$currPos\n };\n }\n function location() {\n return peg$computeLocation(peg$savedPos, peg$currPos);\n }\n function expected(description, location2) {\n location2 = location2 !== void 0 ? location2 : peg$computeLocation(peg$savedPos, peg$currPos);\n throw peg$buildStructuredError(\n [peg$otherExpectation(description)],\n input.substring(peg$savedPos, peg$currPos),\n location2\n );\n }\n function error(message, location2) {\n location2 = location2 !== void 0 ? location2 : peg$computeLocation(peg$savedPos, peg$currPos);\n throw peg$buildSimpleError(message, location2);\n }\n function peg$literalExpectation(text2, ignoreCase) {\n return { type: \"literal\", text: text2, ignoreCase };\n }\n function peg$classExpectation(parts, inverted, ignoreCase) {\n return { type: \"class\", parts, inverted, ignoreCase };\n }\n function peg$anyExpectation() {\n return { type: \"any\" };\n }\n function peg$endExpectation() {\n return { type: \"end\" };\n }\n function peg$otherExpectation(description) {\n return { type: \"other\", description };\n }\n function peg$computePosDetails(pos) {\n var details = peg$posDetailsCache[pos];\n var p;\n if (details) {\n return details;\n } else {\n p = pos - 1;\n while (!peg$posDetailsCache[p]) {\n p--;\n }\n details = peg$posDetailsCache[p];\n details = {\n line: details.line,\n column: details.column\n };\n while (p < pos) {\n if (input.charCodeAt(p) === 10) {\n details.line++;\n details.column = 1;\n } else {\n details.column++;\n }\n p++;\n }\n peg$posDetailsCache[pos] = details;\n return details;\n }\n }\n function peg$computeLocation(startPos, endPos, offset2) {\n var startPosDetails = peg$computePosDetails(startPos);\n var endPosDetails = peg$computePosDetails(endPos);\n var res = {\n source: peg$source,\n start: {\n offset: startPos,\n line: startPosDetails.line,\n column: startPosDetails.column\n },\n end: {\n offset: endPos,\n line: endPosDetails.line,\n column: endPosDetails.column\n }\n };\n if (offset2 && peg$source && typeof peg$source.offset === \"function\") {\n res.start = peg$source.offset(res.start);\n res.end = peg$source.offset(res.end);\n }\n return res;\n }\n function peg$fail(expected2) {\n if (peg$currPos < peg$maxFailPos) {\n return;\n }\n if (peg$currPos > peg$maxFailPos) {\n peg$maxFailPos = peg$currPos;\n peg$maxFailExpected = [];\n }\n peg$maxFailExpected.push(expected2);\n }\n function peg$buildSimpleError(message, location2) {\n return new peg$SyntaxError(message, null, null, location2);\n }\n function peg$buildStructuredError(expected2, found, location2) {\n return new peg$SyntaxError(\n peg$SyntaxError.buildMessage(expected2, found),\n expected2,\n found,\n location2\n );\n }\n function peg$parseroot() {\n var s0, s1, s2, s3, s4;\n s0 = peg$currPos;\n s1 = peg$currPos;\n s2 = peg$parsebase();\n if (s2 !== peg$FAILED) {\n s3 = peg$parsestretchable();\n if (s3 === peg$FAILED) {\n s3 = null;\n }\n s4 = peg$parseshrinkable();\n if (s4 === peg$FAILED) {\n s4 = null;\n }\n peg$savedPos = s1;\n s1 = peg$f0(s2, s3, s4);\n } else {\n peg$currPos = s1;\n s1 = peg$FAILED;\n }\n if (s1 !== peg$FAILED) {\n s2 = [];\n if (input.length > peg$currPos) {\n s3 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s3 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n while (s3 !== peg$FAILED) {\n s2.push(s3);\n if (input.length > peg$currPos) {\n s3 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s3 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n }\n peg$savedPos = s0;\n s0 = peg$f1(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parsebase() {\n var s0, s1, s2;\n s0 = peg$currPos;\n s1 = peg$parsenumber();\n if (s1 !== peg$FAILED) {\n s2 = peg$parseunit();\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f2(s1, s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parsestretchable() {\n var s0, s1, s2, s3;\n s0 = peg$currPos;\n if (input.substr(peg$currPos, 4) === peg$c0) {\n s1 = peg$c0;\n peg$currPos += 4;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e1);\n }\n }\n if (s1 !== peg$FAILED) {\n s2 = peg$parsenumber();\n if (s2 !== peg$FAILED) {\n s3 = peg$parserubber_unit();\n if (s3 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f3(s2, s3);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parseshrinkable() {\n var s0, s1, s2, s3;\n s0 = peg$currPos;\n if (input.substr(peg$currPos, 5) === peg$c1) {\n s1 = peg$c1;\n peg$currPos += 5;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e2);\n }\n }\n if (s1 !== peg$FAILED) {\n s2 = peg$parsenumber();\n if (s2 !== peg$FAILED) {\n s3 = peg$parserubber_unit();\n if (s3 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f4(s2, s3);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parseunit() {\n var s0;\n if (input.substr(peg$currPos, 2) === peg$c2) {\n s0 = peg$c2;\n peg$currPos += 2;\n } else {\n s0 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e3);\n }\n }\n if (s0 === peg$FAILED) {\n if (input.substr(peg$currPos, 2) === peg$c3) {\n s0 = peg$c3;\n peg$currPos += 2;\n } else {\n s0 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e4);\n }\n }\n if (s0 === peg$FAILED) {\n if (input.substr(peg$currPos, 2) === peg$c4) {\n s0 = peg$c4;\n peg$currPos += 2;\n } else {\n s0 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e5);\n }\n }\n if (s0 === peg$FAILED) {\n if (input.substr(peg$currPos, 2) === peg$c5) {\n s0 = peg$c5;\n peg$currPos += 2;\n } else {\n s0 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e6);\n }\n }\n if (s0 === peg$FAILED) {\n if (input.substr(peg$currPos, 2) === peg$c6) {\n s0 = peg$c6;\n peg$currPos += 2;\n } else {\n s0 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e7);\n }\n }\n if (s0 === peg$FAILED) {\n if (input.substr(peg$currPos, 2) === peg$c7) {\n s0 = peg$c7;\n peg$currPos += 2;\n } else {\n s0 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e8);\n }\n }\n if (s0 === peg$FAILED) {\n if (input.substr(peg$currPos, 2) === peg$c8) {\n s0 = peg$c8;\n peg$currPos += 2;\n } else {\n s0 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e9);\n }\n }\n if (s0 === peg$FAILED) {\n if (input.substr(peg$currPos, 2) === peg$c9) {\n s0 = peg$c9;\n peg$currPos += 2;\n } else {\n s0 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e10);\n }\n }\n if (s0 === peg$FAILED) {\n if (input.substr(peg$currPos, 2) === peg$c10) {\n s0 = peg$c10;\n peg$currPos += 2;\n } else {\n s0 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e11);\n }\n }\n if (s0 === peg$FAILED) {\n if (input.substr(peg$currPos, 2) === peg$c11) {\n s0 = peg$c11;\n peg$currPos += 2;\n } else {\n s0 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e12);\n }\n }\n if (s0 === peg$FAILED) {\n if (input.substr(peg$currPos, 2) === peg$c12) {\n s0 = peg$c12;\n peg$currPos += 2;\n } else {\n s0 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e13);\n }\n }\n if (s0 === peg$FAILED) {\n if (input.substr(peg$currPos, 2) === peg$c13) {\n s0 = peg$c13;\n peg$currPos += 2;\n } else {\n s0 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e14);\n }\n }\n if (s0 === peg$FAILED) {\n if (input.substr(peg$currPos, 2) === peg$c14) {\n s0 = peg$c14;\n peg$currPos += 2;\n } else {\n s0 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e15);\n }\n }\n }\n }\n }\n }\n }\n }\n }\n }\n }\n }\n }\n }\n return s0;\n }\n function peg$parserubber_unit() {\n var s0;\n s0 = peg$parseunit();\n if (s0 === peg$FAILED) {\n if (input.substr(peg$currPos, 5) === peg$c15) {\n s0 = peg$c15;\n peg$currPos += 5;\n } else {\n s0 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e16);\n }\n }\n if (s0 === peg$FAILED) {\n if (input.substr(peg$currPos, 4) === peg$c16) {\n s0 = peg$c16;\n peg$currPos += 4;\n } else {\n s0 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e17);\n }\n }\n if (s0 === peg$FAILED) {\n if (input.substr(peg$currPos, 3) === peg$c17) {\n s0 = peg$c17;\n peg$currPos += 3;\n } else {\n s0 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e18);\n }\n }\n }\n }\n }\n return s0;\n }\n function peg$parsenumber() {\n var s0, s1, s2, s3, s4, s5, s6, s7, s8;\n peg$silentFails++;\n s0 = peg$currPos;\n s1 = peg$currPos;\n s2 = peg$currPos;\n s3 = peg$parsesign();\n if (s3 === peg$FAILED) {\n s3 = null;\n }\n s4 = peg$currPos;\n s5 = [];\n if (peg$r0.test(input.charAt(peg$currPos))) {\n s6 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s6 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e20);\n }\n }\n while (s6 !== peg$FAILED) {\n s5.push(s6);\n if (peg$r0.test(input.charAt(peg$currPos))) {\n s6 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s6 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e20);\n }\n }\n }\n if (input.charCodeAt(peg$currPos) === 46) {\n s6 = peg$c18;\n peg$currPos++;\n } else {\n s6 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e21);\n }\n }\n if (s6 !== peg$FAILED) {\n s7 = [];\n if (peg$r0.test(input.charAt(peg$currPos))) {\n s8 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s8 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e20);\n }\n }\n if (s8 !== peg$FAILED) {\n while (s8 !== peg$FAILED) {\n s7.push(s8);\n if (peg$r0.test(input.charAt(peg$currPos))) {\n s8 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s8 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e20);\n }\n }\n }\n } else {\n s7 = peg$FAILED;\n }\n if (s7 !== peg$FAILED) {\n s5 = [s5, s6, s7];\n s4 = s5;\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n if (s4 === peg$FAILED) {\n s4 = [];\n if (peg$r0.test(input.charAt(peg$currPos))) {\n s5 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s5 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e20);\n }\n }\n if (s5 !== peg$FAILED) {\n while (s5 !== peg$FAILED) {\n s4.push(s5);\n if (peg$r0.test(input.charAt(peg$currPos))) {\n s5 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s5 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e20);\n }\n }\n }\n } else {\n s4 = peg$FAILED;\n }\n }\n if (s4 !== peg$FAILED) {\n s3 = [s3, s4];\n s2 = s3;\n } else {\n peg$currPos = s2;\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n s1 = input.substring(s1, peg$currPos);\n } else {\n s1 = s2;\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = s0;\n s1 = peg$f5(s1);\n }\n s0 = s1;\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e19);\n }\n }\n return s0;\n }\n function peg$parsesign() {\n var s0;\n if (input.charCodeAt(peg$currPos) === 43) {\n s0 = peg$c19;\n peg$currPos++;\n } else {\n s0 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e22);\n }\n }\n if (s0 === peg$FAILED) {\n if (input.charCodeAt(peg$currPos) === 45) {\n s0 = peg$c20;\n peg$currPos++;\n } else {\n s0 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e23);\n }\n }\n }\n return s0;\n }\n function peg$parseEOL() {\n var s0, s1;\n s0 = peg$currPos;\n peg$silentFails++;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n peg$silentFails--;\n if (s1 === peg$FAILED) {\n s0 = void 0;\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n peg$result = peg$startRuleFunction();\n if (peg$result !== peg$FAILED && peg$currPos === input.length) {\n return peg$result;\n } else {\n if (peg$result !== peg$FAILED && peg$currPos < input.length) {\n peg$fail(peg$endExpectation());\n }\n throw peg$buildStructuredError(\n peg$maxFailExpected,\n peg$maxFailPos < input.length ? input.charAt(peg$maxFailPos) : null,\n peg$maxFailPos < input.length ? peg$computeLocation(peg$maxFailPos, peg$maxFailPos + 1) : peg$computeLocation(peg$maxFailPos, peg$maxFailPos)\n );\n }\n }\n return {\n SyntaxError: peg$SyntaxError,\n parse: peg$parse\n };\n }()\n);\n","export default (\n // Generated by Peggy 3.0.2.\n //\n // https://peggyjs.org/\n function() {\n \"use strict\";\n function peg$subclass(child, parent) {\n function C() {\n this.constructor = child;\n }\n C.prototype = parent.prototype;\n child.prototype = new C();\n }\n function peg$SyntaxError(message, expected, found, location) {\n var self = Error.call(this, message);\n if (Object.setPrototypeOf) {\n Object.setPrototypeOf(self, peg$SyntaxError.prototype);\n }\n self.expected = expected;\n self.found = found;\n self.location = location;\n self.name = \"SyntaxError\";\n return self;\n }\n peg$subclass(peg$SyntaxError, Error);\n function peg$padEnd(str, targetLength, padString) {\n padString = padString || \" \";\n if (str.length > targetLength) {\n return str;\n }\n targetLength -= str.length;\n padString += padString.repeat(targetLength);\n return str + padString.slice(0, targetLength);\n }\n peg$SyntaxError.prototype.format = function(sources) {\n var str = \"Error: \" + this.message;\n if (this.location) {\n var src = null;\n var k;\n for (k = 0; k < sources.length; k++) {\n if (sources[k].source === this.location.source) {\n src = sources[k].text.split(/\\r\\n|\\n|\\r/g);\n break;\n }\n }\n var s = this.location.start;\n var offset_s = this.location.source && typeof this.location.source.offset === \"function\" ? this.location.source.offset(s) : s;\n var loc = this.location.source + \":\" + offset_s.line + \":\" + offset_s.column;\n if (src) {\n var e = this.location.end;\n var filler = peg$padEnd(\"\", offset_s.line.toString().length, \" \");\n var line = src[s.line - 1];\n var last = s.line === e.line ? e.column : line.length + 1;\n var hatLen = last - s.column || 1;\n str += \"\\n --> \" + loc + \"\\n\" + filler + \" |\\n\" + offset_s.line + \" | \" + line + \"\\n\" + filler + \" | \" + peg$padEnd(\"\", s.column - 1, \" \") + peg$padEnd(\"\", hatLen, \"^\");\n } else {\n str += \"\\n at \" + loc;\n }\n }\n return str;\n };\n peg$SyntaxError.buildMessage = function(expected, found) {\n var DESCRIBE_EXPECTATION_FNS = {\n literal: function(expectation) {\n return '\"' + literalEscape(expectation.text) + '\"';\n },\n class: function(expectation) {\n var escapedParts = expectation.parts.map(function(part) {\n return Array.isArray(part) ? classEscape(part[0]) + \"-\" + classEscape(part[1]) : classEscape(part);\n });\n return \"[\" + (expectation.inverted ? \"^\" : \"\") + escapedParts.join(\"\") + \"]\";\n },\n any: function() {\n return \"any character\";\n },\n end: function() {\n return \"end of input\";\n },\n other: function(expectation) {\n return expectation.description;\n }\n };\n function hex(ch) {\n return ch.charCodeAt(0).toString(16).toUpperCase();\n }\n function literalEscape(s) {\n return s.replace(/\\\\/g, \"\\\\\\\\\").replace(/\"/g, '\\\\\"').replace(/\\0/g, \"\\\\0\").replace(/\\t/g, \"\\\\t\").replace(/\\n/g, \"\\\\n\").replace(/\\r/g, \"\\\\r\").replace(/[\\x00-\\x0F]/g, function(ch) {\n return \"\\\\x0\" + hex(ch);\n }).replace(/[\\x10-\\x1F\\x7F-\\x9F]/g, function(ch) {\n return \"\\\\x\" + hex(ch);\n });\n }\n function classEscape(s) {\n return s.replace(/\\\\/g, \"\\\\\\\\\").replace(/\\]/g, \"\\\\]\").replace(/\\^/g, \"\\\\^\").replace(/-/g, \"\\\\-\").replace(/\\0/g, \"\\\\0\").replace(/\\t/g, \"\\\\t\").replace(/\\n/g, \"\\\\n\").replace(/\\r/g, \"\\\\r\").replace(/[\\x00-\\x0F]/g, function(ch) {\n return \"\\\\x0\" + hex(ch);\n }).replace(/[\\x10-\\x1F\\x7F-\\x9F]/g, function(ch) {\n return \"\\\\x\" + hex(ch);\n });\n }\n function describeExpectation(expectation) {\n return DESCRIBE_EXPECTATION_FNS[expectation.type](expectation);\n }\n function describeExpected(expected2) {\n var descriptions = expected2.map(describeExpectation);\n var i, j;\n descriptions.sort();\n if (descriptions.length > 0) {\n for (i = 1, j = 1; i < descriptions.length; i++) {\n if (descriptions[i - 1] !== descriptions[i]) {\n descriptions[j] = descriptions[i];\n j++;\n }\n }\n descriptions.length = j;\n }\n switch (descriptions.length) {\n case 1:\n return descriptions[0];\n case 2:\n return descriptions[0] + \" or \" + descriptions[1];\n default:\n return descriptions.slice(0, -1).join(\", \") + \", or \" + descriptions[descriptions.length - 1];\n }\n }\n function describeFound(found2) {\n return found2 ? '\"' + literalEscape(found2) + '\"' : \"end of input\";\n }\n return \"Expected \" + describeExpected(expected) + \" but \" + describeFound(found) + \" found.\";\n };\n function peg$parse(input, options) {\n options = options !== void 0 ? options : {};\n var peg$FAILED = {};\n var peg$source = options.grammarSource;\n var peg$startRuleFunctions = { path_spec: peg$parsepath_spec, foreach_body: peg$parseforeach_body };\n var peg$startRuleFunction = peg$parsepath_spec;\n var peg$e0 = peg$anyExpectation();\n var peg$e1 = peg$otherExpectation(\"same line comment\");\n var peg$e2 = peg$otherExpectation(\"own line comment\");\n var peg$e3 = peg$otherExpectation(\"comment\");\n var peg$e4 = peg$otherExpectation(\"floating comment\");\n var peg$e5 = peg$otherExpectation(\"operation\");\n var peg$e6 = peg$otherExpectation(\"=\");\n var peg$f0 = function(v) {\n return v;\n };\n var peg$f1 = function(ops) {\n return { type: \"path_spec\", content: ops };\n };\n var peg$f2 = function(c1, op, comment) {\n return { op, comment };\n };\n var peg$f3 = function(c1, ops, c2, body) {\n const comments = [c1, ...ops.map((x) => x.comment), c2].filter(\n (x) => x\n );\n const attribute = ops.map((x) => x.op.content.content).join(\" \");\n return {\n type: \"animation\",\n comments,\n attribute,\n content: body.content\n };\n };\n var peg$f4 = function(start, b) {\n return { ...b, start, type: \"foreach\" };\n };\n var peg$f5 = function(c1, variables, options2, c2, c3, list, c4, command) {\n const comments = [c1, c2, c3, c4].filter((x) => x);\n return {\n type: \"foreach_body\",\n variables,\n options: options2 && options2.content,\n list,\n command,\n comments\n };\n };\n var peg$f6 = function(c1, options2, c2, body) {\n const comments = [c1, c2].filter((x) => x);\n return {\n type: \"svg_operation\",\n options: options2 && options2.content,\n content: body,\n comments\n };\n };\n var peg$f7 = function(c1, c2, coord, c3, c4, x) {\n return { coord: x, comment: c4 };\n };\n var peg$f8 = function(c1, c2, coord, c3, a, c5) {\n const comments = [c1, c2, c3, a && a.comment, c5].filter((x) => x);\n return {\n type: \"curve_to\",\n controls: a ? [coord, a.coord] : [coord],\n comments\n };\n };\n var peg$f9 = function() {\n return { type: \"line_to\", command: \"|-\" };\n };\n var peg$f10 = function() {\n return { type: \"line_to\", command: \"-|\" };\n };\n var peg$f11 = function() {\n return { type: \"line_to\", command: \"--\" };\n };\n var peg$f12 = function(prefix, content) {\n return { type: \"coordinate\", content, prefix };\n };\n var peg$f13 = function(content) {\n return { type: \"square_brace_group\", content };\n };\n var peg$f14 = function(v) {\n return { type: \"unknown\", content: v };\n };\n var peg$f15 = function(tok) {\n return options.isSameLineComment(tok);\n };\n var peg$f16 = function(tok) {\n return tok;\n };\n var peg$f17 = function(tok) {\n return options.isOwnLineComment(tok);\n };\n var peg$f18 = function(tok) {\n return tok;\n };\n var peg$f19 = function(tok) {\n return options.isComment(tok);\n };\n var peg$f20 = function(tok) {\n return tok;\n };\n var peg$f21 = function(tok) {\n return options.isWhitespace(tok);\n };\n var peg$f22 = function(tok) {\n return tok;\n };\n var peg$f23 = function(c) {\n return c;\n };\n var peg$f24 = function(tok) {\n return options.isOperation(tok);\n };\n var peg$f25 = function(tok) {\n return { type: \"operation\", content: tok };\n };\n var peg$f26 = function(tok) {\n return options.isChar(tok, \"=\");\n };\n var peg$f27 = function(tok) {\n return tok;\n };\n var peg$f28 = function(tok) {\n return options.isChar(tok, \"[\");\n };\n var peg$f29 = function(tok) {\n return tok;\n };\n var peg$f30 = function(tok) {\n return options.isChar(tok, \"]\");\n };\n var peg$f31 = function(tok) {\n return tok;\n };\n var peg$f32 = function(tok) {\n return options.isChar(tok, \"(\");\n };\n var peg$f33 = function(tok) {\n return tok;\n };\n var peg$f34 = function(tok) {\n return options.isChar(tok, \")\");\n };\n var peg$f35 = function(tok) {\n return tok;\n };\n var peg$f36 = function(tok) {\n return options.isChar(tok, \"+\");\n };\n var peg$f37 = function(tok) {\n return tok;\n };\n var peg$f38 = function(tok) {\n return options.isChar(tok, \"-\");\n };\n var peg$f39 = function(tok) {\n return tok;\n };\n var peg$f40 = function(tok) {\n return options.isChar(tok, \"|\");\n };\n var peg$f41 = function(tok) {\n return tok;\n };\n var peg$f42 = function(tok) {\n return options.isChar(tok, \".\");\n };\n var peg$f43 = function(tok) {\n return tok;\n };\n var peg$f44 = function(tok) {\n return options.isChar(tok, \"controls\");\n };\n var peg$f45 = function(tok) {\n return tok;\n };\n var peg$f46 = function(tok) {\n return options.isChar(tok, \"and\");\n };\n var peg$f47 = function(tok) {\n return tok;\n };\n var peg$f48 = function(tok) {\n return options.isChar(tok, \"svg\");\n };\n var peg$f49 = function(tok) {\n return tok;\n };\n var peg$f50 = function(tok) {\n return options.isGroup(tok);\n };\n var peg$f51 = function(tok) {\n return tok;\n };\n var peg$f52 = function(tok) {\n return options.isAnyMacro(tok);\n };\n var peg$f53 = function(tok) {\n return tok;\n };\n var peg$f54 = function(tok) {\n return options.isChar(tok, \"foreach\");\n };\n var peg$f55 = function(tok) {\n return tok;\n };\n var peg$f56 = function(tok) {\n return options.isMacro(tok, \"foreach\");\n };\n var peg$f57 = function(tok) {\n return tok;\n };\n var peg$f58 = function(tok) {\n return options.isChar(tok, \"in\");\n };\n var peg$f59 = function(tok) {\n return tok;\n };\n var peg$f60 = function(tok) {\n return options.isChar(tok, \":\");\n };\n var peg$f61 = function(tok) {\n return tok;\n };\n var peg$currPos = 0;\n var peg$savedPos = 0;\n var peg$posDetailsCache = [{ line: 1, column: 1 }];\n var peg$maxFailPos = 0;\n var peg$maxFailExpected = [];\n var peg$silentFails = 0;\n var peg$result;\n if (\"startRule\" in options) {\n if (!(options.startRule in peg$startRuleFunctions)) {\n throw new Error(`Can't start parsing from rule \"` + options.startRule + '\".');\n }\n peg$startRuleFunction = peg$startRuleFunctions[options.startRule];\n }\n function text() {\n return input.substring(peg$savedPos, peg$currPos);\n }\n function offset() {\n return peg$savedPos;\n }\n function range() {\n return {\n source: peg$source,\n start: peg$savedPos,\n end: peg$currPos\n };\n }\n function location() {\n return peg$computeLocation(peg$savedPos, peg$currPos);\n }\n function expected(description, location2) {\n location2 = location2 !== void 0 ? location2 : peg$computeLocation(peg$savedPos, peg$currPos);\n throw peg$buildStructuredError(\n [peg$otherExpectation(description)],\n input.substring(peg$savedPos, peg$currPos),\n location2\n );\n }\n function error(message, location2) {\n location2 = location2 !== void 0 ? location2 : peg$computeLocation(peg$savedPos, peg$currPos);\n throw peg$buildSimpleError(message, location2);\n }\n function peg$literalExpectation(text2, ignoreCase) {\n return { type: \"literal\", text: text2, ignoreCase };\n }\n function peg$classExpectation(parts, inverted, ignoreCase) {\n return { type: \"class\", parts, inverted, ignoreCase };\n }\n function peg$anyExpectation() {\n return { type: \"any\" };\n }\n function peg$endExpectation() {\n return { type: \"end\" };\n }\n function peg$otherExpectation(description) {\n return { type: \"other\", description };\n }\n function peg$computePosDetails(pos) {\n var details = peg$posDetailsCache[pos];\n var p;\n if (details) {\n return details;\n } else {\n p = pos - 1;\n while (!peg$posDetailsCache[p]) {\n p--;\n }\n details = peg$posDetailsCache[p];\n details = {\n line: details.line,\n column: details.column\n };\n while (p < pos) {\n if (input.charCodeAt(p) === 10) {\n details.line++;\n details.column = 1;\n } else {\n details.column++;\n }\n p++;\n }\n peg$posDetailsCache[pos] = details;\n return details;\n }\n }\n function peg$computeLocation(startPos, endPos, offset2) {\n var startPosDetails = peg$computePosDetails(startPos);\n var endPosDetails = peg$computePosDetails(endPos);\n var res = {\n source: peg$source,\n start: {\n offset: startPos,\n line: startPosDetails.line,\n column: startPosDetails.column\n },\n end: {\n offset: endPos,\n line: endPosDetails.line,\n column: endPosDetails.column\n }\n };\n if (offset2 && peg$source && typeof peg$source.offset === \"function\") {\n res.start = peg$source.offset(res.start);\n res.end = peg$source.offset(res.end);\n }\n return res;\n }\n function peg$fail(expected2) {\n if (peg$currPos < peg$maxFailPos) {\n return;\n }\n if (peg$currPos > peg$maxFailPos) {\n peg$maxFailPos = peg$currPos;\n peg$maxFailExpected = [];\n }\n peg$maxFailExpected.push(expected2);\n }\n function peg$buildSimpleError(message, location2) {\n return new peg$SyntaxError(message, null, null, location2);\n }\n function peg$buildStructuredError(expected2, found, location2) {\n return new peg$SyntaxError(\n peg$SyntaxError.buildMessage(expected2, found),\n expected2,\n found,\n location2\n );\n }\n function peg$parsepath_spec() {\n var s0, s1, s2, s3, s4, s5;\n s0 = peg$currPos;\n s1 = [];\n s2 = peg$currPos;\n s3 = peg$parsesquare_brace_group();\n if (s3 === peg$FAILED) {\n s3 = peg$parsecoordinate();\n if (s3 === peg$FAILED) {\n s3 = peg$parsecurve_to();\n if (s3 === peg$FAILED) {\n s3 = peg$parseline_to();\n if (s3 === peg$FAILED) {\n s3 = peg$parsesvg();\n if (s3 === peg$FAILED) {\n s3 = peg$parseforeach();\n if (s3 === peg$FAILED) {\n s3 = peg$parseoperation();\n if (s3 === peg$FAILED) {\n s3 = peg$parsecomment();\n if (s3 === peg$FAILED) {\n s3 = peg$parseanimation();\n if (s3 === peg$FAILED) {\n s3 = peg$parseunknown();\n }\n }\n }\n }\n }\n }\n }\n }\n }\n if (s3 !== peg$FAILED) {\n s4 = [];\n s5 = peg$parse_();\n while (s5 !== peg$FAILED) {\n s4.push(s5);\n s5 = peg$parse_();\n }\n peg$savedPos = s2;\n s2 = peg$f0(s3);\n } else {\n peg$currPos = s2;\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n while (s2 !== peg$FAILED) {\n s1.push(s2);\n s2 = peg$currPos;\n s3 = peg$parsesquare_brace_group();\n if (s3 === peg$FAILED) {\n s3 = peg$parsecoordinate();\n if (s3 === peg$FAILED) {\n s3 = peg$parsecurve_to();\n if (s3 === peg$FAILED) {\n s3 = peg$parseline_to();\n if (s3 === peg$FAILED) {\n s3 = peg$parsesvg();\n if (s3 === peg$FAILED) {\n s3 = peg$parseforeach();\n if (s3 === peg$FAILED) {\n s3 = peg$parseoperation();\n if (s3 === peg$FAILED) {\n s3 = peg$parsecomment();\n if (s3 === peg$FAILED) {\n s3 = peg$parseanimation();\n if (s3 === peg$FAILED) {\n s3 = peg$parseunknown();\n }\n }\n }\n }\n }\n }\n }\n }\n }\n if (s3 !== peg$FAILED) {\n s4 = [];\n s5 = peg$parse_();\n while (s5 !== peg$FAILED) {\n s4.push(s5);\n s5 = peg$parse_();\n }\n peg$savedPos = s2;\n s2 = peg$f0(s3);\n } else {\n peg$currPos = s2;\n s2 = peg$FAILED;\n }\n }\n } else {\n s1 = peg$FAILED;\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = s0;\n s1 = peg$f1(s1);\n }\n s0 = s1;\n return s0;\n }\n function peg$parseanimation() {\n var s0, s1, s2, s3, s4, s5, s6;\n s0 = peg$currPos;\n s1 = peg$parsecolon();\n if (s1 !== peg$FAILED) {\n s2 = peg$parse_comment_();\n s3 = [];\n s4 = peg$currPos;\n s5 = peg$parseoperation();\n if (s5 !== peg$FAILED) {\n s6 = peg$parse_comment_();\n peg$savedPos = s4;\n s4 = peg$f2(s2, s5, s6);\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n if (s4 !== peg$FAILED) {\n while (s4 !== peg$FAILED) {\n s3.push(s4);\n s4 = peg$currPos;\n s5 = peg$parseoperation();\n if (s5 !== peg$FAILED) {\n s6 = peg$parse_comment_();\n peg$savedPos = s4;\n s4 = peg$f2(s2, s5, s6);\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n }\n } else {\n s3 = peg$FAILED;\n }\n if (s3 !== peg$FAILED) {\n s4 = peg$parseequals();\n if (s4 !== peg$FAILED) {\n s5 = peg$parse_comment_();\n s6 = peg$parsegroup();\n if (s6 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f3(s2, s3, s5, s6);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parseforeach() {\n var s0, s1, s2;\n s0 = peg$currPos;\n s1 = peg$parseforeach_keyword();\n if (s1 === peg$FAILED) {\n s1 = peg$parseforeach_macro();\n }\n if (s1 !== peg$FAILED) {\n s2 = peg$parseforeach_body();\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f4(s1, s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parseforeach_body() {\n var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;\n s0 = peg$currPos;\n s1 = peg$parse_comment_();\n s2 = peg$currPos;\n s3 = [];\n s4 = peg$currPos;\n s5 = peg$currPos;\n peg$silentFails++;\n s6 = peg$parsein_keyword();\n if (s6 === peg$FAILED) {\n s6 = peg$parsesquare_brace_group();\n }\n peg$silentFails--;\n if (s6 === peg$FAILED) {\n s5 = void 0;\n } else {\n peg$currPos = s5;\n s5 = peg$FAILED;\n }\n if (s5 !== peg$FAILED) {\n if (input.length > peg$currPos) {\n s6 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s6 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n if (s6 !== peg$FAILED) {\n s5 = [s5, s6];\n s4 = s5;\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n while (s4 !== peg$FAILED) {\n s3.push(s4);\n s4 = peg$currPos;\n s5 = peg$currPos;\n peg$silentFails++;\n s6 = peg$parsein_keyword();\n if (s6 === peg$FAILED) {\n s6 = peg$parsesquare_brace_group();\n }\n peg$silentFails--;\n if (s6 === peg$FAILED) {\n s5 = void 0;\n } else {\n peg$currPos = s5;\n s5 = peg$FAILED;\n }\n if (s5 !== peg$FAILED) {\n if (input.length > peg$currPos) {\n s6 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s6 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n if (s6 !== peg$FAILED) {\n s5 = [s5, s6];\n s4 = s5;\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n }\n s2 = input.substring(s2, peg$currPos);\n s3 = peg$parsesquare_brace_group();\n if (s3 === peg$FAILED) {\n s3 = null;\n }\n s4 = peg$parse_comment_();\n s5 = peg$parsein_keyword();\n if (s5 !== peg$FAILED) {\n s6 = peg$parse_comment_();\n s7 = peg$parsegroup();\n if (s7 === peg$FAILED) {\n s7 = peg$parsemacro();\n }\n if (s7 !== peg$FAILED) {\n s8 = peg$parse_comment_();\n s9 = peg$parseforeach();\n if (s9 === peg$FAILED) {\n s9 = peg$parsegroup();\n if (s9 === peg$FAILED) {\n s9 = peg$parsemacro();\n }\n }\n if (s9 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f5(s1, s2, s3, s4, s6, s7, s8, s9);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parsesvg() {\n var s0, s1, s2, s3, s4, s5;\n s0 = peg$currPos;\n s1 = peg$parsesvg_keyword();\n if (s1 !== peg$FAILED) {\n s2 = peg$parse_comment_();\n s3 = peg$parsesquare_brace_group();\n if (s3 === peg$FAILED) {\n s3 = null;\n }\n s4 = peg$parse_comment_();\n s5 = peg$parsegroup();\n if (s5 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f6(s2, s3, s4, s5);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parsecurve_to() {\n var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10;\n s0 = peg$currPos;\n s1 = peg$parsedotdot();\n if (s1 !== peg$FAILED) {\n s2 = peg$parse_comment_();\n s3 = peg$parsecontrols_keyword();\n if (s3 !== peg$FAILED) {\n s4 = peg$parse_comment_();\n s5 = peg$parsecoordinate();\n if (s5 !== peg$FAILED) {\n s6 = peg$parse_comment_();\n s7 = peg$currPos;\n s8 = peg$parseand_keyword();\n if (s8 !== peg$FAILED) {\n s9 = peg$parse_comment_();\n s10 = peg$parsecoordinate();\n if (s10 !== peg$FAILED) {\n peg$savedPos = s7;\n s7 = peg$f7(s2, s4, s5, s6, s9, s10);\n } else {\n peg$currPos = s7;\n s7 = peg$FAILED;\n }\n } else {\n peg$currPos = s7;\n s7 = peg$FAILED;\n }\n if (s7 === peg$FAILED) {\n s7 = null;\n }\n s8 = peg$parse_comment_();\n s9 = peg$parsedotdot();\n if (s9 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f8(s2, s4, s5, s6, s7, s8);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parseline_to() {\n var s0, s1, s2;\n s0 = peg$currPos;\n s1 = peg$parsepipe();\n if (s1 !== peg$FAILED) {\n s2 = peg$parseminus();\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f9();\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n if (s0 === peg$FAILED) {\n s0 = peg$currPos;\n s1 = peg$parseminus();\n if (s1 !== peg$FAILED) {\n s2 = peg$parsepipe();\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f10();\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n if (s0 === peg$FAILED) {\n s0 = peg$currPos;\n s1 = peg$parseminus();\n if (s1 !== peg$FAILED) {\n s2 = peg$parseminus();\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f11();\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n }\n }\n return s0;\n }\n function peg$parsecoordinate() {\n var s0, s1, s2, s3, s4, s5, s6, s7;\n s0 = peg$currPos;\n s1 = peg$currPos;\n s2 = peg$currPos;\n s3 = peg$parseplus();\n if (s3 !== peg$FAILED) {\n s4 = peg$parseplus();\n if (s4 === peg$FAILED) {\n s4 = null;\n }\n s3 = [s3, s4];\n s2 = s3;\n } else {\n peg$currPos = s2;\n s2 = peg$FAILED;\n }\n if (s2 === peg$FAILED) {\n s2 = null;\n }\n s1 = input.substring(s1, peg$currPos);\n s2 = peg$parseopen_paren();\n if (s2 !== peg$FAILED) {\n s3 = peg$currPos;\n s4 = [];\n s5 = peg$currPos;\n s6 = peg$currPos;\n peg$silentFails++;\n s7 = peg$parseclose_paren();\n peg$silentFails--;\n if (s7 === peg$FAILED) {\n s6 = void 0;\n } else {\n peg$currPos = s6;\n s6 = peg$FAILED;\n }\n if (s6 !== peg$FAILED) {\n if (input.length > peg$currPos) {\n s7 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s7 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n if (s7 !== peg$FAILED) {\n s6 = [s6, s7];\n s5 = s6;\n } else {\n peg$currPos = s5;\n s5 = peg$FAILED;\n }\n } else {\n peg$currPos = s5;\n s5 = peg$FAILED;\n }\n while (s5 !== peg$FAILED) {\n s4.push(s5);\n s5 = peg$currPos;\n s6 = peg$currPos;\n peg$silentFails++;\n s7 = peg$parseclose_paren();\n peg$silentFails--;\n if (s7 === peg$FAILED) {\n s6 = void 0;\n } else {\n peg$currPos = s6;\n s6 = peg$FAILED;\n }\n if (s6 !== peg$FAILED) {\n if (input.length > peg$currPos) {\n s7 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s7 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n if (s7 !== peg$FAILED) {\n s6 = [s6, s7];\n s5 = s6;\n } else {\n peg$currPos = s5;\n s5 = peg$FAILED;\n }\n } else {\n peg$currPos = s5;\n s5 = peg$FAILED;\n }\n }\n s3 = input.substring(s3, peg$currPos);\n s4 = peg$parseclose_paren();\n if (s4 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f12(s1, s3);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parsesquare_brace_group() {\n var s0, s1, s2, s3, s4, s5, s6;\n s0 = peg$currPos;\n s1 = peg$parseopen_square_brace();\n if (s1 !== peg$FAILED) {\n s2 = peg$currPos;\n s3 = [];\n s4 = peg$currPos;\n s5 = peg$currPos;\n peg$silentFails++;\n s6 = peg$parseclose_square_brace();\n peg$silentFails--;\n if (s6 === peg$FAILED) {\n s5 = void 0;\n } else {\n peg$currPos = s5;\n s5 = peg$FAILED;\n }\n if (s5 !== peg$FAILED) {\n if (input.length > peg$currPos) {\n s6 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s6 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n if (s6 !== peg$FAILED) {\n s5 = [s5, s6];\n s4 = s5;\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n while (s4 !== peg$FAILED) {\n s3.push(s4);\n s4 = peg$currPos;\n s5 = peg$currPos;\n peg$silentFails++;\n s6 = peg$parseclose_square_brace();\n peg$silentFails--;\n if (s6 === peg$FAILED) {\n s5 = void 0;\n } else {\n peg$currPos = s5;\n s5 = peg$FAILED;\n }\n if (s5 !== peg$FAILED) {\n if (input.length > peg$currPos) {\n s6 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s6 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n if (s6 !== peg$FAILED) {\n s5 = [s5, s6];\n s4 = s5;\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n }\n s2 = input.substring(s2, peg$currPos);\n s3 = peg$parseclose_square_brace();\n if (s3 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f13(s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parsedotdot() {\n var s0, s1, s2;\n s0 = peg$currPos;\n s1 = peg$parsedot();\n if (s1 !== peg$FAILED) {\n s2 = peg$parsedot();\n if (s2 !== peg$FAILED) {\n s1 = [s1, s2];\n s0 = s1;\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parseunknown() {\n var s0, s1;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = s0;\n s1 = peg$f14(s1);\n }\n s0 = s1;\n return s0;\n }\n function peg$parsesame_line_comment() {\n var s0, s1, s2;\n peg$silentFails++;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f15(s1);\n if (s2) {\n s2 = void 0;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f16(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e1);\n }\n }\n return s0;\n }\n function peg$parseown_line_comment() {\n var s0, s1, s2;\n peg$silentFails++;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f17(s1);\n if (s2) {\n s2 = void 0;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f18(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e2);\n }\n }\n return s0;\n }\n function peg$parsecomment() {\n var s0, s1, s2;\n peg$silentFails++;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f19(s1);\n if (s2) {\n s2 = void 0;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f20(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e3);\n }\n }\n return s0;\n }\n function peg$parse_() {\n var s0, s1, s2;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f21(s1);\n if (s2) {\n s2 = void 0;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f22(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parse_comment_() {\n var s0, s1, s2, s3, s4;\n peg$silentFails++;\n s0 = peg$currPos;\n s1 = [];\n s2 = peg$parse_();\n while (s2 !== peg$FAILED) {\n s1.push(s2);\n s2 = peg$parse_();\n }\n s2 = peg$parsecomment();\n if (s2 === peg$FAILED) {\n s2 = null;\n }\n s3 = [];\n s4 = peg$parse_();\n while (s4 !== peg$FAILED) {\n s3.push(s4);\n s4 = peg$parse_();\n }\n peg$savedPos = s0;\n s0 = peg$f23(s2);\n peg$silentFails--;\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e4);\n }\n return s0;\n }\n function peg$parseoperation() {\n var s0, s1, s2;\n peg$silentFails++;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f24(s1);\n if (s2) {\n s2 = void 0;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f25(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e5);\n }\n }\n return s0;\n }\n function peg$parseequals() {\n var s0, s1, s2;\n peg$silentFails++;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f26(s1);\n if (s2) {\n s2 = void 0;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f27(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e6);\n }\n }\n return s0;\n }\n function peg$parseopen_square_brace() {\n var s0, s1, s2;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f28(s1);\n if (s2) {\n s2 = void 0;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f29(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parseclose_square_brace() {\n var s0, s1, s2;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f30(s1);\n if (s2) {\n s2 = void 0;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f31(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parseopen_paren() {\n var s0, s1, s2;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f32(s1);\n if (s2) {\n s2 = void 0;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f33(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parseclose_paren() {\n var s0, s1, s2;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f34(s1);\n if (s2) {\n s2 = void 0;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f35(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parseplus() {\n var s0, s1, s2;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f36(s1);\n if (s2) {\n s2 = void 0;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f37(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parseminus() {\n var s0, s1, s2;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f38(s1);\n if (s2) {\n s2 = void 0;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f39(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parsepipe() {\n var s0, s1, s2;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f40(s1);\n if (s2) {\n s2 = void 0;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f41(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parsedot() {\n var s0, s1, s2;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f42(s1);\n if (s2) {\n s2 = void 0;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f43(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parsecontrols_keyword() {\n var s0, s1, s2;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f44(s1);\n if (s2) {\n s2 = void 0;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f45(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parseand_keyword() {\n var s0, s1, s2;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f46(s1);\n if (s2) {\n s2 = void 0;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f47(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parsesvg_keyword() {\n var s0, s1, s2;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f48(s1);\n if (s2) {\n s2 = void 0;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f49(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parsegroup() {\n var s0, s1, s2;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f50(s1);\n if (s2) {\n s2 = void 0;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f51(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parsemacro() {\n var s0, s1, s2;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f52(s1);\n if (s2) {\n s2 = void 0;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f53(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parseforeach_keyword() {\n var s0, s1, s2;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f54(s1);\n if (s2) {\n s2 = void 0;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f55(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parseforeach_macro() {\n var s0, s1, s2;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f56(s1);\n if (s2) {\n s2 = void 0;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f57(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parsein_keyword() {\n var s0, s1, s2;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f58(s1);\n if (s2) {\n s2 = void 0;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f59(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parsecolon() {\n var s0, s1, s2;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f60(s1);\n if (s2) {\n s2 = void 0;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f61(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parseEOL() {\n var s0, s1;\n s0 = peg$currPos;\n peg$silentFails++;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n peg$silentFails--;\n if (s1 === peg$FAILED) {\n s0 = void 0;\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n if (!options.isWhitespace) {\n try {\n Object.assign(options, {\n isChar: (node, char) => node.type === \"string\" && node.content === char,\n isOperation: (node) => node.type === \"string\" && node.content.match(/[a-zA-Z]/),\n isWhitespace: (node) => node.type === \"whitespace\" || node.type === \"parbreak\",\n isSameLineComment: (node) => node.type === \"comment\" && node.sameline,\n isOwnLineComment: (node) => node.type === \"comment\" && !node.sameline,\n isComment: (node) => node.type === \"comment\",\n isGroup: (node) => node.type === \"group\",\n isMacro: (node, name) => node.type === \"macro\" && node.content === name,\n isAnyMacro: (node) => node.type === \"macro\"\n });\n } catch (e) {\n console.warn(\"Error when initializing parser\", e);\n }\n }\n peg$result = peg$startRuleFunction();\n if (peg$result !== peg$FAILED && peg$currPos === input.length) {\n return peg$result;\n } else {\n if (peg$result !== peg$FAILED && peg$currPos < input.length) {\n peg$fail(peg$endExpectation());\n }\n throw peg$buildStructuredError(\n peg$maxFailExpected,\n peg$maxFailPos < input.length ? input.charAt(peg$maxFailPos) : null,\n peg$maxFailPos < input.length ? peg$computeLocation(peg$maxFailPos, peg$maxFailPos + 1) : peg$computeLocation(peg$maxFailPos, peg$maxFailPos)\n );\n }\n }\n return {\n SyntaxError: peg$SyntaxError,\n parse: peg$parse\n };\n }()\n);\n","/* eslint-disable @typescript-eslint/ban-ts-comment */\n// This file needs to be here because typescript does not know how to use babel's transpiler\n// to directly load Pegjs grammars.\n// @ts-nocheck\nimport _LatexPegParser from \"../grammars/latex.pegjs\";\nimport _AlignEnvironmentPegParser from \"../grammars/align-environment.pegjs\";\nimport _ArgSpecPegParser from \"../grammars/xparse-argspec.pegjs\";\nimport _PgfkeysPegParser from \"../grammars/pgfkeys.pegjs\";\nimport _MacroSubstitutionPegParser from \"../grammars/macro-substitutions.pegjs\";\nimport _LigaturesPegParser from \"../grammars/ligatures.pegjs\";\nimport _XColorPegParser from \"../grammars/xcolor-expressions.pegjs\";\nimport _TabularPegParser from \"../grammars/tabular-spec.pegjs\";\nimport _SystemePegParser from \"../grammars/systeme-environment.pegjs\";\nimport _GluePegParser from \"../grammars/tex-glue.pegjs\";\nimport _TikzPegParser from \"../grammars/tikz.pegjs\";\n\ntype PegParser = {\n parse: (input: string | unknown[], options?: unknown) => any;\n SyntaxError: (\n message: string,\n expected: string,\n found: unknown,\n location: unknown\n ) => unknown;\n};\n\nconst LatexPegParser = _LatexPegParser as PegParser;\nconst AlignEnvironmentPegParser = _AlignEnvironmentPegParser as PegParser;\nconst ArgSpecPegParser = _ArgSpecPegParser as PegParser;\nconst PgfkeysPegParser = _PgfkeysPegParser as PegParser;\nconst MacroSubstitutionPegParser = _MacroSubstitutionPegParser as PegParser;\nconst LigaturesPegParser = _LigaturesPegParser as PegParser;\nconst XColorPegParser = _XColorPegParser as PegParser;\nconst TabularPegParser = _TabularPegParser as PegParser;\nconst SystemePegParser = _SystemePegParser as PegParser;\nconst GluePegParser = _GluePegParser as PegParser;\nconst TikzPegParser = _TikzPegParser as PegParser;\n\nexport {\n LatexPegParser,\n AlignEnvironmentPegParser,\n ArgSpecPegParser,\n PgfkeysPegParser,\n MacroSubstitutionPegParser,\n LigaturesPegParser,\n XColorPegParser,\n TabularPegParser,\n SystemePegParser,\n GluePegParser,\n TikzPegParser,\n};\n"],"names":["match"],"mappings":"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"} \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-util-pegjs/index.d.ts b/node_modules/@unified-latex/unified-latex-util-pegjs/index.d.ts new file mode 100644 index 0000000..80bfef7 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-util-pegjs/index.d.ts @@ -0,0 +1,47 @@ +import * as Ast from '@unified-latex/unified-latex-types'; + +export declare const AlignEnvironmentPegParser: PegParser; + +export declare const ArgSpecPegParser: PegParser; + +/** + * Pegjs operates on strings. However, strings and arrays are very similar! + * This function adds `charAt`, `charCodeAt`, and `substring` methods to + * `array` so that `array` can then be fed to a Pegjs generated parser. + * + * @param {[object]} array + * @returns {[object]} + */ +export declare function decorateArrayForPegjs(array: any[]): StringlikeArray; + +export declare const GluePegParser: PegParser; + +export declare const LatexPegParser: PegParser; + +export declare const LigaturesPegParser: PegParser; + +export declare const MacroSubstitutionPegParser: PegParser; + +declare type PegParser = { + parse: (input: string | unknown[], options?: unknown) => any; + SyntaxError: (message: string, expected: string, found: unknown, location: unknown) => unknown; +}; + +export declare const PgfkeysPegParser: PegParser; + +/** + * Splits all multi-character strings into strings that are all single characters. + */ +export declare function splitStringsIntoSingleChars(nodes: Ast.Node[]): Ast.Node[]; + +declare type StringlikeArray = any[] & string; + +export declare const SystemePegParser: PegParser; + +export declare const TabularPegParser: PegParser; + +export declare const TikzPegParser: PegParser; + +export declare const XColorPegParser: PegParser; + +export { } diff --git a/node_modules/@unified-latex/unified-latex-util-pegjs/index.js b/node_modules/@unified-latex/unified-latex-util-pegjs/index.js new file mode 100644 index 0000000..e1f625d --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-util-pegjs/index.js @@ -0,0 +1,16700 @@ +import { match } from "@unified-latex/unified-latex-util-match"; +function decorateArrayForPegjs(array) { + array.charAt = function(i) { + return this[i]; + }; + array.charCodeAt = () => 0; + array.substring = function(i, j) { + return this.slice(i, j); + }; + array.replace = function(a, b) { + const ret = JSON.stringify(this); + return ret.replace(a, b); + }; + return array; +} +function splitStringsIntoSingleChars(nodes) { + return nodes.flatMap( + (node) => match.anyString(node) ? Array.from(node.content).map((c) => ({ + type: "string", + content: c + })) : node + ); +} +const _LatexPegParser = ( + // Generated by Peggy 3.0.2. + // + // https://peggyjs.org/ + function() { + function peg$subclass(child, parent) { + function C() { + this.constructor = child; + } + C.prototype = parent.prototype; + child.prototype = new C(); + } + function peg$SyntaxError(message, expected, found, location) { + var self = Error.call(this, message); + if (Object.setPrototypeOf) { + Object.setPrototypeOf(self, peg$SyntaxError.prototype); + } + self.expected = expected; + self.found = found; + self.location = location; + self.name = "SyntaxError"; + return self; + } + peg$subclass(peg$SyntaxError, Error); + function peg$padEnd(str, targetLength, padString) { + padString = padString || " "; + if (str.length > targetLength) { + return str; + } + targetLength -= str.length; + padString += padString.repeat(targetLength); + return str + padString.slice(0, targetLength); + } + peg$SyntaxError.prototype.format = function(sources) { + var str = "Error: " + this.message; + if (this.location) { + var src = null; + var k; + for (k = 0; k < sources.length; k++) { + if (sources[k].source === this.location.source) { + src = sources[k].text.split(/\r\n|\n|\r/g); + break; + } + } + var s = this.location.start; + var offset_s = this.location.source && typeof this.location.source.offset === "function" ? this.location.source.offset(s) : s; + var loc = this.location.source + ":" + offset_s.line + ":" + offset_s.column; + if (src) { + var e = this.location.end; + var filler = peg$padEnd("", offset_s.line.toString().length, " "); + var line = src[s.line - 1]; + var last = s.line === e.line ? e.column : line.length + 1; + var hatLen = last - s.column || 1; + str += "\n --> " + loc + "\n" + filler + " |\n" + offset_s.line + " | " + line + "\n" + filler + " | " + peg$padEnd("", s.column - 1, " ") + peg$padEnd("", hatLen, "^"); + } else { + str += "\n at " + loc; + } + } + return str; + }; + peg$SyntaxError.buildMessage = function(expected, found) { + var DESCRIBE_EXPECTATION_FNS = { + literal: function(expectation) { + return '"' + literalEscape(expectation.text) + '"'; + }, + class: function(expectation) { + var escapedParts = expectation.parts.map(function(part) { + return Array.isArray(part) ? classEscape(part[0]) + "-" + classEscape(part[1]) : classEscape(part); + }); + return "[" + (expectation.inverted ? "^" : "") + escapedParts.join("") + "]"; + }, + any: function() { + return "any character"; + }, + end: function() { + return "end of input"; + }, + other: function(expectation) { + return expectation.description; + } + }; + function hex(ch) { + return ch.charCodeAt(0).toString(16).toUpperCase(); + } + function literalEscape(s) { + return s.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\0/g, "\\0").replace(/\t/g, "\\t").replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/[\x00-\x0F]/g, function(ch) { + return "\\x0" + hex(ch); + }).replace(/[\x10-\x1F\x7F-\x9F]/g, function(ch) { + return "\\x" + hex(ch); + }); + } + function classEscape(s) { + return s.replace(/\\/g, "\\\\").replace(/\]/g, "\\]").replace(/\^/g, "\\^").replace(/-/g, "\\-").replace(/\0/g, "\\0").replace(/\t/g, "\\t").replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/[\x00-\x0F]/g, function(ch) { + return "\\x0" + hex(ch); + }).replace(/[\x10-\x1F\x7F-\x9F]/g, function(ch) { + return "\\x" + hex(ch); + }); + } + function describeExpectation(expectation) { + return DESCRIBE_EXPECTATION_FNS[expectation.type](expectation); + } + function describeExpected(expected2) { + var descriptions = expected2.map(describeExpectation); + var i, j; + descriptions.sort(); + if (descriptions.length > 0) { + for (i = 1, j = 1; i < descriptions.length; i++) { + if (descriptions[i - 1] !== descriptions[i]) { + descriptions[j] = descriptions[i]; + j++; + } + } + descriptions.length = j; + } + switch (descriptions.length) { + case 1: + return descriptions[0]; + case 2: + return descriptions[0] + " or " + descriptions[1]; + default: + return descriptions.slice(0, -1).join(", ") + ", or " + descriptions[descriptions.length - 1]; + } + } + function describeFound(found2) { + return found2 ? '"' + literalEscape(found2) + '"' : "end of input"; + } + return "Expected " + describeExpected(expected) + " but " + describeFound(found) + " found."; + }; + function peg$parse(input, options) { + options = options !== void 0 ? options : {}; + var peg$FAILED = {}; + var peg$source = options.grammarSource; + var peg$startRuleFunctions = { document: peg$parsedocument, math: peg$parsemath }; + var peg$startRuleFunction = peg$parsedocument; + var peg$c0 = "%"; + var peg$c1 = "."; + var peg$c2 = "verb*"; + var peg$c3 = "verb"; + var peg$c4 = "["; + var peg$c5 = "]"; + var peg$c6 = "lstinline"; + var peg$c7 = "mintinline"; + var peg$c8 = "mint"; + var peg$c9 = "minted"; + var peg$c10 = "verbatim*"; + var peg$c11 = "verbatim"; + var peg$c12 = "filecontents*"; + var peg$c13 = "filecontents"; + var peg$c14 = "comment"; + var peg$c15 = "lstlisting"; + var peg$c16 = "("; + var peg$c17 = ")"; + var peg$c18 = "begin"; + var peg$c19 = "end"; + var peg$c20 = "equation*"; + var peg$c21 = "equation"; + var peg$c22 = "align*"; + var peg$c23 = "align"; + var peg$c24 = "alignat*"; + var peg$c25 = "alignat"; + var peg$c26 = "gather*"; + var peg$c27 = "gather"; + var peg$c28 = "multline*"; + var peg$c29 = "multline"; + var peg$c30 = "flalign*"; + var peg$c31 = "flalign"; + var peg$c32 = "split"; + var peg$c33 = "math"; + var peg$c34 = "displaymath"; + var peg$c35 = "\\"; + var peg$c36 = "{"; + var peg$c37 = "}"; + var peg$c38 = "$"; + var peg$c39 = "&"; + var peg$c40 = "\r"; + var peg$c41 = "\n"; + var peg$c42 = "\r\n"; + var peg$c43 = "#"; + var peg$c44 = "^"; + var peg$c45 = "_"; + var peg$c46 = "\0"; + var peg$r0 = /^[^ \t\n\r]/; + var peg$r1 = /^[ \t]/; + var peg$r2 = /^[a-zA-Z]/; + var peg$r3 = /^[0-9]/; + var peg$r4 = /^[.,;:\-*\/()!?=+<>[\]`'"~]/; + var peg$e0 = peg$otherExpectation("document"); + var peg$e1 = peg$otherExpectation("math"); + var peg$e2 = peg$otherExpectation("token"); + var peg$e3 = peg$anyExpectation(); + var peg$e4 = peg$otherExpectation("parbreak"); + var peg$e5 = peg$otherExpectation("math token"); + var peg$e6 = peg$otherExpectation("nonchar token"); + var peg$e7 = peg$literalExpectation("%", false); + var peg$e8 = peg$otherExpectation("whitespace"); + var peg$e9 = peg$otherExpectation("number"); + var peg$e10 = peg$literalExpectation(".", false); + var peg$e11 = peg$otherExpectation("special macro"); + var peg$e12 = peg$literalExpectation("verb*", false); + var peg$e13 = peg$literalExpectation("verb", false); + var peg$e14 = peg$literalExpectation("[", false); + var peg$e15 = peg$literalExpectation("]", false); + var peg$e16 = peg$classExpectation([" ", " ", "\n", "\r"], true, false); + var peg$e17 = peg$otherExpectation("verbatim listings"); + var peg$e18 = peg$literalExpectation("lstinline", false); + var peg$e19 = peg$otherExpectation("verbatim minted"); + var peg$e20 = peg$literalExpectation("mintinline", false); + var peg$e21 = peg$literalExpectation("mint", false); + var peg$e22 = peg$otherExpectation("verbatim minted environment"); + var peg$e23 = peg$literalExpectation("minted", false); + var peg$e24 = peg$otherExpectation("verbatim environment"); + var peg$e25 = peg$literalExpectation("verbatim*", false); + var peg$e26 = peg$literalExpectation("verbatim", false); + var peg$e27 = peg$literalExpectation("filecontents*", false); + var peg$e28 = peg$literalExpectation("filecontents", false); + var peg$e29 = peg$literalExpectation("comment", false); + var peg$e30 = peg$literalExpectation("lstlisting", false); + var peg$e31 = peg$otherExpectation("macro"); + var peg$e32 = peg$otherExpectation("group"); + var peg$e33 = peg$otherExpectation("environment"); + var peg$e34 = peg$otherExpectation("math environment"); + var peg$e36 = peg$literalExpectation("(", false); + var peg$e37 = peg$literalExpectation(")", false); + var peg$e38 = peg$literalExpectation("begin", false); + var peg$e39 = peg$literalExpectation("end", false); + var peg$e40 = peg$literalExpectation("equation*", false); + var peg$e41 = peg$literalExpectation("equation", false); + var peg$e42 = peg$literalExpectation("align*", false); + var peg$e43 = peg$literalExpectation("align", false); + var peg$e44 = peg$literalExpectation("alignat*", false); + var peg$e45 = peg$literalExpectation("alignat", false); + var peg$e46 = peg$literalExpectation("gather*", false); + var peg$e47 = peg$literalExpectation("gather", false); + var peg$e48 = peg$literalExpectation("multline*", false); + var peg$e49 = peg$literalExpectation("multline", false); + var peg$e50 = peg$literalExpectation("flalign*", false); + var peg$e51 = peg$literalExpectation("flalign", false); + var peg$e52 = peg$literalExpectation("split", false); + var peg$e53 = peg$literalExpectation("math", false); + var peg$e54 = peg$literalExpectation("displaymath", false); + var peg$e55 = peg$otherExpectation("escape"); + var peg$e56 = peg$literalExpectation("\\", false); + var peg$e57 = peg$literalExpectation("{", false); + var peg$e58 = peg$literalExpectation("}", false); + var peg$e59 = peg$literalExpectation("$", false); + var peg$e60 = peg$literalExpectation("&", false); + var peg$e61 = peg$otherExpectation("newline"); + var peg$e62 = peg$literalExpectation("\r", false); + var peg$e63 = peg$literalExpectation("\n", false); + var peg$e64 = peg$literalExpectation("\r\n", false); + var peg$e65 = peg$literalExpectation("#", false); + var peg$e66 = peg$literalExpectation("^", false); + var peg$e67 = peg$literalExpectation("_", false); + var peg$e68 = peg$literalExpectation("\0", false); + var peg$e69 = peg$classExpectation([" ", " "], false, false); + var peg$e70 = peg$otherExpectation("letter"); + var peg$e71 = peg$classExpectation([["a", "z"], ["A", "Z"]], false, false); + var peg$e72 = peg$otherExpectation("digit"); + var peg$e73 = peg$classExpectation([["0", "9"]], false, false); + var peg$e74 = peg$otherExpectation("punctuation"); + var peg$e75 = peg$classExpectation([".", ",", ";", ":", "-", "*", "/", "(", ")", "!", "?", "=", "+", "<", ">", "[", "]", "`", "'", '"', "~"], false, false); + var peg$e76 = peg$otherExpectation("full comment"); + var peg$e77 = peg$otherExpectation("comment"); + var peg$f0 = function(content) { + return createNode("root", { content: content.flatMap((x) => x) }); + }; + var peg$f1 = function(t) { + return t; + }; + var peg$f2 = function(eq) { + return createNode("inlinemath", { content: eq.flatMap((x) => x) }); + }; + var peg$f3 = function(s) { + return createNode("string", { content: s }); + }; + var peg$f4 = function(s) { + return createNode("string", { content: s }); + }; + var peg$f5 = function() { + return createNode("parbreak"); + }; + var peg$f6 = function(x) { + return x; + }; + var peg$f7 = function(x) { + return x; + }; + var peg$f8 = function() { + return createNode("macro", { content: "^", escapeToken: "" }); + }; + var peg$f9 = function() { + return createNode("macro", { content: "_", escapeToken: "" }); + }; + var peg$f10 = function(s) { + return createNode("string", { content: s }); + }; + var peg$f11 = function() { + return createNode("whitespace"); + }; + var peg$f12 = function(a, b) { + return a.join("") + "." + b.join(""); + }; + var peg$f13 = function(b) { + return "." + b.join(""); + }; + var peg$f14 = function(a) { + return a.join("") + "."; + }; + var peg$f15 = function(s) { + return createNode("string", { content: s }); + }; + var peg$f16 = function(env, e, end) { + return end == e; + }; + var peg$f17 = function(env, e, x) { + return x; + }; + var peg$f18 = function(env, e, x, end) { + return end == e; + }; + var peg$f19 = function(env, e, x) { + return createNode("verb", { + env, + escape: e, + content: x.join("") + }); + }; + var peg$f20 = function(x) { + return x; + }; + var peg$f21 = function(x) { + return createNode("displaymath", { content: x.flatMap((x2) => x2) }); + }; + var peg$f22 = function(x) { + return x; + }; + var peg$f23 = function(x) { + return createNode("inlinemath", { content: x.flatMap((x2) => x2) }); + }; + var peg$f24 = function(x) { + return x; + }; + var peg$f25 = function(x) { + return createNode("displaymath", { content: x.flatMap((x2) => x2) }); + }; + var peg$f26 = function(end) { + return end.type === "string" && end.content === "]"; + }; + var peg$f27 = function(x) { + return x; + }; + var peg$f28 = function(o) { + return [ + createNode("string", { content: "[" }), + ...o, + createNode("string", { content: "]" }) + ]; + }; + var peg$f29 = function(x) { + return x; + }; + var peg$f30 = function(v) { + return createNode("group", { + content: createNode("string", { content: v.join("") }) + }); + }; + var peg$f31 = function(d, end) { + return end == d; + }; + var peg$f32 = function(d, x) { + return x; + }; + var peg$f33 = function(d, v, end) { + return end == d; + }; + var peg$f34 = function(d, v) { + return [ + createNode("string", { content: d }), + createNode("string", { content: v.join("") }), + createNode("string", { content: d }) + ]; + }; + var peg$f35 = function(macro, option, verbatim) { + return [ + createNode("macro", { content: macro }), + ...option || [], + ...[].concat(verbatim) + ]; + }; + var peg$f36 = function(macro, option, language, verbatim) { + return [ + createNode("macro", { content: macro }), + ...option || [], + language, + ...[].concat(verbatim) + ]; + }; + var peg$f37 = function(env, option, language, end_env) { + return compare_env({ content: [env] }, end_env); + }; + var peg$f38 = function(env, option, language, body) { + const content = [ + ...option || [], + language, + { type: "string", content: body } + ]; + return createNode("environment", { + env, + content + }); + }; + var peg$f39 = function(env, end_env) { + return compare_env({ content: [env] }, end_env); + }; + var peg$f40 = function(env, x) { + return x; + }; + var peg$f41 = function(env, body) { + return createNode("verbatim", { + env, + content: body + }); + }; + var peg$f42 = function(n) { + return n.join(""); + }; + var peg$f43 = function(n) { + return n; + }; + var peg$f44 = function(m) { + return createNode("macro", { content: m }); + }; + var peg$f45 = function(c) { + return c; + }; + var peg$f46 = function(x) { + return createNode("group", { content: x.flatMap((x2) => x2) }); + }; + var peg$f47 = function(g) { + return text().slice(1, -1); + }; + var peg$f48 = function(env, env_comment, end_env) { + return compare_env(env, end_env); + }; + var peg$f49 = function(env, env_comment, x) { + return x; + }; + var peg$f50 = function(env, env_comment, body) { + body = body.flatMap((x) => x); + return createNode("environment", { + env, + content: env_comment ? [env_comment, ...body] : body + }); + }; + var peg$f51 = function(env, env_comment, end_env) { + return compare_env({ content: [env] }, end_env); + }; + var peg$f52 = function(env, env_comment, x) { + return x; + }; + var peg$f53 = function(env, env_comment, body) { + body = body.flatMap((x) => x); + return createNode("mathenv", { + env, + content: env_comment ? [env_comment, ...body] : body + }); + }; + var peg$f56 = function(e) { + return createNode("string", { content: e }); + }; + var peg$f57 = function() { + return createNode("string", { content: "\\" }); + }; + var peg$f58 = function(s) { + return createNode("string", { content: s }); + }; + var peg$f59 = function(s) { + return createNode("string", { content: s }); + }; + var peg$f60 = function(s) { + return createNode("string", { content: s }); + }; + var peg$f61 = function(s) { + return createNode("string", { content: s }); + }; + var peg$f62 = function(s) { + return createNode("string", { content: s }); + }; + var peg$f63 = function(s) { + return createNode("string", { content: s }); + }; + var peg$f64 = function(s) { + return createNode("string", { content: s }); + }; + var peg$f65 = function() { + return " "; + }; + var peg$f66 = function(p) { + return createNode("string", { content: p }); + }; + var peg$f67 = function(leading_sp, comment) { + return createNode("comment", { + ...comment, + sameline: false, + leadingWhitespace: leading_sp.length > 0 + }); + }; + var peg$f68 = function(spaces, x) { + return createNode("comment", { + ...x, + sameline: true, + leadingWhitespace: spaces.length > 0 + }); + }; + var peg$f69 = function(c) { + return c; + }; + var peg$f70 = function(c) { + return { content: c.join(""), suffixParbreak: true }; + }; + var peg$f71 = function(c) { + return c; + }; + var peg$f72 = function(c) { + return { content: c.join("") }; + }; + var peg$f73 = function() { + var loc = location(); + return loc.start.column === 1; + }; + var peg$currPos = 0; + var peg$savedPos = 0; + var peg$posDetailsCache = [{ line: 1, column: 1 }]; + var peg$maxFailPos = 0; + var peg$maxFailExpected = []; + var peg$silentFails = 0; + var peg$resultsCache = {}; + var peg$result; + if ("startRule" in options) { + if (!(options.startRule in peg$startRuleFunctions)) { + throw new Error(`Can't start parsing from rule "` + options.startRule + '".'); + } + peg$startRuleFunction = peg$startRuleFunctions[options.startRule]; + } + function text() { + return input.substring(peg$savedPos, peg$currPos); + } + function location() { + return peg$computeLocation(peg$savedPos, peg$currPos); + } + function peg$literalExpectation(text2, ignoreCase) { + return { type: "literal", text: text2, ignoreCase }; + } + function peg$classExpectation(parts, inverted, ignoreCase) { + return { type: "class", parts, inverted, ignoreCase }; + } + function peg$anyExpectation() { + return { type: "any" }; + } + function peg$endExpectation() { + return { type: "end" }; + } + function peg$otherExpectation(description) { + return { type: "other", description }; + } + function peg$computePosDetails(pos) { + var details = peg$posDetailsCache[pos]; + var p; + if (details) { + return details; + } else { + p = pos - 1; + while (!peg$posDetailsCache[p]) { + p--; + } + details = peg$posDetailsCache[p]; + details = { + line: details.line, + column: details.column + }; + while (p < pos) { + if (input.charCodeAt(p) === 10) { + details.line++; + details.column = 1; + } else { + details.column++; + } + p++; + } + peg$posDetailsCache[pos] = details; + return details; + } + } + function peg$computeLocation(startPos, endPos, offset2) { + var startPosDetails = peg$computePosDetails(startPos); + var endPosDetails = peg$computePosDetails(endPos); + var res = { + source: peg$source, + start: { + offset: startPos, + line: startPosDetails.line, + column: startPosDetails.column + }, + end: { + offset: endPos, + line: endPosDetails.line, + column: endPosDetails.column + } + }; + return res; + } + function peg$fail(expected2) { + if (peg$currPos < peg$maxFailPos) { + return; + } + if (peg$currPos > peg$maxFailPos) { + peg$maxFailPos = peg$currPos; + peg$maxFailExpected = []; + } + peg$maxFailExpected.push(expected2); + } + function peg$buildStructuredError(expected2, found, location2) { + return new peg$SyntaxError( + peg$SyntaxError.buildMessage(expected2, found), + expected2, + found, + location2 + ); + } + function peg$parsedocument() { + var s0, s1, s2; + var key = peg$currPos * 52 + 0; + var cached = peg$resultsCache[key]; + if (cached) { + peg$currPos = cached.nextPos; + return cached.result; + } + peg$silentFails++; + s0 = peg$currPos; + s1 = []; + s2 = peg$parsetoken(); + while (s2 !== peg$FAILED) { + s1.push(s2); + s2 = peg$parsetoken(); + } + peg$savedPos = s0; + s1 = peg$f0(s1); + s0 = s1; + peg$silentFails--; + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 }; + return s0; + } + function peg$parsemath() { + var s0, s1; + var key = peg$currPos * 52 + 1; + var cached = peg$resultsCache[key]; + if (cached) { + peg$currPos = cached.nextPos; + return cached.result; + } + peg$silentFails++; + s0 = []; + s1 = peg$parsemath_token(); + while (s1 !== peg$FAILED) { + s0.push(s1); + s1 = peg$parsemath_token(); + } + peg$silentFails--; + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e1); + } + peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 }; + return s0; + } + function peg$parsetoken() { + var s0, s1, s2, s3, s4, s5; + var key = peg$currPos * 52 + 2; + var cached = peg$resultsCache[key]; + if (cached) { + peg$currPos = cached.nextPos; + return cached.result; + } + peg$silentFails++; + s0 = peg$parsespecial_macro(); + if (s0 === peg$FAILED) { + s0 = peg$parsemacro(); + if (s0 === peg$FAILED) { + s0 = peg$parsefull_comment(); + if (s0 === peg$FAILED) { + s0 = peg$parsegroup(); + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$parsemath_shift(); + if (s1 !== peg$FAILED) { + s2 = []; + s3 = peg$currPos; + s4 = peg$currPos; + peg$silentFails++; + s5 = peg$parsemath_shift(); + peg$silentFails--; + if (s5 === peg$FAILED) { + s4 = void 0; + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + if (s4 !== peg$FAILED) { + s5 = peg$parsemath_token(); + if (s5 !== peg$FAILED) { + peg$savedPos = s3; + s3 = peg$f1(s5); + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + if (s3 !== peg$FAILED) { + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$currPos; + s4 = peg$currPos; + peg$silentFails++; + s5 = peg$parsemath_shift(); + peg$silentFails--; + if (s5 === peg$FAILED) { + s4 = void 0; + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + if (s4 !== peg$FAILED) { + s5 = peg$parsemath_token(); + if (s5 !== peg$FAILED) { + peg$savedPos = s3; + s3 = peg$f1(s5); + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s3 = peg$parsemath_shift(); + if (s3 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f2(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$parsealignment_tab(); + if (s0 === peg$FAILED) { + s0 = peg$parseparbreak(); + if (s0 === peg$FAILED) { + s0 = peg$parsemacro_parameter(); + if (s0 === peg$FAILED) { + s0 = peg$parseignore(); + if (s0 === peg$FAILED) { + s0 = peg$parsenumber(); + if (s0 === peg$FAILED) { + s0 = peg$parsewhitespace(); + if (s0 === peg$FAILED) { + s0 = peg$parsepunctuation(); + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$currPos; + s2 = []; + s3 = peg$currPos; + s4 = peg$currPos; + peg$silentFails++; + s5 = peg$parsenonchar_token(); + peg$silentFails--; + if (s5 === peg$FAILED) { + s4 = void 0; + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + if (s4 !== peg$FAILED) { + if (input.length > peg$currPos) { + s5 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s5 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s5 !== peg$FAILED) { + s4 = [s4, s5]; + s3 = s4; + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + if (s3 !== peg$FAILED) { + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$currPos; + s4 = peg$currPos; + peg$silentFails++; + s5 = peg$parsenonchar_token(); + peg$silentFails--; + if (s5 === peg$FAILED) { + s4 = void 0; + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + if (s4 !== peg$FAILED) { + if (input.length > peg$currPos) { + s5 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s5 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s5 !== peg$FAILED) { + s4 = [s4, s5]; + s3 = s4; + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s1 = input.substring(s1, peg$currPos); + } else { + s1 = s2; + } + if (s1 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$f3(s1); + } + s0 = s1; + if (s0 === peg$FAILED) { + s0 = peg$parsebegin_group(); + if (s0 === peg$FAILED) { + s0 = peg$parseend_group(); + if (s0 === peg$FAILED) { + s0 = peg$parsemath_shift(); + if (s0 === peg$FAILED) { + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s1 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$f4(s1); + } + s0 = s1; + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e2); + } + } + peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 }; + return s0; + } + function peg$parseparbreak() { + var s0, s1, s2, s3, s4, s5, s6, s7; + var key = peg$currPos * 52 + 3; + var cached = peg$resultsCache[key]; + if (cached) { + peg$currPos = cached.nextPos; + return cached.result; + } + peg$silentFails++; + s0 = peg$currPos; + s1 = peg$currPos; + s2 = []; + s3 = peg$parsesp(); + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$parsesp(); + } + s3 = peg$parsenl(); + if (s3 !== peg$FAILED) { + s4 = []; + s5 = peg$currPos; + s6 = []; + s7 = peg$parsesp(); + while (s7 !== peg$FAILED) { + s6.push(s7); + s7 = peg$parsesp(); + } + s7 = peg$parsenl(); + if (s7 !== peg$FAILED) { + s6 = [s6, s7]; + s5 = s6; + } else { + peg$currPos = s5; + s5 = peg$FAILED; + } + if (s5 !== peg$FAILED) { + while (s5 !== peg$FAILED) { + s4.push(s5); + s5 = peg$currPos; + s6 = []; + s7 = peg$parsesp(); + while (s7 !== peg$FAILED) { + s6.push(s7); + s7 = peg$parsesp(); + } + s7 = peg$parsenl(); + if (s7 !== peg$FAILED) { + s6 = [s6, s7]; + s5 = s6; + } else { + peg$currPos = s5; + s5 = peg$FAILED; + } + } + } else { + s4 = peg$FAILED; + } + if (s4 !== peg$FAILED) { + s5 = []; + s6 = peg$parsesp(); + while (s6 !== peg$FAILED) { + s5.push(s6); + s6 = peg$parsesp(); + } + s6 = peg$currPos; + peg$silentFails++; + s7 = peg$parsecomment_start(); + peg$silentFails--; + if (s7 === peg$FAILED) { + s6 = void 0; + } else { + peg$currPos = s6; + s6 = peg$FAILED; + } + if (s6 !== peg$FAILED) { + s2 = [s2, s3, s4, s5, s6]; + s1 = s2; + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + if (s1 === peg$FAILED) { + s1 = peg$currPos; + s2 = []; + s3 = peg$parsesp(); + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$parsesp(); + } + s3 = peg$parsenl(); + if (s3 !== peg$FAILED) { + s4 = []; + s5 = peg$currPos; + s6 = []; + s7 = peg$parsesp(); + while (s7 !== peg$FAILED) { + s6.push(s7); + s7 = peg$parsesp(); + } + s7 = peg$parsenl(); + if (s7 !== peg$FAILED) { + s6 = [s6, s7]; + s5 = s6; + } else { + peg$currPos = s5; + s5 = peg$FAILED; + } + if (s5 !== peg$FAILED) { + while (s5 !== peg$FAILED) { + s4.push(s5); + s5 = peg$currPos; + s6 = []; + s7 = peg$parsesp(); + while (s7 !== peg$FAILED) { + s6.push(s7); + s7 = peg$parsesp(); + } + s7 = peg$parsenl(); + if (s7 !== peg$FAILED) { + s6 = [s6, s7]; + s5 = s6; + } else { + peg$currPos = s5; + s5 = peg$FAILED; + } + } + } else { + s4 = peg$FAILED; + } + if (s4 !== peg$FAILED) { + s2 = [s2, s3, s4]; + s1 = s2; + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + } + if (s1 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$f5(); + } + s0 = s1; + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e4); + } + } + peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 }; + return s0; + } + function peg$parsemath_token() { + var s0, s1, s2, s3, s4; + var key = peg$currPos * 52 + 4; + var cached = peg$resultsCache[key]; + if (cached) { + peg$currPos = cached.nextPos; + return cached.result; + } + peg$silentFails++; + s0 = peg$parsespecial_macro(); + if (s0 === peg$FAILED) { + s0 = peg$parsemacro(); + if (s0 === peg$FAILED) { + s0 = peg$parsefull_comment(); + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = []; + s2 = peg$parsewhitespace(); + while (s2 !== peg$FAILED) { + s1.push(s2); + s2 = peg$parsewhitespace(); + } + s2 = peg$parsegroup(); + if (s2 !== peg$FAILED) { + s3 = []; + s4 = peg$parsewhitespace(); + while (s4 !== peg$FAILED) { + s3.push(s4); + s4 = peg$parsewhitespace(); + } + peg$savedPos = s0; + s0 = peg$f6(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = []; + s2 = peg$parsewhitespace(); + while (s2 !== peg$FAILED) { + s1.push(s2); + s2 = peg$parsewhitespace(); + } + s2 = peg$parsealignment_tab(); + if (s2 !== peg$FAILED) { + s3 = []; + s4 = peg$parsewhitespace(); + while (s4 !== peg$FAILED) { + s3.push(s4); + s4 = peg$parsewhitespace(); + } + peg$savedPos = s0; + s0 = peg$f7(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$parsemacro_parameter(); + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = []; + s2 = peg$parsewhitespace(); + while (s2 !== peg$FAILED) { + s1.push(s2); + s2 = peg$parsewhitespace(); + } + s2 = peg$parsesuperscript(); + if (s2 !== peg$FAILED) { + s3 = []; + s4 = peg$parsewhitespace(); + while (s4 !== peg$FAILED) { + s3.push(s4); + s4 = peg$parsewhitespace(); + } + peg$savedPos = s0; + s0 = peg$f8(); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = []; + s2 = peg$parsewhitespace(); + while (s2 !== peg$FAILED) { + s1.push(s2); + s2 = peg$parsewhitespace(); + } + s2 = peg$parsesubscript(); + if (s2 !== peg$FAILED) { + s3 = []; + s4 = peg$parsewhitespace(); + while (s4 !== peg$FAILED) { + s3.push(s4); + s4 = peg$parsewhitespace(); + } + peg$savedPos = s0; + s0 = peg$f9(); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$parseignore(); + if (s0 === peg$FAILED) { + s0 = peg$parsewhitespace(); + if (s0 === peg$FAILED) { + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s1 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$f10(s1); + } + s0 = s1; + } + } + } + } + } + } + } + } + } + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e5); + } + } + peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 }; + return s0; + } + function peg$parsenonchar_token() { + var s0; + var key = peg$currPos * 52 + 5; + var cached = peg$resultsCache[key]; + if (cached) { + peg$currPos = cached.nextPos; + return cached.result; + } + peg$silentFails++; + s0 = peg$parseescape(); + if (s0 === peg$FAILED) { + if (input.charCodeAt(peg$currPos) === 37) { + s0 = peg$c0; + peg$currPos++; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e7); + } + } + if (s0 === peg$FAILED) { + s0 = peg$parsebegin_group(); + if (s0 === peg$FAILED) { + s0 = peg$parseend_group(); + if (s0 === peg$FAILED) { + s0 = peg$parsemath_shift(); + if (s0 === peg$FAILED) { + s0 = peg$parsealignment_tab(); + if (s0 === peg$FAILED) { + s0 = peg$parsenl(); + if (s0 === peg$FAILED) { + s0 = peg$parsemacro_parameter(); + if (s0 === peg$FAILED) { + s0 = peg$parseignore(); + if (s0 === peg$FAILED) { + s0 = peg$parsesp(); + if (s0 === peg$FAILED) { + s0 = peg$parsepunctuation(); + if (s0 === peg$FAILED) { + s0 = peg$parseEOF(); + } + } + } + } + } + } + } + } + } + } + } + peg$silentFails--; + if (s0 === peg$FAILED) { + if (peg$silentFails === 0) { + peg$fail(peg$e6); + } + } + peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 }; + return s0; + } + function peg$parsewhitespace() { + var s0, s1, s2, s3, s4, s5, s6, s7; + var key = peg$currPos * 52 + 6; + var cached = peg$resultsCache[key]; + if (cached) { + peg$currPos = cached.nextPos; + return cached.result; + } + peg$silentFails++; + s0 = peg$currPos; + s1 = peg$currPos; + s2 = peg$parsenl(); + if (s2 !== peg$FAILED) { + s3 = []; + s4 = peg$parsesp(); + while (s4 !== peg$FAILED) { + s3.push(s4); + s4 = peg$parsesp(); + } + s2 = [s2, s3]; + s1 = s2; + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + if (s1 === peg$FAILED) { + s1 = peg$currPos; + s2 = []; + s3 = peg$parsesp(); + if (s3 !== peg$FAILED) { + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$parsesp(); + } + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s3 = peg$parsenl(); + if (s3 !== peg$FAILED) { + s4 = peg$currPos; + peg$silentFails++; + s5 = peg$parsecomment_start(); + peg$silentFails--; + if (s5 === peg$FAILED) { + s4 = void 0; + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + if (s4 !== peg$FAILED) { + s5 = []; + s6 = peg$parsesp(); + while (s6 !== peg$FAILED) { + s5.push(s6); + s6 = peg$parsesp(); + } + s6 = peg$currPos; + peg$silentFails++; + s7 = peg$parsenl(); + peg$silentFails--; + if (s7 === peg$FAILED) { + s6 = void 0; + } else { + peg$currPos = s6; + s6 = peg$FAILED; + } + if (s6 !== peg$FAILED) { + s2 = [s2, s3, s4, s5, s6]; + s1 = s2; + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + if (s1 === peg$FAILED) { + s1 = []; + s2 = peg$parsesp(); + if (s2 !== peg$FAILED) { + while (s2 !== peg$FAILED) { + s1.push(s2); + s2 = peg$parsesp(); + } + } else { + s1 = peg$FAILED; + } + } + } + if (s1 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$f11(); + } + s0 = s1; + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e8); + } + } + peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 }; + return s0; + } + function peg$parsenumber() { + var s0, s1, s2, s3, s4, s5; + var key = peg$currPos * 52 + 7; + var cached = peg$resultsCache[key]; + if (cached) { + peg$currPos = cached.nextPos; + return cached.result; + } + peg$silentFails++; + s0 = peg$currPos; + s1 = peg$currPos; + s2 = []; + s3 = peg$parsenum(); + if (s3 !== peg$FAILED) { + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$parsenum(); + } + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + if (input.charCodeAt(peg$currPos) === 46) { + s3 = peg$c1; + peg$currPos++; + } else { + s3 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e10); + } + } + if (s3 !== peg$FAILED) { + s4 = []; + s5 = peg$parsenum(); + if (s5 !== peg$FAILED) { + while (s5 !== peg$FAILED) { + s4.push(s5); + s5 = peg$parsenum(); + } + } else { + s4 = peg$FAILED; + } + if (s4 !== peg$FAILED) { + peg$savedPos = s1; + s1 = peg$f12(s2, s4); + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + if (s1 === peg$FAILED) { + s1 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 46) { + s2 = peg$c1; + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e10); + } + } + if (s2 !== peg$FAILED) { + s3 = []; + s4 = peg$parsenum(); + if (s4 !== peg$FAILED) { + while (s4 !== peg$FAILED) { + s3.push(s4); + s4 = peg$parsenum(); + } + } else { + s3 = peg$FAILED; + } + if (s3 !== peg$FAILED) { + peg$savedPos = s1; + s1 = peg$f13(s3); + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + if (s1 === peg$FAILED) { + s1 = peg$currPos; + s2 = []; + s3 = peg$parsenum(); + if (s3 !== peg$FAILED) { + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$parsenum(); + } + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + if (input.charCodeAt(peg$currPos) === 46) { + s3 = peg$c1; + peg$currPos++; + } else { + s3 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e10); + } + } + if (s3 !== peg$FAILED) { + peg$savedPos = s1; + s1 = peg$f14(s2); + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + } + } + if (s1 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$f15(s1); + } + s0 = s1; + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e9); + } + } + peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 }; + return s0; + } + function peg$parsespecial_macro() { + var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9; + var key = peg$currPos * 52 + 8; + var cached = peg$resultsCache[key]; + if (cached) { + peg$currPos = cached.nextPos; + return cached.result; + } + peg$silentFails++; + s0 = peg$currPos; + s1 = peg$parseescape(); + if (s1 !== peg$FAILED) { + if (input.substr(peg$currPos, 5) === peg$c2) { + s2 = peg$c2; + peg$currPos += 5; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e12); + } + } + if (s2 === peg$FAILED) { + if (input.substr(peg$currPos, 4) === peg$c3) { + s2 = peg$c3; + peg$currPos += 4; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e13); + } + } + } + if (s2 !== peg$FAILED) { + if (input.length > peg$currPos) { + s3 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s3 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s3 !== peg$FAILED) { + s4 = []; + s5 = peg$currPos; + s6 = peg$currPos; + peg$silentFails++; + s7 = peg$currPos; + if (input.length > peg$currPos) { + s8 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s8 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s8 !== peg$FAILED) { + peg$savedPos = peg$currPos; + s9 = peg$f16(s2, s3, s8); + if (s9) { + s9 = void 0; + } else { + s9 = peg$FAILED; + } + if (s9 !== peg$FAILED) { + s8 = [s8, s9]; + s7 = s8; + } else { + peg$currPos = s7; + s7 = peg$FAILED; + } + } else { + peg$currPos = s7; + s7 = peg$FAILED; + } + peg$silentFails--; + if (s7 === peg$FAILED) { + s6 = void 0; + } else { + peg$currPos = s6; + s6 = peg$FAILED; + } + if (s6 !== peg$FAILED) { + if (input.length > peg$currPos) { + s7 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s7 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s7 !== peg$FAILED) { + peg$savedPos = s5; + s5 = peg$f17(s2, s3, s7); + } else { + peg$currPos = s5; + s5 = peg$FAILED; + } + } else { + peg$currPos = s5; + s5 = peg$FAILED; + } + while (s5 !== peg$FAILED) { + s4.push(s5); + s5 = peg$currPos; + s6 = peg$currPos; + peg$silentFails++; + s7 = peg$currPos; + if (input.length > peg$currPos) { + s8 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s8 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s8 !== peg$FAILED) { + peg$savedPos = peg$currPos; + s9 = peg$f16(s2, s3, s8); + if (s9) { + s9 = void 0; + } else { + s9 = peg$FAILED; + } + if (s9 !== peg$FAILED) { + s8 = [s8, s9]; + s7 = s8; + } else { + peg$currPos = s7; + s7 = peg$FAILED; + } + } else { + peg$currPos = s7; + s7 = peg$FAILED; + } + peg$silentFails--; + if (s7 === peg$FAILED) { + s6 = void 0; + } else { + peg$currPos = s6; + s6 = peg$FAILED; + } + if (s6 !== peg$FAILED) { + if (input.length > peg$currPos) { + s7 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s7 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s7 !== peg$FAILED) { + peg$savedPos = s5; + s5 = peg$f17(s2, s3, s7); + } else { + peg$currPos = s5; + s5 = peg$FAILED; + } + } else { + peg$currPos = s5; + s5 = peg$FAILED; + } + } + s5 = peg$currPos; + if (input.length > peg$currPos) { + s6 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s6 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s6 !== peg$FAILED) { + peg$savedPos = peg$currPos; + s7 = peg$f18(s2, s3, s4, s6); + if (s7) { + s7 = void 0; + } else { + s7 = peg$FAILED; + } + if (s7 !== peg$FAILED) { + s6 = [s6, s7]; + s5 = s6; + } else { + peg$currPos = s5; + s5 = peg$FAILED; + } + } else { + peg$currPos = s5; + s5 = peg$FAILED; + } + if (s5 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f19(s2, s3, s4); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$parseverbatim_listings(); + if (s0 === peg$FAILED) { + s0 = peg$parseverbatim_minted(); + if (s0 === peg$FAILED) { + s0 = peg$parseverbatim_minted_environment(); + if (s0 === peg$FAILED) { + s0 = peg$parseverbatim_environment(); + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$parsebegin_display_math(); + if (s1 !== peg$FAILED) { + s2 = []; + s3 = peg$currPos; + s4 = peg$currPos; + peg$silentFails++; + s5 = peg$parseend_display_math(); + peg$silentFails--; + if (s5 === peg$FAILED) { + s4 = void 0; + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + if (s4 !== peg$FAILED) { + s5 = peg$parsemath_token(); + if (s5 !== peg$FAILED) { + peg$savedPos = s3; + s3 = peg$f20(s5); + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$currPos; + s4 = peg$currPos; + peg$silentFails++; + s5 = peg$parseend_display_math(); + peg$silentFails--; + if (s5 === peg$FAILED) { + s4 = void 0; + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + if (s4 !== peg$FAILED) { + s5 = peg$parsemath_token(); + if (s5 !== peg$FAILED) { + peg$savedPos = s3; + s3 = peg$f20(s5); + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } + s3 = peg$parseend_display_math(); + if (s3 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f21(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$parsebegin_inline_math(); + if (s1 !== peg$FAILED) { + s2 = []; + s3 = peg$currPos; + s4 = peg$currPos; + peg$silentFails++; + s5 = peg$parseend_inline_math(); + peg$silentFails--; + if (s5 === peg$FAILED) { + s4 = void 0; + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + if (s4 !== peg$FAILED) { + s5 = peg$parsemath_token(); + if (s5 !== peg$FAILED) { + peg$savedPos = s3; + s3 = peg$f22(s5); + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$currPos; + s4 = peg$currPos; + peg$silentFails++; + s5 = peg$parseend_inline_math(); + peg$silentFails--; + if (s5 === peg$FAILED) { + s4 = void 0; + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + if (s4 !== peg$FAILED) { + s5 = peg$parsemath_token(); + if (s5 !== peg$FAILED) { + peg$savedPos = s3; + s3 = peg$f22(s5); + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } + s3 = peg$parseend_inline_math(); + if (s3 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f23(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$parsemath_shift(); + if (s1 !== peg$FAILED) { + s2 = peg$parsemath_shift(); + if (s2 !== peg$FAILED) { + s3 = []; + s4 = peg$currPos; + s5 = peg$currPos; + peg$silentFails++; + s6 = peg$currPos; + s7 = peg$parsemath_shift(); + if (s7 !== peg$FAILED) { + s8 = peg$parsemath_shift(); + if (s8 !== peg$FAILED) { + s7 = [s7, s8]; + s6 = s7; + } else { + peg$currPos = s6; + s6 = peg$FAILED; + } + } else { + peg$currPos = s6; + s6 = peg$FAILED; + } + peg$silentFails--; + if (s6 === peg$FAILED) { + s5 = void 0; + } else { + peg$currPos = s5; + s5 = peg$FAILED; + } + if (s5 !== peg$FAILED) { + s6 = peg$parsemath_token(); + if (s6 !== peg$FAILED) { + peg$savedPos = s4; + s4 = peg$f24(s6); + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + while (s4 !== peg$FAILED) { + s3.push(s4); + s4 = peg$currPos; + s5 = peg$currPos; + peg$silentFails++; + s6 = peg$currPos; + s7 = peg$parsemath_shift(); + if (s7 !== peg$FAILED) { + s8 = peg$parsemath_shift(); + if (s8 !== peg$FAILED) { + s7 = [s7, s8]; + s6 = s7; + } else { + peg$currPos = s6; + s6 = peg$FAILED; + } + } else { + peg$currPos = s6; + s6 = peg$FAILED; + } + peg$silentFails--; + if (s6 === peg$FAILED) { + s5 = void 0; + } else { + peg$currPos = s5; + s5 = peg$FAILED; + } + if (s5 !== peg$FAILED) { + s6 = peg$parsemath_token(); + if (s6 !== peg$FAILED) { + peg$savedPos = s4; + s4 = peg$f24(s6); + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + } + s4 = peg$parsemath_shift(); + if (s4 !== peg$FAILED) { + s5 = peg$parsemath_shift(); + if (s5 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f25(s3); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$parsemath_environment(); + if (s0 === peg$FAILED) { + s0 = peg$parseenvironment(); + } + } + } + } + } + } + } + } + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e11); + } + } + peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 }; + return s0; + } + function peg$parsesquare_bracket_argument() { + var s0, s1, s2, s3, s4, s5, s6, s7; + var key = peg$currPos * 52 + 9; + var cached = peg$resultsCache[key]; + if (cached) { + peg$currPos = cached.nextPos; + return cached.result; + } + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 91) { + s1 = peg$c4; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e14); + } + } + if (s1 !== peg$FAILED) { + s2 = []; + s3 = peg$currPos; + s4 = peg$currPos; + peg$silentFails++; + s5 = peg$currPos; + s6 = peg$parsetoken(); + if (s6 !== peg$FAILED) { + peg$savedPos = peg$currPos; + s7 = peg$f26(s6); + if (s7) { + s7 = void 0; + } else { + s7 = peg$FAILED; + } + if (s7 !== peg$FAILED) { + s6 = [s6, s7]; + s5 = s6; + } else { + peg$currPos = s5; + s5 = peg$FAILED; + } + } else { + peg$currPos = s5; + s5 = peg$FAILED; + } + peg$silentFails--; + if (s5 === peg$FAILED) { + s4 = void 0; + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + if (s4 !== peg$FAILED) { + s5 = peg$parsetoken(); + if (s5 !== peg$FAILED) { + peg$savedPos = s3; + s3 = peg$f27(s5); + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$currPos; + s4 = peg$currPos; + peg$silentFails++; + s5 = peg$currPos; + s6 = peg$parsetoken(); + if (s6 !== peg$FAILED) { + peg$savedPos = peg$currPos; + s7 = peg$f26(s6); + if (s7) { + s7 = void 0; + } else { + s7 = peg$FAILED; + } + if (s7 !== peg$FAILED) { + s6 = [s6, s7]; + s5 = s6; + } else { + peg$currPos = s5; + s5 = peg$FAILED; + } + } else { + peg$currPos = s5; + s5 = peg$FAILED; + } + peg$silentFails--; + if (s5 === peg$FAILED) { + s4 = void 0; + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + if (s4 !== peg$FAILED) { + s5 = peg$parsetoken(); + if (s5 !== peg$FAILED) { + peg$savedPos = s3; + s3 = peg$f27(s5); + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } + if (input.charCodeAt(peg$currPos) === 93) { + s3 = peg$c5; + peg$currPos++; + } else { + s3 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e15); + } + } + if (s3 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f28(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 }; + return s0; + } + function peg$parseverbatim_group() { + var s0, s1, s2, s3, s4, s5; + var key = peg$currPos * 52 + 10; + var cached = peg$resultsCache[key]; + if (cached) { + peg$currPos = cached.nextPos; + return cached.result; + } + s0 = peg$currPos; + s1 = peg$parsebegin_group(); + if (s1 !== peg$FAILED) { + s2 = []; + s3 = peg$currPos; + s4 = peg$currPos; + peg$silentFails++; + s5 = peg$parseend_group(); + peg$silentFails--; + if (s5 === peg$FAILED) { + s4 = void 0; + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + if (s4 !== peg$FAILED) { + if (input.length > peg$currPos) { + s5 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s5 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s5 !== peg$FAILED) { + peg$savedPos = s3; + s3 = peg$f29(s5); + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$currPos; + s4 = peg$currPos; + peg$silentFails++; + s5 = peg$parseend_group(); + peg$silentFails--; + if (s5 === peg$FAILED) { + s4 = void 0; + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + if (s4 !== peg$FAILED) { + if (input.length > peg$currPos) { + s5 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s5 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s5 !== peg$FAILED) { + peg$savedPos = s3; + s3 = peg$f29(s5); + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } + s3 = peg$parseend_group(); + if (s3 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f30(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 }; + return s0; + } + function peg$parseverbatim_delimited_by_char() { + var s0, s1, s2, s3, s4, s5, s6, s7; + var key = peg$currPos * 52 + 11; + var cached = peg$resultsCache[key]; + if (cached) { + peg$currPos = cached.nextPos; + return cached.result; + } + s0 = peg$currPos; + if (peg$r0.test(input.charAt(peg$currPos))) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e16); + } + } + if (s1 !== peg$FAILED) { + s2 = []; + s3 = peg$currPos; + s4 = peg$currPos; + peg$silentFails++; + s5 = peg$currPos; + if (input.length > peg$currPos) { + s6 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s6 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s6 !== peg$FAILED) { + peg$savedPos = peg$currPos; + s7 = peg$f31(s1, s6); + if (s7) { + s7 = void 0; + } else { + s7 = peg$FAILED; + } + if (s7 !== peg$FAILED) { + s6 = [s6, s7]; + s5 = s6; + } else { + peg$currPos = s5; + s5 = peg$FAILED; + } + } else { + peg$currPos = s5; + s5 = peg$FAILED; + } + peg$silentFails--; + if (s5 === peg$FAILED) { + s4 = void 0; + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + if (s4 !== peg$FAILED) { + if (input.length > peg$currPos) { + s5 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s5 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s5 !== peg$FAILED) { + peg$savedPos = s3; + s3 = peg$f32(s1, s5); + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$currPos; + s4 = peg$currPos; + peg$silentFails++; + s5 = peg$currPos; + if (input.length > peg$currPos) { + s6 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s6 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s6 !== peg$FAILED) { + peg$savedPos = peg$currPos; + s7 = peg$f31(s1, s6); + if (s7) { + s7 = void 0; + } else { + s7 = peg$FAILED; + } + if (s7 !== peg$FAILED) { + s6 = [s6, s7]; + s5 = s6; + } else { + peg$currPos = s5; + s5 = peg$FAILED; + } + } else { + peg$currPos = s5; + s5 = peg$FAILED; + } + peg$silentFails--; + if (s5 === peg$FAILED) { + s4 = void 0; + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + if (s4 !== peg$FAILED) { + if (input.length > peg$currPos) { + s5 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s5 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s5 !== peg$FAILED) { + peg$savedPos = s3; + s3 = peg$f32(s1, s5); + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } + s3 = peg$currPos; + if (input.length > peg$currPos) { + s4 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s4 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s4 !== peg$FAILED) { + peg$savedPos = peg$currPos; + s5 = peg$f33(s1, s2, s4); + if (s5) { + s5 = void 0; + } else { + s5 = peg$FAILED; + } + if (s5 !== peg$FAILED) { + s4 = [s4, s5]; + s3 = s4; + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + if (s3 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f34(s1, s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 }; + return s0; + } + function peg$parseverbatim_listings() { + var s0, s1, s2, s3, s4; + var key = peg$currPos * 52 + 12; + var cached = peg$resultsCache[key]; + if (cached) { + peg$currPos = cached.nextPos; + return cached.result; + } + peg$silentFails++; + s0 = peg$currPos; + s1 = peg$parseescape(); + if (s1 !== peg$FAILED) { + if (input.substr(peg$currPos, 9) === peg$c6) { + s2 = peg$c6; + peg$currPos += 9; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e18); + } + } + if (s2 !== peg$FAILED) { + s3 = peg$parsesquare_bracket_argument(); + if (s3 === peg$FAILED) { + s3 = null; + } + s4 = peg$parseverbatim_group(); + if (s4 === peg$FAILED) { + s4 = peg$parseverbatim_delimited_by_char(); + } + if (s4 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f35(s2, s3, s4); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e17); + } + } + peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 }; + return s0; + } + function peg$parseverbatim_minted() { + var s0, s1, s2, s3, s4, s5; + var key = peg$currPos * 52 + 13; + var cached = peg$resultsCache[key]; + if (cached) { + peg$currPos = cached.nextPos; + return cached.result; + } + peg$silentFails++; + s0 = peg$currPos; + s1 = peg$parseescape(); + if (s1 !== peg$FAILED) { + if (input.substr(peg$currPos, 10) === peg$c7) { + s2 = peg$c7; + peg$currPos += 10; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e20); + } + } + if (s2 === peg$FAILED) { + if (input.substr(peg$currPos, 4) === peg$c8) { + s2 = peg$c8; + peg$currPos += 4; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e21); + } + } + } + if (s2 !== peg$FAILED) { + s3 = peg$parsesquare_bracket_argument(); + if (s3 === peg$FAILED) { + s3 = null; + } + s4 = peg$parsegroup(); + if (s4 !== peg$FAILED) { + s5 = peg$parseverbatim_group(); + if (s5 === peg$FAILED) { + s5 = peg$parseverbatim_delimited_by_char(); + } + if (s5 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f36(s2, s3, s4, s5); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e19); + } + } + peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 }; + return s0; + } + function peg$parseverbatim_minted_environment() { + var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14; + var key = peg$currPos * 52 + 14; + var cached = peg$resultsCache[key]; + if (cached) { + peg$currPos = cached.nextPos; + return cached.result; + } + peg$silentFails++; + s0 = peg$currPos; + s1 = peg$parsebegin_env(); + if (s1 !== peg$FAILED) { + s2 = peg$parsebegin_group(); + if (s2 !== peg$FAILED) { + if (input.substr(peg$currPos, 6) === peg$c9) { + s3 = peg$c9; + peg$currPos += 6; + } else { + s3 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e23); + } + } + if (s3 !== peg$FAILED) { + s4 = peg$parseend_group(); + if (s4 !== peg$FAILED) { + s5 = peg$parsesquare_bracket_argument(); + if (s5 === peg$FAILED) { + s5 = null; + } + s6 = peg$parsegroup(); + if (s6 !== peg$FAILED) { + s7 = peg$currPos; + s8 = []; + s9 = peg$currPos; + s10 = peg$currPos; + peg$silentFails++; + s11 = peg$currPos; + s12 = peg$parseend_env(); + if (s12 !== peg$FAILED) { + s13 = peg$parsegroup(); + if (s13 !== peg$FAILED) { + peg$savedPos = peg$currPos; + s14 = peg$f37(s3, s5, s6, s13); + if (s14) { + s14 = void 0; + } else { + s14 = peg$FAILED; + } + if (s14 !== peg$FAILED) { + s12 = [s12, s13, s14]; + s11 = s12; + } else { + peg$currPos = s11; + s11 = peg$FAILED; + } + } else { + peg$currPos = s11; + s11 = peg$FAILED; + } + } else { + peg$currPos = s11; + s11 = peg$FAILED; + } + peg$silentFails--; + if (s11 === peg$FAILED) { + s10 = void 0; + } else { + peg$currPos = s10; + s10 = peg$FAILED; + } + if (s10 !== peg$FAILED) { + if (input.length > peg$currPos) { + s11 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s11 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s11 !== peg$FAILED) { + s10 = [s10, s11]; + s9 = s10; + } else { + peg$currPos = s9; + s9 = peg$FAILED; + } + } else { + peg$currPos = s9; + s9 = peg$FAILED; + } + while (s9 !== peg$FAILED) { + s8.push(s9); + s9 = peg$currPos; + s10 = peg$currPos; + peg$silentFails++; + s11 = peg$currPos; + s12 = peg$parseend_env(); + if (s12 !== peg$FAILED) { + s13 = peg$parsegroup(); + if (s13 !== peg$FAILED) { + peg$savedPos = peg$currPos; + s14 = peg$f37(s3, s5, s6, s13); + if (s14) { + s14 = void 0; + } else { + s14 = peg$FAILED; + } + if (s14 !== peg$FAILED) { + s12 = [s12, s13, s14]; + s11 = s12; + } else { + peg$currPos = s11; + s11 = peg$FAILED; + } + } else { + peg$currPos = s11; + s11 = peg$FAILED; + } + } else { + peg$currPos = s11; + s11 = peg$FAILED; + } + peg$silentFails--; + if (s11 === peg$FAILED) { + s10 = void 0; + } else { + peg$currPos = s10; + s10 = peg$FAILED; + } + if (s10 !== peg$FAILED) { + if (input.length > peg$currPos) { + s11 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s11 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s11 !== peg$FAILED) { + s10 = [s10, s11]; + s9 = s10; + } else { + peg$currPos = s9; + s9 = peg$FAILED; + } + } else { + peg$currPos = s9; + s9 = peg$FAILED; + } + } + s7 = input.substring(s7, peg$currPos); + s8 = peg$parseend_env(); + if (s8 !== peg$FAILED) { + s9 = peg$parsebegin_group(); + if (s9 !== peg$FAILED) { + if (input.substr(peg$currPos, 6) === peg$c9) { + s10 = peg$c9; + peg$currPos += 6; + } else { + s10 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e23); + } + } + if (s10 !== peg$FAILED) { + s11 = peg$parseend_group(); + if (s11 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f38(s3, s5, s6, s7); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e22); + } + } + peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 }; + return s0; + } + function peg$parseverbatim_environment() { + var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12; + var key = peg$currPos * 52 + 15; + var cached = peg$resultsCache[key]; + if (cached) { + peg$currPos = cached.nextPos; + return cached.result; + } + peg$silentFails++; + s0 = peg$currPos; + s1 = peg$parsebegin_env(); + if (s1 !== peg$FAILED) { + s2 = peg$parsebegin_group(); + if (s2 !== peg$FAILED) { + s3 = peg$parseverbatim_env_name(); + if (s3 !== peg$FAILED) { + s4 = peg$parseend_group(); + if (s4 !== peg$FAILED) { + s5 = peg$currPos; + s6 = []; + s7 = peg$currPos; + s8 = peg$currPos; + peg$silentFails++; + s9 = peg$currPos; + s10 = peg$parseend_env(); + if (s10 !== peg$FAILED) { + s11 = peg$parsegroup(); + if (s11 !== peg$FAILED) { + peg$savedPos = peg$currPos; + s12 = peg$f39(s3, s11); + if (s12) { + s12 = void 0; + } else { + s12 = peg$FAILED; + } + if (s12 !== peg$FAILED) { + s10 = [s10, s11, s12]; + s9 = s10; + } else { + peg$currPos = s9; + s9 = peg$FAILED; + } + } else { + peg$currPos = s9; + s9 = peg$FAILED; + } + } else { + peg$currPos = s9; + s9 = peg$FAILED; + } + peg$silentFails--; + if (s9 === peg$FAILED) { + s8 = void 0; + } else { + peg$currPos = s8; + s8 = peg$FAILED; + } + if (s8 !== peg$FAILED) { + if (input.length > peg$currPos) { + s9 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s9 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s9 !== peg$FAILED) { + peg$savedPos = s7; + s7 = peg$f40(s3, s9); + } else { + peg$currPos = s7; + s7 = peg$FAILED; + } + } else { + peg$currPos = s7; + s7 = peg$FAILED; + } + while (s7 !== peg$FAILED) { + s6.push(s7); + s7 = peg$currPos; + s8 = peg$currPos; + peg$silentFails++; + s9 = peg$currPos; + s10 = peg$parseend_env(); + if (s10 !== peg$FAILED) { + s11 = peg$parsegroup(); + if (s11 !== peg$FAILED) { + peg$savedPos = peg$currPos; + s12 = peg$f39(s3, s11); + if (s12) { + s12 = void 0; + } else { + s12 = peg$FAILED; + } + if (s12 !== peg$FAILED) { + s10 = [s10, s11, s12]; + s9 = s10; + } else { + peg$currPos = s9; + s9 = peg$FAILED; + } + } else { + peg$currPos = s9; + s9 = peg$FAILED; + } + } else { + peg$currPos = s9; + s9 = peg$FAILED; + } + peg$silentFails--; + if (s9 === peg$FAILED) { + s8 = void 0; + } else { + peg$currPos = s8; + s8 = peg$FAILED; + } + if (s8 !== peg$FAILED) { + if (input.length > peg$currPos) { + s9 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s9 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s9 !== peg$FAILED) { + peg$savedPos = s7; + s7 = peg$f40(s3, s9); + } else { + peg$currPos = s7; + s7 = peg$FAILED; + } + } else { + peg$currPos = s7; + s7 = peg$FAILED; + } + } + s5 = input.substring(s5, peg$currPos); + s6 = peg$parseend_env(); + if (s6 !== peg$FAILED) { + s7 = peg$parsebegin_group(); + if (s7 !== peg$FAILED) { + s8 = peg$parseverbatim_env_name(); + if (s8 !== peg$FAILED) { + s9 = peg$parseend_group(); + if (s9 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f41(s3, s5); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e24); + } + } + peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 }; + return s0; + } + function peg$parseverbatim_env_name() { + var s0; + var key = peg$currPos * 52 + 16; + var cached = peg$resultsCache[key]; + if (cached) { + peg$currPos = cached.nextPos; + return cached.result; + } + if (input.substr(peg$currPos, 9) === peg$c10) { + s0 = peg$c10; + peg$currPos += 9; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e25); + } + } + if (s0 === peg$FAILED) { + if (input.substr(peg$currPos, 8) === peg$c11) { + s0 = peg$c11; + peg$currPos += 8; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e26); + } + } + if (s0 === peg$FAILED) { + if (input.substr(peg$currPos, 13) === peg$c12) { + s0 = peg$c12; + peg$currPos += 13; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e27); + } + } + if (s0 === peg$FAILED) { + if (input.substr(peg$currPos, 12) === peg$c13) { + s0 = peg$c13; + peg$currPos += 12; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e28); + } + } + if (s0 === peg$FAILED) { + if (input.substr(peg$currPos, 7) === peg$c14) { + s0 = peg$c14; + peg$currPos += 7; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e29); + } + } + if (s0 === peg$FAILED) { + if (input.substr(peg$currPos, 10) === peg$c15) { + s0 = peg$c15; + peg$currPos += 10; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e30); + } + } + } + } + } + } + } + peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 }; + return s0; + } + function peg$parsemacro() { + var s0, s1, s2, s3, s4; + var key = peg$currPos * 52 + 17; + var cached = peg$resultsCache[key]; + if (cached) { + peg$currPos = cached.nextPos; + return cached.result; + } + peg$silentFails++; + s0 = peg$currPos; + s1 = peg$currPos; + s2 = peg$parseescape(); + if (s2 !== peg$FAILED) { + s3 = []; + s4 = peg$parsechar(); + if (s4 !== peg$FAILED) { + while (s4 !== peg$FAILED) { + s3.push(s4); + s4 = peg$parsechar(); + } + } else { + s3 = peg$FAILED; + } + if (s3 !== peg$FAILED) { + peg$savedPos = s1; + s1 = peg$f42(s3); + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + if (s1 === peg$FAILED) { + s1 = peg$currPos; + s2 = peg$parseescape(); + if (s2 !== peg$FAILED) { + if (input.length > peg$currPos) { + s3 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s3 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s3 !== peg$FAILED) { + peg$savedPos = s1; + s1 = peg$f43(s3); + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + } + if (s1 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$f44(s1); + } + s0 = s1; + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e31); + } + } + peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 }; + return s0; + } + function peg$parsegroup() { + var s0, s1, s2, s3, s4, s5; + var key = peg$currPos * 52 + 18; + var cached = peg$resultsCache[key]; + if (cached) { + peg$currPos = cached.nextPos; + return cached.result; + } + peg$silentFails++; + s0 = peg$currPos; + s1 = peg$parsebegin_group(); + if (s1 !== peg$FAILED) { + s2 = []; + s3 = peg$currPos; + s4 = peg$currPos; + peg$silentFails++; + s5 = peg$parseend_group(); + peg$silentFails--; + if (s5 === peg$FAILED) { + s4 = void 0; + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + if (s4 !== peg$FAILED) { + s5 = peg$parsetoken(); + if (s5 !== peg$FAILED) { + peg$savedPos = s3; + s3 = peg$f45(s5); + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$currPos; + s4 = peg$currPos; + peg$silentFails++; + s5 = peg$parseend_group(); + peg$silentFails--; + if (s5 === peg$FAILED) { + s4 = void 0; + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + if (s4 !== peg$FAILED) { + s5 = peg$parsetoken(); + if (s5 !== peg$FAILED) { + peg$savedPos = s3; + s3 = peg$f45(s5); + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } + s3 = peg$parseend_group(); + if (s3 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f46(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e32); + } + } + peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 }; + return s0; + } + function peg$parsegroup_contents_as_string() { + var s0, s1; + var key = peg$currPos * 52 + 19; + var cached = peg$resultsCache[key]; + if (cached) { + peg$currPos = cached.nextPos; + return cached.result; + } + s0 = peg$currPos; + s1 = peg$parsegroup(); + if (s1 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$f47(); + } + s0 = s1; + peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 }; + return s0; + } + function peg$parseenvironment() { + var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10; + var key = peg$currPos * 52 + 20; + var cached = peg$resultsCache[key]; + if (cached) { + peg$currPos = cached.nextPos; + return cached.result; + } + peg$silentFails++; + s0 = peg$currPos; + s1 = peg$parsebegin_env(); + if (s1 !== peg$FAILED) { + s2 = peg$parsegroup_contents_as_string(); + if (s2 !== peg$FAILED) { + s3 = peg$parsesameline_comment(); + if (s3 === peg$FAILED) { + s3 = null; + } + s4 = []; + s5 = peg$currPos; + s6 = peg$currPos; + peg$silentFails++; + s7 = peg$currPos; + s8 = peg$parseend_env(); + if (s8 !== peg$FAILED) { + s9 = peg$parsegroup_contents_as_string(); + if (s9 !== peg$FAILED) { + peg$savedPos = peg$currPos; + s10 = peg$f48(s2, s3, s9); + if (s10) { + s10 = void 0; + } else { + s10 = peg$FAILED; + } + if (s10 !== peg$FAILED) { + s8 = [s8, s9, s10]; + s7 = s8; + } else { + peg$currPos = s7; + s7 = peg$FAILED; + } + } else { + peg$currPos = s7; + s7 = peg$FAILED; + } + } else { + peg$currPos = s7; + s7 = peg$FAILED; + } + peg$silentFails--; + if (s7 === peg$FAILED) { + s6 = void 0; + } else { + peg$currPos = s6; + s6 = peg$FAILED; + } + if (s6 !== peg$FAILED) { + s7 = peg$parsetoken(); + if (s7 !== peg$FAILED) { + peg$savedPos = s5; + s5 = peg$f49(s2, s3, s7); + } else { + peg$currPos = s5; + s5 = peg$FAILED; + } + } else { + peg$currPos = s5; + s5 = peg$FAILED; + } + while (s5 !== peg$FAILED) { + s4.push(s5); + s5 = peg$currPos; + s6 = peg$currPos; + peg$silentFails++; + s7 = peg$currPos; + s8 = peg$parseend_env(); + if (s8 !== peg$FAILED) { + s9 = peg$parsegroup_contents_as_string(); + if (s9 !== peg$FAILED) { + peg$savedPos = peg$currPos; + s10 = peg$f48(s2, s3, s9); + if (s10) { + s10 = void 0; + } else { + s10 = peg$FAILED; + } + if (s10 !== peg$FAILED) { + s8 = [s8, s9, s10]; + s7 = s8; + } else { + peg$currPos = s7; + s7 = peg$FAILED; + } + } else { + peg$currPos = s7; + s7 = peg$FAILED; + } + } else { + peg$currPos = s7; + s7 = peg$FAILED; + } + peg$silentFails--; + if (s7 === peg$FAILED) { + s6 = void 0; + } else { + peg$currPos = s6; + s6 = peg$FAILED; + } + if (s6 !== peg$FAILED) { + s7 = peg$parsetoken(); + if (s7 !== peg$FAILED) { + peg$savedPos = s5; + s5 = peg$f49(s2, s3, s7); + } else { + peg$currPos = s5; + s5 = peg$FAILED; + } + } else { + peg$currPos = s5; + s5 = peg$FAILED; + } + } + s5 = peg$parseend_env(); + if (s5 !== peg$FAILED) { + s6 = peg$parsegroup_contents_as_string(); + if (s6 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f50(s2, s3, s4); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e33); + } + } + peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 }; + return s0; + } + function peg$parsemath_environment() { + var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12; + var key = peg$currPos * 52 + 21; + var cached = peg$resultsCache[key]; + if (cached) { + peg$currPos = cached.nextPos; + return cached.result; + } + peg$silentFails++; + s0 = peg$currPos; + s1 = peg$parsebegin_env(); + if (s1 !== peg$FAILED) { + s2 = peg$parsebegin_group(); + if (s2 !== peg$FAILED) { + s3 = peg$parsemath_env_name(); + if (s3 !== peg$FAILED) { + s4 = peg$parseend_group(); + if (s4 !== peg$FAILED) { + s5 = peg$parsesameline_comment(); + if (s5 === peg$FAILED) { + s5 = null; + } + s6 = []; + s7 = peg$currPos; + s8 = peg$currPos; + peg$silentFails++; + s9 = peg$currPos; + s10 = peg$parseend_env(); + if (s10 !== peg$FAILED) { + s11 = peg$parsegroup(); + if (s11 !== peg$FAILED) { + peg$savedPos = peg$currPos; + s12 = peg$f51(s3, s5, s11); + if (s12) { + s12 = void 0; + } else { + s12 = peg$FAILED; + } + if (s12 !== peg$FAILED) { + s10 = [s10, s11, s12]; + s9 = s10; + } else { + peg$currPos = s9; + s9 = peg$FAILED; + } + } else { + peg$currPos = s9; + s9 = peg$FAILED; + } + } else { + peg$currPos = s9; + s9 = peg$FAILED; + } + peg$silentFails--; + if (s9 === peg$FAILED) { + s8 = void 0; + } else { + peg$currPos = s8; + s8 = peg$FAILED; + } + if (s8 !== peg$FAILED) { + s9 = peg$parsemath_token(); + if (s9 !== peg$FAILED) { + peg$savedPos = s7; + s7 = peg$f52(s3, s5, s9); + } else { + peg$currPos = s7; + s7 = peg$FAILED; + } + } else { + peg$currPos = s7; + s7 = peg$FAILED; + } + while (s7 !== peg$FAILED) { + s6.push(s7); + s7 = peg$currPos; + s8 = peg$currPos; + peg$silentFails++; + s9 = peg$currPos; + s10 = peg$parseend_env(); + if (s10 !== peg$FAILED) { + s11 = peg$parsegroup(); + if (s11 !== peg$FAILED) { + peg$savedPos = peg$currPos; + s12 = peg$f51(s3, s5, s11); + if (s12) { + s12 = void 0; + } else { + s12 = peg$FAILED; + } + if (s12 !== peg$FAILED) { + s10 = [s10, s11, s12]; + s9 = s10; + } else { + peg$currPos = s9; + s9 = peg$FAILED; + } + } else { + peg$currPos = s9; + s9 = peg$FAILED; + } + } else { + peg$currPos = s9; + s9 = peg$FAILED; + } + peg$silentFails--; + if (s9 === peg$FAILED) { + s8 = void 0; + } else { + peg$currPos = s8; + s8 = peg$FAILED; + } + if (s8 !== peg$FAILED) { + s9 = peg$parsemath_token(); + if (s9 !== peg$FAILED) { + peg$savedPos = s7; + s7 = peg$f52(s3, s5, s9); + } else { + peg$currPos = s7; + s7 = peg$FAILED; + } + } else { + peg$currPos = s7; + s7 = peg$FAILED; + } + } + s7 = peg$parseend_env(); + if (s7 !== peg$FAILED) { + s8 = peg$parsebegin_group(); + if (s8 !== peg$FAILED) { + s9 = peg$parsemath_env_name(); + if (s9 !== peg$FAILED) { + s10 = peg$parseend_group(); + if (s10 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f53(s3, s5, s6); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e34); + } + } + peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 }; + return s0; + } + function peg$parsebegin_display_math() { + var s0, s1, s2; + var key = peg$currPos * 52 + 23; + var cached = peg$resultsCache[key]; + if (cached) { + peg$currPos = cached.nextPos; + return cached.result; + } + s0 = peg$currPos; + s1 = peg$parseescape(); + if (s1 !== peg$FAILED) { + if (input.charCodeAt(peg$currPos) === 91) { + s2 = peg$c4; + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e14); + } + } + if (s2 !== peg$FAILED) { + s1 = [s1, s2]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 }; + return s0; + } + function peg$parseend_display_math() { + var s0, s1, s2; + var key = peg$currPos * 52 + 24; + var cached = peg$resultsCache[key]; + if (cached) { + peg$currPos = cached.nextPos; + return cached.result; + } + s0 = peg$currPos; + s1 = peg$parseescape(); + if (s1 !== peg$FAILED) { + if (input.charCodeAt(peg$currPos) === 93) { + s2 = peg$c5; + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e15); + } + } + if (s2 !== peg$FAILED) { + s1 = [s1, s2]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 }; + return s0; + } + function peg$parsebegin_inline_math() { + var s0, s1, s2; + var key = peg$currPos * 52 + 25; + var cached = peg$resultsCache[key]; + if (cached) { + peg$currPos = cached.nextPos; + return cached.result; + } + s0 = peg$currPos; + s1 = peg$parseescape(); + if (s1 !== peg$FAILED) { + if (input.charCodeAt(peg$currPos) === 40) { + s2 = peg$c16; + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e36); + } + } + if (s2 !== peg$FAILED) { + s1 = [s1, s2]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 }; + return s0; + } + function peg$parseend_inline_math() { + var s0, s1, s2; + var key = peg$currPos * 52 + 26; + var cached = peg$resultsCache[key]; + if (cached) { + peg$currPos = cached.nextPos; + return cached.result; + } + s0 = peg$currPos; + s1 = peg$parseescape(); + if (s1 !== peg$FAILED) { + if (input.charCodeAt(peg$currPos) === 41) { + s2 = peg$c17; + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e37); + } + } + if (s2 !== peg$FAILED) { + s1 = [s1, s2]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 }; + return s0; + } + function peg$parsebegin_env() { + var s0, s1, s2; + var key = peg$currPos * 52 + 27; + var cached = peg$resultsCache[key]; + if (cached) { + peg$currPos = cached.nextPos; + return cached.result; + } + s0 = peg$currPos; + s1 = peg$parseescape(); + if (s1 !== peg$FAILED) { + if (input.substr(peg$currPos, 5) === peg$c18) { + s2 = peg$c18; + peg$currPos += 5; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e38); + } + } + if (s2 !== peg$FAILED) { + s1 = [s1, s2]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 }; + return s0; + } + function peg$parseend_env() { + var s0, s1, s2; + var key = peg$currPos * 52 + 28; + var cached = peg$resultsCache[key]; + if (cached) { + peg$currPos = cached.nextPos; + return cached.result; + } + s0 = peg$currPos; + s1 = peg$parseescape(); + if (s1 !== peg$FAILED) { + if (input.substr(peg$currPos, 3) === peg$c19) { + s2 = peg$c19; + peg$currPos += 3; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e39); + } + } + if (s2 !== peg$FAILED) { + s1 = [s1, s2]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 }; + return s0; + } + function peg$parsemath_env_name() { + var s0, s1; + var key = peg$currPos * 52 + 29; + var cached = peg$resultsCache[key]; + if (cached) { + peg$currPos = cached.nextPos; + return cached.result; + } + s0 = peg$currPos; + if (input.substr(peg$currPos, 9) === peg$c20) { + s1 = peg$c20; + peg$currPos += 9; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e40); + } + } + if (s1 === peg$FAILED) { + if (input.substr(peg$currPos, 8) === peg$c21) { + s1 = peg$c21; + peg$currPos += 8; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e41); + } + } + if (s1 === peg$FAILED) { + if (input.substr(peg$currPos, 6) === peg$c22) { + s1 = peg$c22; + peg$currPos += 6; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e42); + } + } + if (s1 === peg$FAILED) { + if (input.substr(peg$currPos, 5) === peg$c23) { + s1 = peg$c23; + peg$currPos += 5; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e43); + } + } + if (s1 === peg$FAILED) { + if (input.substr(peg$currPos, 8) === peg$c24) { + s1 = peg$c24; + peg$currPos += 8; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e44); + } + } + if (s1 === peg$FAILED) { + if (input.substr(peg$currPos, 7) === peg$c25) { + s1 = peg$c25; + peg$currPos += 7; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e45); + } + } + if (s1 === peg$FAILED) { + if (input.substr(peg$currPos, 7) === peg$c26) { + s1 = peg$c26; + peg$currPos += 7; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e46); + } + } + if (s1 === peg$FAILED) { + if (input.substr(peg$currPos, 6) === peg$c27) { + s1 = peg$c27; + peg$currPos += 6; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e47); + } + } + if (s1 === peg$FAILED) { + if (input.substr(peg$currPos, 9) === peg$c28) { + s1 = peg$c28; + peg$currPos += 9; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e48); + } + } + if (s1 === peg$FAILED) { + if (input.substr(peg$currPos, 8) === peg$c29) { + s1 = peg$c29; + peg$currPos += 8; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e49); + } + } + if (s1 === peg$FAILED) { + if (input.substr(peg$currPos, 8) === peg$c30) { + s1 = peg$c30; + peg$currPos += 8; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e50); + } + } + if (s1 === peg$FAILED) { + if (input.substr(peg$currPos, 7) === peg$c31) { + s1 = peg$c31; + peg$currPos += 7; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e51); + } + } + if (s1 === peg$FAILED) { + if (input.substr(peg$currPos, 5) === peg$c32) { + s1 = peg$c32; + peg$currPos += 5; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e52); + } + } + if (s1 === peg$FAILED) { + if (input.substr(peg$currPos, 4) === peg$c33) { + s1 = peg$c33; + peg$currPos += 4; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e53); + } + } + if (s1 === peg$FAILED) { + if (input.substr(peg$currPos, 11) === peg$c34) { + s1 = peg$c34; + peg$currPos += 11; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e54); + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + if (s1 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$f56(s1); + } + s0 = s1; + peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 }; + return s0; + } + function peg$parseescape() { + var s0, s1; + var key = peg$currPos * 52 + 30; + var cached = peg$resultsCache[key]; + if (cached) { + peg$currPos = cached.nextPos; + return cached.result; + } + peg$silentFails++; + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 92) { + s1 = peg$c35; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e56); + } + } + if (s1 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$f57(); + } + s0 = s1; + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e55); + } + } + peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 }; + return s0; + } + function peg$parsebegin_group() { + var s0, s1; + var key = peg$currPos * 52 + 31; + var cached = peg$resultsCache[key]; + if (cached) { + peg$currPos = cached.nextPos; + return cached.result; + } + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 123) { + s1 = peg$c36; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e57); + } + } + if (s1 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$f58(s1); + } + s0 = s1; + peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 }; + return s0; + } + function peg$parseend_group() { + var s0, s1; + var key = peg$currPos * 52 + 32; + var cached = peg$resultsCache[key]; + if (cached) { + peg$currPos = cached.nextPos; + return cached.result; + } + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 125) { + s1 = peg$c37; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e58); + } + } + if (s1 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$f59(s1); + } + s0 = s1; + peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 }; + return s0; + } + function peg$parsemath_shift() { + var s0, s1; + var key = peg$currPos * 52 + 33; + var cached = peg$resultsCache[key]; + if (cached) { + peg$currPos = cached.nextPos; + return cached.result; + } + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 36) { + s1 = peg$c38; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e59); + } + } + if (s1 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$f60(s1); + } + s0 = s1; + peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 }; + return s0; + } + function peg$parsealignment_tab() { + var s0, s1; + var key = peg$currPos * 52 + 34; + var cached = peg$resultsCache[key]; + if (cached) { + peg$currPos = cached.nextPos; + return cached.result; + } + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 38) { + s1 = peg$c39; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e60); + } + } + if (s1 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$f61(s1); + } + s0 = s1; + peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 }; + return s0; + } + function peg$parsenl() { + var s0, s1, s2; + var key = peg$currPos * 52 + 35; + var cached = peg$resultsCache[key]; + if (cached) { + peg$currPos = cached.nextPos; + return cached.result; + } + peg$silentFails++; + s0 = peg$currPos; + s1 = peg$currPos; + peg$silentFails++; + if (input.charCodeAt(peg$currPos) === 13) { + s2 = peg$c40; + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e62); + } + } + peg$silentFails--; + if (s2 === peg$FAILED) { + s1 = void 0; + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + if (s1 !== peg$FAILED) { + if (input.charCodeAt(peg$currPos) === 10) { + s2 = peg$c41; + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e63); + } + } + if (s2 !== peg$FAILED) { + s1 = [s1, s2]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + if (input.charCodeAt(peg$currPos) === 13) { + s0 = peg$c40; + peg$currPos++; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e62); + } + } + if (s0 === peg$FAILED) { + if (input.substr(peg$currPos, 2) === peg$c42) { + s0 = peg$c42; + peg$currPos += 2; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e64); + } + } + } + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e61); + } + } + peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 }; + return s0; + } + function peg$parsemacro_parameter() { + var s0, s1; + var key = peg$currPos * 52 + 36; + var cached = peg$resultsCache[key]; + if (cached) { + peg$currPos = cached.nextPos; + return cached.result; + } + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 35) { + s1 = peg$c43; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e65); + } + } + if (s1 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$f62(s1); + } + s0 = s1; + peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 }; + return s0; + } + function peg$parsesuperscript() { + var s0, s1; + var key = peg$currPos * 52 + 37; + var cached = peg$resultsCache[key]; + if (cached) { + peg$currPos = cached.nextPos; + return cached.result; + } + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 94) { + s1 = peg$c44; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e66); + } + } + if (s1 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$f63(s1); + } + s0 = s1; + peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 }; + return s0; + } + function peg$parsesubscript() { + var s0, s1; + var key = peg$currPos * 52 + 38; + var cached = peg$resultsCache[key]; + if (cached) { + peg$currPos = cached.nextPos; + return cached.result; + } + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 95) { + s1 = peg$c45; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e67); + } + } + if (s1 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$f64(s1); + } + s0 = s1; + peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 }; + return s0; + } + function peg$parseignore() { + var s0; + var key = peg$currPos * 52 + 39; + var cached = peg$resultsCache[key]; + if (cached) { + peg$currPos = cached.nextPos; + return cached.result; + } + if (input.charCodeAt(peg$currPos) === 0) { + s0 = peg$c46; + peg$currPos++; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e68); + } + } + peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 }; + return s0; + } + function peg$parsesp() { + var s0, s1, s2; + var key = peg$currPos * 52 + 40; + var cached = peg$resultsCache[key]; + if (cached) { + peg$currPos = cached.nextPos; + return cached.result; + } + peg$silentFails++; + s0 = peg$currPos; + s1 = []; + if (peg$r1.test(input.charAt(peg$currPos))) { + s2 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e69); + } + } + if (s2 !== peg$FAILED) { + while (s2 !== peg$FAILED) { + s1.push(s2); + if (peg$r1.test(input.charAt(peg$currPos))) { + s2 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e69); + } + } + } + } else { + s1 = peg$FAILED; + } + if (s1 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$f65(); + } + s0 = s1; + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e8); + } + } + peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 }; + return s0; + } + function peg$parsechar() { + var s0; + var key = peg$currPos * 52 + 41; + var cached = peg$resultsCache[key]; + if (cached) { + peg$currPos = cached.nextPos; + return cached.result; + } + peg$silentFails++; + if (peg$r2.test(input.charAt(peg$currPos))) { + s0 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e71); + } + } + peg$silentFails--; + if (s0 === peg$FAILED) { + if (peg$silentFails === 0) { + peg$fail(peg$e70); + } + } + peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 }; + return s0; + } + function peg$parsenum() { + var s0; + var key = peg$currPos * 52 + 42; + var cached = peg$resultsCache[key]; + if (cached) { + peg$currPos = cached.nextPos; + return cached.result; + } + peg$silentFails++; + if (peg$r3.test(input.charAt(peg$currPos))) { + s0 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e73); + } + } + peg$silentFails--; + if (s0 === peg$FAILED) { + if (peg$silentFails === 0) { + peg$fail(peg$e72); + } + } + peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 }; + return s0; + } + function peg$parsepunctuation() { + var s0, s1; + var key = peg$currPos * 52 + 43; + var cached = peg$resultsCache[key]; + if (cached) { + peg$currPos = cached.nextPos; + return cached.result; + } + peg$silentFails++; + s0 = peg$currPos; + if (peg$r4.test(input.charAt(peg$currPos))) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e75); + } + } + if (s1 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$f66(s1); + } + s0 = s1; + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e74); + } + } + peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 }; + return s0; + } + function peg$parsecomment_start() { + var s0; + var key = peg$currPos * 52 + 44; + var cached = peg$resultsCache[key]; + if (cached) { + peg$currPos = cached.nextPos; + return cached.result; + } + if (input.charCodeAt(peg$currPos) === 37) { + s0 = peg$c0; + peg$currPos++; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e7); + } + } + peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 }; + return s0; + } + function peg$parsefull_comment() { + var s0; + var key = peg$currPos * 52 + 45; + var cached = peg$resultsCache[key]; + if (cached) { + peg$currPos = cached.nextPos; + return cached.result; + } + peg$silentFails++; + s0 = peg$parseownline_comment(); + if (s0 === peg$FAILED) { + s0 = peg$parsesameline_comment(); + } + peg$silentFails--; + if (s0 === peg$FAILED) { + if (peg$silentFails === 0) { + peg$fail(peg$e76); + } + } + peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 }; + return s0; + } + function peg$parseownline_comment() { + var s0, s1, s2, s3; + var key = peg$currPos * 52 + 46; + var cached = peg$resultsCache[key]; + if (cached) { + peg$currPos = cached.nextPos; + return cached.result; + } + s0 = peg$currPos; + s1 = peg$currPos; + s2 = []; + s3 = peg$parsesp(); + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$parsesp(); + } + s3 = peg$parsenl(); + if (s3 !== peg$FAILED) { + s2 = [s2, s3]; + s1 = s2; + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + if (s1 === peg$FAILED) { + s1 = null; + } + s2 = peg$parseleading_sp(); + if (s2 !== peg$FAILED) { + s3 = peg$parsecomment(); + if (s3 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f67(s2, s3); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 }; + return s0; + } + function peg$parsesameline_comment() { + var s0, s1, s2; + var key = peg$currPos * 52 + 47; + var cached = peg$resultsCache[key]; + if (cached) { + peg$currPos = cached.nextPos; + return cached.result; + } + s0 = peg$currPos; + s1 = []; + s2 = peg$parsesp(); + while (s2 !== peg$FAILED) { + s1.push(s2); + s2 = peg$parsesp(); + } + s2 = peg$parsecomment(); + if (s2 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f68(s1, s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 }; + return s0; + } + function peg$parsecomment() { + var s0, s1, s2, s3, s4, s5, s6, s7; + var key = peg$currPos * 52 + 48; + var cached = peg$resultsCache[key]; + if (cached) { + peg$currPos = cached.nextPos; + return cached.result; + } + peg$silentFails++; + s0 = peg$currPos; + s1 = peg$parsecomment_start(); + if (s1 !== peg$FAILED) { + s2 = []; + s3 = peg$currPos; + s4 = peg$currPos; + peg$silentFails++; + s5 = peg$parsenl(); + peg$silentFails--; + if (s5 === peg$FAILED) { + s4 = void 0; + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + if (s4 !== peg$FAILED) { + if (input.length > peg$currPos) { + s5 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s5 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s5 !== peg$FAILED) { + peg$savedPos = s3; + s3 = peg$f69(s5); + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$currPos; + s4 = peg$currPos; + peg$silentFails++; + s5 = peg$parsenl(); + peg$silentFails--; + if (s5 === peg$FAILED) { + s4 = void 0; + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + if (s4 !== peg$FAILED) { + if (input.length > peg$currPos) { + s5 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s5 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s5 !== peg$FAILED) { + peg$savedPos = s3; + s3 = peg$f69(s5); + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } + s3 = peg$currPos; + peg$silentFails++; + s4 = peg$parseparbreak(); + peg$silentFails--; + if (s4 !== peg$FAILED) { + peg$currPos = s3; + s3 = void 0; + } else { + s3 = peg$FAILED; + } + if (s3 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f70(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$parsecomment_start(); + if (s1 !== peg$FAILED) { + s2 = []; + s3 = peg$currPos; + s4 = peg$currPos; + peg$silentFails++; + s5 = peg$parsenl(); + peg$silentFails--; + if (s5 === peg$FAILED) { + s4 = void 0; + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + if (s4 !== peg$FAILED) { + if (input.length > peg$currPos) { + s5 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s5 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s5 !== peg$FAILED) { + peg$savedPos = s3; + s3 = peg$f71(s5); + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$currPos; + s4 = peg$currPos; + peg$silentFails++; + s5 = peg$parsenl(); + peg$silentFails--; + if (s5 === peg$FAILED) { + s4 = void 0; + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + if (s4 !== peg$FAILED) { + if (input.length > peg$currPos) { + s5 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s5 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s5 !== peg$FAILED) { + peg$savedPos = s3; + s3 = peg$f71(s5); + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } + s3 = peg$currPos; + s4 = peg$parsenl(); + if (s4 !== peg$FAILED) { + s5 = []; + s6 = peg$parsesp(); + while (s6 !== peg$FAILED) { + s5.push(s6); + s6 = peg$parsesp(); + } + s6 = peg$currPos; + peg$silentFails++; + s7 = peg$parsecomment_start(); + peg$silentFails--; + if (s7 === peg$FAILED) { + s6 = void 0; + } else { + peg$currPos = s6; + s6 = peg$FAILED; + } + if (s6 !== peg$FAILED) { + s4 = [s4, s5, s6]; + s3 = s4; + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + if (s3 === peg$FAILED) { + s3 = peg$parsenl(); + if (s3 === peg$FAILED) { + s3 = peg$parseEOF(); + } + } + if (s3 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f72(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e77); + } + } + peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 }; + return s0; + } + function peg$parseleading_sp() { + var s0, s1, s2, s3, s4; + var key = peg$currPos * 52 + 49; + var cached = peg$resultsCache[key]; + if (cached) { + peg$currPos = cached.nextPos; + return cached.result; + } + s0 = peg$currPos; + s1 = peg$currPos; + s2 = peg$parsestart_of_line(); + if (s2 !== peg$FAILED) { + s3 = []; + s4 = peg$parsesp(); + while (s4 !== peg$FAILED) { + s3.push(s4); + s4 = peg$parsesp(); + } + s2 = [s2, s3]; + s1 = s2; + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + if (s1 !== peg$FAILED) { + s0 = input.substring(s0, peg$currPos); + } else { + s0 = s1; + } + peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 }; + return s0; + } + function peg$parsestart_of_line() { + var s0; + var key = peg$currPos * 52 + 50; + var cached = peg$resultsCache[key]; + if (cached) { + peg$currPos = cached.nextPos; + return cached.result; + } + peg$savedPos = peg$currPos; + s0 = peg$f73(); + if (s0) { + s0 = void 0; + } else { + s0 = peg$FAILED; + } + peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 }; + return s0; + } + function peg$parseEOF() { + var s0, s1; + var key = peg$currPos * 52 + 51; + var cached = peg$resultsCache[key]; + if (cached) { + peg$currPos = cached.nextPos; + return cached.result; + } + s0 = peg$currPos; + peg$silentFails++; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + peg$silentFails--; + if (s1 === peg$FAILED) { + s0 = void 0; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 }; + return s0; + } + function toString(e) { + if (typeof e === "string") { + return e; + } + if (typeof e.content === "string") { + return e.content; + } + if (e && e.type === "whitespace") { + return " "; + } + return e; + } + function compare_env(g1, g2) { + const g1Name = typeof g1 === "string" ? g1 : g1.content.map(toString).join(""); + const g2Name = typeof g2 === "string" ? g2 : g2.content.map(toString).join(""); + return g1Name === g2Name; + } + function createNode(type, extra = {}) { + return { type, ...extra, position: location() }; + } + peg$result = peg$startRuleFunction(); + if (peg$result !== peg$FAILED && peg$currPos === input.length) { + return peg$result; + } else { + if (peg$result !== peg$FAILED && peg$currPos < input.length) { + peg$fail(peg$endExpectation()); + } + throw peg$buildStructuredError( + peg$maxFailExpected, + peg$maxFailPos < input.length ? input.charAt(peg$maxFailPos) : null, + peg$maxFailPos < input.length ? peg$computeLocation(peg$maxFailPos, peg$maxFailPos + 1) : peg$computeLocation(peg$maxFailPos, peg$maxFailPos) + ); + } + } + return { + SyntaxError: peg$SyntaxError, + parse: peg$parse + }; + }() +); +const _AlignEnvironmentPegParser = ( + // Generated by Peggy 3.0.2. + // + // https://peggyjs.org/ + function() { + function peg$subclass(child, parent) { + function C() { + this.constructor = child; + } + C.prototype = parent.prototype; + child.prototype = new C(); + } + function peg$SyntaxError(message, expected, found, location) { + var self = Error.call(this, message); + if (Object.setPrototypeOf) { + Object.setPrototypeOf(self, peg$SyntaxError.prototype); + } + self.expected = expected; + self.found = found; + self.location = location; + self.name = "SyntaxError"; + return self; + } + peg$subclass(peg$SyntaxError, Error); + function peg$padEnd(str, targetLength, padString) { + padString = padString || " "; + if (str.length > targetLength) { + return str; + } + targetLength -= str.length; + padString += padString.repeat(targetLength); + return str + padString.slice(0, targetLength); + } + peg$SyntaxError.prototype.format = function(sources) { + var str = "Error: " + this.message; + if (this.location) { + var src = null; + var k; + for (k = 0; k < sources.length; k++) { + if (sources[k].source === this.location.source) { + src = sources[k].text.split(/\r\n|\n|\r/g); + break; + } + } + var s = this.location.start; + var offset_s = this.location.source && typeof this.location.source.offset === "function" ? this.location.source.offset(s) : s; + var loc = this.location.source + ":" + offset_s.line + ":" + offset_s.column; + if (src) { + var e = this.location.end; + var filler = peg$padEnd("", offset_s.line.toString().length, " "); + var line = src[s.line - 1]; + var last = s.line === e.line ? e.column : line.length + 1; + var hatLen = last - s.column || 1; + str += "\n --> " + loc + "\n" + filler + " |\n" + offset_s.line + " | " + line + "\n" + filler + " | " + peg$padEnd("", s.column - 1, " ") + peg$padEnd("", hatLen, "^"); + } else { + str += "\n at " + loc; + } + } + return str; + }; + peg$SyntaxError.buildMessage = function(expected, found) { + var DESCRIBE_EXPECTATION_FNS = { + literal: function(expectation) { + return '"' + literalEscape(expectation.text) + '"'; + }, + class: function(expectation) { + var escapedParts = expectation.parts.map(function(part) { + return Array.isArray(part) ? classEscape(part[0]) + "-" + classEscape(part[1]) : classEscape(part); + }); + return "[" + (expectation.inverted ? "^" : "") + escapedParts.join("") + "]"; + }, + any: function() { + return "any character"; + }, + end: function() { + return "end of input"; + }, + other: function(expectation) { + return expectation.description; + } + }; + function hex(ch) { + return ch.charCodeAt(0).toString(16).toUpperCase(); + } + function literalEscape(s) { + return s.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\0/g, "\\0").replace(/\t/g, "\\t").replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/[\x00-\x0F]/g, function(ch) { + return "\\x0" + hex(ch); + }).replace(/[\x10-\x1F\x7F-\x9F]/g, function(ch) { + return "\\x" + hex(ch); + }); + } + function classEscape(s) { + return s.replace(/\\/g, "\\\\").replace(/\]/g, "\\]").replace(/\^/g, "\\^").replace(/-/g, "\\-").replace(/\0/g, "\\0").replace(/\t/g, "\\t").replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/[\x00-\x0F]/g, function(ch) { + return "\\x0" + hex(ch); + }).replace(/[\x10-\x1F\x7F-\x9F]/g, function(ch) { + return "\\x" + hex(ch); + }); + } + function describeExpectation(expectation) { + return DESCRIBE_EXPECTATION_FNS[expectation.type](expectation); + } + function describeExpected(expected2) { + var descriptions = expected2.map(describeExpectation); + var i, j; + descriptions.sort(); + if (descriptions.length > 0) { + for (i = 1, j = 1; i < descriptions.length; i++) { + if (descriptions[i - 1] !== descriptions[i]) { + descriptions[j] = descriptions[i]; + j++; + } + } + descriptions.length = j; + } + switch (descriptions.length) { + case 1: + return descriptions[0]; + case 2: + return descriptions[0] + " or " + descriptions[1]; + default: + return descriptions.slice(0, -1).join(", ") + ", or " + descriptions[descriptions.length - 1]; + } + } + function describeFound(found2) { + return found2 ? '"' + literalEscape(found2) + '"' : "end of input"; + } + return "Expected " + describeExpected(expected) + " but " + describeFound(found) + " found."; + }; + function peg$parse(input, options) { + options = options !== void 0 ? options : {}; + var peg$FAILED = {}; + var peg$source = options.grammarSource; + var peg$startRuleFunctions = { body: peg$parsebody }; + var peg$startRuleFunction = peg$parsebody; + var peg$e0 = peg$anyExpectation(); + var peg$f0 = function() { + return []; + }; + var peg$f1 = function(x) { + return { cells: [], colSeps: [], ...x }; + }; + var peg$f2 = function(rowItems, rowSep, trailingComment) { + return { ...rowItems, rowSep, trailingComment }; + }; + var peg$f3 = function(rowItems, trailingComment) { + return { ...rowItems, rowSep: null, trailingComment }; + }; + var peg$f4 = function(x) { + return x; + }; + var peg$f5 = function(x) { + return { + cells: [], + colSeps: [], + rowSep: null, + trailingComment: x + }; + }; + var peg$f6 = function(x) { + return x; + }; + var peg$f7 = function(colSep, cell) { + return { colSep, cell }; + }; + var peg$f8 = function(colSep) { + return { colSep }; + }; + var peg$f9 = function(a, b) { + return processRow(a, b); + }; + var peg$f10 = function(b) { + return processRow(null, b); + }; + var peg$f11 = function(tok) { + return options.isSameLineComment(tok); + }; + var peg$f12 = function(tok) { + return tok; + }; + var peg$f13 = function(tok) { + return options.isOwnLineComment(tok); + }; + var peg$f14 = function(tok) { + return tok; + }; + var peg$f15 = function(tok) { + return options.isWhitespace(tok); + }; + var peg$f16 = function(tok) { + return tok; + }; + var peg$f17 = function(tok) { + return options.isRowSep(tok); + }; + var peg$f18 = function(tok) { + return tok; + }; + var peg$f19 = function(tok) { + return options.isColSep(tok); + }; + var peg$f20 = function(tok) { + return tok; + }; + var peg$currPos = 0; + var peg$posDetailsCache = [{ line: 1, column: 1 }]; + var peg$maxFailPos = 0; + var peg$maxFailExpected = []; + var peg$silentFails = 0; + var peg$result; + if ("startRule" in options) { + if (!(options.startRule in peg$startRuleFunctions)) { + throw new Error(`Can't start parsing from rule "` + options.startRule + '".'); + } + peg$startRuleFunction = peg$startRuleFunctions[options.startRule]; + } + function peg$anyExpectation() { + return { type: "any" }; + } + function peg$endExpectation() { + return { type: "end" }; + } + function peg$computePosDetails(pos) { + var details = peg$posDetailsCache[pos]; + var p; + if (details) { + return details; + } else { + p = pos - 1; + while (!peg$posDetailsCache[p]) { + p--; + } + details = peg$posDetailsCache[p]; + details = { + line: details.line, + column: details.column + }; + while (p < pos) { + if (input.charCodeAt(p) === 10) { + details.line++; + details.column = 1; + } else { + details.column++; + } + p++; + } + peg$posDetailsCache[pos] = details; + return details; + } + } + function peg$computeLocation(startPos, endPos, offset2) { + var startPosDetails = peg$computePosDetails(startPos); + var endPosDetails = peg$computePosDetails(endPos); + var res = { + source: peg$source, + start: { + offset: startPos, + line: startPosDetails.line, + column: startPosDetails.column + }, + end: { + offset: endPos, + line: endPosDetails.line, + column: endPosDetails.column + } + }; + return res; + } + function peg$fail(expected2) { + if (peg$currPos < peg$maxFailPos) { + return; + } + if (peg$currPos > peg$maxFailPos) { + peg$maxFailPos = peg$currPos; + peg$maxFailExpected = []; + } + peg$maxFailExpected.push(expected2); + } + function peg$buildStructuredError(expected2, found, location2) { + return new peg$SyntaxError( + peg$SyntaxError.buildMessage(expected2, found), + expected2, + found, + location2 + ); + } + function peg$parsebody() { + var s0, s1; + s0 = []; + s1 = peg$parsecomment_only_line(); + if (s1 === peg$FAILED) { + s1 = peg$parserow_with_end(); + if (s1 === peg$FAILED) { + s1 = peg$parserow_without_end(); + } + } + if (s1 !== peg$FAILED) { + while (s1 !== peg$FAILED) { + s0.push(s1); + s1 = peg$parsecomment_only_line(); + if (s1 === peg$FAILED) { + s1 = peg$parserow_with_end(); + if (s1 === peg$FAILED) { + s1 = peg$parserow_without_end(); + } + } + } + } else { + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$parseEOL(); + if (s1 !== peg$FAILED) { + s1 = peg$f0(); + } + s0 = s1; + } + return s0; + } + function peg$parserow_with_end() { + var s0, s1, s2, s3; + s0 = peg$currPos; + s1 = peg$currPos; + s2 = peg$parserow_items(); + if (s2 === peg$FAILED) { + s2 = null; + } + s2 = peg$f1(s2); + s1 = s2; + s2 = peg$parserow_sep(); + if (s2 !== peg$FAILED) { + s3 = peg$parsetrailing_comment(); + if (s3 === peg$FAILED) { + s3 = null; + } + s0 = peg$f2(s1, s2, s3); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parserow_without_end() { + var s0, s1, s2; + s0 = peg$currPos; + s1 = peg$parserow_items(); + if (s1 !== peg$FAILED) { + s2 = peg$parsetrailing_comment(); + if (s2 === peg$FAILED) { + s2 = null; + } + s0 = peg$f3(s1, s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsetrailing_comment() { + var s0, s1, s2; + s0 = peg$currPos; + s1 = []; + s2 = peg$parsewhitespace(); + while (s2 !== peg$FAILED) { + s1.push(s2); + s2 = peg$parsewhitespace(); + } + s2 = peg$parsesame_line_comment(); + if (s2 !== peg$FAILED) { + s0 = peg$f4(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsecomment_only_line() { + var s0, s1, s2; + s0 = peg$currPos; + s1 = []; + s2 = peg$parsewhitespace(); + while (s2 !== peg$FAILED) { + s1.push(s2); + s2 = peg$parsewhitespace(); + } + s2 = peg$parseown_line_comment(); + if (s2 !== peg$FAILED) { + s0 = peg$f5(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsetoken() { + var s0, s1, s2; + s0 = peg$currPos; + s1 = peg$currPos; + peg$silentFails++; + s2 = peg$parserow_sep(); + if (s2 === peg$FAILED) { + s2 = peg$parsecol_sep(); + if (s2 === peg$FAILED) { + s2 = peg$parsetrailing_comment(); + if (s2 === peg$FAILED) { + s2 = peg$parseown_line_comment(); + } + } + } + peg$silentFails--; + if (s2 === peg$FAILED) { + s1 = void 0; + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + if (s1 !== peg$FAILED) { + if (input.length > peg$currPos) { + s2 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s2 !== peg$FAILED) { + s0 = peg$f6(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsecell() { + var s0, s1, s2; + s0 = peg$currPos; + s1 = []; + s2 = peg$parsetoken(); + if (s2 !== peg$FAILED) { + while (s2 !== peg$FAILED) { + s1.push(s2); + s2 = peg$parsetoken(); + } + } else { + s1 = peg$FAILED; + } + if (s1 !== peg$FAILED) { + s0 = input.substring(s0, peg$currPos); + } else { + s0 = s1; + } + return s0; + } + function peg$parseseparated_cell() { + var s0, s1, s2; + s0 = peg$currPos; + s1 = peg$parsecol_sep(); + if (s1 !== peg$FAILED) { + s2 = peg$parsecell(); + if (s2 !== peg$FAILED) { + s0 = peg$f7(s1, s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$parsecol_sep(); + if (s1 !== peg$FAILED) { + s1 = peg$f8(s1); + } + s0 = s1; + } + return s0; + } + function peg$parserow_items() { + var s0, s1, s2, s3; + s0 = peg$currPos; + s1 = peg$parsecell(); + if (s1 !== peg$FAILED) { + s2 = []; + s3 = peg$parseseparated_cell(); + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$parseseparated_cell(); + } + s0 = peg$f9(s1, s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = []; + s2 = peg$parseseparated_cell(); + if (s2 !== peg$FAILED) { + while (s2 !== peg$FAILED) { + s1.push(s2); + s2 = peg$parseseparated_cell(); + } + } else { + s1 = peg$FAILED; + } + if (s1 !== peg$FAILED) { + s1 = peg$f10(s1); + } + s0 = s1; + } + return s0; + } + function peg$parsesame_line_comment() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f11(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s0 = peg$f12(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parseown_line_comment() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f13(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s0 = peg$f14(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsewhitespace() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f15(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s0 = peg$f16(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parserow_sep() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f17(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s0 = peg$f18(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsecol_sep() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f19(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s0 = peg$f20(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parseEOL() { + var s0, s1; + s0 = peg$currPos; + peg$silentFails++; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + peg$silentFails--; + if (s1 === peg$FAILED) { + s0 = void 0; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function processRow(leadCell, otherCells) { + const cells = [leadCell || []]; + const seps = []; + for (const x of otherCells) { + cells.push(x.cell || []); + seps.push(x.colSep); + } + return { cells, colSeps: seps }; + } + if (!options.isWhitespace) { + try { + Object.assign( + options, + createMatchers(["\\", "hline", "cr"], ["&"]) + ); + } catch (e) { + console.warn("Error when initializing parser", e); + } + } + peg$result = peg$startRuleFunction(); + if (peg$result !== peg$FAILED && peg$currPos === input.length) { + return peg$result; + } else { + if (peg$result !== peg$FAILED && peg$currPos < input.length) { + peg$fail(peg$endExpectation()); + } + throw peg$buildStructuredError( + peg$maxFailExpected, + peg$maxFailPos < input.length ? input.charAt(peg$maxFailPos) : null, + peg$maxFailPos < input.length ? peg$computeLocation(peg$maxFailPos, peg$maxFailPos + 1) : peg$computeLocation(peg$maxFailPos, peg$maxFailPos) + ); + } + } + return { + SyntaxError: peg$SyntaxError, + parse: peg$parse + }; + }() +); +const _ArgSpecPegParser = ( + // Generated by Peggy 3.0.2. + // + // https://peggyjs.org/ + function() { + function peg$subclass(child, parent) { + function C() { + this.constructor = child; + } + C.prototype = parent.prototype; + child.prototype = new C(); + } + function peg$SyntaxError(message, expected, found, location) { + var self = Error.call(this, message); + if (Object.setPrototypeOf) { + Object.setPrototypeOf(self, peg$SyntaxError.prototype); + } + self.expected = expected; + self.found = found; + self.location = location; + self.name = "SyntaxError"; + return self; + } + peg$subclass(peg$SyntaxError, Error); + function peg$padEnd(str, targetLength, padString) { + padString = padString || " "; + if (str.length > targetLength) { + return str; + } + targetLength -= str.length; + padString += padString.repeat(targetLength); + return str + padString.slice(0, targetLength); + } + peg$SyntaxError.prototype.format = function(sources) { + var str = "Error: " + this.message; + if (this.location) { + var src = null; + var k; + for (k = 0; k < sources.length; k++) { + if (sources[k].source === this.location.source) { + src = sources[k].text.split(/\r\n|\n|\r/g); + break; + } + } + var s = this.location.start; + var offset_s = this.location.source && typeof this.location.source.offset === "function" ? this.location.source.offset(s) : s; + var loc = this.location.source + ":" + offset_s.line + ":" + offset_s.column; + if (src) { + var e = this.location.end; + var filler = peg$padEnd("", offset_s.line.toString().length, " "); + var line = src[s.line - 1]; + var last = s.line === e.line ? e.column : line.length + 1; + var hatLen = last - s.column || 1; + str += "\n --> " + loc + "\n" + filler + " |\n" + offset_s.line + " | " + line + "\n" + filler + " | " + peg$padEnd("", s.column - 1, " ") + peg$padEnd("", hatLen, "^"); + } else { + str += "\n at " + loc; + } + } + return str; + }; + peg$SyntaxError.buildMessage = function(expected, found) { + var DESCRIBE_EXPECTATION_FNS = { + literal: function(expectation) { + return '"' + literalEscape(expectation.text) + '"'; + }, + class: function(expectation) { + var escapedParts = expectation.parts.map(function(part) { + return Array.isArray(part) ? classEscape(part[0]) + "-" + classEscape(part[1]) : classEscape(part); + }); + return "[" + (expectation.inverted ? "^" : "") + escapedParts.join("") + "]"; + }, + any: function() { + return "any character"; + }, + end: function() { + return "end of input"; + }, + other: function(expectation) { + return expectation.description; + } + }; + function hex(ch) { + return ch.charCodeAt(0).toString(16).toUpperCase(); + } + function literalEscape(s) { + return s.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\0/g, "\\0").replace(/\t/g, "\\t").replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/[\x00-\x0F]/g, function(ch) { + return "\\x0" + hex(ch); + }).replace(/[\x10-\x1F\x7F-\x9F]/g, function(ch) { + return "\\x" + hex(ch); + }); + } + function classEscape(s) { + return s.replace(/\\/g, "\\\\").replace(/\]/g, "\\]").replace(/\^/g, "\\^").replace(/-/g, "\\-").replace(/\0/g, "\\0").replace(/\t/g, "\\t").replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/[\x00-\x0F]/g, function(ch) { + return "\\x0" + hex(ch); + }).replace(/[\x10-\x1F\x7F-\x9F]/g, function(ch) { + return "\\x" + hex(ch); + }); + } + function describeExpectation(expectation) { + return DESCRIBE_EXPECTATION_FNS[expectation.type](expectation); + } + function describeExpected(expected2) { + var descriptions = expected2.map(describeExpectation); + var i, j; + descriptions.sort(); + if (descriptions.length > 0) { + for (i = 1, j = 1; i < descriptions.length; i++) { + if (descriptions[i - 1] !== descriptions[i]) { + descriptions[j] = descriptions[i]; + j++; + } + } + descriptions.length = j; + } + switch (descriptions.length) { + case 1: + return descriptions[0]; + case 2: + return descriptions[0] + " or " + descriptions[1]; + default: + return descriptions.slice(0, -1).join(", ") + ", or " + descriptions[descriptions.length - 1]; + } + } + function describeFound(found2) { + return found2 ? '"' + literalEscape(found2) + '"' : "end of input"; + } + return "Expected " + describeExpected(expected) + " but " + describeFound(found) + " found."; + }; + function peg$parse(input, options) { + options = options !== void 0 ? options : {}; + var peg$FAILED = {}; + var peg$source = options.grammarSource; + var peg$startRuleFunctions = { args_spec_list: peg$parseargs_spec_list }; + var peg$startRuleFunction = peg$parseargs_spec_list; + var peg$c1 = "v"; + var peg$c2 = "b"; + var peg$c3 = "!"; + var peg$c4 = "D"; + var peg$c5 = "d"; + var peg$c6 = "s"; + var peg$c7 = "O"; + var peg$c8 = "o"; + var peg$c9 = "e"; + var peg$c10 = "E"; + var peg$c11 = "t"; + var peg$c12 = "R"; + var peg$c13 = "r"; + var peg$c14 = "u"; + var peg$c15 = "m"; + var peg$c16 = "{"; + var peg$c17 = "}"; + var peg$c18 = " "; + var peg$c19 = "\n"; + var peg$c20 = "\r"; + var peg$c21 = "\\"; + var peg$r0 = /^[{ ]/; + var peg$r1 = /^[a-zA-Z]/; + var peg$r2 = /^[{}]/; + var peg$e0 = peg$literalExpectation("+", false); + var peg$e1 = peg$literalExpectation("v", false); + var peg$e2 = peg$anyExpectation(); + var peg$e3 = peg$literalExpectation("b", false); + var peg$e4 = peg$literalExpectation("!", false); + var peg$e5 = peg$literalExpectation("D", false); + var peg$e6 = peg$literalExpectation("d", false); + var peg$e7 = peg$literalExpectation("s", false); + var peg$e8 = peg$literalExpectation("O", false); + var peg$e9 = peg$literalExpectation("o", false); + var peg$e10 = peg$literalExpectation("e", false); + var peg$e11 = peg$literalExpectation("E", false); + var peg$e12 = peg$literalExpectation("t", false); + var peg$e13 = peg$literalExpectation("R", false); + var peg$e14 = peg$literalExpectation("r", false); + var peg$e15 = peg$literalExpectation("u", false); + var peg$e16 = peg$classExpectation(["{", " "], false, false); + var peg$e17 = peg$literalExpectation("m", false); + var peg$e18 = peg$literalExpectation("{", false); + var peg$e19 = peg$literalExpectation("}", false); + var peg$e20 = peg$literalExpectation(" ", false); + var peg$e21 = peg$literalExpectation("\n", false); + var peg$e22 = peg$literalExpectation("\r", false); + var peg$e23 = peg$literalExpectation("\\", false); + var peg$e24 = peg$classExpectation([["a", "z"], ["A", "Z"]], false, false); + var peg$e25 = peg$classExpectation(["{", "}"], false, false); + var peg$f0 = function(x) { + return x; + }; + var peg$f1 = function(spec) { + return spec; + }; + var peg$f2 = function(spec) { + return spec; + }; + var peg$f3 = function(openBrace) { + return createNode("verbatim", { openBrace, closeBrace: openBrace }); + }; + var peg$f4 = function() { + return createNode("body"); + }; + var peg$f5 = function(leading_bang, spec) { + return leading_bang ? { ...spec, noLeadingWhitespace: true } : spec; + }; + var peg$f6 = function(braceSpec, defaultArg) { + return createNode("optional", { ...braceSpec, defaultArg }); + }; + var peg$f7 = function(braceSpec) { + return createNode("optional", braceSpec); + }; + var peg$f8 = function() { + return createNode("optionalStar"); + }; + var peg$f9 = function(g) { + return createNode("optional", { defaultArg: g }); + }; + var peg$f10 = function() { + return createNode("optional"); + }; + var peg$f11 = function(args) { + return createNode("embellishment", { + embellishmentTokens: args + }); + }; + var peg$f12 = function(args, g) { + return createNode("embellishment", { + embellishmentTokens: args, + defaultArg: g + }); + }; + var peg$f13 = function(tok) { + return createNode("optionalToken", { token: tok }); + }; + var peg$f14 = function(braceSpec, defaultArg) { + return createNode("mandatory", { ...braceSpec, defaultArg }); + }; + var peg$f15 = function(braceSpec) { + return createNode("mandatory", braceSpec); + }; + var peg$f16 = function(stopTokens) { + return createNode("until", { stopTokens }); + }; + var peg$f17 = function(x) { + return [x]; + }; + var peg$f18 = function(g) { + return g.content; + }; + var peg$f19 = function() { + return createNode("mandatory"); + }; + var peg$f20 = function(openBrace, closeBrace) { + return { openBrace, closeBrace }; + }; + var peg$f21 = function(g) { + return g.content.map(groupToStr).join(""); + }; + var peg$f22 = function(t) { + return [t]; + }; + var peg$f23 = function(args) { + return args.filter((a) => !a.match(/^\s*$/)); + }; + var peg$f24 = function(content) { + return { type: "group", content }; + }; + var peg$f25 = function() { + return ""; + }; + var peg$currPos = 0; + var peg$posDetailsCache = [{ line: 1, column: 1 }]; + var peg$maxFailPos = 0; + var peg$maxFailExpected = []; + var peg$silentFails = 0; + var peg$result; + if ("startRule" in options) { + if (!(options.startRule in peg$startRuleFunctions)) { + throw new Error(`Can't start parsing from rule "` + options.startRule + '".'); + } + peg$startRuleFunction = peg$startRuleFunctions[options.startRule]; + } + function peg$literalExpectation(text2, ignoreCase) { + return { type: "literal", text: text2, ignoreCase }; + } + function peg$classExpectation(parts, inverted, ignoreCase) { + return { type: "class", parts, inverted, ignoreCase }; + } + function peg$anyExpectation() { + return { type: "any" }; + } + function peg$endExpectation() { + return { type: "end" }; + } + function peg$computePosDetails(pos) { + var details = peg$posDetailsCache[pos]; + var p; + if (details) { + return details; + } else { + p = pos - 1; + while (!peg$posDetailsCache[p]) { + p--; + } + details = peg$posDetailsCache[p]; + details = { + line: details.line, + column: details.column + }; + while (p < pos) { + if (input.charCodeAt(p) === 10) { + details.line++; + details.column = 1; + } else { + details.column++; + } + p++; + } + peg$posDetailsCache[pos] = details; + return details; + } + } + function peg$computeLocation(startPos, endPos, offset2) { + var startPosDetails = peg$computePosDetails(startPos); + var endPosDetails = peg$computePosDetails(endPos); + var res = { + source: peg$source, + start: { + offset: startPos, + line: startPosDetails.line, + column: startPosDetails.column + }, + end: { + offset: endPos, + line: endPosDetails.line, + column: endPosDetails.column + } + }; + return res; + } + function peg$fail(expected2) { + if (peg$currPos < peg$maxFailPos) { + return; + } + if (peg$currPos > peg$maxFailPos) { + peg$maxFailPos = peg$currPos; + peg$maxFailExpected = []; + } + peg$maxFailExpected.push(expected2); + } + function peg$buildStructuredError(expected2, found, location2) { + return new peg$SyntaxError( + peg$SyntaxError.buildMessage(expected2, found), + expected2, + found, + location2 + ); + } + function peg$parseargs_spec_list() { + var s0, s1, s2, s4; + s0 = peg$currPos; + s1 = []; + s2 = peg$currPos; + peg$parsewhitespace(); + s4 = peg$parsearg_spec(); + if (s4 !== peg$FAILED) { + s2 = peg$f0(s4); + } else { + peg$currPos = s2; + s2 = peg$FAILED; + } + while (s2 !== peg$FAILED) { + s1.push(s2); + s2 = peg$currPos; + peg$parsewhitespace(); + s4 = peg$parsearg_spec(); + if (s4 !== peg$FAILED) { + s2 = peg$f0(s4); + } else { + peg$currPos = s2; + s2 = peg$FAILED; + } + } + s2 = peg$parsewhitespace(); + s0 = peg$f1(s1); + return s0; + } + function peg$parsearg_spec() { + var s0, s2; + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 43) { + peg$currPos++; + } else { + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + s2 = peg$parseoptional(); + if (s2 === peg$FAILED) { + s2 = peg$parsemandatory(); + if (s2 === peg$FAILED) { + s2 = peg$parseverbatim(); + if (s2 === peg$FAILED) { + s2 = peg$parserequired(); + if (s2 === peg$FAILED) { + s2 = peg$parsebody(); + if (s2 === peg$FAILED) { + s2 = peg$parseuntil(); + } + } + } + } + } + if (s2 !== peg$FAILED) { + s0 = peg$f2(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parseverbatim() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 118) { + s1 = peg$c1; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e1); + } + } + if (s1 !== peg$FAILED) { + if (input.length > peg$currPos) { + s2 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e2); + } + } + if (s2 !== peg$FAILED) { + s0 = peg$f3(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsebody() { + var s0, s1; + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 98) { + s1 = peg$c2; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s1 !== peg$FAILED) { + s1 = peg$f4(); + } + s0 = s1; + return s0; + } + function peg$parseoptional() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 33) { + s1 = peg$c3; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e4); + } + } + if (s1 === peg$FAILED) { + s1 = null; + } + s2 = peg$parseoptional_star(); + if (s2 === peg$FAILED) { + s2 = peg$parseoptional_standard(); + if (s2 === peg$FAILED) { + s2 = peg$parseoptional_delimited(); + if (s2 === peg$FAILED) { + s2 = peg$parseoptional_embellishment(); + if (s2 === peg$FAILED) { + s2 = peg$parseoptional_token(); + } + } + } + } + if (s2 !== peg$FAILED) { + s0 = peg$f5(s1, s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parseoptional_delimited() { + var s0, s1, s2, s3; + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 68) { + s1 = peg$c4; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e5); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$parsebrace_spec(); + s3 = peg$parsearg(); + if (s3 !== peg$FAILED) { + s0 = peg$f6(s2, s3); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 100) { + s1 = peg$c5; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e6); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$parsebrace_spec(); + s0 = peg$f7(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } + return s0; + } + function peg$parseoptional_star() { + var s0, s1; + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 115) { + s1 = peg$c6; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e7); + } + } + if (s1 !== peg$FAILED) { + s1 = peg$f8(); + } + s0 = s1; + return s0; + } + function peg$parseoptional_standard() { + var s0, s1, s3; + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 79) { + s1 = peg$c7; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e8); + } + } + if (s1 !== peg$FAILED) { + peg$parsewhitespace(); + s3 = peg$parsearg(); + if (s3 !== peg$FAILED) { + s0 = peg$f9(s3); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 111) { + s1 = peg$c8; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e9); + } + } + if (s1 !== peg$FAILED) { + s1 = peg$f10(); + } + s0 = s1; + } + return s0; + } + function peg$parseoptional_embellishment() { + var s0, s1, s3, s5; + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 101) { + s1 = peg$c9; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e10); + } + } + if (s1 !== peg$FAILED) { + peg$parsewhitespace(); + s3 = peg$parseargs(); + if (s3 !== peg$FAILED) { + s0 = peg$f11(s3); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 69) { + s1 = peg$c10; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e11); + } + } + if (s1 !== peg$FAILED) { + peg$parsewhitespace(); + s3 = peg$parseargs(); + if (s3 !== peg$FAILED) { + peg$parsewhitespace(); + s5 = peg$parseargs(); + if (s5 !== peg$FAILED) { + s0 = peg$f12(s3, s5); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } + return s0; + } + function peg$parseoptional_token() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 116) { + s1 = peg$c11; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e12); + } + } + if (s1 !== peg$FAILED) { + if (input.length > peg$currPos) { + s2 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e2); + } + } + if (s2 !== peg$FAILED) { + s0 = peg$f13(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parserequired() { + var s0, s1, s2, s3; + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 82) { + s1 = peg$c12; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e13); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$parsebrace_spec(); + s3 = peg$parsearg(); + if (s3 !== peg$FAILED) { + s0 = peg$f14(s2, s3); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 114) { + s1 = peg$c13; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e14); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$parsebrace_spec(); + s0 = peg$f15(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } + return s0; + } + function peg$parseuntil() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 117) { + s1 = peg$c14; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e15); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$parseuntil_stop_token(); + if (s2 !== peg$FAILED) { + s0 = peg$f16(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parseuntil_stop_token() { + var s0, s1, s2; + s0 = peg$currPos; + s1 = peg$currPos; + peg$silentFails++; + if (peg$r0.test(input.charAt(peg$currPos))) { + s2 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e16); + } + } + peg$silentFails--; + if (s2 === peg$FAILED) { + s1 = void 0; + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + if (s1 !== peg$FAILED) { + if (input.length > peg$currPos) { + s2 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e2); + } + } + if (s2 !== peg$FAILED) { + s0 = peg$f17(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$parsebraced_group(); + if (s1 !== peg$FAILED) { + s1 = peg$f18(s1); + } + s0 = s1; + } + return s0; + } + function peg$parsemandatory() { + var s0, s1; + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 109) { + s1 = peg$c15; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e17); + } + } + if (s1 !== peg$FAILED) { + s1 = peg$f19(); + } + s0 = s1; + return s0; + } + function peg$parsebrace_spec() { + var s0, s1, s2, s3, s4, s5; + s0 = peg$currPos; + s1 = peg$currPos; + s2 = peg$currPos; + s3 = peg$currPos; + peg$silentFails++; + s4 = peg$parsewhitespace_token(); + peg$silentFails--; + if (s4 === peg$FAILED) { + s3 = void 0; + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + if (s3 !== peg$FAILED) { + s4 = peg$parsemacro(); + if (s4 === peg$FAILED) { + if (input.length > peg$currPos) { + s4 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s4 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e2); + } + } + } + if (s4 !== peg$FAILED) { + s3 = [s3, s4]; + s2 = s3; + } else { + peg$currPos = s2; + s2 = peg$FAILED; + } + } else { + peg$currPos = s2; + s2 = peg$FAILED; + } + if (s2 === peg$FAILED) { + s2 = null; + } + s1 = input.substring(s1, peg$currPos); + s2 = peg$currPos; + s3 = peg$currPos; + s4 = peg$currPos; + peg$silentFails++; + s5 = peg$parsewhitespace_token(); + peg$silentFails--; + if (s5 === peg$FAILED) { + s4 = void 0; + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + if (s4 !== peg$FAILED) { + s5 = peg$parsemacro(); + if (s5 === peg$FAILED) { + if (input.length > peg$currPos) { + s5 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s5 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e2); + } + } + } + if (s5 !== peg$FAILED) { + s4 = [s4, s5]; + s3 = s4; + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + if (s3 === peg$FAILED) { + s3 = null; + } + s2 = input.substring(s2, peg$currPos); + s0 = peg$f20(s1, s2); + return s0; + } + function peg$parsearg() { + var s0, s1; + s0 = peg$parsetoken(); + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$parsebraced_group(); + if (s1 !== peg$FAILED) { + s1 = peg$f21(s1); + } + s0 = s1; + } + return s0; + } + function peg$parseargs() { + var s0, s1, s2, s3; + s0 = peg$currPos; + s1 = peg$parsetoken(); + if (s1 !== peg$FAILED) { + s1 = peg$f22(s1); + } + s0 = s1; + if (s0 === peg$FAILED) { + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 123) { + s1 = peg$c16; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e18); + } + } + if (s1 !== peg$FAILED) { + s2 = []; + s3 = peg$parsearg(); + if (s3 === peg$FAILED) { + s3 = peg$parsewhitespace_token(); + } + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$parsearg(); + if (s3 === peg$FAILED) { + s3 = peg$parsewhitespace_token(); + } + } + if (input.charCodeAt(peg$currPos) === 125) { + s3 = peg$c17; + peg$currPos++; + } else { + s3 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e19); + } + } + if (s3 !== peg$FAILED) { + s0 = peg$f23(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } + return s0; + } + function peg$parsebraced_group() { + var s0, s1, s2, s3, s4, s5, s6, s7; + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 123) { + s1 = peg$c16; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e18); + } + } + if (s1 !== peg$FAILED) { + s2 = []; + s3 = peg$currPos; + s4 = peg$currPos; + s5 = peg$currPos; + peg$silentFails++; + if (input.charCodeAt(peg$currPos) === 125) { + s6 = peg$c17; + peg$currPos++; + } else { + s6 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e19); + } + } + peg$silentFails--; + if (s6 === peg$FAILED) { + s5 = void 0; + } else { + peg$currPos = s5; + s5 = peg$FAILED; + } + if (s5 !== peg$FAILED) { + s6 = peg$currPos; + peg$silentFails++; + s7 = peg$parsebraced_group(); + peg$silentFails--; + if (s7 === peg$FAILED) { + s6 = void 0; + } else { + peg$currPos = s6; + s6 = peg$FAILED; + } + if (s6 !== peg$FAILED) { + s7 = peg$parsetoken(); + if (s7 === peg$FAILED) { + s7 = peg$parsewhitespace_token(); + } + if (s7 !== peg$FAILED) { + s5 = [s5, s6, s7]; + s4 = s5; + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + if (s4 !== peg$FAILED) { + s3 = input.substring(s3, peg$currPos); + } else { + s3 = s4; + } + if (s3 === peg$FAILED) { + s3 = peg$parsebraced_group(); + } + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$currPos; + s4 = peg$currPos; + s5 = peg$currPos; + peg$silentFails++; + if (input.charCodeAt(peg$currPos) === 125) { + s6 = peg$c17; + peg$currPos++; + } else { + s6 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e19); + } + } + peg$silentFails--; + if (s6 === peg$FAILED) { + s5 = void 0; + } else { + peg$currPos = s5; + s5 = peg$FAILED; + } + if (s5 !== peg$FAILED) { + s6 = peg$currPos; + peg$silentFails++; + s7 = peg$parsebraced_group(); + peg$silentFails--; + if (s7 === peg$FAILED) { + s6 = void 0; + } else { + peg$currPos = s6; + s6 = peg$FAILED; + } + if (s6 !== peg$FAILED) { + s7 = peg$parsetoken(); + if (s7 === peg$FAILED) { + s7 = peg$parsewhitespace_token(); + } + if (s7 !== peg$FAILED) { + s5 = [s5, s6, s7]; + s4 = s5; + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + if (s4 !== peg$FAILED) { + s3 = input.substring(s3, peg$currPos); + } else { + s3 = s4; + } + if (s3 === peg$FAILED) { + s3 = peg$parsebraced_group(); + } + } + if (input.charCodeAt(peg$currPos) === 125) { + s3 = peg$c17; + peg$currPos++; + } else { + s3 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e19); + } + } + if (s3 !== peg$FAILED) { + s0 = peg$f24(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsewhitespace() { + var s0, s1, s2; + s0 = peg$currPos; + s1 = []; + s2 = peg$parsewhitespace_token(); + while (s2 !== peg$FAILED) { + s1.push(s2); + s2 = peg$parsewhitespace_token(); + } + s1 = peg$f25(); + s0 = s1; + return s0; + } + function peg$parsewhitespace_token() { + var s0; + if (input.charCodeAt(peg$currPos) === 32) { + s0 = peg$c18; + peg$currPos++; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e20); + } + } + if (s0 === peg$FAILED) { + if (input.charCodeAt(peg$currPos) === 10) { + s0 = peg$c19; + peg$currPos++; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e21); + } + } + if (s0 === peg$FAILED) { + if (input.charCodeAt(peg$currPos) === 13) { + s0 = peg$c20; + peg$currPos++; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e22); + } + } + } + } + return s0; + } + function peg$parsemacro() { + var s0, s1, s2, s3, s4; + s0 = peg$currPos; + s1 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 92) { + s2 = peg$c21; + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e23); + } + } + if (s2 !== peg$FAILED) { + s3 = []; + if (peg$r1.test(input.charAt(peg$currPos))) { + s4 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s4 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e24); + } + } + if (s4 !== peg$FAILED) { + while (s4 !== peg$FAILED) { + s3.push(s4); + if (peg$r1.test(input.charAt(peg$currPos))) { + s4 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s4 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e24); + } + } + } + } else { + s3 = peg$FAILED; + } + if (s3 !== peg$FAILED) { + s2 = [s2, s3]; + s1 = s2; + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + if (s1 !== peg$FAILED) { + s0 = input.substring(s0, peg$currPos); + } else { + s0 = s1; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 92) { + s2 = peg$c21; + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e23); + } + } + if (s2 !== peg$FAILED) { + s3 = peg$currPos; + peg$silentFails++; + if (peg$r1.test(input.charAt(peg$currPos))) { + s4 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s4 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e24); + } + } + peg$silentFails--; + if (s4 === peg$FAILED) { + s3 = void 0; + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + if (s3 !== peg$FAILED) { + if (input.length > peg$currPos) { + s4 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s4 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e2); + } + } + if (s4 !== peg$FAILED) { + s2 = [s2, s3, s4]; + s1 = s2; + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + if (s1 !== peg$FAILED) { + s0 = input.substring(s0, peg$currPos); + } else { + s0 = s1; + } + } + return s0; + } + function peg$parsetoken() { + var s0, s1, s2, s3; + s0 = peg$parsemacro(); + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$currPos; + peg$silentFails++; + if (peg$r2.test(input.charAt(peg$currPos))) { + s2 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e25); + } + } + peg$silentFails--; + if (s2 === peg$FAILED) { + s1 = void 0; + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + if (s1 !== peg$FAILED) { + s2 = peg$currPos; + peg$silentFails++; + s3 = peg$parsewhitespace_token(); + peg$silentFails--; + if (s3 === peg$FAILED) { + s2 = void 0; + } else { + peg$currPos = s2; + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + if (input.length > peg$currPos) { + s3 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s3 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e2); + } + } + if (s3 !== peg$FAILED) { + s0 = s3; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } + return s0; + } + const DEFAULT_OPTIONS = { + optional: { openBrace: "[", closeBrace: "]" }, + mandatory: { openBrace: "{", closeBrace: "}" } + }; + function createNode(type, options2) { + const computedOptions = DEFAULT_OPTIONS[type] || {}; + return { type, ...computedOptions, ...options2 }; + } + function groupToStr(node) { + if (typeof node !== "object" || !node) { + return node; + } + if (node.type === "group") { + return `{${node.content.map(groupToStr).join("")}}`; + } + return node; + } + peg$result = peg$startRuleFunction(); + if (peg$result !== peg$FAILED && peg$currPos === input.length) { + return peg$result; + } else { + if (peg$result !== peg$FAILED && peg$currPos < input.length) { + peg$fail(peg$endExpectation()); + } + throw peg$buildStructuredError( + peg$maxFailExpected, + peg$maxFailPos < input.length ? input.charAt(peg$maxFailPos) : null, + peg$maxFailPos < input.length ? peg$computeLocation(peg$maxFailPos, peg$maxFailPos + 1) : peg$computeLocation(peg$maxFailPos, peg$maxFailPos) + ); + } + } + return { + SyntaxError: peg$SyntaxError, + parse: peg$parse + }; + }() +); +const _PgfkeysPegParser = ( + // Generated by Peggy 3.0.2. + // + // https://peggyjs.org/ + function() { + function peg$subclass(child, parent) { + function C() { + this.constructor = child; + } + C.prototype = parent.prototype; + child.prototype = new C(); + } + function peg$SyntaxError(message, expected, found, location) { + var self = Error.call(this, message); + if (Object.setPrototypeOf) { + Object.setPrototypeOf(self, peg$SyntaxError.prototype); + } + self.expected = expected; + self.found = found; + self.location = location; + self.name = "SyntaxError"; + return self; + } + peg$subclass(peg$SyntaxError, Error); + function peg$padEnd(str, targetLength, padString) { + padString = padString || " "; + if (str.length > targetLength) { + return str; + } + targetLength -= str.length; + padString += padString.repeat(targetLength); + return str + padString.slice(0, targetLength); + } + peg$SyntaxError.prototype.format = function(sources) { + var str = "Error: " + this.message; + if (this.location) { + var src = null; + var k; + for (k = 0; k < sources.length; k++) { + if (sources[k].source === this.location.source) { + src = sources[k].text.split(/\r\n|\n|\r/g); + break; + } + } + var s = this.location.start; + var offset_s = this.location.source && typeof this.location.source.offset === "function" ? this.location.source.offset(s) : s; + var loc = this.location.source + ":" + offset_s.line + ":" + offset_s.column; + if (src) { + var e = this.location.end; + var filler = peg$padEnd("", offset_s.line.toString().length, " "); + var line = src[s.line - 1]; + var last = s.line === e.line ? e.column : line.length + 1; + var hatLen = last - s.column || 1; + str += "\n --> " + loc + "\n" + filler + " |\n" + offset_s.line + " | " + line + "\n" + filler + " | " + peg$padEnd("", s.column - 1, " ") + peg$padEnd("", hatLen, "^"); + } else { + str += "\n at " + loc; + } + } + return str; + }; + peg$SyntaxError.buildMessage = function(expected, found) { + var DESCRIBE_EXPECTATION_FNS = { + literal: function(expectation) { + return '"' + literalEscape(expectation.text) + '"'; + }, + class: function(expectation) { + var escapedParts = expectation.parts.map(function(part) { + return Array.isArray(part) ? classEscape(part[0]) + "-" + classEscape(part[1]) : classEscape(part); + }); + return "[" + (expectation.inverted ? "^" : "") + escapedParts.join("") + "]"; + }, + any: function() { + return "any character"; + }, + end: function() { + return "end of input"; + }, + other: function(expectation) { + return expectation.description; + } + }; + function hex(ch) { + return ch.charCodeAt(0).toString(16).toUpperCase(); + } + function literalEscape(s) { + return s.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\0/g, "\\0").replace(/\t/g, "\\t").replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/[\x00-\x0F]/g, function(ch) { + return "\\x0" + hex(ch); + }).replace(/[\x10-\x1F\x7F-\x9F]/g, function(ch) { + return "\\x" + hex(ch); + }); + } + function classEscape(s) { + return s.replace(/\\/g, "\\\\").replace(/\]/g, "\\]").replace(/\^/g, "\\^").replace(/-/g, "\\-").replace(/\0/g, "\\0").replace(/\t/g, "\\t").replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/[\x00-\x0F]/g, function(ch) { + return "\\x0" + hex(ch); + }).replace(/[\x10-\x1F\x7F-\x9F]/g, function(ch) { + return "\\x" + hex(ch); + }); + } + function describeExpectation(expectation) { + return DESCRIBE_EXPECTATION_FNS[expectation.type](expectation); + } + function describeExpected(expected2) { + var descriptions = expected2.map(describeExpectation); + var i, j; + descriptions.sort(); + if (descriptions.length > 0) { + for (i = 1, j = 1; i < descriptions.length; i++) { + if (descriptions[i - 1] !== descriptions[i]) { + descriptions[j] = descriptions[i]; + j++; + } + } + descriptions.length = j; + } + switch (descriptions.length) { + case 1: + return descriptions[0]; + case 2: + return descriptions[0] + " or " + descriptions[1]; + default: + return descriptions.slice(0, -1).join(", ") + ", or " + descriptions[descriptions.length - 1]; + } + } + function describeFound(found2) { + return found2 ? '"' + literalEscape(found2) + '"' : "end of input"; + } + return "Expected " + describeExpected(expected) + " but " + describeFound(found) + " found."; + }; + function peg$parse(input, options) { + options = options !== void 0 ? options : {}; + var peg$FAILED = {}; + var peg$source = options.grammarSource; + var peg$startRuleFunctions = { body: peg$parsebody }; + var peg$startRuleFunction = peg$parsebody; + var peg$e0 = peg$anyExpectation(); + var peg$f0 = function() { + return []; + }; + var peg$f1 = function(rowItems, trailingComment) { + return { + itemParts: [], + ...rowItems, + trailingComment, + trailingComma: true + }; + }; + var peg$f2 = function(rowItems, trailingComment) { + return { ...rowItems, trailingComment }; + }; + var peg$f3 = function(a, b) { + return processItem(a, b); + }; + var peg$f4 = function(b) { + return processItem(null, b); + }; + var peg$f5 = function(cell) { + return { cell }; + }; + var peg$f6 = function() { + return {}; + }; + var peg$f7 = function(part) { + return part; + }; + var peg$f8 = function(x) { + return x; + }; + var peg$f9 = function(space, x) { + return { + trailingComment: x, + leadingParbreak: space.parbreak > 0 + }; + }; + var peg$f10 = function(list) { + return { + whitespace: list.filter((x) => options.isWhitespace(x)).length, + parbreak: list.filter((x) => options.isParbreak(x)).length + }; + }; + var peg$f11 = function() { + return !options.allowParenGroups; + }; + var peg$f12 = function(tok) { + return options.isSameLineComment(tok); + }; + var peg$f13 = function(tok) { + return tok; + }; + var peg$f14 = function(tok) { + return options.isOwnLineComment(tok); + }; + var peg$f15 = function(tok) { + return tok; + }; + var peg$f16 = function(tok) { + return options.isWhitespace(tok); + }; + var peg$f17 = function(tok) { + return tok; + }; + var peg$f18 = function(tok) { + return options.isParbreak(tok); + }; + var peg$f19 = function(tok) { + return tok; + }; + var peg$f20 = function(tok) { + return options.isComma(tok); + }; + var peg$f21 = function(tok) { + return tok; + }; + var peg$f22 = function(tok) { + return options.isEquals(tok); + }; + var peg$f23 = function(tok) { + return tok; + }; + var peg$f24 = function(tok) { + return options.isChar(tok, "("); + }; + var peg$f25 = function(tok) { + return tok; + }; + var peg$f26 = function(tok) { + return options.isChar(tok, ")"); + }; + var peg$f27 = function(tok) { + return tok; + }; + var peg$currPos = 0; + var peg$posDetailsCache = [{ line: 1, column: 1 }]; + var peg$maxFailPos = 0; + var peg$maxFailExpected = []; + var peg$silentFails = 0; + var peg$result; + if ("startRule" in options) { + if (!(options.startRule in peg$startRuleFunctions)) { + throw new Error(`Can't start parsing from rule "` + options.startRule + '".'); + } + peg$startRuleFunction = peg$startRuleFunctions[options.startRule]; + } + function peg$anyExpectation() { + return { type: "any" }; + } + function peg$endExpectation() { + return { type: "end" }; + } + function peg$computePosDetails(pos) { + var details = peg$posDetailsCache[pos]; + var p; + if (details) { + return details; + } else { + p = pos - 1; + while (!peg$posDetailsCache[p]) { + p--; + } + details = peg$posDetailsCache[p]; + details = { + line: details.line, + column: details.column + }; + while (p < pos) { + if (input.charCodeAt(p) === 10) { + details.line++; + details.column = 1; + } else { + details.column++; + } + p++; + } + peg$posDetailsCache[pos] = details; + return details; + } + } + function peg$computeLocation(startPos, endPos, offset2) { + var startPosDetails = peg$computePosDetails(startPos); + var endPosDetails = peg$computePosDetails(endPos); + var res = { + source: peg$source, + start: { + offset: startPos, + line: startPosDetails.line, + column: startPosDetails.column + }, + end: { + offset: endPos, + line: endPosDetails.line, + column: endPosDetails.column + } + }; + return res; + } + function peg$fail(expected2) { + if (peg$currPos < peg$maxFailPos) { + return; + } + if (peg$currPos > peg$maxFailPos) { + peg$maxFailPos = peg$currPos; + peg$maxFailExpected = []; + } + peg$maxFailExpected.push(expected2); + } + function peg$buildStructuredError(expected2, found, location2) { + return new peg$SyntaxError( + peg$SyntaxError.buildMessage(expected2, found), + expected2, + found, + location2 + ); + } + function peg$parsebody() { + var s0, s1, s2; + s0 = []; + s1 = peg$parsecomment_only_line(); + if (s1 === peg$FAILED) { + s1 = peg$parseitem_with_end(); + if (s1 === peg$FAILED) { + s1 = peg$parseitem_without_end(); + } + } + if (s1 !== peg$FAILED) { + while (s1 !== peg$FAILED) { + s0.push(s1); + s1 = peg$parsecomment_only_line(); + if (s1 === peg$FAILED) { + s1 = peg$parseitem_with_end(); + if (s1 === peg$FAILED) { + s1 = peg$parseitem_without_end(); + } + } + } + } else { + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = []; + s2 = peg$parsewhitespace(); + while (s2 !== peg$FAILED) { + s1.push(s2); + s2 = peg$parsewhitespace(); + } + s2 = peg$parseEOL(); + if (s2 !== peg$FAILED) { + s0 = peg$f0(); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } + return s0; + } + function peg$parseitem_with_end() { + var s0, s2, s4, s5, s6, s7, s8; + s0 = peg$currPos; + peg$parsewhitespace_or_parbreaks(); + s2 = peg$parserow_items(); + if (s2 === peg$FAILED) { + s2 = null; + } + peg$parsewhitespace_or_parbreaks(); + s4 = peg$parseitem_sep(); + if (s4 !== peg$FAILED) { + s5 = []; + s6 = peg$parsewhitespace(); + while (s6 !== peg$FAILED) { + s5.push(s6); + s6 = peg$parsewhitespace(); + } + s6 = peg$parsetrailing_comment(); + if (s6 === peg$FAILED) { + s6 = null; + } + s7 = []; + s8 = peg$parsewhitespace(); + while (s8 !== peg$FAILED) { + s7.push(s8); + s8 = peg$parsewhitespace(); + } + s0 = peg$f1(s2, s6); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parseitem_without_end() { + var s0, s2, s3; + s0 = peg$currPos; + peg$parsewhitespace_or_parbreaks(); + s2 = peg$parserow_items(); + if (s2 !== peg$FAILED) { + s3 = peg$parsetrailing_comment(); + if (s3 === peg$FAILED) { + s3 = null; + } + s0 = peg$f2(s2, s3); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parserow_items() { + var s0, s1, s2, s3; + s0 = peg$currPos; + s1 = peg$parseitem_part(); + if (s1 !== peg$FAILED) { + s2 = []; + s3 = peg$parseseparated_part(); + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$parseseparated_part(); + } + s0 = peg$f3(s1, s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = []; + s2 = peg$parseseparated_part(); + if (s2 !== peg$FAILED) { + while (s2 !== peg$FAILED) { + s1.push(s2); + s2 = peg$parseseparated_part(); + } + } else { + s1 = peg$FAILED; + } + if (s1 !== peg$FAILED) { + s1 = peg$f4(s1); + } + s0 = s1; + } + return s0; + } + function peg$parseseparated_part() { + var s0, s1, s2, s3, s4; + s0 = peg$currPos; + s1 = []; + s2 = peg$parseparbreak(); + while (s2 !== peg$FAILED) { + s1.push(s2); + s2 = peg$parseparbreak(); + } + s2 = peg$parseequals(); + if (s2 !== peg$FAILED) { + s3 = []; + s4 = peg$parseparbreak(); + while (s4 !== peg$FAILED) { + s3.push(s4); + s4 = peg$parseparbreak(); + } + s4 = peg$parseitem_part(); + if (s4 !== peg$FAILED) { + s0 = peg$f5(s4); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = []; + s2 = peg$parseparbreak(); + while (s2 !== peg$FAILED) { + s1.push(s2); + s2 = peg$parseparbreak(); + } + s2 = peg$parseequals(); + if (s2 !== peg$FAILED) { + s0 = peg$f6(); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } + return s0; + } + function peg$parseitem_part() { + var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9; + s0 = peg$currPos; + s1 = []; + s2 = peg$parsewhitespace(); + while (s2 !== peg$FAILED) { + s1.push(s2); + s2 = peg$parsewhitespace(); + } + s2 = peg$currPos; + s3 = []; + s4 = peg$parsenon_whitespace_non_parbreak_token(); + if (s4 === peg$FAILED) { + s4 = peg$currPos; + s5 = peg$parsewhitespace(); + if (s5 === peg$FAILED) { + s5 = peg$parseparbreak(); + } + if (s5 !== peg$FAILED) { + s6 = peg$currPos; + peg$silentFails++; + s7 = peg$currPos; + s8 = []; + s9 = peg$parsewhitespace(); + if (s9 === peg$FAILED) { + s9 = peg$parseparbreak(); + } + while (s9 !== peg$FAILED) { + s8.push(s9); + s9 = peg$parsewhitespace(); + if (s9 === peg$FAILED) { + s9 = peg$parseparbreak(); + } + } + s9 = peg$parsenon_whitespace_non_parbreak_token(); + if (s9 !== peg$FAILED) { + s8 = [s8, s9]; + s7 = s8; + } else { + peg$currPos = s7; + s7 = peg$FAILED; + } + peg$silentFails--; + if (s7 !== peg$FAILED) { + peg$currPos = s6; + s6 = void 0; + } else { + s6 = peg$FAILED; + } + if (s6 !== peg$FAILED) { + s5 = [s5, s6]; + s4 = s5; + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + } + if (s4 !== peg$FAILED) { + while (s4 !== peg$FAILED) { + s3.push(s4); + s4 = peg$parsenon_whitespace_non_parbreak_token(); + if (s4 === peg$FAILED) { + s4 = peg$currPos; + s5 = peg$parsewhitespace(); + if (s5 === peg$FAILED) { + s5 = peg$parseparbreak(); + } + if (s5 !== peg$FAILED) { + s6 = peg$currPos; + peg$silentFails++; + s7 = peg$currPos; + s8 = []; + s9 = peg$parsewhitespace(); + if (s9 === peg$FAILED) { + s9 = peg$parseparbreak(); + } + while (s9 !== peg$FAILED) { + s8.push(s9); + s9 = peg$parsewhitespace(); + if (s9 === peg$FAILED) { + s9 = peg$parseparbreak(); + } + } + s9 = peg$parsenon_whitespace_non_parbreak_token(); + if (s9 !== peg$FAILED) { + s8 = [s8, s9]; + s7 = s8; + } else { + peg$currPos = s7; + s7 = peg$FAILED; + } + peg$silentFails--; + if (s7 !== peg$FAILED) { + peg$currPos = s6; + s6 = void 0; + } else { + s6 = peg$FAILED; + } + if (s6 !== peg$FAILED) { + s5 = [s5, s6]; + s4 = s5; + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + } + } + } else { + s3 = peg$FAILED; + } + if (s3 !== peg$FAILED) { + s2 = input.substring(s2, peg$currPos); + } else { + s2 = s3; + } + if (s2 !== peg$FAILED) { + s3 = []; + s4 = peg$parsewhitespace(); + while (s4 !== peg$FAILED) { + s3.push(s4); + s4 = peg$parsewhitespace(); + } + s0 = peg$f7(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsetrailing_comment() { + var s0, s1, s2; + s0 = peg$currPos; + s1 = []; + s2 = peg$parsewhitespace(); + while (s2 !== peg$FAILED) { + s1.push(s2); + s2 = peg$parsewhitespace(); + } + s2 = peg$parsesame_line_comment(); + if (s2 !== peg$FAILED) { + s0 = peg$f8(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsecomment_only_line() { + var s0, s1, s2; + s0 = peg$currPos; + s1 = peg$parsewhitespace_or_parbreaks(); + s2 = peg$parseown_line_comment(); + if (s2 !== peg$FAILED) { + s0 = peg$f9(s1, s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsetoken() { + var s0, s1, s2, s3; + s0 = peg$currPos; + s1 = peg$currPos; + s2 = peg$currPos; + peg$silentFails++; + s3 = peg$parsenon_token(); + peg$silentFails--; + if (s3 === peg$FAILED) { + s2 = void 0; + } else { + peg$currPos = s2; + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + if (input.length > peg$currPos) { + s3 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s3 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s3 !== peg$FAILED) { + s2 = [s2, s3]; + s1 = s2; + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + if (s1 !== peg$FAILED) { + s0 = input.substring(s0, peg$currPos); + } else { + s0 = s1; + } + return s0; + } + function peg$parsenon_whitespace_non_parbreak_token() { + var s0, s1, s2, s3; + s0 = peg$currPos; + s1 = peg$currPos; + s2 = peg$currPos; + peg$silentFails++; + s3 = peg$parsewhitespace(); + if (s3 === peg$FAILED) { + s3 = peg$parseparbreak(); + } + peg$silentFails--; + if (s3 === peg$FAILED) { + s2 = void 0; + } else { + peg$currPos = s2; + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s3 = peg$parseparen_block(); + if (s3 === peg$FAILED) { + s3 = peg$parsetoken(); + } + if (s3 !== peg$FAILED) { + s2 = [s2, s3]; + s1 = s2; + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + if (s1 !== peg$FAILED) { + s0 = input.substring(s0, peg$currPos); + } else { + s0 = s1; + } + return s0; + } + function peg$parsenon_token() { + var s0; + s0 = peg$parseitem_sep(); + if (s0 === peg$FAILED) { + s0 = peg$parseequals(); + if (s0 === peg$FAILED) { + s0 = peg$parsetrailing_comment(); + if (s0 === peg$FAILED) { + s0 = peg$parseown_line_comment(); + } + } + } + return s0; + } + function peg$parsewhitespace_or_parbreaks() { + var s0, s1, s2; + s0 = peg$currPos; + s1 = []; + s2 = peg$parsewhitespace(); + if (s2 === peg$FAILED) { + s2 = peg$parseparbreak(); + } + while (s2 !== peg$FAILED) { + s1.push(s2); + s2 = peg$parsewhitespace(); + if (s2 === peg$FAILED) { + s2 = peg$parseparbreak(); + } + } + s1 = peg$f10(s1); + s0 = s1; + return s0; + } + function peg$parseparen_block() { + var s0, s1, s2, s3, s4, s5, s6, s7, s8; + s0 = peg$currPos; + s1 = peg$f11(); + if (s1) { + s1 = peg$FAILED; + } else { + s1 = void 0; + } + if (s1 !== peg$FAILED) { + s2 = peg$currPos; + s3 = peg$currPos; + s4 = peg$parseopen_paren(); + if (s4 !== peg$FAILED) { + s5 = []; + s6 = peg$currPos; + s7 = peg$currPos; + peg$silentFails++; + s8 = peg$parseclose_paren(); + peg$silentFails--; + if (s8 === peg$FAILED) { + s7 = void 0; + } else { + peg$currPos = s7; + s7 = peg$FAILED; + } + if (s7 !== peg$FAILED) { + if (input.length > peg$currPos) { + s8 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s8 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s8 !== peg$FAILED) { + s7 = [s7, s8]; + s6 = s7; + } else { + peg$currPos = s6; + s6 = peg$FAILED; + } + } else { + peg$currPos = s6; + s6 = peg$FAILED; + } + while (s6 !== peg$FAILED) { + s5.push(s6); + s6 = peg$currPos; + s7 = peg$currPos; + peg$silentFails++; + s8 = peg$parseclose_paren(); + peg$silentFails--; + if (s8 === peg$FAILED) { + s7 = void 0; + } else { + peg$currPos = s7; + s7 = peg$FAILED; + } + if (s7 !== peg$FAILED) { + if (input.length > peg$currPos) { + s8 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s8 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s8 !== peg$FAILED) { + s7 = [s7, s8]; + s6 = s7; + } else { + peg$currPos = s6; + s6 = peg$FAILED; + } + } else { + peg$currPos = s6; + s6 = peg$FAILED; + } + } + s6 = peg$parseclose_paren(); + if (s6 !== peg$FAILED) { + s4 = [s4, s5, s6]; + s3 = s4; + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + if (s3 !== peg$FAILED) { + s2 = input.substring(s2, peg$currPos); + } else { + s2 = s3; + } + if (s2 !== peg$FAILED) { + s1 = [s1, s2]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsesame_line_comment() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f12(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s0 = peg$f13(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parseown_line_comment() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f14(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s0 = peg$f15(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsewhitespace() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f16(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s0 = peg$f17(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parseparbreak() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f18(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s0 = peg$f19(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parseitem_sep() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f20(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s0 = peg$f21(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parseequals() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f22(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s0 = peg$f23(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parseopen_paren() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f24(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s0 = peg$f25(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parseclose_paren() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f26(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s0 = peg$f27(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parseEOL() { + var s0, s1; + s0 = peg$currPos; + peg$silentFails++; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + peg$silentFails--; + if (s1 === peg$FAILED) { + s0 = void 0; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function processItem(leadCell, otherCells) { + const cells = [leadCell || []]; + for (const x of otherCells) { + cells.push(x.cell || []); + } + return { itemParts: cells }; + } + if (!options.isWhitespace) { + try { + Object.assign(options, { + isChar: (node, char) => node.type === "string" && node.content === char, + isComma(node) { + return node.type === "string" && node.content === ","; + }, + isEquals(node) { + return node.type === "string" && node.content === "="; + }, + isParbreak(node) { + return node.type === "parbreak"; + }, + isWhitespace(node) { + return node.type === "whitespace"; + }, + isSameLineComment: (node) => node.type === "comment" && node.sameline, + isOwnLineComment: (node) => node.type === "comment" && !node.sameline, + isComment: (node) => node.type === "comment", + allowParenGroups: true + }); + } catch (e) { + console.warn("Error when initializing parser", e); + } + } + peg$result = peg$startRuleFunction(); + if (peg$result !== peg$FAILED && peg$currPos === input.length) { + return peg$result; + } else { + if (peg$result !== peg$FAILED && peg$currPos < input.length) { + peg$fail(peg$endExpectation()); + } + throw peg$buildStructuredError( + peg$maxFailExpected, + peg$maxFailPos < input.length ? input.charAt(peg$maxFailPos) : null, + peg$maxFailPos < input.length ? peg$computeLocation(peg$maxFailPos, peg$maxFailPos + 1) : peg$computeLocation(peg$maxFailPos, peg$maxFailPos) + ); + } + } + return { + SyntaxError: peg$SyntaxError, + parse: peg$parse + }; + }() +); +const _MacroSubstitutionPegParser = ( + // Generated by Peggy 3.0.2. + // + // https://peggyjs.org/ + function() { + function peg$subclass(child, parent) { + function C() { + this.constructor = child; + } + C.prototype = parent.prototype; + child.prototype = new C(); + } + function peg$SyntaxError(message, expected, found, location) { + var self = Error.call(this, message); + if (Object.setPrototypeOf) { + Object.setPrototypeOf(self, peg$SyntaxError.prototype); + } + self.expected = expected; + self.found = found; + self.location = location; + self.name = "SyntaxError"; + return self; + } + peg$subclass(peg$SyntaxError, Error); + function peg$padEnd(str, targetLength, padString) { + padString = padString || " "; + if (str.length > targetLength) { + return str; + } + targetLength -= str.length; + padString += padString.repeat(targetLength); + return str + padString.slice(0, targetLength); + } + peg$SyntaxError.prototype.format = function(sources) { + var str = "Error: " + this.message; + if (this.location) { + var src = null; + var k; + for (k = 0; k < sources.length; k++) { + if (sources[k].source === this.location.source) { + src = sources[k].text.split(/\r\n|\n|\r/g); + break; + } + } + var s = this.location.start; + var offset_s = this.location.source && typeof this.location.source.offset === "function" ? this.location.source.offset(s) : s; + var loc = this.location.source + ":" + offset_s.line + ":" + offset_s.column; + if (src) { + var e = this.location.end; + var filler = peg$padEnd("", offset_s.line.toString().length, " "); + var line = src[s.line - 1]; + var last = s.line === e.line ? e.column : line.length + 1; + var hatLen = last - s.column || 1; + str += "\n --> " + loc + "\n" + filler + " |\n" + offset_s.line + " | " + line + "\n" + filler + " | " + peg$padEnd("", s.column - 1, " ") + peg$padEnd("", hatLen, "^"); + } else { + str += "\n at " + loc; + } + } + return str; + }; + peg$SyntaxError.buildMessage = function(expected, found) { + var DESCRIBE_EXPECTATION_FNS = { + literal: function(expectation) { + return '"' + literalEscape(expectation.text) + '"'; + }, + class: function(expectation) { + var escapedParts = expectation.parts.map(function(part) { + return Array.isArray(part) ? classEscape(part[0]) + "-" + classEscape(part[1]) : classEscape(part); + }); + return "[" + (expectation.inverted ? "^" : "") + escapedParts.join("") + "]"; + }, + any: function() { + return "any character"; + }, + end: function() { + return "end of input"; + }, + other: function(expectation) { + return expectation.description; + } + }; + function hex(ch) { + return ch.charCodeAt(0).toString(16).toUpperCase(); + } + function literalEscape(s) { + return s.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\0/g, "\\0").replace(/\t/g, "\\t").replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/[\x00-\x0F]/g, function(ch) { + return "\\x0" + hex(ch); + }).replace(/[\x10-\x1F\x7F-\x9F]/g, function(ch) { + return "\\x" + hex(ch); + }); + } + function classEscape(s) { + return s.replace(/\\/g, "\\\\").replace(/\]/g, "\\]").replace(/\^/g, "\\^").replace(/-/g, "\\-").replace(/\0/g, "\\0").replace(/\t/g, "\\t").replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/[\x00-\x0F]/g, function(ch) { + return "\\x0" + hex(ch); + }).replace(/[\x10-\x1F\x7F-\x9F]/g, function(ch) { + return "\\x" + hex(ch); + }); + } + function describeExpectation(expectation) { + return DESCRIBE_EXPECTATION_FNS[expectation.type](expectation); + } + function describeExpected(expected2) { + var descriptions = expected2.map(describeExpectation); + var i, j; + descriptions.sort(); + if (descriptions.length > 0) { + for (i = 1, j = 1; i < descriptions.length; i++) { + if (descriptions[i - 1] !== descriptions[i]) { + descriptions[j] = descriptions[i]; + j++; + } + } + descriptions.length = j; + } + switch (descriptions.length) { + case 1: + return descriptions[0]; + case 2: + return descriptions[0] + " or " + descriptions[1]; + default: + return descriptions.slice(0, -1).join(", ") + ", or " + descriptions[descriptions.length - 1]; + } + } + function describeFound(found2) { + return found2 ? '"' + literalEscape(found2) + '"' : "end of input"; + } + return "Expected " + describeExpected(expected) + " but " + describeFound(found) + " found."; + }; + function peg$parse(input, options) { + options = options !== void 0 ? options : {}; + var peg$FAILED = {}; + var peg$source = options.grammarSource; + var peg$startRuleFunctions = { body: peg$parsebody }; + var peg$startRuleFunction = peg$parsebody; + var peg$e0 = peg$anyExpectation(); + var peg$f0 = function(e) { + return [].concat(...e).filter((n) => !!n); + }; + var peg$f1 = function() { + return []; + }; + var peg$f2 = function(tok) { + return options.isHash(tok); + }; + var peg$f3 = function(tok) { + return tok; + }; + var peg$f4 = function(tok) { + return options.isNumber(tok); + }; + var peg$f5 = function(tok) { + return tok; + }; + var peg$f6 = function() { + return { type: "string", content: "#" }; + }; + var peg$f7 = function(num) { + const split = options.splitNumber(num); + return [{ type: "hash_number", number: split.number }, split.rest]; + }; + var peg$currPos = 0; + var peg$posDetailsCache = [{ line: 1, column: 1 }]; + var peg$maxFailPos = 0; + var peg$maxFailExpected = []; + var peg$silentFails = 0; + var peg$result; + if ("startRule" in options) { + if (!(options.startRule in peg$startRuleFunctions)) { + throw new Error(`Can't start parsing from rule "` + options.startRule + '".'); + } + peg$startRuleFunction = peg$startRuleFunctions[options.startRule]; + } + function peg$anyExpectation() { + return { type: "any" }; + } + function peg$endExpectation() { + return { type: "end" }; + } + function peg$computePosDetails(pos) { + var details = peg$posDetailsCache[pos]; + var p; + if (details) { + return details; + } else { + p = pos - 1; + while (!peg$posDetailsCache[p]) { + p--; + } + details = peg$posDetailsCache[p]; + details = { + line: details.line, + column: details.column + }; + while (p < pos) { + if (input.charCodeAt(p) === 10) { + details.line++; + details.column = 1; + } else { + details.column++; + } + p++; + } + peg$posDetailsCache[pos] = details; + return details; + } + } + function peg$computeLocation(startPos, endPos, offset2) { + var startPosDetails = peg$computePosDetails(startPos); + var endPosDetails = peg$computePosDetails(endPos); + var res = { + source: peg$source, + start: { + offset: startPos, + line: startPosDetails.line, + column: startPosDetails.column + }, + end: { + offset: endPos, + line: endPosDetails.line, + column: endPosDetails.column + } + }; + return res; + } + function peg$fail(expected2) { + if (peg$currPos < peg$maxFailPos) { + return; + } + if (peg$currPos > peg$maxFailPos) { + peg$maxFailPos = peg$currPos; + peg$maxFailExpected = []; + } + peg$maxFailExpected.push(expected2); + } + function peg$buildStructuredError(expected2, found, location2) { + return new peg$SyntaxError( + peg$SyntaxError.buildMessage(expected2, found), + expected2, + found, + location2 + ); + } + function peg$parsebody() { + var s0, s1, s2; + s0 = peg$currPos; + s1 = []; + s2 = peg$parsedouble_hash(); + if (s2 === peg$FAILED) { + s2 = peg$parsehash_number(); + if (s2 === peg$FAILED) { + if (input.length > peg$currPos) { + s2 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + } + } + if (s2 !== peg$FAILED) { + while (s2 !== peg$FAILED) { + s1.push(s2); + s2 = peg$parsedouble_hash(); + if (s2 === peg$FAILED) { + s2 = peg$parsehash_number(); + if (s2 === peg$FAILED) { + if (input.length > peg$currPos) { + s2 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + } + } + } + } else { + s1 = peg$FAILED; + } + if (s1 !== peg$FAILED) { + s1 = peg$f0(s1); + } + s0 = s1; + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$parseEOL(); + if (s1 !== peg$FAILED) { + s1 = peg$f1(); + } + s0 = s1; + } + return s0; + } + function peg$parsehash() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f2(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s0 = peg$f3(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsenumber() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f4(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s0 = peg$f5(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsedouble_hash() { + var s0, s1, s2; + s0 = peg$currPos; + s1 = peg$parsehash(); + if (s1 !== peg$FAILED) { + s2 = peg$parsehash(); + if (s2 !== peg$FAILED) { + s0 = peg$f6(); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsehash_number() { + var s0, s1, s2; + s0 = peg$currPos; + s1 = peg$parsehash(); + if (s1 !== peg$FAILED) { + s2 = peg$parsenumber(); + if (s2 !== peg$FAILED) { + s0 = peg$f7(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parseEOL() { + var s0, s1; + s0 = peg$currPos; + peg$silentFails++; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + peg$silentFails--; + if (s1 === peg$FAILED) { + s0 = void 0; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + if (!options.isHash) { + try { + Object.assign(options, { + isHash: (node) => node.type === "string" && node.content === "#", + isNumber: (node) => node.type === "string" && 0 < +node.content.charAt(0), + splitNumber: (node) => { + const number = +node.content.charAt(0); + if (node.content.length > 1) { + return { + number, + rest: { + type: "string", + content: node.content.slice(1) + } + }; + } + return { number }; + } + }); + } catch (e) { + console.warn("Error when initializing parser", e); + } + } + peg$result = peg$startRuleFunction(); + if (peg$result !== peg$FAILED && peg$currPos === input.length) { + return peg$result; + } else { + if (peg$result !== peg$FAILED && peg$currPos < input.length) { + peg$fail(peg$endExpectation()); + } + throw peg$buildStructuredError( + peg$maxFailExpected, + peg$maxFailPos < input.length ? input.charAt(peg$maxFailPos) : null, + peg$maxFailPos < input.length ? peg$computeLocation(peg$maxFailPos, peg$maxFailPos + 1) : peg$computeLocation(peg$maxFailPos, peg$maxFailPos) + ); + } + } + return { + SyntaxError: peg$SyntaxError, + parse: peg$parse + }; + }() +); +const _LigaturesPegParser = ( + // Generated by Peggy 3.0.2. + // + // https://peggyjs.org/ + function() { + function peg$subclass(child, parent) { + function C() { + this.constructor = child; + } + C.prototype = parent.prototype; + child.prototype = new C(); + } + function peg$SyntaxError(message, expected, found, location) { + var self = Error.call(this, message); + if (Object.setPrototypeOf) { + Object.setPrototypeOf(self, peg$SyntaxError.prototype); + } + self.expected = expected; + self.found = found; + self.location = location; + self.name = "SyntaxError"; + return self; + } + peg$subclass(peg$SyntaxError, Error); + function peg$padEnd(str, targetLength, padString) { + padString = padString || " "; + if (str.length > targetLength) { + return str; + } + targetLength -= str.length; + padString += padString.repeat(targetLength); + return str + padString.slice(0, targetLength); + } + peg$SyntaxError.prototype.format = function(sources) { + var str = "Error: " + this.message; + if (this.location) { + var src = null; + var k; + for (k = 0; k < sources.length; k++) { + if (sources[k].source === this.location.source) { + src = sources[k].text.split(/\r\n|\n|\r/g); + break; + } + } + var s = this.location.start; + var offset_s = this.location.source && typeof this.location.source.offset === "function" ? this.location.source.offset(s) : s; + var loc = this.location.source + ":" + offset_s.line + ":" + offset_s.column; + if (src) { + var e = this.location.end; + var filler = peg$padEnd("", offset_s.line.toString().length, " "); + var line = src[s.line - 1]; + var last = s.line === e.line ? e.column : line.length + 1; + var hatLen = last - s.column || 1; + str += "\n --> " + loc + "\n" + filler + " |\n" + offset_s.line + " | " + line + "\n" + filler + " | " + peg$padEnd("", s.column - 1, " ") + peg$padEnd("", hatLen, "^"); + } else { + str += "\n at " + loc; + } + } + return str; + }; + peg$SyntaxError.buildMessage = function(expected, found) { + var DESCRIBE_EXPECTATION_FNS = { + literal: function(expectation) { + return '"' + literalEscape(expectation.text) + '"'; + }, + class: function(expectation) { + var escapedParts = expectation.parts.map(function(part) { + return Array.isArray(part) ? classEscape(part[0]) + "-" + classEscape(part[1]) : classEscape(part); + }); + return "[" + (expectation.inverted ? "^" : "") + escapedParts.join("") + "]"; + }, + any: function() { + return "any character"; + }, + end: function() { + return "end of input"; + }, + other: function(expectation) { + return expectation.description; + } + }; + function hex(ch) { + return ch.charCodeAt(0).toString(16).toUpperCase(); + } + function literalEscape(s) { + return s.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\0/g, "\\0").replace(/\t/g, "\\t").replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/[\x00-\x0F]/g, function(ch) { + return "\\x0" + hex(ch); + }).replace(/[\x10-\x1F\x7F-\x9F]/g, function(ch) { + return "\\x" + hex(ch); + }); + } + function classEscape(s) { + return s.replace(/\\/g, "\\\\").replace(/\]/g, "\\]").replace(/\^/g, "\\^").replace(/-/g, "\\-").replace(/\0/g, "\\0").replace(/\t/g, "\\t").replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/[\x00-\x0F]/g, function(ch) { + return "\\x0" + hex(ch); + }).replace(/[\x10-\x1F\x7F-\x9F]/g, function(ch) { + return "\\x" + hex(ch); + }); + } + function describeExpectation(expectation) { + return DESCRIBE_EXPECTATION_FNS[expectation.type](expectation); + } + function describeExpected(expected2) { + var descriptions = expected2.map(describeExpectation); + var i, j; + descriptions.sort(); + if (descriptions.length > 0) { + for (i = 1, j = 1; i < descriptions.length; i++) { + if (descriptions[i - 1] !== descriptions[i]) { + descriptions[j] = descriptions[i]; + j++; + } + } + descriptions.length = j; + } + switch (descriptions.length) { + case 1: + return descriptions[0]; + case 2: + return descriptions[0] + " or " + descriptions[1]; + default: + return descriptions.slice(0, -1).join(", ") + ", or " + descriptions[descriptions.length - 1]; + } + } + function describeFound(found2) { + return found2 ? '"' + literalEscape(found2) + '"' : "end of input"; + } + return "Expected " + describeExpected(expected) + " but " + describeFound(found) + " found."; + }; + function peg$parse(input, options) { + options = options !== void 0 ? options : {}; + var peg$FAILED = {}; + var peg$source = options.grammarSource; + var peg$startRuleFunctions = { body: peg$parsebody }; + var peg$startRuleFunction = peg$parsebody; + var peg$e0 = peg$anyExpectation(); + var peg$f0 = function(e) { + return [].concat(...e).filter((n) => !!n); + }; + var peg$f1 = function() { + return []; + }; + var peg$f2 = function(toks) { + return options.isRecognized(toks); + }; + var peg$f3 = function(toks) { + return options.isRecognized(toks); + }; + var peg$f4 = function(tok1, tok2) { + const split = options.split(tok2); + return options.isRecognized([tok1, split[0]]); + }; + var peg$f5 = function(tok1, tok2) { + const split = options.split(tok2); + return [options.isRecognized([tok1, split[0]]), split[1]]; + }; + var peg$f6 = function(tok1, tok2) { + return options.isRecognized([tok1, tok2]); + }; + var peg$f7 = function(tok1, tok2) { + return options.isRecognized([tok1, tok2]); + }; + var peg$f8 = function(toks) { + return options.isRecognized(toks); + }; + var peg$f9 = function(toks) { + return options.isRecognized(toks); + }; + var peg$f10 = function(tok) { + return options.isRecognized([tok]); + }; + var peg$f11 = function(tok) { + return options.isRecognized([tok]); + }; + var peg$f12 = function(tok) { + return options.isMacro(tok); + }; + var peg$f13 = function(tok) { + return tok; + }; + var peg$f14 = function(tok) { + return options.isWhitespace(tok); + }; + var peg$f15 = function(tok) { + return tok; + }; + var peg$f16 = function(tok) { + return options.isSplitable(tok); + }; + var peg$f17 = function(tok) { + return tok; + }; + var peg$currPos = 0; + var peg$posDetailsCache = [{ line: 1, column: 1 }]; + var peg$maxFailPos = 0; + var peg$maxFailExpected = []; + var peg$silentFails = 0; + var peg$result; + if ("startRule" in options) { + if (!(options.startRule in peg$startRuleFunctions)) { + throw new Error(`Can't start parsing from rule "` + options.startRule + '".'); + } + peg$startRuleFunction = peg$startRuleFunctions[options.startRule]; + } + function peg$anyExpectation() { + return { type: "any" }; + } + function peg$endExpectation() { + return { type: "end" }; + } + function peg$computePosDetails(pos) { + var details = peg$posDetailsCache[pos]; + var p; + if (details) { + return details; + } else { + p = pos - 1; + while (!peg$posDetailsCache[p]) { + p--; + } + details = peg$posDetailsCache[p]; + details = { + line: details.line, + column: details.column + }; + while (p < pos) { + if (input.charCodeAt(p) === 10) { + details.line++; + details.column = 1; + } else { + details.column++; + } + p++; + } + peg$posDetailsCache[pos] = details; + return details; + } + } + function peg$computeLocation(startPos, endPos, offset2) { + var startPosDetails = peg$computePosDetails(startPos); + var endPosDetails = peg$computePosDetails(endPos); + var res = { + source: peg$source, + start: { + offset: startPos, + line: startPosDetails.line, + column: startPosDetails.column + }, + end: { + offset: endPos, + line: endPosDetails.line, + column: endPosDetails.column + } + }; + return res; + } + function peg$fail(expected2) { + if (peg$currPos < peg$maxFailPos) { + return; + } + if (peg$currPos > peg$maxFailPos) { + peg$maxFailPos = peg$currPos; + peg$maxFailExpected = []; + } + peg$maxFailExpected.push(expected2); + } + function peg$buildStructuredError(expected2, found, location2) { + return new peg$SyntaxError( + peg$SyntaxError.buildMessage(expected2, found), + expected2, + found, + location2 + ); + } + function peg$parsebody() { + var s0, s1, s2; + s0 = peg$currPos; + s1 = []; + s2 = peg$parsetriple_ligature(); + if (s2 === peg$FAILED) { + s2 = peg$parsedouble_ligature(); + if (s2 === peg$FAILED) { + s2 = peg$parsemono_ligature(); + if (s2 === peg$FAILED) { + if (input.length > peg$currPos) { + s2 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + } + } + } + if (s2 !== peg$FAILED) { + while (s2 !== peg$FAILED) { + s1.push(s2); + s2 = peg$parsetriple_ligature(); + if (s2 === peg$FAILED) { + s2 = peg$parsedouble_ligature(); + if (s2 === peg$FAILED) { + s2 = peg$parsemono_ligature(); + if (s2 === peg$FAILED) { + if (input.length > peg$currPos) { + s2 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + } + } + } + } + } else { + s1 = peg$FAILED; + } + if (s1 !== peg$FAILED) { + s1 = peg$f0(s1); + } + s0 = s1; + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$parseEOL(); + if (s1 !== peg$FAILED) { + s1 = peg$f1(); + } + s0 = s1; + } + return s0; + } + function peg$parsetriple_ligature() { + var s0, s1, s2, s3, s4; + s0 = peg$currPos; + s1 = peg$currPos; + if (input.length > peg$currPos) { + s2 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s2 !== peg$FAILED) { + if (input.length > peg$currPos) { + s3 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s3 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s3 !== peg$FAILED) { + if (input.length > peg$currPos) { + s4 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s4 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s4 !== peg$FAILED) { + s2 = [s2, s3, s4]; + s1 = s2; + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + if (s1 !== peg$FAILED) { + s2 = peg$f2(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s0 = peg$f3(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsedouble_ligature() { + var s0; + s0 = peg$parsedouble_macro_ligature(); + if (s0 === peg$FAILED) { + s0 = peg$parsedouble_macro_ligature_extracted(); + if (s0 === peg$FAILED) { + s0 = peg$parsedouble_char_ligature(); + } + } + return s0; + } + function peg$parsedouble_macro_ligature_extracted() { + var s0, s1, s2, s3, s4; + s0 = peg$currPos; + s1 = peg$parsemacro(); + if (s1 !== peg$FAILED) { + s2 = []; + s3 = peg$parsewhitespace(); + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$parsewhitespace(); + } + s3 = peg$parsesplitable(); + if (s3 !== peg$FAILED) { + s4 = peg$f4(s1, s3); + if (s4) { + s4 = void 0; + } else { + s4 = peg$FAILED; + } + if (s4 !== peg$FAILED) { + s0 = peg$f5(s1, s3); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsedouble_macro_ligature() { + var s0, s1, s2, s3, s4; + s0 = peg$currPos; + s1 = peg$parsemacro(); + if (s1 !== peg$FAILED) { + s2 = []; + s3 = peg$parsewhitespace(); + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$parsewhitespace(); + } + if (input.length > peg$currPos) { + s3 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s3 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s3 !== peg$FAILED) { + s4 = peg$f6(s1, s3); + if (s4) { + s4 = void 0; + } else { + s4 = peg$FAILED; + } + if (s4 !== peg$FAILED) { + s0 = peg$f7(s1, s3); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsedouble_char_ligature() { + var s0, s1, s2, s3; + s0 = peg$currPos; + s1 = peg$currPos; + if (input.length > peg$currPos) { + s2 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s2 !== peg$FAILED) { + if (input.length > peg$currPos) { + s3 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s3 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s3 !== peg$FAILED) { + s2 = [s2, s3]; + s1 = s2; + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + if (s1 !== peg$FAILED) { + s2 = peg$f8(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s0 = peg$f9(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsemono_ligature() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f10(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s0 = peg$f11(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsemacro() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f12(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s0 = peg$f13(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsewhitespace() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f14(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s0 = peg$f15(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsesplitable() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f16(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s0 = peg$f17(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parseEOL() { + var s0, s1; + s0 = peg$currPos; + peg$silentFails++; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + peg$silentFails--; + if (s1 === peg$FAILED) { + s0 = void 0; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + if (!options.isWhitespace) { + try { + Object.assign(options, { + isMacro: (node) => node.type === "macro", + isWhitespace: (node) => node.type === "whitespace", + isRecognized: (nodes) => { + if (nodes.length == 2 && nodes[0].content === "^" && nodes[1].content === "o") { + return { type: "string", content: "ô" }; + } + return null; + }, + isSplitable: (node) => node.type === "string" && node.content.length > 1, + split: (node) => [ + { type: "string", content: node.content.charAt(0) }, + { type: "string", content: node.content.slice(1) } + ] + }); + } catch (e) { + console.warn("Error when initializing parser", e); + } + } + peg$result = peg$startRuleFunction(); + if (peg$result !== peg$FAILED && peg$currPos === input.length) { + return peg$result; + } else { + if (peg$result !== peg$FAILED && peg$currPos < input.length) { + peg$fail(peg$endExpectation()); + } + throw peg$buildStructuredError( + peg$maxFailExpected, + peg$maxFailPos < input.length ? input.charAt(peg$maxFailPos) : null, + peg$maxFailPos < input.length ? peg$computeLocation(peg$maxFailPos, peg$maxFailPos + 1) : peg$computeLocation(peg$maxFailPos, peg$maxFailPos) + ); + } + } + return { + SyntaxError: peg$SyntaxError, + parse: peg$parse + }; + }() +); +const _XColorPegParser = ( + // Generated by Peggy 3.0.2. + // + // https://peggyjs.org/ + function() { + function peg$subclass(child, parent) { + function C() { + this.constructor = child; + } + C.prototype = parent.prototype; + child.prototype = new C(); + } + function peg$SyntaxError(message, expected, found, location) { + var self = Error.call(this, message); + if (Object.setPrototypeOf) { + Object.setPrototypeOf(self, peg$SyntaxError.prototype); + } + self.expected = expected; + self.found = found; + self.location = location; + self.name = "SyntaxError"; + return self; + } + peg$subclass(peg$SyntaxError, Error); + function peg$padEnd(str, targetLength, padString) { + padString = padString || " "; + if (str.length > targetLength) { + return str; + } + targetLength -= str.length; + padString += padString.repeat(targetLength); + return str + padString.slice(0, targetLength); + } + peg$SyntaxError.prototype.format = function(sources) { + var str = "Error: " + this.message; + if (this.location) { + var src = null; + var k; + for (k = 0; k < sources.length; k++) { + if (sources[k].source === this.location.source) { + src = sources[k].text.split(/\r\n|\n|\r/g); + break; + } + } + var s = this.location.start; + var offset_s = this.location.source && typeof this.location.source.offset === "function" ? this.location.source.offset(s) : s; + var loc = this.location.source + ":" + offset_s.line + ":" + offset_s.column; + if (src) { + var e = this.location.end; + var filler = peg$padEnd("", offset_s.line.toString().length, " "); + var line = src[s.line - 1]; + var last = s.line === e.line ? e.column : line.length + 1; + var hatLen = last - s.column || 1; + str += "\n --> " + loc + "\n" + filler + " |\n" + offset_s.line + " | " + line + "\n" + filler + " | " + peg$padEnd("", s.column - 1, " ") + peg$padEnd("", hatLen, "^"); + } else { + str += "\n at " + loc; + } + } + return str; + }; + peg$SyntaxError.buildMessage = function(expected, found) { + var DESCRIBE_EXPECTATION_FNS = { + literal: function(expectation) { + return '"' + literalEscape(expectation.text) + '"'; + }, + class: function(expectation) { + var escapedParts = expectation.parts.map(function(part) { + return Array.isArray(part) ? classEscape(part[0]) + "-" + classEscape(part[1]) : classEscape(part); + }); + return "[" + (expectation.inverted ? "^" : "") + escapedParts.join("") + "]"; + }, + any: function() { + return "any character"; + }, + end: function() { + return "end of input"; + }, + other: function(expectation) { + return expectation.description; + } + }; + function hex(ch) { + return ch.charCodeAt(0).toString(16).toUpperCase(); + } + function literalEscape(s) { + return s.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\0/g, "\\0").replace(/\t/g, "\\t").replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/[\x00-\x0F]/g, function(ch) { + return "\\x0" + hex(ch); + }).replace(/[\x10-\x1F\x7F-\x9F]/g, function(ch) { + return "\\x" + hex(ch); + }); + } + function classEscape(s) { + return s.replace(/\\/g, "\\\\").replace(/\]/g, "\\]").replace(/\^/g, "\\^").replace(/-/g, "\\-").replace(/\0/g, "\\0").replace(/\t/g, "\\t").replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/[\x00-\x0F]/g, function(ch) { + return "\\x0" + hex(ch); + }).replace(/[\x10-\x1F\x7F-\x9F]/g, function(ch) { + return "\\x" + hex(ch); + }); + } + function describeExpectation(expectation) { + return DESCRIBE_EXPECTATION_FNS[expectation.type](expectation); + } + function describeExpected(expected2) { + var descriptions = expected2.map(describeExpectation); + var i, j; + descriptions.sort(); + if (descriptions.length > 0) { + for (i = 1, j = 1; i < descriptions.length; i++) { + if (descriptions[i - 1] !== descriptions[i]) { + descriptions[j] = descriptions[i]; + j++; + } + } + descriptions.length = j; + } + switch (descriptions.length) { + case 1: + return descriptions[0]; + case 2: + return descriptions[0] + " or " + descriptions[1]; + default: + return descriptions.slice(0, -1).join(", ") + ", or " + descriptions[descriptions.length - 1]; + } + } + function describeFound(found2) { + return found2 ? '"' + literalEscape(found2) + '"' : "end of input"; + } + return "Expected " + describeExpected(expected) + " but " + describeFound(found) + " found."; + }; + function peg$parse(input, options) { + options = options !== void 0 ? options : {}; + var peg$FAILED = {}; + var peg$source = options.grammarSource; + var peg$startRuleFunctions = { start: peg$parsestart }; + var peg$startRuleFunction = peg$parsestart; + var peg$c0 = ";"; + var peg$c1 = ","; + var peg$c2 = ":"; + var peg$c3 = "/"; + var peg$c4 = ">"; + var peg$c5 = "!"; + var peg$c6 = "."; + var peg$c7 = "!!["; + var peg$c8 = "]"; + var peg$c9 = "!!"; + var peg$c10 = "+"; + var peg$c11 = "-"; + var peg$r0 = /^[a-zA-Z0-9]/; + var peg$r1 = /^[0-9]/; + var peg$r2 = /^[ \t\n\r]/; + var peg$r3 = /^[0-9a-fA-F]/; + var peg$e0 = peg$anyExpectation(); + var peg$e1 = peg$literalExpectation(";", false); + var peg$e2 = peg$literalExpectation(",", false); + var peg$e3 = peg$otherExpectation("model list"); + var peg$e4 = peg$literalExpectation(":", false); + var peg$e5 = peg$literalExpectation("/", false); + var peg$e6 = peg$otherExpectation("model"); + var peg$e7 = peg$otherExpectation("color spec list"); + var peg$e8 = peg$otherExpectation("color spec"); + var peg$e9 = peg$otherExpectation("color"); + var peg$e10 = peg$otherExpectation("function expression"); + var peg$e11 = peg$literalExpectation(">", false); + var peg$e12 = peg$otherExpectation("function"); + var peg$e13 = peg$otherExpectation("extended expression"); + var peg$e14 = peg$otherExpectation("core model"); + var peg$e15 = peg$otherExpectation("expr"); + var peg$e16 = peg$literalExpectation("!", false); + var peg$e17 = peg$otherExpectation("mix expr"); + var peg$e18 = peg$otherExpectation("name"); + var peg$e19 = peg$literalExpectation(".", false); + var peg$e20 = peg$classExpectation([["a", "z"], ["A", "Z"], ["0", "9"]], false, false); + var peg$e21 = peg$otherExpectation("postfix"); + var peg$e22 = peg$literalExpectation("!![", false); + var peg$e23 = peg$literalExpectation("]", false); + var peg$e24 = peg$literalExpectation("!!", false); + var peg$e25 = peg$otherExpectation("prefix"); + var peg$e26 = peg$otherExpectation("plus"); + var peg$e27 = peg$literalExpectation("+", false); + var peg$e28 = peg$otherExpectation("minus"); + var peg$e29 = peg$literalExpectation("-", false); + var peg$e30 = peg$otherExpectation("num"); + var peg$e31 = peg$classExpectation([["0", "9"]], false, false); + var peg$e32 = peg$otherExpectation("positive float"); + var peg$e33 = peg$otherExpectation("divisor"); + var peg$e34 = peg$otherExpectation("int"); + var peg$e36 = peg$classExpectation([" ", " ", "\n", "\r"], false, false); + var peg$e37 = peg$classExpectation([["0", "9"], ["a", "f"], ["A", "F"]], false, false); + var peg$f0 = function(m) { + return m; + }; + var peg$f1 = function(m) { + return m; + }; + var peg$f2 = function(m) { + return m; + }; + var peg$f3 = function(m) { + return m; + }; + var peg$f4 = function(m) { + return m; + }; + var peg$f5 = function(a) { + return { type: "invalid_spec", content: a }; + }; + var peg$f6 = function(f, c) { + return c; + }; + var peg$f7 = function(f, r) { + return { type: "color_set", content: [f].concat(r) }; + }; + var peg$f8 = function(n, s) { + return { type: "color_set_item", name: n, spec_list: s }; + }; + var peg$f9 = function(c, m) { + return { type: "model_list", contents: m, core_model: c }; + }; + var peg$f10 = function(m) { + return { type: "model_list", contents: m, core_model: null }; + }; + var peg$f11 = function(m, a) { + return a; + }; + var peg$f12 = function(m, r) { + return [m].concat(r); + }; + var peg$f13 = function(s, a) { + return a; + }; + var peg$f14 = function(s, r) { + return { type: "spec_list", content: [s].concat(r) }; + }; + var peg$f15 = function(c) { + return { type: "hex_spec", content: [c] }; + }; + var peg$f16 = function(c, d) { + return d; + }; + var peg$f17 = function(c, d) { + return d; + }; + var peg$f18 = function(c, r) { + return { type: "num_spec", content: r ? [c].concat(r) : [c] }; + }; + var peg$f19 = function(c, fs) { + return { type: "color", color: c, functions: fs }; + }; + var peg$f20 = function(f, n) { + return n; + }; + var peg$f21 = function(f, args) { + return { type: "function", name: f, args }; + }; + var peg$f22 = function(core, d, e, es) { + return { + type: "extended_expr", + core_model: core, + div: d, + expressions: [e].concat(es) + }; + }; + var peg$f23 = function(core, e, es) { + return { + type: "extended_expr", + core_model: core, + div: null, + expressions: [e].concat(es) + }; + }; + var peg$f24 = function(e, d) { + return { type: "weighted_expr", color: e, weight: d }; + }; + var peg$f25 = function(e) { + return e; + }; + var peg$f26 = function(p, n, e, po) { + return { + type: "expr", + prefix: p, + name: n, + mix_expr: e, + postfix: po + }; + }; + var peg$f27 = function(p, n) { + return { type: "complete_mix", mix_percent: p, name: n }; + }; + var peg$f28 = function(p) { + return { type: "partial_mix", mix_percent: p }; + }; + var peg$f29 = function(c, p) { + return c.concat(p || []); + }; + var peg$f30 = function(n) { + return { type: "postfix", num: n }; + }; + var peg$f31 = function(p) { + return { type: "postfix", plusses: p }; + }; + var peg$f32 = function(n) { + return parseInt(n, 10); + }; + var peg$f33 = function(n) { + return parseFloat(n); + }; + var peg$f34 = function(n) { + return n; + }; + var peg$f35 = function(n) { + return -n; + }; + var peg$f36 = function(m, n) { + return m ? -n : n; + }; + var peg$f37 = function(h) { + return h.toUpperCase(); + }; + var peg$currPos = 0; + var peg$posDetailsCache = [{ line: 1, column: 1 }]; + var peg$maxFailPos = 0; + var peg$maxFailExpected = []; + var peg$silentFails = 0; + var peg$result; + if ("startRule" in options) { + if (!(options.startRule in peg$startRuleFunctions)) { + throw new Error(`Can't start parsing from rule "` + options.startRule + '".'); + } + peg$startRuleFunction = peg$startRuleFunctions[options.startRule]; + } + function peg$literalExpectation(text2, ignoreCase) { + return { type: "literal", text: text2, ignoreCase }; + } + function peg$classExpectation(parts, inverted, ignoreCase) { + return { type: "class", parts, inverted, ignoreCase }; + } + function peg$anyExpectation() { + return { type: "any" }; + } + function peg$endExpectation() { + return { type: "end" }; + } + function peg$otherExpectation(description) { + return { type: "other", description }; + } + function peg$computePosDetails(pos) { + var details = peg$posDetailsCache[pos]; + var p; + if (details) { + return details; + } else { + p = pos - 1; + while (!peg$posDetailsCache[p]) { + p--; + } + details = peg$posDetailsCache[p]; + details = { + line: details.line, + column: details.column + }; + while (p < pos) { + if (input.charCodeAt(p) === 10) { + details.line++; + details.column = 1; + } else { + details.column++; + } + p++; + } + peg$posDetailsCache[pos] = details; + return details; + } + } + function peg$computeLocation(startPos, endPos, offset2) { + var startPosDetails = peg$computePosDetails(startPos); + var endPosDetails = peg$computePosDetails(endPos); + var res = { + source: peg$source, + start: { + offset: startPos, + line: startPosDetails.line, + column: startPosDetails.column + }, + end: { + offset: endPos, + line: endPosDetails.line, + column: endPosDetails.column + } + }; + return res; + } + function peg$fail(expected2) { + if (peg$currPos < peg$maxFailPos) { + return; + } + if (peg$currPos > peg$maxFailPos) { + peg$maxFailPos = peg$currPos; + peg$maxFailExpected = []; + } + peg$maxFailExpected.push(expected2); + } + function peg$buildStructuredError(expected2, found, location2) { + return new peg$SyntaxError( + peg$SyntaxError.buildMessage(expected2, found), + expected2, + found, + location2 + ); + } + function peg$parsestart() { + var s0, s1, s2, s3; + s0 = peg$currPos; + s1 = peg$parsespec(); + if (s1 !== peg$FAILED) { + s2 = peg$parseEOL(); + if (s2 !== peg$FAILED) { + s0 = peg$f0(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$parsespec_list(); + if (s1 !== peg$FAILED) { + s2 = peg$parseEOL(); + if (s2 !== peg$FAILED) { + s0 = peg$f1(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$parsecolor(); + if (s1 !== peg$FAILED) { + s2 = peg$parseEOL(); + if (s2 !== peg$FAILED) { + s0 = peg$f2(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$parsemodel_list(); + if (s1 !== peg$FAILED) { + s2 = peg$parseEOL(); + if (s2 !== peg$FAILED) { + s0 = peg$f3(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$parsecolor_set_spec(); + if (s1 !== peg$FAILED) { + s2 = peg$parseEOL(); + if (s2 !== peg$FAILED) { + s0 = peg$f4(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$currPos; + s2 = []; + if (input.length > peg$currPos) { + s3 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s3 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + while (s3 !== peg$FAILED) { + s2.push(s3); + if (input.length > peg$currPos) { + s3 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s3 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + } + s1 = input.substring(s1, peg$currPos); + s1 = peg$f5(s1); + s0 = s1; + } + } + } + } + } + return s0; + } + function peg$parsecolor_set_spec() { + var s0, s1, s2, s3, s4, s5; + s0 = peg$currPos; + s1 = peg$parsecolor_set_item(); + if (s1 !== peg$FAILED) { + s2 = []; + s3 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 59) { + s4 = peg$c0; + peg$currPos++; + } else { + s4 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e1); + } + } + if (s4 !== peg$FAILED) { + s5 = peg$parsecolor_set_item(); + if (s5 !== peg$FAILED) { + s3 = peg$f6(s1, s5); + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 59) { + s4 = peg$c0; + peg$currPos++; + } else { + s4 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e1); + } + } + if (s4 !== peg$FAILED) { + s5 = peg$parsecolor_set_item(); + if (s5 !== peg$FAILED) { + s3 = peg$f6(s1, s5); + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } + s0 = peg$f7(s1, s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsecolor_set_item() { + var s0, s1, s2, s3; + s0 = peg$currPos; + s1 = peg$parsename(); + if (s1 !== peg$FAILED) { + if (input.charCodeAt(peg$currPos) === 44) { + s2 = peg$c1; + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e2); + } + } + if (s2 !== peg$FAILED) { + s3 = peg$parsespec_list(); + if (s3 !== peg$FAILED) { + s0 = peg$f8(s1, s3); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsemodel_list() { + var s0, s1, s2, s3; + peg$silentFails++; + s0 = peg$currPos; + s1 = peg$parsecore_model(); + if (s1 !== peg$FAILED) { + if (input.charCodeAt(peg$currPos) === 58) { + s2 = peg$c2; + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e4); + } + } + if (s2 !== peg$FAILED) { + s3 = peg$parsemodel_list_tail(); + if (s3 !== peg$FAILED) { + s0 = peg$f9(s1, s3); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$parsemodel_list_tail(); + if (s1 !== peg$FAILED) { + s1 = peg$f10(s1); + } + s0 = s1; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + return s0; + } + function peg$parsemodel_list_tail() { + var s0, s1, s2, s3, s4, s5; + s0 = peg$currPos; + s1 = peg$parsemodel(); + if (s1 !== peg$FAILED) { + s2 = []; + s3 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 47) { + s4 = peg$c3; + peg$currPos++; + } else { + s4 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e5); + } + } + if (s4 !== peg$FAILED) { + s5 = peg$parsemodel(); + if (s5 !== peg$FAILED) { + s3 = peg$f11(s1, s5); + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 47) { + s4 = peg$c3; + peg$currPos++; + } else { + s4 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e5); + } + } + if (s4 !== peg$FAILED) { + s5 = peg$parsemodel(); + if (s5 !== peg$FAILED) { + s3 = peg$f11(s1, s5); + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } + s0 = peg$f12(s1, s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsemodel() { + var s0; + peg$silentFails++; + s0 = peg$parsecore_model(); + peg$silentFails--; + if (s0 === peg$FAILED) { + if (peg$silentFails === 0) { + peg$fail(peg$e6); + } + } + return s0; + } + function peg$parsespec_list() { + var s0, s1, s2, s3, s4, s5; + peg$silentFails++; + s0 = peg$currPos; + s1 = peg$parsespec(); + if (s1 !== peg$FAILED) { + s2 = []; + s3 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 47) { + s4 = peg$c3; + peg$currPos++; + } else { + s4 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e5); + } + } + if (s4 !== peg$FAILED) { + s5 = peg$parsespec(); + if (s5 !== peg$FAILED) { + s3 = peg$f13(s1, s5); + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 47) { + s4 = peg$c3; + peg$currPos++; + } else { + s4 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e5); + } + } + if (s4 !== peg$FAILED) { + s5 = peg$parsespec(); + if (s5 !== peg$FAILED) { + s3 = peg$f13(s1, s5); + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } + s0 = peg$f14(s1, s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e7); + } + } + return s0; + } + function peg$parsespec() { + var s0, s1, s2, s3, s4, s5, s6, s7, s8; + peg$silentFails++; + s0 = peg$currPos; + s1 = peg$currPos; + s2 = peg$currPos; + s3 = peg$parsehex(); + if (s3 !== peg$FAILED) { + s4 = peg$parsehex(); + if (s4 !== peg$FAILED) { + s5 = peg$parsehex(); + if (s5 !== peg$FAILED) { + s6 = peg$parsehex(); + if (s6 !== peg$FAILED) { + s7 = peg$parsehex(); + if (s7 !== peg$FAILED) { + s8 = peg$parsehex(); + if (s8 !== peg$FAILED) { + s3 = [s3, s4, s5, s6, s7, s8]; + s2 = s3; + } else { + peg$currPos = s2; + s2 = peg$FAILED; + } + } else { + peg$currPos = s2; + s2 = peg$FAILED; + } + } else { + peg$currPos = s2; + s2 = peg$FAILED; + } + } else { + peg$currPos = s2; + s2 = peg$FAILED; + } + } else { + peg$currPos = s2; + s2 = peg$FAILED; + } + } else { + peg$currPos = s2; + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s1 = input.substring(s1, peg$currPos); + } else { + s1 = s2; + } + if (s1 !== peg$FAILED) { + s1 = peg$f15(s1); + } + s0 = s1; + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$parsedec(); + if (s1 !== peg$FAILED) { + s2 = []; + s3 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 44) { + s4 = peg$c1; + peg$currPos++; + } else { + s4 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e2); + } + } + if (s4 !== peg$FAILED) { + s5 = peg$parsedec(); + if (s5 !== peg$FAILED) { + s3 = peg$f16(s1, s5); + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + if (s3 !== peg$FAILED) { + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 44) { + s4 = peg$c1; + peg$currPos++; + } else { + s4 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e2); + } + } + if (s4 !== peg$FAILED) { + s5 = peg$parsedec(); + if (s5 !== peg$FAILED) { + s3 = peg$f16(s1, s5); + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } + } else { + s2 = peg$FAILED; + } + if (s2 === peg$FAILED) { + s2 = []; + s3 = peg$currPos; + s4 = peg$parsesp(); + if (s4 !== peg$FAILED) { + s5 = peg$parsedec(); + if (s5 !== peg$FAILED) { + s3 = peg$f17(s1, s5); + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + if (s3 !== peg$FAILED) { + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$currPos; + s4 = peg$parsesp(); + if (s4 !== peg$FAILED) { + s5 = peg$parsedec(); + if (s5 !== peg$FAILED) { + s3 = peg$f17(s1, s5); + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } + } else { + s2 = peg$FAILED; + } + } + if (s2 === peg$FAILED) { + s2 = null; + } + s0 = peg$f18(s1, s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e8); + } + } + return s0; + } + function peg$parsecolor() { + var s0, s1, s2, s3; + peg$silentFails++; + s0 = peg$currPos; + s1 = peg$parsecolor_expr(); + if (s1 !== peg$FAILED) { + s2 = []; + s3 = peg$parsefunc_expr(); + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$parsefunc_expr(); + } + s0 = peg$f19(s1, s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e9); + } + } + return s0; + } + function peg$parsecolor_expr() { + var s0; + s0 = peg$parseext_expr(); + if (s0 === peg$FAILED) { + s0 = peg$parseexpr(); + if (s0 === peg$FAILED) { + s0 = peg$parsename(); + } + } + return s0; + } + function peg$parsefunc_expr() { + var s0, s1, s2, s3, s4, s5, s6; + peg$silentFails++; + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 62) { + s1 = peg$c4; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e11); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$parsefunction(); + if (s2 !== peg$FAILED) { + s3 = []; + s4 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 44) { + s5 = peg$c1; + peg$currPos++; + } else { + s5 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e2); + } + } + if (s5 !== peg$FAILED) { + s6 = peg$parseint(); + if (s6 !== peg$FAILED) { + s4 = peg$f20(s2, s6); + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + while (s4 !== peg$FAILED) { + s3.push(s4); + s4 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 44) { + s5 = peg$c1; + peg$currPos++; + } else { + s5 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e2); + } + } + if (s5 !== peg$FAILED) { + s6 = peg$parseint(); + if (s6 !== peg$FAILED) { + s4 = peg$f20(s2, s6); + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + } + s0 = peg$f21(s2, s3); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e10); + } + } + return s0; + } + function peg$parsefunction() { + var s0; + peg$silentFails++; + s0 = peg$parsename(); + peg$silentFails--; + if (s0 === peg$FAILED) { + if (peg$silentFails === 0) { + peg$fail(peg$e12); + } + } + return s0; + } + function peg$parseext_expr() { + var s0, s1, s2, s3, s4, s5, s6, s7; + peg$silentFails++; + s0 = peg$currPos; + s1 = peg$parsecore_model(); + if (s1 !== peg$FAILED) { + if (input.charCodeAt(peg$currPos) === 44) { + s2 = peg$c1; + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e2); + } + } + if (s2 !== peg$FAILED) { + s3 = peg$parsediv(); + if (s3 !== peg$FAILED) { + if (input.charCodeAt(peg$currPos) === 58) { + s4 = peg$c2; + peg$currPos++; + } else { + s4 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e4); + } + } + if (s4 !== peg$FAILED) { + s5 = peg$parseweighted_expr(); + if (s5 !== peg$FAILED) { + s6 = []; + s7 = peg$parseadditional_weighted_expr(); + while (s7 !== peg$FAILED) { + s6.push(s7); + s7 = peg$parseadditional_weighted_expr(); + } + s0 = peg$f22(s1, s3, s5, s6); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$parsecore_model(); + if (s1 !== peg$FAILED) { + if (input.charCodeAt(peg$currPos) === 58) { + s2 = peg$c2; + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e4); + } + } + if (s2 !== peg$FAILED) { + s3 = peg$parseweighted_expr(); + if (s3 !== peg$FAILED) { + s4 = []; + s5 = peg$parseadditional_weighted_expr(); + while (s5 !== peg$FAILED) { + s4.push(s5); + s5 = peg$parseadditional_weighted_expr(); + } + s0 = peg$f23(s1, s3, s4); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e13); + } + } + return s0; + } + function peg$parseweighted_expr() { + var s0, s1, s2, s3; + s0 = peg$currPos; + s1 = peg$parseexpr(); + if (s1 !== peg$FAILED) { + if (input.charCodeAt(peg$currPos) === 44) { + s2 = peg$c1; + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e2); + } + } + if (s2 !== peg$FAILED) { + s3 = peg$parsedec(); + if (s3 !== peg$FAILED) { + s0 = peg$f24(s1, s3); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parseadditional_weighted_expr() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 59) { + s1 = peg$c0; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e1); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$parseweighted_expr(); + if (s2 !== peg$FAILED) { + s0 = peg$f25(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsecore_model() { + var s0; + peg$silentFails++; + s0 = peg$parsename(); + peg$silentFails--; + if (s0 === peg$FAILED) { + if (peg$silentFails === 0) { + peg$fail(peg$e14); + } + } + return s0; + } + function peg$parseexpr() { + var s0, s1, s2, s3, s4; + peg$silentFails++; + s0 = peg$currPos; + s1 = peg$parseprefix(); + s2 = peg$parsename(); + if (s2 !== peg$FAILED) { + s3 = peg$parsemix_expr(); + s4 = peg$parsepostfix(); + if (s4 === peg$FAILED) { + s4 = null; + } + s0 = peg$f26(s1, s2, s3, s4); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e15); + } + } + return s0; + } + function peg$parsecomplete_mix() { + var s0, s1, s2, s3, s4; + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 33) { + s1 = peg$c5; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e16); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$parsepct(); + if (s2 !== peg$FAILED) { + if (input.charCodeAt(peg$currPos) === 33) { + s3 = peg$c5; + peg$currPos++; + } else { + s3 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e16); + } + } + if (s3 !== peg$FAILED) { + s4 = peg$parsename(); + if (s4 !== peg$FAILED) { + s0 = peg$f27(s2, s4); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsepartial_mix() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 33) { + s1 = peg$c5; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e16); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$parsepct(); + if (s2 !== peg$FAILED) { + s0 = peg$f28(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsemix_expr() { + var s0, s1, s2; + peg$silentFails++; + s0 = peg$currPos; + s1 = []; + s2 = peg$parsecomplete_mix(); + while (s2 !== peg$FAILED) { + s1.push(s2); + s2 = peg$parsecomplete_mix(); + } + s2 = peg$parsepartial_mix(); + if (s2 === peg$FAILED) { + s2 = null; + } + s0 = peg$f29(s1, s2); + peg$silentFails--; + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e17); + } + return s0; + } + function peg$parsename() { + var s0, s1, s2; + peg$silentFails++; + if (input.charCodeAt(peg$currPos) === 46) { + s0 = peg$c6; + peg$currPos++; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e19); + } + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = []; + if (peg$r0.test(input.charAt(peg$currPos))) { + s2 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e20); + } + } + if (s2 !== peg$FAILED) { + while (s2 !== peg$FAILED) { + s1.push(s2); + if (peg$r0.test(input.charAt(peg$currPos))) { + s2 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e20); + } + } + } + } else { + s1 = peg$FAILED; + } + if (s1 !== peg$FAILED) { + s0 = input.substring(s0, peg$currPos); + } else { + s0 = s1; + } + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e18); + } + } + return s0; + } + function peg$parsepostfix() { + var s0, s1, s2, s3, s4; + peg$silentFails++; + s0 = peg$currPos; + if (input.substr(peg$currPos, 3) === peg$c7) { + s1 = peg$c7; + peg$currPos += 3; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e22); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$parsenum(); + if (s2 !== peg$FAILED) { + if (input.charCodeAt(peg$currPos) === 93) { + s3 = peg$c8; + peg$currPos++; + } else { + s3 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e23); + } + } + if (s3 !== peg$FAILED) { + s0 = peg$f30(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + if (input.substr(peg$currPos, 2) === peg$c9) { + s1 = peg$c9; + peg$currPos += 2; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e24); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$currPos; + s3 = []; + s4 = peg$parseplus(); + if (s4 !== peg$FAILED) { + while (s4 !== peg$FAILED) { + s3.push(s4); + s4 = peg$parseplus(); + } + } else { + s3 = peg$FAILED; + } + if (s3 !== peg$FAILED) { + s2 = input.substring(s2, peg$currPos); + } else { + s2 = s3; + } + if (s2 !== peg$FAILED) { + s0 = peg$f31(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e21); + } + } + return s0; + } + function peg$parseprefix() { + var s0; + peg$silentFails++; + s0 = peg$parseminus(); + if (s0 === peg$FAILED) { + s0 = null; + } + peg$silentFails--; + if (peg$silentFails === 0) { + peg$fail(peg$e25); + } + return s0; + } + function peg$parseplus() { + var s0, s1, s2; + peg$silentFails++; + s0 = peg$currPos; + s1 = []; + if (input.charCodeAt(peg$currPos) === 43) { + s2 = peg$c10; + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e27); + } + } + if (s2 !== peg$FAILED) { + while (s2 !== peg$FAILED) { + s1.push(s2); + if (input.charCodeAt(peg$currPos) === 43) { + s2 = peg$c10; + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e27); + } + } + } + } else { + s1 = peg$FAILED; + } + if (s1 !== peg$FAILED) { + s0 = input.substring(s0, peg$currPos); + } else { + s0 = s1; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e26); + } + } + return s0; + } + function peg$parseminus() { + var s0, s1, s2; + peg$silentFails++; + s0 = peg$currPos; + s1 = []; + if (input.charCodeAt(peg$currPos) === 45) { + s2 = peg$c11; + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e29); + } + } + if (s2 !== peg$FAILED) { + while (s2 !== peg$FAILED) { + s1.push(s2); + if (input.charCodeAt(peg$currPos) === 45) { + s2 = peg$c11; + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e29); + } + } + } + } else { + s1 = peg$FAILED; + } + if (s1 !== peg$FAILED) { + s0 = input.substring(s0, peg$currPos); + } else { + s0 = s1; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e28); + } + } + return s0; + } + function peg$parsenum() { + var s0, s1, s2, s3; + peg$silentFails++; + s0 = peg$currPos; + s1 = peg$currPos; + s2 = []; + if (peg$r1.test(input.charAt(peg$currPos))) { + s3 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s3 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e31); + } + } + if (s3 !== peg$FAILED) { + while (s3 !== peg$FAILED) { + s2.push(s3); + if (peg$r1.test(input.charAt(peg$currPos))) { + s3 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s3 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e31); + } + } + } + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s1 = input.substring(s1, peg$currPos); + } else { + s1 = s2; + } + if (s1 !== peg$FAILED) { + s1 = peg$f32(s1); + } + s0 = s1; + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e30); + } + } + return s0; + } + function peg$parsepct() { + var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9; + peg$silentFails++; + s0 = peg$currPos; + s1 = peg$currPos; + s2 = peg$currPos; + s3 = peg$currPos; + s4 = []; + if (peg$r1.test(input.charAt(peg$currPos))) { + s5 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s5 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e31); + } + } + if (s5 !== peg$FAILED) { + while (s5 !== peg$FAILED) { + s4.push(s5); + if (peg$r1.test(input.charAt(peg$currPos))) { + s5 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s5 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e31); + } + } + } + } else { + s4 = peg$FAILED; + } + if (s4 !== peg$FAILED) { + s3 = input.substring(s3, peg$currPos); + } else { + s3 = s4; + } + if (s3 !== peg$FAILED) { + s4 = peg$currPos; + s5 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 46) { + s6 = peg$c6; + peg$currPos++; + } else { + s6 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e19); + } + } + if (s6 !== peg$FAILED) { + s7 = peg$currPos; + s8 = []; + if (peg$r1.test(input.charAt(peg$currPos))) { + s9 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s9 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e31); + } + } + while (s9 !== peg$FAILED) { + s8.push(s9); + if (peg$r1.test(input.charAt(peg$currPos))) { + s9 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s9 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e31); + } + } + } + s7 = input.substring(s7, peg$currPos); + s6 = [s6, s7]; + s5 = s6; + } else { + peg$currPos = s5; + s5 = peg$FAILED; + } + if (s5 === peg$FAILED) { + s5 = null; + } + s4 = input.substring(s4, peg$currPos); + s3 = [s3, s4]; + s2 = s3; + } else { + peg$currPos = s2; + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s1 = input.substring(s1, peg$currPos); + } else { + s1 = s2; + } + if (s1 === peg$FAILED) { + s1 = peg$currPos; + s2 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 46) { + s3 = peg$c6; + peg$currPos++; + } else { + s3 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e19); + } + } + if (s3 !== peg$FAILED) { + s4 = peg$currPos; + s5 = []; + if (peg$r1.test(input.charAt(peg$currPos))) { + s6 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s6 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e31); + } + } + if (s6 !== peg$FAILED) { + while (s6 !== peg$FAILED) { + s5.push(s6); + if (peg$r1.test(input.charAt(peg$currPos))) { + s6 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s6 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e31); + } + } + } + } else { + s5 = peg$FAILED; + } + if (s5 !== peg$FAILED) { + s4 = input.substring(s4, peg$currPos); + } else { + s4 = s5; + } + if (s4 !== peg$FAILED) { + s3 = [s3, s4]; + s2 = s3; + } else { + peg$currPos = s2; + s2 = peg$FAILED; + } + } else { + peg$currPos = s2; + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s1 = input.substring(s1, peg$currPos); + } else { + s1 = s2; + } + } + if (s1 !== peg$FAILED) { + s1 = peg$f33(s1); + } + s0 = s1; + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e32); + } + } + return s0; + } + function peg$parsediv() { + var s0; + peg$silentFails++; + s0 = peg$parsepct(); + peg$silentFails--; + if (s0 === peg$FAILED) { + if (peg$silentFails === 0) { + peg$fail(peg$e33); + } + } + return s0; + } + function peg$parsedec() { + var s0, s1, s2; + s0 = peg$parsepct(); + if (s0 === peg$FAILED) { + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 43) { + s1 = peg$c10; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e27); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$parsepct(); + if (s2 !== peg$FAILED) { + s0 = peg$f34(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 45) { + s1 = peg$c11; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e29); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$parsepct(); + if (s2 !== peg$FAILED) { + s0 = peg$f35(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } + } + return s0; + } + function peg$parseint() { + var s0, s1, s2; + peg$silentFails++; + s0 = peg$currPos; + s1 = peg$parseminus(); + if (s1 === peg$FAILED) { + s1 = null; + } + s2 = peg$parsenum(); + if (s2 !== peg$FAILED) { + s0 = peg$f36(s1, s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e34); + } + } + return s0; + } + function peg$parsesp() { + var s0, s1; + s0 = []; + if (peg$r2.test(input.charAt(peg$currPos))) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e36); + } + } + if (s1 !== peg$FAILED) { + while (s1 !== peg$FAILED) { + s0.push(s1); + if (peg$r2.test(input.charAt(peg$currPos))) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e36); + } + } + } + } else { + s0 = peg$FAILED; + } + return s0; + } + function peg$parsehex() { + var s0, s1; + s0 = peg$currPos; + if (peg$r3.test(input.charAt(peg$currPos))) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e37); + } + } + if (s1 !== peg$FAILED) { + s1 = peg$f37(s1); + } + s0 = s1; + return s0; + } + function peg$parseEOL() { + var s0, s1; + s0 = peg$currPos; + peg$silentFails++; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + peg$silentFails--; + if (s1 === peg$FAILED) { + s0 = void 0; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + peg$result = peg$startRuleFunction(); + if (peg$result !== peg$FAILED && peg$currPos === input.length) { + return peg$result; + } else { + if (peg$result !== peg$FAILED && peg$currPos < input.length) { + peg$fail(peg$endExpectation()); + } + throw peg$buildStructuredError( + peg$maxFailExpected, + peg$maxFailPos < input.length ? input.charAt(peg$maxFailPos) : null, + peg$maxFailPos < input.length ? peg$computeLocation(peg$maxFailPos, peg$maxFailPos + 1) : peg$computeLocation(peg$maxFailPos, peg$maxFailPos) + ); + } + } + return { + SyntaxError: peg$SyntaxError, + parse: peg$parse + }; + }() +); +const _TabularPegParser = ( + // Generated by Peggy 3.0.2. + // + // https://peggyjs.org/ + function() { + function peg$subclass(child, parent) { + function C() { + this.constructor = child; + } + C.prototype = parent.prototype; + child.prototype = new C(); + } + function peg$SyntaxError(message, expected, found, location) { + var self = Error.call(this, message); + if (Object.setPrototypeOf) { + Object.setPrototypeOf(self, peg$SyntaxError.prototype); + } + self.expected = expected; + self.found = found; + self.location = location; + self.name = "SyntaxError"; + return self; + } + peg$subclass(peg$SyntaxError, Error); + function peg$padEnd(str, targetLength, padString) { + padString = padString || " "; + if (str.length > targetLength) { + return str; + } + targetLength -= str.length; + padString += padString.repeat(targetLength); + return str + padString.slice(0, targetLength); + } + peg$SyntaxError.prototype.format = function(sources) { + var str = "Error: " + this.message; + if (this.location) { + var src = null; + var k; + for (k = 0; k < sources.length; k++) { + if (sources[k].source === this.location.source) { + src = sources[k].text.split(/\r\n|\n|\r/g); + break; + } + } + var s = this.location.start; + var offset_s = this.location.source && typeof this.location.source.offset === "function" ? this.location.source.offset(s) : s; + var loc = this.location.source + ":" + offset_s.line + ":" + offset_s.column; + if (src) { + var e = this.location.end; + var filler = peg$padEnd("", offset_s.line.toString().length, " "); + var line = src[s.line - 1]; + var last = s.line === e.line ? e.column : line.length + 1; + var hatLen = last - s.column || 1; + str += "\n --> " + loc + "\n" + filler + " |\n" + offset_s.line + " | " + line + "\n" + filler + " | " + peg$padEnd("", s.column - 1, " ") + peg$padEnd("", hatLen, "^"); + } else { + str += "\n at " + loc; + } + } + return str; + }; + peg$SyntaxError.buildMessage = function(expected, found) { + var DESCRIBE_EXPECTATION_FNS = { + literal: function(expectation) { + return '"' + literalEscape(expectation.text) + '"'; + }, + class: function(expectation) { + var escapedParts = expectation.parts.map(function(part) { + return Array.isArray(part) ? classEscape(part[0]) + "-" + classEscape(part[1]) : classEscape(part); + }); + return "[" + (expectation.inverted ? "^" : "") + escapedParts.join("") + "]"; + }, + any: function() { + return "any character"; + }, + end: function() { + return "end of input"; + }, + other: function(expectation) { + return expectation.description; + } + }; + function hex(ch) { + return ch.charCodeAt(0).toString(16).toUpperCase(); + } + function literalEscape(s) { + return s.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\0/g, "\\0").replace(/\t/g, "\\t").replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/[\x00-\x0F]/g, function(ch) { + return "\\x0" + hex(ch); + }).replace(/[\x10-\x1F\x7F-\x9F]/g, function(ch) { + return "\\x" + hex(ch); + }); + } + function classEscape(s) { + return s.replace(/\\/g, "\\\\").replace(/\]/g, "\\]").replace(/\^/g, "\\^").replace(/-/g, "\\-").replace(/\0/g, "\\0").replace(/\t/g, "\\t").replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/[\x00-\x0F]/g, function(ch) { + return "\\x0" + hex(ch); + }).replace(/[\x10-\x1F\x7F-\x9F]/g, function(ch) { + return "\\x" + hex(ch); + }); + } + function describeExpectation(expectation) { + return DESCRIBE_EXPECTATION_FNS[expectation.type](expectation); + } + function describeExpected(expected2) { + var descriptions = expected2.map(describeExpectation); + var i, j; + descriptions.sort(); + if (descriptions.length > 0) { + for (i = 1, j = 1; i < descriptions.length; i++) { + if (descriptions[i - 1] !== descriptions[i]) { + descriptions[j] = descriptions[i]; + j++; + } + } + descriptions.length = j; + } + switch (descriptions.length) { + case 1: + return descriptions[0]; + case 2: + return descriptions[0] + " or " + descriptions[1]; + default: + return descriptions.slice(0, -1).join(", ") + ", or " + descriptions[descriptions.length - 1]; + } + } + function describeFound(found2) { + return found2 ? '"' + literalEscape(found2) + '"' : "end of input"; + } + return "Expected " + describeExpected(expected) + " but " + describeFound(found) + " found."; + }; + function peg$parse(input, options) { + options = options !== void 0 ? options : {}; + var peg$FAILED = {}; + var peg$source = options.grammarSource; + var peg$startRuleFunctions = { body: peg$parsebody }; + var peg$startRuleFunction = peg$parsebody; + var peg$e0 = peg$otherExpectation("decl_start"); + var peg$e1 = peg$otherExpectation("decl_end"); + var peg$e2 = peg$otherExpectation("vert"); + var peg$e3 = peg$anyExpectation(); + var peg$e4 = peg$otherExpectation("l"); + var peg$e5 = peg$otherExpectation("r"); + var peg$e6 = peg$otherExpectation("c"); + var peg$e7 = peg$otherExpectation("p"); + var peg$e8 = peg$otherExpectation("m"); + var peg$e9 = peg$otherExpectation("b"); + var peg$e10 = peg$otherExpectation("w"); + var peg$e11 = peg$otherExpectation("W"); + var peg$e12 = peg$otherExpectation("X"); + var peg$e13 = peg$otherExpectation("!"); + var peg$e14 = peg$otherExpectation("@"); + var peg$e15 = peg$otherExpectation("<"); + var peg$e16 = peg$otherExpectation(">"); + var peg$e17 = peg$otherExpectation("group"); + var peg$e18 = peg$otherExpectation("whitespace"); + var peg$f0 = function(c) { + return c; + }; + var peg$f1 = function(cols) { + return cols; + }; + var peg$f2 = function() { + return []; + }; + var peg$f3 = function(divs1, start, a, end, divs2) { + return { + type: "column", + pre_dividers: divs1, + post_dividers: divs2, + before_start_code: start, + before_end_code: end, + alignment: a + }; + }; + var peg$f4 = function() { + return { + type: "vert_divider" + }; + }; + var peg$f5 = function(b, g) { + return { + type: "bang_divider", + content: g[0].content + }; + }; + var peg$f6 = function(g) { + return { + type: "at_divider", + content: g[0].content + }; + }; + var peg$f7 = function(div) { + return div; + }; + var peg$f8 = function(g) { + return { type: "decl_code", code: g[0].content }; + }; + var peg$f9 = function(g) { + return { type: "decl_code", code: g[0].content }; + }; + var peg$f10 = function() { + return { type: "alignment", alignment: "left" }; + }; + var peg$f11 = function() { + return { type: "alignment", alignment: "center" }; + }; + var peg$f12 = function() { + return { type: "alignment", alignment: "right" }; + }; + var peg$f13 = function() { + return { type: "alignment", alignment: "X" }; + }; + var peg$f14 = function() { + return "top"; + }; + var peg$f15 = function() { + return "default"; + }; + var peg$f16 = function() { + return "bottom"; + }; + var peg$f17 = function(a, g) { + return { + type: "alignment", + alignment: "parbox", + baseline: a, + size: g[0].content + }; + }; + var peg$f18 = function(g1, g2) { + return { + type: "alignment", + alignment: "parbox", + baseline: g1[0].content, + size: g2[0].content + }; + }; + var peg$f19 = function(tok) { + return options.matchChar(tok, "|"); + }; + var peg$f20 = function(tok) { + return options.matchChar(tok, "l"); + }; + var peg$f21 = function(tok) { + return options.matchChar(tok, "r"); + }; + var peg$f22 = function(tok) { + return options.matchChar(tok, "c"); + }; + var peg$f23 = function(tok) { + return options.matchChar(tok, "p"); + }; + var peg$f24 = function(tok) { + return options.matchChar(tok, "m"); + }; + var peg$f25 = function(tok) { + return options.matchChar(tok, "b"); + }; + var peg$f26 = function(tok) { + return options.matchChar(tok, "w"); + }; + var peg$f27 = function(tok) { + return options.matchChar(tok, "W"); + }; + var peg$f28 = function(tok) { + return options.matchChar(tok, "X"); + }; + var peg$f29 = function(tok) { + return options.matchChar(tok, "!"); + }; + var peg$f30 = function(tok) { + return options.matchChar(tok, "@"); + }; + var peg$f31 = function(tok) { + return options.matchChar(tok, "<"); + }; + var peg$f32 = function(tok) { + return options.matchChar(tok, ">"); + }; + var peg$f33 = function(tok) { + return options.isGroup(tok); + }; + var peg$f34 = function(tok) { + return options.isWhitespace(tok); + }; + var peg$currPos = 0; + var peg$posDetailsCache = [{ line: 1, column: 1 }]; + var peg$maxFailPos = 0; + var peg$maxFailExpected = []; + var peg$silentFails = 0; + var peg$result; + if ("startRule" in options) { + if (!(options.startRule in peg$startRuleFunctions)) { + throw new Error(`Can't start parsing from rule "` + options.startRule + '".'); + } + peg$startRuleFunction = peg$startRuleFunctions[options.startRule]; + } + function peg$anyExpectation() { + return { type: "any" }; + } + function peg$endExpectation() { + return { type: "end" }; + } + function peg$otherExpectation(description) { + return { type: "other", description }; + } + function peg$computePosDetails(pos) { + var details = peg$posDetailsCache[pos]; + var p; + if (details) { + return details; + } else { + p = pos - 1; + while (!peg$posDetailsCache[p]) { + p--; + } + details = peg$posDetailsCache[p]; + details = { + line: details.line, + column: details.column + }; + while (p < pos) { + if (input.charCodeAt(p) === 10) { + details.line++; + details.column = 1; + } else { + details.column++; + } + p++; + } + peg$posDetailsCache[pos] = details; + return details; + } + } + function peg$computeLocation(startPos, endPos, offset2) { + var startPosDetails = peg$computePosDetails(startPos); + var endPosDetails = peg$computePosDetails(endPos); + var res = { + source: peg$source, + start: { + offset: startPos, + line: startPosDetails.line, + column: startPosDetails.column + }, + end: { + offset: endPos, + line: endPosDetails.line, + column: endPosDetails.column + } + }; + return res; + } + function peg$fail(expected2) { + if (peg$currPos < peg$maxFailPos) { + return; + } + if (peg$currPos > peg$maxFailPos) { + peg$maxFailPos = peg$currPos; + peg$maxFailExpected = []; + } + peg$maxFailExpected.push(expected2); + } + function peg$buildStructuredError(expected2, found, location2) { + return new peg$SyntaxError( + peg$SyntaxError.buildMessage(expected2, found), + expected2, + found, + location2 + ); + } + function peg$parsebody() { + var s0, s1, s2, s3, s4, s5; + s0 = peg$currPos; + s1 = []; + s2 = peg$currPos; + s3 = peg$parsecolumn(); + if (s3 !== peg$FAILED) { + s4 = []; + s5 = peg$parse_(); + while (s5 !== peg$FAILED) { + s4.push(s5); + s5 = peg$parse_(); + } + s2 = peg$f0(s3); + } else { + peg$currPos = s2; + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + while (s2 !== peg$FAILED) { + s1.push(s2); + s2 = peg$currPos; + s3 = peg$parsecolumn(); + if (s3 !== peg$FAILED) { + s4 = []; + s5 = peg$parse_(); + while (s5 !== peg$FAILED) { + s4.push(s5); + s5 = peg$parse_(); + } + s2 = peg$f0(s3); + } else { + peg$currPos = s2; + s2 = peg$FAILED; + } + } + } else { + s1 = peg$FAILED; + } + if (s1 !== peg$FAILED) { + s1 = peg$f1(s1); + } + s0 = s1; + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$parseEOL(); + if (s1 !== peg$FAILED) { + s1 = peg$f2(); + } + s0 = s1; + } + return s0; + } + function peg$parsecolumn() { + var s0, s1, s2, s3, s4, s5, s6; + s0 = peg$currPos; + s1 = []; + s2 = peg$parsecolumn_divider(); + while (s2 !== peg$FAILED) { + s1.push(s2); + s2 = peg$parsecolumn_divider(); + } + s2 = peg$parsedecl_start(); + if (s2 === peg$FAILED) { + s2 = null; + } + s3 = peg$parsealignment(); + if (s3 !== peg$FAILED) { + s4 = peg$parsedecl_end(); + if (s4 === peg$FAILED) { + s4 = null; + } + s5 = []; + s6 = peg$parsecolumn_divider(); + while (s6 !== peg$FAILED) { + s5.push(s6); + s6 = peg$parsecolumn_divider(); + } + s0 = peg$f3(s1, s2, s3, s4, s5); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsecolumn_divider() { + var s0, s1, s2, s3, s4; + s0 = peg$currPos; + s1 = []; + s2 = peg$parse_(); + while (s2 !== peg$FAILED) { + s1.push(s2); + s2 = peg$parse_(); + } + s2 = peg$currPos; + s3 = peg$parsevert(); + if (s3 !== peg$FAILED) { + s3 = peg$f4(); + } + s2 = s3; + if (s2 === peg$FAILED) { + s2 = peg$currPos; + s3 = peg$parsebang(); + if (s3 !== peg$FAILED) { + s4 = peg$parsegroup(); + if (s4 !== peg$FAILED) { + s2 = peg$f5(s3, s4); + } else { + peg$currPos = s2; + s2 = peg$FAILED; + } + } else { + peg$currPos = s2; + s2 = peg$FAILED; + } + if (s2 === peg$FAILED) { + s2 = peg$currPos; + s3 = peg$parseat(); + if (s3 !== peg$FAILED) { + s4 = peg$parsegroup(); + if (s4 !== peg$FAILED) { + s2 = peg$f6(s4); + } else { + peg$currPos = s2; + s2 = peg$FAILED; + } + } else { + peg$currPos = s2; + s2 = peg$FAILED; + } + } + } + if (s2 !== peg$FAILED) { + s3 = []; + s4 = peg$parse_(); + while (s4 !== peg$FAILED) { + s3.push(s4); + s4 = peg$parse_(); + } + s0 = peg$f7(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsedecl_start() { + var s0, s1, s2; + peg$silentFails++; + s0 = peg$currPos; + s1 = peg$parsegreater(); + if (s1 !== peg$FAILED) { + s2 = peg$parsegroup(); + if (s2 !== peg$FAILED) { + s0 = peg$f8(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + return s0; + } + function peg$parsedecl_end() { + var s0, s1, s2; + peg$silentFails++; + s0 = peg$currPos; + s1 = peg$parseless(); + if (s1 !== peg$FAILED) { + s2 = peg$parsegroup(); + if (s2 !== peg$FAILED) { + s0 = peg$f9(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e1); + } + } + return s0; + } + function peg$parsealignment() { + var s0, s1, s2, s3, s4, s5; + s0 = peg$currPos; + s1 = peg$parsel(); + if (s1 !== peg$FAILED) { + s1 = peg$f10(); + } + s0 = s1; + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$parsec(); + if (s1 !== peg$FAILED) { + s1 = peg$f11(); + } + s0 = s1; + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$parser(); + if (s1 !== peg$FAILED) { + s1 = peg$f12(); + } + s0 = s1; + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$parseX(); + if (s1 !== peg$FAILED) { + s1 = peg$f13(); + } + s0 = s1; + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$currPos; + s2 = peg$parsep(); + if (s2 !== peg$FAILED) { + s2 = peg$f14(); + } + s1 = s2; + if (s1 === peg$FAILED) { + s1 = peg$currPos; + s2 = peg$parsem(); + if (s2 !== peg$FAILED) { + s2 = peg$f15(); + } + s1 = s2; + if (s1 === peg$FAILED) { + s1 = peg$currPos; + s2 = peg$parseb(); + if (s2 !== peg$FAILED) { + s2 = peg$f16(); + } + s1 = s2; + } + } + if (s1 !== peg$FAILED) { + s2 = []; + s3 = peg$parse_(); + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$parse_(); + } + s3 = peg$parsegroup(); + if (s3 !== peg$FAILED) { + s0 = peg$f17(s1, s3); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$parsew(); + if (s1 === peg$FAILED) { + s1 = peg$parseW(); + } + if (s1 !== peg$FAILED) { + s2 = []; + s3 = peg$parse_(); + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$parse_(); + } + s3 = peg$parsegroup(); + if (s3 !== peg$FAILED) { + s4 = []; + s5 = peg$parse_(); + while (s5 !== peg$FAILED) { + s4.push(s5); + s5 = peg$parse_(); + } + s5 = peg$parsegroup(); + if (s5 !== peg$FAILED) { + s0 = peg$f18(s3, s5); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } + } + } + } + } + return s0; + } + function peg$parsevert() { + var s0, s1, s2; + peg$silentFails++; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f19(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s1 = [s1, s2]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e2); + } + } + return s0; + } + function peg$parsel() { + var s0, s1, s2; + peg$silentFails++; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f20(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s1 = [s1, s2]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e4); + } + } + return s0; + } + function peg$parser() { + var s0, s1, s2; + peg$silentFails++; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f21(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s1 = [s1, s2]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e5); + } + } + return s0; + } + function peg$parsec() { + var s0, s1, s2; + peg$silentFails++; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f22(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s1 = [s1, s2]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e6); + } + } + return s0; + } + function peg$parsep() { + var s0, s1, s2; + peg$silentFails++; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f23(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s1 = [s1, s2]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e7); + } + } + return s0; + } + function peg$parsem() { + var s0, s1, s2; + peg$silentFails++; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f24(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s1 = [s1, s2]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e8); + } + } + return s0; + } + function peg$parseb() { + var s0, s1, s2; + peg$silentFails++; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f25(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s1 = [s1, s2]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e9); + } + } + return s0; + } + function peg$parsew() { + var s0, s1, s2; + peg$silentFails++; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f26(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s1 = [s1, s2]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e10); + } + } + return s0; + } + function peg$parseW() { + var s0, s1, s2; + peg$silentFails++; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f27(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s1 = [s1, s2]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e11); + } + } + return s0; + } + function peg$parseX() { + var s0, s1, s2; + peg$silentFails++; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f28(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s1 = [s1, s2]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e12); + } + } + return s0; + } + function peg$parsebang() { + var s0, s1, s2; + peg$silentFails++; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f29(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s1 = [s1, s2]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e13); + } + } + return s0; + } + function peg$parseat() { + var s0, s1, s2; + peg$silentFails++; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f30(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s1 = [s1, s2]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e14); + } + } + return s0; + } + function peg$parseless() { + var s0, s1, s2; + peg$silentFails++; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f31(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s1 = [s1, s2]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e15); + } + } + return s0; + } + function peg$parsegreater() { + var s0, s1, s2; + peg$silentFails++; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f32(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s1 = [s1, s2]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e16); + } + } + return s0; + } + function peg$parsegroup() { + var s0, s1, s2; + peg$silentFails++; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f33(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s1 = [s1, s2]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e17); + } + } + return s0; + } + function peg$parse_() { + var s0, s1, s2; + peg$silentFails++; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f34(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s1 = [s1, s2]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e18); + } + } + return s0; + } + function peg$parseEOL() { + var s0, s1; + s0 = peg$currPos; + peg$silentFails++; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + peg$silentFails--; + if (s1 === peg$FAILED) { + s0 = void 0; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + if (!options.isHash) { + try { + Object.assign(options, { + matchChar: (node, char) => node.type === "string" && node.content === char, + isGroup: (node) => node.type === "group", + isWhitespace: (node) => node.type === "whitespace" + }); + } catch (e) { + console.warn("Error when initializing parser", e); + } + } + peg$result = peg$startRuleFunction(); + if (peg$result !== peg$FAILED && peg$currPos === input.length) { + return peg$result; + } else { + if (peg$result !== peg$FAILED && peg$currPos < input.length) { + peg$fail(peg$endExpectation()); + } + throw peg$buildStructuredError( + peg$maxFailExpected, + peg$maxFailPos < input.length ? input.charAt(peg$maxFailPos) : null, + peg$maxFailPos < input.length ? peg$computeLocation(peg$maxFailPos, peg$maxFailPos + 1) : peg$computeLocation(peg$maxFailPos, peg$maxFailPos) + ); + } + } + return { + SyntaxError: peg$SyntaxError, + parse: peg$parse + }; + }() +); +const _SystemePegParser = ( + // Generated by Peggy 3.0.2. + // + // https://peggyjs.org/ + function() { + function peg$subclass(child, parent) { + function C() { + this.constructor = child; + } + C.prototype = parent.prototype; + child.prototype = new C(); + } + function peg$SyntaxError(message, expected, found, location) { + var self = Error.call(this, message); + if (Object.setPrototypeOf) { + Object.setPrototypeOf(self, peg$SyntaxError.prototype); + } + self.expected = expected; + self.found = found; + self.location = location; + self.name = "SyntaxError"; + return self; + } + peg$subclass(peg$SyntaxError, Error); + function peg$padEnd(str, targetLength, padString) { + padString = padString || " "; + if (str.length > targetLength) { + return str; + } + targetLength -= str.length; + padString += padString.repeat(targetLength); + return str + padString.slice(0, targetLength); + } + peg$SyntaxError.prototype.format = function(sources) { + var str = "Error: " + this.message; + if (this.location) { + var src = null; + var k; + for (k = 0; k < sources.length; k++) { + if (sources[k].source === this.location.source) { + src = sources[k].text.split(/\r\n|\n|\r/g); + break; + } + } + var s = this.location.start; + var offset_s = this.location.source && typeof this.location.source.offset === "function" ? this.location.source.offset(s) : s; + var loc = this.location.source + ":" + offset_s.line + ":" + offset_s.column; + if (src) { + var e = this.location.end; + var filler = peg$padEnd("", offset_s.line.toString().length, " "); + var line = src[s.line - 1]; + var last = s.line === e.line ? e.column : line.length + 1; + var hatLen = last - s.column || 1; + str += "\n --> " + loc + "\n" + filler + " |\n" + offset_s.line + " | " + line + "\n" + filler + " | " + peg$padEnd("", s.column - 1, " ") + peg$padEnd("", hatLen, "^"); + } else { + str += "\n at " + loc; + } + } + return str; + }; + peg$SyntaxError.buildMessage = function(expected, found) { + var DESCRIBE_EXPECTATION_FNS = { + literal: function(expectation) { + return '"' + literalEscape(expectation.text) + '"'; + }, + class: function(expectation) { + var escapedParts = expectation.parts.map(function(part) { + return Array.isArray(part) ? classEscape(part[0]) + "-" + classEscape(part[1]) : classEscape(part); + }); + return "[" + (expectation.inverted ? "^" : "") + escapedParts.join("") + "]"; + }, + any: function() { + return "any character"; + }, + end: function() { + return "end of input"; + }, + other: function(expectation) { + return expectation.description; + } + }; + function hex(ch) { + return ch.charCodeAt(0).toString(16).toUpperCase(); + } + function literalEscape(s) { + return s.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\0/g, "\\0").replace(/\t/g, "\\t").replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/[\x00-\x0F]/g, function(ch) { + return "\\x0" + hex(ch); + }).replace(/[\x10-\x1F\x7F-\x9F]/g, function(ch) { + return "\\x" + hex(ch); + }); + } + function classEscape(s) { + return s.replace(/\\/g, "\\\\").replace(/\]/g, "\\]").replace(/\^/g, "\\^").replace(/-/g, "\\-").replace(/\0/g, "\\0").replace(/\t/g, "\\t").replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/[\x00-\x0F]/g, function(ch) { + return "\\x0" + hex(ch); + }).replace(/[\x10-\x1F\x7F-\x9F]/g, function(ch) { + return "\\x" + hex(ch); + }); + } + function describeExpectation(expectation) { + return DESCRIBE_EXPECTATION_FNS[expectation.type](expectation); + } + function describeExpected(expected2) { + var descriptions = expected2.map(describeExpectation); + var i, j; + descriptions.sort(); + if (descriptions.length > 0) { + for (i = 1, j = 1; i < descriptions.length; i++) { + if (descriptions[i - 1] !== descriptions[i]) { + descriptions[j] = descriptions[i]; + j++; + } + } + descriptions.length = j; + } + switch (descriptions.length) { + case 1: + return descriptions[0]; + case 2: + return descriptions[0] + " or " + descriptions[1]; + default: + return descriptions.slice(0, -1).join(", ") + ", or " + descriptions[descriptions.length - 1]; + } + } + function describeFound(found2) { + return found2 ? '"' + literalEscape(found2) + '"' : "end of input"; + } + return "Expected " + describeExpected(expected) + " but " + describeFound(found) + " found."; + }; + function peg$parse(input, options) { + options = options !== void 0 ? options : {}; + var peg$FAILED = {}; + var peg$source = options.grammarSource; + var peg$startRuleFunctions = { body: peg$parsebody }; + var peg$startRuleFunction = peg$parsebody; + var peg$e1 = peg$otherExpectation("item"); + var peg$e2 = peg$anyExpectation(); + var peg$e3 = peg$otherExpectation("equation"); + var peg$e4 = peg$otherExpectation("trailing comment"); + var peg$e5 = peg$otherExpectation("comment only line"); + var peg$e6 = peg$otherExpectation("non-var token"); + var peg$e7 = peg$otherExpectation("token"); + var peg$e8 = peg$otherExpectation("same line comment"); + var peg$e9 = peg$otherExpectation("own line comment"); + var peg$e10 = peg$otherExpectation(","); + var peg$e11 = peg$otherExpectation("@"); + var peg$e12 = peg$otherExpectation("variable token"); + var peg$e13 = peg$otherExpectation("+/-"); + var peg$e14 = peg$otherExpectation("="); + var peg$f0 = function(a, b) { + return a.concat(b ? b : []); + }; + var peg$f1 = function() { + return []; + }; + var peg$f3 = function(op, a, b, c) { + return { type: "item", op, variable: b, content: a.concat(b, c) }; + }; + var peg$f4 = function(op, a) { + return { type: "item", op, variable: null, content: a }; + }; + var peg$f5 = function(line, sep, comment) { + return { ...line, sep: [].concat(sep), trailingComment: comment }; + }; + var peg$f6 = function(line, comment) { + return { ...line, trailingComment: comment }; + }; + var peg$f7 = function(eq, ann) { + return { + type: "line", + equation: eq, + annotation: ann, + sep: null + }; + }; + var peg$f8 = function(at, ann) { + return at ? { type: "annotation", marker: at, content: ann } : null; + }; + var peg$f9 = function(left, eq, right) { + return { type: "equation", left, right, equals: eq }; + }; + var peg$f10 = function(x) { + return x; + }; + var peg$f11 = function(x) { + return { + type: "line", + trailingComment: x + }; + }; + var peg$f12 = function(v, s) { + return [v].concat(s ? s : []); + }; + var peg$f13 = function(t) { + return t; + }; + var peg$f14 = function(x) { + return x; + }; + var peg$f15 = function(x) { + return x; + }; + var peg$f16 = function(tok) { + return options.isSameLineComment(tok); + }; + var peg$f17 = function(tok) { + return tok; + }; + var peg$f18 = function(tok) { + return options.isOwnLineComment(tok); + }; + var peg$f19 = function(tok) { + return tok; + }; + var peg$f20 = function(tok) { + return options.isWhitespace(tok); + }; + var peg$f21 = function(tok) { + return tok; + }; + var peg$f22 = function(tok) { + return options.isSep(tok); + }; + var peg$f23 = function(tok) { + return tok; + }; + var peg$f24 = function(tok) { + return options.isAt(tok); + }; + var peg$f25 = function(tok) { + return tok; + }; + var peg$f26 = function(tok) { + return options.isVar(tok); + }; + var peg$f27 = function(tok) { + return tok; + }; + var peg$f28 = function(tok) { + return options.isOperation(tok); + }; + var peg$f29 = function(tok) { + return tok; + }; + var peg$f30 = function(tok) { + return options.isEquals(tok); + }; + var peg$f31 = function(tok) { + return tok; + }; + var peg$f32 = function(tok) { + return options.isSubscript(tok); + }; + var peg$f33 = function(tok) { + return tok; + }; + var peg$currPos = 0; + var peg$posDetailsCache = [{ line: 1, column: 1 }]; + var peg$maxFailPos = 0; + var peg$maxFailExpected = []; + var peg$silentFails = 0; + var peg$result; + if ("startRule" in options) { + if (!(options.startRule in peg$startRuleFunctions)) { + throw new Error(`Can't start parsing from rule "` + options.startRule + '".'); + } + peg$startRuleFunction = peg$startRuleFunctions[options.startRule]; + } + function peg$anyExpectation() { + return { type: "any" }; + } + function peg$endExpectation() { + return { type: "end" }; + } + function peg$otherExpectation(description) { + return { type: "other", description }; + } + function peg$computePosDetails(pos) { + var details = peg$posDetailsCache[pos]; + var p; + if (details) { + return details; + } else { + p = pos - 1; + while (!peg$posDetailsCache[p]) { + p--; + } + details = peg$posDetailsCache[p]; + details = { + line: details.line, + column: details.column + }; + while (p < pos) { + if (input.charCodeAt(p) === 10) { + details.line++; + details.column = 1; + } else { + details.column++; + } + p++; + } + peg$posDetailsCache[pos] = details; + return details; + } + } + function peg$computeLocation(startPos, endPos, offset2) { + var startPosDetails = peg$computePosDetails(startPos); + var endPosDetails = peg$computePosDetails(endPos); + var res = { + source: peg$source, + start: { + offset: startPos, + line: startPosDetails.line, + column: startPosDetails.column + }, + end: { + offset: endPos, + line: endPosDetails.line, + column: endPosDetails.column + } + }; + return res; + } + function peg$fail(expected2) { + if (peg$currPos < peg$maxFailPos) { + return; + } + if (peg$currPos > peg$maxFailPos) { + peg$maxFailPos = peg$currPos; + peg$maxFailExpected = []; + } + peg$maxFailExpected.push(expected2); + } + function peg$buildStructuredError(expected2, found, location2) { + return new peg$SyntaxError( + peg$SyntaxError.buildMessage(expected2, found), + expected2, + found, + location2 + ); + } + function peg$parsebody() { + var s0, s1, s2; + s0 = peg$currPos; + s1 = []; + s2 = peg$parsecomment_only_line(); + if (s2 === peg$FAILED) { + s2 = peg$parseline_with_sep(); + if (s2 === peg$FAILED) { + s2 = peg$parsepartial_line_with_comment(); + } + } + while (s2 !== peg$FAILED) { + s1.push(s2); + s2 = peg$parsecomment_only_line(); + if (s2 === peg$FAILED) { + s2 = peg$parseline_with_sep(); + if (s2 === peg$FAILED) { + s2 = peg$parsepartial_line_with_comment(); + } + } + } + s2 = peg$parseline_without_sep(); + if (s2 === peg$FAILED) { + s2 = peg$parseEOL(); + } + if (s2 !== peg$FAILED) { + s0 = peg$f0(s1, s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$parseEOL(); + if (s1 !== peg$FAILED) { + s1 = peg$f1(); + } + s0 = s1; + } + return s0; + } + function peg$parseitem() { + var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9; + peg$silentFails++; + s0 = peg$currPos; + s1 = peg$parseoperation(); + if (s1 === peg$FAILED) { + s1 = null; + } + s2 = []; + s3 = peg$parse_(); + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$parse_(); + } + s3 = []; + s4 = peg$parsenon_var_token(); + while (s4 !== peg$FAILED) { + s3.push(s4); + s4 = peg$parsenon_var_token(); + } + s4 = []; + s5 = peg$parse_(); + while (s5 !== peg$FAILED) { + s4.push(s5); + s5 = peg$parse_(); + } + s5 = peg$parsevar(); + if (s5 !== peg$FAILED) { + s6 = []; + s7 = peg$parse_(); + while (s7 !== peg$FAILED) { + s6.push(s7); + s7 = peg$parse_(); + } + s7 = []; + s8 = peg$parsetoken(); + while (s8 !== peg$FAILED) { + s7.push(s8); + s8 = peg$parsetoken(); + } + s8 = []; + s9 = peg$parse_(); + while (s9 !== peg$FAILED) { + s8.push(s9); + s9 = peg$parse_(); + } + s0 = peg$f3(s1, s3, s5, s7); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$parseoperation(); + if (s1 === peg$FAILED) { + s1 = null; + } + s2 = []; + s3 = peg$parse_(); + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$parse_(); + } + s3 = []; + s4 = peg$parsenon_var_token(); + if (s4 !== peg$FAILED) { + while (s4 !== peg$FAILED) { + s3.push(s4); + s4 = peg$parsenon_var_token(); + } + } else { + s3 = peg$FAILED; + } + if (s3 !== peg$FAILED) { + s4 = []; + s5 = peg$parse_(); + while (s5 !== peg$FAILED) { + s4.push(s5); + s5 = peg$parse_(); + } + s0 = peg$f4(s1, s3); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e1); + } + } + return s0; + } + function peg$parseline_with_sep() { + var s0, s1, s2, s3; + s0 = peg$currPos; + s1 = peg$parseline_without_sep(); + if (s1 !== peg$FAILED) { + s2 = peg$parsesep(); + if (s2 !== peg$FAILED) { + s3 = peg$parsetrailing_comment(); + if (s3 === peg$FAILED) { + s3 = null; + } + s0 = peg$f5(s1, s2, s3); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsepartial_line_with_comment() { + var s0, s1, s2; + s0 = peg$currPos; + s1 = peg$parseline_without_sep(); + if (s1 !== peg$FAILED) { + s2 = peg$parsetrailing_comment(); + if (s2 !== peg$FAILED) { + s0 = peg$f6(s1, s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parseline_without_sep() { + var s0, s1, s2, s3; + s0 = peg$currPos; + s1 = peg$currPos; + peg$silentFails++; + if (input.length > peg$currPos) { + s2 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e2); + } + } + peg$silentFails--; + if (s2 !== peg$FAILED) { + peg$currPos = s1; + s1 = void 0; + } else { + s1 = peg$FAILED; + } + if (s1 !== peg$FAILED) { + s2 = peg$parseequation(); + s3 = peg$parseannotation(); + if (s3 === peg$FAILED) { + s3 = null; + } + s0 = peg$f7(s2, s3); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parseannotation() { + var s0, s1, s2, s3; + s0 = peg$currPos; + s1 = peg$parseat(); + if (s1 !== peg$FAILED) { + s2 = []; + s3 = peg$parsenon_sep_token(); + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$parsenon_sep_token(); + } + s0 = peg$f8(s1, s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parseequation() { + var s0, s1, s2, s3, s4; + peg$silentFails++; + s0 = peg$currPos; + s1 = []; + s2 = peg$parseitem(); + while (s2 !== peg$FAILED) { + s1.push(s2); + s2 = peg$parseitem(); + } + s2 = peg$parseequals(); + if (s2 === peg$FAILED) { + s2 = null; + } + s3 = []; + s4 = peg$parsetoken(); + if (s4 === peg$FAILED) { + s4 = peg$parseoperation(); + } + while (s4 !== peg$FAILED) { + s3.push(s4); + s4 = peg$parsetoken(); + if (s4 === peg$FAILED) { + s4 = peg$parseoperation(); + } + } + s0 = peg$f9(s1, s2, s3); + peg$silentFails--; + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + return s0; + } + function peg$parsetrailing_comment() { + var s0, s1, s2; + peg$silentFails++; + s0 = peg$currPos; + s1 = []; + s2 = peg$parse_(); + while (s2 !== peg$FAILED) { + s1.push(s2); + s2 = peg$parse_(); + } + s2 = peg$parsesame_line_comment(); + if (s2 !== peg$FAILED) { + s0 = peg$f10(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e4); + } + } + return s0; + } + function peg$parsecomment_only_line() { + var s0, s1, s2; + peg$silentFails++; + s0 = peg$currPos; + s1 = []; + s2 = peg$parse_(); + while (s2 !== peg$FAILED) { + s1.push(s2); + s2 = peg$parse_(); + } + s2 = peg$parseown_line_comment(); + if (s2 !== peg$FAILED) { + s0 = peg$f11(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e5); + } + } + return s0; + } + function peg$parsevar() { + var s0, s1, s2, s3; + s0 = peg$currPos; + s1 = peg$parsevar_token(); + if (s1 !== peg$FAILED) { + s2 = []; + s3 = peg$parse_(); + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$parse_(); + } + s3 = peg$parsesubscript(); + if (s3 === peg$FAILED) { + s3 = null; + } + s0 = peg$f12(s1, s3); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsenon_var_token() { + var s0, s1, s2; + peg$silentFails++; + s0 = peg$currPos; + s1 = peg$currPos; + peg$silentFails++; + s2 = peg$parsevar(); + peg$silentFails--; + if (s2 === peg$FAILED) { + s1 = void 0; + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + if (s1 !== peg$FAILED) { + s2 = peg$parsetoken(); + if (s2 !== peg$FAILED) { + s0 = peg$f13(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e6); + } + } + return s0; + } + function peg$parsenon_sep_token() { + var s0, s1, s2; + s0 = peg$currPos; + s1 = peg$currPos; + peg$silentFails++; + s2 = peg$parsesep(); + if (s2 === peg$FAILED) { + s2 = peg$parsetrailing_comment(); + if (s2 === peg$FAILED) { + s2 = peg$parseown_line_comment(); + } + } + peg$silentFails--; + if (s2 === peg$FAILED) { + s1 = void 0; + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + if (s1 !== peg$FAILED) { + if (input.length > peg$currPos) { + s2 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e2); + } + } + if (s2 !== peg$FAILED) { + s0 = peg$f14(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsetoken() { + var s0, s1, s2; + peg$silentFails++; + s0 = peg$currPos; + s1 = peg$currPos; + peg$silentFails++; + s2 = peg$parsesep(); + if (s2 === peg$FAILED) { + s2 = peg$parseat(); + if (s2 === peg$FAILED) { + s2 = peg$parseoperation(); + if (s2 === peg$FAILED) { + s2 = peg$parseequals(); + if (s2 === peg$FAILED) { + s2 = peg$parsetrailing_comment(); + if (s2 === peg$FAILED) { + s2 = peg$parseown_line_comment(); + } + } + } + } + } + peg$silentFails--; + if (s2 === peg$FAILED) { + s1 = void 0; + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + if (s1 !== peg$FAILED) { + if (input.length > peg$currPos) { + s2 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e2); + } + } + if (s2 !== peg$FAILED) { + s0 = peg$f15(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e7); + } + } + return s0; + } + function peg$parsesame_line_comment() { + var s0, s1, s2; + peg$silentFails++; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e2); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f16(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s0 = peg$f17(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e8); + } + } + return s0; + } + function peg$parseown_line_comment() { + var s0, s1, s2; + peg$silentFails++; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e2); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f18(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s0 = peg$f19(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e9); + } + } + return s0; + } + function peg$parse_() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e2); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f20(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s0 = peg$f21(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsesep() { + var s0, s1, s2; + peg$silentFails++; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e2); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f22(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s0 = peg$f23(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e10); + } + } + return s0; + } + function peg$parseat() { + var s0, s1, s2; + peg$silentFails++; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e2); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f24(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s0 = peg$f25(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e11); + } + } + return s0; + } + function peg$parsevar_token() { + var s0, s1, s2; + peg$silentFails++; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e2); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f26(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s0 = peg$f27(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e12); + } + } + return s0; + } + function peg$parseoperation() { + var s0, s1, s2, s3, s4; + peg$silentFails++; + s0 = peg$currPos; + s1 = []; + s2 = peg$parse_(); + while (s2 !== peg$FAILED) { + s1.push(s2); + s2 = peg$parse_(); + } + if (input.length > peg$currPos) { + s2 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e2); + } + } + if (s2 !== peg$FAILED) { + s3 = []; + s4 = peg$parse_(); + while (s4 !== peg$FAILED) { + s3.push(s4); + s4 = peg$parse_(); + } + s4 = peg$f28(s2); + if (s4) { + s4 = void 0; + } else { + s4 = peg$FAILED; + } + if (s4 !== peg$FAILED) { + s0 = peg$f29(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e13); + } + } + return s0; + } + function peg$parseequals() { + var s0, s1, s2; + peg$silentFails++; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e2); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f30(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s0 = peg$f31(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e14); + } + } + return s0; + } + function peg$parsesubscript() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e2); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f32(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s0 = peg$f33(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parseEOL() { + var s0, s1; + s0 = peg$currPos; + peg$silentFails++; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e2); + } + } + peg$silentFails--; + if (s1 === peg$FAILED) { + s0 = void 0; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + if (!options.isWhitespace) { + try { + Object.assign(options, { + isSep: (node) => node.type === "string" && node.content === ",", + isVar: (node) => node.type === "string" && node.content.match(/[a-zA-Z]/), + isOperation: (node) => node.type === "string" && node.content.match(/[+-]/), + isEquals: (node) => node.type === "string" && node.content === "=", + isAt: (node) => node.type === "string" && node.content === "@", + isSubscript: (node) => node.content === "_", + isWhitespace: (node) => node.type === "whitespace", + isSameLineComment: (node) => node.type === "comment" && node.sameline, + isOwnLineComment: (node) => node.type === "comment" && !node.sameline + }); + } catch (e) { + console.warn("Error when initializing parser", e); + } + } + peg$result = peg$startRuleFunction(); + if (peg$result !== peg$FAILED && peg$currPos === input.length) { + return peg$result; + } else { + if (peg$result !== peg$FAILED && peg$currPos < input.length) { + peg$fail(peg$endExpectation()); + } + throw peg$buildStructuredError( + peg$maxFailExpected, + peg$maxFailPos < input.length ? input.charAt(peg$maxFailPos) : null, + peg$maxFailPos < input.length ? peg$computeLocation(peg$maxFailPos, peg$maxFailPos + 1) : peg$computeLocation(peg$maxFailPos, peg$maxFailPos) + ); + } + } + return { + SyntaxError: peg$SyntaxError, + parse: peg$parse + }; + }() +); +const _GluePegParser = ( + // Generated by Peggy 3.0.2. + // + // https://peggyjs.org/ + function() { + function peg$subclass(child, parent) { + function C() { + this.constructor = child; + } + C.prototype = parent.prototype; + child.prototype = new C(); + } + function peg$SyntaxError(message, expected, found, location) { + var self = Error.call(this, message); + if (Object.setPrototypeOf) { + Object.setPrototypeOf(self, peg$SyntaxError.prototype); + } + self.expected = expected; + self.found = found; + self.location = location; + self.name = "SyntaxError"; + return self; + } + peg$subclass(peg$SyntaxError, Error); + function peg$padEnd(str, targetLength, padString) { + padString = padString || " "; + if (str.length > targetLength) { + return str; + } + targetLength -= str.length; + padString += padString.repeat(targetLength); + return str + padString.slice(0, targetLength); + } + peg$SyntaxError.prototype.format = function(sources) { + var str = "Error: " + this.message; + if (this.location) { + var src = null; + var k; + for (k = 0; k < sources.length; k++) { + if (sources[k].source === this.location.source) { + src = sources[k].text.split(/\r\n|\n|\r/g); + break; + } + } + var s = this.location.start; + var offset_s = this.location.source && typeof this.location.source.offset === "function" ? this.location.source.offset(s) : s; + var loc = this.location.source + ":" + offset_s.line + ":" + offset_s.column; + if (src) { + var e = this.location.end; + var filler = peg$padEnd("", offset_s.line.toString().length, " "); + var line = src[s.line - 1]; + var last = s.line === e.line ? e.column : line.length + 1; + var hatLen = last - s.column || 1; + str += "\n --> " + loc + "\n" + filler + " |\n" + offset_s.line + " | " + line + "\n" + filler + " | " + peg$padEnd("", s.column - 1, " ") + peg$padEnd("", hatLen, "^"); + } else { + str += "\n at " + loc; + } + } + return str; + }; + peg$SyntaxError.buildMessage = function(expected, found) { + var DESCRIBE_EXPECTATION_FNS = { + literal: function(expectation) { + return '"' + literalEscape(expectation.text) + '"'; + }, + class: function(expectation) { + var escapedParts = expectation.parts.map(function(part) { + return Array.isArray(part) ? classEscape(part[0]) + "-" + classEscape(part[1]) : classEscape(part); + }); + return "[" + (expectation.inverted ? "^" : "") + escapedParts.join("") + "]"; + }, + any: function() { + return "any character"; + }, + end: function() { + return "end of input"; + }, + other: function(expectation) { + return expectation.description; + } + }; + function hex(ch) { + return ch.charCodeAt(0).toString(16).toUpperCase(); + } + function literalEscape(s) { + return s.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\0/g, "\\0").replace(/\t/g, "\\t").replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/[\x00-\x0F]/g, function(ch) { + return "\\x0" + hex(ch); + }).replace(/[\x10-\x1F\x7F-\x9F]/g, function(ch) { + return "\\x" + hex(ch); + }); + } + function classEscape(s) { + return s.replace(/\\/g, "\\\\").replace(/\]/g, "\\]").replace(/\^/g, "\\^").replace(/-/g, "\\-").replace(/\0/g, "\\0").replace(/\t/g, "\\t").replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/[\x00-\x0F]/g, function(ch) { + return "\\x0" + hex(ch); + }).replace(/[\x10-\x1F\x7F-\x9F]/g, function(ch) { + return "\\x" + hex(ch); + }); + } + function describeExpectation(expectation) { + return DESCRIBE_EXPECTATION_FNS[expectation.type](expectation); + } + function describeExpected(expected2) { + var descriptions = expected2.map(describeExpectation); + var i, j; + descriptions.sort(); + if (descriptions.length > 0) { + for (i = 1, j = 1; i < descriptions.length; i++) { + if (descriptions[i - 1] !== descriptions[i]) { + descriptions[j] = descriptions[i]; + j++; + } + } + descriptions.length = j; + } + switch (descriptions.length) { + case 1: + return descriptions[0]; + case 2: + return descriptions[0] + " or " + descriptions[1]; + default: + return descriptions.slice(0, -1).join(", ") + ", or " + descriptions[descriptions.length - 1]; + } + } + function describeFound(found2) { + return found2 ? '"' + literalEscape(found2) + '"' : "end of input"; + } + return "Expected " + describeExpected(expected) + " but " + describeFound(found) + " found."; + }; + function peg$parse(input, options) { + options = options !== void 0 ? options : {}; + var peg$FAILED = {}; + var peg$source = options.grammarSource; + var peg$startRuleFunctions = { root: peg$parseroot }; + var peg$startRuleFunction = peg$parseroot; + var peg$c0 = "plus"; + var peg$c1 = "minus"; + var peg$c2 = "pt"; + var peg$c3 = "mm"; + var peg$c4 = "cm"; + var peg$c5 = "in"; + var peg$c6 = "ex"; + var peg$c7 = "em"; + var peg$c8 = "bp"; + var peg$c9 = "pc"; + var peg$c10 = "dd"; + var peg$c11 = "cc"; + var peg$c12 = "nd"; + var peg$c13 = "nc"; + var peg$c14 = "sp"; + var peg$c15 = "filll"; + var peg$c16 = "fill"; + var peg$c17 = "fil"; + var peg$c18 = "."; + var peg$c19 = "+"; + var peg$c20 = "-"; + var peg$r0 = /^[0-9]/; + var peg$e0 = peg$anyExpectation(); + var peg$e1 = peg$literalExpectation("plus", false); + var peg$e2 = peg$literalExpectation("minus", false); + var peg$e3 = peg$literalExpectation("pt", false); + var peg$e4 = peg$literalExpectation("mm", false); + var peg$e5 = peg$literalExpectation("cm", false); + var peg$e6 = peg$literalExpectation("in", false); + var peg$e7 = peg$literalExpectation("ex", false); + var peg$e8 = peg$literalExpectation("em", false); + var peg$e9 = peg$literalExpectation("bp", false); + var peg$e10 = peg$literalExpectation("pc", false); + var peg$e11 = peg$literalExpectation("dd", false); + var peg$e12 = peg$literalExpectation("cc", false); + var peg$e13 = peg$literalExpectation("nd", false); + var peg$e14 = peg$literalExpectation("nc", false); + var peg$e15 = peg$literalExpectation("sp", false); + var peg$e16 = peg$literalExpectation("filll", false); + var peg$e17 = peg$literalExpectation("fill", false); + var peg$e18 = peg$literalExpectation("fil", false); + var peg$e19 = peg$otherExpectation("number"); + var peg$e20 = peg$classExpectation([["0", "9"]], false, false); + var peg$e21 = peg$literalExpectation(".", false); + var peg$e22 = peg$literalExpectation("+", false); + var peg$e23 = peg$literalExpectation("-", false); + var peg$f0 = function(b, st, sh) { + return { + type: "glue", + fixed: b, + stretchable: st, + shrinkable: sh, + position: location() + }; + }; + var peg$f1 = function(glue) { + return glue; + }; + var peg$f2 = function(n, u) { + return { type: "dim", value: n, unit: u }; + }; + var peg$f3 = function(n, u) { + return { type: "dim", value: n, unit: u }; + }; + var peg$f4 = function(n, u) { + return { type: "dim", value: n, unit: u }; + }; + var peg$f5 = function(n) { + return parseFloat(n); + }; + var peg$currPos = 0; + var peg$savedPos = 0; + var peg$posDetailsCache = [{ line: 1, column: 1 }]; + var peg$maxFailPos = 0; + var peg$maxFailExpected = []; + var peg$silentFails = 0; + var peg$result; + if ("startRule" in options) { + if (!(options.startRule in peg$startRuleFunctions)) { + throw new Error(`Can't start parsing from rule "` + options.startRule + '".'); + } + peg$startRuleFunction = peg$startRuleFunctions[options.startRule]; + } + function location() { + return peg$computeLocation(peg$savedPos, peg$currPos); + } + function peg$literalExpectation(text2, ignoreCase) { + return { type: "literal", text: text2, ignoreCase }; + } + function peg$classExpectation(parts, inverted, ignoreCase) { + return { type: "class", parts, inverted, ignoreCase }; + } + function peg$anyExpectation() { + return { type: "any" }; + } + function peg$endExpectation() { + return { type: "end" }; + } + function peg$otherExpectation(description) { + return { type: "other", description }; + } + function peg$computePosDetails(pos) { + var details = peg$posDetailsCache[pos]; + var p; + if (details) { + return details; + } else { + p = pos - 1; + while (!peg$posDetailsCache[p]) { + p--; + } + details = peg$posDetailsCache[p]; + details = { + line: details.line, + column: details.column + }; + while (p < pos) { + if (input.charCodeAt(p) === 10) { + details.line++; + details.column = 1; + } else { + details.column++; + } + p++; + } + peg$posDetailsCache[pos] = details; + return details; + } + } + function peg$computeLocation(startPos, endPos, offset2) { + var startPosDetails = peg$computePosDetails(startPos); + var endPosDetails = peg$computePosDetails(endPos); + var res = { + source: peg$source, + start: { + offset: startPos, + line: startPosDetails.line, + column: startPosDetails.column + }, + end: { + offset: endPos, + line: endPosDetails.line, + column: endPosDetails.column + } + }; + return res; + } + function peg$fail(expected2) { + if (peg$currPos < peg$maxFailPos) { + return; + } + if (peg$currPos > peg$maxFailPos) { + peg$maxFailPos = peg$currPos; + peg$maxFailExpected = []; + } + peg$maxFailExpected.push(expected2); + } + function peg$buildStructuredError(expected2, found, location2) { + return new peg$SyntaxError( + peg$SyntaxError.buildMessage(expected2, found), + expected2, + found, + location2 + ); + } + function peg$parseroot() { + var s0, s1, s2, s3, s4; + s0 = peg$currPos; + s1 = peg$currPos; + s2 = peg$parsebase(); + if (s2 !== peg$FAILED) { + s3 = peg$parsestretchable(); + if (s3 === peg$FAILED) { + s3 = null; + } + s4 = peg$parseshrinkable(); + if (s4 === peg$FAILED) { + s4 = null; + } + peg$savedPos = s1; + s1 = peg$f0(s2, s3, s4); + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + if (s1 !== peg$FAILED) { + s2 = []; + if (input.length > peg$currPos) { + s3 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s3 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + while (s3 !== peg$FAILED) { + s2.push(s3); + if (input.length > peg$currPos) { + s3 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s3 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + } + peg$savedPos = s0; + s0 = peg$f1(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsebase() { + var s0, s1, s2; + s0 = peg$currPos; + s1 = peg$parsenumber(); + if (s1 !== peg$FAILED) { + s2 = peg$parseunit(); + if (s2 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f2(s1, s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsestretchable() { + var s0, s1, s2, s3; + s0 = peg$currPos; + if (input.substr(peg$currPos, 4) === peg$c0) { + s1 = peg$c0; + peg$currPos += 4; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e1); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$parsenumber(); + if (s2 !== peg$FAILED) { + s3 = peg$parserubber_unit(); + if (s3 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f3(s2, s3); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parseshrinkable() { + var s0, s1, s2, s3; + s0 = peg$currPos; + if (input.substr(peg$currPos, 5) === peg$c1) { + s1 = peg$c1; + peg$currPos += 5; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e2); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$parsenumber(); + if (s2 !== peg$FAILED) { + s3 = peg$parserubber_unit(); + if (s3 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f4(s2, s3); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parseunit() { + var s0; + if (input.substr(peg$currPos, 2) === peg$c2) { + s0 = peg$c2; + peg$currPos += 2; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s0 === peg$FAILED) { + if (input.substr(peg$currPos, 2) === peg$c3) { + s0 = peg$c3; + peg$currPos += 2; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e4); + } + } + if (s0 === peg$FAILED) { + if (input.substr(peg$currPos, 2) === peg$c4) { + s0 = peg$c4; + peg$currPos += 2; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e5); + } + } + if (s0 === peg$FAILED) { + if (input.substr(peg$currPos, 2) === peg$c5) { + s0 = peg$c5; + peg$currPos += 2; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e6); + } + } + if (s0 === peg$FAILED) { + if (input.substr(peg$currPos, 2) === peg$c6) { + s0 = peg$c6; + peg$currPos += 2; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e7); + } + } + if (s0 === peg$FAILED) { + if (input.substr(peg$currPos, 2) === peg$c7) { + s0 = peg$c7; + peg$currPos += 2; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e8); + } + } + if (s0 === peg$FAILED) { + if (input.substr(peg$currPos, 2) === peg$c8) { + s0 = peg$c8; + peg$currPos += 2; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e9); + } + } + if (s0 === peg$FAILED) { + if (input.substr(peg$currPos, 2) === peg$c9) { + s0 = peg$c9; + peg$currPos += 2; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e10); + } + } + if (s0 === peg$FAILED) { + if (input.substr(peg$currPos, 2) === peg$c10) { + s0 = peg$c10; + peg$currPos += 2; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e11); + } + } + if (s0 === peg$FAILED) { + if (input.substr(peg$currPos, 2) === peg$c11) { + s0 = peg$c11; + peg$currPos += 2; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e12); + } + } + if (s0 === peg$FAILED) { + if (input.substr(peg$currPos, 2) === peg$c12) { + s0 = peg$c12; + peg$currPos += 2; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e13); + } + } + if (s0 === peg$FAILED) { + if (input.substr(peg$currPos, 2) === peg$c13) { + s0 = peg$c13; + peg$currPos += 2; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e14); + } + } + if (s0 === peg$FAILED) { + if (input.substr(peg$currPos, 2) === peg$c14) { + s0 = peg$c14; + peg$currPos += 2; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e15); + } + } + } + } + } + } + } + } + } + } + } + } + } + } + return s0; + } + function peg$parserubber_unit() { + var s0; + s0 = peg$parseunit(); + if (s0 === peg$FAILED) { + if (input.substr(peg$currPos, 5) === peg$c15) { + s0 = peg$c15; + peg$currPos += 5; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e16); + } + } + if (s0 === peg$FAILED) { + if (input.substr(peg$currPos, 4) === peg$c16) { + s0 = peg$c16; + peg$currPos += 4; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e17); + } + } + if (s0 === peg$FAILED) { + if (input.substr(peg$currPos, 3) === peg$c17) { + s0 = peg$c17; + peg$currPos += 3; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e18); + } + } + } + } + } + return s0; + } + function peg$parsenumber() { + var s0, s1, s2, s3, s4, s5, s6, s7, s8; + peg$silentFails++; + s0 = peg$currPos; + s1 = peg$currPos; + s2 = peg$currPos; + s3 = peg$parsesign(); + if (s3 === peg$FAILED) { + s3 = null; + } + s4 = peg$currPos; + s5 = []; + if (peg$r0.test(input.charAt(peg$currPos))) { + s6 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s6 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e20); + } + } + while (s6 !== peg$FAILED) { + s5.push(s6); + if (peg$r0.test(input.charAt(peg$currPos))) { + s6 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s6 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e20); + } + } + } + if (input.charCodeAt(peg$currPos) === 46) { + s6 = peg$c18; + peg$currPos++; + } else { + s6 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e21); + } + } + if (s6 !== peg$FAILED) { + s7 = []; + if (peg$r0.test(input.charAt(peg$currPos))) { + s8 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s8 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e20); + } + } + if (s8 !== peg$FAILED) { + while (s8 !== peg$FAILED) { + s7.push(s8); + if (peg$r0.test(input.charAt(peg$currPos))) { + s8 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s8 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e20); + } + } + } + } else { + s7 = peg$FAILED; + } + if (s7 !== peg$FAILED) { + s5 = [s5, s6, s7]; + s4 = s5; + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + if (s4 === peg$FAILED) { + s4 = []; + if (peg$r0.test(input.charAt(peg$currPos))) { + s5 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s5 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e20); + } + } + if (s5 !== peg$FAILED) { + while (s5 !== peg$FAILED) { + s4.push(s5); + if (peg$r0.test(input.charAt(peg$currPos))) { + s5 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s5 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e20); + } + } + } + } else { + s4 = peg$FAILED; + } + } + if (s4 !== peg$FAILED) { + s3 = [s3, s4]; + s2 = s3; + } else { + peg$currPos = s2; + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s1 = input.substring(s1, peg$currPos); + } else { + s1 = s2; + } + if (s1 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$f5(s1); + } + s0 = s1; + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e19); + } + } + return s0; + } + function peg$parsesign() { + var s0; + if (input.charCodeAt(peg$currPos) === 43) { + s0 = peg$c19; + peg$currPos++; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e22); + } + } + if (s0 === peg$FAILED) { + if (input.charCodeAt(peg$currPos) === 45) { + s0 = peg$c20; + peg$currPos++; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e23); + } + } + } + return s0; + } + peg$result = peg$startRuleFunction(); + if (peg$result !== peg$FAILED && peg$currPos === input.length) { + return peg$result; + } else { + if (peg$result !== peg$FAILED && peg$currPos < input.length) { + peg$fail(peg$endExpectation()); + } + throw peg$buildStructuredError( + peg$maxFailExpected, + peg$maxFailPos < input.length ? input.charAt(peg$maxFailPos) : null, + peg$maxFailPos < input.length ? peg$computeLocation(peg$maxFailPos, peg$maxFailPos + 1) : peg$computeLocation(peg$maxFailPos, peg$maxFailPos) + ); + } + } + return { + SyntaxError: peg$SyntaxError, + parse: peg$parse + }; + }() +); +const _TikzPegParser = ( + // Generated by Peggy 3.0.2. + // + // https://peggyjs.org/ + function() { + function peg$subclass(child, parent) { + function C() { + this.constructor = child; + } + C.prototype = parent.prototype; + child.prototype = new C(); + } + function peg$SyntaxError(message, expected, found, location) { + var self = Error.call(this, message); + if (Object.setPrototypeOf) { + Object.setPrototypeOf(self, peg$SyntaxError.prototype); + } + self.expected = expected; + self.found = found; + self.location = location; + self.name = "SyntaxError"; + return self; + } + peg$subclass(peg$SyntaxError, Error); + function peg$padEnd(str, targetLength, padString) { + padString = padString || " "; + if (str.length > targetLength) { + return str; + } + targetLength -= str.length; + padString += padString.repeat(targetLength); + return str + padString.slice(0, targetLength); + } + peg$SyntaxError.prototype.format = function(sources) { + var str = "Error: " + this.message; + if (this.location) { + var src = null; + var k; + for (k = 0; k < sources.length; k++) { + if (sources[k].source === this.location.source) { + src = sources[k].text.split(/\r\n|\n|\r/g); + break; + } + } + var s = this.location.start; + var offset_s = this.location.source && typeof this.location.source.offset === "function" ? this.location.source.offset(s) : s; + var loc = this.location.source + ":" + offset_s.line + ":" + offset_s.column; + if (src) { + var e = this.location.end; + var filler = peg$padEnd("", offset_s.line.toString().length, " "); + var line = src[s.line - 1]; + var last = s.line === e.line ? e.column : line.length + 1; + var hatLen = last - s.column || 1; + str += "\n --> " + loc + "\n" + filler + " |\n" + offset_s.line + " | " + line + "\n" + filler + " | " + peg$padEnd("", s.column - 1, " ") + peg$padEnd("", hatLen, "^"); + } else { + str += "\n at " + loc; + } + } + return str; + }; + peg$SyntaxError.buildMessage = function(expected, found) { + var DESCRIBE_EXPECTATION_FNS = { + literal: function(expectation) { + return '"' + literalEscape(expectation.text) + '"'; + }, + class: function(expectation) { + var escapedParts = expectation.parts.map(function(part) { + return Array.isArray(part) ? classEscape(part[0]) + "-" + classEscape(part[1]) : classEscape(part); + }); + return "[" + (expectation.inverted ? "^" : "") + escapedParts.join("") + "]"; + }, + any: function() { + return "any character"; + }, + end: function() { + return "end of input"; + }, + other: function(expectation) { + return expectation.description; + } + }; + function hex(ch) { + return ch.charCodeAt(0).toString(16).toUpperCase(); + } + function literalEscape(s) { + return s.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\0/g, "\\0").replace(/\t/g, "\\t").replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/[\x00-\x0F]/g, function(ch) { + return "\\x0" + hex(ch); + }).replace(/[\x10-\x1F\x7F-\x9F]/g, function(ch) { + return "\\x" + hex(ch); + }); + } + function classEscape(s) { + return s.replace(/\\/g, "\\\\").replace(/\]/g, "\\]").replace(/\^/g, "\\^").replace(/-/g, "\\-").replace(/\0/g, "\\0").replace(/\t/g, "\\t").replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/[\x00-\x0F]/g, function(ch) { + return "\\x0" + hex(ch); + }).replace(/[\x10-\x1F\x7F-\x9F]/g, function(ch) { + return "\\x" + hex(ch); + }); + } + function describeExpectation(expectation) { + return DESCRIBE_EXPECTATION_FNS[expectation.type](expectation); + } + function describeExpected(expected2) { + var descriptions = expected2.map(describeExpectation); + var i, j; + descriptions.sort(); + if (descriptions.length > 0) { + for (i = 1, j = 1; i < descriptions.length; i++) { + if (descriptions[i - 1] !== descriptions[i]) { + descriptions[j] = descriptions[i]; + j++; + } + } + descriptions.length = j; + } + switch (descriptions.length) { + case 1: + return descriptions[0]; + case 2: + return descriptions[0] + " or " + descriptions[1]; + default: + return descriptions.slice(0, -1).join(", ") + ", or " + descriptions[descriptions.length - 1]; + } + } + function describeFound(found2) { + return found2 ? '"' + literalEscape(found2) + '"' : "end of input"; + } + return "Expected " + describeExpected(expected) + " but " + describeFound(found) + " found."; + }; + function peg$parse(input, options) { + options = options !== void 0 ? options : {}; + var peg$FAILED = {}; + var peg$source = options.grammarSource; + var peg$startRuleFunctions = { path_spec: peg$parsepath_spec, foreach_body: peg$parseforeach_body }; + var peg$startRuleFunction = peg$parsepath_spec; + var peg$e0 = peg$anyExpectation(); + var peg$e3 = peg$otherExpectation("comment"); + var peg$e4 = peg$otherExpectation("floating comment"); + var peg$e5 = peg$otherExpectation("operation"); + var peg$e6 = peg$otherExpectation("="); + var peg$f0 = function(v) { + return v; + }; + var peg$f1 = function(ops) { + return { type: "path_spec", content: ops }; + }; + var peg$f2 = function(c1, op, comment) { + return { op, comment }; + }; + var peg$f3 = function(c1, ops, c2, body) { + const comments = [c1, ...ops.map((x) => x.comment), c2].filter( + (x) => x + ); + const attribute = ops.map((x) => x.op.content.content).join(" "); + return { + type: "animation", + comments, + attribute, + content: body.content + }; + }; + var peg$f4 = function(start, b) { + return { ...b, start, type: "foreach" }; + }; + var peg$f5 = function(c1, variables, options2, c2, c3, list, c4, command) { + const comments = [c1, c2, c3, c4].filter((x) => x); + return { + type: "foreach_body", + variables, + options: options2 && options2.content, + list, + command, + comments + }; + }; + var peg$f6 = function(c1, options2, c2, body) { + const comments = [c1, c2].filter((x) => x); + return { + type: "svg_operation", + options: options2 && options2.content, + content: body, + comments + }; + }; + var peg$f7 = function(c1, c2, coord, c3, c4, x) { + return { coord: x, comment: c4 }; + }; + var peg$f8 = function(c1, c2, coord, c3, a, c5) { + const comments = [c1, c2, c3, a && a.comment, c5].filter((x) => x); + return { + type: "curve_to", + controls: a ? [coord, a.coord] : [coord], + comments + }; + }; + var peg$f9 = function() { + return { type: "line_to", command: "|-" }; + }; + var peg$f10 = function() { + return { type: "line_to", command: "-|" }; + }; + var peg$f11 = function() { + return { type: "line_to", command: "--" }; + }; + var peg$f12 = function(prefix, content) { + return { type: "coordinate", content, prefix }; + }; + var peg$f13 = function(content) { + return { type: "square_brace_group", content }; + }; + var peg$f14 = function(v) { + return { type: "unknown", content: v }; + }; + var peg$f19 = function(tok) { + return options.isComment(tok); + }; + var peg$f20 = function(tok) { + return tok; + }; + var peg$f21 = function(tok) { + return options.isWhitespace(tok); + }; + var peg$f22 = function(tok) { + return tok; + }; + var peg$f23 = function(c) { + return c; + }; + var peg$f24 = function(tok) { + return options.isOperation(tok); + }; + var peg$f25 = function(tok) { + return { type: "operation", content: tok }; + }; + var peg$f26 = function(tok) { + return options.isChar(tok, "="); + }; + var peg$f27 = function(tok) { + return tok; + }; + var peg$f28 = function(tok) { + return options.isChar(tok, "["); + }; + var peg$f29 = function(tok) { + return tok; + }; + var peg$f30 = function(tok) { + return options.isChar(tok, "]"); + }; + var peg$f31 = function(tok) { + return tok; + }; + var peg$f32 = function(tok) { + return options.isChar(tok, "("); + }; + var peg$f33 = function(tok) { + return tok; + }; + var peg$f34 = function(tok) { + return options.isChar(tok, ")"); + }; + var peg$f35 = function(tok) { + return tok; + }; + var peg$f36 = function(tok) { + return options.isChar(tok, "+"); + }; + var peg$f37 = function(tok) { + return tok; + }; + var peg$f38 = function(tok) { + return options.isChar(tok, "-"); + }; + var peg$f39 = function(tok) { + return tok; + }; + var peg$f40 = function(tok) { + return options.isChar(tok, "|"); + }; + var peg$f41 = function(tok) { + return tok; + }; + var peg$f42 = function(tok) { + return options.isChar(tok, "."); + }; + var peg$f43 = function(tok) { + return tok; + }; + var peg$f44 = function(tok) { + return options.isChar(tok, "controls"); + }; + var peg$f45 = function(tok) { + return tok; + }; + var peg$f46 = function(tok) { + return options.isChar(tok, "and"); + }; + var peg$f47 = function(tok) { + return tok; + }; + var peg$f48 = function(tok) { + return options.isChar(tok, "svg"); + }; + var peg$f49 = function(tok) { + return tok; + }; + var peg$f50 = function(tok) { + return options.isGroup(tok); + }; + var peg$f51 = function(tok) { + return tok; + }; + var peg$f52 = function(tok) { + return options.isAnyMacro(tok); + }; + var peg$f53 = function(tok) { + return tok; + }; + var peg$f54 = function(tok) { + return options.isChar(tok, "foreach"); + }; + var peg$f55 = function(tok) { + return tok; + }; + var peg$f56 = function(tok) { + return options.isMacro(tok, "foreach"); + }; + var peg$f57 = function(tok) { + return tok; + }; + var peg$f58 = function(tok) { + return options.isChar(tok, "in"); + }; + var peg$f59 = function(tok) { + return tok; + }; + var peg$f60 = function(tok) { + return options.isChar(tok, ":"); + }; + var peg$f61 = function(tok) { + return tok; + }; + var peg$currPos = 0; + var peg$posDetailsCache = [{ line: 1, column: 1 }]; + var peg$maxFailPos = 0; + var peg$maxFailExpected = []; + var peg$silentFails = 0; + var peg$result; + if ("startRule" in options) { + if (!(options.startRule in peg$startRuleFunctions)) { + throw new Error(`Can't start parsing from rule "` + options.startRule + '".'); + } + peg$startRuleFunction = peg$startRuleFunctions[options.startRule]; + } + function peg$anyExpectation() { + return { type: "any" }; + } + function peg$endExpectation() { + return { type: "end" }; + } + function peg$otherExpectation(description) { + return { type: "other", description }; + } + function peg$computePosDetails(pos) { + var details = peg$posDetailsCache[pos]; + var p; + if (details) { + return details; + } else { + p = pos - 1; + while (!peg$posDetailsCache[p]) { + p--; + } + details = peg$posDetailsCache[p]; + details = { + line: details.line, + column: details.column + }; + while (p < pos) { + if (input.charCodeAt(p) === 10) { + details.line++; + details.column = 1; + } else { + details.column++; + } + p++; + } + peg$posDetailsCache[pos] = details; + return details; + } + } + function peg$computeLocation(startPos, endPos, offset2) { + var startPosDetails = peg$computePosDetails(startPos); + var endPosDetails = peg$computePosDetails(endPos); + var res = { + source: peg$source, + start: { + offset: startPos, + line: startPosDetails.line, + column: startPosDetails.column + }, + end: { + offset: endPos, + line: endPosDetails.line, + column: endPosDetails.column + } + }; + return res; + } + function peg$fail(expected2) { + if (peg$currPos < peg$maxFailPos) { + return; + } + if (peg$currPos > peg$maxFailPos) { + peg$maxFailPos = peg$currPos; + peg$maxFailExpected = []; + } + peg$maxFailExpected.push(expected2); + } + function peg$buildStructuredError(expected2, found, location2) { + return new peg$SyntaxError( + peg$SyntaxError.buildMessage(expected2, found), + expected2, + found, + location2 + ); + } + function peg$parsepath_spec() { + var s0, s1, s2, s3, s4, s5; + s0 = peg$currPos; + s1 = []; + s2 = peg$currPos; + s3 = peg$parsesquare_brace_group(); + if (s3 === peg$FAILED) { + s3 = peg$parsecoordinate(); + if (s3 === peg$FAILED) { + s3 = peg$parsecurve_to(); + if (s3 === peg$FAILED) { + s3 = peg$parseline_to(); + if (s3 === peg$FAILED) { + s3 = peg$parsesvg(); + if (s3 === peg$FAILED) { + s3 = peg$parseforeach(); + if (s3 === peg$FAILED) { + s3 = peg$parseoperation(); + if (s3 === peg$FAILED) { + s3 = peg$parsecomment(); + if (s3 === peg$FAILED) { + s3 = peg$parseanimation(); + if (s3 === peg$FAILED) { + s3 = peg$parseunknown(); + } + } + } + } + } + } + } + } + } + if (s3 !== peg$FAILED) { + s4 = []; + s5 = peg$parse_(); + while (s5 !== peg$FAILED) { + s4.push(s5); + s5 = peg$parse_(); + } + s2 = peg$f0(s3); + } else { + peg$currPos = s2; + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + while (s2 !== peg$FAILED) { + s1.push(s2); + s2 = peg$currPos; + s3 = peg$parsesquare_brace_group(); + if (s3 === peg$FAILED) { + s3 = peg$parsecoordinate(); + if (s3 === peg$FAILED) { + s3 = peg$parsecurve_to(); + if (s3 === peg$FAILED) { + s3 = peg$parseline_to(); + if (s3 === peg$FAILED) { + s3 = peg$parsesvg(); + if (s3 === peg$FAILED) { + s3 = peg$parseforeach(); + if (s3 === peg$FAILED) { + s3 = peg$parseoperation(); + if (s3 === peg$FAILED) { + s3 = peg$parsecomment(); + if (s3 === peg$FAILED) { + s3 = peg$parseanimation(); + if (s3 === peg$FAILED) { + s3 = peg$parseunknown(); + } + } + } + } + } + } + } + } + } + if (s3 !== peg$FAILED) { + s4 = []; + s5 = peg$parse_(); + while (s5 !== peg$FAILED) { + s4.push(s5); + s5 = peg$parse_(); + } + s2 = peg$f0(s3); + } else { + peg$currPos = s2; + s2 = peg$FAILED; + } + } + } else { + s1 = peg$FAILED; + } + if (s1 !== peg$FAILED) { + s1 = peg$f1(s1); + } + s0 = s1; + return s0; + } + function peg$parseanimation() { + var s0, s1, s2, s3, s4, s5, s6; + s0 = peg$currPos; + s1 = peg$parsecolon(); + if (s1 !== peg$FAILED) { + s2 = peg$parse_comment_(); + s3 = []; + s4 = peg$currPos; + s5 = peg$parseoperation(); + if (s5 !== peg$FAILED) { + s6 = peg$parse_comment_(); + s4 = peg$f2(s2, s5, s6); + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + if (s4 !== peg$FAILED) { + while (s4 !== peg$FAILED) { + s3.push(s4); + s4 = peg$currPos; + s5 = peg$parseoperation(); + if (s5 !== peg$FAILED) { + s6 = peg$parse_comment_(); + s4 = peg$f2(s2, s5, s6); + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + } + } else { + s3 = peg$FAILED; + } + if (s3 !== peg$FAILED) { + s4 = peg$parseequals(); + if (s4 !== peg$FAILED) { + s5 = peg$parse_comment_(); + s6 = peg$parsegroup(); + if (s6 !== peg$FAILED) { + s0 = peg$f3(s2, s3, s5, s6); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parseforeach() { + var s0, s1, s2; + s0 = peg$currPos; + s1 = peg$parseforeach_keyword(); + if (s1 === peg$FAILED) { + s1 = peg$parseforeach_macro(); + } + if (s1 !== peg$FAILED) { + s2 = peg$parseforeach_body(); + if (s2 !== peg$FAILED) { + s0 = peg$f4(s1, s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parseforeach_body() { + var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9; + s0 = peg$currPos; + s1 = peg$parse_comment_(); + s2 = peg$currPos; + s3 = []; + s4 = peg$currPos; + s5 = peg$currPos; + peg$silentFails++; + s6 = peg$parsein_keyword(); + if (s6 === peg$FAILED) { + s6 = peg$parsesquare_brace_group(); + } + peg$silentFails--; + if (s6 === peg$FAILED) { + s5 = void 0; + } else { + peg$currPos = s5; + s5 = peg$FAILED; + } + if (s5 !== peg$FAILED) { + if (input.length > peg$currPos) { + s6 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s6 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s6 !== peg$FAILED) { + s5 = [s5, s6]; + s4 = s5; + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + while (s4 !== peg$FAILED) { + s3.push(s4); + s4 = peg$currPos; + s5 = peg$currPos; + peg$silentFails++; + s6 = peg$parsein_keyword(); + if (s6 === peg$FAILED) { + s6 = peg$parsesquare_brace_group(); + } + peg$silentFails--; + if (s6 === peg$FAILED) { + s5 = void 0; + } else { + peg$currPos = s5; + s5 = peg$FAILED; + } + if (s5 !== peg$FAILED) { + if (input.length > peg$currPos) { + s6 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s6 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s6 !== peg$FAILED) { + s5 = [s5, s6]; + s4 = s5; + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + } + s2 = input.substring(s2, peg$currPos); + s3 = peg$parsesquare_brace_group(); + if (s3 === peg$FAILED) { + s3 = null; + } + s4 = peg$parse_comment_(); + s5 = peg$parsein_keyword(); + if (s5 !== peg$FAILED) { + s6 = peg$parse_comment_(); + s7 = peg$parsegroup(); + if (s7 === peg$FAILED) { + s7 = peg$parsemacro(); + } + if (s7 !== peg$FAILED) { + s8 = peg$parse_comment_(); + s9 = peg$parseforeach(); + if (s9 === peg$FAILED) { + s9 = peg$parsegroup(); + if (s9 === peg$FAILED) { + s9 = peg$parsemacro(); + } + } + if (s9 !== peg$FAILED) { + s0 = peg$f5(s1, s2, s3, s4, s6, s7, s8, s9); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsesvg() { + var s0, s1, s2, s3, s4, s5; + s0 = peg$currPos; + s1 = peg$parsesvg_keyword(); + if (s1 !== peg$FAILED) { + s2 = peg$parse_comment_(); + s3 = peg$parsesquare_brace_group(); + if (s3 === peg$FAILED) { + s3 = null; + } + s4 = peg$parse_comment_(); + s5 = peg$parsegroup(); + if (s5 !== peg$FAILED) { + s0 = peg$f6(s2, s3, s4, s5); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsecurve_to() { + var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10; + s0 = peg$currPos; + s1 = peg$parsedotdot(); + if (s1 !== peg$FAILED) { + s2 = peg$parse_comment_(); + s3 = peg$parsecontrols_keyword(); + if (s3 !== peg$FAILED) { + s4 = peg$parse_comment_(); + s5 = peg$parsecoordinate(); + if (s5 !== peg$FAILED) { + s6 = peg$parse_comment_(); + s7 = peg$currPos; + s8 = peg$parseand_keyword(); + if (s8 !== peg$FAILED) { + s9 = peg$parse_comment_(); + s10 = peg$parsecoordinate(); + if (s10 !== peg$FAILED) { + s7 = peg$f7(s2, s4, s5, s6, s9, s10); + } else { + peg$currPos = s7; + s7 = peg$FAILED; + } + } else { + peg$currPos = s7; + s7 = peg$FAILED; + } + if (s7 === peg$FAILED) { + s7 = null; + } + s8 = peg$parse_comment_(); + s9 = peg$parsedotdot(); + if (s9 !== peg$FAILED) { + s0 = peg$f8(s2, s4, s5, s6, s7, s8); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parseline_to() { + var s0, s1, s2; + s0 = peg$currPos; + s1 = peg$parsepipe(); + if (s1 !== peg$FAILED) { + s2 = peg$parseminus(); + if (s2 !== peg$FAILED) { + s0 = peg$f9(); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$parseminus(); + if (s1 !== peg$FAILED) { + s2 = peg$parsepipe(); + if (s2 !== peg$FAILED) { + s0 = peg$f10(); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$parseminus(); + if (s1 !== peg$FAILED) { + s2 = peg$parseminus(); + if (s2 !== peg$FAILED) { + s0 = peg$f11(); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } + } + return s0; + } + function peg$parsecoordinate() { + var s0, s1, s2, s3, s4, s5, s6, s7; + s0 = peg$currPos; + s1 = peg$currPos; + s2 = peg$currPos; + s3 = peg$parseplus(); + if (s3 !== peg$FAILED) { + s4 = peg$parseplus(); + if (s4 === peg$FAILED) { + s4 = null; + } + s3 = [s3, s4]; + s2 = s3; + } else { + peg$currPos = s2; + s2 = peg$FAILED; + } + if (s2 === peg$FAILED) { + s2 = null; + } + s1 = input.substring(s1, peg$currPos); + s2 = peg$parseopen_paren(); + if (s2 !== peg$FAILED) { + s3 = peg$currPos; + s4 = []; + s5 = peg$currPos; + s6 = peg$currPos; + peg$silentFails++; + s7 = peg$parseclose_paren(); + peg$silentFails--; + if (s7 === peg$FAILED) { + s6 = void 0; + } else { + peg$currPos = s6; + s6 = peg$FAILED; + } + if (s6 !== peg$FAILED) { + if (input.length > peg$currPos) { + s7 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s7 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s7 !== peg$FAILED) { + s6 = [s6, s7]; + s5 = s6; + } else { + peg$currPos = s5; + s5 = peg$FAILED; + } + } else { + peg$currPos = s5; + s5 = peg$FAILED; + } + while (s5 !== peg$FAILED) { + s4.push(s5); + s5 = peg$currPos; + s6 = peg$currPos; + peg$silentFails++; + s7 = peg$parseclose_paren(); + peg$silentFails--; + if (s7 === peg$FAILED) { + s6 = void 0; + } else { + peg$currPos = s6; + s6 = peg$FAILED; + } + if (s6 !== peg$FAILED) { + if (input.length > peg$currPos) { + s7 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s7 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s7 !== peg$FAILED) { + s6 = [s6, s7]; + s5 = s6; + } else { + peg$currPos = s5; + s5 = peg$FAILED; + } + } else { + peg$currPos = s5; + s5 = peg$FAILED; + } + } + s3 = input.substring(s3, peg$currPos); + s4 = peg$parseclose_paren(); + if (s4 !== peg$FAILED) { + s0 = peg$f12(s1, s3); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsesquare_brace_group() { + var s0, s1, s2, s3, s4, s5, s6; + s0 = peg$currPos; + s1 = peg$parseopen_square_brace(); + if (s1 !== peg$FAILED) { + s2 = peg$currPos; + s3 = []; + s4 = peg$currPos; + s5 = peg$currPos; + peg$silentFails++; + s6 = peg$parseclose_square_brace(); + peg$silentFails--; + if (s6 === peg$FAILED) { + s5 = void 0; + } else { + peg$currPos = s5; + s5 = peg$FAILED; + } + if (s5 !== peg$FAILED) { + if (input.length > peg$currPos) { + s6 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s6 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s6 !== peg$FAILED) { + s5 = [s5, s6]; + s4 = s5; + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + while (s4 !== peg$FAILED) { + s3.push(s4); + s4 = peg$currPos; + s5 = peg$currPos; + peg$silentFails++; + s6 = peg$parseclose_square_brace(); + peg$silentFails--; + if (s6 === peg$FAILED) { + s5 = void 0; + } else { + peg$currPos = s5; + s5 = peg$FAILED; + } + if (s5 !== peg$FAILED) { + if (input.length > peg$currPos) { + s6 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s6 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s6 !== peg$FAILED) { + s5 = [s5, s6]; + s4 = s5; + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + } + s2 = input.substring(s2, peg$currPos); + s3 = peg$parseclose_square_brace(); + if (s3 !== peg$FAILED) { + s0 = peg$f13(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsedotdot() { + var s0, s1, s2; + s0 = peg$currPos; + s1 = peg$parsedot(); + if (s1 !== peg$FAILED) { + s2 = peg$parsedot(); + if (s2 !== peg$FAILED) { + s1 = [s1, s2]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parseunknown() { + var s0, s1; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + s1 = peg$f14(s1); + } + s0 = s1; + return s0; + } + function peg$parsecomment() { + var s0, s1, s2; + peg$silentFails++; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f19(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s0 = peg$f20(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + return s0; + } + function peg$parse_() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f21(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s0 = peg$f22(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parse_comment_() { + var s0, s1, s2, s3, s4; + peg$silentFails++; + s0 = peg$currPos; + s1 = []; + s2 = peg$parse_(); + while (s2 !== peg$FAILED) { + s1.push(s2); + s2 = peg$parse_(); + } + s2 = peg$parsecomment(); + if (s2 === peg$FAILED) { + s2 = null; + } + s3 = []; + s4 = peg$parse_(); + while (s4 !== peg$FAILED) { + s3.push(s4); + s4 = peg$parse_(); + } + s0 = peg$f23(s2); + peg$silentFails--; + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e4); + } + return s0; + } + function peg$parseoperation() { + var s0, s1, s2; + peg$silentFails++; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f24(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s0 = peg$f25(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e5); + } + } + return s0; + } + function peg$parseequals() { + var s0, s1, s2; + peg$silentFails++; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f26(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s0 = peg$f27(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e6); + } + } + return s0; + } + function peg$parseopen_square_brace() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f28(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s0 = peg$f29(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parseclose_square_brace() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f30(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s0 = peg$f31(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parseopen_paren() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f32(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s0 = peg$f33(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parseclose_paren() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f34(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s0 = peg$f35(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parseplus() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f36(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s0 = peg$f37(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parseminus() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f38(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s0 = peg$f39(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsepipe() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f40(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s0 = peg$f41(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsedot() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f42(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s0 = peg$f43(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsecontrols_keyword() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f44(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s0 = peg$f45(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parseand_keyword() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f46(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s0 = peg$f47(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsesvg_keyword() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f48(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s0 = peg$f49(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsegroup() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f50(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s0 = peg$f51(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsemacro() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f52(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s0 = peg$f53(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parseforeach_keyword() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f54(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s0 = peg$f55(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parseforeach_macro() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f56(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s0 = peg$f57(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsein_keyword() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f58(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s0 = peg$f59(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsecolon() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f60(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s0 = peg$f61(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + if (!options.isWhitespace) { + try { + Object.assign(options, { + isChar: (node, char) => node.type === "string" && node.content === char, + isOperation: (node) => node.type === "string" && node.content.match(/[a-zA-Z]/), + isWhitespace: (node) => node.type === "whitespace" || node.type === "parbreak", + isSameLineComment: (node) => node.type === "comment" && node.sameline, + isOwnLineComment: (node) => node.type === "comment" && !node.sameline, + isComment: (node) => node.type === "comment", + isGroup: (node) => node.type === "group", + isMacro: (node, name) => node.type === "macro" && node.content === name, + isAnyMacro: (node) => node.type === "macro" + }); + } catch (e) { + console.warn("Error when initializing parser", e); + } + } + peg$result = peg$startRuleFunction(); + if (peg$result !== peg$FAILED && peg$currPos === input.length) { + return peg$result; + } else { + if (peg$result !== peg$FAILED && peg$currPos < input.length) { + peg$fail(peg$endExpectation()); + } + throw peg$buildStructuredError( + peg$maxFailExpected, + peg$maxFailPos < input.length ? input.charAt(peg$maxFailPos) : null, + peg$maxFailPos < input.length ? peg$computeLocation(peg$maxFailPos, peg$maxFailPos + 1) : peg$computeLocation(peg$maxFailPos, peg$maxFailPos) + ); + } + } + return { + SyntaxError: peg$SyntaxError, + parse: peg$parse + }; + }() +); +const LatexPegParser = _LatexPegParser; +const AlignEnvironmentPegParser = _AlignEnvironmentPegParser; +const ArgSpecPegParser = _ArgSpecPegParser; +const PgfkeysPegParser = _PgfkeysPegParser; +const MacroSubstitutionPegParser = _MacroSubstitutionPegParser; +const LigaturesPegParser = _LigaturesPegParser; +const XColorPegParser = _XColorPegParser; +const TabularPegParser = _TabularPegParser; +const SystemePegParser = _SystemePegParser; +const GluePegParser = _GluePegParser; +const TikzPegParser = _TikzPegParser; +export { + AlignEnvironmentPegParser, + ArgSpecPegParser, + GluePegParser, + LatexPegParser, + LigaturesPegParser, + MacroSubstitutionPegParser, + PgfkeysPegParser, + SystemePegParser, + TabularPegParser, + TikzPegParser, + XColorPegParser, + decorateArrayForPegjs, + splitStringsIntoSingleChars +}; +//# sourceMappingURL=index.js.map diff --git a/node_modules/@unified-latex/unified-latex-util-pegjs/index.js.map b/node_modules/@unified-latex/unified-latex-util-pegjs/index.js.map new file mode 100644 index 0000000..451a69f --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-util-pegjs/index.js.map @@ -0,0 +1 @@ +{"version":3,"file":"index.js","sources":["../libs/decorate-array-for-pegjs.ts","../libs/split-strings.ts","../grammars/latex.pegjs","../grammars/align-environment.pegjs","../grammars/xparse-argspec.pegjs","../grammars/pgfkeys.pegjs","../grammars/macro-substitutions.pegjs","../grammars/ligatures.pegjs","../grammars/xcolor-expressions.pegjs","../grammars/tabular-spec.pegjs","../grammars/systeme-environment.pegjs","../grammars/tex-glue.pegjs","../grammars/tikz.pegjs","../libs/pegjs-parsers.ts"],"sourcesContent":["type StringlikeArray = any[] & string;\n\n/**\n * Pegjs operates on strings. However, strings and arrays are very similar!\n * This function adds `charAt`, `charCodeAt`, and `substring` methods to\n * `array` so that `array` can then be fed to a Pegjs generated parser.\n *\n * @param {[object]} array\n * @returns {[object]}\n */\nexport function decorateArrayForPegjs(array: any[]): StringlikeArray {\n (array as any).charAt = function (i: number) {\n return this[i];\n };\n // We don't have a hope of imitating `charCodeAt`, so\n // make it something that won't interfere\n (array as any).charCodeAt = () => 0;\n (array as any).substring = function (i: number, j: number) {\n return this.slice(i, j);\n };\n // This function is called when reporting an error,\n // so we convert back to a string.\n (array as any).replace = function (a: string, b: string) {\n const ret = JSON.stringify(this);\n return ret.replace(a, b);\n };\n return array as StringlikeArray;\n}\n","import * as Ast from \"@unified-latex/unified-latex-types\";\nimport { match } from \"@unified-latex/unified-latex-util-match\";\n\n/**\n * Splits all multi-character strings into strings that are all single characters.\n */\nexport function splitStringsIntoSingleChars(nodes: Ast.Node[]): Ast.Node[] {\n return nodes.flatMap((node) =>\n match.anyString(node)\n ? (Array.from(node.content).map((c) => ({\n type: \"string\",\n content: c,\n })) as Ast.Node[])\n : node\n );\n}\n","export default (\n // Generated by Peggy 3.0.2.\n //\n // https://peggyjs.org/\n function() {\n \"use strict\";\n function peg$subclass(child, parent) {\n function C() {\n this.constructor = child;\n }\n C.prototype = parent.prototype;\n child.prototype = new C();\n }\n function peg$SyntaxError(message, expected, found, location) {\n var self = Error.call(this, message);\n if (Object.setPrototypeOf) {\n Object.setPrototypeOf(self, peg$SyntaxError.prototype);\n }\n self.expected = expected;\n self.found = found;\n self.location = location;\n self.name = \"SyntaxError\";\n return self;\n }\n peg$subclass(peg$SyntaxError, Error);\n function peg$padEnd(str, targetLength, padString) {\n padString = padString || \" \";\n if (str.length > targetLength) {\n return str;\n }\n targetLength -= str.length;\n padString += padString.repeat(targetLength);\n return str + padString.slice(0, targetLength);\n }\n peg$SyntaxError.prototype.format = function(sources) {\n var str = \"Error: \" + this.message;\n if (this.location) {\n var src = null;\n var k;\n for (k = 0; k < sources.length; k++) {\n if (sources[k].source === this.location.source) {\n src = sources[k].text.split(/\\r\\n|\\n|\\r/g);\n break;\n }\n }\n var s = this.location.start;\n var offset_s = this.location.source && typeof this.location.source.offset === \"function\" ? this.location.source.offset(s) : s;\n var loc = this.location.source + \":\" + offset_s.line + \":\" + offset_s.column;\n if (src) {\n var e = this.location.end;\n var filler = peg$padEnd(\"\", offset_s.line.toString().length, \" \");\n var line = src[s.line - 1];\n var last = s.line === e.line ? e.column : line.length + 1;\n var hatLen = last - s.column || 1;\n str += \"\\n --> \" + loc + \"\\n\" + filler + \" |\\n\" + offset_s.line + \" | \" + line + \"\\n\" + filler + \" | \" + peg$padEnd(\"\", s.column - 1, \" \") + peg$padEnd(\"\", hatLen, \"^\");\n } else {\n str += \"\\n at \" + loc;\n }\n }\n return str;\n };\n peg$SyntaxError.buildMessage = function(expected, found) {\n var DESCRIBE_EXPECTATION_FNS = {\n literal: function(expectation) {\n return '\"' + literalEscape(expectation.text) + '\"';\n },\n class: function(expectation) {\n var escapedParts = expectation.parts.map(function(part) {\n return Array.isArray(part) ? classEscape(part[0]) + \"-\" + classEscape(part[1]) : classEscape(part);\n });\n return \"[\" + (expectation.inverted ? \"^\" : \"\") + escapedParts.join(\"\") + \"]\";\n },\n any: function() {\n return \"any character\";\n },\n end: function() {\n return \"end of input\";\n },\n other: function(expectation) {\n return expectation.description;\n }\n };\n function hex(ch) {\n return ch.charCodeAt(0).toString(16).toUpperCase();\n }\n function literalEscape(s) {\n return s.replace(/\\\\/g, \"\\\\\\\\\").replace(/\"/g, '\\\\\"').replace(/\\0/g, \"\\\\0\").replace(/\\t/g, \"\\\\t\").replace(/\\n/g, \"\\\\n\").replace(/\\r/g, \"\\\\r\").replace(/[\\x00-\\x0F]/g, function(ch) {\n return \"\\\\x0\" + hex(ch);\n }).replace(/[\\x10-\\x1F\\x7F-\\x9F]/g, function(ch) {\n return \"\\\\x\" + hex(ch);\n });\n }\n function classEscape(s) {\n return s.replace(/\\\\/g, \"\\\\\\\\\").replace(/\\]/g, \"\\\\]\").replace(/\\^/g, \"\\\\^\").replace(/-/g, \"\\\\-\").replace(/\\0/g, \"\\\\0\").replace(/\\t/g, \"\\\\t\").replace(/\\n/g, \"\\\\n\").replace(/\\r/g, \"\\\\r\").replace(/[\\x00-\\x0F]/g, function(ch) {\n return \"\\\\x0\" + hex(ch);\n }).replace(/[\\x10-\\x1F\\x7F-\\x9F]/g, function(ch) {\n return \"\\\\x\" + hex(ch);\n });\n }\n function describeExpectation(expectation) {\n return DESCRIBE_EXPECTATION_FNS[expectation.type](expectation);\n }\n function describeExpected(expected2) {\n var descriptions = expected2.map(describeExpectation);\n var i, j;\n descriptions.sort();\n if (descriptions.length > 0) {\n for (i = 1, j = 1; i < descriptions.length; i++) {\n if (descriptions[i - 1] !== descriptions[i]) {\n descriptions[j] = descriptions[i];\n j++;\n }\n }\n descriptions.length = j;\n }\n switch (descriptions.length) {\n case 1:\n return descriptions[0];\n case 2:\n return descriptions[0] + \" or \" + descriptions[1];\n default:\n return descriptions.slice(0, -1).join(\", \") + \", or \" + descriptions[descriptions.length - 1];\n }\n }\n function describeFound(found2) {\n return found2 ? '\"' + literalEscape(found2) + '\"' : \"end of input\";\n }\n return \"Expected \" + describeExpected(expected) + \" but \" + describeFound(found) + \" found.\";\n };\n function peg$parse(input, options) {\n options = options !== void 0 ? options : {};\n var peg$FAILED = {};\n var peg$source = options.grammarSource;\n var peg$startRuleFunctions = { document: peg$parsedocument, math: peg$parsemath };\n var peg$startRuleFunction = peg$parsedocument;\n var peg$c0 = \"%\";\n var peg$c1 = \".\";\n var peg$c2 = \"verb*\";\n var peg$c3 = \"verb\";\n var peg$c4 = \"[\";\n var peg$c5 = \"]\";\n var peg$c6 = \"lstinline\";\n var peg$c7 = \"mintinline\";\n var peg$c8 = \"mint\";\n var peg$c9 = \"minted\";\n var peg$c10 = \"verbatim*\";\n var peg$c11 = \"verbatim\";\n var peg$c12 = \"filecontents*\";\n var peg$c13 = \"filecontents\";\n var peg$c14 = \"comment\";\n var peg$c15 = \"lstlisting\";\n var peg$c16 = \"(\";\n var peg$c17 = \")\";\n var peg$c18 = \"begin\";\n var peg$c19 = \"end\";\n var peg$c20 = \"equation*\";\n var peg$c21 = \"equation\";\n var peg$c22 = \"align*\";\n var peg$c23 = \"align\";\n var peg$c24 = \"alignat*\";\n var peg$c25 = \"alignat\";\n var peg$c26 = \"gather*\";\n var peg$c27 = \"gather\";\n var peg$c28 = \"multline*\";\n var peg$c29 = \"multline\";\n var peg$c30 = \"flalign*\";\n var peg$c31 = \"flalign\";\n var peg$c32 = \"split\";\n var peg$c33 = \"math\";\n var peg$c34 = \"displaymath\";\n var peg$c35 = \"\\\\\";\n var peg$c36 = \"{\";\n var peg$c37 = \"}\";\n var peg$c38 = \"$\";\n var peg$c39 = \"&\";\n var peg$c40 = \"\\r\";\n var peg$c41 = \"\\n\";\n var peg$c42 = \"\\r\\n\";\n var peg$c43 = \"#\";\n var peg$c44 = \"^\";\n var peg$c45 = \"_\";\n var peg$c46 = \"\\0\";\n var peg$r0 = /^[^ \\t\\n\\r]/;\n var peg$r1 = /^[ \\t]/;\n var peg$r2 = /^[a-zA-Z]/;\n var peg$r3 = /^[0-9]/;\n var peg$r4 = /^[.,;:\\-*\\/()!?=+<>[\\]`'\"~]/;\n var peg$e0 = peg$otherExpectation(\"document\");\n var peg$e1 = peg$otherExpectation(\"math\");\n var peg$e2 = peg$otherExpectation(\"token\");\n var peg$e3 = peg$anyExpectation();\n var peg$e4 = peg$otherExpectation(\"parbreak\");\n var peg$e5 = peg$otherExpectation(\"math token\");\n var peg$e6 = peg$otherExpectation(\"nonchar token\");\n var peg$e7 = peg$literalExpectation(\"%\", false);\n var peg$e8 = peg$otherExpectation(\"whitespace\");\n var peg$e9 = peg$otherExpectation(\"number\");\n var peg$e10 = peg$literalExpectation(\".\", false);\n var peg$e11 = peg$otherExpectation(\"special macro\");\n var peg$e12 = peg$literalExpectation(\"verb*\", false);\n var peg$e13 = peg$literalExpectation(\"verb\", false);\n var peg$e14 = peg$literalExpectation(\"[\", false);\n var peg$e15 = peg$literalExpectation(\"]\", false);\n var peg$e16 = peg$classExpectation([\" \", \"\t\", \"\\n\", \"\\r\"], true, false);\n var peg$e17 = peg$otherExpectation(\"verbatim listings\");\n var peg$e18 = peg$literalExpectation(\"lstinline\", false);\n var peg$e19 = peg$otherExpectation(\"verbatim minted\");\n var peg$e20 = peg$literalExpectation(\"mintinline\", false);\n var peg$e21 = peg$literalExpectation(\"mint\", false);\n var peg$e22 = peg$otherExpectation(\"verbatim minted environment\");\n var peg$e23 = peg$literalExpectation(\"minted\", false);\n var peg$e24 = peg$otherExpectation(\"verbatim environment\");\n var peg$e25 = peg$literalExpectation(\"verbatim*\", false);\n var peg$e26 = peg$literalExpectation(\"verbatim\", false);\n var peg$e27 = peg$literalExpectation(\"filecontents*\", false);\n var peg$e28 = peg$literalExpectation(\"filecontents\", false);\n var peg$e29 = peg$literalExpectation(\"comment\", false);\n var peg$e30 = peg$literalExpectation(\"lstlisting\", false);\n var peg$e31 = peg$otherExpectation(\"macro\");\n var peg$e32 = peg$otherExpectation(\"group\");\n var peg$e33 = peg$otherExpectation(\"environment\");\n var peg$e34 = peg$otherExpectation(\"math environment\");\n var peg$e35 = peg$otherExpectation(\"math group\");\n var peg$e36 = peg$literalExpectation(\"(\", false);\n var peg$e37 = peg$literalExpectation(\")\", false);\n var peg$e38 = peg$literalExpectation(\"begin\", false);\n var peg$e39 = peg$literalExpectation(\"end\", false);\n var peg$e40 = peg$literalExpectation(\"equation*\", false);\n var peg$e41 = peg$literalExpectation(\"equation\", false);\n var peg$e42 = peg$literalExpectation(\"align*\", false);\n var peg$e43 = peg$literalExpectation(\"align\", false);\n var peg$e44 = peg$literalExpectation(\"alignat*\", false);\n var peg$e45 = peg$literalExpectation(\"alignat\", false);\n var peg$e46 = peg$literalExpectation(\"gather*\", false);\n var peg$e47 = peg$literalExpectation(\"gather\", false);\n var peg$e48 = peg$literalExpectation(\"multline*\", false);\n var peg$e49 = peg$literalExpectation(\"multline\", false);\n var peg$e50 = peg$literalExpectation(\"flalign*\", false);\n var peg$e51 = peg$literalExpectation(\"flalign\", false);\n var peg$e52 = peg$literalExpectation(\"split\", false);\n var peg$e53 = peg$literalExpectation(\"math\", false);\n var peg$e54 = peg$literalExpectation(\"displaymath\", false);\n var peg$e55 = peg$otherExpectation(\"escape\");\n var peg$e56 = peg$literalExpectation(\"\\\\\", false);\n var peg$e57 = peg$literalExpectation(\"{\", false);\n var peg$e58 = peg$literalExpectation(\"}\", false);\n var peg$e59 = peg$literalExpectation(\"$\", false);\n var peg$e60 = peg$literalExpectation(\"&\", false);\n var peg$e61 = peg$otherExpectation(\"newline\");\n var peg$e62 = peg$literalExpectation(\"\\r\", false);\n var peg$e63 = peg$literalExpectation(\"\\n\", false);\n var peg$e64 = peg$literalExpectation(\"\\r\\n\", false);\n var peg$e65 = peg$literalExpectation(\"#\", false);\n var peg$e66 = peg$literalExpectation(\"^\", false);\n var peg$e67 = peg$literalExpectation(\"_\", false);\n var peg$e68 = peg$literalExpectation(\"\\0\", false);\n var peg$e69 = peg$classExpectation([\" \", \"\t\"], false, false);\n var peg$e70 = peg$otherExpectation(\"letter\");\n var peg$e71 = peg$classExpectation([[\"a\", \"z\"], [\"A\", \"Z\"]], false, false);\n var peg$e72 = peg$otherExpectation(\"digit\");\n var peg$e73 = peg$classExpectation([[\"0\", \"9\"]], false, false);\n var peg$e74 = peg$otherExpectation(\"punctuation\");\n var peg$e75 = peg$classExpectation([\".\", \",\", \";\", \":\", \"-\", \"*\", \"/\", \"(\", \")\", \"!\", \"?\", \"=\", \"+\", \"<\", \">\", \"[\", \"]\", \"`\", \"'\", '\"', \"~\"], false, false);\n var peg$e76 = peg$otherExpectation(\"full comment\");\n var peg$e77 = peg$otherExpectation(\"comment\");\n var peg$f0 = function(content) {\n return createNode(\"root\", { content: content.flatMap((x) => x) });\n };\n var peg$f1 = function(t) {\n return t;\n };\n var peg$f2 = function(eq) {\n return createNode(\"inlinemath\", { content: eq.flatMap((x) => x) });\n };\n var peg$f3 = function(s) {\n return createNode(\"string\", { content: s });\n };\n var peg$f4 = function(s) {\n return createNode(\"string\", { content: s });\n };\n var peg$f5 = function() {\n return createNode(\"parbreak\");\n };\n var peg$f6 = function(x) {\n return x;\n };\n var peg$f7 = function(x) {\n return x;\n };\n var peg$f8 = function() {\n return createNode(\"macro\", { content: \"^\", escapeToken: \"\" });\n };\n var peg$f9 = function() {\n return createNode(\"macro\", { content: \"_\", escapeToken: \"\" });\n };\n var peg$f10 = function(s) {\n return createNode(\"string\", { content: s });\n };\n var peg$f11 = function() {\n return createNode(\"whitespace\");\n };\n var peg$f12 = function(a, b) {\n return a.join(\"\") + \".\" + b.join(\"\");\n };\n var peg$f13 = function(b) {\n return \".\" + b.join(\"\");\n };\n var peg$f14 = function(a) {\n return a.join(\"\") + \".\";\n };\n var peg$f15 = function(s) {\n return createNode(\"string\", { content: s });\n };\n var peg$f16 = function(env, e, end) {\n return end == e;\n };\n var peg$f17 = function(env, e, x) {\n return x;\n };\n var peg$f18 = function(env, e, x, end) {\n return end == e;\n };\n var peg$f19 = function(env, e, x) {\n return createNode(\"verb\", {\n env,\n escape: e,\n content: x.join(\"\")\n });\n };\n var peg$f20 = function(x) {\n return x;\n };\n var peg$f21 = function(x) {\n return createNode(\"displaymath\", { content: x.flatMap((x2) => x2) });\n };\n var peg$f22 = function(x) {\n return x;\n };\n var peg$f23 = function(x) {\n return createNode(\"inlinemath\", { content: x.flatMap((x2) => x2) });\n };\n var peg$f24 = function(x) {\n return x;\n };\n var peg$f25 = function(x) {\n return createNode(\"displaymath\", { content: x.flatMap((x2) => x2) });\n };\n var peg$f26 = function(end) {\n return end.type === \"string\" && end.content === \"]\";\n };\n var peg$f27 = function(x) {\n return x;\n };\n var peg$f28 = function(o) {\n return [\n createNode(\"string\", { content: \"[\" }),\n ...o,\n createNode(\"string\", { content: \"]\" })\n ];\n };\n var peg$f29 = function(x) {\n return x;\n };\n var peg$f30 = function(v) {\n return createNode(\"group\", {\n content: createNode(\"string\", { content: v.join(\"\") })\n });\n };\n var peg$f31 = function(d, end) {\n return end == d;\n };\n var peg$f32 = function(d, x) {\n return x;\n };\n var peg$f33 = function(d, v, end) {\n return end == d;\n };\n var peg$f34 = function(d, v) {\n return [\n createNode(\"string\", { content: d }),\n createNode(\"string\", { content: v.join(\"\") }),\n createNode(\"string\", { content: d })\n ];\n };\n var peg$f35 = function(macro, option, verbatim) {\n return [\n createNode(\"macro\", { content: macro }),\n ...option || [],\n ...[].concat(verbatim)\n ];\n };\n var peg$f36 = function(macro, option, language, verbatim) {\n return [\n createNode(\"macro\", { content: macro }),\n ...option || [],\n language,\n ...[].concat(verbatim)\n ];\n };\n var peg$f37 = function(env, option, language, end_env) {\n return compare_env({ content: [env] }, end_env);\n };\n var peg$f38 = function(env, option, language, body) {\n const content = [\n ...option || [],\n language,\n { type: \"string\", content: body }\n ];\n return createNode(\"environment\", {\n env,\n content\n });\n };\n var peg$f39 = function(env, end_env) {\n return compare_env({ content: [env] }, end_env);\n };\n var peg$f40 = function(env, x) {\n return x;\n };\n var peg$f41 = function(env, body) {\n return createNode(\"verbatim\", {\n env,\n content: body\n });\n };\n var peg$f42 = function(n) {\n return n.join(\"\");\n };\n var peg$f43 = function(n) {\n return n;\n };\n var peg$f44 = function(m) {\n return createNode(\"macro\", { content: m });\n };\n var peg$f45 = function(c) {\n return c;\n };\n var peg$f46 = function(x) {\n return createNode(\"group\", { content: x.flatMap((x2) => x2) });\n };\n var peg$f47 = function(g) {\n return text().slice(1, -1);\n };\n var peg$f48 = function(env, env_comment, end_env) {\n return compare_env(env, end_env);\n };\n var peg$f49 = function(env, env_comment, x) {\n return x;\n };\n var peg$f50 = function(env, env_comment, body) {\n body = body.flatMap((x) => x);\n return createNode(\"environment\", {\n env,\n content: env_comment ? [env_comment, ...body] : body\n });\n };\n var peg$f51 = function(env, env_comment, end_env) {\n return compare_env({ content: [env] }, end_env);\n };\n var peg$f52 = function(env, env_comment, x) {\n return x;\n };\n var peg$f53 = function(env, env_comment, body) {\n body = body.flatMap((x) => x);\n return createNode(\"mathenv\", {\n env,\n content: env_comment ? [env_comment, ...body] : body\n });\n };\n var peg$f54 = function(c) {\n return c;\n };\n var peg$f55 = function(x) {\n return createNode(\"group\", { content: x.flatMap((x2) => x2) });\n };\n var peg$f56 = function(e) {\n return createNode(\"string\", { content: e });\n };\n var peg$f57 = function() {\n return createNode(\"string\", { content: \"\\\\\" });\n };\n var peg$f58 = function(s) {\n return createNode(\"string\", { content: s });\n };\n var peg$f59 = function(s) {\n return createNode(\"string\", { content: s });\n };\n var peg$f60 = function(s) {\n return createNode(\"string\", { content: s });\n };\n var peg$f61 = function(s) {\n return createNode(\"string\", { content: s });\n };\n var peg$f62 = function(s) {\n return createNode(\"string\", { content: s });\n };\n var peg$f63 = function(s) {\n return createNode(\"string\", { content: s });\n };\n var peg$f64 = function(s) {\n return createNode(\"string\", { content: s });\n };\n var peg$f65 = function() {\n return \" \";\n };\n var peg$f66 = function(p) {\n return createNode(\"string\", { content: p });\n };\n var peg$f67 = function(leading_sp, comment) {\n return createNode(\"comment\", {\n ...comment,\n sameline: false,\n leadingWhitespace: leading_sp.length > 0\n });\n };\n var peg$f68 = function(spaces, x) {\n return createNode(\"comment\", {\n ...x,\n sameline: true,\n leadingWhitespace: spaces.length > 0\n });\n };\n var peg$f69 = function(c) {\n return c;\n };\n var peg$f70 = function(c) {\n return { content: c.join(\"\"), suffixParbreak: true };\n };\n var peg$f71 = function(c) {\n return c;\n };\n var peg$f72 = function(c) {\n return { content: c.join(\"\") };\n };\n var peg$f73 = function() {\n var loc = location();\n return loc.start.column === 1;\n };\n var peg$currPos = 0;\n var peg$savedPos = 0;\n var peg$posDetailsCache = [{ line: 1, column: 1 }];\n var peg$maxFailPos = 0;\n var peg$maxFailExpected = [];\n var peg$silentFails = 0;\n var peg$resultsCache = {};\n var peg$result;\n if (\"startRule\" in options) {\n if (!(options.startRule in peg$startRuleFunctions)) {\n throw new Error(`Can't start parsing from rule \"` + options.startRule + '\".');\n }\n peg$startRuleFunction = peg$startRuleFunctions[options.startRule];\n }\n function text() {\n return input.substring(peg$savedPos, peg$currPos);\n }\n function offset() {\n return peg$savedPos;\n }\n function range() {\n return {\n source: peg$source,\n start: peg$savedPos,\n end: peg$currPos\n };\n }\n function location() {\n return peg$computeLocation(peg$savedPos, peg$currPos);\n }\n function expected(description, location2) {\n location2 = location2 !== void 0 ? location2 : peg$computeLocation(peg$savedPos, peg$currPos);\n throw peg$buildStructuredError(\n [peg$otherExpectation(description)],\n input.substring(peg$savedPos, peg$currPos),\n location2\n );\n }\n function error(message, location2) {\n location2 = location2 !== void 0 ? location2 : peg$computeLocation(peg$savedPos, peg$currPos);\n throw peg$buildSimpleError(message, location2);\n }\n function peg$literalExpectation(text2, ignoreCase) {\n return { type: \"literal\", text: text2, ignoreCase };\n }\n function peg$classExpectation(parts, inverted, ignoreCase) {\n return { type: \"class\", parts, inverted, ignoreCase };\n }\n function peg$anyExpectation() {\n return { type: \"any\" };\n }\n function peg$endExpectation() {\n return { type: \"end\" };\n }\n function peg$otherExpectation(description) {\n return { type: \"other\", description };\n }\n function peg$computePosDetails(pos) {\n var details = peg$posDetailsCache[pos];\n var p;\n if (details) {\n return details;\n } else {\n p = pos - 1;\n while (!peg$posDetailsCache[p]) {\n p--;\n }\n details = peg$posDetailsCache[p];\n details = {\n line: details.line,\n column: details.column\n };\n while (p < pos) {\n if (input.charCodeAt(p) === 10) {\n details.line++;\n details.column = 1;\n } else {\n details.column++;\n }\n p++;\n }\n peg$posDetailsCache[pos] = details;\n return details;\n }\n }\n function peg$computeLocation(startPos, endPos, offset2) {\n var startPosDetails = peg$computePosDetails(startPos);\n var endPosDetails = peg$computePosDetails(endPos);\n var res = {\n source: peg$source,\n start: {\n offset: startPos,\n line: startPosDetails.line,\n column: startPosDetails.column\n },\n end: {\n offset: endPos,\n line: endPosDetails.line,\n column: endPosDetails.column\n }\n };\n if (offset2 && peg$source && typeof peg$source.offset === \"function\") {\n res.start = peg$source.offset(res.start);\n res.end = peg$source.offset(res.end);\n }\n return res;\n }\n function peg$fail(expected2) {\n if (peg$currPos < peg$maxFailPos) {\n return;\n }\n if (peg$currPos > peg$maxFailPos) {\n peg$maxFailPos = peg$currPos;\n peg$maxFailExpected = [];\n }\n peg$maxFailExpected.push(expected2);\n }\n function peg$buildSimpleError(message, location2) {\n return new peg$SyntaxError(message, null, null, location2);\n }\n function peg$buildStructuredError(expected2, found, location2) {\n return new peg$SyntaxError(\n peg$SyntaxError.buildMessage(expected2, found),\n expected2,\n found,\n location2\n );\n }\n function peg$parsedocument() {\n var s0, s1, s2;\n var key = peg$currPos * 52 + 0;\n var cached = peg$resultsCache[key];\n if (cached) {\n peg$currPos = cached.nextPos;\n return cached.result;\n }\n peg$silentFails++;\n s0 = peg$currPos;\n s1 = [];\n s2 = peg$parsetoken();\n while (s2 !== peg$FAILED) {\n s1.push(s2);\n s2 = peg$parsetoken();\n }\n peg$savedPos = s0;\n s1 = peg$f0(s1);\n s0 = s1;\n peg$silentFails--;\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };\n return s0;\n }\n function peg$parsemath() {\n var s0, s1;\n var key = peg$currPos * 52 + 1;\n var cached = peg$resultsCache[key];\n if (cached) {\n peg$currPos = cached.nextPos;\n return cached.result;\n }\n peg$silentFails++;\n s0 = [];\n s1 = peg$parsemath_token();\n while (s1 !== peg$FAILED) {\n s0.push(s1);\n s1 = peg$parsemath_token();\n }\n peg$silentFails--;\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e1);\n }\n peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };\n return s0;\n }\n function peg$parsetoken() {\n var s0, s1, s2, s3, s4, s5;\n var key = peg$currPos * 52 + 2;\n var cached = peg$resultsCache[key];\n if (cached) {\n peg$currPos = cached.nextPos;\n return cached.result;\n }\n peg$silentFails++;\n s0 = peg$parsespecial_macro();\n if (s0 === peg$FAILED) {\n s0 = peg$parsemacro();\n if (s0 === peg$FAILED) {\n s0 = peg$parsefull_comment();\n if (s0 === peg$FAILED) {\n s0 = peg$parsegroup();\n if (s0 === peg$FAILED) {\n s0 = peg$currPos;\n s1 = peg$parsemath_shift();\n if (s1 !== peg$FAILED) {\n s2 = [];\n s3 = peg$currPos;\n s4 = peg$currPos;\n peg$silentFails++;\n s5 = peg$parsemath_shift();\n peg$silentFails--;\n if (s5 === peg$FAILED) {\n s4 = void 0;\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n if (s4 !== peg$FAILED) {\n s5 = peg$parsemath_token();\n if (s5 !== peg$FAILED) {\n peg$savedPos = s3;\n s3 = peg$f1(s5);\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n if (s3 !== peg$FAILED) {\n while (s3 !== peg$FAILED) {\n s2.push(s3);\n s3 = peg$currPos;\n s4 = peg$currPos;\n peg$silentFails++;\n s5 = peg$parsemath_shift();\n peg$silentFails--;\n if (s5 === peg$FAILED) {\n s4 = void 0;\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n if (s4 !== peg$FAILED) {\n s5 = peg$parsemath_token();\n if (s5 !== peg$FAILED) {\n peg$savedPos = s3;\n s3 = peg$f1(s5);\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n }\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n s3 = peg$parsemath_shift();\n if (s3 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f2(s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n if (s0 === peg$FAILED) {\n s0 = peg$parsealignment_tab();\n if (s0 === peg$FAILED) {\n s0 = peg$parseparbreak();\n if (s0 === peg$FAILED) {\n s0 = peg$parsemacro_parameter();\n if (s0 === peg$FAILED) {\n s0 = peg$parseignore();\n if (s0 === peg$FAILED) {\n s0 = peg$parsenumber();\n if (s0 === peg$FAILED) {\n s0 = peg$parsewhitespace();\n if (s0 === peg$FAILED) {\n s0 = peg$parsepunctuation();\n if (s0 === peg$FAILED) {\n s0 = peg$currPos;\n s1 = peg$currPos;\n s2 = [];\n s3 = peg$currPos;\n s4 = peg$currPos;\n peg$silentFails++;\n s5 = peg$parsenonchar_token();\n peg$silentFails--;\n if (s5 === peg$FAILED) {\n s4 = void 0;\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n if (s4 !== peg$FAILED) {\n if (input.length > peg$currPos) {\n s5 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s5 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e3);\n }\n }\n if (s5 !== peg$FAILED) {\n s4 = [s4, s5];\n s3 = s4;\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n if (s3 !== peg$FAILED) {\n while (s3 !== peg$FAILED) {\n s2.push(s3);\n s3 = peg$currPos;\n s4 = peg$currPos;\n peg$silentFails++;\n s5 = peg$parsenonchar_token();\n peg$silentFails--;\n if (s5 === peg$FAILED) {\n s4 = void 0;\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n if (s4 !== peg$FAILED) {\n if (input.length > peg$currPos) {\n s5 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s5 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e3);\n }\n }\n if (s5 !== peg$FAILED) {\n s4 = [s4, s5];\n s3 = s4;\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n }\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n s1 = input.substring(s1, peg$currPos);\n } else {\n s1 = s2;\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = s0;\n s1 = peg$f3(s1);\n }\n s0 = s1;\n if (s0 === peg$FAILED) {\n s0 = peg$parsebegin_group();\n if (s0 === peg$FAILED) {\n s0 = peg$parseend_group();\n if (s0 === peg$FAILED) {\n s0 = peg$parsemath_shift();\n if (s0 === peg$FAILED) {\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e3);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = s0;\n s1 = peg$f4(s1);\n }\n s0 = s1;\n }\n }\n }\n }\n }\n }\n }\n }\n }\n }\n }\n }\n }\n }\n }\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e2);\n }\n }\n peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };\n return s0;\n }\n function peg$parseparbreak() {\n var s0, s1, s2, s3, s4, s5, s6, s7;\n var key = peg$currPos * 52 + 3;\n var cached = peg$resultsCache[key];\n if (cached) {\n peg$currPos = cached.nextPos;\n return cached.result;\n }\n peg$silentFails++;\n s0 = peg$currPos;\n s1 = peg$currPos;\n s2 = [];\n s3 = peg$parsesp();\n while (s3 !== peg$FAILED) {\n s2.push(s3);\n s3 = peg$parsesp();\n }\n s3 = peg$parsenl();\n if (s3 !== peg$FAILED) {\n s4 = [];\n s5 = peg$currPos;\n s6 = [];\n s7 = peg$parsesp();\n while (s7 !== peg$FAILED) {\n s6.push(s7);\n s7 = peg$parsesp();\n }\n s7 = peg$parsenl();\n if (s7 !== peg$FAILED) {\n s6 = [s6, s7];\n s5 = s6;\n } else {\n peg$currPos = s5;\n s5 = peg$FAILED;\n }\n if (s5 !== peg$FAILED) {\n while (s5 !== peg$FAILED) {\n s4.push(s5);\n s5 = peg$currPos;\n s6 = [];\n s7 = peg$parsesp();\n while (s7 !== peg$FAILED) {\n s6.push(s7);\n s7 = peg$parsesp();\n }\n s7 = peg$parsenl();\n if (s7 !== peg$FAILED) {\n s6 = [s6, s7];\n s5 = s6;\n } else {\n peg$currPos = s5;\n s5 = peg$FAILED;\n }\n }\n } else {\n s4 = peg$FAILED;\n }\n if (s4 !== peg$FAILED) {\n s5 = [];\n s6 = peg$parsesp();\n while (s6 !== peg$FAILED) {\n s5.push(s6);\n s6 = peg$parsesp();\n }\n s6 = peg$currPos;\n peg$silentFails++;\n s7 = peg$parsecomment_start();\n peg$silentFails--;\n if (s7 === peg$FAILED) {\n s6 = void 0;\n } else {\n peg$currPos = s6;\n s6 = peg$FAILED;\n }\n if (s6 !== peg$FAILED) {\n s2 = [s2, s3, s4, s5, s6];\n s1 = s2;\n } else {\n peg$currPos = s1;\n s1 = peg$FAILED;\n }\n } else {\n peg$currPos = s1;\n s1 = peg$FAILED;\n }\n } else {\n peg$currPos = s1;\n s1 = peg$FAILED;\n }\n if (s1 === peg$FAILED) {\n s1 = peg$currPos;\n s2 = [];\n s3 = peg$parsesp();\n while (s3 !== peg$FAILED) {\n s2.push(s3);\n s3 = peg$parsesp();\n }\n s3 = peg$parsenl();\n if (s3 !== peg$FAILED) {\n s4 = [];\n s5 = peg$currPos;\n s6 = [];\n s7 = peg$parsesp();\n while (s7 !== peg$FAILED) {\n s6.push(s7);\n s7 = peg$parsesp();\n }\n s7 = peg$parsenl();\n if (s7 !== peg$FAILED) {\n s6 = [s6, s7];\n s5 = s6;\n } else {\n peg$currPos = s5;\n s5 = peg$FAILED;\n }\n if (s5 !== peg$FAILED) {\n while (s5 !== peg$FAILED) {\n s4.push(s5);\n s5 = peg$currPos;\n s6 = [];\n s7 = peg$parsesp();\n while (s7 !== peg$FAILED) {\n s6.push(s7);\n s7 = peg$parsesp();\n }\n s7 = peg$parsenl();\n if (s7 !== peg$FAILED) {\n s6 = [s6, s7];\n s5 = s6;\n } else {\n peg$currPos = s5;\n s5 = peg$FAILED;\n }\n }\n } else {\n s4 = peg$FAILED;\n }\n if (s4 !== peg$FAILED) {\n s2 = [s2, s3, s4];\n s1 = s2;\n } else {\n peg$currPos = s1;\n s1 = peg$FAILED;\n }\n } else {\n peg$currPos = s1;\n s1 = peg$FAILED;\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = s0;\n s1 = peg$f5();\n }\n s0 = s1;\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e4);\n }\n }\n peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };\n return s0;\n }\n function peg$parsemath_token() {\n var s0, s1, s2, s3, s4;\n var key = peg$currPos * 52 + 4;\n var cached = peg$resultsCache[key];\n if (cached) {\n peg$currPos = cached.nextPos;\n return cached.result;\n }\n peg$silentFails++;\n s0 = peg$parsespecial_macro();\n if (s0 === peg$FAILED) {\n s0 = peg$parsemacro();\n if (s0 === peg$FAILED) {\n s0 = peg$parsefull_comment();\n if (s0 === peg$FAILED) {\n s0 = peg$currPos;\n s1 = [];\n s2 = peg$parsewhitespace();\n while (s2 !== peg$FAILED) {\n s1.push(s2);\n s2 = peg$parsewhitespace();\n }\n s2 = peg$parsegroup();\n if (s2 !== peg$FAILED) {\n s3 = [];\n s4 = peg$parsewhitespace();\n while (s4 !== peg$FAILED) {\n s3.push(s4);\n s4 = peg$parsewhitespace();\n }\n peg$savedPos = s0;\n s0 = peg$f6(s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n if (s0 === peg$FAILED) {\n s0 = peg$currPos;\n s1 = [];\n s2 = peg$parsewhitespace();\n while (s2 !== peg$FAILED) {\n s1.push(s2);\n s2 = peg$parsewhitespace();\n }\n s2 = peg$parsealignment_tab();\n if (s2 !== peg$FAILED) {\n s3 = [];\n s4 = peg$parsewhitespace();\n while (s4 !== peg$FAILED) {\n s3.push(s4);\n s4 = peg$parsewhitespace();\n }\n peg$savedPos = s0;\n s0 = peg$f7(s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n if (s0 === peg$FAILED) {\n s0 = peg$parsemacro_parameter();\n if (s0 === peg$FAILED) {\n s0 = peg$currPos;\n s1 = [];\n s2 = peg$parsewhitespace();\n while (s2 !== peg$FAILED) {\n s1.push(s2);\n s2 = peg$parsewhitespace();\n }\n s2 = peg$parsesuperscript();\n if (s2 !== peg$FAILED) {\n s3 = [];\n s4 = peg$parsewhitespace();\n while (s4 !== peg$FAILED) {\n s3.push(s4);\n s4 = peg$parsewhitespace();\n }\n peg$savedPos = s0;\n s0 = peg$f8();\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n if (s0 === peg$FAILED) {\n s0 = peg$currPos;\n s1 = [];\n s2 = peg$parsewhitespace();\n while (s2 !== peg$FAILED) {\n s1.push(s2);\n s2 = peg$parsewhitespace();\n }\n s2 = peg$parsesubscript();\n if (s2 !== peg$FAILED) {\n s3 = [];\n s4 = peg$parsewhitespace();\n while (s4 !== peg$FAILED) {\n s3.push(s4);\n s4 = peg$parsewhitespace();\n }\n peg$savedPos = s0;\n s0 = peg$f9();\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n if (s0 === peg$FAILED) {\n s0 = peg$parseignore();\n if (s0 === peg$FAILED) {\n s0 = peg$parsewhitespace();\n if (s0 === peg$FAILED) {\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e3);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = s0;\n s1 = peg$f10(s1);\n }\n s0 = s1;\n }\n }\n }\n }\n }\n }\n }\n }\n }\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e5);\n }\n }\n peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };\n return s0;\n }\n function peg$parsenonchar_token() {\n var s0, s1;\n var key = peg$currPos * 52 + 5;\n var cached = peg$resultsCache[key];\n if (cached) {\n peg$currPos = cached.nextPos;\n return cached.result;\n }\n peg$silentFails++;\n s0 = peg$parseescape();\n if (s0 === peg$FAILED) {\n if (input.charCodeAt(peg$currPos) === 37) {\n s0 = peg$c0;\n peg$currPos++;\n } else {\n s0 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e7);\n }\n }\n if (s0 === peg$FAILED) {\n s0 = peg$parsebegin_group();\n if (s0 === peg$FAILED) {\n s0 = peg$parseend_group();\n if (s0 === peg$FAILED) {\n s0 = peg$parsemath_shift();\n if (s0 === peg$FAILED) {\n s0 = peg$parsealignment_tab();\n if (s0 === peg$FAILED) {\n s0 = peg$parsenl();\n if (s0 === peg$FAILED) {\n s0 = peg$parsemacro_parameter();\n if (s0 === peg$FAILED) {\n s0 = peg$parseignore();\n if (s0 === peg$FAILED) {\n s0 = peg$parsesp();\n if (s0 === peg$FAILED) {\n s0 = peg$parsepunctuation();\n if (s0 === peg$FAILED) {\n s0 = peg$parseEOF();\n }\n }\n }\n }\n }\n }\n }\n }\n }\n }\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e6);\n }\n }\n peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };\n return s0;\n }\n function peg$parsewhitespace() {\n var s0, s1, s2, s3, s4, s5, s6, s7;\n var key = peg$currPos * 52 + 6;\n var cached = peg$resultsCache[key];\n if (cached) {\n peg$currPos = cached.nextPos;\n return cached.result;\n }\n peg$silentFails++;\n s0 = peg$currPos;\n s1 = peg$currPos;\n s2 = peg$parsenl();\n if (s2 !== peg$FAILED) {\n s3 = [];\n s4 = peg$parsesp();\n while (s4 !== peg$FAILED) {\n s3.push(s4);\n s4 = peg$parsesp();\n }\n s2 = [s2, s3];\n s1 = s2;\n } else {\n peg$currPos = s1;\n s1 = peg$FAILED;\n }\n if (s1 === peg$FAILED) {\n s1 = peg$currPos;\n s2 = [];\n s3 = peg$parsesp();\n if (s3 !== peg$FAILED) {\n while (s3 !== peg$FAILED) {\n s2.push(s3);\n s3 = peg$parsesp();\n }\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n s3 = peg$parsenl();\n if (s3 !== peg$FAILED) {\n s4 = peg$currPos;\n peg$silentFails++;\n s5 = peg$parsecomment_start();\n peg$silentFails--;\n if (s5 === peg$FAILED) {\n s4 = void 0;\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n if (s4 !== peg$FAILED) {\n s5 = [];\n s6 = peg$parsesp();\n while (s6 !== peg$FAILED) {\n s5.push(s6);\n s6 = peg$parsesp();\n }\n s6 = peg$currPos;\n peg$silentFails++;\n s7 = peg$parsenl();\n peg$silentFails--;\n if (s7 === peg$FAILED) {\n s6 = void 0;\n } else {\n peg$currPos = s6;\n s6 = peg$FAILED;\n }\n if (s6 !== peg$FAILED) {\n s2 = [s2, s3, s4, s5, s6];\n s1 = s2;\n } else {\n peg$currPos = s1;\n s1 = peg$FAILED;\n }\n } else {\n peg$currPos = s1;\n s1 = peg$FAILED;\n }\n } else {\n peg$currPos = s1;\n s1 = peg$FAILED;\n }\n } else {\n peg$currPos = s1;\n s1 = peg$FAILED;\n }\n if (s1 === peg$FAILED) {\n s1 = [];\n s2 = peg$parsesp();\n if (s2 !== peg$FAILED) {\n while (s2 !== peg$FAILED) {\n s1.push(s2);\n s2 = peg$parsesp();\n }\n } else {\n s1 = peg$FAILED;\n }\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = s0;\n s1 = peg$f11();\n }\n s0 = s1;\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e8);\n }\n }\n peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };\n return s0;\n }\n function peg$parsenumber() {\n var s0, s1, s2, s3, s4, s5;\n var key = peg$currPos * 52 + 7;\n var cached = peg$resultsCache[key];\n if (cached) {\n peg$currPos = cached.nextPos;\n return cached.result;\n }\n peg$silentFails++;\n s0 = peg$currPos;\n s1 = peg$currPos;\n s2 = [];\n s3 = peg$parsenum();\n if (s3 !== peg$FAILED) {\n while (s3 !== peg$FAILED) {\n s2.push(s3);\n s3 = peg$parsenum();\n }\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n if (input.charCodeAt(peg$currPos) === 46) {\n s3 = peg$c1;\n peg$currPos++;\n } else {\n s3 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e10);\n }\n }\n if (s3 !== peg$FAILED) {\n s4 = [];\n s5 = peg$parsenum();\n if (s5 !== peg$FAILED) {\n while (s5 !== peg$FAILED) {\n s4.push(s5);\n s5 = peg$parsenum();\n }\n } else {\n s4 = peg$FAILED;\n }\n if (s4 !== peg$FAILED) {\n peg$savedPos = s1;\n s1 = peg$f12(s2, s4);\n } else {\n peg$currPos = s1;\n s1 = peg$FAILED;\n }\n } else {\n peg$currPos = s1;\n s1 = peg$FAILED;\n }\n } else {\n peg$currPos = s1;\n s1 = peg$FAILED;\n }\n if (s1 === peg$FAILED) {\n s1 = peg$currPos;\n if (input.charCodeAt(peg$currPos) === 46) {\n s2 = peg$c1;\n peg$currPos++;\n } else {\n s2 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e10);\n }\n }\n if (s2 !== peg$FAILED) {\n s3 = [];\n s4 = peg$parsenum();\n if (s4 !== peg$FAILED) {\n while (s4 !== peg$FAILED) {\n s3.push(s4);\n s4 = peg$parsenum();\n }\n } else {\n s3 = peg$FAILED;\n }\n if (s3 !== peg$FAILED) {\n peg$savedPos = s1;\n s1 = peg$f13(s3);\n } else {\n peg$currPos = s1;\n s1 = peg$FAILED;\n }\n } else {\n peg$currPos = s1;\n s1 = peg$FAILED;\n }\n if (s1 === peg$FAILED) {\n s1 = peg$currPos;\n s2 = [];\n s3 = peg$parsenum();\n if (s3 !== peg$FAILED) {\n while (s3 !== peg$FAILED) {\n s2.push(s3);\n s3 = peg$parsenum();\n }\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n if (input.charCodeAt(peg$currPos) === 46) {\n s3 = peg$c1;\n peg$currPos++;\n } else {\n s3 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e10);\n }\n }\n if (s3 !== peg$FAILED) {\n peg$savedPos = s1;\n s1 = peg$f14(s2);\n } else {\n peg$currPos = s1;\n s1 = peg$FAILED;\n }\n } else {\n peg$currPos = s1;\n s1 = peg$FAILED;\n }\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = s0;\n s1 = peg$f15(s1);\n }\n s0 = s1;\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e9);\n }\n }\n peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };\n return s0;\n }\n function peg$parsespecial_macro() {\n var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;\n var key = peg$currPos * 52 + 8;\n var cached = peg$resultsCache[key];\n if (cached) {\n peg$currPos = cached.nextPos;\n return cached.result;\n }\n peg$silentFails++;\n s0 = peg$currPos;\n s1 = peg$parseescape();\n if (s1 !== peg$FAILED) {\n if (input.substr(peg$currPos, 5) === peg$c2) {\n s2 = peg$c2;\n peg$currPos += 5;\n } else {\n s2 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e12);\n }\n }\n if (s2 === peg$FAILED) {\n if (input.substr(peg$currPos, 4) === peg$c3) {\n s2 = peg$c3;\n peg$currPos += 4;\n } else {\n s2 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e13);\n }\n }\n }\n if (s2 !== peg$FAILED) {\n if (input.length > peg$currPos) {\n s3 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s3 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e3);\n }\n }\n if (s3 !== peg$FAILED) {\n s4 = [];\n s5 = peg$currPos;\n s6 = peg$currPos;\n peg$silentFails++;\n s7 = peg$currPos;\n if (input.length > peg$currPos) {\n s8 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s8 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e3);\n }\n }\n if (s8 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s9 = peg$f16(s2, s3, s8);\n if (s9) {\n s9 = void 0;\n } else {\n s9 = peg$FAILED;\n }\n if (s9 !== peg$FAILED) {\n s8 = [s8, s9];\n s7 = s8;\n } else {\n peg$currPos = s7;\n s7 = peg$FAILED;\n }\n } else {\n peg$currPos = s7;\n s7 = peg$FAILED;\n }\n peg$silentFails--;\n if (s7 === peg$FAILED) {\n s6 = void 0;\n } else {\n peg$currPos = s6;\n s6 = peg$FAILED;\n }\n if (s6 !== peg$FAILED) {\n if (input.length > peg$currPos) {\n s7 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s7 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e3);\n }\n }\n if (s7 !== peg$FAILED) {\n peg$savedPos = s5;\n s5 = peg$f17(s2, s3, s7);\n } else {\n peg$currPos = s5;\n s5 = peg$FAILED;\n }\n } else {\n peg$currPos = s5;\n s5 = peg$FAILED;\n }\n while (s5 !== peg$FAILED) {\n s4.push(s5);\n s5 = peg$currPos;\n s6 = peg$currPos;\n peg$silentFails++;\n s7 = peg$currPos;\n if (input.length > peg$currPos) {\n s8 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s8 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e3);\n }\n }\n if (s8 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s9 = peg$f16(s2, s3, s8);\n if (s9) {\n s9 = void 0;\n } else {\n s9 = peg$FAILED;\n }\n if (s9 !== peg$FAILED) {\n s8 = [s8, s9];\n s7 = s8;\n } else {\n peg$currPos = s7;\n s7 = peg$FAILED;\n }\n } else {\n peg$currPos = s7;\n s7 = peg$FAILED;\n }\n peg$silentFails--;\n if (s7 === peg$FAILED) {\n s6 = void 0;\n } else {\n peg$currPos = s6;\n s6 = peg$FAILED;\n }\n if (s6 !== peg$FAILED) {\n if (input.length > peg$currPos) {\n s7 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s7 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e3);\n }\n }\n if (s7 !== peg$FAILED) {\n peg$savedPos = s5;\n s5 = peg$f17(s2, s3, s7);\n } else {\n peg$currPos = s5;\n s5 = peg$FAILED;\n }\n } else {\n peg$currPos = s5;\n s5 = peg$FAILED;\n }\n }\n s5 = peg$currPos;\n if (input.length > peg$currPos) {\n s6 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s6 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e3);\n }\n }\n if (s6 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s7 = peg$f18(s2, s3, s4, s6);\n if (s7) {\n s7 = void 0;\n } else {\n s7 = peg$FAILED;\n }\n if (s7 !== peg$FAILED) {\n s6 = [s6, s7];\n s5 = s6;\n } else {\n peg$currPos = s5;\n s5 = peg$FAILED;\n }\n } else {\n peg$currPos = s5;\n s5 = peg$FAILED;\n }\n if (s5 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f19(s2, s3, s4);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n if (s0 === peg$FAILED) {\n s0 = peg$parseverbatim_listings();\n if (s0 === peg$FAILED) {\n s0 = peg$parseverbatim_minted();\n if (s0 === peg$FAILED) {\n s0 = peg$parseverbatim_minted_environment();\n if (s0 === peg$FAILED) {\n s0 = peg$parseverbatim_environment();\n if (s0 === peg$FAILED) {\n s0 = peg$currPos;\n s1 = peg$parsebegin_display_math();\n if (s1 !== peg$FAILED) {\n s2 = [];\n s3 = peg$currPos;\n s4 = peg$currPos;\n peg$silentFails++;\n s5 = peg$parseend_display_math();\n peg$silentFails--;\n if (s5 === peg$FAILED) {\n s4 = void 0;\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n if (s4 !== peg$FAILED) {\n s5 = peg$parsemath_token();\n if (s5 !== peg$FAILED) {\n peg$savedPos = s3;\n s3 = peg$f20(s5);\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n while (s3 !== peg$FAILED) {\n s2.push(s3);\n s3 = peg$currPos;\n s4 = peg$currPos;\n peg$silentFails++;\n s5 = peg$parseend_display_math();\n peg$silentFails--;\n if (s5 === peg$FAILED) {\n s4 = void 0;\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n if (s4 !== peg$FAILED) {\n s5 = peg$parsemath_token();\n if (s5 !== peg$FAILED) {\n peg$savedPos = s3;\n s3 = peg$f20(s5);\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n }\n s3 = peg$parseend_display_math();\n if (s3 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f21(s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n if (s0 === peg$FAILED) {\n s0 = peg$currPos;\n s1 = peg$parsebegin_inline_math();\n if (s1 !== peg$FAILED) {\n s2 = [];\n s3 = peg$currPos;\n s4 = peg$currPos;\n peg$silentFails++;\n s5 = peg$parseend_inline_math();\n peg$silentFails--;\n if (s5 === peg$FAILED) {\n s4 = void 0;\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n if (s4 !== peg$FAILED) {\n s5 = peg$parsemath_token();\n if (s5 !== peg$FAILED) {\n peg$savedPos = s3;\n s3 = peg$f22(s5);\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n while (s3 !== peg$FAILED) {\n s2.push(s3);\n s3 = peg$currPos;\n s4 = peg$currPos;\n peg$silentFails++;\n s5 = peg$parseend_inline_math();\n peg$silentFails--;\n if (s5 === peg$FAILED) {\n s4 = void 0;\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n if (s4 !== peg$FAILED) {\n s5 = peg$parsemath_token();\n if (s5 !== peg$FAILED) {\n peg$savedPos = s3;\n s3 = peg$f22(s5);\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n }\n s3 = peg$parseend_inline_math();\n if (s3 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f23(s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n if (s0 === peg$FAILED) {\n s0 = peg$currPos;\n s1 = peg$parsemath_shift();\n if (s1 !== peg$FAILED) {\n s2 = peg$parsemath_shift();\n if (s2 !== peg$FAILED) {\n s3 = [];\n s4 = peg$currPos;\n s5 = peg$currPos;\n peg$silentFails++;\n s6 = peg$currPos;\n s7 = peg$parsemath_shift();\n if (s7 !== peg$FAILED) {\n s8 = peg$parsemath_shift();\n if (s8 !== peg$FAILED) {\n s7 = [s7, s8];\n s6 = s7;\n } else {\n peg$currPos = s6;\n s6 = peg$FAILED;\n }\n } else {\n peg$currPos = s6;\n s6 = peg$FAILED;\n }\n peg$silentFails--;\n if (s6 === peg$FAILED) {\n s5 = void 0;\n } else {\n peg$currPos = s5;\n s5 = peg$FAILED;\n }\n if (s5 !== peg$FAILED) {\n s6 = peg$parsemath_token();\n if (s6 !== peg$FAILED) {\n peg$savedPos = s4;\n s4 = peg$f24(s6);\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n while (s4 !== peg$FAILED) {\n s3.push(s4);\n s4 = peg$currPos;\n s5 = peg$currPos;\n peg$silentFails++;\n s6 = peg$currPos;\n s7 = peg$parsemath_shift();\n if (s7 !== peg$FAILED) {\n s8 = peg$parsemath_shift();\n if (s8 !== peg$FAILED) {\n s7 = [s7, s8];\n s6 = s7;\n } else {\n peg$currPos = s6;\n s6 = peg$FAILED;\n }\n } else {\n peg$currPos = s6;\n s6 = peg$FAILED;\n }\n peg$silentFails--;\n if (s6 === peg$FAILED) {\n s5 = void 0;\n } else {\n peg$currPos = s5;\n s5 = peg$FAILED;\n }\n if (s5 !== peg$FAILED) {\n s6 = peg$parsemath_token();\n if (s6 !== peg$FAILED) {\n peg$savedPos = s4;\n s4 = peg$f24(s6);\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n }\n s4 = peg$parsemath_shift();\n if (s4 !== peg$FAILED) {\n s5 = peg$parsemath_shift();\n if (s5 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f25(s3);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n if (s0 === peg$FAILED) {\n s0 = peg$parsemath_environment();\n if (s0 === peg$FAILED) {\n s0 = peg$parseenvironment();\n }\n }\n }\n }\n }\n }\n }\n }\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e11);\n }\n }\n peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };\n return s0;\n }\n function peg$parsesquare_bracket_argument() {\n var s0, s1, s2, s3, s4, s5, s6, s7;\n var key = peg$currPos * 52 + 9;\n var cached = peg$resultsCache[key];\n if (cached) {\n peg$currPos = cached.nextPos;\n return cached.result;\n }\n s0 = peg$currPos;\n if (input.charCodeAt(peg$currPos) === 91) {\n s1 = peg$c4;\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e14);\n }\n }\n if (s1 !== peg$FAILED) {\n s2 = [];\n s3 = peg$currPos;\n s4 = peg$currPos;\n peg$silentFails++;\n s5 = peg$currPos;\n s6 = peg$parsetoken();\n if (s6 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s7 = peg$f26(s6);\n if (s7) {\n s7 = void 0;\n } else {\n s7 = peg$FAILED;\n }\n if (s7 !== peg$FAILED) {\n s6 = [s6, s7];\n s5 = s6;\n } else {\n peg$currPos = s5;\n s5 = peg$FAILED;\n }\n } else {\n peg$currPos = s5;\n s5 = peg$FAILED;\n }\n peg$silentFails--;\n if (s5 === peg$FAILED) {\n s4 = void 0;\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n if (s4 !== peg$FAILED) {\n s5 = peg$parsetoken();\n if (s5 !== peg$FAILED) {\n peg$savedPos = s3;\n s3 = peg$f27(s5);\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n while (s3 !== peg$FAILED) {\n s2.push(s3);\n s3 = peg$currPos;\n s4 = peg$currPos;\n peg$silentFails++;\n s5 = peg$currPos;\n s6 = peg$parsetoken();\n if (s6 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s7 = peg$f26(s6);\n if (s7) {\n s7 = void 0;\n } else {\n s7 = peg$FAILED;\n }\n if (s7 !== peg$FAILED) {\n s6 = [s6, s7];\n s5 = s6;\n } else {\n peg$currPos = s5;\n s5 = peg$FAILED;\n }\n } else {\n peg$currPos = s5;\n s5 = peg$FAILED;\n }\n peg$silentFails--;\n if (s5 === peg$FAILED) {\n s4 = void 0;\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n if (s4 !== peg$FAILED) {\n s5 = peg$parsetoken();\n if (s5 !== peg$FAILED) {\n peg$savedPos = s3;\n s3 = peg$f27(s5);\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n }\n if (input.charCodeAt(peg$currPos) === 93) {\n s3 = peg$c5;\n peg$currPos++;\n } else {\n s3 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e15);\n }\n }\n if (s3 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f28(s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };\n return s0;\n }\n function peg$parseverbatim_group() {\n var s0, s1, s2, s3, s4, s5;\n var key = peg$currPos * 52 + 10;\n var cached = peg$resultsCache[key];\n if (cached) {\n peg$currPos = cached.nextPos;\n return cached.result;\n }\n s0 = peg$currPos;\n s1 = peg$parsebegin_group();\n if (s1 !== peg$FAILED) {\n s2 = [];\n s3 = peg$currPos;\n s4 = peg$currPos;\n peg$silentFails++;\n s5 = peg$parseend_group();\n peg$silentFails--;\n if (s5 === peg$FAILED) {\n s4 = void 0;\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n if (s4 !== peg$FAILED) {\n if (input.length > peg$currPos) {\n s5 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s5 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e3);\n }\n }\n if (s5 !== peg$FAILED) {\n peg$savedPos = s3;\n s3 = peg$f29(s5);\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n while (s3 !== peg$FAILED) {\n s2.push(s3);\n s3 = peg$currPos;\n s4 = peg$currPos;\n peg$silentFails++;\n s5 = peg$parseend_group();\n peg$silentFails--;\n if (s5 === peg$FAILED) {\n s4 = void 0;\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n if (s4 !== peg$FAILED) {\n if (input.length > peg$currPos) {\n s5 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s5 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e3);\n }\n }\n if (s5 !== peg$FAILED) {\n peg$savedPos = s3;\n s3 = peg$f29(s5);\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n }\n s3 = peg$parseend_group();\n if (s3 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f30(s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };\n return s0;\n }\n function peg$parseverbatim_delimited_by_char() {\n var s0, s1, s2, s3, s4, s5, s6, s7;\n var key = peg$currPos * 52 + 11;\n var cached = peg$resultsCache[key];\n if (cached) {\n peg$currPos = cached.nextPos;\n return cached.result;\n }\n s0 = peg$currPos;\n if (peg$r0.test(input.charAt(peg$currPos))) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e16);\n }\n }\n if (s1 !== peg$FAILED) {\n s2 = [];\n s3 = peg$currPos;\n s4 = peg$currPos;\n peg$silentFails++;\n s5 = peg$currPos;\n if (input.length > peg$currPos) {\n s6 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s6 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e3);\n }\n }\n if (s6 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s7 = peg$f31(s1, s6);\n if (s7) {\n s7 = void 0;\n } else {\n s7 = peg$FAILED;\n }\n if (s7 !== peg$FAILED) {\n s6 = [s6, s7];\n s5 = s6;\n } else {\n peg$currPos = s5;\n s5 = peg$FAILED;\n }\n } else {\n peg$currPos = s5;\n s5 = peg$FAILED;\n }\n peg$silentFails--;\n if (s5 === peg$FAILED) {\n s4 = void 0;\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n if (s4 !== peg$FAILED) {\n if (input.length > peg$currPos) {\n s5 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s5 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e3);\n }\n }\n if (s5 !== peg$FAILED) {\n peg$savedPos = s3;\n s3 = peg$f32(s1, s5);\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n while (s3 !== peg$FAILED) {\n s2.push(s3);\n s3 = peg$currPos;\n s4 = peg$currPos;\n peg$silentFails++;\n s5 = peg$currPos;\n if (input.length > peg$currPos) {\n s6 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s6 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e3);\n }\n }\n if (s6 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s7 = peg$f31(s1, s6);\n if (s7) {\n s7 = void 0;\n } else {\n s7 = peg$FAILED;\n }\n if (s7 !== peg$FAILED) {\n s6 = [s6, s7];\n s5 = s6;\n } else {\n peg$currPos = s5;\n s5 = peg$FAILED;\n }\n } else {\n peg$currPos = s5;\n s5 = peg$FAILED;\n }\n peg$silentFails--;\n if (s5 === peg$FAILED) {\n s4 = void 0;\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n if (s4 !== peg$FAILED) {\n if (input.length > peg$currPos) {\n s5 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s5 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e3);\n }\n }\n if (s5 !== peg$FAILED) {\n peg$savedPos = s3;\n s3 = peg$f32(s1, s5);\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n }\n s3 = peg$currPos;\n if (input.length > peg$currPos) {\n s4 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s4 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e3);\n }\n }\n if (s4 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s5 = peg$f33(s1, s2, s4);\n if (s5) {\n s5 = void 0;\n } else {\n s5 = peg$FAILED;\n }\n if (s5 !== peg$FAILED) {\n s4 = [s4, s5];\n s3 = s4;\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n if (s3 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f34(s1, s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };\n return s0;\n }\n function peg$parseverbatim_listings() {\n var s0, s1, s2, s3, s4;\n var key = peg$currPos * 52 + 12;\n var cached = peg$resultsCache[key];\n if (cached) {\n peg$currPos = cached.nextPos;\n return cached.result;\n }\n peg$silentFails++;\n s0 = peg$currPos;\n s1 = peg$parseescape();\n if (s1 !== peg$FAILED) {\n if (input.substr(peg$currPos, 9) === peg$c6) {\n s2 = peg$c6;\n peg$currPos += 9;\n } else {\n s2 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e18);\n }\n }\n if (s2 !== peg$FAILED) {\n s3 = peg$parsesquare_bracket_argument();\n if (s3 === peg$FAILED) {\n s3 = null;\n }\n s4 = peg$parseverbatim_group();\n if (s4 === peg$FAILED) {\n s4 = peg$parseverbatim_delimited_by_char();\n }\n if (s4 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f35(s2, s3, s4);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e17);\n }\n }\n peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };\n return s0;\n }\n function peg$parseverbatim_minted() {\n var s0, s1, s2, s3, s4, s5;\n var key = peg$currPos * 52 + 13;\n var cached = peg$resultsCache[key];\n if (cached) {\n peg$currPos = cached.nextPos;\n return cached.result;\n }\n peg$silentFails++;\n s0 = peg$currPos;\n s1 = peg$parseescape();\n if (s1 !== peg$FAILED) {\n if (input.substr(peg$currPos, 10) === peg$c7) {\n s2 = peg$c7;\n peg$currPos += 10;\n } else {\n s2 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e20);\n }\n }\n if (s2 === peg$FAILED) {\n if (input.substr(peg$currPos, 4) === peg$c8) {\n s2 = peg$c8;\n peg$currPos += 4;\n } else {\n s2 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e21);\n }\n }\n }\n if (s2 !== peg$FAILED) {\n s3 = peg$parsesquare_bracket_argument();\n if (s3 === peg$FAILED) {\n s3 = null;\n }\n s4 = peg$parsegroup();\n if (s4 !== peg$FAILED) {\n s5 = peg$parseverbatim_group();\n if (s5 === peg$FAILED) {\n s5 = peg$parseverbatim_delimited_by_char();\n }\n if (s5 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f36(s2, s3, s4, s5);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e19);\n }\n }\n peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };\n return s0;\n }\n function peg$parseverbatim_minted_environment() {\n var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14;\n var key = peg$currPos * 52 + 14;\n var cached = peg$resultsCache[key];\n if (cached) {\n peg$currPos = cached.nextPos;\n return cached.result;\n }\n peg$silentFails++;\n s0 = peg$currPos;\n s1 = peg$parsebegin_env();\n if (s1 !== peg$FAILED) {\n s2 = peg$parsebegin_group();\n if (s2 !== peg$FAILED) {\n if (input.substr(peg$currPos, 6) === peg$c9) {\n s3 = peg$c9;\n peg$currPos += 6;\n } else {\n s3 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e23);\n }\n }\n if (s3 !== peg$FAILED) {\n s4 = peg$parseend_group();\n if (s4 !== peg$FAILED) {\n s5 = peg$parsesquare_bracket_argument();\n if (s5 === peg$FAILED) {\n s5 = null;\n }\n s6 = peg$parsegroup();\n if (s6 !== peg$FAILED) {\n s7 = peg$currPos;\n s8 = [];\n s9 = peg$currPos;\n s10 = peg$currPos;\n peg$silentFails++;\n s11 = peg$currPos;\n s12 = peg$parseend_env();\n if (s12 !== peg$FAILED) {\n s13 = peg$parsegroup();\n if (s13 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s14 = peg$f37(s3, s5, s6, s13);\n if (s14) {\n s14 = void 0;\n } else {\n s14 = peg$FAILED;\n }\n if (s14 !== peg$FAILED) {\n s12 = [s12, s13, s14];\n s11 = s12;\n } else {\n peg$currPos = s11;\n s11 = peg$FAILED;\n }\n } else {\n peg$currPos = s11;\n s11 = peg$FAILED;\n }\n } else {\n peg$currPos = s11;\n s11 = peg$FAILED;\n }\n peg$silentFails--;\n if (s11 === peg$FAILED) {\n s10 = void 0;\n } else {\n peg$currPos = s10;\n s10 = peg$FAILED;\n }\n if (s10 !== peg$FAILED) {\n if (input.length > peg$currPos) {\n s11 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s11 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e3);\n }\n }\n if (s11 !== peg$FAILED) {\n s10 = [s10, s11];\n s9 = s10;\n } else {\n peg$currPos = s9;\n s9 = peg$FAILED;\n }\n } else {\n peg$currPos = s9;\n s9 = peg$FAILED;\n }\n while (s9 !== peg$FAILED) {\n s8.push(s9);\n s9 = peg$currPos;\n s10 = peg$currPos;\n peg$silentFails++;\n s11 = peg$currPos;\n s12 = peg$parseend_env();\n if (s12 !== peg$FAILED) {\n s13 = peg$parsegroup();\n if (s13 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s14 = peg$f37(s3, s5, s6, s13);\n if (s14) {\n s14 = void 0;\n } else {\n s14 = peg$FAILED;\n }\n if (s14 !== peg$FAILED) {\n s12 = [s12, s13, s14];\n s11 = s12;\n } else {\n peg$currPos = s11;\n s11 = peg$FAILED;\n }\n } else {\n peg$currPos = s11;\n s11 = peg$FAILED;\n }\n } else {\n peg$currPos = s11;\n s11 = peg$FAILED;\n }\n peg$silentFails--;\n if (s11 === peg$FAILED) {\n s10 = void 0;\n } else {\n peg$currPos = s10;\n s10 = peg$FAILED;\n }\n if (s10 !== peg$FAILED) {\n if (input.length > peg$currPos) {\n s11 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s11 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e3);\n }\n }\n if (s11 !== peg$FAILED) {\n s10 = [s10, s11];\n s9 = s10;\n } else {\n peg$currPos = s9;\n s9 = peg$FAILED;\n }\n } else {\n peg$currPos = s9;\n s9 = peg$FAILED;\n }\n }\n s7 = input.substring(s7, peg$currPos);\n s8 = peg$parseend_env();\n if (s8 !== peg$FAILED) {\n s9 = peg$parsebegin_group();\n if (s9 !== peg$FAILED) {\n if (input.substr(peg$currPos, 6) === peg$c9) {\n s10 = peg$c9;\n peg$currPos += 6;\n } else {\n s10 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e23);\n }\n }\n if (s10 !== peg$FAILED) {\n s11 = peg$parseend_group();\n if (s11 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f38(s3, s5, s6, s7);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e22);\n }\n }\n peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };\n return s0;\n }\n function peg$parseverbatim_environment() {\n var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12;\n var key = peg$currPos * 52 + 15;\n var cached = peg$resultsCache[key];\n if (cached) {\n peg$currPos = cached.nextPos;\n return cached.result;\n }\n peg$silentFails++;\n s0 = peg$currPos;\n s1 = peg$parsebegin_env();\n if (s1 !== peg$FAILED) {\n s2 = peg$parsebegin_group();\n if (s2 !== peg$FAILED) {\n s3 = peg$parseverbatim_env_name();\n if (s3 !== peg$FAILED) {\n s4 = peg$parseend_group();\n if (s4 !== peg$FAILED) {\n s5 = peg$currPos;\n s6 = [];\n s7 = peg$currPos;\n s8 = peg$currPos;\n peg$silentFails++;\n s9 = peg$currPos;\n s10 = peg$parseend_env();\n if (s10 !== peg$FAILED) {\n s11 = peg$parsegroup();\n if (s11 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s12 = peg$f39(s3, s11);\n if (s12) {\n s12 = void 0;\n } else {\n s12 = peg$FAILED;\n }\n if (s12 !== peg$FAILED) {\n s10 = [s10, s11, s12];\n s9 = s10;\n } else {\n peg$currPos = s9;\n s9 = peg$FAILED;\n }\n } else {\n peg$currPos = s9;\n s9 = peg$FAILED;\n }\n } else {\n peg$currPos = s9;\n s9 = peg$FAILED;\n }\n peg$silentFails--;\n if (s9 === peg$FAILED) {\n s8 = void 0;\n } else {\n peg$currPos = s8;\n s8 = peg$FAILED;\n }\n if (s8 !== peg$FAILED) {\n if (input.length > peg$currPos) {\n s9 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s9 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e3);\n }\n }\n if (s9 !== peg$FAILED) {\n peg$savedPos = s7;\n s7 = peg$f40(s3, s9);\n } else {\n peg$currPos = s7;\n s7 = peg$FAILED;\n }\n } else {\n peg$currPos = s7;\n s7 = peg$FAILED;\n }\n while (s7 !== peg$FAILED) {\n s6.push(s7);\n s7 = peg$currPos;\n s8 = peg$currPos;\n peg$silentFails++;\n s9 = peg$currPos;\n s10 = peg$parseend_env();\n if (s10 !== peg$FAILED) {\n s11 = peg$parsegroup();\n if (s11 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s12 = peg$f39(s3, s11);\n if (s12) {\n s12 = void 0;\n } else {\n s12 = peg$FAILED;\n }\n if (s12 !== peg$FAILED) {\n s10 = [s10, s11, s12];\n s9 = s10;\n } else {\n peg$currPos = s9;\n s9 = peg$FAILED;\n }\n } else {\n peg$currPos = s9;\n s9 = peg$FAILED;\n }\n } else {\n peg$currPos = s9;\n s9 = peg$FAILED;\n }\n peg$silentFails--;\n if (s9 === peg$FAILED) {\n s8 = void 0;\n } else {\n peg$currPos = s8;\n s8 = peg$FAILED;\n }\n if (s8 !== peg$FAILED) {\n if (input.length > peg$currPos) {\n s9 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s9 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e3);\n }\n }\n if (s9 !== peg$FAILED) {\n peg$savedPos = s7;\n s7 = peg$f40(s3, s9);\n } else {\n peg$currPos = s7;\n s7 = peg$FAILED;\n }\n } else {\n peg$currPos = s7;\n s7 = peg$FAILED;\n }\n }\n s5 = input.substring(s5, peg$currPos);\n s6 = peg$parseend_env();\n if (s6 !== peg$FAILED) {\n s7 = peg$parsebegin_group();\n if (s7 !== peg$FAILED) {\n s8 = peg$parseverbatim_env_name();\n if (s8 !== peg$FAILED) {\n s9 = peg$parseend_group();\n if (s9 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f41(s3, s5);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e24);\n }\n }\n peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };\n return s0;\n }\n function peg$parseverbatim_env_name() {\n var s0;\n var key = peg$currPos * 52 + 16;\n var cached = peg$resultsCache[key];\n if (cached) {\n peg$currPos = cached.nextPos;\n return cached.result;\n }\n if (input.substr(peg$currPos, 9) === peg$c10) {\n s0 = peg$c10;\n peg$currPos += 9;\n } else {\n s0 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e25);\n }\n }\n if (s0 === peg$FAILED) {\n if (input.substr(peg$currPos, 8) === peg$c11) {\n s0 = peg$c11;\n peg$currPos += 8;\n } else {\n s0 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e26);\n }\n }\n if (s0 === peg$FAILED) {\n if (input.substr(peg$currPos, 13) === peg$c12) {\n s0 = peg$c12;\n peg$currPos += 13;\n } else {\n s0 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e27);\n }\n }\n if (s0 === peg$FAILED) {\n if (input.substr(peg$currPos, 12) === peg$c13) {\n s0 = peg$c13;\n peg$currPos += 12;\n } else {\n s0 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e28);\n }\n }\n if (s0 === peg$FAILED) {\n if (input.substr(peg$currPos, 7) === peg$c14) {\n s0 = peg$c14;\n peg$currPos += 7;\n } else {\n s0 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e29);\n }\n }\n if (s0 === peg$FAILED) {\n if (input.substr(peg$currPos, 10) === peg$c15) {\n s0 = peg$c15;\n peg$currPos += 10;\n } else {\n s0 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e30);\n }\n }\n }\n }\n }\n }\n }\n peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };\n return s0;\n }\n function peg$parsemacro() {\n var s0, s1, s2, s3, s4;\n var key = peg$currPos * 52 + 17;\n var cached = peg$resultsCache[key];\n if (cached) {\n peg$currPos = cached.nextPos;\n return cached.result;\n }\n peg$silentFails++;\n s0 = peg$currPos;\n s1 = peg$currPos;\n s2 = peg$parseescape();\n if (s2 !== peg$FAILED) {\n s3 = [];\n s4 = peg$parsechar();\n if (s4 !== peg$FAILED) {\n while (s4 !== peg$FAILED) {\n s3.push(s4);\n s4 = peg$parsechar();\n }\n } else {\n s3 = peg$FAILED;\n }\n if (s3 !== peg$FAILED) {\n peg$savedPos = s1;\n s1 = peg$f42(s3);\n } else {\n peg$currPos = s1;\n s1 = peg$FAILED;\n }\n } else {\n peg$currPos = s1;\n s1 = peg$FAILED;\n }\n if (s1 === peg$FAILED) {\n s1 = peg$currPos;\n s2 = peg$parseescape();\n if (s2 !== peg$FAILED) {\n if (input.length > peg$currPos) {\n s3 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s3 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e3);\n }\n }\n if (s3 !== peg$FAILED) {\n peg$savedPos = s1;\n s1 = peg$f43(s3);\n } else {\n peg$currPos = s1;\n s1 = peg$FAILED;\n }\n } else {\n peg$currPos = s1;\n s1 = peg$FAILED;\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = s0;\n s1 = peg$f44(s1);\n }\n s0 = s1;\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e31);\n }\n }\n peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };\n return s0;\n }\n function peg$parsegroup() {\n var s0, s1, s2, s3, s4, s5;\n var key = peg$currPos * 52 + 18;\n var cached = peg$resultsCache[key];\n if (cached) {\n peg$currPos = cached.nextPos;\n return cached.result;\n }\n peg$silentFails++;\n s0 = peg$currPos;\n s1 = peg$parsebegin_group();\n if (s1 !== peg$FAILED) {\n s2 = [];\n s3 = peg$currPos;\n s4 = peg$currPos;\n peg$silentFails++;\n s5 = peg$parseend_group();\n peg$silentFails--;\n if (s5 === peg$FAILED) {\n s4 = void 0;\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n if (s4 !== peg$FAILED) {\n s5 = peg$parsetoken();\n if (s5 !== peg$FAILED) {\n peg$savedPos = s3;\n s3 = peg$f45(s5);\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n while (s3 !== peg$FAILED) {\n s2.push(s3);\n s3 = peg$currPos;\n s4 = peg$currPos;\n peg$silentFails++;\n s5 = peg$parseend_group();\n peg$silentFails--;\n if (s5 === peg$FAILED) {\n s4 = void 0;\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n if (s4 !== peg$FAILED) {\n s5 = peg$parsetoken();\n if (s5 !== peg$FAILED) {\n peg$savedPos = s3;\n s3 = peg$f45(s5);\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n }\n s3 = peg$parseend_group();\n if (s3 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f46(s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e32);\n }\n }\n peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };\n return s0;\n }\n function peg$parsegroup_contents_as_string() {\n var s0, s1;\n var key = peg$currPos * 52 + 19;\n var cached = peg$resultsCache[key];\n if (cached) {\n peg$currPos = cached.nextPos;\n return cached.result;\n }\n s0 = peg$currPos;\n s1 = peg$parsegroup();\n if (s1 !== peg$FAILED) {\n peg$savedPos = s0;\n s1 = peg$f47(s1);\n }\n s0 = s1;\n peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };\n return s0;\n }\n function peg$parseenvironment() {\n var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10;\n var key = peg$currPos * 52 + 20;\n var cached = peg$resultsCache[key];\n if (cached) {\n peg$currPos = cached.nextPos;\n return cached.result;\n }\n peg$silentFails++;\n s0 = peg$currPos;\n s1 = peg$parsebegin_env();\n if (s1 !== peg$FAILED) {\n s2 = peg$parsegroup_contents_as_string();\n if (s2 !== peg$FAILED) {\n s3 = peg$parsesameline_comment();\n if (s3 === peg$FAILED) {\n s3 = null;\n }\n s4 = [];\n s5 = peg$currPos;\n s6 = peg$currPos;\n peg$silentFails++;\n s7 = peg$currPos;\n s8 = peg$parseend_env();\n if (s8 !== peg$FAILED) {\n s9 = peg$parsegroup_contents_as_string();\n if (s9 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s10 = peg$f48(s2, s3, s9);\n if (s10) {\n s10 = void 0;\n } else {\n s10 = peg$FAILED;\n }\n if (s10 !== peg$FAILED) {\n s8 = [s8, s9, s10];\n s7 = s8;\n } else {\n peg$currPos = s7;\n s7 = peg$FAILED;\n }\n } else {\n peg$currPos = s7;\n s7 = peg$FAILED;\n }\n } else {\n peg$currPos = s7;\n s7 = peg$FAILED;\n }\n peg$silentFails--;\n if (s7 === peg$FAILED) {\n s6 = void 0;\n } else {\n peg$currPos = s6;\n s6 = peg$FAILED;\n }\n if (s6 !== peg$FAILED) {\n s7 = peg$parsetoken();\n if (s7 !== peg$FAILED) {\n peg$savedPos = s5;\n s5 = peg$f49(s2, s3, s7);\n } else {\n peg$currPos = s5;\n s5 = peg$FAILED;\n }\n } else {\n peg$currPos = s5;\n s5 = peg$FAILED;\n }\n while (s5 !== peg$FAILED) {\n s4.push(s5);\n s5 = peg$currPos;\n s6 = peg$currPos;\n peg$silentFails++;\n s7 = peg$currPos;\n s8 = peg$parseend_env();\n if (s8 !== peg$FAILED) {\n s9 = peg$parsegroup_contents_as_string();\n if (s9 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s10 = peg$f48(s2, s3, s9);\n if (s10) {\n s10 = void 0;\n } else {\n s10 = peg$FAILED;\n }\n if (s10 !== peg$FAILED) {\n s8 = [s8, s9, s10];\n s7 = s8;\n } else {\n peg$currPos = s7;\n s7 = peg$FAILED;\n }\n } else {\n peg$currPos = s7;\n s7 = peg$FAILED;\n }\n } else {\n peg$currPos = s7;\n s7 = peg$FAILED;\n }\n peg$silentFails--;\n if (s7 === peg$FAILED) {\n s6 = void 0;\n } else {\n peg$currPos = s6;\n s6 = peg$FAILED;\n }\n if (s6 !== peg$FAILED) {\n s7 = peg$parsetoken();\n if (s7 !== peg$FAILED) {\n peg$savedPos = s5;\n s5 = peg$f49(s2, s3, s7);\n } else {\n peg$currPos = s5;\n s5 = peg$FAILED;\n }\n } else {\n peg$currPos = s5;\n s5 = peg$FAILED;\n }\n }\n s5 = peg$parseend_env();\n if (s5 !== peg$FAILED) {\n s6 = peg$parsegroup_contents_as_string();\n if (s6 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f50(s2, s3, s4);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e33);\n }\n }\n peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };\n return s0;\n }\n function peg$parsemath_environment() {\n var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12;\n var key = peg$currPos * 52 + 21;\n var cached = peg$resultsCache[key];\n if (cached) {\n peg$currPos = cached.nextPos;\n return cached.result;\n }\n peg$silentFails++;\n s0 = peg$currPos;\n s1 = peg$parsebegin_env();\n if (s1 !== peg$FAILED) {\n s2 = peg$parsebegin_group();\n if (s2 !== peg$FAILED) {\n s3 = peg$parsemath_env_name();\n if (s3 !== peg$FAILED) {\n s4 = peg$parseend_group();\n if (s4 !== peg$FAILED) {\n s5 = peg$parsesameline_comment();\n if (s5 === peg$FAILED) {\n s5 = null;\n }\n s6 = [];\n s7 = peg$currPos;\n s8 = peg$currPos;\n peg$silentFails++;\n s9 = peg$currPos;\n s10 = peg$parseend_env();\n if (s10 !== peg$FAILED) {\n s11 = peg$parsegroup();\n if (s11 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s12 = peg$f51(s3, s5, s11);\n if (s12) {\n s12 = void 0;\n } else {\n s12 = peg$FAILED;\n }\n if (s12 !== peg$FAILED) {\n s10 = [s10, s11, s12];\n s9 = s10;\n } else {\n peg$currPos = s9;\n s9 = peg$FAILED;\n }\n } else {\n peg$currPos = s9;\n s9 = peg$FAILED;\n }\n } else {\n peg$currPos = s9;\n s9 = peg$FAILED;\n }\n peg$silentFails--;\n if (s9 === peg$FAILED) {\n s8 = void 0;\n } else {\n peg$currPos = s8;\n s8 = peg$FAILED;\n }\n if (s8 !== peg$FAILED) {\n s9 = peg$parsemath_token();\n if (s9 !== peg$FAILED) {\n peg$savedPos = s7;\n s7 = peg$f52(s3, s5, s9);\n } else {\n peg$currPos = s7;\n s7 = peg$FAILED;\n }\n } else {\n peg$currPos = s7;\n s7 = peg$FAILED;\n }\n while (s7 !== peg$FAILED) {\n s6.push(s7);\n s7 = peg$currPos;\n s8 = peg$currPos;\n peg$silentFails++;\n s9 = peg$currPos;\n s10 = peg$parseend_env();\n if (s10 !== peg$FAILED) {\n s11 = peg$parsegroup();\n if (s11 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s12 = peg$f51(s3, s5, s11);\n if (s12) {\n s12 = void 0;\n } else {\n s12 = peg$FAILED;\n }\n if (s12 !== peg$FAILED) {\n s10 = [s10, s11, s12];\n s9 = s10;\n } else {\n peg$currPos = s9;\n s9 = peg$FAILED;\n }\n } else {\n peg$currPos = s9;\n s9 = peg$FAILED;\n }\n } else {\n peg$currPos = s9;\n s9 = peg$FAILED;\n }\n peg$silentFails--;\n if (s9 === peg$FAILED) {\n s8 = void 0;\n } else {\n peg$currPos = s8;\n s8 = peg$FAILED;\n }\n if (s8 !== peg$FAILED) {\n s9 = peg$parsemath_token();\n if (s9 !== peg$FAILED) {\n peg$savedPos = s7;\n s7 = peg$f52(s3, s5, s9);\n } else {\n peg$currPos = s7;\n s7 = peg$FAILED;\n }\n } else {\n peg$currPos = s7;\n s7 = peg$FAILED;\n }\n }\n s7 = peg$parseend_env();\n if (s7 !== peg$FAILED) {\n s8 = peg$parsebegin_group();\n if (s8 !== peg$FAILED) {\n s9 = peg$parsemath_env_name();\n if (s9 !== peg$FAILED) {\n s10 = peg$parseend_group();\n if (s10 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f53(s3, s5, s6);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e34);\n }\n }\n peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };\n return s0;\n }\n function peg$parsemath_group() {\n var s0, s1, s2, s3, s4, s5;\n var key = peg$currPos * 52 + 22;\n var cached = peg$resultsCache[key];\n if (cached) {\n peg$currPos = cached.nextPos;\n return cached.result;\n }\n peg$silentFails++;\n s0 = peg$currPos;\n s1 = peg$parsebegin_group();\n if (s1 !== peg$FAILED) {\n s2 = [];\n s3 = peg$currPos;\n s4 = peg$currPos;\n peg$silentFails++;\n s5 = peg$parseend_group();\n peg$silentFails--;\n if (s5 === peg$FAILED) {\n s4 = void 0;\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n if (s4 !== peg$FAILED) {\n s5 = peg$parsemath_token();\n if (s5 !== peg$FAILED) {\n peg$savedPos = s3;\n s3 = peg$f54(s5);\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n while (s3 !== peg$FAILED) {\n s2.push(s3);\n s3 = peg$currPos;\n s4 = peg$currPos;\n peg$silentFails++;\n s5 = peg$parseend_group();\n peg$silentFails--;\n if (s5 === peg$FAILED) {\n s4 = void 0;\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n if (s4 !== peg$FAILED) {\n s5 = peg$parsemath_token();\n if (s5 !== peg$FAILED) {\n peg$savedPos = s3;\n s3 = peg$f54(s5);\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n }\n s3 = peg$parseend_group();\n if (s3 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f55(s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e35);\n }\n }\n peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };\n return s0;\n }\n function peg$parsebegin_display_math() {\n var s0, s1, s2;\n var key = peg$currPos * 52 + 23;\n var cached = peg$resultsCache[key];\n if (cached) {\n peg$currPos = cached.nextPos;\n return cached.result;\n }\n s0 = peg$currPos;\n s1 = peg$parseescape();\n if (s1 !== peg$FAILED) {\n if (input.charCodeAt(peg$currPos) === 91) {\n s2 = peg$c4;\n peg$currPos++;\n } else {\n s2 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e14);\n }\n }\n if (s2 !== peg$FAILED) {\n s1 = [s1, s2];\n s0 = s1;\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };\n return s0;\n }\n function peg$parseend_display_math() {\n var s0, s1, s2;\n var key = peg$currPos * 52 + 24;\n var cached = peg$resultsCache[key];\n if (cached) {\n peg$currPos = cached.nextPos;\n return cached.result;\n }\n s0 = peg$currPos;\n s1 = peg$parseescape();\n if (s1 !== peg$FAILED) {\n if (input.charCodeAt(peg$currPos) === 93) {\n s2 = peg$c5;\n peg$currPos++;\n } else {\n s2 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e15);\n }\n }\n if (s2 !== peg$FAILED) {\n s1 = [s1, s2];\n s0 = s1;\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };\n return s0;\n }\n function peg$parsebegin_inline_math() {\n var s0, s1, s2;\n var key = peg$currPos * 52 + 25;\n var cached = peg$resultsCache[key];\n if (cached) {\n peg$currPos = cached.nextPos;\n return cached.result;\n }\n s0 = peg$currPos;\n s1 = peg$parseescape();\n if (s1 !== peg$FAILED) {\n if (input.charCodeAt(peg$currPos) === 40) {\n s2 = peg$c16;\n peg$currPos++;\n } else {\n s2 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e36);\n }\n }\n if (s2 !== peg$FAILED) {\n s1 = [s1, s2];\n s0 = s1;\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };\n return s0;\n }\n function peg$parseend_inline_math() {\n var s0, s1, s2;\n var key = peg$currPos * 52 + 26;\n var cached = peg$resultsCache[key];\n if (cached) {\n peg$currPos = cached.nextPos;\n return cached.result;\n }\n s0 = peg$currPos;\n s1 = peg$parseescape();\n if (s1 !== peg$FAILED) {\n if (input.charCodeAt(peg$currPos) === 41) {\n s2 = peg$c17;\n peg$currPos++;\n } else {\n s2 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e37);\n }\n }\n if (s2 !== peg$FAILED) {\n s1 = [s1, s2];\n s0 = s1;\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };\n return s0;\n }\n function peg$parsebegin_env() {\n var s0, s1, s2;\n var key = peg$currPos * 52 + 27;\n var cached = peg$resultsCache[key];\n if (cached) {\n peg$currPos = cached.nextPos;\n return cached.result;\n }\n s0 = peg$currPos;\n s1 = peg$parseescape();\n if (s1 !== peg$FAILED) {\n if (input.substr(peg$currPos, 5) === peg$c18) {\n s2 = peg$c18;\n peg$currPos += 5;\n } else {\n s2 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e38);\n }\n }\n if (s2 !== peg$FAILED) {\n s1 = [s1, s2];\n s0 = s1;\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };\n return s0;\n }\n function peg$parseend_env() {\n var s0, s1, s2;\n var key = peg$currPos * 52 + 28;\n var cached = peg$resultsCache[key];\n if (cached) {\n peg$currPos = cached.nextPos;\n return cached.result;\n }\n s0 = peg$currPos;\n s1 = peg$parseescape();\n if (s1 !== peg$FAILED) {\n if (input.substr(peg$currPos, 3) === peg$c19) {\n s2 = peg$c19;\n peg$currPos += 3;\n } else {\n s2 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e39);\n }\n }\n if (s2 !== peg$FAILED) {\n s1 = [s1, s2];\n s0 = s1;\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };\n return s0;\n }\n function peg$parsemath_env_name() {\n var s0, s1;\n var key = peg$currPos * 52 + 29;\n var cached = peg$resultsCache[key];\n if (cached) {\n peg$currPos = cached.nextPos;\n return cached.result;\n }\n s0 = peg$currPos;\n if (input.substr(peg$currPos, 9) === peg$c20) {\n s1 = peg$c20;\n peg$currPos += 9;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e40);\n }\n }\n if (s1 === peg$FAILED) {\n if (input.substr(peg$currPos, 8) === peg$c21) {\n s1 = peg$c21;\n peg$currPos += 8;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e41);\n }\n }\n if (s1 === peg$FAILED) {\n if (input.substr(peg$currPos, 6) === peg$c22) {\n s1 = peg$c22;\n peg$currPos += 6;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e42);\n }\n }\n if (s1 === peg$FAILED) {\n if (input.substr(peg$currPos, 5) === peg$c23) {\n s1 = peg$c23;\n peg$currPos += 5;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e43);\n }\n }\n if (s1 === peg$FAILED) {\n if (input.substr(peg$currPos, 8) === peg$c24) {\n s1 = peg$c24;\n peg$currPos += 8;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e44);\n }\n }\n if (s1 === peg$FAILED) {\n if (input.substr(peg$currPos, 7) === peg$c25) {\n s1 = peg$c25;\n peg$currPos += 7;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e45);\n }\n }\n if (s1 === peg$FAILED) {\n if (input.substr(peg$currPos, 7) === peg$c26) {\n s1 = peg$c26;\n peg$currPos += 7;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e46);\n }\n }\n if (s1 === peg$FAILED) {\n if (input.substr(peg$currPos, 6) === peg$c27) {\n s1 = peg$c27;\n peg$currPos += 6;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e47);\n }\n }\n if (s1 === peg$FAILED) {\n if (input.substr(peg$currPos, 9) === peg$c28) {\n s1 = peg$c28;\n peg$currPos += 9;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e48);\n }\n }\n if (s1 === peg$FAILED) {\n if (input.substr(peg$currPos, 8) === peg$c29) {\n s1 = peg$c29;\n peg$currPos += 8;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e49);\n }\n }\n if (s1 === peg$FAILED) {\n if (input.substr(peg$currPos, 8) === peg$c30) {\n s1 = peg$c30;\n peg$currPos += 8;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e50);\n }\n }\n if (s1 === peg$FAILED) {\n if (input.substr(peg$currPos, 7) === peg$c31) {\n s1 = peg$c31;\n peg$currPos += 7;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e51);\n }\n }\n if (s1 === peg$FAILED) {\n if (input.substr(peg$currPos, 5) === peg$c32) {\n s1 = peg$c32;\n peg$currPos += 5;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e52);\n }\n }\n if (s1 === peg$FAILED) {\n if (input.substr(peg$currPos, 4) === peg$c33) {\n s1 = peg$c33;\n peg$currPos += 4;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e53);\n }\n }\n if (s1 === peg$FAILED) {\n if (input.substr(peg$currPos, 11) === peg$c34) {\n s1 = peg$c34;\n peg$currPos += 11;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e54);\n }\n }\n }\n }\n }\n }\n }\n }\n }\n }\n }\n }\n }\n }\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = s0;\n s1 = peg$f56(s1);\n }\n s0 = s1;\n peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };\n return s0;\n }\n function peg$parseescape() {\n var s0, s1;\n var key = peg$currPos * 52 + 30;\n var cached = peg$resultsCache[key];\n if (cached) {\n peg$currPos = cached.nextPos;\n return cached.result;\n }\n peg$silentFails++;\n s0 = peg$currPos;\n if (input.charCodeAt(peg$currPos) === 92) {\n s1 = peg$c35;\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e56);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = s0;\n s1 = peg$f57();\n }\n s0 = s1;\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e55);\n }\n }\n peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };\n return s0;\n }\n function peg$parsebegin_group() {\n var s0, s1;\n var key = peg$currPos * 52 + 31;\n var cached = peg$resultsCache[key];\n if (cached) {\n peg$currPos = cached.nextPos;\n return cached.result;\n }\n s0 = peg$currPos;\n if (input.charCodeAt(peg$currPos) === 123) {\n s1 = peg$c36;\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e57);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = s0;\n s1 = peg$f58(s1);\n }\n s0 = s1;\n peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };\n return s0;\n }\n function peg$parseend_group() {\n var s0, s1;\n var key = peg$currPos * 52 + 32;\n var cached = peg$resultsCache[key];\n if (cached) {\n peg$currPos = cached.nextPos;\n return cached.result;\n }\n s0 = peg$currPos;\n if (input.charCodeAt(peg$currPos) === 125) {\n s1 = peg$c37;\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e58);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = s0;\n s1 = peg$f59(s1);\n }\n s0 = s1;\n peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };\n return s0;\n }\n function peg$parsemath_shift() {\n var s0, s1;\n var key = peg$currPos * 52 + 33;\n var cached = peg$resultsCache[key];\n if (cached) {\n peg$currPos = cached.nextPos;\n return cached.result;\n }\n s0 = peg$currPos;\n if (input.charCodeAt(peg$currPos) === 36) {\n s1 = peg$c38;\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e59);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = s0;\n s1 = peg$f60(s1);\n }\n s0 = s1;\n peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };\n return s0;\n }\n function peg$parsealignment_tab() {\n var s0, s1;\n var key = peg$currPos * 52 + 34;\n var cached = peg$resultsCache[key];\n if (cached) {\n peg$currPos = cached.nextPos;\n return cached.result;\n }\n s0 = peg$currPos;\n if (input.charCodeAt(peg$currPos) === 38) {\n s1 = peg$c39;\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e60);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = s0;\n s1 = peg$f61(s1);\n }\n s0 = s1;\n peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };\n return s0;\n }\n function peg$parsenl() {\n var s0, s1, s2;\n var key = peg$currPos * 52 + 35;\n var cached = peg$resultsCache[key];\n if (cached) {\n peg$currPos = cached.nextPos;\n return cached.result;\n }\n peg$silentFails++;\n s0 = peg$currPos;\n s1 = peg$currPos;\n peg$silentFails++;\n if (input.charCodeAt(peg$currPos) === 13) {\n s2 = peg$c40;\n peg$currPos++;\n } else {\n s2 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e62);\n }\n }\n peg$silentFails--;\n if (s2 === peg$FAILED) {\n s1 = void 0;\n } else {\n peg$currPos = s1;\n s1 = peg$FAILED;\n }\n if (s1 !== peg$FAILED) {\n if (input.charCodeAt(peg$currPos) === 10) {\n s2 = peg$c41;\n peg$currPos++;\n } else {\n s2 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e63);\n }\n }\n if (s2 !== peg$FAILED) {\n s1 = [s1, s2];\n s0 = s1;\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n if (s0 === peg$FAILED) {\n if (input.charCodeAt(peg$currPos) === 13) {\n s0 = peg$c40;\n peg$currPos++;\n } else {\n s0 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e62);\n }\n }\n if (s0 === peg$FAILED) {\n if (input.substr(peg$currPos, 2) === peg$c42) {\n s0 = peg$c42;\n peg$currPos += 2;\n } else {\n s0 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e64);\n }\n }\n }\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e61);\n }\n }\n peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };\n return s0;\n }\n function peg$parsemacro_parameter() {\n var s0, s1;\n var key = peg$currPos * 52 + 36;\n var cached = peg$resultsCache[key];\n if (cached) {\n peg$currPos = cached.nextPos;\n return cached.result;\n }\n s0 = peg$currPos;\n if (input.charCodeAt(peg$currPos) === 35) {\n s1 = peg$c43;\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e65);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = s0;\n s1 = peg$f62(s1);\n }\n s0 = s1;\n peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };\n return s0;\n }\n function peg$parsesuperscript() {\n var s0, s1;\n var key = peg$currPos * 52 + 37;\n var cached = peg$resultsCache[key];\n if (cached) {\n peg$currPos = cached.nextPos;\n return cached.result;\n }\n s0 = peg$currPos;\n if (input.charCodeAt(peg$currPos) === 94) {\n s1 = peg$c44;\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e66);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = s0;\n s1 = peg$f63(s1);\n }\n s0 = s1;\n peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };\n return s0;\n }\n function peg$parsesubscript() {\n var s0, s1;\n var key = peg$currPos * 52 + 38;\n var cached = peg$resultsCache[key];\n if (cached) {\n peg$currPos = cached.nextPos;\n return cached.result;\n }\n s0 = peg$currPos;\n if (input.charCodeAt(peg$currPos) === 95) {\n s1 = peg$c45;\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e67);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = s0;\n s1 = peg$f64(s1);\n }\n s0 = s1;\n peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };\n return s0;\n }\n function peg$parseignore() {\n var s0;\n var key = peg$currPos * 52 + 39;\n var cached = peg$resultsCache[key];\n if (cached) {\n peg$currPos = cached.nextPos;\n return cached.result;\n }\n if (input.charCodeAt(peg$currPos) === 0) {\n s0 = peg$c46;\n peg$currPos++;\n } else {\n s0 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e68);\n }\n }\n peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };\n return s0;\n }\n function peg$parsesp() {\n var s0, s1, s2;\n var key = peg$currPos * 52 + 40;\n var cached = peg$resultsCache[key];\n if (cached) {\n peg$currPos = cached.nextPos;\n return cached.result;\n }\n peg$silentFails++;\n s0 = peg$currPos;\n s1 = [];\n if (peg$r1.test(input.charAt(peg$currPos))) {\n s2 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s2 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e69);\n }\n }\n if (s2 !== peg$FAILED) {\n while (s2 !== peg$FAILED) {\n s1.push(s2);\n if (peg$r1.test(input.charAt(peg$currPos))) {\n s2 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s2 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e69);\n }\n }\n }\n } else {\n s1 = peg$FAILED;\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = s0;\n s1 = peg$f65();\n }\n s0 = s1;\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e8);\n }\n }\n peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };\n return s0;\n }\n function peg$parsechar() {\n var s0, s1;\n var key = peg$currPos * 52 + 41;\n var cached = peg$resultsCache[key];\n if (cached) {\n peg$currPos = cached.nextPos;\n return cached.result;\n }\n peg$silentFails++;\n if (peg$r2.test(input.charAt(peg$currPos))) {\n s0 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s0 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e71);\n }\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e70);\n }\n }\n peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };\n return s0;\n }\n function peg$parsenum() {\n var s0, s1;\n var key = peg$currPos * 52 + 42;\n var cached = peg$resultsCache[key];\n if (cached) {\n peg$currPos = cached.nextPos;\n return cached.result;\n }\n peg$silentFails++;\n if (peg$r3.test(input.charAt(peg$currPos))) {\n s0 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s0 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e73);\n }\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e72);\n }\n }\n peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };\n return s0;\n }\n function peg$parsepunctuation() {\n var s0, s1;\n var key = peg$currPos * 52 + 43;\n var cached = peg$resultsCache[key];\n if (cached) {\n peg$currPos = cached.nextPos;\n return cached.result;\n }\n peg$silentFails++;\n s0 = peg$currPos;\n if (peg$r4.test(input.charAt(peg$currPos))) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e75);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = s0;\n s1 = peg$f66(s1);\n }\n s0 = s1;\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e74);\n }\n }\n peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };\n return s0;\n }\n function peg$parsecomment_start() {\n var s0;\n var key = peg$currPos * 52 + 44;\n var cached = peg$resultsCache[key];\n if (cached) {\n peg$currPos = cached.nextPos;\n return cached.result;\n }\n if (input.charCodeAt(peg$currPos) === 37) {\n s0 = peg$c0;\n peg$currPos++;\n } else {\n s0 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e7);\n }\n }\n peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };\n return s0;\n }\n function peg$parsefull_comment() {\n var s0, s1;\n var key = peg$currPos * 52 + 45;\n var cached = peg$resultsCache[key];\n if (cached) {\n peg$currPos = cached.nextPos;\n return cached.result;\n }\n peg$silentFails++;\n s0 = peg$parseownline_comment();\n if (s0 === peg$FAILED) {\n s0 = peg$parsesameline_comment();\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e76);\n }\n }\n peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };\n return s0;\n }\n function peg$parseownline_comment() {\n var s0, s1, s2, s3;\n var key = peg$currPos * 52 + 46;\n var cached = peg$resultsCache[key];\n if (cached) {\n peg$currPos = cached.nextPos;\n return cached.result;\n }\n s0 = peg$currPos;\n s1 = peg$currPos;\n s2 = [];\n s3 = peg$parsesp();\n while (s3 !== peg$FAILED) {\n s2.push(s3);\n s3 = peg$parsesp();\n }\n s3 = peg$parsenl();\n if (s3 !== peg$FAILED) {\n s2 = [s2, s3];\n s1 = s2;\n } else {\n peg$currPos = s1;\n s1 = peg$FAILED;\n }\n if (s1 === peg$FAILED) {\n s1 = null;\n }\n s2 = peg$parseleading_sp();\n if (s2 !== peg$FAILED) {\n s3 = peg$parsecomment();\n if (s3 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f67(s2, s3);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };\n return s0;\n }\n function peg$parsesameline_comment() {\n var s0, s1, s2;\n var key = peg$currPos * 52 + 47;\n var cached = peg$resultsCache[key];\n if (cached) {\n peg$currPos = cached.nextPos;\n return cached.result;\n }\n s0 = peg$currPos;\n s1 = [];\n s2 = peg$parsesp();\n while (s2 !== peg$FAILED) {\n s1.push(s2);\n s2 = peg$parsesp();\n }\n s2 = peg$parsecomment();\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f68(s1, s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };\n return s0;\n }\n function peg$parsecomment() {\n var s0, s1, s2, s3, s4, s5, s6, s7;\n var key = peg$currPos * 52 + 48;\n var cached = peg$resultsCache[key];\n if (cached) {\n peg$currPos = cached.nextPos;\n return cached.result;\n }\n peg$silentFails++;\n s0 = peg$currPos;\n s1 = peg$parsecomment_start();\n if (s1 !== peg$FAILED) {\n s2 = [];\n s3 = peg$currPos;\n s4 = peg$currPos;\n peg$silentFails++;\n s5 = peg$parsenl();\n peg$silentFails--;\n if (s5 === peg$FAILED) {\n s4 = void 0;\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n if (s4 !== peg$FAILED) {\n if (input.length > peg$currPos) {\n s5 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s5 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e3);\n }\n }\n if (s5 !== peg$FAILED) {\n peg$savedPos = s3;\n s3 = peg$f69(s5);\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n while (s3 !== peg$FAILED) {\n s2.push(s3);\n s3 = peg$currPos;\n s4 = peg$currPos;\n peg$silentFails++;\n s5 = peg$parsenl();\n peg$silentFails--;\n if (s5 === peg$FAILED) {\n s4 = void 0;\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n if (s4 !== peg$FAILED) {\n if (input.length > peg$currPos) {\n s5 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s5 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e3);\n }\n }\n if (s5 !== peg$FAILED) {\n peg$savedPos = s3;\n s3 = peg$f69(s5);\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n }\n s3 = peg$currPos;\n peg$silentFails++;\n s4 = peg$parseparbreak();\n peg$silentFails--;\n if (s4 !== peg$FAILED) {\n peg$currPos = s3;\n s3 = void 0;\n } else {\n s3 = peg$FAILED;\n }\n if (s3 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f70(s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n if (s0 === peg$FAILED) {\n s0 = peg$currPos;\n s1 = peg$parsecomment_start();\n if (s1 !== peg$FAILED) {\n s2 = [];\n s3 = peg$currPos;\n s4 = peg$currPos;\n peg$silentFails++;\n s5 = peg$parsenl();\n peg$silentFails--;\n if (s5 === peg$FAILED) {\n s4 = void 0;\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n if (s4 !== peg$FAILED) {\n if (input.length > peg$currPos) {\n s5 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s5 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e3);\n }\n }\n if (s5 !== peg$FAILED) {\n peg$savedPos = s3;\n s3 = peg$f71(s5);\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n while (s3 !== peg$FAILED) {\n s2.push(s3);\n s3 = peg$currPos;\n s4 = peg$currPos;\n peg$silentFails++;\n s5 = peg$parsenl();\n peg$silentFails--;\n if (s5 === peg$FAILED) {\n s4 = void 0;\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n if (s4 !== peg$FAILED) {\n if (input.length > peg$currPos) {\n s5 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s5 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e3);\n }\n }\n if (s5 !== peg$FAILED) {\n peg$savedPos = s3;\n s3 = peg$f71(s5);\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n }\n s3 = peg$currPos;\n s4 = peg$parsenl();\n if (s4 !== peg$FAILED) {\n s5 = [];\n s6 = peg$parsesp();\n while (s6 !== peg$FAILED) {\n s5.push(s6);\n s6 = peg$parsesp();\n }\n s6 = peg$currPos;\n peg$silentFails++;\n s7 = peg$parsecomment_start();\n peg$silentFails--;\n if (s7 === peg$FAILED) {\n s6 = void 0;\n } else {\n peg$currPos = s6;\n s6 = peg$FAILED;\n }\n if (s6 !== peg$FAILED) {\n s4 = [s4, s5, s6];\n s3 = s4;\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n if (s3 === peg$FAILED) {\n s3 = peg$parsenl();\n if (s3 === peg$FAILED) {\n s3 = peg$parseEOF();\n }\n }\n if (s3 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f72(s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e77);\n }\n }\n peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };\n return s0;\n }\n function peg$parseleading_sp() {\n var s0, s1, s2, s3, s4;\n var key = peg$currPos * 52 + 49;\n var cached = peg$resultsCache[key];\n if (cached) {\n peg$currPos = cached.nextPos;\n return cached.result;\n }\n s0 = peg$currPos;\n s1 = peg$currPos;\n s2 = peg$parsestart_of_line();\n if (s2 !== peg$FAILED) {\n s3 = [];\n s4 = peg$parsesp();\n while (s4 !== peg$FAILED) {\n s3.push(s4);\n s4 = peg$parsesp();\n }\n s2 = [s2, s3];\n s1 = s2;\n } else {\n peg$currPos = s1;\n s1 = peg$FAILED;\n }\n if (s1 !== peg$FAILED) {\n s0 = input.substring(s0, peg$currPos);\n } else {\n s0 = s1;\n }\n peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };\n return s0;\n }\n function peg$parsestart_of_line() {\n var s0;\n var key = peg$currPos * 52 + 50;\n var cached = peg$resultsCache[key];\n if (cached) {\n peg$currPos = cached.nextPos;\n return cached.result;\n }\n peg$savedPos = peg$currPos;\n s0 = peg$f73();\n if (s0) {\n s0 = void 0;\n } else {\n s0 = peg$FAILED;\n }\n peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };\n return s0;\n }\n function peg$parseEOF() {\n var s0, s1;\n var key = peg$currPos * 52 + 51;\n var cached = peg$resultsCache[key];\n if (cached) {\n peg$currPos = cached.nextPos;\n return cached.result;\n }\n s0 = peg$currPos;\n peg$silentFails++;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e3);\n }\n }\n peg$silentFails--;\n if (s1 === peg$FAILED) {\n s0 = void 0;\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };\n return s0;\n }\n function toString(e) {\n if (typeof e === \"string\") {\n return e;\n }\n if (typeof e.content === \"string\") {\n return e.content;\n }\n if (e && e.type === \"whitespace\") {\n return \" \";\n }\n return e;\n }\n function compare_env(g1, g2) {\n const g1Name = typeof g1 === \"string\" ? g1 : g1.content.map(toString).join(\"\");\n const g2Name = typeof g2 === \"string\" ? g2 : g2.content.map(toString).join(\"\");\n return g1Name === g2Name;\n }\n function createNode(type, extra = {}) {\n return { type, ...extra, position: location() };\n }\n peg$result = peg$startRuleFunction();\n if (peg$result !== peg$FAILED && peg$currPos === input.length) {\n return peg$result;\n } else {\n if (peg$result !== peg$FAILED && peg$currPos < input.length) {\n peg$fail(peg$endExpectation());\n }\n throw peg$buildStructuredError(\n peg$maxFailExpected,\n peg$maxFailPos < input.length ? input.charAt(peg$maxFailPos) : null,\n peg$maxFailPos < input.length ? peg$computeLocation(peg$maxFailPos, peg$maxFailPos + 1) : peg$computeLocation(peg$maxFailPos, peg$maxFailPos)\n );\n }\n }\n return {\n SyntaxError: peg$SyntaxError,\n parse: peg$parse\n };\n }()\n);\n","export default (\n // Generated by Peggy 3.0.2.\n //\n // https://peggyjs.org/\n function() {\n \"use strict\";\n function peg$subclass(child, parent) {\n function C() {\n this.constructor = child;\n }\n C.prototype = parent.prototype;\n child.prototype = new C();\n }\n function peg$SyntaxError(message, expected, found, location) {\n var self = Error.call(this, message);\n if (Object.setPrototypeOf) {\n Object.setPrototypeOf(self, peg$SyntaxError.prototype);\n }\n self.expected = expected;\n self.found = found;\n self.location = location;\n self.name = \"SyntaxError\";\n return self;\n }\n peg$subclass(peg$SyntaxError, Error);\n function peg$padEnd(str, targetLength, padString) {\n padString = padString || \" \";\n if (str.length > targetLength) {\n return str;\n }\n targetLength -= str.length;\n padString += padString.repeat(targetLength);\n return str + padString.slice(0, targetLength);\n }\n peg$SyntaxError.prototype.format = function(sources) {\n var str = \"Error: \" + this.message;\n if (this.location) {\n var src = null;\n var k;\n for (k = 0; k < sources.length; k++) {\n if (sources[k].source === this.location.source) {\n src = sources[k].text.split(/\\r\\n|\\n|\\r/g);\n break;\n }\n }\n var s = this.location.start;\n var offset_s = this.location.source && typeof this.location.source.offset === \"function\" ? this.location.source.offset(s) : s;\n var loc = this.location.source + \":\" + offset_s.line + \":\" + offset_s.column;\n if (src) {\n var e = this.location.end;\n var filler = peg$padEnd(\"\", offset_s.line.toString().length, \" \");\n var line = src[s.line - 1];\n var last = s.line === e.line ? e.column : line.length + 1;\n var hatLen = last - s.column || 1;\n str += \"\\n --> \" + loc + \"\\n\" + filler + \" |\\n\" + offset_s.line + \" | \" + line + \"\\n\" + filler + \" | \" + peg$padEnd(\"\", s.column - 1, \" \") + peg$padEnd(\"\", hatLen, \"^\");\n } else {\n str += \"\\n at \" + loc;\n }\n }\n return str;\n };\n peg$SyntaxError.buildMessage = function(expected, found) {\n var DESCRIBE_EXPECTATION_FNS = {\n literal: function(expectation) {\n return '\"' + literalEscape(expectation.text) + '\"';\n },\n class: function(expectation) {\n var escapedParts = expectation.parts.map(function(part) {\n return Array.isArray(part) ? classEscape(part[0]) + \"-\" + classEscape(part[1]) : classEscape(part);\n });\n return \"[\" + (expectation.inverted ? \"^\" : \"\") + escapedParts.join(\"\") + \"]\";\n },\n any: function() {\n return \"any character\";\n },\n end: function() {\n return \"end of input\";\n },\n other: function(expectation) {\n return expectation.description;\n }\n };\n function hex(ch) {\n return ch.charCodeAt(0).toString(16).toUpperCase();\n }\n function literalEscape(s) {\n return s.replace(/\\\\/g, \"\\\\\\\\\").replace(/\"/g, '\\\\\"').replace(/\\0/g, \"\\\\0\").replace(/\\t/g, \"\\\\t\").replace(/\\n/g, \"\\\\n\").replace(/\\r/g, \"\\\\r\").replace(/[\\x00-\\x0F]/g, function(ch) {\n return \"\\\\x0\" + hex(ch);\n }).replace(/[\\x10-\\x1F\\x7F-\\x9F]/g, function(ch) {\n return \"\\\\x\" + hex(ch);\n });\n }\n function classEscape(s) {\n return s.replace(/\\\\/g, \"\\\\\\\\\").replace(/\\]/g, \"\\\\]\").replace(/\\^/g, \"\\\\^\").replace(/-/g, \"\\\\-\").replace(/\\0/g, \"\\\\0\").replace(/\\t/g, \"\\\\t\").replace(/\\n/g, \"\\\\n\").replace(/\\r/g, \"\\\\r\").replace(/[\\x00-\\x0F]/g, function(ch) {\n return \"\\\\x0\" + hex(ch);\n }).replace(/[\\x10-\\x1F\\x7F-\\x9F]/g, function(ch) {\n return \"\\\\x\" + hex(ch);\n });\n }\n function describeExpectation(expectation) {\n return DESCRIBE_EXPECTATION_FNS[expectation.type](expectation);\n }\n function describeExpected(expected2) {\n var descriptions = expected2.map(describeExpectation);\n var i, j;\n descriptions.sort();\n if (descriptions.length > 0) {\n for (i = 1, j = 1; i < descriptions.length; i++) {\n if (descriptions[i - 1] !== descriptions[i]) {\n descriptions[j] = descriptions[i];\n j++;\n }\n }\n descriptions.length = j;\n }\n switch (descriptions.length) {\n case 1:\n return descriptions[0];\n case 2:\n return descriptions[0] + \" or \" + descriptions[1];\n default:\n return descriptions.slice(0, -1).join(\", \") + \", or \" + descriptions[descriptions.length - 1];\n }\n }\n function describeFound(found2) {\n return found2 ? '\"' + literalEscape(found2) + '\"' : \"end of input\";\n }\n return \"Expected \" + describeExpected(expected) + \" but \" + describeFound(found) + \" found.\";\n };\n function peg$parse(input, options) {\n options = options !== void 0 ? options : {};\n var peg$FAILED = {};\n var peg$source = options.grammarSource;\n var peg$startRuleFunctions = { body: peg$parsebody };\n var peg$startRuleFunction = peg$parsebody;\n var peg$e0 = peg$anyExpectation();\n var peg$f0 = function() {\n return [];\n };\n var peg$f1 = function(x) {\n return { cells: [], colSeps: [], ...x };\n };\n var peg$f2 = function(rowItems, rowSep, trailingComment) {\n return { ...rowItems, rowSep, trailingComment };\n };\n var peg$f3 = function(rowItems, trailingComment) {\n return { ...rowItems, rowSep: null, trailingComment };\n };\n var peg$f4 = function(x) {\n return x;\n };\n var peg$f5 = function(x) {\n return {\n cells: [],\n colSeps: [],\n rowSep: null,\n trailingComment: x\n };\n };\n var peg$f6 = function(x) {\n return x;\n };\n var peg$f7 = function(colSep, cell) {\n return { colSep, cell };\n };\n var peg$f8 = function(colSep) {\n return { colSep };\n };\n var peg$f9 = function(a, b) {\n return processRow(a, b);\n };\n var peg$f10 = function(b) {\n return processRow(null, b);\n };\n var peg$f11 = function(tok) {\n return options.isSameLineComment(tok);\n };\n var peg$f12 = function(tok) {\n return tok;\n };\n var peg$f13 = function(tok) {\n return options.isOwnLineComment(tok);\n };\n var peg$f14 = function(tok) {\n return tok;\n };\n var peg$f15 = function(tok) {\n return options.isWhitespace(tok);\n };\n var peg$f16 = function(tok) {\n return tok;\n };\n var peg$f17 = function(tok) {\n return options.isRowSep(tok);\n };\n var peg$f18 = function(tok) {\n return tok;\n };\n var peg$f19 = function(tok) {\n return options.isColSep(tok);\n };\n var peg$f20 = function(tok) {\n return tok;\n };\n var peg$currPos = 0;\n var peg$savedPos = 0;\n var peg$posDetailsCache = [{ line: 1, column: 1 }];\n var peg$maxFailPos = 0;\n var peg$maxFailExpected = [];\n var peg$silentFails = 0;\n var peg$result;\n if (\"startRule\" in options) {\n if (!(options.startRule in peg$startRuleFunctions)) {\n throw new Error(`Can't start parsing from rule \"` + options.startRule + '\".');\n }\n peg$startRuleFunction = peg$startRuleFunctions[options.startRule];\n }\n function text() {\n return input.substring(peg$savedPos, peg$currPos);\n }\n function offset() {\n return peg$savedPos;\n }\n function range() {\n return {\n source: peg$source,\n start: peg$savedPos,\n end: peg$currPos\n };\n }\n function location() {\n return peg$computeLocation(peg$savedPos, peg$currPos);\n }\n function expected(description, location2) {\n location2 = location2 !== void 0 ? location2 : peg$computeLocation(peg$savedPos, peg$currPos);\n throw peg$buildStructuredError(\n [peg$otherExpectation(description)],\n input.substring(peg$savedPos, peg$currPos),\n location2\n );\n }\n function error(message, location2) {\n location2 = location2 !== void 0 ? location2 : peg$computeLocation(peg$savedPos, peg$currPos);\n throw peg$buildSimpleError(message, location2);\n }\n function peg$literalExpectation(text2, ignoreCase) {\n return { type: \"literal\", text: text2, ignoreCase };\n }\n function peg$classExpectation(parts, inverted, ignoreCase) {\n return { type: \"class\", parts, inverted, ignoreCase };\n }\n function peg$anyExpectation() {\n return { type: \"any\" };\n }\n function peg$endExpectation() {\n return { type: \"end\" };\n }\n function peg$otherExpectation(description) {\n return { type: \"other\", description };\n }\n function peg$computePosDetails(pos) {\n var details = peg$posDetailsCache[pos];\n var p;\n if (details) {\n return details;\n } else {\n p = pos - 1;\n while (!peg$posDetailsCache[p]) {\n p--;\n }\n details = peg$posDetailsCache[p];\n details = {\n line: details.line,\n column: details.column\n };\n while (p < pos) {\n if (input.charCodeAt(p) === 10) {\n details.line++;\n details.column = 1;\n } else {\n details.column++;\n }\n p++;\n }\n peg$posDetailsCache[pos] = details;\n return details;\n }\n }\n function peg$computeLocation(startPos, endPos, offset2) {\n var startPosDetails = peg$computePosDetails(startPos);\n var endPosDetails = peg$computePosDetails(endPos);\n var res = {\n source: peg$source,\n start: {\n offset: startPos,\n line: startPosDetails.line,\n column: startPosDetails.column\n },\n end: {\n offset: endPos,\n line: endPosDetails.line,\n column: endPosDetails.column\n }\n };\n if (offset2 && peg$source && typeof peg$source.offset === \"function\") {\n res.start = peg$source.offset(res.start);\n res.end = peg$source.offset(res.end);\n }\n return res;\n }\n function peg$fail(expected2) {\n if (peg$currPos < peg$maxFailPos) {\n return;\n }\n if (peg$currPos > peg$maxFailPos) {\n peg$maxFailPos = peg$currPos;\n peg$maxFailExpected = [];\n }\n peg$maxFailExpected.push(expected2);\n }\n function peg$buildSimpleError(message, location2) {\n return new peg$SyntaxError(message, null, null, location2);\n }\n function peg$buildStructuredError(expected2, found, location2) {\n return new peg$SyntaxError(\n peg$SyntaxError.buildMessage(expected2, found),\n expected2,\n found,\n location2\n );\n }\n function peg$parsebody() {\n var s0, s1;\n s0 = [];\n s1 = peg$parsecomment_only_line();\n if (s1 === peg$FAILED) {\n s1 = peg$parserow_with_end();\n if (s1 === peg$FAILED) {\n s1 = peg$parserow_without_end();\n }\n }\n if (s1 !== peg$FAILED) {\n while (s1 !== peg$FAILED) {\n s0.push(s1);\n s1 = peg$parsecomment_only_line();\n if (s1 === peg$FAILED) {\n s1 = peg$parserow_with_end();\n if (s1 === peg$FAILED) {\n s1 = peg$parserow_without_end();\n }\n }\n }\n } else {\n s0 = peg$FAILED;\n }\n if (s0 === peg$FAILED) {\n s0 = peg$currPos;\n s1 = peg$parseEOL();\n if (s1 !== peg$FAILED) {\n peg$savedPos = s0;\n s1 = peg$f0();\n }\n s0 = s1;\n }\n return s0;\n }\n function peg$parserow_with_end() {\n var s0, s1, s2, s3;\n s0 = peg$currPos;\n s1 = peg$currPos;\n s2 = peg$parserow_items();\n if (s2 === peg$FAILED) {\n s2 = null;\n }\n peg$savedPos = s1;\n s2 = peg$f1(s2);\n s1 = s2;\n s2 = peg$parserow_sep();\n if (s2 !== peg$FAILED) {\n s3 = peg$parsetrailing_comment();\n if (s3 === peg$FAILED) {\n s3 = null;\n }\n peg$savedPos = s0;\n s0 = peg$f2(s1, s2, s3);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parserow_without_end() {\n var s0, s1, s2;\n s0 = peg$currPos;\n s1 = peg$parserow_items();\n if (s1 !== peg$FAILED) {\n s2 = peg$parsetrailing_comment();\n if (s2 === peg$FAILED) {\n s2 = null;\n }\n peg$savedPos = s0;\n s0 = peg$f3(s1, s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parsetrailing_comment() {\n var s0, s1, s2;\n s0 = peg$currPos;\n s1 = [];\n s2 = peg$parsewhitespace();\n while (s2 !== peg$FAILED) {\n s1.push(s2);\n s2 = peg$parsewhitespace();\n }\n s2 = peg$parsesame_line_comment();\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f4(s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parsecomment_only_line() {\n var s0, s1, s2;\n s0 = peg$currPos;\n s1 = [];\n s2 = peg$parsewhitespace();\n while (s2 !== peg$FAILED) {\n s1.push(s2);\n s2 = peg$parsewhitespace();\n }\n s2 = peg$parseown_line_comment();\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f5(s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parsetoken() {\n var s0, s1, s2;\n s0 = peg$currPos;\n s1 = peg$currPos;\n peg$silentFails++;\n s2 = peg$parserow_sep();\n if (s2 === peg$FAILED) {\n s2 = peg$parsecol_sep();\n if (s2 === peg$FAILED) {\n s2 = peg$parsetrailing_comment();\n if (s2 === peg$FAILED) {\n s2 = peg$parseown_line_comment();\n }\n }\n }\n peg$silentFails--;\n if (s2 === peg$FAILED) {\n s1 = void 0;\n } else {\n peg$currPos = s1;\n s1 = peg$FAILED;\n }\n if (s1 !== peg$FAILED) {\n if (input.length > peg$currPos) {\n s2 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s2 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f6(s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parsecell() {\n var s0, s1, s2;\n s0 = peg$currPos;\n s1 = [];\n s2 = peg$parsetoken();\n if (s2 !== peg$FAILED) {\n while (s2 !== peg$FAILED) {\n s1.push(s2);\n s2 = peg$parsetoken();\n }\n } else {\n s1 = peg$FAILED;\n }\n if (s1 !== peg$FAILED) {\n s0 = input.substring(s0, peg$currPos);\n } else {\n s0 = s1;\n }\n return s0;\n }\n function peg$parseseparated_cell() {\n var s0, s1, s2;\n s0 = peg$currPos;\n s1 = peg$parsecol_sep();\n if (s1 !== peg$FAILED) {\n s2 = peg$parsecell();\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f7(s1, s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n if (s0 === peg$FAILED) {\n s0 = peg$currPos;\n s1 = peg$parsecol_sep();\n if (s1 !== peg$FAILED) {\n peg$savedPos = s0;\n s1 = peg$f8(s1);\n }\n s0 = s1;\n }\n return s0;\n }\n function peg$parserow_items() {\n var s0, s1, s2, s3;\n s0 = peg$currPos;\n s1 = peg$parsecell();\n if (s1 !== peg$FAILED) {\n s2 = [];\n s3 = peg$parseseparated_cell();\n while (s3 !== peg$FAILED) {\n s2.push(s3);\n s3 = peg$parseseparated_cell();\n }\n peg$savedPos = s0;\n s0 = peg$f9(s1, s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n if (s0 === peg$FAILED) {\n s0 = peg$currPos;\n s1 = [];\n s2 = peg$parseseparated_cell();\n if (s2 !== peg$FAILED) {\n while (s2 !== peg$FAILED) {\n s1.push(s2);\n s2 = peg$parseseparated_cell();\n }\n } else {\n s1 = peg$FAILED;\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = s0;\n s1 = peg$f10(s1);\n }\n s0 = s1;\n }\n return s0;\n }\n function peg$parsesame_line_comment() {\n var s0, s1, s2;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f11(s1);\n if (s2) {\n s2 = void 0;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f12(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parseown_line_comment() {\n var s0, s1, s2;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f13(s1);\n if (s2) {\n s2 = void 0;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f14(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parsewhitespace() {\n var s0, s1, s2;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f15(s1);\n if (s2) {\n s2 = void 0;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f16(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parserow_sep() {\n var s0, s1, s2;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f17(s1);\n if (s2) {\n s2 = void 0;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f18(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parsecol_sep() {\n var s0, s1, s2;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f19(s1);\n if (s2) {\n s2 = void 0;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f20(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parseEOL() {\n var s0, s1;\n s0 = peg$currPos;\n peg$silentFails++;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n peg$silentFails--;\n if (s1 === peg$FAILED) {\n s0 = void 0;\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function processRow(leadCell, otherCells) {\n const cells = [leadCell || []];\n const seps = [];\n for (const x of otherCells) {\n cells.push(x.cell || []);\n seps.push(x.colSep);\n }\n return { cells, colSeps: seps };\n }\n if (!options.isWhitespace) {\n try {\n Object.assign(\n options,\n createMatchers([\"\\\\\", \"hline\", \"cr\"], [\"&\"])\n );\n } catch (e) {\n console.warn(\"Error when initializing parser\", e);\n }\n }\n peg$result = peg$startRuleFunction();\n if (peg$result !== peg$FAILED && peg$currPos === input.length) {\n return peg$result;\n } else {\n if (peg$result !== peg$FAILED && peg$currPos < input.length) {\n peg$fail(peg$endExpectation());\n }\n throw peg$buildStructuredError(\n peg$maxFailExpected,\n peg$maxFailPos < input.length ? input.charAt(peg$maxFailPos) : null,\n peg$maxFailPos < input.length ? peg$computeLocation(peg$maxFailPos, peg$maxFailPos + 1) : peg$computeLocation(peg$maxFailPos, peg$maxFailPos)\n );\n }\n }\n return {\n SyntaxError: peg$SyntaxError,\n parse: peg$parse\n };\n }()\n);\n","export default (\n // Generated by Peggy 3.0.2.\n //\n // https://peggyjs.org/\n function() {\n \"use strict\";\n function peg$subclass(child, parent) {\n function C() {\n this.constructor = child;\n }\n C.prototype = parent.prototype;\n child.prototype = new C();\n }\n function peg$SyntaxError(message, expected, found, location) {\n var self = Error.call(this, message);\n if (Object.setPrototypeOf) {\n Object.setPrototypeOf(self, peg$SyntaxError.prototype);\n }\n self.expected = expected;\n self.found = found;\n self.location = location;\n self.name = \"SyntaxError\";\n return self;\n }\n peg$subclass(peg$SyntaxError, Error);\n function peg$padEnd(str, targetLength, padString) {\n padString = padString || \" \";\n if (str.length > targetLength) {\n return str;\n }\n targetLength -= str.length;\n padString += padString.repeat(targetLength);\n return str + padString.slice(0, targetLength);\n }\n peg$SyntaxError.prototype.format = function(sources) {\n var str = \"Error: \" + this.message;\n if (this.location) {\n var src = null;\n var k;\n for (k = 0; k < sources.length; k++) {\n if (sources[k].source === this.location.source) {\n src = sources[k].text.split(/\\r\\n|\\n|\\r/g);\n break;\n }\n }\n var s = this.location.start;\n var offset_s = this.location.source && typeof this.location.source.offset === \"function\" ? this.location.source.offset(s) : s;\n var loc = this.location.source + \":\" + offset_s.line + \":\" + offset_s.column;\n if (src) {\n var e = this.location.end;\n var filler = peg$padEnd(\"\", offset_s.line.toString().length, \" \");\n var line = src[s.line - 1];\n var last = s.line === e.line ? e.column : line.length + 1;\n var hatLen = last - s.column || 1;\n str += \"\\n --> \" + loc + \"\\n\" + filler + \" |\\n\" + offset_s.line + \" | \" + line + \"\\n\" + filler + \" | \" + peg$padEnd(\"\", s.column - 1, \" \") + peg$padEnd(\"\", hatLen, \"^\");\n } else {\n str += \"\\n at \" + loc;\n }\n }\n return str;\n };\n peg$SyntaxError.buildMessage = function(expected, found) {\n var DESCRIBE_EXPECTATION_FNS = {\n literal: function(expectation) {\n return '\"' + literalEscape(expectation.text) + '\"';\n },\n class: function(expectation) {\n var escapedParts = expectation.parts.map(function(part) {\n return Array.isArray(part) ? classEscape(part[0]) + \"-\" + classEscape(part[1]) : classEscape(part);\n });\n return \"[\" + (expectation.inverted ? \"^\" : \"\") + escapedParts.join(\"\") + \"]\";\n },\n any: function() {\n return \"any character\";\n },\n end: function() {\n return \"end of input\";\n },\n other: function(expectation) {\n return expectation.description;\n }\n };\n function hex(ch) {\n return ch.charCodeAt(0).toString(16).toUpperCase();\n }\n function literalEscape(s) {\n return s.replace(/\\\\/g, \"\\\\\\\\\").replace(/\"/g, '\\\\\"').replace(/\\0/g, \"\\\\0\").replace(/\\t/g, \"\\\\t\").replace(/\\n/g, \"\\\\n\").replace(/\\r/g, \"\\\\r\").replace(/[\\x00-\\x0F]/g, function(ch) {\n return \"\\\\x0\" + hex(ch);\n }).replace(/[\\x10-\\x1F\\x7F-\\x9F]/g, function(ch) {\n return \"\\\\x\" + hex(ch);\n });\n }\n function classEscape(s) {\n return s.replace(/\\\\/g, \"\\\\\\\\\").replace(/\\]/g, \"\\\\]\").replace(/\\^/g, \"\\\\^\").replace(/-/g, \"\\\\-\").replace(/\\0/g, \"\\\\0\").replace(/\\t/g, \"\\\\t\").replace(/\\n/g, \"\\\\n\").replace(/\\r/g, \"\\\\r\").replace(/[\\x00-\\x0F]/g, function(ch) {\n return \"\\\\x0\" + hex(ch);\n }).replace(/[\\x10-\\x1F\\x7F-\\x9F]/g, function(ch) {\n return \"\\\\x\" + hex(ch);\n });\n }\n function describeExpectation(expectation) {\n return DESCRIBE_EXPECTATION_FNS[expectation.type](expectation);\n }\n function describeExpected(expected2) {\n var descriptions = expected2.map(describeExpectation);\n var i, j;\n descriptions.sort();\n if (descriptions.length > 0) {\n for (i = 1, j = 1; i < descriptions.length; i++) {\n if (descriptions[i - 1] !== descriptions[i]) {\n descriptions[j] = descriptions[i];\n j++;\n }\n }\n descriptions.length = j;\n }\n switch (descriptions.length) {\n case 1:\n return descriptions[0];\n case 2:\n return descriptions[0] + \" or \" + descriptions[1];\n default:\n return descriptions.slice(0, -1).join(\", \") + \", or \" + descriptions[descriptions.length - 1];\n }\n }\n function describeFound(found2) {\n return found2 ? '\"' + literalEscape(found2) + '\"' : \"end of input\";\n }\n return \"Expected \" + describeExpected(expected) + \" but \" + describeFound(found) + \" found.\";\n };\n function peg$parse(input, options) {\n options = options !== void 0 ? options : {};\n var peg$FAILED = {};\n var peg$source = options.grammarSource;\n var peg$startRuleFunctions = { args_spec_list: peg$parseargs_spec_list };\n var peg$startRuleFunction = peg$parseargs_spec_list;\n var peg$c0 = \"+\";\n var peg$c1 = \"v\";\n var peg$c2 = \"b\";\n var peg$c3 = \"!\";\n var peg$c4 = \"D\";\n var peg$c5 = \"d\";\n var peg$c6 = \"s\";\n var peg$c7 = \"O\";\n var peg$c8 = \"o\";\n var peg$c9 = \"e\";\n var peg$c10 = \"E\";\n var peg$c11 = \"t\";\n var peg$c12 = \"R\";\n var peg$c13 = \"r\";\n var peg$c14 = \"u\";\n var peg$c15 = \"m\";\n var peg$c16 = \"{\";\n var peg$c17 = \"}\";\n var peg$c18 = \" \";\n var peg$c19 = \"\\n\";\n var peg$c20 = \"\\r\";\n var peg$c21 = \"\\\\\";\n var peg$r0 = /^[{ ]/;\n var peg$r1 = /^[a-zA-Z]/;\n var peg$r2 = /^[{}]/;\n var peg$e0 = peg$literalExpectation(\"+\", false);\n var peg$e1 = peg$literalExpectation(\"v\", false);\n var peg$e2 = peg$anyExpectation();\n var peg$e3 = peg$literalExpectation(\"b\", false);\n var peg$e4 = peg$literalExpectation(\"!\", false);\n var peg$e5 = peg$literalExpectation(\"D\", false);\n var peg$e6 = peg$literalExpectation(\"d\", false);\n var peg$e7 = peg$literalExpectation(\"s\", false);\n var peg$e8 = peg$literalExpectation(\"O\", false);\n var peg$e9 = peg$literalExpectation(\"o\", false);\n var peg$e10 = peg$literalExpectation(\"e\", false);\n var peg$e11 = peg$literalExpectation(\"E\", false);\n var peg$e12 = peg$literalExpectation(\"t\", false);\n var peg$e13 = peg$literalExpectation(\"R\", false);\n var peg$e14 = peg$literalExpectation(\"r\", false);\n var peg$e15 = peg$literalExpectation(\"u\", false);\n var peg$e16 = peg$classExpectation([\"{\", \" \"], false, false);\n var peg$e17 = peg$literalExpectation(\"m\", false);\n var peg$e18 = peg$literalExpectation(\"{\", false);\n var peg$e19 = peg$literalExpectation(\"}\", false);\n var peg$e20 = peg$literalExpectation(\" \", false);\n var peg$e21 = peg$literalExpectation(\"\\n\", false);\n var peg$e22 = peg$literalExpectation(\"\\r\", false);\n var peg$e23 = peg$literalExpectation(\"\\\\\", false);\n var peg$e24 = peg$classExpectation([[\"a\", \"z\"], [\"A\", \"Z\"]], false, false);\n var peg$e25 = peg$classExpectation([\"{\", \"}\"], false, false);\n var peg$f0 = function(x) {\n return x;\n };\n var peg$f1 = function(spec) {\n return spec;\n };\n var peg$f2 = function(spec) {\n return spec;\n };\n var peg$f3 = function(openBrace) {\n return createNode(\"verbatim\", { openBrace, closeBrace: openBrace });\n };\n var peg$f4 = function() {\n return createNode(\"body\");\n };\n var peg$f5 = function(leading_bang, spec) {\n return leading_bang ? { ...spec, noLeadingWhitespace: true } : spec;\n };\n var peg$f6 = function(braceSpec, defaultArg) {\n return createNode(\"optional\", { ...braceSpec, defaultArg });\n };\n var peg$f7 = function(braceSpec) {\n return createNode(\"optional\", braceSpec);\n };\n var peg$f8 = function() {\n return createNode(\"optionalStar\");\n };\n var peg$f9 = function(g) {\n return createNode(\"optional\", { defaultArg: g });\n };\n var peg$f10 = function() {\n return createNode(\"optional\");\n };\n var peg$f11 = function(args) {\n return createNode(\"embellishment\", {\n embellishmentTokens: args\n });\n };\n var peg$f12 = function(args, g) {\n return createNode(\"embellishment\", {\n embellishmentTokens: args,\n defaultArg: g\n });\n };\n var peg$f13 = function(tok) {\n return createNode(\"optionalToken\", { token: tok });\n };\n var peg$f14 = function(braceSpec, defaultArg) {\n return createNode(\"mandatory\", { ...braceSpec, defaultArg });\n };\n var peg$f15 = function(braceSpec) {\n return createNode(\"mandatory\", braceSpec);\n };\n var peg$f16 = function(stopTokens) {\n return createNode(\"until\", { stopTokens });\n };\n var peg$f17 = function(x) {\n return [x];\n };\n var peg$f18 = function(g) {\n return g.content;\n };\n var peg$f19 = function() {\n return createNode(\"mandatory\");\n };\n var peg$f20 = function(openBrace, closeBrace) {\n return { openBrace, closeBrace };\n };\n var peg$f21 = function(g) {\n return g.content.map(groupToStr).join(\"\");\n };\n var peg$f22 = function(t) {\n return [t];\n };\n var peg$f23 = function(args) {\n return args.filter((a) => !a.match(/^\\s*$/));\n };\n var peg$f24 = function(content) {\n return { type: \"group\", content };\n };\n var peg$f25 = function() {\n return \"\";\n };\n var peg$currPos = 0;\n var peg$savedPos = 0;\n var peg$posDetailsCache = [{ line: 1, column: 1 }];\n var peg$maxFailPos = 0;\n var peg$maxFailExpected = [];\n var peg$silentFails = 0;\n var peg$result;\n if (\"startRule\" in options) {\n if (!(options.startRule in peg$startRuleFunctions)) {\n throw new Error(`Can't start parsing from rule \"` + options.startRule + '\".');\n }\n peg$startRuleFunction = peg$startRuleFunctions[options.startRule];\n }\n function text() {\n return input.substring(peg$savedPos, peg$currPos);\n }\n function offset() {\n return peg$savedPos;\n }\n function range() {\n return {\n source: peg$source,\n start: peg$savedPos,\n end: peg$currPos\n };\n }\n function location() {\n return peg$computeLocation(peg$savedPos, peg$currPos);\n }\n function expected(description, location2) {\n location2 = location2 !== void 0 ? location2 : peg$computeLocation(peg$savedPos, peg$currPos);\n throw peg$buildStructuredError(\n [peg$otherExpectation(description)],\n input.substring(peg$savedPos, peg$currPos),\n location2\n );\n }\n function error(message, location2) {\n location2 = location2 !== void 0 ? location2 : peg$computeLocation(peg$savedPos, peg$currPos);\n throw peg$buildSimpleError(message, location2);\n }\n function peg$literalExpectation(text2, ignoreCase) {\n return { type: \"literal\", text: text2, ignoreCase };\n }\n function peg$classExpectation(parts, inverted, ignoreCase) {\n return { type: \"class\", parts, inverted, ignoreCase };\n }\n function peg$anyExpectation() {\n return { type: \"any\" };\n }\n function peg$endExpectation() {\n return { type: \"end\" };\n }\n function peg$otherExpectation(description) {\n return { type: \"other\", description };\n }\n function peg$computePosDetails(pos) {\n var details = peg$posDetailsCache[pos];\n var p;\n if (details) {\n return details;\n } else {\n p = pos - 1;\n while (!peg$posDetailsCache[p]) {\n p--;\n }\n details = peg$posDetailsCache[p];\n details = {\n line: details.line,\n column: details.column\n };\n while (p < pos) {\n if (input.charCodeAt(p) === 10) {\n details.line++;\n details.column = 1;\n } else {\n details.column++;\n }\n p++;\n }\n peg$posDetailsCache[pos] = details;\n return details;\n }\n }\n function peg$computeLocation(startPos, endPos, offset2) {\n var startPosDetails = peg$computePosDetails(startPos);\n var endPosDetails = peg$computePosDetails(endPos);\n var res = {\n source: peg$source,\n start: {\n offset: startPos,\n line: startPosDetails.line,\n column: startPosDetails.column\n },\n end: {\n offset: endPos,\n line: endPosDetails.line,\n column: endPosDetails.column\n }\n };\n if (offset2 && peg$source && typeof peg$source.offset === \"function\") {\n res.start = peg$source.offset(res.start);\n res.end = peg$source.offset(res.end);\n }\n return res;\n }\n function peg$fail(expected2) {\n if (peg$currPos < peg$maxFailPos) {\n return;\n }\n if (peg$currPos > peg$maxFailPos) {\n peg$maxFailPos = peg$currPos;\n peg$maxFailExpected = [];\n }\n peg$maxFailExpected.push(expected2);\n }\n function peg$buildSimpleError(message, location2) {\n return new peg$SyntaxError(message, null, null, location2);\n }\n function peg$buildStructuredError(expected2, found, location2) {\n return new peg$SyntaxError(\n peg$SyntaxError.buildMessage(expected2, found),\n expected2,\n found,\n location2\n );\n }\n function peg$parseargs_spec_list() {\n var s0, s1, s2, s3, s4;\n s0 = peg$currPos;\n s1 = [];\n s2 = peg$currPos;\n s3 = peg$parsewhitespace();\n s4 = peg$parsearg_spec();\n if (s4 !== peg$FAILED) {\n peg$savedPos = s2;\n s2 = peg$f0(s4);\n } else {\n peg$currPos = s2;\n s2 = peg$FAILED;\n }\n while (s2 !== peg$FAILED) {\n s1.push(s2);\n s2 = peg$currPos;\n s3 = peg$parsewhitespace();\n s4 = peg$parsearg_spec();\n if (s4 !== peg$FAILED) {\n peg$savedPos = s2;\n s2 = peg$f0(s4);\n } else {\n peg$currPos = s2;\n s2 = peg$FAILED;\n }\n }\n s2 = peg$parsewhitespace();\n peg$savedPos = s0;\n s0 = peg$f1(s1);\n return s0;\n }\n function peg$parsearg_spec() {\n var s0, s1, s2;\n s0 = peg$currPos;\n if (input.charCodeAt(peg$currPos) === 43) {\n s1 = peg$c0;\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n if (s1 === peg$FAILED) {\n s1 = null;\n }\n s2 = peg$parseoptional();\n if (s2 === peg$FAILED) {\n s2 = peg$parsemandatory();\n if (s2 === peg$FAILED) {\n s2 = peg$parseverbatim();\n if (s2 === peg$FAILED) {\n s2 = peg$parserequired();\n if (s2 === peg$FAILED) {\n s2 = peg$parsebody();\n if (s2 === peg$FAILED) {\n s2 = peg$parseuntil();\n }\n }\n }\n }\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f2(s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parseverbatim() {\n var s0, s1, s2;\n s0 = peg$currPos;\n if (input.charCodeAt(peg$currPos) === 118) {\n s1 = peg$c1;\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e1);\n }\n }\n if (s1 !== peg$FAILED) {\n if (input.length > peg$currPos) {\n s2 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s2 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e2);\n }\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f3(s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parsebody() {\n var s0, s1;\n s0 = peg$currPos;\n if (input.charCodeAt(peg$currPos) === 98) {\n s1 = peg$c2;\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e3);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = s0;\n s1 = peg$f4();\n }\n s0 = s1;\n return s0;\n }\n function peg$parseoptional() {\n var s0, s1, s2;\n s0 = peg$currPos;\n if (input.charCodeAt(peg$currPos) === 33) {\n s1 = peg$c3;\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e4);\n }\n }\n if (s1 === peg$FAILED) {\n s1 = null;\n }\n s2 = peg$parseoptional_star();\n if (s2 === peg$FAILED) {\n s2 = peg$parseoptional_standard();\n if (s2 === peg$FAILED) {\n s2 = peg$parseoptional_delimited();\n if (s2 === peg$FAILED) {\n s2 = peg$parseoptional_embellishment();\n if (s2 === peg$FAILED) {\n s2 = peg$parseoptional_token();\n }\n }\n }\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f5(s1, s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parseoptional_delimited() {\n var s0, s1, s2, s3;\n s0 = peg$currPos;\n if (input.charCodeAt(peg$currPos) === 68) {\n s1 = peg$c4;\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e5);\n }\n }\n if (s1 !== peg$FAILED) {\n s2 = peg$parsebrace_spec();\n s3 = peg$parsearg();\n if (s3 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f6(s2, s3);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n if (s0 === peg$FAILED) {\n s0 = peg$currPos;\n if (input.charCodeAt(peg$currPos) === 100) {\n s1 = peg$c5;\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e6);\n }\n }\n if (s1 !== peg$FAILED) {\n s2 = peg$parsebrace_spec();\n peg$savedPos = s0;\n s0 = peg$f7(s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n }\n return s0;\n }\n function peg$parseoptional_star() {\n var s0, s1;\n s0 = peg$currPos;\n if (input.charCodeAt(peg$currPos) === 115) {\n s1 = peg$c6;\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e7);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = s0;\n s1 = peg$f8();\n }\n s0 = s1;\n return s0;\n }\n function peg$parseoptional_standard() {\n var s0, s1, s2, s3;\n s0 = peg$currPos;\n if (input.charCodeAt(peg$currPos) === 79) {\n s1 = peg$c7;\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e8);\n }\n }\n if (s1 !== peg$FAILED) {\n s2 = peg$parsewhitespace();\n s3 = peg$parsearg();\n if (s3 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f9(s3);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n if (s0 === peg$FAILED) {\n s0 = peg$currPos;\n if (input.charCodeAt(peg$currPos) === 111) {\n s1 = peg$c8;\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e9);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = s0;\n s1 = peg$f10();\n }\n s0 = s1;\n }\n return s0;\n }\n function peg$parseoptional_embellishment() {\n var s0, s1, s2, s3, s4, s5;\n s0 = peg$currPos;\n if (input.charCodeAt(peg$currPos) === 101) {\n s1 = peg$c9;\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e10);\n }\n }\n if (s1 !== peg$FAILED) {\n s2 = peg$parsewhitespace();\n s3 = peg$parseargs();\n if (s3 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f11(s3);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n if (s0 === peg$FAILED) {\n s0 = peg$currPos;\n if (input.charCodeAt(peg$currPos) === 69) {\n s1 = peg$c10;\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e11);\n }\n }\n if (s1 !== peg$FAILED) {\n s2 = peg$parsewhitespace();\n s3 = peg$parseargs();\n if (s3 !== peg$FAILED) {\n s4 = peg$parsewhitespace();\n s5 = peg$parseargs();\n if (s5 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f12(s3, s5);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n }\n return s0;\n }\n function peg$parseoptional_token() {\n var s0, s1, s2;\n s0 = peg$currPos;\n if (input.charCodeAt(peg$currPos) === 116) {\n s1 = peg$c11;\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e12);\n }\n }\n if (s1 !== peg$FAILED) {\n if (input.length > peg$currPos) {\n s2 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s2 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e2);\n }\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f13(s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parserequired() {\n var s0, s1, s2, s3;\n s0 = peg$currPos;\n if (input.charCodeAt(peg$currPos) === 82) {\n s1 = peg$c12;\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e13);\n }\n }\n if (s1 !== peg$FAILED) {\n s2 = peg$parsebrace_spec();\n s3 = peg$parsearg();\n if (s3 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f14(s2, s3);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n if (s0 === peg$FAILED) {\n s0 = peg$currPos;\n if (input.charCodeAt(peg$currPos) === 114) {\n s1 = peg$c13;\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e14);\n }\n }\n if (s1 !== peg$FAILED) {\n s2 = peg$parsebrace_spec();\n peg$savedPos = s0;\n s0 = peg$f15(s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n }\n return s0;\n }\n function peg$parseuntil() {\n var s0, s1, s2;\n s0 = peg$currPos;\n if (input.charCodeAt(peg$currPos) === 117) {\n s1 = peg$c14;\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e15);\n }\n }\n if (s1 !== peg$FAILED) {\n s2 = peg$parseuntil_stop_token();\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f16(s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parseuntil_stop_token() {\n var s0, s1, s2;\n s0 = peg$currPos;\n s1 = peg$currPos;\n peg$silentFails++;\n if (peg$r0.test(input.charAt(peg$currPos))) {\n s2 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s2 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e16);\n }\n }\n peg$silentFails--;\n if (s2 === peg$FAILED) {\n s1 = void 0;\n } else {\n peg$currPos = s1;\n s1 = peg$FAILED;\n }\n if (s1 !== peg$FAILED) {\n if (input.length > peg$currPos) {\n s2 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s2 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e2);\n }\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f17(s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n if (s0 === peg$FAILED) {\n s0 = peg$currPos;\n s1 = peg$parsebraced_group();\n if (s1 !== peg$FAILED) {\n peg$savedPos = s0;\n s1 = peg$f18(s1);\n }\n s0 = s1;\n }\n return s0;\n }\n function peg$parsemandatory() {\n var s0, s1;\n s0 = peg$currPos;\n if (input.charCodeAt(peg$currPos) === 109) {\n s1 = peg$c15;\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e17);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = s0;\n s1 = peg$f19();\n }\n s0 = s1;\n return s0;\n }\n function peg$parsebrace_spec() {\n var s0, s1, s2, s3, s4, s5;\n s0 = peg$currPos;\n s1 = peg$currPos;\n s2 = peg$currPos;\n s3 = peg$currPos;\n peg$silentFails++;\n s4 = peg$parsewhitespace_token();\n peg$silentFails--;\n if (s4 === peg$FAILED) {\n s3 = void 0;\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n if (s3 !== peg$FAILED) {\n s4 = peg$parsemacro();\n if (s4 === peg$FAILED) {\n if (input.length > peg$currPos) {\n s4 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s4 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e2);\n }\n }\n }\n if (s4 !== peg$FAILED) {\n s3 = [s3, s4];\n s2 = s3;\n } else {\n peg$currPos = s2;\n s2 = peg$FAILED;\n }\n } else {\n peg$currPos = s2;\n s2 = peg$FAILED;\n }\n if (s2 === peg$FAILED) {\n s2 = null;\n }\n s1 = input.substring(s1, peg$currPos);\n s2 = peg$currPos;\n s3 = peg$currPos;\n s4 = peg$currPos;\n peg$silentFails++;\n s5 = peg$parsewhitespace_token();\n peg$silentFails--;\n if (s5 === peg$FAILED) {\n s4 = void 0;\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n if (s4 !== peg$FAILED) {\n s5 = peg$parsemacro();\n if (s5 === peg$FAILED) {\n if (input.length > peg$currPos) {\n s5 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s5 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e2);\n }\n }\n }\n if (s5 !== peg$FAILED) {\n s4 = [s4, s5];\n s3 = s4;\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n if (s3 === peg$FAILED) {\n s3 = null;\n }\n s2 = input.substring(s2, peg$currPos);\n peg$savedPos = s0;\n s0 = peg$f20(s1, s2);\n return s0;\n }\n function peg$parsearg() {\n var s0, s1;\n s0 = peg$parsetoken();\n if (s0 === peg$FAILED) {\n s0 = peg$currPos;\n s1 = peg$parsebraced_group();\n if (s1 !== peg$FAILED) {\n peg$savedPos = s0;\n s1 = peg$f21(s1);\n }\n s0 = s1;\n }\n return s0;\n }\n function peg$parseargs() {\n var s0, s1, s2, s3;\n s0 = peg$currPos;\n s1 = peg$parsetoken();\n if (s1 !== peg$FAILED) {\n peg$savedPos = s0;\n s1 = peg$f22(s1);\n }\n s0 = s1;\n if (s0 === peg$FAILED) {\n s0 = peg$currPos;\n if (input.charCodeAt(peg$currPos) === 123) {\n s1 = peg$c16;\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e18);\n }\n }\n if (s1 !== peg$FAILED) {\n s2 = [];\n s3 = peg$parsearg();\n if (s3 === peg$FAILED) {\n s3 = peg$parsewhitespace_token();\n }\n while (s3 !== peg$FAILED) {\n s2.push(s3);\n s3 = peg$parsearg();\n if (s3 === peg$FAILED) {\n s3 = peg$parsewhitespace_token();\n }\n }\n if (input.charCodeAt(peg$currPos) === 125) {\n s3 = peg$c17;\n peg$currPos++;\n } else {\n s3 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e19);\n }\n }\n if (s3 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f23(s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n }\n return s0;\n }\n function peg$parsebraced_group() {\n var s0, s1, s2, s3, s4, s5, s6, s7;\n s0 = peg$currPos;\n if (input.charCodeAt(peg$currPos) === 123) {\n s1 = peg$c16;\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e18);\n }\n }\n if (s1 !== peg$FAILED) {\n s2 = [];\n s3 = peg$currPos;\n s4 = peg$currPos;\n s5 = peg$currPos;\n peg$silentFails++;\n if (input.charCodeAt(peg$currPos) === 125) {\n s6 = peg$c17;\n peg$currPos++;\n } else {\n s6 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e19);\n }\n }\n peg$silentFails--;\n if (s6 === peg$FAILED) {\n s5 = void 0;\n } else {\n peg$currPos = s5;\n s5 = peg$FAILED;\n }\n if (s5 !== peg$FAILED) {\n s6 = peg$currPos;\n peg$silentFails++;\n s7 = peg$parsebraced_group();\n peg$silentFails--;\n if (s7 === peg$FAILED) {\n s6 = void 0;\n } else {\n peg$currPos = s6;\n s6 = peg$FAILED;\n }\n if (s6 !== peg$FAILED) {\n s7 = peg$parsetoken();\n if (s7 === peg$FAILED) {\n s7 = peg$parsewhitespace_token();\n }\n if (s7 !== peg$FAILED) {\n s5 = [s5, s6, s7];\n s4 = s5;\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n if (s4 !== peg$FAILED) {\n s3 = input.substring(s3, peg$currPos);\n } else {\n s3 = s4;\n }\n if (s3 === peg$FAILED) {\n s3 = peg$parsebraced_group();\n }\n while (s3 !== peg$FAILED) {\n s2.push(s3);\n s3 = peg$currPos;\n s4 = peg$currPos;\n s5 = peg$currPos;\n peg$silentFails++;\n if (input.charCodeAt(peg$currPos) === 125) {\n s6 = peg$c17;\n peg$currPos++;\n } else {\n s6 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e19);\n }\n }\n peg$silentFails--;\n if (s6 === peg$FAILED) {\n s5 = void 0;\n } else {\n peg$currPos = s5;\n s5 = peg$FAILED;\n }\n if (s5 !== peg$FAILED) {\n s6 = peg$currPos;\n peg$silentFails++;\n s7 = peg$parsebraced_group();\n peg$silentFails--;\n if (s7 === peg$FAILED) {\n s6 = void 0;\n } else {\n peg$currPos = s6;\n s6 = peg$FAILED;\n }\n if (s6 !== peg$FAILED) {\n s7 = peg$parsetoken();\n if (s7 === peg$FAILED) {\n s7 = peg$parsewhitespace_token();\n }\n if (s7 !== peg$FAILED) {\n s5 = [s5, s6, s7];\n s4 = s5;\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n if (s4 !== peg$FAILED) {\n s3 = input.substring(s3, peg$currPos);\n } else {\n s3 = s4;\n }\n if (s3 === peg$FAILED) {\n s3 = peg$parsebraced_group();\n }\n }\n if (input.charCodeAt(peg$currPos) === 125) {\n s3 = peg$c17;\n peg$currPos++;\n } else {\n s3 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e19);\n }\n }\n if (s3 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f24(s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parsewhitespace() {\n var s0, s1, s2;\n s0 = peg$currPos;\n s1 = [];\n s2 = peg$parsewhitespace_token();\n while (s2 !== peg$FAILED) {\n s1.push(s2);\n s2 = peg$parsewhitespace_token();\n }\n peg$savedPos = s0;\n s1 = peg$f25();\n s0 = s1;\n return s0;\n }\n function peg$parsewhitespace_token() {\n var s0;\n if (input.charCodeAt(peg$currPos) === 32) {\n s0 = peg$c18;\n peg$currPos++;\n } else {\n s0 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e20);\n }\n }\n if (s0 === peg$FAILED) {\n if (input.charCodeAt(peg$currPos) === 10) {\n s0 = peg$c19;\n peg$currPos++;\n } else {\n s0 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e21);\n }\n }\n if (s0 === peg$FAILED) {\n if (input.charCodeAt(peg$currPos) === 13) {\n s0 = peg$c20;\n peg$currPos++;\n } else {\n s0 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e22);\n }\n }\n }\n }\n return s0;\n }\n function peg$parsemacro() {\n var s0, s1, s2, s3, s4;\n s0 = peg$currPos;\n s1 = peg$currPos;\n if (input.charCodeAt(peg$currPos) === 92) {\n s2 = peg$c21;\n peg$currPos++;\n } else {\n s2 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e23);\n }\n }\n if (s2 !== peg$FAILED) {\n s3 = [];\n if (peg$r1.test(input.charAt(peg$currPos))) {\n s4 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s4 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e24);\n }\n }\n if (s4 !== peg$FAILED) {\n while (s4 !== peg$FAILED) {\n s3.push(s4);\n if (peg$r1.test(input.charAt(peg$currPos))) {\n s4 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s4 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e24);\n }\n }\n }\n } else {\n s3 = peg$FAILED;\n }\n if (s3 !== peg$FAILED) {\n s2 = [s2, s3];\n s1 = s2;\n } else {\n peg$currPos = s1;\n s1 = peg$FAILED;\n }\n } else {\n peg$currPos = s1;\n s1 = peg$FAILED;\n }\n if (s1 !== peg$FAILED) {\n s0 = input.substring(s0, peg$currPos);\n } else {\n s0 = s1;\n }\n if (s0 === peg$FAILED) {\n s0 = peg$currPos;\n s1 = peg$currPos;\n if (input.charCodeAt(peg$currPos) === 92) {\n s2 = peg$c21;\n peg$currPos++;\n } else {\n s2 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e23);\n }\n }\n if (s2 !== peg$FAILED) {\n s3 = peg$currPos;\n peg$silentFails++;\n if (peg$r1.test(input.charAt(peg$currPos))) {\n s4 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s4 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e24);\n }\n }\n peg$silentFails--;\n if (s4 === peg$FAILED) {\n s3 = void 0;\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n if (s3 !== peg$FAILED) {\n if (input.length > peg$currPos) {\n s4 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s4 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e2);\n }\n }\n if (s4 !== peg$FAILED) {\n s2 = [s2, s3, s4];\n s1 = s2;\n } else {\n peg$currPos = s1;\n s1 = peg$FAILED;\n }\n } else {\n peg$currPos = s1;\n s1 = peg$FAILED;\n }\n } else {\n peg$currPos = s1;\n s1 = peg$FAILED;\n }\n if (s1 !== peg$FAILED) {\n s0 = input.substring(s0, peg$currPos);\n } else {\n s0 = s1;\n }\n }\n return s0;\n }\n function peg$parsetoken() {\n var s0, s1, s2, s3;\n s0 = peg$parsemacro();\n if (s0 === peg$FAILED) {\n s0 = peg$currPos;\n s1 = peg$currPos;\n peg$silentFails++;\n if (peg$r2.test(input.charAt(peg$currPos))) {\n s2 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s2 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e25);\n }\n }\n peg$silentFails--;\n if (s2 === peg$FAILED) {\n s1 = void 0;\n } else {\n peg$currPos = s1;\n s1 = peg$FAILED;\n }\n if (s1 !== peg$FAILED) {\n s2 = peg$currPos;\n peg$silentFails++;\n s3 = peg$parsewhitespace_token();\n peg$silentFails--;\n if (s3 === peg$FAILED) {\n s2 = void 0;\n } else {\n peg$currPos = s2;\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n if (input.length > peg$currPos) {\n s3 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s3 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e2);\n }\n }\n if (s3 !== peg$FAILED) {\n s0 = s3;\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n }\n return s0;\n }\n const DEFAULT_OPTIONS = {\n optional: { openBrace: \"[\", closeBrace: \"]\" },\n mandatory: { openBrace: \"{\", closeBrace: \"}\" }\n };\n function createNode(type, options2) {\n const computedOptions = DEFAULT_OPTIONS[type] || {};\n return { type, ...computedOptions, ...options2 };\n }\n function groupToStr(node) {\n if (typeof node !== \"object\" || !node) {\n return node;\n }\n if (node.type === \"group\") {\n return `{${node.content.map(groupToStr).join(\"\")}}`;\n }\n return node;\n }\n peg$result = peg$startRuleFunction();\n if (peg$result !== peg$FAILED && peg$currPos === input.length) {\n return peg$result;\n } else {\n if (peg$result !== peg$FAILED && peg$currPos < input.length) {\n peg$fail(peg$endExpectation());\n }\n throw peg$buildStructuredError(\n peg$maxFailExpected,\n peg$maxFailPos < input.length ? input.charAt(peg$maxFailPos) : null,\n peg$maxFailPos < input.length ? peg$computeLocation(peg$maxFailPos, peg$maxFailPos + 1) : peg$computeLocation(peg$maxFailPos, peg$maxFailPos)\n );\n }\n }\n return {\n SyntaxError: peg$SyntaxError,\n parse: peg$parse\n };\n }()\n);\n","export default (\n // Generated by Peggy 3.0.2.\n //\n // https://peggyjs.org/\n function() {\n \"use strict\";\n function peg$subclass(child, parent) {\n function C() {\n this.constructor = child;\n }\n C.prototype = parent.prototype;\n child.prototype = new C();\n }\n function peg$SyntaxError(message, expected, found, location) {\n var self = Error.call(this, message);\n if (Object.setPrototypeOf) {\n Object.setPrototypeOf(self, peg$SyntaxError.prototype);\n }\n self.expected = expected;\n self.found = found;\n self.location = location;\n self.name = \"SyntaxError\";\n return self;\n }\n peg$subclass(peg$SyntaxError, Error);\n function peg$padEnd(str, targetLength, padString) {\n padString = padString || \" \";\n if (str.length > targetLength) {\n return str;\n }\n targetLength -= str.length;\n padString += padString.repeat(targetLength);\n return str + padString.slice(0, targetLength);\n }\n peg$SyntaxError.prototype.format = function(sources) {\n var str = \"Error: \" + this.message;\n if (this.location) {\n var src = null;\n var k;\n for (k = 0; k < sources.length; k++) {\n if (sources[k].source === this.location.source) {\n src = sources[k].text.split(/\\r\\n|\\n|\\r/g);\n break;\n }\n }\n var s = this.location.start;\n var offset_s = this.location.source && typeof this.location.source.offset === \"function\" ? this.location.source.offset(s) : s;\n var loc = this.location.source + \":\" + offset_s.line + \":\" + offset_s.column;\n if (src) {\n var e = this.location.end;\n var filler = peg$padEnd(\"\", offset_s.line.toString().length, \" \");\n var line = src[s.line - 1];\n var last = s.line === e.line ? e.column : line.length + 1;\n var hatLen = last - s.column || 1;\n str += \"\\n --> \" + loc + \"\\n\" + filler + \" |\\n\" + offset_s.line + \" | \" + line + \"\\n\" + filler + \" | \" + peg$padEnd(\"\", s.column - 1, \" \") + peg$padEnd(\"\", hatLen, \"^\");\n } else {\n str += \"\\n at \" + loc;\n }\n }\n return str;\n };\n peg$SyntaxError.buildMessage = function(expected, found) {\n var DESCRIBE_EXPECTATION_FNS = {\n literal: function(expectation) {\n return '\"' + literalEscape(expectation.text) + '\"';\n },\n class: function(expectation) {\n var escapedParts = expectation.parts.map(function(part) {\n return Array.isArray(part) ? classEscape(part[0]) + \"-\" + classEscape(part[1]) : classEscape(part);\n });\n return \"[\" + (expectation.inverted ? \"^\" : \"\") + escapedParts.join(\"\") + \"]\";\n },\n any: function() {\n return \"any character\";\n },\n end: function() {\n return \"end of input\";\n },\n other: function(expectation) {\n return expectation.description;\n }\n };\n function hex(ch) {\n return ch.charCodeAt(0).toString(16).toUpperCase();\n }\n function literalEscape(s) {\n return s.replace(/\\\\/g, \"\\\\\\\\\").replace(/\"/g, '\\\\\"').replace(/\\0/g, \"\\\\0\").replace(/\\t/g, \"\\\\t\").replace(/\\n/g, \"\\\\n\").replace(/\\r/g, \"\\\\r\").replace(/[\\x00-\\x0F]/g, function(ch) {\n return \"\\\\x0\" + hex(ch);\n }).replace(/[\\x10-\\x1F\\x7F-\\x9F]/g, function(ch) {\n return \"\\\\x\" + hex(ch);\n });\n }\n function classEscape(s) {\n return s.replace(/\\\\/g, \"\\\\\\\\\").replace(/\\]/g, \"\\\\]\").replace(/\\^/g, \"\\\\^\").replace(/-/g, \"\\\\-\").replace(/\\0/g, \"\\\\0\").replace(/\\t/g, \"\\\\t\").replace(/\\n/g, \"\\\\n\").replace(/\\r/g, \"\\\\r\").replace(/[\\x00-\\x0F]/g, function(ch) {\n return \"\\\\x0\" + hex(ch);\n }).replace(/[\\x10-\\x1F\\x7F-\\x9F]/g, function(ch) {\n return \"\\\\x\" + hex(ch);\n });\n }\n function describeExpectation(expectation) {\n return DESCRIBE_EXPECTATION_FNS[expectation.type](expectation);\n }\n function describeExpected(expected2) {\n var descriptions = expected2.map(describeExpectation);\n var i, j;\n descriptions.sort();\n if (descriptions.length > 0) {\n for (i = 1, j = 1; i < descriptions.length; i++) {\n if (descriptions[i - 1] !== descriptions[i]) {\n descriptions[j] = descriptions[i];\n j++;\n }\n }\n descriptions.length = j;\n }\n switch (descriptions.length) {\n case 1:\n return descriptions[0];\n case 2:\n return descriptions[0] + \" or \" + descriptions[1];\n default:\n return descriptions.slice(0, -1).join(\", \") + \", or \" + descriptions[descriptions.length - 1];\n }\n }\n function describeFound(found2) {\n return found2 ? '\"' + literalEscape(found2) + '\"' : \"end of input\";\n }\n return \"Expected \" + describeExpected(expected) + \" but \" + describeFound(found) + \" found.\";\n };\n function peg$parse(input, options) {\n options = options !== void 0 ? options : {};\n var peg$FAILED = {};\n var peg$source = options.grammarSource;\n var peg$startRuleFunctions = { body: peg$parsebody };\n var peg$startRuleFunction = peg$parsebody;\n var peg$e0 = peg$anyExpectation();\n var peg$f0 = function() {\n return [];\n };\n var peg$f1 = function(rowItems, trailingComment) {\n return {\n itemParts: [],\n ...rowItems,\n trailingComment,\n trailingComma: true\n };\n };\n var peg$f2 = function(rowItems, trailingComment) {\n return { ...rowItems, trailingComment };\n };\n var peg$f3 = function(a, b) {\n return processItem(a, b);\n };\n var peg$f4 = function(b) {\n return processItem(null, b);\n };\n var peg$f5 = function(cell) {\n return { cell };\n };\n var peg$f6 = function() {\n return {};\n };\n var peg$f7 = function(part) {\n return part;\n };\n var peg$f8 = function(x) {\n return x;\n };\n var peg$f9 = function(space, x) {\n return {\n trailingComment: x,\n leadingParbreak: space.parbreak > 0\n };\n };\n var peg$f10 = function(list) {\n return {\n whitespace: list.filter((x) => options.isWhitespace(x)).length,\n parbreak: list.filter((x) => options.isParbreak(x)).length\n };\n };\n var peg$f11 = function() {\n return !options.allowParenGroups;\n };\n var peg$f12 = function(tok) {\n return options.isSameLineComment(tok);\n };\n var peg$f13 = function(tok) {\n return tok;\n };\n var peg$f14 = function(tok) {\n return options.isOwnLineComment(tok);\n };\n var peg$f15 = function(tok) {\n return tok;\n };\n var peg$f16 = function(tok) {\n return options.isWhitespace(tok);\n };\n var peg$f17 = function(tok) {\n return tok;\n };\n var peg$f18 = function(tok) {\n return options.isParbreak(tok);\n };\n var peg$f19 = function(tok) {\n return tok;\n };\n var peg$f20 = function(tok) {\n return options.isComma(tok);\n };\n var peg$f21 = function(tok) {\n return tok;\n };\n var peg$f22 = function(tok) {\n return options.isEquals(tok);\n };\n var peg$f23 = function(tok) {\n return tok;\n };\n var peg$f24 = function(tok) {\n return options.isChar(tok, \"(\");\n };\n var peg$f25 = function(tok) {\n return tok;\n };\n var peg$f26 = function(tok) {\n return options.isChar(tok, \")\");\n };\n var peg$f27 = function(tok) {\n return tok;\n };\n var peg$currPos = 0;\n var peg$savedPos = 0;\n var peg$posDetailsCache = [{ line: 1, column: 1 }];\n var peg$maxFailPos = 0;\n var peg$maxFailExpected = [];\n var peg$silentFails = 0;\n var peg$result;\n if (\"startRule\" in options) {\n if (!(options.startRule in peg$startRuleFunctions)) {\n throw new Error(`Can't start parsing from rule \"` + options.startRule + '\".');\n }\n peg$startRuleFunction = peg$startRuleFunctions[options.startRule];\n }\n function text() {\n return input.substring(peg$savedPos, peg$currPos);\n }\n function offset() {\n return peg$savedPos;\n }\n function range() {\n return {\n source: peg$source,\n start: peg$savedPos,\n end: peg$currPos\n };\n }\n function location() {\n return peg$computeLocation(peg$savedPos, peg$currPos);\n }\n function expected(description, location2) {\n location2 = location2 !== void 0 ? location2 : peg$computeLocation(peg$savedPos, peg$currPos);\n throw peg$buildStructuredError(\n [peg$otherExpectation(description)],\n input.substring(peg$savedPos, peg$currPos),\n location2\n );\n }\n function error(message, location2) {\n location2 = location2 !== void 0 ? location2 : peg$computeLocation(peg$savedPos, peg$currPos);\n throw peg$buildSimpleError(message, location2);\n }\n function peg$literalExpectation(text2, ignoreCase) {\n return { type: \"literal\", text: text2, ignoreCase };\n }\n function peg$classExpectation(parts, inverted, ignoreCase) {\n return { type: \"class\", parts, inverted, ignoreCase };\n }\n function peg$anyExpectation() {\n return { type: \"any\" };\n }\n function peg$endExpectation() {\n return { type: \"end\" };\n }\n function peg$otherExpectation(description) {\n return { type: \"other\", description };\n }\n function peg$computePosDetails(pos) {\n var details = peg$posDetailsCache[pos];\n var p;\n if (details) {\n return details;\n } else {\n p = pos - 1;\n while (!peg$posDetailsCache[p]) {\n p--;\n }\n details = peg$posDetailsCache[p];\n details = {\n line: details.line,\n column: details.column\n };\n while (p < pos) {\n if (input.charCodeAt(p) === 10) {\n details.line++;\n details.column = 1;\n } else {\n details.column++;\n }\n p++;\n }\n peg$posDetailsCache[pos] = details;\n return details;\n }\n }\n function peg$computeLocation(startPos, endPos, offset2) {\n var startPosDetails = peg$computePosDetails(startPos);\n var endPosDetails = peg$computePosDetails(endPos);\n var res = {\n source: peg$source,\n start: {\n offset: startPos,\n line: startPosDetails.line,\n column: startPosDetails.column\n },\n end: {\n offset: endPos,\n line: endPosDetails.line,\n column: endPosDetails.column\n }\n };\n if (offset2 && peg$source && typeof peg$source.offset === \"function\") {\n res.start = peg$source.offset(res.start);\n res.end = peg$source.offset(res.end);\n }\n return res;\n }\n function peg$fail(expected2) {\n if (peg$currPos < peg$maxFailPos) {\n return;\n }\n if (peg$currPos > peg$maxFailPos) {\n peg$maxFailPos = peg$currPos;\n peg$maxFailExpected = [];\n }\n peg$maxFailExpected.push(expected2);\n }\n function peg$buildSimpleError(message, location2) {\n return new peg$SyntaxError(message, null, null, location2);\n }\n function peg$buildStructuredError(expected2, found, location2) {\n return new peg$SyntaxError(\n peg$SyntaxError.buildMessage(expected2, found),\n expected2,\n found,\n location2\n );\n }\n function peg$parsebody() {\n var s0, s1, s2;\n s0 = [];\n s1 = peg$parsecomment_only_line();\n if (s1 === peg$FAILED) {\n s1 = peg$parseitem_with_end();\n if (s1 === peg$FAILED) {\n s1 = peg$parseitem_without_end();\n }\n }\n if (s1 !== peg$FAILED) {\n while (s1 !== peg$FAILED) {\n s0.push(s1);\n s1 = peg$parsecomment_only_line();\n if (s1 === peg$FAILED) {\n s1 = peg$parseitem_with_end();\n if (s1 === peg$FAILED) {\n s1 = peg$parseitem_without_end();\n }\n }\n }\n } else {\n s0 = peg$FAILED;\n }\n if (s0 === peg$FAILED) {\n s0 = peg$currPos;\n s1 = [];\n s2 = peg$parsewhitespace();\n while (s2 !== peg$FAILED) {\n s1.push(s2);\n s2 = peg$parsewhitespace();\n }\n s2 = peg$parseEOL();\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f0();\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n }\n return s0;\n }\n function peg$parseitem_with_end() {\n var s0, s1, s2, s3, s4, s5, s6, s7, s8;\n s0 = peg$currPos;\n s1 = peg$parsewhitespace_or_parbreaks();\n s2 = peg$parserow_items();\n if (s2 === peg$FAILED) {\n s2 = null;\n }\n s3 = peg$parsewhitespace_or_parbreaks();\n s4 = peg$parseitem_sep();\n if (s4 !== peg$FAILED) {\n s5 = [];\n s6 = peg$parsewhitespace();\n while (s6 !== peg$FAILED) {\n s5.push(s6);\n s6 = peg$parsewhitespace();\n }\n s6 = peg$parsetrailing_comment();\n if (s6 === peg$FAILED) {\n s6 = null;\n }\n s7 = [];\n s8 = peg$parsewhitespace();\n while (s8 !== peg$FAILED) {\n s7.push(s8);\n s8 = peg$parsewhitespace();\n }\n peg$savedPos = s0;\n s0 = peg$f1(s2, s6);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parseitem_without_end() {\n var s0, s1, s2, s3;\n s0 = peg$currPos;\n s1 = peg$parsewhitespace_or_parbreaks();\n s2 = peg$parserow_items();\n if (s2 !== peg$FAILED) {\n s3 = peg$parsetrailing_comment();\n if (s3 === peg$FAILED) {\n s3 = null;\n }\n peg$savedPos = s0;\n s0 = peg$f2(s2, s3);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parserow_items() {\n var s0, s1, s2, s3;\n s0 = peg$currPos;\n s1 = peg$parseitem_part();\n if (s1 !== peg$FAILED) {\n s2 = [];\n s3 = peg$parseseparated_part();\n while (s3 !== peg$FAILED) {\n s2.push(s3);\n s3 = peg$parseseparated_part();\n }\n peg$savedPos = s0;\n s0 = peg$f3(s1, s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n if (s0 === peg$FAILED) {\n s0 = peg$currPos;\n s1 = [];\n s2 = peg$parseseparated_part();\n if (s2 !== peg$FAILED) {\n while (s2 !== peg$FAILED) {\n s1.push(s2);\n s2 = peg$parseseparated_part();\n }\n } else {\n s1 = peg$FAILED;\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = s0;\n s1 = peg$f4(s1);\n }\n s0 = s1;\n }\n return s0;\n }\n function peg$parseseparated_part() {\n var s0, s1, s2, s3, s4;\n s0 = peg$currPos;\n s1 = [];\n s2 = peg$parseparbreak();\n while (s2 !== peg$FAILED) {\n s1.push(s2);\n s2 = peg$parseparbreak();\n }\n s2 = peg$parseequals();\n if (s2 !== peg$FAILED) {\n s3 = [];\n s4 = peg$parseparbreak();\n while (s4 !== peg$FAILED) {\n s3.push(s4);\n s4 = peg$parseparbreak();\n }\n s4 = peg$parseitem_part();\n if (s4 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f5(s4);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n if (s0 === peg$FAILED) {\n s0 = peg$currPos;\n s1 = [];\n s2 = peg$parseparbreak();\n while (s2 !== peg$FAILED) {\n s1.push(s2);\n s2 = peg$parseparbreak();\n }\n s2 = peg$parseequals();\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f6();\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n }\n return s0;\n }\n function peg$parseitem_part() {\n var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;\n s0 = peg$currPos;\n s1 = [];\n s2 = peg$parsewhitespace();\n while (s2 !== peg$FAILED) {\n s1.push(s2);\n s2 = peg$parsewhitespace();\n }\n s2 = peg$currPos;\n s3 = [];\n s4 = peg$parsenon_whitespace_non_parbreak_token();\n if (s4 === peg$FAILED) {\n s4 = peg$currPos;\n s5 = peg$parsewhitespace();\n if (s5 === peg$FAILED) {\n s5 = peg$parseparbreak();\n }\n if (s5 !== peg$FAILED) {\n s6 = peg$currPos;\n peg$silentFails++;\n s7 = peg$currPos;\n s8 = [];\n s9 = peg$parsewhitespace();\n if (s9 === peg$FAILED) {\n s9 = peg$parseparbreak();\n }\n while (s9 !== peg$FAILED) {\n s8.push(s9);\n s9 = peg$parsewhitespace();\n if (s9 === peg$FAILED) {\n s9 = peg$parseparbreak();\n }\n }\n s9 = peg$parsenon_whitespace_non_parbreak_token();\n if (s9 !== peg$FAILED) {\n s8 = [s8, s9];\n s7 = s8;\n } else {\n peg$currPos = s7;\n s7 = peg$FAILED;\n }\n peg$silentFails--;\n if (s7 !== peg$FAILED) {\n peg$currPos = s6;\n s6 = void 0;\n } else {\n s6 = peg$FAILED;\n }\n if (s6 !== peg$FAILED) {\n s5 = [s5, s6];\n s4 = s5;\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n }\n if (s4 !== peg$FAILED) {\n while (s4 !== peg$FAILED) {\n s3.push(s4);\n s4 = peg$parsenon_whitespace_non_parbreak_token();\n if (s4 === peg$FAILED) {\n s4 = peg$currPos;\n s5 = peg$parsewhitespace();\n if (s5 === peg$FAILED) {\n s5 = peg$parseparbreak();\n }\n if (s5 !== peg$FAILED) {\n s6 = peg$currPos;\n peg$silentFails++;\n s7 = peg$currPos;\n s8 = [];\n s9 = peg$parsewhitespace();\n if (s9 === peg$FAILED) {\n s9 = peg$parseparbreak();\n }\n while (s9 !== peg$FAILED) {\n s8.push(s9);\n s9 = peg$parsewhitespace();\n if (s9 === peg$FAILED) {\n s9 = peg$parseparbreak();\n }\n }\n s9 = peg$parsenon_whitespace_non_parbreak_token();\n if (s9 !== peg$FAILED) {\n s8 = [s8, s9];\n s7 = s8;\n } else {\n peg$currPos = s7;\n s7 = peg$FAILED;\n }\n peg$silentFails--;\n if (s7 !== peg$FAILED) {\n peg$currPos = s6;\n s6 = void 0;\n } else {\n s6 = peg$FAILED;\n }\n if (s6 !== peg$FAILED) {\n s5 = [s5, s6];\n s4 = s5;\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n }\n }\n } else {\n s3 = peg$FAILED;\n }\n if (s3 !== peg$FAILED) {\n s2 = input.substring(s2, peg$currPos);\n } else {\n s2 = s3;\n }\n if (s2 !== peg$FAILED) {\n s3 = [];\n s4 = peg$parsewhitespace();\n while (s4 !== peg$FAILED) {\n s3.push(s4);\n s4 = peg$parsewhitespace();\n }\n peg$savedPos = s0;\n s0 = peg$f7(s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parsetrailing_comment() {\n var s0, s1, s2;\n s0 = peg$currPos;\n s1 = [];\n s2 = peg$parsewhitespace();\n while (s2 !== peg$FAILED) {\n s1.push(s2);\n s2 = peg$parsewhitespace();\n }\n s2 = peg$parsesame_line_comment();\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f8(s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parsecomment_only_line() {\n var s0, s1, s2;\n s0 = peg$currPos;\n s1 = peg$parsewhitespace_or_parbreaks();\n s2 = peg$parseown_line_comment();\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f9(s1, s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parsetoken() {\n var s0, s1, s2, s3;\n s0 = peg$currPos;\n s1 = peg$currPos;\n s2 = peg$currPos;\n peg$silentFails++;\n s3 = peg$parsenon_token();\n peg$silentFails--;\n if (s3 === peg$FAILED) {\n s2 = void 0;\n } else {\n peg$currPos = s2;\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n if (input.length > peg$currPos) {\n s3 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s3 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n if (s3 !== peg$FAILED) {\n s2 = [s2, s3];\n s1 = s2;\n } else {\n peg$currPos = s1;\n s1 = peg$FAILED;\n }\n } else {\n peg$currPos = s1;\n s1 = peg$FAILED;\n }\n if (s1 !== peg$FAILED) {\n s0 = input.substring(s0, peg$currPos);\n } else {\n s0 = s1;\n }\n return s0;\n }\n function peg$parsenon_whitespace_non_parbreak_token() {\n var s0, s1, s2, s3;\n s0 = peg$currPos;\n s1 = peg$currPos;\n s2 = peg$currPos;\n peg$silentFails++;\n s3 = peg$parsewhitespace();\n if (s3 === peg$FAILED) {\n s3 = peg$parseparbreak();\n }\n peg$silentFails--;\n if (s3 === peg$FAILED) {\n s2 = void 0;\n } else {\n peg$currPos = s2;\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n s3 = peg$parseparen_block();\n if (s3 === peg$FAILED) {\n s3 = peg$parsetoken();\n }\n if (s3 !== peg$FAILED) {\n s2 = [s2, s3];\n s1 = s2;\n } else {\n peg$currPos = s1;\n s1 = peg$FAILED;\n }\n } else {\n peg$currPos = s1;\n s1 = peg$FAILED;\n }\n if (s1 !== peg$FAILED) {\n s0 = input.substring(s0, peg$currPos);\n } else {\n s0 = s1;\n }\n return s0;\n }\n function peg$parsenon_token() {\n var s0;\n s0 = peg$parseitem_sep();\n if (s0 === peg$FAILED) {\n s0 = peg$parseequals();\n if (s0 === peg$FAILED) {\n s0 = peg$parsetrailing_comment();\n if (s0 === peg$FAILED) {\n s0 = peg$parseown_line_comment();\n }\n }\n }\n return s0;\n }\n function peg$parsewhitespace_or_parbreaks() {\n var s0, s1, s2;\n s0 = peg$currPos;\n s1 = [];\n s2 = peg$parsewhitespace();\n if (s2 === peg$FAILED) {\n s2 = peg$parseparbreak();\n }\n while (s2 !== peg$FAILED) {\n s1.push(s2);\n s2 = peg$parsewhitespace();\n if (s2 === peg$FAILED) {\n s2 = peg$parseparbreak();\n }\n }\n peg$savedPos = s0;\n s1 = peg$f10(s1);\n s0 = s1;\n return s0;\n }\n function peg$parseparen_block() {\n var s0, s1, s2, s3, s4, s5, s6, s7, s8;\n s0 = peg$currPos;\n peg$savedPos = peg$currPos;\n s1 = peg$f11();\n if (s1) {\n s1 = peg$FAILED;\n } else {\n s1 = void 0;\n }\n if (s1 !== peg$FAILED) {\n s2 = peg$currPos;\n s3 = peg$currPos;\n s4 = peg$parseopen_paren();\n if (s4 !== peg$FAILED) {\n s5 = [];\n s6 = peg$currPos;\n s7 = peg$currPos;\n peg$silentFails++;\n s8 = peg$parseclose_paren();\n peg$silentFails--;\n if (s8 === peg$FAILED) {\n s7 = void 0;\n } else {\n peg$currPos = s7;\n s7 = peg$FAILED;\n }\n if (s7 !== peg$FAILED) {\n if (input.length > peg$currPos) {\n s8 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s8 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n if (s8 !== peg$FAILED) {\n s7 = [s7, s8];\n s6 = s7;\n } else {\n peg$currPos = s6;\n s6 = peg$FAILED;\n }\n } else {\n peg$currPos = s6;\n s6 = peg$FAILED;\n }\n while (s6 !== peg$FAILED) {\n s5.push(s6);\n s6 = peg$currPos;\n s7 = peg$currPos;\n peg$silentFails++;\n s8 = peg$parseclose_paren();\n peg$silentFails--;\n if (s8 === peg$FAILED) {\n s7 = void 0;\n } else {\n peg$currPos = s7;\n s7 = peg$FAILED;\n }\n if (s7 !== peg$FAILED) {\n if (input.length > peg$currPos) {\n s8 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s8 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n if (s8 !== peg$FAILED) {\n s7 = [s7, s8];\n s6 = s7;\n } else {\n peg$currPos = s6;\n s6 = peg$FAILED;\n }\n } else {\n peg$currPos = s6;\n s6 = peg$FAILED;\n }\n }\n s6 = peg$parseclose_paren();\n if (s6 !== peg$FAILED) {\n s4 = [s4, s5, s6];\n s3 = s4;\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n if (s3 !== peg$FAILED) {\n s2 = input.substring(s2, peg$currPos);\n } else {\n s2 = s3;\n }\n if (s2 !== peg$FAILED) {\n s1 = [s1, s2];\n s0 = s1;\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parsesame_line_comment() {\n var s0, s1, s2;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f12(s1);\n if (s2) {\n s2 = void 0;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f13(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parseown_line_comment() {\n var s0, s1, s2;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f14(s1);\n if (s2) {\n s2 = void 0;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f15(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parsewhitespace() {\n var s0, s1, s2;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f16(s1);\n if (s2) {\n s2 = void 0;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f17(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parseparbreak() {\n var s0, s1, s2;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f18(s1);\n if (s2) {\n s2 = void 0;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f19(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parseitem_sep() {\n var s0, s1, s2;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f20(s1);\n if (s2) {\n s2 = void 0;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f21(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parseequals() {\n var s0, s1, s2;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f22(s1);\n if (s2) {\n s2 = void 0;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f23(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parseopen_paren() {\n var s0, s1, s2;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f24(s1);\n if (s2) {\n s2 = void 0;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f25(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parseclose_paren() {\n var s0, s1, s2;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f26(s1);\n if (s2) {\n s2 = void 0;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f27(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parseEOL() {\n var s0, s1;\n s0 = peg$currPos;\n peg$silentFails++;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n peg$silentFails--;\n if (s1 === peg$FAILED) {\n s0 = void 0;\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function processItem(leadCell, otherCells) {\n const cells = [leadCell || []];\n for (const x of otherCells) {\n cells.push(x.cell || []);\n }\n return { itemParts: cells };\n }\n if (!options.isWhitespace) {\n try {\n Object.assign(options, {\n isChar: (node, char) => node.type === \"string\" && node.content === char,\n isComma(node) {\n return node.type === \"string\" && node.content === \",\";\n },\n isEquals(node) {\n return node.type === \"string\" && node.content === \"=\";\n },\n isParbreak(node) {\n return node.type === \"parbreak\";\n },\n isWhitespace(node) {\n return node.type === \"whitespace\";\n },\n isSameLineComment: (node) => node.type === \"comment\" && node.sameline,\n isOwnLineComment: (node) => node.type === \"comment\" && !node.sameline,\n isComment: (node) => node.type === \"comment\",\n allowParenGroups: true\n });\n } catch (e) {\n console.warn(\"Error when initializing parser\", e);\n }\n }\n peg$result = peg$startRuleFunction();\n if (peg$result !== peg$FAILED && peg$currPos === input.length) {\n return peg$result;\n } else {\n if (peg$result !== peg$FAILED && peg$currPos < input.length) {\n peg$fail(peg$endExpectation());\n }\n throw peg$buildStructuredError(\n peg$maxFailExpected,\n peg$maxFailPos < input.length ? input.charAt(peg$maxFailPos) : null,\n peg$maxFailPos < input.length ? peg$computeLocation(peg$maxFailPos, peg$maxFailPos + 1) : peg$computeLocation(peg$maxFailPos, peg$maxFailPos)\n );\n }\n }\n return {\n SyntaxError: peg$SyntaxError,\n parse: peg$parse\n };\n }()\n);\n","export default (\n // Generated by Peggy 3.0.2.\n //\n // https://peggyjs.org/\n function() {\n \"use strict\";\n function peg$subclass(child, parent) {\n function C() {\n this.constructor = child;\n }\n C.prototype = parent.prototype;\n child.prototype = new C();\n }\n function peg$SyntaxError(message, expected, found, location) {\n var self = Error.call(this, message);\n if (Object.setPrototypeOf) {\n Object.setPrototypeOf(self, peg$SyntaxError.prototype);\n }\n self.expected = expected;\n self.found = found;\n self.location = location;\n self.name = \"SyntaxError\";\n return self;\n }\n peg$subclass(peg$SyntaxError, Error);\n function peg$padEnd(str, targetLength, padString) {\n padString = padString || \" \";\n if (str.length > targetLength) {\n return str;\n }\n targetLength -= str.length;\n padString += padString.repeat(targetLength);\n return str + padString.slice(0, targetLength);\n }\n peg$SyntaxError.prototype.format = function(sources) {\n var str = \"Error: \" + this.message;\n if (this.location) {\n var src = null;\n var k;\n for (k = 0; k < sources.length; k++) {\n if (sources[k].source === this.location.source) {\n src = sources[k].text.split(/\\r\\n|\\n|\\r/g);\n break;\n }\n }\n var s = this.location.start;\n var offset_s = this.location.source && typeof this.location.source.offset === \"function\" ? this.location.source.offset(s) : s;\n var loc = this.location.source + \":\" + offset_s.line + \":\" + offset_s.column;\n if (src) {\n var e = this.location.end;\n var filler = peg$padEnd(\"\", offset_s.line.toString().length, \" \");\n var line = src[s.line - 1];\n var last = s.line === e.line ? e.column : line.length + 1;\n var hatLen = last - s.column || 1;\n str += \"\\n --> \" + loc + \"\\n\" + filler + \" |\\n\" + offset_s.line + \" | \" + line + \"\\n\" + filler + \" | \" + peg$padEnd(\"\", s.column - 1, \" \") + peg$padEnd(\"\", hatLen, \"^\");\n } else {\n str += \"\\n at \" + loc;\n }\n }\n return str;\n };\n peg$SyntaxError.buildMessage = function(expected, found) {\n var DESCRIBE_EXPECTATION_FNS = {\n literal: function(expectation) {\n return '\"' + literalEscape(expectation.text) + '\"';\n },\n class: function(expectation) {\n var escapedParts = expectation.parts.map(function(part) {\n return Array.isArray(part) ? classEscape(part[0]) + \"-\" + classEscape(part[1]) : classEscape(part);\n });\n return \"[\" + (expectation.inverted ? \"^\" : \"\") + escapedParts.join(\"\") + \"]\";\n },\n any: function() {\n return \"any character\";\n },\n end: function() {\n return \"end of input\";\n },\n other: function(expectation) {\n return expectation.description;\n }\n };\n function hex(ch) {\n return ch.charCodeAt(0).toString(16).toUpperCase();\n }\n function literalEscape(s) {\n return s.replace(/\\\\/g, \"\\\\\\\\\").replace(/\"/g, '\\\\\"').replace(/\\0/g, \"\\\\0\").replace(/\\t/g, \"\\\\t\").replace(/\\n/g, \"\\\\n\").replace(/\\r/g, \"\\\\r\").replace(/[\\x00-\\x0F]/g, function(ch) {\n return \"\\\\x0\" + hex(ch);\n }).replace(/[\\x10-\\x1F\\x7F-\\x9F]/g, function(ch) {\n return \"\\\\x\" + hex(ch);\n });\n }\n function classEscape(s) {\n return s.replace(/\\\\/g, \"\\\\\\\\\").replace(/\\]/g, \"\\\\]\").replace(/\\^/g, \"\\\\^\").replace(/-/g, \"\\\\-\").replace(/\\0/g, \"\\\\0\").replace(/\\t/g, \"\\\\t\").replace(/\\n/g, \"\\\\n\").replace(/\\r/g, \"\\\\r\").replace(/[\\x00-\\x0F]/g, function(ch) {\n return \"\\\\x0\" + hex(ch);\n }).replace(/[\\x10-\\x1F\\x7F-\\x9F]/g, function(ch) {\n return \"\\\\x\" + hex(ch);\n });\n }\n function describeExpectation(expectation) {\n return DESCRIBE_EXPECTATION_FNS[expectation.type](expectation);\n }\n function describeExpected(expected2) {\n var descriptions = expected2.map(describeExpectation);\n var i, j;\n descriptions.sort();\n if (descriptions.length > 0) {\n for (i = 1, j = 1; i < descriptions.length; i++) {\n if (descriptions[i - 1] !== descriptions[i]) {\n descriptions[j] = descriptions[i];\n j++;\n }\n }\n descriptions.length = j;\n }\n switch (descriptions.length) {\n case 1:\n return descriptions[0];\n case 2:\n return descriptions[0] + \" or \" + descriptions[1];\n default:\n return descriptions.slice(0, -1).join(\", \") + \", or \" + descriptions[descriptions.length - 1];\n }\n }\n function describeFound(found2) {\n return found2 ? '\"' + literalEscape(found2) + '\"' : \"end of input\";\n }\n return \"Expected \" + describeExpected(expected) + \" but \" + describeFound(found) + \" found.\";\n };\n function peg$parse(input, options) {\n options = options !== void 0 ? options : {};\n var peg$FAILED = {};\n var peg$source = options.grammarSource;\n var peg$startRuleFunctions = { body: peg$parsebody };\n var peg$startRuleFunction = peg$parsebody;\n var peg$e0 = peg$anyExpectation();\n var peg$f0 = function(e) {\n return [].concat(...e).filter((n) => !!n);\n };\n var peg$f1 = function() {\n return [];\n };\n var peg$f2 = function(tok) {\n return options.isHash(tok);\n };\n var peg$f3 = function(tok) {\n return tok;\n };\n var peg$f4 = function(tok) {\n return options.isNumber(tok);\n };\n var peg$f5 = function(tok) {\n return tok;\n };\n var peg$f6 = function() {\n return { type: \"string\", content: \"#\" };\n };\n var peg$f7 = function(num) {\n const split = options.splitNumber(num);\n return [{ type: \"hash_number\", number: split.number }, split.rest];\n };\n var peg$currPos = 0;\n var peg$savedPos = 0;\n var peg$posDetailsCache = [{ line: 1, column: 1 }];\n var peg$maxFailPos = 0;\n var peg$maxFailExpected = [];\n var peg$silentFails = 0;\n var peg$result;\n if (\"startRule\" in options) {\n if (!(options.startRule in peg$startRuleFunctions)) {\n throw new Error(`Can't start parsing from rule \"` + options.startRule + '\".');\n }\n peg$startRuleFunction = peg$startRuleFunctions[options.startRule];\n }\n function text() {\n return input.substring(peg$savedPos, peg$currPos);\n }\n function offset() {\n return peg$savedPos;\n }\n function range() {\n return {\n source: peg$source,\n start: peg$savedPos,\n end: peg$currPos\n };\n }\n function location() {\n return peg$computeLocation(peg$savedPos, peg$currPos);\n }\n function expected(description, location2) {\n location2 = location2 !== void 0 ? location2 : peg$computeLocation(peg$savedPos, peg$currPos);\n throw peg$buildStructuredError(\n [peg$otherExpectation(description)],\n input.substring(peg$savedPos, peg$currPos),\n location2\n );\n }\n function error(message, location2) {\n location2 = location2 !== void 0 ? location2 : peg$computeLocation(peg$savedPos, peg$currPos);\n throw peg$buildSimpleError(message, location2);\n }\n function peg$literalExpectation(text2, ignoreCase) {\n return { type: \"literal\", text: text2, ignoreCase };\n }\n function peg$classExpectation(parts, inverted, ignoreCase) {\n return { type: \"class\", parts, inverted, ignoreCase };\n }\n function peg$anyExpectation() {\n return { type: \"any\" };\n }\n function peg$endExpectation() {\n return { type: \"end\" };\n }\n function peg$otherExpectation(description) {\n return { type: \"other\", description };\n }\n function peg$computePosDetails(pos) {\n var details = peg$posDetailsCache[pos];\n var p;\n if (details) {\n return details;\n } else {\n p = pos - 1;\n while (!peg$posDetailsCache[p]) {\n p--;\n }\n details = peg$posDetailsCache[p];\n details = {\n line: details.line,\n column: details.column\n };\n while (p < pos) {\n if (input.charCodeAt(p) === 10) {\n details.line++;\n details.column = 1;\n } else {\n details.column++;\n }\n p++;\n }\n peg$posDetailsCache[pos] = details;\n return details;\n }\n }\n function peg$computeLocation(startPos, endPos, offset2) {\n var startPosDetails = peg$computePosDetails(startPos);\n var endPosDetails = peg$computePosDetails(endPos);\n var res = {\n source: peg$source,\n start: {\n offset: startPos,\n line: startPosDetails.line,\n column: startPosDetails.column\n },\n end: {\n offset: endPos,\n line: endPosDetails.line,\n column: endPosDetails.column\n }\n };\n if (offset2 && peg$source && typeof peg$source.offset === \"function\") {\n res.start = peg$source.offset(res.start);\n res.end = peg$source.offset(res.end);\n }\n return res;\n }\n function peg$fail(expected2) {\n if (peg$currPos < peg$maxFailPos) {\n return;\n }\n if (peg$currPos > peg$maxFailPos) {\n peg$maxFailPos = peg$currPos;\n peg$maxFailExpected = [];\n }\n peg$maxFailExpected.push(expected2);\n }\n function peg$buildSimpleError(message, location2) {\n return new peg$SyntaxError(message, null, null, location2);\n }\n function peg$buildStructuredError(expected2, found, location2) {\n return new peg$SyntaxError(\n peg$SyntaxError.buildMessage(expected2, found),\n expected2,\n found,\n location2\n );\n }\n function peg$parsebody() {\n var s0, s1, s2;\n s0 = peg$currPos;\n s1 = [];\n s2 = peg$parsedouble_hash();\n if (s2 === peg$FAILED) {\n s2 = peg$parsehash_number();\n if (s2 === peg$FAILED) {\n if (input.length > peg$currPos) {\n s2 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s2 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n }\n }\n if (s2 !== peg$FAILED) {\n while (s2 !== peg$FAILED) {\n s1.push(s2);\n s2 = peg$parsedouble_hash();\n if (s2 === peg$FAILED) {\n s2 = peg$parsehash_number();\n if (s2 === peg$FAILED) {\n if (input.length > peg$currPos) {\n s2 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s2 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n }\n }\n }\n } else {\n s1 = peg$FAILED;\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = s0;\n s1 = peg$f0(s1);\n }\n s0 = s1;\n if (s0 === peg$FAILED) {\n s0 = peg$currPos;\n s1 = peg$parseEOL();\n if (s1 !== peg$FAILED) {\n peg$savedPos = s0;\n s1 = peg$f1();\n }\n s0 = s1;\n }\n return s0;\n }\n function peg$parsehash() {\n var s0, s1, s2;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f2(s1);\n if (s2) {\n s2 = void 0;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f3(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parsenumber() {\n var s0, s1, s2;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f4(s1);\n if (s2) {\n s2 = void 0;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f5(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parsedouble_hash() {\n var s0, s1, s2;\n s0 = peg$currPos;\n s1 = peg$parsehash();\n if (s1 !== peg$FAILED) {\n s2 = peg$parsehash();\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f6();\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parsehash_number() {\n var s0, s1, s2;\n s0 = peg$currPos;\n s1 = peg$parsehash();\n if (s1 !== peg$FAILED) {\n s2 = peg$parsenumber();\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f7(s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parseEOL() {\n var s0, s1;\n s0 = peg$currPos;\n peg$silentFails++;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n peg$silentFails--;\n if (s1 === peg$FAILED) {\n s0 = void 0;\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n if (!options.isHash) {\n try {\n Object.assign(options, {\n isHash: (node) => node.type === \"string\" && node.content === \"#\",\n isNumber: (node) => node.type === \"string\" && 0 < +node.content.charAt(0),\n splitNumber: (node) => {\n const number = +node.content.charAt(0);\n if (node.content.length > 1) {\n return {\n number,\n rest: {\n type: \"string\",\n content: node.content.slice(1)\n }\n };\n }\n return { number };\n }\n });\n } catch (e) {\n console.warn(\"Error when initializing parser\", e);\n }\n }\n peg$result = peg$startRuleFunction();\n if (peg$result !== peg$FAILED && peg$currPos === input.length) {\n return peg$result;\n } else {\n if (peg$result !== peg$FAILED && peg$currPos < input.length) {\n peg$fail(peg$endExpectation());\n }\n throw peg$buildStructuredError(\n peg$maxFailExpected,\n peg$maxFailPos < input.length ? input.charAt(peg$maxFailPos) : null,\n peg$maxFailPos < input.length ? peg$computeLocation(peg$maxFailPos, peg$maxFailPos + 1) : peg$computeLocation(peg$maxFailPos, peg$maxFailPos)\n );\n }\n }\n return {\n SyntaxError: peg$SyntaxError,\n parse: peg$parse\n };\n }()\n);\n","export default (\n // Generated by Peggy 3.0.2.\n //\n // https://peggyjs.org/\n function() {\n \"use strict\";\n function peg$subclass(child, parent) {\n function C() {\n this.constructor = child;\n }\n C.prototype = parent.prototype;\n child.prototype = new C();\n }\n function peg$SyntaxError(message, expected, found, location) {\n var self = Error.call(this, message);\n if (Object.setPrototypeOf) {\n Object.setPrototypeOf(self, peg$SyntaxError.prototype);\n }\n self.expected = expected;\n self.found = found;\n self.location = location;\n self.name = \"SyntaxError\";\n return self;\n }\n peg$subclass(peg$SyntaxError, Error);\n function peg$padEnd(str, targetLength, padString) {\n padString = padString || \" \";\n if (str.length > targetLength) {\n return str;\n }\n targetLength -= str.length;\n padString += padString.repeat(targetLength);\n return str + padString.slice(0, targetLength);\n }\n peg$SyntaxError.prototype.format = function(sources) {\n var str = \"Error: \" + this.message;\n if (this.location) {\n var src = null;\n var k;\n for (k = 0; k < sources.length; k++) {\n if (sources[k].source === this.location.source) {\n src = sources[k].text.split(/\\r\\n|\\n|\\r/g);\n break;\n }\n }\n var s = this.location.start;\n var offset_s = this.location.source && typeof this.location.source.offset === \"function\" ? this.location.source.offset(s) : s;\n var loc = this.location.source + \":\" + offset_s.line + \":\" + offset_s.column;\n if (src) {\n var e = this.location.end;\n var filler = peg$padEnd(\"\", offset_s.line.toString().length, \" \");\n var line = src[s.line - 1];\n var last = s.line === e.line ? e.column : line.length + 1;\n var hatLen = last - s.column || 1;\n str += \"\\n --> \" + loc + \"\\n\" + filler + \" |\\n\" + offset_s.line + \" | \" + line + \"\\n\" + filler + \" | \" + peg$padEnd(\"\", s.column - 1, \" \") + peg$padEnd(\"\", hatLen, \"^\");\n } else {\n str += \"\\n at \" + loc;\n }\n }\n return str;\n };\n peg$SyntaxError.buildMessage = function(expected, found) {\n var DESCRIBE_EXPECTATION_FNS = {\n literal: function(expectation) {\n return '\"' + literalEscape(expectation.text) + '\"';\n },\n class: function(expectation) {\n var escapedParts = expectation.parts.map(function(part) {\n return Array.isArray(part) ? classEscape(part[0]) + \"-\" + classEscape(part[1]) : classEscape(part);\n });\n return \"[\" + (expectation.inverted ? \"^\" : \"\") + escapedParts.join(\"\") + \"]\";\n },\n any: function() {\n return \"any character\";\n },\n end: function() {\n return \"end of input\";\n },\n other: function(expectation) {\n return expectation.description;\n }\n };\n function hex(ch) {\n return ch.charCodeAt(0).toString(16).toUpperCase();\n }\n function literalEscape(s) {\n return s.replace(/\\\\/g, \"\\\\\\\\\").replace(/\"/g, '\\\\\"').replace(/\\0/g, \"\\\\0\").replace(/\\t/g, \"\\\\t\").replace(/\\n/g, \"\\\\n\").replace(/\\r/g, \"\\\\r\").replace(/[\\x00-\\x0F]/g, function(ch) {\n return \"\\\\x0\" + hex(ch);\n }).replace(/[\\x10-\\x1F\\x7F-\\x9F]/g, function(ch) {\n return \"\\\\x\" + hex(ch);\n });\n }\n function classEscape(s) {\n return s.replace(/\\\\/g, \"\\\\\\\\\").replace(/\\]/g, \"\\\\]\").replace(/\\^/g, \"\\\\^\").replace(/-/g, \"\\\\-\").replace(/\\0/g, \"\\\\0\").replace(/\\t/g, \"\\\\t\").replace(/\\n/g, \"\\\\n\").replace(/\\r/g, \"\\\\r\").replace(/[\\x00-\\x0F]/g, function(ch) {\n return \"\\\\x0\" + hex(ch);\n }).replace(/[\\x10-\\x1F\\x7F-\\x9F]/g, function(ch) {\n return \"\\\\x\" + hex(ch);\n });\n }\n function describeExpectation(expectation) {\n return DESCRIBE_EXPECTATION_FNS[expectation.type](expectation);\n }\n function describeExpected(expected2) {\n var descriptions = expected2.map(describeExpectation);\n var i, j;\n descriptions.sort();\n if (descriptions.length > 0) {\n for (i = 1, j = 1; i < descriptions.length; i++) {\n if (descriptions[i - 1] !== descriptions[i]) {\n descriptions[j] = descriptions[i];\n j++;\n }\n }\n descriptions.length = j;\n }\n switch (descriptions.length) {\n case 1:\n return descriptions[0];\n case 2:\n return descriptions[0] + \" or \" + descriptions[1];\n default:\n return descriptions.slice(0, -1).join(\", \") + \", or \" + descriptions[descriptions.length - 1];\n }\n }\n function describeFound(found2) {\n return found2 ? '\"' + literalEscape(found2) + '\"' : \"end of input\";\n }\n return \"Expected \" + describeExpected(expected) + \" but \" + describeFound(found) + \" found.\";\n };\n function peg$parse(input, options) {\n options = options !== void 0 ? options : {};\n var peg$FAILED = {};\n var peg$source = options.grammarSource;\n var peg$startRuleFunctions = { body: peg$parsebody };\n var peg$startRuleFunction = peg$parsebody;\n var peg$e0 = peg$anyExpectation();\n var peg$f0 = function(e) {\n return [].concat(...e).filter((n) => !!n);\n };\n var peg$f1 = function() {\n return [];\n };\n var peg$f2 = function(toks) {\n return options.isRecognized(toks);\n };\n var peg$f3 = function(toks) {\n return options.isRecognized(toks);\n };\n var peg$f4 = function(tok1, tok2) {\n const split = options.split(tok2);\n return options.isRecognized([tok1, split[0]]);\n };\n var peg$f5 = function(tok1, tok2) {\n const split = options.split(tok2);\n return [options.isRecognized([tok1, split[0]]), split[1]];\n };\n var peg$f6 = function(tok1, tok2) {\n return options.isRecognized([tok1, tok2]);\n };\n var peg$f7 = function(tok1, tok2) {\n return options.isRecognized([tok1, tok2]);\n };\n var peg$f8 = function(toks) {\n return options.isRecognized(toks);\n };\n var peg$f9 = function(toks) {\n return options.isRecognized(toks);\n };\n var peg$f10 = function(tok) {\n return options.isRecognized([tok]);\n };\n var peg$f11 = function(tok) {\n return options.isRecognized([tok]);\n };\n var peg$f12 = function(tok) {\n return options.isMacro(tok);\n };\n var peg$f13 = function(tok) {\n return tok;\n };\n var peg$f14 = function(tok) {\n return options.isWhitespace(tok);\n };\n var peg$f15 = function(tok) {\n return tok;\n };\n var peg$f16 = function(tok) {\n return options.isSplitable(tok);\n };\n var peg$f17 = function(tok) {\n return tok;\n };\n var peg$currPos = 0;\n var peg$savedPos = 0;\n var peg$posDetailsCache = [{ line: 1, column: 1 }];\n var peg$maxFailPos = 0;\n var peg$maxFailExpected = [];\n var peg$silentFails = 0;\n var peg$result;\n if (\"startRule\" in options) {\n if (!(options.startRule in peg$startRuleFunctions)) {\n throw new Error(`Can't start parsing from rule \"` + options.startRule + '\".');\n }\n peg$startRuleFunction = peg$startRuleFunctions[options.startRule];\n }\n function text() {\n return input.substring(peg$savedPos, peg$currPos);\n }\n function offset() {\n return peg$savedPos;\n }\n function range() {\n return {\n source: peg$source,\n start: peg$savedPos,\n end: peg$currPos\n };\n }\n function location() {\n return peg$computeLocation(peg$savedPos, peg$currPos);\n }\n function expected(description, location2) {\n location2 = location2 !== void 0 ? location2 : peg$computeLocation(peg$savedPos, peg$currPos);\n throw peg$buildStructuredError(\n [peg$otherExpectation(description)],\n input.substring(peg$savedPos, peg$currPos),\n location2\n );\n }\n function error(message, location2) {\n location2 = location2 !== void 0 ? location2 : peg$computeLocation(peg$savedPos, peg$currPos);\n throw peg$buildSimpleError(message, location2);\n }\n function peg$literalExpectation(text2, ignoreCase) {\n return { type: \"literal\", text: text2, ignoreCase };\n }\n function peg$classExpectation(parts, inverted, ignoreCase) {\n return { type: \"class\", parts, inverted, ignoreCase };\n }\n function peg$anyExpectation() {\n return { type: \"any\" };\n }\n function peg$endExpectation() {\n return { type: \"end\" };\n }\n function peg$otherExpectation(description) {\n return { type: \"other\", description };\n }\n function peg$computePosDetails(pos) {\n var details = peg$posDetailsCache[pos];\n var p;\n if (details) {\n return details;\n } else {\n p = pos - 1;\n while (!peg$posDetailsCache[p]) {\n p--;\n }\n details = peg$posDetailsCache[p];\n details = {\n line: details.line,\n column: details.column\n };\n while (p < pos) {\n if (input.charCodeAt(p) === 10) {\n details.line++;\n details.column = 1;\n } else {\n details.column++;\n }\n p++;\n }\n peg$posDetailsCache[pos] = details;\n return details;\n }\n }\n function peg$computeLocation(startPos, endPos, offset2) {\n var startPosDetails = peg$computePosDetails(startPos);\n var endPosDetails = peg$computePosDetails(endPos);\n var res = {\n source: peg$source,\n start: {\n offset: startPos,\n line: startPosDetails.line,\n column: startPosDetails.column\n },\n end: {\n offset: endPos,\n line: endPosDetails.line,\n column: endPosDetails.column\n }\n };\n if (offset2 && peg$source && typeof peg$source.offset === \"function\") {\n res.start = peg$source.offset(res.start);\n res.end = peg$source.offset(res.end);\n }\n return res;\n }\n function peg$fail(expected2) {\n if (peg$currPos < peg$maxFailPos) {\n return;\n }\n if (peg$currPos > peg$maxFailPos) {\n peg$maxFailPos = peg$currPos;\n peg$maxFailExpected = [];\n }\n peg$maxFailExpected.push(expected2);\n }\n function peg$buildSimpleError(message, location2) {\n return new peg$SyntaxError(message, null, null, location2);\n }\n function peg$buildStructuredError(expected2, found, location2) {\n return new peg$SyntaxError(\n peg$SyntaxError.buildMessage(expected2, found),\n expected2,\n found,\n location2\n );\n }\n function peg$parsebody() {\n var s0, s1, s2;\n s0 = peg$currPos;\n s1 = [];\n s2 = peg$parsetriple_ligature();\n if (s2 === peg$FAILED) {\n s2 = peg$parsedouble_ligature();\n if (s2 === peg$FAILED) {\n s2 = peg$parsemono_ligature();\n if (s2 === peg$FAILED) {\n if (input.length > peg$currPos) {\n s2 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s2 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n }\n }\n }\n if (s2 !== peg$FAILED) {\n while (s2 !== peg$FAILED) {\n s1.push(s2);\n s2 = peg$parsetriple_ligature();\n if (s2 === peg$FAILED) {\n s2 = peg$parsedouble_ligature();\n if (s2 === peg$FAILED) {\n s2 = peg$parsemono_ligature();\n if (s2 === peg$FAILED) {\n if (input.length > peg$currPos) {\n s2 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s2 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n }\n }\n }\n }\n } else {\n s1 = peg$FAILED;\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = s0;\n s1 = peg$f0(s1);\n }\n s0 = s1;\n if (s0 === peg$FAILED) {\n s0 = peg$currPos;\n s1 = peg$parseEOL();\n if (s1 !== peg$FAILED) {\n peg$savedPos = s0;\n s1 = peg$f1();\n }\n s0 = s1;\n }\n return s0;\n }\n function peg$parsetriple_ligature() {\n var s0, s1, s2, s3, s4;\n s0 = peg$currPos;\n s1 = peg$currPos;\n if (input.length > peg$currPos) {\n s2 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s2 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n if (s2 !== peg$FAILED) {\n if (input.length > peg$currPos) {\n s3 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s3 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n if (s3 !== peg$FAILED) {\n if (input.length > peg$currPos) {\n s4 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s4 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n if (s4 !== peg$FAILED) {\n s2 = [s2, s3, s4];\n s1 = s2;\n } else {\n peg$currPos = s1;\n s1 = peg$FAILED;\n }\n } else {\n peg$currPos = s1;\n s1 = peg$FAILED;\n }\n } else {\n peg$currPos = s1;\n s1 = peg$FAILED;\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f2(s1);\n if (s2) {\n s2 = void 0;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f3(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parsedouble_ligature() {\n var s0;\n s0 = peg$parsedouble_macro_ligature();\n if (s0 === peg$FAILED) {\n s0 = peg$parsedouble_macro_ligature_extracted();\n if (s0 === peg$FAILED) {\n s0 = peg$parsedouble_char_ligature();\n }\n }\n return s0;\n }\n function peg$parsedouble_macro_ligature_extracted() {\n var s0, s1, s2, s3, s4;\n s0 = peg$currPos;\n s1 = peg$parsemacro();\n if (s1 !== peg$FAILED) {\n s2 = [];\n s3 = peg$parsewhitespace();\n while (s3 !== peg$FAILED) {\n s2.push(s3);\n s3 = peg$parsewhitespace();\n }\n s3 = peg$parsesplitable();\n if (s3 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s4 = peg$f4(s1, s3);\n if (s4) {\n s4 = void 0;\n } else {\n s4 = peg$FAILED;\n }\n if (s4 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f5(s1, s3);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parsedouble_macro_ligature() {\n var s0, s1, s2, s3, s4;\n s0 = peg$currPos;\n s1 = peg$parsemacro();\n if (s1 !== peg$FAILED) {\n s2 = [];\n s3 = peg$parsewhitespace();\n while (s3 !== peg$FAILED) {\n s2.push(s3);\n s3 = peg$parsewhitespace();\n }\n if (input.length > peg$currPos) {\n s3 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s3 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n if (s3 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s4 = peg$f6(s1, s3);\n if (s4) {\n s4 = void 0;\n } else {\n s4 = peg$FAILED;\n }\n if (s4 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f7(s1, s3);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parsedouble_char_ligature() {\n var s0, s1, s2, s3;\n s0 = peg$currPos;\n s1 = peg$currPos;\n if (input.length > peg$currPos) {\n s2 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s2 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n if (s2 !== peg$FAILED) {\n if (input.length > peg$currPos) {\n s3 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s3 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n if (s3 !== peg$FAILED) {\n s2 = [s2, s3];\n s1 = s2;\n } else {\n peg$currPos = s1;\n s1 = peg$FAILED;\n }\n } else {\n peg$currPos = s1;\n s1 = peg$FAILED;\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f8(s1);\n if (s2) {\n s2 = void 0;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f9(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parsemono_ligature() {\n var s0, s1, s2;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f10(s1);\n if (s2) {\n s2 = void 0;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f11(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parsemacro() {\n var s0, s1, s2;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f12(s1);\n if (s2) {\n s2 = void 0;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f13(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parsewhitespace() {\n var s0, s1, s2;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f14(s1);\n if (s2) {\n s2 = void 0;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f15(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parsesplitable() {\n var s0, s1, s2;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f16(s1);\n if (s2) {\n s2 = void 0;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f17(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parseEOL() {\n var s0, s1;\n s0 = peg$currPos;\n peg$silentFails++;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n peg$silentFails--;\n if (s1 === peg$FAILED) {\n s0 = void 0;\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n if (!options.isWhitespace) {\n try {\n Object.assign(options, {\n isMacro: (node) => node.type === \"macro\",\n isWhitespace: (node) => node.type === \"whitespace\",\n isRecognized: (nodes) => {\n if (nodes.length == 2 && nodes[0].content === \"^\" && nodes[1].content === \"o\") {\n return { type: \"string\", content: \"\\xF4\" };\n }\n return null;\n },\n isSplitable: (node) => node.type === \"string\" && node.content.length > 1,\n split: (node) => [\n { type: \"string\", content: node.content.charAt(0) },\n { type: \"string\", content: node.content.slice(1) }\n ]\n });\n } catch (e) {\n console.warn(\"Error when initializing parser\", e);\n }\n }\n peg$result = peg$startRuleFunction();\n if (peg$result !== peg$FAILED && peg$currPos === input.length) {\n return peg$result;\n } else {\n if (peg$result !== peg$FAILED && peg$currPos < input.length) {\n peg$fail(peg$endExpectation());\n }\n throw peg$buildStructuredError(\n peg$maxFailExpected,\n peg$maxFailPos < input.length ? input.charAt(peg$maxFailPos) : null,\n peg$maxFailPos < input.length ? peg$computeLocation(peg$maxFailPos, peg$maxFailPos + 1) : peg$computeLocation(peg$maxFailPos, peg$maxFailPos)\n );\n }\n }\n return {\n SyntaxError: peg$SyntaxError,\n parse: peg$parse\n };\n }()\n);\n","export default (\n // Generated by Peggy 3.0.2.\n //\n // https://peggyjs.org/\n function() {\n \"use strict\";\n function peg$subclass(child, parent) {\n function C() {\n this.constructor = child;\n }\n C.prototype = parent.prototype;\n child.prototype = new C();\n }\n function peg$SyntaxError(message, expected, found, location) {\n var self = Error.call(this, message);\n if (Object.setPrototypeOf) {\n Object.setPrototypeOf(self, peg$SyntaxError.prototype);\n }\n self.expected = expected;\n self.found = found;\n self.location = location;\n self.name = \"SyntaxError\";\n return self;\n }\n peg$subclass(peg$SyntaxError, Error);\n function peg$padEnd(str, targetLength, padString) {\n padString = padString || \" \";\n if (str.length > targetLength) {\n return str;\n }\n targetLength -= str.length;\n padString += padString.repeat(targetLength);\n return str + padString.slice(0, targetLength);\n }\n peg$SyntaxError.prototype.format = function(sources) {\n var str = \"Error: \" + this.message;\n if (this.location) {\n var src = null;\n var k;\n for (k = 0; k < sources.length; k++) {\n if (sources[k].source === this.location.source) {\n src = sources[k].text.split(/\\r\\n|\\n|\\r/g);\n break;\n }\n }\n var s = this.location.start;\n var offset_s = this.location.source && typeof this.location.source.offset === \"function\" ? this.location.source.offset(s) : s;\n var loc = this.location.source + \":\" + offset_s.line + \":\" + offset_s.column;\n if (src) {\n var e = this.location.end;\n var filler = peg$padEnd(\"\", offset_s.line.toString().length, \" \");\n var line = src[s.line - 1];\n var last = s.line === e.line ? e.column : line.length + 1;\n var hatLen = last - s.column || 1;\n str += \"\\n --> \" + loc + \"\\n\" + filler + \" |\\n\" + offset_s.line + \" | \" + line + \"\\n\" + filler + \" | \" + peg$padEnd(\"\", s.column - 1, \" \") + peg$padEnd(\"\", hatLen, \"^\");\n } else {\n str += \"\\n at \" + loc;\n }\n }\n return str;\n };\n peg$SyntaxError.buildMessage = function(expected, found) {\n var DESCRIBE_EXPECTATION_FNS = {\n literal: function(expectation) {\n return '\"' + literalEscape(expectation.text) + '\"';\n },\n class: function(expectation) {\n var escapedParts = expectation.parts.map(function(part) {\n return Array.isArray(part) ? classEscape(part[0]) + \"-\" + classEscape(part[1]) : classEscape(part);\n });\n return \"[\" + (expectation.inverted ? \"^\" : \"\") + escapedParts.join(\"\") + \"]\";\n },\n any: function() {\n return \"any character\";\n },\n end: function() {\n return \"end of input\";\n },\n other: function(expectation) {\n return expectation.description;\n }\n };\n function hex(ch) {\n return ch.charCodeAt(0).toString(16).toUpperCase();\n }\n function literalEscape(s) {\n return s.replace(/\\\\/g, \"\\\\\\\\\").replace(/\"/g, '\\\\\"').replace(/\\0/g, \"\\\\0\").replace(/\\t/g, \"\\\\t\").replace(/\\n/g, \"\\\\n\").replace(/\\r/g, \"\\\\r\").replace(/[\\x00-\\x0F]/g, function(ch) {\n return \"\\\\x0\" + hex(ch);\n }).replace(/[\\x10-\\x1F\\x7F-\\x9F]/g, function(ch) {\n return \"\\\\x\" + hex(ch);\n });\n }\n function classEscape(s) {\n return s.replace(/\\\\/g, \"\\\\\\\\\").replace(/\\]/g, \"\\\\]\").replace(/\\^/g, \"\\\\^\").replace(/-/g, \"\\\\-\").replace(/\\0/g, \"\\\\0\").replace(/\\t/g, \"\\\\t\").replace(/\\n/g, \"\\\\n\").replace(/\\r/g, \"\\\\r\").replace(/[\\x00-\\x0F]/g, function(ch) {\n return \"\\\\x0\" + hex(ch);\n }).replace(/[\\x10-\\x1F\\x7F-\\x9F]/g, function(ch) {\n return \"\\\\x\" + hex(ch);\n });\n }\n function describeExpectation(expectation) {\n return DESCRIBE_EXPECTATION_FNS[expectation.type](expectation);\n }\n function describeExpected(expected2) {\n var descriptions = expected2.map(describeExpectation);\n var i, j;\n descriptions.sort();\n if (descriptions.length > 0) {\n for (i = 1, j = 1; i < descriptions.length; i++) {\n if (descriptions[i - 1] !== descriptions[i]) {\n descriptions[j] = descriptions[i];\n j++;\n }\n }\n descriptions.length = j;\n }\n switch (descriptions.length) {\n case 1:\n return descriptions[0];\n case 2:\n return descriptions[0] + \" or \" + descriptions[1];\n default:\n return descriptions.slice(0, -1).join(\", \") + \", or \" + descriptions[descriptions.length - 1];\n }\n }\n function describeFound(found2) {\n return found2 ? '\"' + literalEscape(found2) + '\"' : \"end of input\";\n }\n return \"Expected \" + describeExpected(expected) + \" but \" + describeFound(found) + \" found.\";\n };\n function peg$parse(input, options) {\n options = options !== void 0 ? options : {};\n var peg$FAILED = {};\n var peg$source = options.grammarSource;\n var peg$startRuleFunctions = { start: peg$parsestart };\n var peg$startRuleFunction = peg$parsestart;\n var peg$c0 = \";\";\n var peg$c1 = \",\";\n var peg$c2 = \":\";\n var peg$c3 = \"/\";\n var peg$c4 = \">\";\n var peg$c5 = \"!\";\n var peg$c6 = \".\";\n var peg$c7 = \"!![\";\n var peg$c8 = \"]\";\n var peg$c9 = \"!!\";\n var peg$c10 = \"+\";\n var peg$c11 = \"-\";\n var peg$r0 = /^[a-zA-Z0-9]/;\n var peg$r1 = /^[0-9]/;\n var peg$r2 = /^[ \\t\\n\\r]/;\n var peg$r3 = /^[0-9a-fA-F]/;\n var peg$e0 = peg$anyExpectation();\n var peg$e1 = peg$literalExpectation(\";\", false);\n var peg$e2 = peg$literalExpectation(\",\", false);\n var peg$e3 = peg$otherExpectation(\"model list\");\n var peg$e4 = peg$literalExpectation(\":\", false);\n var peg$e5 = peg$literalExpectation(\"/\", false);\n var peg$e6 = peg$otherExpectation(\"model\");\n var peg$e7 = peg$otherExpectation(\"color spec list\");\n var peg$e8 = peg$otherExpectation(\"color spec\");\n var peg$e9 = peg$otherExpectation(\"color\");\n var peg$e10 = peg$otherExpectation(\"function expression\");\n var peg$e11 = peg$literalExpectation(\">\", false);\n var peg$e12 = peg$otherExpectation(\"function\");\n var peg$e13 = peg$otherExpectation(\"extended expression\");\n var peg$e14 = peg$otherExpectation(\"core model\");\n var peg$e15 = peg$otherExpectation(\"expr\");\n var peg$e16 = peg$literalExpectation(\"!\", false);\n var peg$e17 = peg$otherExpectation(\"mix expr\");\n var peg$e18 = peg$otherExpectation(\"name\");\n var peg$e19 = peg$literalExpectation(\".\", false);\n var peg$e20 = peg$classExpectation([[\"a\", \"z\"], [\"A\", \"Z\"], [\"0\", \"9\"]], false, false);\n var peg$e21 = peg$otherExpectation(\"postfix\");\n var peg$e22 = peg$literalExpectation(\"!![\", false);\n var peg$e23 = peg$literalExpectation(\"]\", false);\n var peg$e24 = peg$literalExpectation(\"!!\", false);\n var peg$e25 = peg$otherExpectation(\"prefix\");\n var peg$e26 = peg$otherExpectation(\"plus\");\n var peg$e27 = peg$literalExpectation(\"+\", false);\n var peg$e28 = peg$otherExpectation(\"minus\");\n var peg$e29 = peg$literalExpectation(\"-\", false);\n var peg$e30 = peg$otherExpectation(\"num\");\n var peg$e31 = peg$classExpectation([[\"0\", \"9\"]], false, false);\n var peg$e32 = peg$otherExpectation(\"positive float\");\n var peg$e33 = peg$otherExpectation(\"divisor\");\n var peg$e34 = peg$otherExpectation(\"int\");\n var peg$e35 = peg$otherExpectation(\"whitespace\");\n var peg$e36 = peg$classExpectation([\" \", \"\t\", \"\\n\", \"\\r\"], false, false);\n var peg$e37 = peg$classExpectation([[\"0\", \"9\"], [\"a\", \"f\"], [\"A\", \"F\"]], false, false);\n var peg$f0 = function(m) {\n return m;\n };\n var peg$f1 = function(m) {\n return m;\n };\n var peg$f2 = function(m) {\n return m;\n };\n var peg$f3 = function(m) {\n return m;\n };\n var peg$f4 = function(m) {\n return m;\n };\n var peg$f5 = function(a) {\n return { type: \"invalid_spec\", content: a };\n };\n var peg$f6 = function(f, c) {\n return c;\n };\n var peg$f7 = function(f, r) {\n return { type: \"color_set\", content: [f].concat(r) };\n };\n var peg$f8 = function(n, s) {\n return { type: \"color_set_item\", name: n, spec_list: s };\n };\n var peg$f9 = function(c, m) {\n return { type: \"model_list\", contents: m, core_model: c };\n };\n var peg$f10 = function(m) {\n return { type: \"model_list\", contents: m, core_model: null };\n };\n var peg$f11 = function(m, a) {\n return a;\n };\n var peg$f12 = function(m, r) {\n return [m].concat(r);\n };\n var peg$f13 = function(s, a) {\n return a;\n };\n var peg$f14 = function(s, r) {\n return { type: \"spec_list\", content: [s].concat(r) };\n };\n var peg$f15 = function(c) {\n return { type: \"hex_spec\", content: [c] };\n };\n var peg$f16 = function(c, d) {\n return d;\n };\n var peg$f17 = function(c, d) {\n return d;\n };\n var peg$f18 = function(c, r) {\n return { type: \"num_spec\", content: r ? [c].concat(r) : [c] };\n };\n var peg$f19 = function(c, fs) {\n return { type: \"color\", color: c, functions: fs };\n };\n var peg$f20 = function(f, n) {\n return n;\n };\n var peg$f21 = function(f, args) {\n return { type: \"function\", name: f, args };\n };\n var peg$f22 = function(core, d, e, es) {\n return {\n type: \"extended_expr\",\n core_model: core,\n div: d,\n expressions: [e].concat(es)\n };\n };\n var peg$f23 = function(core, e, es) {\n return {\n type: \"extended_expr\",\n core_model: core,\n div: null,\n expressions: [e].concat(es)\n };\n };\n var peg$f24 = function(e, d) {\n return { type: \"weighted_expr\", color: e, weight: d };\n };\n var peg$f25 = function(e) {\n return e;\n };\n var peg$f26 = function(p, n, e, po) {\n return {\n type: \"expr\",\n prefix: p,\n name: n,\n mix_expr: e,\n postfix: po\n };\n };\n var peg$f27 = function(p, n) {\n return { type: \"complete_mix\", mix_percent: p, name: n };\n };\n var peg$f28 = function(p) {\n return { type: \"partial_mix\", mix_percent: p };\n };\n var peg$f29 = function(c, p) {\n return c.concat(p || []);\n };\n var peg$f30 = function(n) {\n return { type: \"postfix\", num: n };\n };\n var peg$f31 = function(p) {\n return { type: \"postfix\", plusses: p };\n };\n var peg$f32 = function(n) {\n return parseInt(n, 10);\n };\n var peg$f33 = function(n) {\n return parseFloat(n);\n };\n var peg$f34 = function(n) {\n return n;\n };\n var peg$f35 = function(n) {\n return -n;\n };\n var peg$f36 = function(m, n) {\n return m ? -n : n;\n };\n var peg$f37 = function(h) {\n return h.toUpperCase();\n };\n var peg$currPos = 0;\n var peg$savedPos = 0;\n var peg$posDetailsCache = [{ line: 1, column: 1 }];\n var peg$maxFailPos = 0;\n var peg$maxFailExpected = [];\n var peg$silentFails = 0;\n var peg$result;\n if (\"startRule\" in options) {\n if (!(options.startRule in peg$startRuleFunctions)) {\n throw new Error(`Can't start parsing from rule \"` + options.startRule + '\".');\n }\n peg$startRuleFunction = peg$startRuleFunctions[options.startRule];\n }\n function text() {\n return input.substring(peg$savedPos, peg$currPos);\n }\n function offset() {\n return peg$savedPos;\n }\n function range() {\n return {\n source: peg$source,\n start: peg$savedPos,\n end: peg$currPos\n };\n }\n function location() {\n return peg$computeLocation(peg$savedPos, peg$currPos);\n }\n function expected(description, location2) {\n location2 = location2 !== void 0 ? location2 : peg$computeLocation(peg$savedPos, peg$currPos);\n throw peg$buildStructuredError(\n [peg$otherExpectation(description)],\n input.substring(peg$savedPos, peg$currPos),\n location2\n );\n }\n function error(message, location2) {\n location2 = location2 !== void 0 ? location2 : peg$computeLocation(peg$savedPos, peg$currPos);\n throw peg$buildSimpleError(message, location2);\n }\n function peg$literalExpectation(text2, ignoreCase) {\n return { type: \"literal\", text: text2, ignoreCase };\n }\n function peg$classExpectation(parts, inverted, ignoreCase) {\n return { type: \"class\", parts, inverted, ignoreCase };\n }\n function peg$anyExpectation() {\n return { type: \"any\" };\n }\n function peg$endExpectation() {\n return { type: \"end\" };\n }\n function peg$otherExpectation(description) {\n return { type: \"other\", description };\n }\n function peg$computePosDetails(pos) {\n var details = peg$posDetailsCache[pos];\n var p;\n if (details) {\n return details;\n } else {\n p = pos - 1;\n while (!peg$posDetailsCache[p]) {\n p--;\n }\n details = peg$posDetailsCache[p];\n details = {\n line: details.line,\n column: details.column\n };\n while (p < pos) {\n if (input.charCodeAt(p) === 10) {\n details.line++;\n details.column = 1;\n } else {\n details.column++;\n }\n p++;\n }\n peg$posDetailsCache[pos] = details;\n return details;\n }\n }\n function peg$computeLocation(startPos, endPos, offset2) {\n var startPosDetails = peg$computePosDetails(startPos);\n var endPosDetails = peg$computePosDetails(endPos);\n var res = {\n source: peg$source,\n start: {\n offset: startPos,\n line: startPosDetails.line,\n column: startPosDetails.column\n },\n end: {\n offset: endPos,\n line: endPosDetails.line,\n column: endPosDetails.column\n }\n };\n if (offset2 && peg$source && typeof peg$source.offset === \"function\") {\n res.start = peg$source.offset(res.start);\n res.end = peg$source.offset(res.end);\n }\n return res;\n }\n function peg$fail(expected2) {\n if (peg$currPos < peg$maxFailPos) {\n return;\n }\n if (peg$currPos > peg$maxFailPos) {\n peg$maxFailPos = peg$currPos;\n peg$maxFailExpected = [];\n }\n peg$maxFailExpected.push(expected2);\n }\n function peg$buildSimpleError(message, location2) {\n return new peg$SyntaxError(message, null, null, location2);\n }\n function peg$buildStructuredError(expected2, found, location2) {\n return new peg$SyntaxError(\n peg$SyntaxError.buildMessage(expected2, found),\n expected2,\n found,\n location2\n );\n }\n function peg$parsestart() {\n var s0, s1, s2, s3;\n s0 = peg$currPos;\n s1 = peg$parsespec();\n if (s1 !== peg$FAILED) {\n s2 = peg$parseEOL();\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f0(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n if (s0 === peg$FAILED) {\n s0 = peg$currPos;\n s1 = peg$parsespec_list();\n if (s1 !== peg$FAILED) {\n s2 = peg$parseEOL();\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f1(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n if (s0 === peg$FAILED) {\n s0 = peg$currPos;\n s1 = peg$parsecolor();\n if (s1 !== peg$FAILED) {\n s2 = peg$parseEOL();\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f2(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n if (s0 === peg$FAILED) {\n s0 = peg$currPos;\n s1 = peg$parsemodel_list();\n if (s1 !== peg$FAILED) {\n s2 = peg$parseEOL();\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f3(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n if (s0 === peg$FAILED) {\n s0 = peg$currPos;\n s1 = peg$parsecolor_set_spec();\n if (s1 !== peg$FAILED) {\n s2 = peg$parseEOL();\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f4(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n if (s0 === peg$FAILED) {\n s0 = peg$currPos;\n s1 = peg$currPos;\n s2 = [];\n if (input.length > peg$currPos) {\n s3 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s3 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n while (s3 !== peg$FAILED) {\n s2.push(s3);\n if (input.length > peg$currPos) {\n s3 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s3 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n }\n s1 = input.substring(s1, peg$currPos);\n peg$savedPos = s0;\n s1 = peg$f5(s1);\n s0 = s1;\n }\n }\n }\n }\n }\n return s0;\n }\n function peg$parsecolor_set_spec() {\n var s0, s1, s2, s3, s4, s5;\n s0 = peg$currPos;\n s1 = peg$parsecolor_set_item();\n if (s1 !== peg$FAILED) {\n s2 = [];\n s3 = peg$currPos;\n if (input.charCodeAt(peg$currPos) === 59) {\n s4 = peg$c0;\n peg$currPos++;\n } else {\n s4 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e1);\n }\n }\n if (s4 !== peg$FAILED) {\n s5 = peg$parsecolor_set_item();\n if (s5 !== peg$FAILED) {\n peg$savedPos = s3;\n s3 = peg$f6(s1, s5);\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n while (s3 !== peg$FAILED) {\n s2.push(s3);\n s3 = peg$currPos;\n if (input.charCodeAt(peg$currPos) === 59) {\n s4 = peg$c0;\n peg$currPos++;\n } else {\n s4 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e1);\n }\n }\n if (s4 !== peg$FAILED) {\n s5 = peg$parsecolor_set_item();\n if (s5 !== peg$FAILED) {\n peg$savedPos = s3;\n s3 = peg$f6(s1, s5);\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n }\n peg$savedPos = s0;\n s0 = peg$f7(s1, s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parsecolor_set_item() {\n var s0, s1, s2, s3;\n s0 = peg$currPos;\n s1 = peg$parsename();\n if (s1 !== peg$FAILED) {\n if (input.charCodeAt(peg$currPos) === 44) {\n s2 = peg$c1;\n peg$currPos++;\n } else {\n s2 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e2);\n }\n }\n if (s2 !== peg$FAILED) {\n s3 = peg$parsespec_list();\n if (s3 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f8(s1, s3);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parsemodel_list() {\n var s0, s1, s2, s3;\n peg$silentFails++;\n s0 = peg$currPos;\n s1 = peg$parsecore_model();\n if (s1 !== peg$FAILED) {\n if (input.charCodeAt(peg$currPos) === 58) {\n s2 = peg$c2;\n peg$currPos++;\n } else {\n s2 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e4);\n }\n }\n if (s2 !== peg$FAILED) {\n s3 = peg$parsemodel_list_tail();\n if (s3 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f9(s1, s3);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n if (s0 === peg$FAILED) {\n s0 = peg$currPos;\n s1 = peg$parsemodel_list_tail();\n if (s1 !== peg$FAILED) {\n peg$savedPos = s0;\n s1 = peg$f10(s1);\n }\n s0 = s1;\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e3);\n }\n }\n return s0;\n }\n function peg$parsemodel_list_tail() {\n var s0, s1, s2, s3, s4, s5;\n s0 = peg$currPos;\n s1 = peg$parsemodel();\n if (s1 !== peg$FAILED) {\n s2 = [];\n s3 = peg$currPos;\n if (input.charCodeAt(peg$currPos) === 47) {\n s4 = peg$c3;\n peg$currPos++;\n } else {\n s4 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e5);\n }\n }\n if (s4 !== peg$FAILED) {\n s5 = peg$parsemodel();\n if (s5 !== peg$FAILED) {\n peg$savedPos = s3;\n s3 = peg$f11(s1, s5);\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n while (s3 !== peg$FAILED) {\n s2.push(s3);\n s3 = peg$currPos;\n if (input.charCodeAt(peg$currPos) === 47) {\n s4 = peg$c3;\n peg$currPos++;\n } else {\n s4 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e5);\n }\n }\n if (s4 !== peg$FAILED) {\n s5 = peg$parsemodel();\n if (s5 !== peg$FAILED) {\n peg$savedPos = s3;\n s3 = peg$f11(s1, s5);\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n }\n peg$savedPos = s0;\n s0 = peg$f12(s1, s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parsemodel() {\n var s0, s1;\n peg$silentFails++;\n s0 = peg$parsecore_model();\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e6);\n }\n }\n return s0;\n }\n function peg$parsespec_list() {\n var s0, s1, s2, s3, s4, s5;\n peg$silentFails++;\n s0 = peg$currPos;\n s1 = peg$parsespec();\n if (s1 !== peg$FAILED) {\n s2 = [];\n s3 = peg$currPos;\n if (input.charCodeAt(peg$currPos) === 47) {\n s4 = peg$c3;\n peg$currPos++;\n } else {\n s4 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e5);\n }\n }\n if (s4 !== peg$FAILED) {\n s5 = peg$parsespec();\n if (s5 !== peg$FAILED) {\n peg$savedPos = s3;\n s3 = peg$f13(s1, s5);\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n while (s3 !== peg$FAILED) {\n s2.push(s3);\n s3 = peg$currPos;\n if (input.charCodeAt(peg$currPos) === 47) {\n s4 = peg$c3;\n peg$currPos++;\n } else {\n s4 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e5);\n }\n }\n if (s4 !== peg$FAILED) {\n s5 = peg$parsespec();\n if (s5 !== peg$FAILED) {\n peg$savedPos = s3;\n s3 = peg$f13(s1, s5);\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n }\n peg$savedPos = s0;\n s0 = peg$f14(s1, s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e7);\n }\n }\n return s0;\n }\n function peg$parsespec() {\n var s0, s1, s2, s3, s4, s5, s6, s7, s8;\n peg$silentFails++;\n s0 = peg$currPos;\n s1 = peg$currPos;\n s2 = peg$currPos;\n s3 = peg$parsehex();\n if (s3 !== peg$FAILED) {\n s4 = peg$parsehex();\n if (s4 !== peg$FAILED) {\n s5 = peg$parsehex();\n if (s5 !== peg$FAILED) {\n s6 = peg$parsehex();\n if (s6 !== peg$FAILED) {\n s7 = peg$parsehex();\n if (s7 !== peg$FAILED) {\n s8 = peg$parsehex();\n if (s8 !== peg$FAILED) {\n s3 = [s3, s4, s5, s6, s7, s8];\n s2 = s3;\n } else {\n peg$currPos = s2;\n s2 = peg$FAILED;\n }\n } else {\n peg$currPos = s2;\n s2 = peg$FAILED;\n }\n } else {\n peg$currPos = s2;\n s2 = peg$FAILED;\n }\n } else {\n peg$currPos = s2;\n s2 = peg$FAILED;\n }\n } else {\n peg$currPos = s2;\n s2 = peg$FAILED;\n }\n } else {\n peg$currPos = s2;\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n s1 = input.substring(s1, peg$currPos);\n } else {\n s1 = s2;\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = s0;\n s1 = peg$f15(s1);\n }\n s0 = s1;\n if (s0 === peg$FAILED) {\n s0 = peg$currPos;\n s1 = peg$parsedec();\n if (s1 !== peg$FAILED) {\n s2 = [];\n s3 = peg$currPos;\n if (input.charCodeAt(peg$currPos) === 44) {\n s4 = peg$c1;\n peg$currPos++;\n } else {\n s4 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e2);\n }\n }\n if (s4 !== peg$FAILED) {\n s5 = peg$parsedec();\n if (s5 !== peg$FAILED) {\n peg$savedPos = s3;\n s3 = peg$f16(s1, s5);\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n if (s3 !== peg$FAILED) {\n while (s3 !== peg$FAILED) {\n s2.push(s3);\n s3 = peg$currPos;\n if (input.charCodeAt(peg$currPos) === 44) {\n s4 = peg$c1;\n peg$currPos++;\n } else {\n s4 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e2);\n }\n }\n if (s4 !== peg$FAILED) {\n s5 = peg$parsedec();\n if (s5 !== peg$FAILED) {\n peg$savedPos = s3;\n s3 = peg$f16(s1, s5);\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n }\n } else {\n s2 = peg$FAILED;\n }\n if (s2 === peg$FAILED) {\n s2 = [];\n s3 = peg$currPos;\n s4 = peg$parsesp();\n if (s4 !== peg$FAILED) {\n s5 = peg$parsedec();\n if (s5 !== peg$FAILED) {\n peg$savedPos = s3;\n s3 = peg$f17(s1, s5);\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n if (s3 !== peg$FAILED) {\n while (s3 !== peg$FAILED) {\n s2.push(s3);\n s3 = peg$currPos;\n s4 = peg$parsesp();\n if (s4 !== peg$FAILED) {\n s5 = peg$parsedec();\n if (s5 !== peg$FAILED) {\n peg$savedPos = s3;\n s3 = peg$f17(s1, s5);\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n }\n } else {\n s2 = peg$FAILED;\n }\n }\n if (s2 === peg$FAILED) {\n s2 = null;\n }\n peg$savedPos = s0;\n s0 = peg$f18(s1, s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e8);\n }\n }\n return s0;\n }\n function peg$parsecolor() {\n var s0, s1, s2, s3;\n peg$silentFails++;\n s0 = peg$currPos;\n s1 = peg$parsecolor_expr();\n if (s1 !== peg$FAILED) {\n s2 = [];\n s3 = peg$parsefunc_expr();\n while (s3 !== peg$FAILED) {\n s2.push(s3);\n s3 = peg$parsefunc_expr();\n }\n peg$savedPos = s0;\n s0 = peg$f19(s1, s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e9);\n }\n }\n return s0;\n }\n function peg$parsecolor_expr() {\n var s0;\n s0 = peg$parseext_expr();\n if (s0 === peg$FAILED) {\n s0 = peg$parseexpr();\n if (s0 === peg$FAILED) {\n s0 = peg$parsename();\n }\n }\n return s0;\n }\n function peg$parsefunc_expr() {\n var s0, s1, s2, s3, s4, s5, s6;\n peg$silentFails++;\n s0 = peg$currPos;\n if (input.charCodeAt(peg$currPos) === 62) {\n s1 = peg$c4;\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e11);\n }\n }\n if (s1 !== peg$FAILED) {\n s2 = peg$parsefunction();\n if (s2 !== peg$FAILED) {\n s3 = [];\n s4 = peg$currPos;\n if (input.charCodeAt(peg$currPos) === 44) {\n s5 = peg$c1;\n peg$currPos++;\n } else {\n s5 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e2);\n }\n }\n if (s5 !== peg$FAILED) {\n s6 = peg$parseint();\n if (s6 !== peg$FAILED) {\n peg$savedPos = s4;\n s4 = peg$f20(s2, s6);\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n while (s4 !== peg$FAILED) {\n s3.push(s4);\n s4 = peg$currPos;\n if (input.charCodeAt(peg$currPos) === 44) {\n s5 = peg$c1;\n peg$currPos++;\n } else {\n s5 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e2);\n }\n }\n if (s5 !== peg$FAILED) {\n s6 = peg$parseint();\n if (s6 !== peg$FAILED) {\n peg$savedPos = s4;\n s4 = peg$f20(s2, s6);\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n }\n peg$savedPos = s0;\n s0 = peg$f21(s2, s3);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e10);\n }\n }\n return s0;\n }\n function peg$parsefunction() {\n var s0, s1;\n peg$silentFails++;\n s0 = peg$parsename();\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e12);\n }\n }\n return s0;\n }\n function peg$parseext_expr() {\n var s0, s1, s2, s3, s4, s5, s6, s7;\n peg$silentFails++;\n s0 = peg$currPos;\n s1 = peg$parsecore_model();\n if (s1 !== peg$FAILED) {\n if (input.charCodeAt(peg$currPos) === 44) {\n s2 = peg$c1;\n peg$currPos++;\n } else {\n s2 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e2);\n }\n }\n if (s2 !== peg$FAILED) {\n s3 = peg$parsediv();\n if (s3 !== peg$FAILED) {\n if (input.charCodeAt(peg$currPos) === 58) {\n s4 = peg$c2;\n peg$currPos++;\n } else {\n s4 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e4);\n }\n }\n if (s4 !== peg$FAILED) {\n s5 = peg$parseweighted_expr();\n if (s5 !== peg$FAILED) {\n s6 = [];\n s7 = peg$parseadditional_weighted_expr();\n while (s7 !== peg$FAILED) {\n s6.push(s7);\n s7 = peg$parseadditional_weighted_expr();\n }\n peg$savedPos = s0;\n s0 = peg$f22(s1, s3, s5, s6);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n if (s0 === peg$FAILED) {\n s0 = peg$currPos;\n s1 = peg$parsecore_model();\n if (s1 !== peg$FAILED) {\n if (input.charCodeAt(peg$currPos) === 58) {\n s2 = peg$c2;\n peg$currPos++;\n } else {\n s2 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e4);\n }\n }\n if (s2 !== peg$FAILED) {\n s3 = peg$parseweighted_expr();\n if (s3 !== peg$FAILED) {\n s4 = [];\n s5 = peg$parseadditional_weighted_expr();\n while (s5 !== peg$FAILED) {\n s4.push(s5);\n s5 = peg$parseadditional_weighted_expr();\n }\n peg$savedPos = s0;\n s0 = peg$f23(s1, s3, s4);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e13);\n }\n }\n return s0;\n }\n function peg$parseweighted_expr() {\n var s0, s1, s2, s3;\n s0 = peg$currPos;\n s1 = peg$parseexpr();\n if (s1 !== peg$FAILED) {\n if (input.charCodeAt(peg$currPos) === 44) {\n s2 = peg$c1;\n peg$currPos++;\n } else {\n s2 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e2);\n }\n }\n if (s2 !== peg$FAILED) {\n s3 = peg$parsedec();\n if (s3 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f24(s1, s3);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parseadditional_weighted_expr() {\n var s0, s1, s2;\n s0 = peg$currPos;\n if (input.charCodeAt(peg$currPos) === 59) {\n s1 = peg$c0;\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e1);\n }\n }\n if (s1 !== peg$FAILED) {\n s2 = peg$parseweighted_expr();\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f25(s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parsecore_model() {\n var s0, s1;\n peg$silentFails++;\n s0 = peg$parsename();\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e14);\n }\n }\n return s0;\n }\n function peg$parseexpr() {\n var s0, s1, s2, s3, s4;\n peg$silentFails++;\n s0 = peg$currPos;\n s1 = peg$parseprefix();\n s2 = peg$parsename();\n if (s2 !== peg$FAILED) {\n s3 = peg$parsemix_expr();\n s4 = peg$parsepostfix();\n if (s4 === peg$FAILED) {\n s4 = null;\n }\n peg$savedPos = s0;\n s0 = peg$f26(s1, s2, s3, s4);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e15);\n }\n }\n return s0;\n }\n function peg$parsecomplete_mix() {\n var s0, s1, s2, s3, s4;\n s0 = peg$currPos;\n if (input.charCodeAt(peg$currPos) === 33) {\n s1 = peg$c5;\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e16);\n }\n }\n if (s1 !== peg$FAILED) {\n s2 = peg$parsepct();\n if (s2 !== peg$FAILED) {\n if (input.charCodeAt(peg$currPos) === 33) {\n s3 = peg$c5;\n peg$currPos++;\n } else {\n s3 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e16);\n }\n }\n if (s3 !== peg$FAILED) {\n s4 = peg$parsename();\n if (s4 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f27(s2, s4);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parsepartial_mix() {\n var s0, s1, s2;\n s0 = peg$currPos;\n if (input.charCodeAt(peg$currPos) === 33) {\n s1 = peg$c5;\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e16);\n }\n }\n if (s1 !== peg$FAILED) {\n s2 = peg$parsepct();\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f28(s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parsemix_expr() {\n var s0, s1, s2;\n peg$silentFails++;\n s0 = peg$currPos;\n s1 = [];\n s2 = peg$parsecomplete_mix();\n while (s2 !== peg$FAILED) {\n s1.push(s2);\n s2 = peg$parsecomplete_mix();\n }\n s2 = peg$parsepartial_mix();\n if (s2 === peg$FAILED) {\n s2 = null;\n }\n peg$savedPos = s0;\n s0 = peg$f29(s1, s2);\n peg$silentFails--;\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e17);\n }\n return s0;\n }\n function peg$parsename() {\n var s0, s1, s2;\n peg$silentFails++;\n if (input.charCodeAt(peg$currPos) === 46) {\n s0 = peg$c6;\n peg$currPos++;\n } else {\n s0 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e19);\n }\n }\n if (s0 === peg$FAILED) {\n s0 = peg$currPos;\n s1 = [];\n if (peg$r0.test(input.charAt(peg$currPos))) {\n s2 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s2 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e20);\n }\n }\n if (s2 !== peg$FAILED) {\n while (s2 !== peg$FAILED) {\n s1.push(s2);\n if (peg$r0.test(input.charAt(peg$currPos))) {\n s2 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s2 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e20);\n }\n }\n }\n } else {\n s1 = peg$FAILED;\n }\n if (s1 !== peg$FAILED) {\n s0 = input.substring(s0, peg$currPos);\n } else {\n s0 = s1;\n }\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e18);\n }\n }\n return s0;\n }\n function peg$parsepostfix() {\n var s0, s1, s2, s3, s4;\n peg$silentFails++;\n s0 = peg$currPos;\n if (input.substr(peg$currPos, 3) === peg$c7) {\n s1 = peg$c7;\n peg$currPos += 3;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e22);\n }\n }\n if (s1 !== peg$FAILED) {\n s2 = peg$parsenum();\n if (s2 !== peg$FAILED) {\n if (input.charCodeAt(peg$currPos) === 93) {\n s3 = peg$c8;\n peg$currPos++;\n } else {\n s3 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e23);\n }\n }\n if (s3 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f30(s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n if (s0 === peg$FAILED) {\n s0 = peg$currPos;\n if (input.substr(peg$currPos, 2) === peg$c9) {\n s1 = peg$c9;\n peg$currPos += 2;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e24);\n }\n }\n if (s1 !== peg$FAILED) {\n s2 = peg$currPos;\n s3 = [];\n s4 = peg$parseplus();\n if (s4 !== peg$FAILED) {\n while (s4 !== peg$FAILED) {\n s3.push(s4);\n s4 = peg$parseplus();\n }\n } else {\n s3 = peg$FAILED;\n }\n if (s3 !== peg$FAILED) {\n s2 = input.substring(s2, peg$currPos);\n } else {\n s2 = s3;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f31(s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e21);\n }\n }\n return s0;\n }\n function peg$parseprefix() {\n var s0, s1;\n peg$silentFails++;\n s0 = peg$parseminus();\n if (s0 === peg$FAILED) {\n s0 = null;\n }\n peg$silentFails--;\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e25);\n }\n return s0;\n }\n function peg$parseplus() {\n var s0, s1, s2;\n peg$silentFails++;\n s0 = peg$currPos;\n s1 = [];\n if (input.charCodeAt(peg$currPos) === 43) {\n s2 = peg$c10;\n peg$currPos++;\n } else {\n s2 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e27);\n }\n }\n if (s2 !== peg$FAILED) {\n while (s2 !== peg$FAILED) {\n s1.push(s2);\n if (input.charCodeAt(peg$currPos) === 43) {\n s2 = peg$c10;\n peg$currPos++;\n } else {\n s2 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e27);\n }\n }\n }\n } else {\n s1 = peg$FAILED;\n }\n if (s1 !== peg$FAILED) {\n s0 = input.substring(s0, peg$currPos);\n } else {\n s0 = s1;\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e26);\n }\n }\n return s0;\n }\n function peg$parseminus() {\n var s0, s1, s2;\n peg$silentFails++;\n s0 = peg$currPos;\n s1 = [];\n if (input.charCodeAt(peg$currPos) === 45) {\n s2 = peg$c11;\n peg$currPos++;\n } else {\n s2 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e29);\n }\n }\n if (s2 !== peg$FAILED) {\n while (s2 !== peg$FAILED) {\n s1.push(s2);\n if (input.charCodeAt(peg$currPos) === 45) {\n s2 = peg$c11;\n peg$currPos++;\n } else {\n s2 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e29);\n }\n }\n }\n } else {\n s1 = peg$FAILED;\n }\n if (s1 !== peg$FAILED) {\n s0 = input.substring(s0, peg$currPos);\n } else {\n s0 = s1;\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e28);\n }\n }\n return s0;\n }\n function peg$parsenum() {\n var s0, s1, s2, s3;\n peg$silentFails++;\n s0 = peg$currPos;\n s1 = peg$currPos;\n s2 = [];\n if (peg$r1.test(input.charAt(peg$currPos))) {\n s3 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s3 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e31);\n }\n }\n if (s3 !== peg$FAILED) {\n while (s3 !== peg$FAILED) {\n s2.push(s3);\n if (peg$r1.test(input.charAt(peg$currPos))) {\n s3 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s3 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e31);\n }\n }\n }\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n s1 = input.substring(s1, peg$currPos);\n } else {\n s1 = s2;\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = s0;\n s1 = peg$f32(s1);\n }\n s0 = s1;\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e30);\n }\n }\n return s0;\n }\n function peg$parsepct() {\n var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;\n peg$silentFails++;\n s0 = peg$currPos;\n s1 = peg$currPos;\n s2 = peg$currPos;\n s3 = peg$currPos;\n s4 = [];\n if (peg$r1.test(input.charAt(peg$currPos))) {\n s5 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s5 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e31);\n }\n }\n if (s5 !== peg$FAILED) {\n while (s5 !== peg$FAILED) {\n s4.push(s5);\n if (peg$r1.test(input.charAt(peg$currPos))) {\n s5 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s5 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e31);\n }\n }\n }\n } else {\n s4 = peg$FAILED;\n }\n if (s4 !== peg$FAILED) {\n s3 = input.substring(s3, peg$currPos);\n } else {\n s3 = s4;\n }\n if (s3 !== peg$FAILED) {\n s4 = peg$currPos;\n s5 = peg$currPos;\n if (input.charCodeAt(peg$currPos) === 46) {\n s6 = peg$c6;\n peg$currPos++;\n } else {\n s6 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e19);\n }\n }\n if (s6 !== peg$FAILED) {\n s7 = peg$currPos;\n s8 = [];\n if (peg$r1.test(input.charAt(peg$currPos))) {\n s9 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s9 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e31);\n }\n }\n while (s9 !== peg$FAILED) {\n s8.push(s9);\n if (peg$r1.test(input.charAt(peg$currPos))) {\n s9 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s9 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e31);\n }\n }\n }\n s7 = input.substring(s7, peg$currPos);\n s6 = [s6, s7];\n s5 = s6;\n } else {\n peg$currPos = s5;\n s5 = peg$FAILED;\n }\n if (s5 === peg$FAILED) {\n s5 = null;\n }\n s4 = input.substring(s4, peg$currPos);\n s3 = [s3, s4];\n s2 = s3;\n } else {\n peg$currPos = s2;\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n s1 = input.substring(s1, peg$currPos);\n } else {\n s1 = s2;\n }\n if (s1 === peg$FAILED) {\n s1 = peg$currPos;\n s2 = peg$currPos;\n if (input.charCodeAt(peg$currPos) === 46) {\n s3 = peg$c6;\n peg$currPos++;\n } else {\n s3 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e19);\n }\n }\n if (s3 !== peg$FAILED) {\n s4 = peg$currPos;\n s5 = [];\n if (peg$r1.test(input.charAt(peg$currPos))) {\n s6 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s6 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e31);\n }\n }\n if (s6 !== peg$FAILED) {\n while (s6 !== peg$FAILED) {\n s5.push(s6);\n if (peg$r1.test(input.charAt(peg$currPos))) {\n s6 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s6 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e31);\n }\n }\n }\n } else {\n s5 = peg$FAILED;\n }\n if (s5 !== peg$FAILED) {\n s4 = input.substring(s4, peg$currPos);\n } else {\n s4 = s5;\n }\n if (s4 !== peg$FAILED) {\n s3 = [s3, s4];\n s2 = s3;\n } else {\n peg$currPos = s2;\n s2 = peg$FAILED;\n }\n } else {\n peg$currPos = s2;\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n s1 = input.substring(s1, peg$currPos);\n } else {\n s1 = s2;\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = s0;\n s1 = peg$f33(s1);\n }\n s0 = s1;\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e32);\n }\n }\n return s0;\n }\n function peg$parsediv() {\n var s0, s1;\n peg$silentFails++;\n s0 = peg$parsepct();\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e33);\n }\n }\n return s0;\n }\n function peg$parsedec() {\n var s0, s1, s2;\n s0 = peg$parsepct();\n if (s0 === peg$FAILED) {\n s0 = peg$currPos;\n if (input.charCodeAt(peg$currPos) === 43) {\n s1 = peg$c10;\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e27);\n }\n }\n if (s1 !== peg$FAILED) {\n s2 = peg$parsepct();\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f34(s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n if (s0 === peg$FAILED) {\n s0 = peg$currPos;\n if (input.charCodeAt(peg$currPos) === 45) {\n s1 = peg$c11;\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e29);\n }\n }\n if (s1 !== peg$FAILED) {\n s2 = peg$parsepct();\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f35(s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n }\n }\n return s0;\n }\n function peg$parseint() {\n var s0, s1, s2;\n peg$silentFails++;\n s0 = peg$currPos;\n s1 = peg$parseminus();\n if (s1 === peg$FAILED) {\n s1 = null;\n }\n s2 = peg$parsenum();\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f36(s1, s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e34);\n }\n }\n return s0;\n }\n function peg$parse_() {\n var s0, s1;\n peg$silentFails++;\n s0 = [];\n if (peg$r2.test(input.charAt(peg$currPos))) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e36);\n }\n }\n while (s1 !== peg$FAILED) {\n s0.push(s1);\n if (peg$r2.test(input.charAt(peg$currPos))) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e36);\n }\n }\n }\n peg$silentFails--;\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e35);\n }\n return s0;\n }\n function peg$parsesp() {\n var s0, s1;\n s0 = [];\n if (peg$r2.test(input.charAt(peg$currPos))) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e36);\n }\n }\n if (s1 !== peg$FAILED) {\n while (s1 !== peg$FAILED) {\n s0.push(s1);\n if (peg$r2.test(input.charAt(peg$currPos))) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e36);\n }\n }\n }\n } else {\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parsehex() {\n var s0, s1;\n s0 = peg$currPos;\n if (peg$r3.test(input.charAt(peg$currPos))) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e37);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = s0;\n s1 = peg$f37(s1);\n }\n s0 = s1;\n return s0;\n }\n function peg$parseEOL() {\n var s0, s1;\n s0 = peg$currPos;\n peg$silentFails++;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n peg$silentFails--;\n if (s1 === peg$FAILED) {\n s0 = void 0;\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n peg$result = peg$startRuleFunction();\n if (peg$result !== peg$FAILED && peg$currPos === input.length) {\n return peg$result;\n } else {\n if (peg$result !== peg$FAILED && peg$currPos < input.length) {\n peg$fail(peg$endExpectation());\n }\n throw peg$buildStructuredError(\n peg$maxFailExpected,\n peg$maxFailPos < input.length ? input.charAt(peg$maxFailPos) : null,\n peg$maxFailPos < input.length ? peg$computeLocation(peg$maxFailPos, peg$maxFailPos + 1) : peg$computeLocation(peg$maxFailPos, peg$maxFailPos)\n );\n }\n }\n return {\n SyntaxError: peg$SyntaxError,\n parse: peg$parse\n };\n }()\n);\n","export default (\n // Generated by Peggy 3.0.2.\n //\n // https://peggyjs.org/\n function() {\n \"use strict\";\n function peg$subclass(child, parent) {\n function C() {\n this.constructor = child;\n }\n C.prototype = parent.prototype;\n child.prototype = new C();\n }\n function peg$SyntaxError(message, expected, found, location) {\n var self = Error.call(this, message);\n if (Object.setPrototypeOf) {\n Object.setPrototypeOf(self, peg$SyntaxError.prototype);\n }\n self.expected = expected;\n self.found = found;\n self.location = location;\n self.name = \"SyntaxError\";\n return self;\n }\n peg$subclass(peg$SyntaxError, Error);\n function peg$padEnd(str, targetLength, padString) {\n padString = padString || \" \";\n if (str.length > targetLength) {\n return str;\n }\n targetLength -= str.length;\n padString += padString.repeat(targetLength);\n return str + padString.slice(0, targetLength);\n }\n peg$SyntaxError.prototype.format = function(sources) {\n var str = \"Error: \" + this.message;\n if (this.location) {\n var src = null;\n var k;\n for (k = 0; k < sources.length; k++) {\n if (sources[k].source === this.location.source) {\n src = sources[k].text.split(/\\r\\n|\\n|\\r/g);\n break;\n }\n }\n var s = this.location.start;\n var offset_s = this.location.source && typeof this.location.source.offset === \"function\" ? this.location.source.offset(s) : s;\n var loc = this.location.source + \":\" + offset_s.line + \":\" + offset_s.column;\n if (src) {\n var e = this.location.end;\n var filler = peg$padEnd(\"\", offset_s.line.toString().length, \" \");\n var line = src[s.line - 1];\n var last = s.line === e.line ? e.column : line.length + 1;\n var hatLen = last - s.column || 1;\n str += \"\\n --> \" + loc + \"\\n\" + filler + \" |\\n\" + offset_s.line + \" | \" + line + \"\\n\" + filler + \" | \" + peg$padEnd(\"\", s.column - 1, \" \") + peg$padEnd(\"\", hatLen, \"^\");\n } else {\n str += \"\\n at \" + loc;\n }\n }\n return str;\n };\n peg$SyntaxError.buildMessage = function(expected, found) {\n var DESCRIBE_EXPECTATION_FNS = {\n literal: function(expectation) {\n return '\"' + literalEscape(expectation.text) + '\"';\n },\n class: function(expectation) {\n var escapedParts = expectation.parts.map(function(part) {\n return Array.isArray(part) ? classEscape(part[0]) + \"-\" + classEscape(part[1]) : classEscape(part);\n });\n return \"[\" + (expectation.inverted ? \"^\" : \"\") + escapedParts.join(\"\") + \"]\";\n },\n any: function() {\n return \"any character\";\n },\n end: function() {\n return \"end of input\";\n },\n other: function(expectation) {\n return expectation.description;\n }\n };\n function hex(ch) {\n return ch.charCodeAt(0).toString(16).toUpperCase();\n }\n function literalEscape(s) {\n return s.replace(/\\\\/g, \"\\\\\\\\\").replace(/\"/g, '\\\\\"').replace(/\\0/g, \"\\\\0\").replace(/\\t/g, \"\\\\t\").replace(/\\n/g, \"\\\\n\").replace(/\\r/g, \"\\\\r\").replace(/[\\x00-\\x0F]/g, function(ch) {\n return \"\\\\x0\" + hex(ch);\n }).replace(/[\\x10-\\x1F\\x7F-\\x9F]/g, function(ch) {\n return \"\\\\x\" + hex(ch);\n });\n }\n function classEscape(s) {\n return s.replace(/\\\\/g, \"\\\\\\\\\").replace(/\\]/g, \"\\\\]\").replace(/\\^/g, \"\\\\^\").replace(/-/g, \"\\\\-\").replace(/\\0/g, \"\\\\0\").replace(/\\t/g, \"\\\\t\").replace(/\\n/g, \"\\\\n\").replace(/\\r/g, \"\\\\r\").replace(/[\\x00-\\x0F]/g, function(ch) {\n return \"\\\\x0\" + hex(ch);\n }).replace(/[\\x10-\\x1F\\x7F-\\x9F]/g, function(ch) {\n return \"\\\\x\" + hex(ch);\n });\n }\n function describeExpectation(expectation) {\n return DESCRIBE_EXPECTATION_FNS[expectation.type](expectation);\n }\n function describeExpected(expected2) {\n var descriptions = expected2.map(describeExpectation);\n var i, j;\n descriptions.sort();\n if (descriptions.length > 0) {\n for (i = 1, j = 1; i < descriptions.length; i++) {\n if (descriptions[i - 1] !== descriptions[i]) {\n descriptions[j] = descriptions[i];\n j++;\n }\n }\n descriptions.length = j;\n }\n switch (descriptions.length) {\n case 1:\n return descriptions[0];\n case 2:\n return descriptions[0] + \" or \" + descriptions[1];\n default:\n return descriptions.slice(0, -1).join(\", \") + \", or \" + descriptions[descriptions.length - 1];\n }\n }\n function describeFound(found2) {\n return found2 ? '\"' + literalEscape(found2) + '\"' : \"end of input\";\n }\n return \"Expected \" + describeExpected(expected) + \" but \" + describeFound(found) + \" found.\";\n };\n function peg$parse(input, options) {\n options = options !== void 0 ? options : {};\n var peg$FAILED = {};\n var peg$source = options.grammarSource;\n var peg$startRuleFunctions = { body: peg$parsebody };\n var peg$startRuleFunction = peg$parsebody;\n var peg$e0 = peg$otherExpectation(\"decl_start\");\n var peg$e1 = peg$otherExpectation(\"decl_end\");\n var peg$e2 = peg$otherExpectation(\"vert\");\n var peg$e3 = peg$anyExpectation();\n var peg$e4 = peg$otherExpectation(\"l\");\n var peg$e5 = peg$otherExpectation(\"r\");\n var peg$e6 = peg$otherExpectation(\"c\");\n var peg$e7 = peg$otherExpectation(\"p\");\n var peg$e8 = peg$otherExpectation(\"m\");\n var peg$e9 = peg$otherExpectation(\"b\");\n var peg$e10 = peg$otherExpectation(\"w\");\n var peg$e11 = peg$otherExpectation(\"W\");\n var peg$e12 = peg$otherExpectation(\"X\");\n var peg$e13 = peg$otherExpectation(\"!\");\n var peg$e14 = peg$otherExpectation(\"@\");\n var peg$e15 = peg$otherExpectation(\"<\");\n var peg$e16 = peg$otherExpectation(\">\");\n var peg$e17 = peg$otherExpectation(\"group\");\n var peg$e18 = peg$otherExpectation(\"whitespace\");\n var peg$f0 = function(c) {\n return c;\n };\n var peg$f1 = function(cols) {\n return cols;\n };\n var peg$f2 = function() {\n return [];\n };\n var peg$f3 = function(divs1, start, a, end, divs2) {\n return {\n type: \"column\",\n pre_dividers: divs1,\n post_dividers: divs2,\n before_start_code: start,\n before_end_code: end,\n alignment: a\n };\n };\n var peg$f4 = function() {\n return {\n type: \"vert_divider\"\n };\n };\n var peg$f5 = function(b, g) {\n return {\n type: \"bang_divider\",\n content: g[0].content\n };\n };\n var peg$f6 = function(g) {\n return {\n type: \"at_divider\",\n content: g[0].content\n };\n };\n var peg$f7 = function(div) {\n return div;\n };\n var peg$f8 = function(g) {\n return { type: \"decl_code\", code: g[0].content };\n };\n var peg$f9 = function(g) {\n return { type: \"decl_code\", code: g[0].content };\n };\n var peg$f10 = function() {\n return { type: \"alignment\", alignment: \"left\" };\n };\n var peg$f11 = function() {\n return { type: \"alignment\", alignment: \"center\" };\n };\n var peg$f12 = function() {\n return { type: \"alignment\", alignment: \"right\" };\n };\n var peg$f13 = function() {\n return { type: \"alignment\", alignment: \"X\" };\n };\n var peg$f14 = function() {\n return \"top\";\n };\n var peg$f15 = function() {\n return \"default\";\n };\n var peg$f16 = function() {\n return \"bottom\";\n };\n var peg$f17 = function(a, g) {\n return {\n type: \"alignment\",\n alignment: \"parbox\",\n baseline: a,\n size: g[0].content\n };\n };\n var peg$f18 = function(g1, g2) {\n return {\n type: \"alignment\",\n alignment: \"parbox\",\n baseline: g1[0].content,\n size: g2[0].content\n };\n };\n var peg$f19 = function(tok) {\n return options.matchChar(tok, \"|\");\n };\n var peg$f20 = function(tok) {\n return options.matchChar(tok, \"l\");\n };\n var peg$f21 = function(tok) {\n return options.matchChar(tok, \"r\");\n };\n var peg$f22 = function(tok) {\n return options.matchChar(tok, \"c\");\n };\n var peg$f23 = function(tok) {\n return options.matchChar(tok, \"p\");\n };\n var peg$f24 = function(tok) {\n return options.matchChar(tok, \"m\");\n };\n var peg$f25 = function(tok) {\n return options.matchChar(tok, \"b\");\n };\n var peg$f26 = function(tok) {\n return options.matchChar(tok, \"w\");\n };\n var peg$f27 = function(tok) {\n return options.matchChar(tok, \"W\");\n };\n var peg$f28 = function(tok) {\n return options.matchChar(tok, \"X\");\n };\n var peg$f29 = function(tok) {\n return options.matchChar(tok, \"!\");\n };\n var peg$f30 = function(tok) {\n return options.matchChar(tok, \"@\");\n };\n var peg$f31 = function(tok) {\n return options.matchChar(tok, \"<\");\n };\n var peg$f32 = function(tok) {\n return options.matchChar(tok, \">\");\n };\n var peg$f33 = function(tok) {\n return options.isGroup(tok);\n };\n var peg$f34 = function(tok) {\n return options.isWhitespace(tok);\n };\n var peg$currPos = 0;\n var peg$savedPos = 0;\n var peg$posDetailsCache = [{ line: 1, column: 1 }];\n var peg$maxFailPos = 0;\n var peg$maxFailExpected = [];\n var peg$silentFails = 0;\n var peg$result;\n if (\"startRule\" in options) {\n if (!(options.startRule in peg$startRuleFunctions)) {\n throw new Error(`Can't start parsing from rule \"` + options.startRule + '\".');\n }\n peg$startRuleFunction = peg$startRuleFunctions[options.startRule];\n }\n function text() {\n return input.substring(peg$savedPos, peg$currPos);\n }\n function offset() {\n return peg$savedPos;\n }\n function range() {\n return {\n source: peg$source,\n start: peg$savedPos,\n end: peg$currPos\n };\n }\n function location() {\n return peg$computeLocation(peg$savedPos, peg$currPos);\n }\n function expected(description, location2) {\n location2 = location2 !== void 0 ? location2 : peg$computeLocation(peg$savedPos, peg$currPos);\n throw peg$buildStructuredError(\n [peg$otherExpectation(description)],\n input.substring(peg$savedPos, peg$currPos),\n location2\n );\n }\n function error(message, location2) {\n location2 = location2 !== void 0 ? location2 : peg$computeLocation(peg$savedPos, peg$currPos);\n throw peg$buildSimpleError(message, location2);\n }\n function peg$literalExpectation(text2, ignoreCase) {\n return { type: \"literal\", text: text2, ignoreCase };\n }\n function peg$classExpectation(parts, inverted, ignoreCase) {\n return { type: \"class\", parts, inverted, ignoreCase };\n }\n function peg$anyExpectation() {\n return { type: \"any\" };\n }\n function peg$endExpectation() {\n return { type: \"end\" };\n }\n function peg$otherExpectation(description) {\n return { type: \"other\", description };\n }\n function peg$computePosDetails(pos) {\n var details = peg$posDetailsCache[pos];\n var p;\n if (details) {\n return details;\n } else {\n p = pos - 1;\n while (!peg$posDetailsCache[p]) {\n p--;\n }\n details = peg$posDetailsCache[p];\n details = {\n line: details.line,\n column: details.column\n };\n while (p < pos) {\n if (input.charCodeAt(p) === 10) {\n details.line++;\n details.column = 1;\n } else {\n details.column++;\n }\n p++;\n }\n peg$posDetailsCache[pos] = details;\n return details;\n }\n }\n function peg$computeLocation(startPos, endPos, offset2) {\n var startPosDetails = peg$computePosDetails(startPos);\n var endPosDetails = peg$computePosDetails(endPos);\n var res = {\n source: peg$source,\n start: {\n offset: startPos,\n line: startPosDetails.line,\n column: startPosDetails.column\n },\n end: {\n offset: endPos,\n line: endPosDetails.line,\n column: endPosDetails.column\n }\n };\n if (offset2 && peg$source && typeof peg$source.offset === \"function\") {\n res.start = peg$source.offset(res.start);\n res.end = peg$source.offset(res.end);\n }\n return res;\n }\n function peg$fail(expected2) {\n if (peg$currPos < peg$maxFailPos) {\n return;\n }\n if (peg$currPos > peg$maxFailPos) {\n peg$maxFailPos = peg$currPos;\n peg$maxFailExpected = [];\n }\n peg$maxFailExpected.push(expected2);\n }\n function peg$buildSimpleError(message, location2) {\n return new peg$SyntaxError(message, null, null, location2);\n }\n function peg$buildStructuredError(expected2, found, location2) {\n return new peg$SyntaxError(\n peg$SyntaxError.buildMessage(expected2, found),\n expected2,\n found,\n location2\n );\n }\n function peg$parsebody() {\n var s0, s1, s2, s3, s4, s5;\n s0 = peg$currPos;\n s1 = [];\n s2 = peg$currPos;\n s3 = peg$parsecolumn();\n if (s3 !== peg$FAILED) {\n s4 = [];\n s5 = peg$parse_();\n while (s5 !== peg$FAILED) {\n s4.push(s5);\n s5 = peg$parse_();\n }\n peg$savedPos = s2;\n s2 = peg$f0(s3);\n } else {\n peg$currPos = s2;\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n while (s2 !== peg$FAILED) {\n s1.push(s2);\n s2 = peg$currPos;\n s3 = peg$parsecolumn();\n if (s3 !== peg$FAILED) {\n s4 = [];\n s5 = peg$parse_();\n while (s5 !== peg$FAILED) {\n s4.push(s5);\n s5 = peg$parse_();\n }\n peg$savedPos = s2;\n s2 = peg$f0(s3);\n } else {\n peg$currPos = s2;\n s2 = peg$FAILED;\n }\n }\n } else {\n s1 = peg$FAILED;\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = s0;\n s1 = peg$f1(s1);\n }\n s0 = s1;\n if (s0 === peg$FAILED) {\n s0 = peg$currPos;\n s1 = peg$parseEOL();\n if (s1 !== peg$FAILED) {\n peg$savedPos = s0;\n s1 = peg$f2();\n }\n s0 = s1;\n }\n return s0;\n }\n function peg$parsecolumn() {\n var s0, s1, s2, s3, s4, s5, s6;\n s0 = peg$currPos;\n s1 = [];\n s2 = peg$parsecolumn_divider();\n while (s2 !== peg$FAILED) {\n s1.push(s2);\n s2 = peg$parsecolumn_divider();\n }\n s2 = peg$parsedecl_start();\n if (s2 === peg$FAILED) {\n s2 = null;\n }\n s3 = peg$parsealignment();\n if (s3 !== peg$FAILED) {\n s4 = peg$parsedecl_end();\n if (s4 === peg$FAILED) {\n s4 = null;\n }\n s5 = [];\n s6 = peg$parsecolumn_divider();\n while (s6 !== peg$FAILED) {\n s5.push(s6);\n s6 = peg$parsecolumn_divider();\n }\n peg$savedPos = s0;\n s0 = peg$f3(s1, s2, s3, s4, s5);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parsecolumn_divider() {\n var s0, s1, s2, s3, s4;\n s0 = peg$currPos;\n s1 = [];\n s2 = peg$parse_();\n while (s2 !== peg$FAILED) {\n s1.push(s2);\n s2 = peg$parse_();\n }\n s2 = peg$currPos;\n s3 = peg$parsevert();\n if (s3 !== peg$FAILED) {\n peg$savedPos = s2;\n s3 = peg$f4();\n }\n s2 = s3;\n if (s2 === peg$FAILED) {\n s2 = peg$currPos;\n s3 = peg$parsebang();\n if (s3 !== peg$FAILED) {\n s4 = peg$parsegroup();\n if (s4 !== peg$FAILED) {\n peg$savedPos = s2;\n s2 = peg$f5(s3, s4);\n } else {\n peg$currPos = s2;\n s2 = peg$FAILED;\n }\n } else {\n peg$currPos = s2;\n s2 = peg$FAILED;\n }\n if (s2 === peg$FAILED) {\n s2 = peg$currPos;\n s3 = peg$parseat();\n if (s3 !== peg$FAILED) {\n s4 = peg$parsegroup();\n if (s4 !== peg$FAILED) {\n peg$savedPos = s2;\n s2 = peg$f6(s4);\n } else {\n peg$currPos = s2;\n s2 = peg$FAILED;\n }\n } else {\n peg$currPos = s2;\n s2 = peg$FAILED;\n }\n }\n }\n if (s2 !== peg$FAILED) {\n s3 = [];\n s4 = peg$parse_();\n while (s4 !== peg$FAILED) {\n s3.push(s4);\n s4 = peg$parse_();\n }\n peg$savedPos = s0;\n s0 = peg$f7(s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parsedecl_start() {\n var s0, s1, s2;\n peg$silentFails++;\n s0 = peg$currPos;\n s1 = peg$parsegreater();\n if (s1 !== peg$FAILED) {\n s2 = peg$parsegroup();\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f8(s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n return s0;\n }\n function peg$parsedecl_end() {\n var s0, s1, s2;\n peg$silentFails++;\n s0 = peg$currPos;\n s1 = peg$parseless();\n if (s1 !== peg$FAILED) {\n s2 = peg$parsegroup();\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f9(s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e1);\n }\n }\n return s0;\n }\n function peg$parsealignment() {\n var s0, s1, s2, s3, s4, s5;\n s0 = peg$currPos;\n s1 = peg$parsel();\n if (s1 !== peg$FAILED) {\n peg$savedPos = s0;\n s1 = peg$f10();\n }\n s0 = s1;\n if (s0 === peg$FAILED) {\n s0 = peg$currPos;\n s1 = peg$parsec();\n if (s1 !== peg$FAILED) {\n peg$savedPos = s0;\n s1 = peg$f11();\n }\n s0 = s1;\n if (s0 === peg$FAILED) {\n s0 = peg$currPos;\n s1 = peg$parser();\n if (s1 !== peg$FAILED) {\n peg$savedPos = s0;\n s1 = peg$f12();\n }\n s0 = s1;\n if (s0 === peg$FAILED) {\n s0 = peg$currPos;\n s1 = peg$parseX();\n if (s1 !== peg$FAILED) {\n peg$savedPos = s0;\n s1 = peg$f13();\n }\n s0 = s1;\n if (s0 === peg$FAILED) {\n s0 = peg$currPos;\n s1 = peg$currPos;\n s2 = peg$parsep();\n if (s2 !== peg$FAILED) {\n peg$savedPos = s1;\n s2 = peg$f14();\n }\n s1 = s2;\n if (s1 === peg$FAILED) {\n s1 = peg$currPos;\n s2 = peg$parsem();\n if (s2 !== peg$FAILED) {\n peg$savedPos = s1;\n s2 = peg$f15();\n }\n s1 = s2;\n if (s1 === peg$FAILED) {\n s1 = peg$currPos;\n s2 = peg$parseb();\n if (s2 !== peg$FAILED) {\n peg$savedPos = s1;\n s2 = peg$f16();\n }\n s1 = s2;\n }\n }\n if (s1 !== peg$FAILED) {\n s2 = [];\n s3 = peg$parse_();\n while (s3 !== peg$FAILED) {\n s2.push(s3);\n s3 = peg$parse_();\n }\n s3 = peg$parsegroup();\n if (s3 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f17(s1, s3);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n if (s0 === peg$FAILED) {\n s0 = peg$currPos;\n s1 = peg$parsew();\n if (s1 === peg$FAILED) {\n s1 = peg$parseW();\n }\n if (s1 !== peg$FAILED) {\n s2 = [];\n s3 = peg$parse_();\n while (s3 !== peg$FAILED) {\n s2.push(s3);\n s3 = peg$parse_();\n }\n s3 = peg$parsegroup();\n if (s3 !== peg$FAILED) {\n s4 = [];\n s5 = peg$parse_();\n while (s5 !== peg$FAILED) {\n s4.push(s5);\n s5 = peg$parse_();\n }\n s5 = peg$parsegroup();\n if (s5 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f18(s3, s5);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n }\n }\n }\n }\n }\n return s0;\n }\n function peg$parsevert() {\n var s0, s1, s2;\n peg$silentFails++;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e3);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f19(s1);\n if (s2) {\n s2 = void 0;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n s1 = [s1, s2];\n s0 = s1;\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e2);\n }\n }\n return s0;\n }\n function peg$parsel() {\n var s0, s1, s2;\n peg$silentFails++;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e3);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f20(s1);\n if (s2) {\n s2 = void 0;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n s1 = [s1, s2];\n s0 = s1;\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e4);\n }\n }\n return s0;\n }\n function peg$parser() {\n var s0, s1, s2;\n peg$silentFails++;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e3);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f21(s1);\n if (s2) {\n s2 = void 0;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n s1 = [s1, s2];\n s0 = s1;\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e5);\n }\n }\n return s0;\n }\n function peg$parsec() {\n var s0, s1, s2;\n peg$silentFails++;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e3);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f22(s1);\n if (s2) {\n s2 = void 0;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n s1 = [s1, s2];\n s0 = s1;\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e6);\n }\n }\n return s0;\n }\n function peg$parsep() {\n var s0, s1, s2;\n peg$silentFails++;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e3);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f23(s1);\n if (s2) {\n s2 = void 0;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n s1 = [s1, s2];\n s0 = s1;\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e7);\n }\n }\n return s0;\n }\n function peg$parsem() {\n var s0, s1, s2;\n peg$silentFails++;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e3);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f24(s1);\n if (s2) {\n s2 = void 0;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n s1 = [s1, s2];\n s0 = s1;\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e8);\n }\n }\n return s0;\n }\n function peg$parseb() {\n var s0, s1, s2;\n peg$silentFails++;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e3);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f25(s1);\n if (s2) {\n s2 = void 0;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n s1 = [s1, s2];\n s0 = s1;\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e9);\n }\n }\n return s0;\n }\n function peg$parsew() {\n var s0, s1, s2;\n peg$silentFails++;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e3);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f26(s1);\n if (s2) {\n s2 = void 0;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n s1 = [s1, s2];\n s0 = s1;\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e10);\n }\n }\n return s0;\n }\n function peg$parseW() {\n var s0, s1, s2;\n peg$silentFails++;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e3);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f27(s1);\n if (s2) {\n s2 = void 0;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n s1 = [s1, s2];\n s0 = s1;\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e11);\n }\n }\n return s0;\n }\n function peg$parseX() {\n var s0, s1, s2;\n peg$silentFails++;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e3);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f28(s1);\n if (s2) {\n s2 = void 0;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n s1 = [s1, s2];\n s0 = s1;\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e12);\n }\n }\n return s0;\n }\n function peg$parsebang() {\n var s0, s1, s2;\n peg$silentFails++;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e3);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f29(s1);\n if (s2) {\n s2 = void 0;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n s1 = [s1, s2];\n s0 = s1;\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e13);\n }\n }\n return s0;\n }\n function peg$parseat() {\n var s0, s1, s2;\n peg$silentFails++;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e3);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f30(s1);\n if (s2) {\n s2 = void 0;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n s1 = [s1, s2];\n s0 = s1;\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e14);\n }\n }\n return s0;\n }\n function peg$parseless() {\n var s0, s1, s2;\n peg$silentFails++;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e3);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f31(s1);\n if (s2) {\n s2 = void 0;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n s1 = [s1, s2];\n s0 = s1;\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e15);\n }\n }\n return s0;\n }\n function peg$parsegreater() {\n var s0, s1, s2;\n peg$silentFails++;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e3);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f32(s1);\n if (s2) {\n s2 = void 0;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n s1 = [s1, s2];\n s0 = s1;\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e16);\n }\n }\n return s0;\n }\n function peg$parsegroup() {\n var s0, s1, s2;\n peg$silentFails++;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e3);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f33(s1);\n if (s2) {\n s2 = void 0;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n s1 = [s1, s2];\n s0 = s1;\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e17);\n }\n }\n return s0;\n }\n function peg$parse_() {\n var s0, s1, s2;\n peg$silentFails++;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e3);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f34(s1);\n if (s2) {\n s2 = void 0;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n s1 = [s1, s2];\n s0 = s1;\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e18);\n }\n }\n return s0;\n }\n function peg$parseEOL() {\n var s0, s1;\n s0 = peg$currPos;\n peg$silentFails++;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e3);\n }\n }\n peg$silentFails--;\n if (s1 === peg$FAILED) {\n s0 = void 0;\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n if (!options.isHash) {\n try {\n Object.assign(options, {\n matchChar: (node, char) => node.type === \"string\" && node.content === char,\n isGroup: (node) => node.type === \"group\",\n isWhitespace: (node) => node.type === \"whitespace\"\n });\n } catch (e) {\n console.warn(\"Error when initializing parser\", e);\n }\n }\n peg$result = peg$startRuleFunction();\n if (peg$result !== peg$FAILED && peg$currPos === input.length) {\n return peg$result;\n } else {\n if (peg$result !== peg$FAILED && peg$currPos < input.length) {\n peg$fail(peg$endExpectation());\n }\n throw peg$buildStructuredError(\n peg$maxFailExpected,\n peg$maxFailPos < input.length ? input.charAt(peg$maxFailPos) : null,\n peg$maxFailPos < input.length ? peg$computeLocation(peg$maxFailPos, peg$maxFailPos + 1) : peg$computeLocation(peg$maxFailPos, peg$maxFailPos)\n );\n }\n }\n return {\n SyntaxError: peg$SyntaxError,\n parse: peg$parse\n };\n }()\n);\n","export default (\n // Generated by Peggy 3.0.2.\n //\n // https://peggyjs.org/\n function() {\n \"use strict\";\n function peg$subclass(child, parent) {\n function C() {\n this.constructor = child;\n }\n C.prototype = parent.prototype;\n child.prototype = new C();\n }\n function peg$SyntaxError(message, expected, found, location) {\n var self = Error.call(this, message);\n if (Object.setPrototypeOf) {\n Object.setPrototypeOf(self, peg$SyntaxError.prototype);\n }\n self.expected = expected;\n self.found = found;\n self.location = location;\n self.name = \"SyntaxError\";\n return self;\n }\n peg$subclass(peg$SyntaxError, Error);\n function peg$padEnd(str, targetLength, padString) {\n padString = padString || \" \";\n if (str.length > targetLength) {\n return str;\n }\n targetLength -= str.length;\n padString += padString.repeat(targetLength);\n return str + padString.slice(0, targetLength);\n }\n peg$SyntaxError.prototype.format = function(sources) {\n var str = \"Error: \" + this.message;\n if (this.location) {\n var src = null;\n var k;\n for (k = 0; k < sources.length; k++) {\n if (sources[k].source === this.location.source) {\n src = sources[k].text.split(/\\r\\n|\\n|\\r/g);\n break;\n }\n }\n var s = this.location.start;\n var offset_s = this.location.source && typeof this.location.source.offset === \"function\" ? this.location.source.offset(s) : s;\n var loc = this.location.source + \":\" + offset_s.line + \":\" + offset_s.column;\n if (src) {\n var e = this.location.end;\n var filler = peg$padEnd(\"\", offset_s.line.toString().length, \" \");\n var line = src[s.line - 1];\n var last = s.line === e.line ? e.column : line.length + 1;\n var hatLen = last - s.column || 1;\n str += \"\\n --> \" + loc + \"\\n\" + filler + \" |\\n\" + offset_s.line + \" | \" + line + \"\\n\" + filler + \" | \" + peg$padEnd(\"\", s.column - 1, \" \") + peg$padEnd(\"\", hatLen, \"^\");\n } else {\n str += \"\\n at \" + loc;\n }\n }\n return str;\n };\n peg$SyntaxError.buildMessage = function(expected, found) {\n var DESCRIBE_EXPECTATION_FNS = {\n literal: function(expectation) {\n return '\"' + literalEscape(expectation.text) + '\"';\n },\n class: function(expectation) {\n var escapedParts = expectation.parts.map(function(part) {\n return Array.isArray(part) ? classEscape(part[0]) + \"-\" + classEscape(part[1]) : classEscape(part);\n });\n return \"[\" + (expectation.inverted ? \"^\" : \"\") + escapedParts.join(\"\") + \"]\";\n },\n any: function() {\n return \"any character\";\n },\n end: function() {\n return \"end of input\";\n },\n other: function(expectation) {\n return expectation.description;\n }\n };\n function hex(ch) {\n return ch.charCodeAt(0).toString(16).toUpperCase();\n }\n function literalEscape(s) {\n return s.replace(/\\\\/g, \"\\\\\\\\\").replace(/\"/g, '\\\\\"').replace(/\\0/g, \"\\\\0\").replace(/\\t/g, \"\\\\t\").replace(/\\n/g, \"\\\\n\").replace(/\\r/g, \"\\\\r\").replace(/[\\x00-\\x0F]/g, function(ch) {\n return \"\\\\x0\" + hex(ch);\n }).replace(/[\\x10-\\x1F\\x7F-\\x9F]/g, function(ch) {\n return \"\\\\x\" + hex(ch);\n });\n }\n function classEscape(s) {\n return s.replace(/\\\\/g, \"\\\\\\\\\").replace(/\\]/g, \"\\\\]\").replace(/\\^/g, \"\\\\^\").replace(/-/g, \"\\\\-\").replace(/\\0/g, \"\\\\0\").replace(/\\t/g, \"\\\\t\").replace(/\\n/g, \"\\\\n\").replace(/\\r/g, \"\\\\r\").replace(/[\\x00-\\x0F]/g, function(ch) {\n return \"\\\\x0\" + hex(ch);\n }).replace(/[\\x10-\\x1F\\x7F-\\x9F]/g, function(ch) {\n return \"\\\\x\" + hex(ch);\n });\n }\n function describeExpectation(expectation) {\n return DESCRIBE_EXPECTATION_FNS[expectation.type](expectation);\n }\n function describeExpected(expected2) {\n var descriptions = expected2.map(describeExpectation);\n var i, j;\n descriptions.sort();\n if (descriptions.length > 0) {\n for (i = 1, j = 1; i < descriptions.length; i++) {\n if (descriptions[i - 1] !== descriptions[i]) {\n descriptions[j] = descriptions[i];\n j++;\n }\n }\n descriptions.length = j;\n }\n switch (descriptions.length) {\n case 1:\n return descriptions[0];\n case 2:\n return descriptions[0] + \" or \" + descriptions[1];\n default:\n return descriptions.slice(0, -1).join(\", \") + \", or \" + descriptions[descriptions.length - 1];\n }\n }\n function describeFound(found2) {\n return found2 ? '\"' + literalEscape(found2) + '\"' : \"end of input\";\n }\n return \"Expected \" + describeExpected(expected) + \" but \" + describeFound(found) + \" found.\";\n };\n function peg$parse(input, options) {\n options = options !== void 0 ? options : {};\n var peg$FAILED = {};\n var peg$source = options.grammarSource;\n var peg$startRuleFunctions = { body: peg$parsebody };\n var peg$startRuleFunction = peg$parsebody;\n var peg$e0 = peg$otherExpectation(\"partial item\");\n var peg$e1 = peg$otherExpectation(\"item\");\n var peg$e2 = peg$anyExpectation();\n var peg$e3 = peg$otherExpectation(\"equation\");\n var peg$e4 = peg$otherExpectation(\"trailing comment\");\n var peg$e5 = peg$otherExpectation(\"comment only line\");\n var peg$e6 = peg$otherExpectation(\"non-var token\");\n var peg$e7 = peg$otherExpectation(\"token\");\n var peg$e8 = peg$otherExpectation(\"same line comment\");\n var peg$e9 = peg$otherExpectation(\"own line comment\");\n var peg$e10 = peg$otherExpectation(\",\");\n var peg$e11 = peg$otherExpectation(\"@\");\n var peg$e12 = peg$otherExpectation(\"variable token\");\n var peg$e13 = peg$otherExpectation(\"+/-\");\n var peg$e14 = peg$otherExpectation(\"=\");\n var peg$f0 = function(a, b) {\n return a.concat(b ? b : []);\n };\n var peg$f1 = function() {\n return [];\n };\n var peg$f2 = function(a, b, c) {\n return a.concat(b, c);\n };\n var peg$f3 = function(op, a, b, c) {\n return { type: \"item\", op, variable: b, content: a.concat(b, c) };\n };\n var peg$f4 = function(op, a) {\n return { type: \"item\", op, variable: null, content: a };\n };\n var peg$f5 = function(line, sep, comment) {\n return { ...line, sep: [].concat(sep), trailingComment: comment };\n };\n var peg$f6 = function(line, comment) {\n return { ...line, trailingComment: comment };\n };\n var peg$f7 = function(eq, ann) {\n return {\n type: \"line\",\n equation: eq,\n annotation: ann,\n sep: null\n };\n };\n var peg$f8 = function(at, ann) {\n return at ? { type: \"annotation\", marker: at, content: ann } : null;\n };\n var peg$f9 = function(left, eq, right) {\n return { type: \"equation\", left, right, equals: eq };\n };\n var peg$f10 = function(x) {\n return x;\n };\n var peg$f11 = function(x) {\n return {\n type: \"line\",\n trailingComment: x\n };\n };\n var peg$f12 = function(v, s) {\n return [v].concat(s ? s : []);\n };\n var peg$f13 = function(t) {\n return t;\n };\n var peg$f14 = function(x) {\n return x;\n };\n var peg$f15 = function(x) {\n return x;\n };\n var peg$f16 = function(tok) {\n return options.isSameLineComment(tok);\n };\n var peg$f17 = function(tok) {\n return tok;\n };\n var peg$f18 = function(tok) {\n return options.isOwnLineComment(tok);\n };\n var peg$f19 = function(tok) {\n return tok;\n };\n var peg$f20 = function(tok) {\n return options.isWhitespace(tok);\n };\n var peg$f21 = function(tok) {\n return tok;\n };\n var peg$f22 = function(tok) {\n return options.isSep(tok);\n };\n var peg$f23 = function(tok) {\n return tok;\n };\n var peg$f24 = function(tok) {\n return options.isAt(tok);\n };\n var peg$f25 = function(tok) {\n return tok;\n };\n var peg$f26 = function(tok) {\n return options.isVar(tok);\n };\n var peg$f27 = function(tok) {\n return tok;\n };\n var peg$f28 = function(tok) {\n return options.isOperation(tok);\n };\n var peg$f29 = function(tok) {\n return tok;\n };\n var peg$f30 = function(tok) {\n return options.isEquals(tok);\n };\n var peg$f31 = function(tok) {\n return tok;\n };\n var peg$f32 = function(tok) {\n return options.isSubscript(tok);\n };\n var peg$f33 = function(tok) {\n return tok;\n };\n var peg$currPos = 0;\n var peg$savedPos = 0;\n var peg$posDetailsCache = [{ line: 1, column: 1 }];\n var peg$maxFailPos = 0;\n var peg$maxFailExpected = [];\n var peg$silentFails = 0;\n var peg$result;\n if (\"startRule\" in options) {\n if (!(options.startRule in peg$startRuleFunctions)) {\n throw new Error(`Can't start parsing from rule \"` + options.startRule + '\".');\n }\n peg$startRuleFunction = peg$startRuleFunctions[options.startRule];\n }\n function text() {\n return input.substring(peg$savedPos, peg$currPos);\n }\n function offset() {\n return peg$savedPos;\n }\n function range() {\n return {\n source: peg$source,\n start: peg$savedPos,\n end: peg$currPos\n };\n }\n function location() {\n return peg$computeLocation(peg$savedPos, peg$currPos);\n }\n function expected(description, location2) {\n location2 = location2 !== void 0 ? location2 : peg$computeLocation(peg$savedPos, peg$currPos);\n throw peg$buildStructuredError(\n [peg$otherExpectation(description)],\n input.substring(peg$savedPos, peg$currPos),\n location2\n );\n }\n function error(message, location2) {\n location2 = location2 !== void 0 ? location2 : peg$computeLocation(peg$savedPos, peg$currPos);\n throw peg$buildSimpleError(message, location2);\n }\n function peg$literalExpectation(text2, ignoreCase) {\n return { type: \"literal\", text: text2, ignoreCase };\n }\n function peg$classExpectation(parts, inverted, ignoreCase) {\n return { type: \"class\", parts, inverted, ignoreCase };\n }\n function peg$anyExpectation() {\n return { type: \"any\" };\n }\n function peg$endExpectation() {\n return { type: \"end\" };\n }\n function peg$otherExpectation(description) {\n return { type: \"other\", description };\n }\n function peg$computePosDetails(pos) {\n var details = peg$posDetailsCache[pos];\n var p;\n if (details) {\n return details;\n } else {\n p = pos - 1;\n while (!peg$posDetailsCache[p]) {\n p--;\n }\n details = peg$posDetailsCache[p];\n details = {\n line: details.line,\n column: details.column\n };\n while (p < pos) {\n if (input.charCodeAt(p) === 10) {\n details.line++;\n details.column = 1;\n } else {\n details.column++;\n }\n p++;\n }\n peg$posDetailsCache[pos] = details;\n return details;\n }\n }\n function peg$computeLocation(startPos, endPos, offset2) {\n var startPosDetails = peg$computePosDetails(startPos);\n var endPosDetails = peg$computePosDetails(endPos);\n var res = {\n source: peg$source,\n start: {\n offset: startPos,\n line: startPosDetails.line,\n column: startPosDetails.column\n },\n end: {\n offset: endPos,\n line: endPosDetails.line,\n column: endPosDetails.column\n }\n };\n if (offset2 && peg$source && typeof peg$source.offset === \"function\") {\n res.start = peg$source.offset(res.start);\n res.end = peg$source.offset(res.end);\n }\n return res;\n }\n function peg$fail(expected2) {\n if (peg$currPos < peg$maxFailPos) {\n return;\n }\n if (peg$currPos > peg$maxFailPos) {\n peg$maxFailPos = peg$currPos;\n peg$maxFailExpected = [];\n }\n peg$maxFailExpected.push(expected2);\n }\n function peg$buildSimpleError(message, location2) {\n return new peg$SyntaxError(message, null, null, location2);\n }\n function peg$buildStructuredError(expected2, found, location2) {\n return new peg$SyntaxError(\n peg$SyntaxError.buildMessage(expected2, found),\n expected2,\n found,\n location2\n );\n }\n function peg$parsebody() {\n var s0, s1, s2;\n s0 = peg$currPos;\n s1 = [];\n s2 = peg$parsecomment_only_line();\n if (s2 === peg$FAILED) {\n s2 = peg$parseline_with_sep();\n if (s2 === peg$FAILED) {\n s2 = peg$parsepartial_line_with_comment();\n }\n }\n while (s2 !== peg$FAILED) {\n s1.push(s2);\n s2 = peg$parsecomment_only_line();\n if (s2 === peg$FAILED) {\n s2 = peg$parseline_with_sep();\n if (s2 === peg$FAILED) {\n s2 = peg$parsepartial_line_with_comment();\n }\n }\n }\n s2 = peg$parseline_without_sep();\n if (s2 === peg$FAILED) {\n s2 = peg$parseEOL();\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f0(s1, s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n if (s0 === peg$FAILED) {\n s0 = peg$currPos;\n s1 = peg$parseEOL();\n if (s1 !== peg$FAILED) {\n peg$savedPos = s0;\n s1 = peg$f1();\n }\n s0 = s1;\n }\n return s0;\n }\n function peg$parsepartial_item() {\n var s0, s1, s2, s3, s4, s5, s6, s7, s8;\n peg$silentFails++;\n s0 = peg$currPos;\n s1 = [];\n s2 = peg$parse_();\n while (s2 !== peg$FAILED) {\n s1.push(s2);\n s2 = peg$parse_();\n }\n s2 = [];\n s3 = peg$parsenon_var_token();\n while (s3 !== peg$FAILED) {\n s2.push(s3);\n s3 = peg$parsenon_var_token();\n }\n s3 = [];\n s4 = peg$parse_();\n while (s4 !== peg$FAILED) {\n s3.push(s4);\n s4 = peg$parse_();\n }\n s4 = peg$parsevar();\n if (s4 !== peg$FAILED) {\n s5 = [];\n s6 = peg$parse_();\n while (s6 !== peg$FAILED) {\n s5.push(s6);\n s6 = peg$parse_();\n }\n s6 = [];\n s7 = peg$parsetoken();\n while (s7 !== peg$FAILED) {\n s6.push(s7);\n s7 = peg$parsetoken();\n }\n s7 = [];\n s8 = peg$parse_();\n while (s8 !== peg$FAILED) {\n s7.push(s8);\n s8 = peg$parse_();\n }\n peg$savedPos = s0;\n s0 = peg$f2(s2, s4, s6);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n return s0;\n }\n function peg$parseitem() {\n var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;\n peg$silentFails++;\n s0 = peg$currPos;\n s1 = peg$parseoperation();\n if (s1 === peg$FAILED) {\n s1 = null;\n }\n s2 = [];\n s3 = peg$parse_();\n while (s3 !== peg$FAILED) {\n s2.push(s3);\n s3 = peg$parse_();\n }\n s3 = [];\n s4 = peg$parsenon_var_token();\n while (s4 !== peg$FAILED) {\n s3.push(s4);\n s4 = peg$parsenon_var_token();\n }\n s4 = [];\n s5 = peg$parse_();\n while (s5 !== peg$FAILED) {\n s4.push(s5);\n s5 = peg$parse_();\n }\n s5 = peg$parsevar();\n if (s5 !== peg$FAILED) {\n s6 = [];\n s7 = peg$parse_();\n while (s7 !== peg$FAILED) {\n s6.push(s7);\n s7 = peg$parse_();\n }\n s7 = [];\n s8 = peg$parsetoken();\n while (s8 !== peg$FAILED) {\n s7.push(s8);\n s8 = peg$parsetoken();\n }\n s8 = [];\n s9 = peg$parse_();\n while (s9 !== peg$FAILED) {\n s8.push(s9);\n s9 = peg$parse_();\n }\n peg$savedPos = s0;\n s0 = peg$f3(s1, s3, s5, s7);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n if (s0 === peg$FAILED) {\n s0 = peg$currPos;\n s1 = peg$parseoperation();\n if (s1 === peg$FAILED) {\n s1 = null;\n }\n s2 = [];\n s3 = peg$parse_();\n while (s3 !== peg$FAILED) {\n s2.push(s3);\n s3 = peg$parse_();\n }\n s3 = [];\n s4 = peg$parsenon_var_token();\n if (s4 !== peg$FAILED) {\n while (s4 !== peg$FAILED) {\n s3.push(s4);\n s4 = peg$parsenon_var_token();\n }\n } else {\n s3 = peg$FAILED;\n }\n if (s3 !== peg$FAILED) {\n s4 = [];\n s5 = peg$parse_();\n while (s5 !== peg$FAILED) {\n s4.push(s5);\n s5 = peg$parse_();\n }\n peg$savedPos = s0;\n s0 = peg$f4(s1, s3);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e1);\n }\n }\n return s0;\n }\n function peg$parseline_with_sep() {\n var s0, s1, s2, s3;\n s0 = peg$currPos;\n s1 = peg$parseline_without_sep();\n if (s1 !== peg$FAILED) {\n s2 = peg$parsesep();\n if (s2 !== peg$FAILED) {\n s3 = peg$parsetrailing_comment();\n if (s3 === peg$FAILED) {\n s3 = null;\n }\n peg$savedPos = s0;\n s0 = peg$f5(s1, s2, s3);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parsepartial_line_with_comment() {\n var s0, s1, s2;\n s0 = peg$currPos;\n s1 = peg$parseline_without_sep();\n if (s1 !== peg$FAILED) {\n s2 = peg$parsetrailing_comment();\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f6(s1, s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parseline_without_sep() {\n var s0, s1, s2, s3;\n s0 = peg$currPos;\n s1 = peg$currPos;\n peg$silentFails++;\n if (input.length > peg$currPos) {\n s2 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s2 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e2);\n }\n }\n peg$silentFails--;\n if (s2 !== peg$FAILED) {\n peg$currPos = s1;\n s1 = void 0;\n } else {\n s1 = peg$FAILED;\n }\n if (s1 !== peg$FAILED) {\n s2 = peg$parseequation();\n s3 = peg$parseannotation();\n if (s3 === peg$FAILED) {\n s3 = null;\n }\n peg$savedPos = s0;\n s0 = peg$f7(s2, s3);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parseannotation() {\n var s0, s1, s2, s3;\n s0 = peg$currPos;\n s1 = peg$parseat();\n if (s1 !== peg$FAILED) {\n s2 = [];\n s3 = peg$parsenon_sep_token();\n while (s3 !== peg$FAILED) {\n s2.push(s3);\n s3 = peg$parsenon_sep_token();\n }\n peg$savedPos = s0;\n s0 = peg$f8(s1, s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parseequation() {\n var s0, s1, s2, s3, s4;\n peg$silentFails++;\n s0 = peg$currPos;\n s1 = [];\n s2 = peg$parseitem();\n while (s2 !== peg$FAILED) {\n s1.push(s2);\n s2 = peg$parseitem();\n }\n s2 = peg$parseequals();\n if (s2 === peg$FAILED) {\n s2 = null;\n }\n s3 = [];\n s4 = peg$parsetoken();\n if (s4 === peg$FAILED) {\n s4 = peg$parseoperation();\n }\n while (s4 !== peg$FAILED) {\n s3.push(s4);\n s4 = peg$parsetoken();\n if (s4 === peg$FAILED) {\n s4 = peg$parseoperation();\n }\n }\n peg$savedPos = s0;\n s0 = peg$f9(s1, s2, s3);\n peg$silentFails--;\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e3);\n }\n return s0;\n }\n function peg$parsetrailing_comment() {\n var s0, s1, s2;\n peg$silentFails++;\n s0 = peg$currPos;\n s1 = [];\n s2 = peg$parse_();\n while (s2 !== peg$FAILED) {\n s1.push(s2);\n s2 = peg$parse_();\n }\n s2 = peg$parsesame_line_comment();\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f10(s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e4);\n }\n }\n return s0;\n }\n function peg$parsecomment_only_line() {\n var s0, s1, s2;\n peg$silentFails++;\n s0 = peg$currPos;\n s1 = [];\n s2 = peg$parse_();\n while (s2 !== peg$FAILED) {\n s1.push(s2);\n s2 = peg$parse_();\n }\n s2 = peg$parseown_line_comment();\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f11(s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e5);\n }\n }\n return s0;\n }\n function peg$parsevar() {\n var s0, s1, s2, s3;\n s0 = peg$currPos;\n s1 = peg$parsevar_token();\n if (s1 !== peg$FAILED) {\n s2 = [];\n s3 = peg$parse_();\n while (s3 !== peg$FAILED) {\n s2.push(s3);\n s3 = peg$parse_();\n }\n s3 = peg$parsesubscript();\n if (s3 === peg$FAILED) {\n s3 = null;\n }\n peg$savedPos = s0;\n s0 = peg$f12(s1, s3);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parsenon_var_token() {\n var s0, s1, s2;\n peg$silentFails++;\n s0 = peg$currPos;\n s1 = peg$currPos;\n peg$silentFails++;\n s2 = peg$parsevar();\n peg$silentFails--;\n if (s2 === peg$FAILED) {\n s1 = void 0;\n } else {\n peg$currPos = s1;\n s1 = peg$FAILED;\n }\n if (s1 !== peg$FAILED) {\n s2 = peg$parsetoken();\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f13(s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e6);\n }\n }\n return s0;\n }\n function peg$parsenon_sep_token() {\n var s0, s1, s2;\n s0 = peg$currPos;\n s1 = peg$currPos;\n peg$silentFails++;\n s2 = peg$parsesep();\n if (s2 === peg$FAILED) {\n s2 = peg$parsetrailing_comment();\n if (s2 === peg$FAILED) {\n s2 = peg$parseown_line_comment();\n }\n }\n peg$silentFails--;\n if (s2 === peg$FAILED) {\n s1 = void 0;\n } else {\n peg$currPos = s1;\n s1 = peg$FAILED;\n }\n if (s1 !== peg$FAILED) {\n if (input.length > peg$currPos) {\n s2 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s2 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e2);\n }\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f14(s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parsetoken() {\n var s0, s1, s2;\n peg$silentFails++;\n s0 = peg$currPos;\n s1 = peg$currPos;\n peg$silentFails++;\n s2 = peg$parsesep();\n if (s2 === peg$FAILED) {\n s2 = peg$parseat();\n if (s2 === peg$FAILED) {\n s2 = peg$parseoperation();\n if (s2 === peg$FAILED) {\n s2 = peg$parseequals();\n if (s2 === peg$FAILED) {\n s2 = peg$parsetrailing_comment();\n if (s2 === peg$FAILED) {\n s2 = peg$parseown_line_comment();\n }\n }\n }\n }\n }\n peg$silentFails--;\n if (s2 === peg$FAILED) {\n s1 = void 0;\n } else {\n peg$currPos = s1;\n s1 = peg$FAILED;\n }\n if (s1 !== peg$FAILED) {\n if (input.length > peg$currPos) {\n s2 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s2 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e2);\n }\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f15(s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e7);\n }\n }\n return s0;\n }\n function peg$parsesame_line_comment() {\n var s0, s1, s2;\n peg$silentFails++;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e2);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f16(s1);\n if (s2) {\n s2 = void 0;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f17(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e8);\n }\n }\n return s0;\n }\n function peg$parseown_line_comment() {\n var s0, s1, s2;\n peg$silentFails++;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e2);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f18(s1);\n if (s2) {\n s2 = void 0;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f19(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e9);\n }\n }\n return s0;\n }\n function peg$parse_() {\n var s0, s1, s2;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e2);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f20(s1);\n if (s2) {\n s2 = void 0;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f21(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parsesep() {\n var s0, s1, s2;\n peg$silentFails++;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e2);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f22(s1);\n if (s2) {\n s2 = void 0;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f23(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e10);\n }\n }\n return s0;\n }\n function peg$parseat() {\n var s0, s1, s2;\n peg$silentFails++;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e2);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f24(s1);\n if (s2) {\n s2 = void 0;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f25(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e11);\n }\n }\n return s0;\n }\n function peg$parsevar_token() {\n var s0, s1, s2;\n peg$silentFails++;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e2);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f26(s1);\n if (s2) {\n s2 = void 0;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f27(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e12);\n }\n }\n return s0;\n }\n function peg$parseoperation() {\n var s0, s1, s2, s3, s4;\n peg$silentFails++;\n s0 = peg$currPos;\n s1 = [];\n s2 = peg$parse_();\n while (s2 !== peg$FAILED) {\n s1.push(s2);\n s2 = peg$parse_();\n }\n if (input.length > peg$currPos) {\n s2 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s2 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e2);\n }\n }\n if (s2 !== peg$FAILED) {\n s3 = [];\n s4 = peg$parse_();\n while (s4 !== peg$FAILED) {\n s3.push(s4);\n s4 = peg$parse_();\n }\n peg$savedPos = peg$currPos;\n s4 = peg$f28(s2);\n if (s4) {\n s4 = void 0;\n } else {\n s4 = peg$FAILED;\n }\n if (s4 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f29(s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e13);\n }\n }\n return s0;\n }\n function peg$parseequals() {\n var s0, s1, s2;\n peg$silentFails++;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e2);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f30(s1);\n if (s2) {\n s2 = void 0;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f31(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e14);\n }\n }\n return s0;\n }\n function peg$parsesubscript() {\n var s0, s1, s2;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e2);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f32(s1);\n if (s2) {\n s2 = void 0;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f33(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parseEOL() {\n var s0, s1;\n s0 = peg$currPos;\n peg$silentFails++;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e2);\n }\n }\n peg$silentFails--;\n if (s1 === peg$FAILED) {\n s0 = void 0;\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n if (!options.isWhitespace) {\n try {\n Object.assign(options, {\n isSep: (node) => node.type === \"string\" && node.content === \",\",\n isVar: (node) => node.type === \"string\" && node.content.match(/[a-zA-Z]/),\n isOperation: (node) => node.type === \"string\" && node.content.match(/[+-]/),\n isEquals: (node) => node.type === \"string\" && node.content === \"=\",\n isAt: (node) => node.type === \"string\" && node.content === \"@\",\n isSubscript: (node) => node.content === \"_\",\n isWhitespace: (node) => node.type === \"whitespace\",\n isSameLineComment: (node) => node.type === \"comment\" && node.sameline,\n isOwnLineComment: (node) => node.type === \"comment\" && !node.sameline\n });\n } catch (e) {\n console.warn(\"Error when initializing parser\", e);\n }\n }\n peg$result = peg$startRuleFunction();\n if (peg$result !== peg$FAILED && peg$currPos === input.length) {\n return peg$result;\n } else {\n if (peg$result !== peg$FAILED && peg$currPos < input.length) {\n peg$fail(peg$endExpectation());\n }\n throw peg$buildStructuredError(\n peg$maxFailExpected,\n peg$maxFailPos < input.length ? input.charAt(peg$maxFailPos) : null,\n peg$maxFailPos < input.length ? peg$computeLocation(peg$maxFailPos, peg$maxFailPos + 1) : peg$computeLocation(peg$maxFailPos, peg$maxFailPos)\n );\n }\n }\n return {\n SyntaxError: peg$SyntaxError,\n parse: peg$parse\n };\n }()\n);\n","export default (\n // Generated by Peggy 3.0.2.\n //\n // https://peggyjs.org/\n function() {\n \"use strict\";\n function peg$subclass(child, parent) {\n function C() {\n this.constructor = child;\n }\n C.prototype = parent.prototype;\n child.prototype = new C();\n }\n function peg$SyntaxError(message, expected, found, location) {\n var self = Error.call(this, message);\n if (Object.setPrototypeOf) {\n Object.setPrototypeOf(self, peg$SyntaxError.prototype);\n }\n self.expected = expected;\n self.found = found;\n self.location = location;\n self.name = \"SyntaxError\";\n return self;\n }\n peg$subclass(peg$SyntaxError, Error);\n function peg$padEnd(str, targetLength, padString) {\n padString = padString || \" \";\n if (str.length > targetLength) {\n return str;\n }\n targetLength -= str.length;\n padString += padString.repeat(targetLength);\n return str + padString.slice(0, targetLength);\n }\n peg$SyntaxError.prototype.format = function(sources) {\n var str = \"Error: \" + this.message;\n if (this.location) {\n var src = null;\n var k;\n for (k = 0; k < sources.length; k++) {\n if (sources[k].source === this.location.source) {\n src = sources[k].text.split(/\\r\\n|\\n|\\r/g);\n break;\n }\n }\n var s = this.location.start;\n var offset_s = this.location.source && typeof this.location.source.offset === \"function\" ? this.location.source.offset(s) : s;\n var loc = this.location.source + \":\" + offset_s.line + \":\" + offset_s.column;\n if (src) {\n var e = this.location.end;\n var filler = peg$padEnd(\"\", offset_s.line.toString().length, \" \");\n var line = src[s.line - 1];\n var last = s.line === e.line ? e.column : line.length + 1;\n var hatLen = last - s.column || 1;\n str += \"\\n --> \" + loc + \"\\n\" + filler + \" |\\n\" + offset_s.line + \" | \" + line + \"\\n\" + filler + \" | \" + peg$padEnd(\"\", s.column - 1, \" \") + peg$padEnd(\"\", hatLen, \"^\");\n } else {\n str += \"\\n at \" + loc;\n }\n }\n return str;\n };\n peg$SyntaxError.buildMessage = function(expected, found) {\n var DESCRIBE_EXPECTATION_FNS = {\n literal: function(expectation) {\n return '\"' + literalEscape(expectation.text) + '\"';\n },\n class: function(expectation) {\n var escapedParts = expectation.parts.map(function(part) {\n return Array.isArray(part) ? classEscape(part[0]) + \"-\" + classEscape(part[1]) : classEscape(part);\n });\n return \"[\" + (expectation.inverted ? \"^\" : \"\") + escapedParts.join(\"\") + \"]\";\n },\n any: function() {\n return \"any character\";\n },\n end: function() {\n return \"end of input\";\n },\n other: function(expectation) {\n return expectation.description;\n }\n };\n function hex(ch) {\n return ch.charCodeAt(0).toString(16).toUpperCase();\n }\n function literalEscape(s) {\n return s.replace(/\\\\/g, \"\\\\\\\\\").replace(/\"/g, '\\\\\"').replace(/\\0/g, \"\\\\0\").replace(/\\t/g, \"\\\\t\").replace(/\\n/g, \"\\\\n\").replace(/\\r/g, \"\\\\r\").replace(/[\\x00-\\x0F]/g, function(ch) {\n return \"\\\\x0\" + hex(ch);\n }).replace(/[\\x10-\\x1F\\x7F-\\x9F]/g, function(ch) {\n return \"\\\\x\" + hex(ch);\n });\n }\n function classEscape(s) {\n return s.replace(/\\\\/g, \"\\\\\\\\\").replace(/\\]/g, \"\\\\]\").replace(/\\^/g, \"\\\\^\").replace(/-/g, \"\\\\-\").replace(/\\0/g, \"\\\\0\").replace(/\\t/g, \"\\\\t\").replace(/\\n/g, \"\\\\n\").replace(/\\r/g, \"\\\\r\").replace(/[\\x00-\\x0F]/g, function(ch) {\n return \"\\\\x0\" + hex(ch);\n }).replace(/[\\x10-\\x1F\\x7F-\\x9F]/g, function(ch) {\n return \"\\\\x\" + hex(ch);\n });\n }\n function describeExpectation(expectation) {\n return DESCRIBE_EXPECTATION_FNS[expectation.type](expectation);\n }\n function describeExpected(expected2) {\n var descriptions = expected2.map(describeExpectation);\n var i, j;\n descriptions.sort();\n if (descriptions.length > 0) {\n for (i = 1, j = 1; i < descriptions.length; i++) {\n if (descriptions[i - 1] !== descriptions[i]) {\n descriptions[j] = descriptions[i];\n j++;\n }\n }\n descriptions.length = j;\n }\n switch (descriptions.length) {\n case 1:\n return descriptions[0];\n case 2:\n return descriptions[0] + \" or \" + descriptions[1];\n default:\n return descriptions.slice(0, -1).join(\", \") + \", or \" + descriptions[descriptions.length - 1];\n }\n }\n function describeFound(found2) {\n return found2 ? '\"' + literalEscape(found2) + '\"' : \"end of input\";\n }\n return \"Expected \" + describeExpected(expected) + \" but \" + describeFound(found) + \" found.\";\n };\n function peg$parse(input, options) {\n options = options !== void 0 ? options : {};\n var peg$FAILED = {};\n var peg$source = options.grammarSource;\n var peg$startRuleFunctions = { root: peg$parseroot };\n var peg$startRuleFunction = peg$parseroot;\n var peg$c0 = \"plus\";\n var peg$c1 = \"minus\";\n var peg$c2 = \"pt\";\n var peg$c3 = \"mm\";\n var peg$c4 = \"cm\";\n var peg$c5 = \"in\";\n var peg$c6 = \"ex\";\n var peg$c7 = \"em\";\n var peg$c8 = \"bp\";\n var peg$c9 = \"pc\";\n var peg$c10 = \"dd\";\n var peg$c11 = \"cc\";\n var peg$c12 = \"nd\";\n var peg$c13 = \"nc\";\n var peg$c14 = \"sp\";\n var peg$c15 = \"filll\";\n var peg$c16 = \"fill\";\n var peg$c17 = \"fil\";\n var peg$c18 = \".\";\n var peg$c19 = \"+\";\n var peg$c20 = \"-\";\n var peg$r0 = /^[0-9]/;\n var peg$e0 = peg$anyExpectation();\n var peg$e1 = peg$literalExpectation(\"plus\", false);\n var peg$e2 = peg$literalExpectation(\"minus\", false);\n var peg$e3 = peg$literalExpectation(\"pt\", false);\n var peg$e4 = peg$literalExpectation(\"mm\", false);\n var peg$e5 = peg$literalExpectation(\"cm\", false);\n var peg$e6 = peg$literalExpectation(\"in\", false);\n var peg$e7 = peg$literalExpectation(\"ex\", false);\n var peg$e8 = peg$literalExpectation(\"em\", false);\n var peg$e9 = peg$literalExpectation(\"bp\", false);\n var peg$e10 = peg$literalExpectation(\"pc\", false);\n var peg$e11 = peg$literalExpectation(\"dd\", false);\n var peg$e12 = peg$literalExpectation(\"cc\", false);\n var peg$e13 = peg$literalExpectation(\"nd\", false);\n var peg$e14 = peg$literalExpectation(\"nc\", false);\n var peg$e15 = peg$literalExpectation(\"sp\", false);\n var peg$e16 = peg$literalExpectation(\"filll\", false);\n var peg$e17 = peg$literalExpectation(\"fill\", false);\n var peg$e18 = peg$literalExpectation(\"fil\", false);\n var peg$e19 = peg$otherExpectation(\"number\");\n var peg$e20 = peg$classExpectation([[\"0\", \"9\"]], false, false);\n var peg$e21 = peg$literalExpectation(\".\", false);\n var peg$e22 = peg$literalExpectation(\"+\", false);\n var peg$e23 = peg$literalExpectation(\"-\", false);\n var peg$f0 = function(b, st, sh) {\n return {\n type: \"glue\",\n fixed: b,\n stretchable: st,\n shrinkable: sh,\n position: location()\n };\n };\n var peg$f1 = function(glue) {\n return glue;\n };\n var peg$f2 = function(n, u) {\n return { type: \"dim\", value: n, unit: u };\n };\n var peg$f3 = function(n, u) {\n return { type: \"dim\", value: n, unit: u };\n };\n var peg$f4 = function(n, u) {\n return { type: \"dim\", value: n, unit: u };\n };\n var peg$f5 = function(n) {\n return parseFloat(n);\n };\n var peg$currPos = 0;\n var peg$savedPos = 0;\n var peg$posDetailsCache = [{ line: 1, column: 1 }];\n var peg$maxFailPos = 0;\n var peg$maxFailExpected = [];\n var peg$silentFails = 0;\n var peg$result;\n if (\"startRule\" in options) {\n if (!(options.startRule in peg$startRuleFunctions)) {\n throw new Error(`Can't start parsing from rule \"` + options.startRule + '\".');\n }\n peg$startRuleFunction = peg$startRuleFunctions[options.startRule];\n }\n function text() {\n return input.substring(peg$savedPos, peg$currPos);\n }\n function offset() {\n return peg$savedPos;\n }\n function range() {\n return {\n source: peg$source,\n start: peg$savedPos,\n end: peg$currPos\n };\n }\n function location() {\n return peg$computeLocation(peg$savedPos, peg$currPos);\n }\n function expected(description, location2) {\n location2 = location2 !== void 0 ? location2 : peg$computeLocation(peg$savedPos, peg$currPos);\n throw peg$buildStructuredError(\n [peg$otherExpectation(description)],\n input.substring(peg$savedPos, peg$currPos),\n location2\n );\n }\n function error(message, location2) {\n location2 = location2 !== void 0 ? location2 : peg$computeLocation(peg$savedPos, peg$currPos);\n throw peg$buildSimpleError(message, location2);\n }\n function peg$literalExpectation(text2, ignoreCase) {\n return { type: \"literal\", text: text2, ignoreCase };\n }\n function peg$classExpectation(parts, inverted, ignoreCase) {\n return { type: \"class\", parts, inverted, ignoreCase };\n }\n function peg$anyExpectation() {\n return { type: \"any\" };\n }\n function peg$endExpectation() {\n return { type: \"end\" };\n }\n function peg$otherExpectation(description) {\n return { type: \"other\", description };\n }\n function peg$computePosDetails(pos) {\n var details = peg$posDetailsCache[pos];\n var p;\n if (details) {\n return details;\n } else {\n p = pos - 1;\n while (!peg$posDetailsCache[p]) {\n p--;\n }\n details = peg$posDetailsCache[p];\n details = {\n line: details.line,\n column: details.column\n };\n while (p < pos) {\n if (input.charCodeAt(p) === 10) {\n details.line++;\n details.column = 1;\n } else {\n details.column++;\n }\n p++;\n }\n peg$posDetailsCache[pos] = details;\n return details;\n }\n }\n function peg$computeLocation(startPos, endPos, offset2) {\n var startPosDetails = peg$computePosDetails(startPos);\n var endPosDetails = peg$computePosDetails(endPos);\n var res = {\n source: peg$source,\n start: {\n offset: startPos,\n line: startPosDetails.line,\n column: startPosDetails.column\n },\n end: {\n offset: endPos,\n line: endPosDetails.line,\n column: endPosDetails.column\n }\n };\n if (offset2 && peg$source && typeof peg$source.offset === \"function\") {\n res.start = peg$source.offset(res.start);\n res.end = peg$source.offset(res.end);\n }\n return res;\n }\n function peg$fail(expected2) {\n if (peg$currPos < peg$maxFailPos) {\n return;\n }\n if (peg$currPos > peg$maxFailPos) {\n peg$maxFailPos = peg$currPos;\n peg$maxFailExpected = [];\n }\n peg$maxFailExpected.push(expected2);\n }\n function peg$buildSimpleError(message, location2) {\n return new peg$SyntaxError(message, null, null, location2);\n }\n function peg$buildStructuredError(expected2, found, location2) {\n return new peg$SyntaxError(\n peg$SyntaxError.buildMessage(expected2, found),\n expected2,\n found,\n location2\n );\n }\n function peg$parseroot() {\n var s0, s1, s2, s3, s4;\n s0 = peg$currPos;\n s1 = peg$currPos;\n s2 = peg$parsebase();\n if (s2 !== peg$FAILED) {\n s3 = peg$parsestretchable();\n if (s3 === peg$FAILED) {\n s3 = null;\n }\n s4 = peg$parseshrinkable();\n if (s4 === peg$FAILED) {\n s4 = null;\n }\n peg$savedPos = s1;\n s1 = peg$f0(s2, s3, s4);\n } else {\n peg$currPos = s1;\n s1 = peg$FAILED;\n }\n if (s1 !== peg$FAILED) {\n s2 = [];\n if (input.length > peg$currPos) {\n s3 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s3 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n while (s3 !== peg$FAILED) {\n s2.push(s3);\n if (input.length > peg$currPos) {\n s3 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s3 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n }\n peg$savedPos = s0;\n s0 = peg$f1(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parsebase() {\n var s0, s1, s2;\n s0 = peg$currPos;\n s1 = peg$parsenumber();\n if (s1 !== peg$FAILED) {\n s2 = peg$parseunit();\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f2(s1, s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parsestretchable() {\n var s0, s1, s2, s3;\n s0 = peg$currPos;\n if (input.substr(peg$currPos, 4) === peg$c0) {\n s1 = peg$c0;\n peg$currPos += 4;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e1);\n }\n }\n if (s1 !== peg$FAILED) {\n s2 = peg$parsenumber();\n if (s2 !== peg$FAILED) {\n s3 = peg$parserubber_unit();\n if (s3 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f3(s2, s3);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parseshrinkable() {\n var s0, s1, s2, s3;\n s0 = peg$currPos;\n if (input.substr(peg$currPos, 5) === peg$c1) {\n s1 = peg$c1;\n peg$currPos += 5;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e2);\n }\n }\n if (s1 !== peg$FAILED) {\n s2 = peg$parsenumber();\n if (s2 !== peg$FAILED) {\n s3 = peg$parserubber_unit();\n if (s3 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f4(s2, s3);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parseunit() {\n var s0;\n if (input.substr(peg$currPos, 2) === peg$c2) {\n s0 = peg$c2;\n peg$currPos += 2;\n } else {\n s0 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e3);\n }\n }\n if (s0 === peg$FAILED) {\n if (input.substr(peg$currPos, 2) === peg$c3) {\n s0 = peg$c3;\n peg$currPos += 2;\n } else {\n s0 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e4);\n }\n }\n if (s0 === peg$FAILED) {\n if (input.substr(peg$currPos, 2) === peg$c4) {\n s0 = peg$c4;\n peg$currPos += 2;\n } else {\n s0 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e5);\n }\n }\n if (s0 === peg$FAILED) {\n if (input.substr(peg$currPos, 2) === peg$c5) {\n s0 = peg$c5;\n peg$currPos += 2;\n } else {\n s0 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e6);\n }\n }\n if (s0 === peg$FAILED) {\n if (input.substr(peg$currPos, 2) === peg$c6) {\n s0 = peg$c6;\n peg$currPos += 2;\n } else {\n s0 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e7);\n }\n }\n if (s0 === peg$FAILED) {\n if (input.substr(peg$currPos, 2) === peg$c7) {\n s0 = peg$c7;\n peg$currPos += 2;\n } else {\n s0 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e8);\n }\n }\n if (s0 === peg$FAILED) {\n if (input.substr(peg$currPos, 2) === peg$c8) {\n s0 = peg$c8;\n peg$currPos += 2;\n } else {\n s0 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e9);\n }\n }\n if (s0 === peg$FAILED) {\n if (input.substr(peg$currPos, 2) === peg$c9) {\n s0 = peg$c9;\n peg$currPos += 2;\n } else {\n s0 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e10);\n }\n }\n if (s0 === peg$FAILED) {\n if (input.substr(peg$currPos, 2) === peg$c10) {\n s0 = peg$c10;\n peg$currPos += 2;\n } else {\n s0 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e11);\n }\n }\n if (s0 === peg$FAILED) {\n if (input.substr(peg$currPos, 2) === peg$c11) {\n s0 = peg$c11;\n peg$currPos += 2;\n } else {\n s0 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e12);\n }\n }\n if (s0 === peg$FAILED) {\n if (input.substr(peg$currPos, 2) === peg$c12) {\n s0 = peg$c12;\n peg$currPos += 2;\n } else {\n s0 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e13);\n }\n }\n if (s0 === peg$FAILED) {\n if (input.substr(peg$currPos, 2) === peg$c13) {\n s0 = peg$c13;\n peg$currPos += 2;\n } else {\n s0 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e14);\n }\n }\n if (s0 === peg$FAILED) {\n if (input.substr(peg$currPos, 2) === peg$c14) {\n s0 = peg$c14;\n peg$currPos += 2;\n } else {\n s0 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e15);\n }\n }\n }\n }\n }\n }\n }\n }\n }\n }\n }\n }\n }\n }\n return s0;\n }\n function peg$parserubber_unit() {\n var s0;\n s0 = peg$parseunit();\n if (s0 === peg$FAILED) {\n if (input.substr(peg$currPos, 5) === peg$c15) {\n s0 = peg$c15;\n peg$currPos += 5;\n } else {\n s0 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e16);\n }\n }\n if (s0 === peg$FAILED) {\n if (input.substr(peg$currPos, 4) === peg$c16) {\n s0 = peg$c16;\n peg$currPos += 4;\n } else {\n s0 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e17);\n }\n }\n if (s0 === peg$FAILED) {\n if (input.substr(peg$currPos, 3) === peg$c17) {\n s0 = peg$c17;\n peg$currPos += 3;\n } else {\n s0 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e18);\n }\n }\n }\n }\n }\n return s0;\n }\n function peg$parsenumber() {\n var s0, s1, s2, s3, s4, s5, s6, s7, s8;\n peg$silentFails++;\n s0 = peg$currPos;\n s1 = peg$currPos;\n s2 = peg$currPos;\n s3 = peg$parsesign();\n if (s3 === peg$FAILED) {\n s3 = null;\n }\n s4 = peg$currPos;\n s5 = [];\n if (peg$r0.test(input.charAt(peg$currPos))) {\n s6 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s6 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e20);\n }\n }\n while (s6 !== peg$FAILED) {\n s5.push(s6);\n if (peg$r0.test(input.charAt(peg$currPos))) {\n s6 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s6 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e20);\n }\n }\n }\n if (input.charCodeAt(peg$currPos) === 46) {\n s6 = peg$c18;\n peg$currPos++;\n } else {\n s6 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e21);\n }\n }\n if (s6 !== peg$FAILED) {\n s7 = [];\n if (peg$r0.test(input.charAt(peg$currPos))) {\n s8 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s8 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e20);\n }\n }\n if (s8 !== peg$FAILED) {\n while (s8 !== peg$FAILED) {\n s7.push(s8);\n if (peg$r0.test(input.charAt(peg$currPos))) {\n s8 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s8 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e20);\n }\n }\n }\n } else {\n s7 = peg$FAILED;\n }\n if (s7 !== peg$FAILED) {\n s5 = [s5, s6, s7];\n s4 = s5;\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n if (s4 === peg$FAILED) {\n s4 = [];\n if (peg$r0.test(input.charAt(peg$currPos))) {\n s5 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s5 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e20);\n }\n }\n if (s5 !== peg$FAILED) {\n while (s5 !== peg$FAILED) {\n s4.push(s5);\n if (peg$r0.test(input.charAt(peg$currPos))) {\n s5 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s5 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e20);\n }\n }\n }\n } else {\n s4 = peg$FAILED;\n }\n }\n if (s4 !== peg$FAILED) {\n s3 = [s3, s4];\n s2 = s3;\n } else {\n peg$currPos = s2;\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n s1 = input.substring(s1, peg$currPos);\n } else {\n s1 = s2;\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = s0;\n s1 = peg$f5(s1);\n }\n s0 = s1;\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e19);\n }\n }\n return s0;\n }\n function peg$parsesign() {\n var s0;\n if (input.charCodeAt(peg$currPos) === 43) {\n s0 = peg$c19;\n peg$currPos++;\n } else {\n s0 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e22);\n }\n }\n if (s0 === peg$FAILED) {\n if (input.charCodeAt(peg$currPos) === 45) {\n s0 = peg$c20;\n peg$currPos++;\n } else {\n s0 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e23);\n }\n }\n }\n return s0;\n }\n function peg$parseEOL() {\n var s0, s1;\n s0 = peg$currPos;\n peg$silentFails++;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n peg$silentFails--;\n if (s1 === peg$FAILED) {\n s0 = void 0;\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n peg$result = peg$startRuleFunction();\n if (peg$result !== peg$FAILED && peg$currPos === input.length) {\n return peg$result;\n } else {\n if (peg$result !== peg$FAILED && peg$currPos < input.length) {\n peg$fail(peg$endExpectation());\n }\n throw peg$buildStructuredError(\n peg$maxFailExpected,\n peg$maxFailPos < input.length ? input.charAt(peg$maxFailPos) : null,\n peg$maxFailPos < input.length ? peg$computeLocation(peg$maxFailPos, peg$maxFailPos + 1) : peg$computeLocation(peg$maxFailPos, peg$maxFailPos)\n );\n }\n }\n return {\n SyntaxError: peg$SyntaxError,\n parse: peg$parse\n };\n }()\n);\n","export default (\n // Generated by Peggy 3.0.2.\n //\n // https://peggyjs.org/\n function() {\n \"use strict\";\n function peg$subclass(child, parent) {\n function C() {\n this.constructor = child;\n }\n C.prototype = parent.prototype;\n child.prototype = new C();\n }\n function peg$SyntaxError(message, expected, found, location) {\n var self = Error.call(this, message);\n if (Object.setPrototypeOf) {\n Object.setPrototypeOf(self, peg$SyntaxError.prototype);\n }\n self.expected = expected;\n self.found = found;\n self.location = location;\n self.name = \"SyntaxError\";\n return self;\n }\n peg$subclass(peg$SyntaxError, Error);\n function peg$padEnd(str, targetLength, padString) {\n padString = padString || \" \";\n if (str.length > targetLength) {\n return str;\n }\n targetLength -= str.length;\n padString += padString.repeat(targetLength);\n return str + padString.slice(0, targetLength);\n }\n peg$SyntaxError.prototype.format = function(sources) {\n var str = \"Error: \" + this.message;\n if (this.location) {\n var src = null;\n var k;\n for (k = 0; k < sources.length; k++) {\n if (sources[k].source === this.location.source) {\n src = sources[k].text.split(/\\r\\n|\\n|\\r/g);\n break;\n }\n }\n var s = this.location.start;\n var offset_s = this.location.source && typeof this.location.source.offset === \"function\" ? this.location.source.offset(s) : s;\n var loc = this.location.source + \":\" + offset_s.line + \":\" + offset_s.column;\n if (src) {\n var e = this.location.end;\n var filler = peg$padEnd(\"\", offset_s.line.toString().length, \" \");\n var line = src[s.line - 1];\n var last = s.line === e.line ? e.column : line.length + 1;\n var hatLen = last - s.column || 1;\n str += \"\\n --> \" + loc + \"\\n\" + filler + \" |\\n\" + offset_s.line + \" | \" + line + \"\\n\" + filler + \" | \" + peg$padEnd(\"\", s.column - 1, \" \") + peg$padEnd(\"\", hatLen, \"^\");\n } else {\n str += \"\\n at \" + loc;\n }\n }\n return str;\n };\n peg$SyntaxError.buildMessage = function(expected, found) {\n var DESCRIBE_EXPECTATION_FNS = {\n literal: function(expectation) {\n return '\"' + literalEscape(expectation.text) + '\"';\n },\n class: function(expectation) {\n var escapedParts = expectation.parts.map(function(part) {\n return Array.isArray(part) ? classEscape(part[0]) + \"-\" + classEscape(part[1]) : classEscape(part);\n });\n return \"[\" + (expectation.inverted ? \"^\" : \"\") + escapedParts.join(\"\") + \"]\";\n },\n any: function() {\n return \"any character\";\n },\n end: function() {\n return \"end of input\";\n },\n other: function(expectation) {\n return expectation.description;\n }\n };\n function hex(ch) {\n return ch.charCodeAt(0).toString(16).toUpperCase();\n }\n function literalEscape(s) {\n return s.replace(/\\\\/g, \"\\\\\\\\\").replace(/\"/g, '\\\\\"').replace(/\\0/g, \"\\\\0\").replace(/\\t/g, \"\\\\t\").replace(/\\n/g, \"\\\\n\").replace(/\\r/g, \"\\\\r\").replace(/[\\x00-\\x0F]/g, function(ch) {\n return \"\\\\x0\" + hex(ch);\n }).replace(/[\\x10-\\x1F\\x7F-\\x9F]/g, function(ch) {\n return \"\\\\x\" + hex(ch);\n });\n }\n function classEscape(s) {\n return s.replace(/\\\\/g, \"\\\\\\\\\").replace(/\\]/g, \"\\\\]\").replace(/\\^/g, \"\\\\^\").replace(/-/g, \"\\\\-\").replace(/\\0/g, \"\\\\0\").replace(/\\t/g, \"\\\\t\").replace(/\\n/g, \"\\\\n\").replace(/\\r/g, \"\\\\r\").replace(/[\\x00-\\x0F]/g, function(ch) {\n return \"\\\\x0\" + hex(ch);\n }).replace(/[\\x10-\\x1F\\x7F-\\x9F]/g, function(ch) {\n return \"\\\\x\" + hex(ch);\n });\n }\n function describeExpectation(expectation) {\n return DESCRIBE_EXPECTATION_FNS[expectation.type](expectation);\n }\n function describeExpected(expected2) {\n var descriptions = expected2.map(describeExpectation);\n var i, j;\n descriptions.sort();\n if (descriptions.length > 0) {\n for (i = 1, j = 1; i < descriptions.length; i++) {\n if (descriptions[i - 1] !== descriptions[i]) {\n descriptions[j] = descriptions[i];\n j++;\n }\n }\n descriptions.length = j;\n }\n switch (descriptions.length) {\n case 1:\n return descriptions[0];\n case 2:\n return descriptions[0] + \" or \" + descriptions[1];\n default:\n return descriptions.slice(0, -1).join(\", \") + \", or \" + descriptions[descriptions.length - 1];\n }\n }\n function describeFound(found2) {\n return found2 ? '\"' + literalEscape(found2) + '\"' : \"end of input\";\n }\n return \"Expected \" + describeExpected(expected) + \" but \" + describeFound(found) + \" found.\";\n };\n function peg$parse(input, options) {\n options = options !== void 0 ? options : {};\n var peg$FAILED = {};\n var peg$source = options.grammarSource;\n var peg$startRuleFunctions = { path_spec: peg$parsepath_spec, foreach_body: peg$parseforeach_body };\n var peg$startRuleFunction = peg$parsepath_spec;\n var peg$e0 = peg$anyExpectation();\n var peg$e1 = peg$otherExpectation(\"same line comment\");\n var peg$e2 = peg$otherExpectation(\"own line comment\");\n var peg$e3 = peg$otherExpectation(\"comment\");\n var peg$e4 = peg$otherExpectation(\"floating comment\");\n var peg$e5 = peg$otherExpectation(\"operation\");\n var peg$e6 = peg$otherExpectation(\"=\");\n var peg$f0 = function(v) {\n return v;\n };\n var peg$f1 = function(ops) {\n return { type: \"path_spec\", content: ops };\n };\n var peg$f2 = function(c1, op, comment) {\n return { op, comment };\n };\n var peg$f3 = function(c1, ops, c2, body) {\n const comments = [c1, ...ops.map((x) => x.comment), c2].filter(\n (x) => x\n );\n const attribute = ops.map((x) => x.op.content.content).join(\" \");\n return {\n type: \"animation\",\n comments,\n attribute,\n content: body.content\n };\n };\n var peg$f4 = function(start, b) {\n return { ...b, start, type: \"foreach\" };\n };\n var peg$f5 = function(c1, variables, options2, c2, c3, list, c4, command) {\n const comments = [c1, c2, c3, c4].filter((x) => x);\n return {\n type: \"foreach_body\",\n variables,\n options: options2 && options2.content,\n list,\n command,\n comments\n };\n };\n var peg$f6 = function(c1, options2, c2, body) {\n const comments = [c1, c2].filter((x) => x);\n return {\n type: \"svg_operation\",\n options: options2 && options2.content,\n content: body,\n comments\n };\n };\n var peg$f7 = function(c1, c2, coord, c3, c4, x) {\n return { coord: x, comment: c4 };\n };\n var peg$f8 = function(c1, c2, coord, c3, a, c5) {\n const comments = [c1, c2, c3, a && a.comment, c5].filter((x) => x);\n return {\n type: \"curve_to\",\n controls: a ? [coord, a.coord] : [coord],\n comments\n };\n };\n var peg$f9 = function() {\n return { type: \"line_to\", command: \"|-\" };\n };\n var peg$f10 = function() {\n return { type: \"line_to\", command: \"-|\" };\n };\n var peg$f11 = function() {\n return { type: \"line_to\", command: \"--\" };\n };\n var peg$f12 = function(prefix, content) {\n return { type: \"coordinate\", content, prefix };\n };\n var peg$f13 = function(content) {\n return { type: \"square_brace_group\", content };\n };\n var peg$f14 = function(v) {\n return { type: \"unknown\", content: v };\n };\n var peg$f15 = function(tok) {\n return options.isSameLineComment(tok);\n };\n var peg$f16 = function(tok) {\n return tok;\n };\n var peg$f17 = function(tok) {\n return options.isOwnLineComment(tok);\n };\n var peg$f18 = function(tok) {\n return tok;\n };\n var peg$f19 = function(tok) {\n return options.isComment(tok);\n };\n var peg$f20 = function(tok) {\n return tok;\n };\n var peg$f21 = function(tok) {\n return options.isWhitespace(tok);\n };\n var peg$f22 = function(tok) {\n return tok;\n };\n var peg$f23 = function(c) {\n return c;\n };\n var peg$f24 = function(tok) {\n return options.isOperation(tok);\n };\n var peg$f25 = function(tok) {\n return { type: \"operation\", content: tok };\n };\n var peg$f26 = function(tok) {\n return options.isChar(tok, \"=\");\n };\n var peg$f27 = function(tok) {\n return tok;\n };\n var peg$f28 = function(tok) {\n return options.isChar(tok, \"[\");\n };\n var peg$f29 = function(tok) {\n return tok;\n };\n var peg$f30 = function(tok) {\n return options.isChar(tok, \"]\");\n };\n var peg$f31 = function(tok) {\n return tok;\n };\n var peg$f32 = function(tok) {\n return options.isChar(tok, \"(\");\n };\n var peg$f33 = function(tok) {\n return tok;\n };\n var peg$f34 = function(tok) {\n return options.isChar(tok, \")\");\n };\n var peg$f35 = function(tok) {\n return tok;\n };\n var peg$f36 = function(tok) {\n return options.isChar(tok, \"+\");\n };\n var peg$f37 = function(tok) {\n return tok;\n };\n var peg$f38 = function(tok) {\n return options.isChar(tok, \"-\");\n };\n var peg$f39 = function(tok) {\n return tok;\n };\n var peg$f40 = function(tok) {\n return options.isChar(tok, \"|\");\n };\n var peg$f41 = function(tok) {\n return tok;\n };\n var peg$f42 = function(tok) {\n return options.isChar(tok, \".\");\n };\n var peg$f43 = function(tok) {\n return tok;\n };\n var peg$f44 = function(tok) {\n return options.isChar(tok, \"controls\");\n };\n var peg$f45 = function(tok) {\n return tok;\n };\n var peg$f46 = function(tok) {\n return options.isChar(tok, \"and\");\n };\n var peg$f47 = function(tok) {\n return tok;\n };\n var peg$f48 = function(tok) {\n return options.isChar(tok, \"svg\");\n };\n var peg$f49 = function(tok) {\n return tok;\n };\n var peg$f50 = function(tok) {\n return options.isGroup(tok);\n };\n var peg$f51 = function(tok) {\n return tok;\n };\n var peg$f52 = function(tok) {\n return options.isAnyMacro(tok);\n };\n var peg$f53 = function(tok) {\n return tok;\n };\n var peg$f54 = function(tok) {\n return options.isChar(tok, \"foreach\");\n };\n var peg$f55 = function(tok) {\n return tok;\n };\n var peg$f56 = function(tok) {\n return options.isMacro(tok, \"foreach\");\n };\n var peg$f57 = function(tok) {\n return tok;\n };\n var peg$f58 = function(tok) {\n return options.isChar(tok, \"in\");\n };\n var peg$f59 = function(tok) {\n return tok;\n };\n var peg$f60 = function(tok) {\n return options.isChar(tok, \":\");\n };\n var peg$f61 = function(tok) {\n return tok;\n };\n var peg$currPos = 0;\n var peg$savedPos = 0;\n var peg$posDetailsCache = [{ line: 1, column: 1 }];\n var peg$maxFailPos = 0;\n var peg$maxFailExpected = [];\n var peg$silentFails = 0;\n var peg$result;\n if (\"startRule\" in options) {\n if (!(options.startRule in peg$startRuleFunctions)) {\n throw new Error(`Can't start parsing from rule \"` + options.startRule + '\".');\n }\n peg$startRuleFunction = peg$startRuleFunctions[options.startRule];\n }\n function text() {\n return input.substring(peg$savedPos, peg$currPos);\n }\n function offset() {\n return peg$savedPos;\n }\n function range() {\n return {\n source: peg$source,\n start: peg$savedPos,\n end: peg$currPos\n };\n }\n function location() {\n return peg$computeLocation(peg$savedPos, peg$currPos);\n }\n function expected(description, location2) {\n location2 = location2 !== void 0 ? location2 : peg$computeLocation(peg$savedPos, peg$currPos);\n throw peg$buildStructuredError(\n [peg$otherExpectation(description)],\n input.substring(peg$savedPos, peg$currPos),\n location2\n );\n }\n function error(message, location2) {\n location2 = location2 !== void 0 ? location2 : peg$computeLocation(peg$savedPos, peg$currPos);\n throw peg$buildSimpleError(message, location2);\n }\n function peg$literalExpectation(text2, ignoreCase) {\n return { type: \"literal\", text: text2, ignoreCase };\n }\n function peg$classExpectation(parts, inverted, ignoreCase) {\n return { type: \"class\", parts, inverted, ignoreCase };\n }\n function peg$anyExpectation() {\n return { type: \"any\" };\n }\n function peg$endExpectation() {\n return { type: \"end\" };\n }\n function peg$otherExpectation(description) {\n return { type: \"other\", description };\n }\n function peg$computePosDetails(pos) {\n var details = peg$posDetailsCache[pos];\n var p;\n if (details) {\n return details;\n } else {\n p = pos - 1;\n while (!peg$posDetailsCache[p]) {\n p--;\n }\n details = peg$posDetailsCache[p];\n details = {\n line: details.line,\n column: details.column\n };\n while (p < pos) {\n if (input.charCodeAt(p) === 10) {\n details.line++;\n details.column = 1;\n } else {\n details.column++;\n }\n p++;\n }\n peg$posDetailsCache[pos] = details;\n return details;\n }\n }\n function peg$computeLocation(startPos, endPos, offset2) {\n var startPosDetails = peg$computePosDetails(startPos);\n var endPosDetails = peg$computePosDetails(endPos);\n var res = {\n source: peg$source,\n start: {\n offset: startPos,\n line: startPosDetails.line,\n column: startPosDetails.column\n },\n end: {\n offset: endPos,\n line: endPosDetails.line,\n column: endPosDetails.column\n }\n };\n if (offset2 && peg$source && typeof peg$source.offset === \"function\") {\n res.start = peg$source.offset(res.start);\n res.end = peg$source.offset(res.end);\n }\n return res;\n }\n function peg$fail(expected2) {\n if (peg$currPos < peg$maxFailPos) {\n return;\n }\n if (peg$currPos > peg$maxFailPos) {\n peg$maxFailPos = peg$currPos;\n peg$maxFailExpected = [];\n }\n peg$maxFailExpected.push(expected2);\n }\n function peg$buildSimpleError(message, location2) {\n return new peg$SyntaxError(message, null, null, location2);\n }\n function peg$buildStructuredError(expected2, found, location2) {\n return new peg$SyntaxError(\n peg$SyntaxError.buildMessage(expected2, found),\n expected2,\n found,\n location2\n );\n }\n function peg$parsepath_spec() {\n var s0, s1, s2, s3, s4, s5;\n s0 = peg$currPos;\n s1 = [];\n s2 = peg$currPos;\n s3 = peg$parsesquare_brace_group();\n if (s3 === peg$FAILED) {\n s3 = peg$parsecoordinate();\n if (s3 === peg$FAILED) {\n s3 = peg$parsecurve_to();\n if (s3 === peg$FAILED) {\n s3 = peg$parseline_to();\n if (s3 === peg$FAILED) {\n s3 = peg$parsesvg();\n if (s3 === peg$FAILED) {\n s3 = peg$parseforeach();\n if (s3 === peg$FAILED) {\n s3 = peg$parseoperation();\n if (s3 === peg$FAILED) {\n s3 = peg$parsecomment();\n if (s3 === peg$FAILED) {\n s3 = peg$parseanimation();\n if (s3 === peg$FAILED) {\n s3 = peg$parseunknown();\n }\n }\n }\n }\n }\n }\n }\n }\n }\n if (s3 !== peg$FAILED) {\n s4 = [];\n s5 = peg$parse_();\n while (s5 !== peg$FAILED) {\n s4.push(s5);\n s5 = peg$parse_();\n }\n peg$savedPos = s2;\n s2 = peg$f0(s3);\n } else {\n peg$currPos = s2;\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n while (s2 !== peg$FAILED) {\n s1.push(s2);\n s2 = peg$currPos;\n s3 = peg$parsesquare_brace_group();\n if (s3 === peg$FAILED) {\n s3 = peg$parsecoordinate();\n if (s3 === peg$FAILED) {\n s3 = peg$parsecurve_to();\n if (s3 === peg$FAILED) {\n s3 = peg$parseline_to();\n if (s3 === peg$FAILED) {\n s3 = peg$parsesvg();\n if (s3 === peg$FAILED) {\n s3 = peg$parseforeach();\n if (s3 === peg$FAILED) {\n s3 = peg$parseoperation();\n if (s3 === peg$FAILED) {\n s3 = peg$parsecomment();\n if (s3 === peg$FAILED) {\n s3 = peg$parseanimation();\n if (s3 === peg$FAILED) {\n s3 = peg$parseunknown();\n }\n }\n }\n }\n }\n }\n }\n }\n }\n if (s3 !== peg$FAILED) {\n s4 = [];\n s5 = peg$parse_();\n while (s5 !== peg$FAILED) {\n s4.push(s5);\n s5 = peg$parse_();\n }\n peg$savedPos = s2;\n s2 = peg$f0(s3);\n } else {\n peg$currPos = s2;\n s2 = peg$FAILED;\n }\n }\n } else {\n s1 = peg$FAILED;\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = s0;\n s1 = peg$f1(s1);\n }\n s0 = s1;\n return s0;\n }\n function peg$parseanimation() {\n var s0, s1, s2, s3, s4, s5, s6;\n s0 = peg$currPos;\n s1 = peg$parsecolon();\n if (s1 !== peg$FAILED) {\n s2 = peg$parse_comment_();\n s3 = [];\n s4 = peg$currPos;\n s5 = peg$parseoperation();\n if (s5 !== peg$FAILED) {\n s6 = peg$parse_comment_();\n peg$savedPos = s4;\n s4 = peg$f2(s2, s5, s6);\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n if (s4 !== peg$FAILED) {\n while (s4 !== peg$FAILED) {\n s3.push(s4);\n s4 = peg$currPos;\n s5 = peg$parseoperation();\n if (s5 !== peg$FAILED) {\n s6 = peg$parse_comment_();\n peg$savedPos = s4;\n s4 = peg$f2(s2, s5, s6);\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n }\n } else {\n s3 = peg$FAILED;\n }\n if (s3 !== peg$FAILED) {\n s4 = peg$parseequals();\n if (s4 !== peg$FAILED) {\n s5 = peg$parse_comment_();\n s6 = peg$parsegroup();\n if (s6 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f3(s2, s3, s5, s6);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parseforeach() {\n var s0, s1, s2;\n s0 = peg$currPos;\n s1 = peg$parseforeach_keyword();\n if (s1 === peg$FAILED) {\n s1 = peg$parseforeach_macro();\n }\n if (s1 !== peg$FAILED) {\n s2 = peg$parseforeach_body();\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f4(s1, s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parseforeach_body() {\n var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;\n s0 = peg$currPos;\n s1 = peg$parse_comment_();\n s2 = peg$currPos;\n s3 = [];\n s4 = peg$currPos;\n s5 = peg$currPos;\n peg$silentFails++;\n s6 = peg$parsein_keyword();\n if (s6 === peg$FAILED) {\n s6 = peg$parsesquare_brace_group();\n }\n peg$silentFails--;\n if (s6 === peg$FAILED) {\n s5 = void 0;\n } else {\n peg$currPos = s5;\n s5 = peg$FAILED;\n }\n if (s5 !== peg$FAILED) {\n if (input.length > peg$currPos) {\n s6 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s6 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n if (s6 !== peg$FAILED) {\n s5 = [s5, s6];\n s4 = s5;\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n while (s4 !== peg$FAILED) {\n s3.push(s4);\n s4 = peg$currPos;\n s5 = peg$currPos;\n peg$silentFails++;\n s6 = peg$parsein_keyword();\n if (s6 === peg$FAILED) {\n s6 = peg$parsesquare_brace_group();\n }\n peg$silentFails--;\n if (s6 === peg$FAILED) {\n s5 = void 0;\n } else {\n peg$currPos = s5;\n s5 = peg$FAILED;\n }\n if (s5 !== peg$FAILED) {\n if (input.length > peg$currPos) {\n s6 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s6 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n if (s6 !== peg$FAILED) {\n s5 = [s5, s6];\n s4 = s5;\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n }\n s2 = input.substring(s2, peg$currPos);\n s3 = peg$parsesquare_brace_group();\n if (s3 === peg$FAILED) {\n s3 = null;\n }\n s4 = peg$parse_comment_();\n s5 = peg$parsein_keyword();\n if (s5 !== peg$FAILED) {\n s6 = peg$parse_comment_();\n s7 = peg$parsegroup();\n if (s7 === peg$FAILED) {\n s7 = peg$parsemacro();\n }\n if (s7 !== peg$FAILED) {\n s8 = peg$parse_comment_();\n s9 = peg$parseforeach();\n if (s9 === peg$FAILED) {\n s9 = peg$parsegroup();\n if (s9 === peg$FAILED) {\n s9 = peg$parsemacro();\n }\n }\n if (s9 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f5(s1, s2, s3, s4, s6, s7, s8, s9);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parsesvg() {\n var s0, s1, s2, s3, s4, s5;\n s0 = peg$currPos;\n s1 = peg$parsesvg_keyword();\n if (s1 !== peg$FAILED) {\n s2 = peg$parse_comment_();\n s3 = peg$parsesquare_brace_group();\n if (s3 === peg$FAILED) {\n s3 = null;\n }\n s4 = peg$parse_comment_();\n s5 = peg$parsegroup();\n if (s5 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f6(s2, s3, s4, s5);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parsecurve_to() {\n var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10;\n s0 = peg$currPos;\n s1 = peg$parsedotdot();\n if (s1 !== peg$FAILED) {\n s2 = peg$parse_comment_();\n s3 = peg$parsecontrols_keyword();\n if (s3 !== peg$FAILED) {\n s4 = peg$parse_comment_();\n s5 = peg$parsecoordinate();\n if (s5 !== peg$FAILED) {\n s6 = peg$parse_comment_();\n s7 = peg$currPos;\n s8 = peg$parseand_keyword();\n if (s8 !== peg$FAILED) {\n s9 = peg$parse_comment_();\n s10 = peg$parsecoordinate();\n if (s10 !== peg$FAILED) {\n peg$savedPos = s7;\n s7 = peg$f7(s2, s4, s5, s6, s9, s10);\n } else {\n peg$currPos = s7;\n s7 = peg$FAILED;\n }\n } else {\n peg$currPos = s7;\n s7 = peg$FAILED;\n }\n if (s7 === peg$FAILED) {\n s7 = null;\n }\n s8 = peg$parse_comment_();\n s9 = peg$parsedotdot();\n if (s9 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f8(s2, s4, s5, s6, s7, s8);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parseline_to() {\n var s0, s1, s2;\n s0 = peg$currPos;\n s1 = peg$parsepipe();\n if (s1 !== peg$FAILED) {\n s2 = peg$parseminus();\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f9();\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n if (s0 === peg$FAILED) {\n s0 = peg$currPos;\n s1 = peg$parseminus();\n if (s1 !== peg$FAILED) {\n s2 = peg$parsepipe();\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f10();\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n if (s0 === peg$FAILED) {\n s0 = peg$currPos;\n s1 = peg$parseminus();\n if (s1 !== peg$FAILED) {\n s2 = peg$parseminus();\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f11();\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n }\n }\n return s0;\n }\n function peg$parsecoordinate() {\n var s0, s1, s2, s3, s4, s5, s6, s7;\n s0 = peg$currPos;\n s1 = peg$currPos;\n s2 = peg$currPos;\n s3 = peg$parseplus();\n if (s3 !== peg$FAILED) {\n s4 = peg$parseplus();\n if (s4 === peg$FAILED) {\n s4 = null;\n }\n s3 = [s3, s4];\n s2 = s3;\n } else {\n peg$currPos = s2;\n s2 = peg$FAILED;\n }\n if (s2 === peg$FAILED) {\n s2 = null;\n }\n s1 = input.substring(s1, peg$currPos);\n s2 = peg$parseopen_paren();\n if (s2 !== peg$FAILED) {\n s3 = peg$currPos;\n s4 = [];\n s5 = peg$currPos;\n s6 = peg$currPos;\n peg$silentFails++;\n s7 = peg$parseclose_paren();\n peg$silentFails--;\n if (s7 === peg$FAILED) {\n s6 = void 0;\n } else {\n peg$currPos = s6;\n s6 = peg$FAILED;\n }\n if (s6 !== peg$FAILED) {\n if (input.length > peg$currPos) {\n s7 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s7 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n if (s7 !== peg$FAILED) {\n s6 = [s6, s7];\n s5 = s6;\n } else {\n peg$currPos = s5;\n s5 = peg$FAILED;\n }\n } else {\n peg$currPos = s5;\n s5 = peg$FAILED;\n }\n while (s5 !== peg$FAILED) {\n s4.push(s5);\n s5 = peg$currPos;\n s6 = peg$currPos;\n peg$silentFails++;\n s7 = peg$parseclose_paren();\n peg$silentFails--;\n if (s7 === peg$FAILED) {\n s6 = void 0;\n } else {\n peg$currPos = s6;\n s6 = peg$FAILED;\n }\n if (s6 !== peg$FAILED) {\n if (input.length > peg$currPos) {\n s7 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s7 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n if (s7 !== peg$FAILED) {\n s6 = [s6, s7];\n s5 = s6;\n } else {\n peg$currPos = s5;\n s5 = peg$FAILED;\n }\n } else {\n peg$currPos = s5;\n s5 = peg$FAILED;\n }\n }\n s3 = input.substring(s3, peg$currPos);\n s4 = peg$parseclose_paren();\n if (s4 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f12(s1, s3);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parsesquare_brace_group() {\n var s0, s1, s2, s3, s4, s5, s6;\n s0 = peg$currPos;\n s1 = peg$parseopen_square_brace();\n if (s1 !== peg$FAILED) {\n s2 = peg$currPos;\n s3 = [];\n s4 = peg$currPos;\n s5 = peg$currPos;\n peg$silentFails++;\n s6 = peg$parseclose_square_brace();\n peg$silentFails--;\n if (s6 === peg$FAILED) {\n s5 = void 0;\n } else {\n peg$currPos = s5;\n s5 = peg$FAILED;\n }\n if (s5 !== peg$FAILED) {\n if (input.length > peg$currPos) {\n s6 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s6 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n if (s6 !== peg$FAILED) {\n s5 = [s5, s6];\n s4 = s5;\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n while (s4 !== peg$FAILED) {\n s3.push(s4);\n s4 = peg$currPos;\n s5 = peg$currPos;\n peg$silentFails++;\n s6 = peg$parseclose_square_brace();\n peg$silentFails--;\n if (s6 === peg$FAILED) {\n s5 = void 0;\n } else {\n peg$currPos = s5;\n s5 = peg$FAILED;\n }\n if (s5 !== peg$FAILED) {\n if (input.length > peg$currPos) {\n s6 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s6 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n if (s6 !== peg$FAILED) {\n s5 = [s5, s6];\n s4 = s5;\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n }\n s2 = input.substring(s2, peg$currPos);\n s3 = peg$parseclose_square_brace();\n if (s3 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f13(s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parsedotdot() {\n var s0, s1, s2;\n s0 = peg$currPos;\n s1 = peg$parsedot();\n if (s1 !== peg$FAILED) {\n s2 = peg$parsedot();\n if (s2 !== peg$FAILED) {\n s1 = [s1, s2];\n s0 = s1;\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parseunknown() {\n var s0, s1;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = s0;\n s1 = peg$f14(s1);\n }\n s0 = s1;\n return s0;\n }\n function peg$parsesame_line_comment() {\n var s0, s1, s2;\n peg$silentFails++;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f15(s1);\n if (s2) {\n s2 = void 0;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f16(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e1);\n }\n }\n return s0;\n }\n function peg$parseown_line_comment() {\n var s0, s1, s2;\n peg$silentFails++;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f17(s1);\n if (s2) {\n s2 = void 0;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f18(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e2);\n }\n }\n return s0;\n }\n function peg$parsecomment() {\n var s0, s1, s2;\n peg$silentFails++;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f19(s1);\n if (s2) {\n s2 = void 0;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f20(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e3);\n }\n }\n return s0;\n }\n function peg$parse_() {\n var s0, s1, s2;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f21(s1);\n if (s2) {\n s2 = void 0;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f22(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parse_comment_() {\n var s0, s1, s2, s3, s4;\n peg$silentFails++;\n s0 = peg$currPos;\n s1 = [];\n s2 = peg$parse_();\n while (s2 !== peg$FAILED) {\n s1.push(s2);\n s2 = peg$parse_();\n }\n s2 = peg$parsecomment();\n if (s2 === peg$FAILED) {\n s2 = null;\n }\n s3 = [];\n s4 = peg$parse_();\n while (s4 !== peg$FAILED) {\n s3.push(s4);\n s4 = peg$parse_();\n }\n peg$savedPos = s0;\n s0 = peg$f23(s2);\n peg$silentFails--;\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e4);\n }\n return s0;\n }\n function peg$parseoperation() {\n var s0, s1, s2;\n peg$silentFails++;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f24(s1);\n if (s2) {\n s2 = void 0;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f25(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e5);\n }\n }\n return s0;\n }\n function peg$parseequals() {\n var s0, s1, s2;\n peg$silentFails++;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f26(s1);\n if (s2) {\n s2 = void 0;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f27(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e6);\n }\n }\n return s0;\n }\n function peg$parseopen_square_brace() {\n var s0, s1, s2;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f28(s1);\n if (s2) {\n s2 = void 0;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f29(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parseclose_square_brace() {\n var s0, s1, s2;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f30(s1);\n if (s2) {\n s2 = void 0;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f31(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parseopen_paren() {\n var s0, s1, s2;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f32(s1);\n if (s2) {\n s2 = void 0;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f33(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parseclose_paren() {\n var s0, s1, s2;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f34(s1);\n if (s2) {\n s2 = void 0;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f35(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parseplus() {\n var s0, s1, s2;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f36(s1);\n if (s2) {\n s2 = void 0;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f37(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parseminus() {\n var s0, s1, s2;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f38(s1);\n if (s2) {\n s2 = void 0;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f39(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parsepipe() {\n var s0, s1, s2;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f40(s1);\n if (s2) {\n s2 = void 0;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f41(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parsedot() {\n var s0, s1, s2;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f42(s1);\n if (s2) {\n s2 = void 0;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f43(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parsecontrols_keyword() {\n var s0, s1, s2;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f44(s1);\n if (s2) {\n s2 = void 0;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f45(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parseand_keyword() {\n var s0, s1, s2;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f46(s1);\n if (s2) {\n s2 = void 0;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f47(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parsesvg_keyword() {\n var s0, s1, s2;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f48(s1);\n if (s2) {\n s2 = void 0;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f49(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parsegroup() {\n var s0, s1, s2;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f50(s1);\n if (s2) {\n s2 = void 0;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f51(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parsemacro() {\n var s0, s1, s2;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f52(s1);\n if (s2) {\n s2 = void 0;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f53(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parseforeach_keyword() {\n var s0, s1, s2;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f54(s1);\n if (s2) {\n s2 = void 0;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f55(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parseforeach_macro() {\n var s0, s1, s2;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f56(s1);\n if (s2) {\n s2 = void 0;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f57(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parsein_keyword() {\n var s0, s1, s2;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f58(s1);\n if (s2) {\n s2 = void 0;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f59(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parsecolon() {\n var s0, s1, s2;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f60(s1);\n if (s2) {\n s2 = void 0;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f61(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parseEOL() {\n var s0, s1;\n s0 = peg$currPos;\n peg$silentFails++;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n peg$silentFails--;\n if (s1 === peg$FAILED) {\n s0 = void 0;\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n if (!options.isWhitespace) {\n try {\n Object.assign(options, {\n isChar: (node, char) => node.type === \"string\" && node.content === char,\n isOperation: (node) => node.type === \"string\" && node.content.match(/[a-zA-Z]/),\n isWhitespace: (node) => node.type === \"whitespace\" || node.type === \"parbreak\",\n isSameLineComment: (node) => node.type === \"comment\" && node.sameline,\n isOwnLineComment: (node) => node.type === \"comment\" && !node.sameline,\n isComment: (node) => node.type === \"comment\",\n isGroup: (node) => node.type === \"group\",\n isMacro: (node, name) => node.type === \"macro\" && node.content === name,\n isAnyMacro: (node) => node.type === \"macro\"\n });\n } catch (e) {\n console.warn(\"Error when initializing parser\", e);\n }\n }\n peg$result = peg$startRuleFunction();\n if (peg$result !== peg$FAILED && peg$currPos === input.length) {\n return peg$result;\n } else {\n if (peg$result !== peg$FAILED && peg$currPos < input.length) {\n peg$fail(peg$endExpectation());\n }\n throw peg$buildStructuredError(\n peg$maxFailExpected,\n peg$maxFailPos < input.length ? input.charAt(peg$maxFailPos) : null,\n peg$maxFailPos < input.length ? peg$computeLocation(peg$maxFailPos, peg$maxFailPos + 1) : peg$computeLocation(peg$maxFailPos, peg$maxFailPos)\n );\n }\n }\n return {\n SyntaxError: peg$SyntaxError,\n parse: peg$parse\n };\n }()\n);\n","/* eslint-disable @typescript-eslint/ban-ts-comment */\n// This file needs to be here because typescript does not know how to use babel's transpiler\n// to directly load Pegjs grammars.\n// @ts-nocheck\nimport _LatexPegParser from \"../grammars/latex.pegjs\";\nimport _AlignEnvironmentPegParser from \"../grammars/align-environment.pegjs\";\nimport _ArgSpecPegParser from \"../grammars/xparse-argspec.pegjs\";\nimport _PgfkeysPegParser from \"../grammars/pgfkeys.pegjs\";\nimport _MacroSubstitutionPegParser from \"../grammars/macro-substitutions.pegjs\";\nimport _LigaturesPegParser from \"../grammars/ligatures.pegjs\";\nimport _XColorPegParser from \"../grammars/xcolor-expressions.pegjs\";\nimport _TabularPegParser from \"../grammars/tabular-spec.pegjs\";\nimport _SystemePegParser from \"../grammars/systeme-environment.pegjs\";\nimport _GluePegParser from \"../grammars/tex-glue.pegjs\";\nimport _TikzPegParser from \"../grammars/tikz.pegjs\";\n\ntype PegParser = {\n parse: (input: string | unknown[], options?: unknown) => any;\n SyntaxError: (\n message: string,\n expected: string,\n found: unknown,\n location: unknown\n ) => unknown;\n};\n\nconst LatexPegParser = _LatexPegParser as PegParser;\nconst AlignEnvironmentPegParser = _AlignEnvironmentPegParser as PegParser;\nconst ArgSpecPegParser = _ArgSpecPegParser as PegParser;\nconst PgfkeysPegParser = _PgfkeysPegParser as PegParser;\nconst MacroSubstitutionPegParser = _MacroSubstitutionPegParser as PegParser;\nconst LigaturesPegParser = _LigaturesPegParser as PegParser;\nconst XColorPegParser = _XColorPegParser as PegParser;\nconst TabularPegParser = _TabularPegParser as PegParser;\nconst SystemePegParser = _SystemePegParser as PegParser;\nconst GluePegParser = _GluePegParser as PegParser;\nconst TikzPegParser = _TikzPegParser as PegParser;\n\nexport {\n LatexPegParser,\n AlignEnvironmentPegParser,\n ArgSpecPegParser,\n PgfkeysPegParser,\n MacroSubstitutionPegParser,\n LigaturesPegParser,\n XColorPegParser,\n TabularPegParser,\n SystemePegParser,\n GluePegParser,\n TikzPegParser,\n};\n"],"names":[],"mappings":"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"} \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-util-pegjs/package.json b/node_modules/@unified-latex/unified-latex-util-pegjs/package.json new file mode 100644 index 0000000..9da23c2 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-util-pegjs/package.json @@ -0,0 +1,52 @@ +{ + "name": "@unified-latex/unified-latex-util-pegjs", + "version": "1.8.1", + "description": "PEGjs grammars and tools for constructing unified-latex ASTs", + "main": "index.js", + "type": "module", + "dependencies": { + "@unified-latex/unified-latex-types": "^1.8.0", + "@unified-latex/unified-latex-util-match": "^1.8.0" + }, + "repository": { + "type": "git", + "url": "git+https://github.com/siefkenj/unified-latex.git" + }, + "keywords": [ + "pegjs", + "latex", + "parser", + "prettier", + "unified-latex", + "unified" + ], + "author": "Jason Siefken", + "license": "MIT", + "bugs": { + "url": "https://github.com/siefkenj/unified-latex/issues" + }, + "homepage": "https://github.com/siefkenj/unified-latex#readme", + "exports": { + ".": { + "import": "./index.js", + "require": "./index.cjs", + "types": "./index.d.ts" + }, + "./*js": "./*js", + "./*": { + "import": "./*/index.js", + "require": "./*/index.cjs", + "types": "./*/index.d.ts" + }, + "./*/index": { + "import": "./*/index.js", + "require": "./*/index.cjs" + } + }, + "files": [ + "**/*ts", + "**/*js", + "**/*.map", + "**/*.json" + ] +} \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-util-pgfkeys/README.md b/node_modules/@unified-latex/unified-latex-util-pgfkeys/README.md new file mode 100644 index 0000000..6b90de2 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-util-pgfkeys/README.md @@ -0,0 +1,88 @@ + + + + +# unified-latex-util-pgfkeys + +## What is this? + +Functions to help manipulate `unified-latex` Abstract Syntax Tree (AST) that contain +pgfkeys-style arguments. Note that pgfkeys aren't built into `Ast.Ast`. Instead, parsing +nodes as pgfkeys will produce a new (incompatible) AST. + +## When should I use this? + +If you want to parse or manipulate macros/environments with pgfkeys-style arguments. + +## Install + +```bash +npm install @unified-latex/unified-latex-util-pgfkeys +``` + +This package contains both esm and commonjs exports. To explicitly access the esm export, +import the `.js` file. To explicitly access the commonjs export, import the `.cjs` file. + +# Functions + +## `createMatchers()` + + + +```typescript +function createMatchers(): { isChar: (node: Ast.Node, char: string) => node is Ast.String; isComma: (node: Ast.Node) => node is Ast.String; isEquals: (node: Ast.Node) => node is Ast.String; isWhitespace: (node: Ast.Node) => node is Ast.Whitespace; isParbreak: (node: Ast.Node) => node is Ast.Parbreak; isSameLineComment: (node: Ast.Node) => boo... +``` + +## `parsePgfkeys(ast, options)` + +Parse the arguments of a Pgfkeys macro. The `ast` +is expected to be a comma separated list of `Item`s. +Each item can have 0 or more item parts, which are separated +by "=". If `itemPart` is undefined, + +If `options.allowParenGroups === true`, then commas that occur inside groups of parenthesis +will not be parsed as separators. This is useful for parsing tikz `\foreach` loops. + +```typescript +function parsePgfkeys( + ast: Ast.Node[], + options: { allowParenGroups: boolean } +): Item[]; +``` + +**Parameters** + +| Param | Type | +| :------ | :-------------------------------- | +| ast | `Ast.Node[]` | +| options | Omitted | + +## `pgfkeysArgToObject(arg)` + +Parse `arg` as pgfkeys and return a JavaScript object with the results. +The keys will be normalized to strings and the values will be arrays of nodes. + +```typescript +function pgfkeysArgToObject( + arg: Ast.Node[] | Ast.Argument +): Record; +``` + +**Parameters** + +| Param | Type | +| :---- | :--------------------------- | +| arg | `Ast.Node[] \| Ast.Argument` | + +# Types + +## `Item` + +```typescript +export type Item = { + itemParts?: Ast.Node[][]; + trailingComment: Ast.Comment | null; + trailingComma?: boolean; + leadingParbreak?: boolean; +}; +``` diff --git a/node_modules/@unified-latex/unified-latex-util-pgfkeys/index.cjs b/node_modules/@unified-latex/unified-latex-util-pgfkeys/index.cjs new file mode 100644 index 0000000..f156cad --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-util-pgfkeys/index.cjs @@ -0,0 +1,58 @@ +"use strict"; +Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" }); +const unifiedLatexUtilPegjs = require("@unified-latex/unified-latex-util-pegjs"); +const unifiedLatexUtilMatch = require("@unified-latex/unified-latex-util-match"); +const unifiedLatexUtilPrintRaw = require("@unified-latex/unified-latex-util-print-raw"); +function createMatchers() { + return { + isChar: (node, char) => unifiedLatexUtilMatch.match.string(node, char), + isComma: (node) => unifiedLatexUtilMatch.match.string(node, ","), + isEquals: (node) => unifiedLatexUtilMatch.match.string(node, "="), + isWhitespace: (node) => unifiedLatexUtilMatch.match.whitespace(node), + isParbreak: (node) => unifiedLatexUtilMatch.match.parbreak(node), + isSameLineComment: (node) => unifiedLatexUtilMatch.match.comment(node) && node.sameline, + isOwnLineComment: (node) => unifiedLatexUtilMatch.match.comment(node) && !node.sameline + }; +} +function parsePgfkeys(ast, options) { + if (!Array.isArray(ast)) { + throw new Error("You must pass an array of nodes"); + } + const { allowParenGroups = false } = options || {}; + ast = unifiedLatexUtilPegjs.decorateArrayForPegjs([...ast]); + return unifiedLatexUtilPegjs.PgfkeysPegParser.parse(ast, { + ...createMatchers(), + allowParenGroups + }); +} +function pgfkeysArgToObject(arg) { + function parseFront(nodes) { + return unifiedLatexUtilPrintRaw.printRaw(nodes); + } + function parseBack(nodes) { + if (!nodes) { + return []; + } + if (nodes.length === 1 && unifiedLatexUtilMatch.match.group(nodes[0])) { + return nodes[0].content; + } + return nodes; + } + let nodeList; + if (unifiedLatexUtilMatch.match.argument(arg)) { + nodeList = arg.content; + } else { + nodeList = arg; + } + const parsedArgs = parsePgfkeys(nodeList); + return Object.fromEntries( + parsedArgs.filter((part) => part.itemParts).map((part) => [ + parseFront(part.itemParts[0]), + parseBack(part.itemParts[1]) + ]) + ); +} +exports.createMatchers = createMatchers; +exports.parsePgfkeys = parsePgfkeys; +exports.pgfkeysArgToObject = pgfkeysArgToObject; +//# sourceMappingURL=index.cjs.map diff --git a/node_modules/@unified-latex/unified-latex-util-pgfkeys/index.cjs.map b/node_modules/@unified-latex/unified-latex-util-pgfkeys/index.cjs.map new file mode 100644 index 0000000..a036671 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-util-pgfkeys/index.cjs.map @@ -0,0 +1 @@ +{"version":3,"file":"index.cjs","sources":["../libs/pgfkeys-parser.ts","../libs/pgfkeys-to-object.ts"],"sourcesContent":["import { PgfkeysPegParser } from \"@unified-latex/unified-latex-util-pegjs\";\nimport * as Ast from \"@unified-latex/unified-latex-types\";\nimport { match } from \"@unified-latex/unified-latex-util-match\";\nimport { decorateArrayForPegjs } from \"@unified-latex/unified-latex-util-pegjs\";\n\n// The types returned by the grammar\n\nexport type Item = {\n itemParts?: Ast.Node[][];\n trailingComment: Ast.Comment | null;\n trailingComma?: boolean;\n leadingParbreak?: boolean;\n};\n\nexport function createMatchers() {\n return {\n isChar: (node: Ast.Node, char: string) => match.string(node, char),\n isComma: (node: Ast.Node) => match.string(node, \",\"),\n isEquals: (node: Ast.Node) => match.string(node, \"=\"),\n isWhitespace: (node: Ast.Node) => match.whitespace(node),\n isParbreak: (node: Ast.Node) => match.parbreak(node),\n isSameLineComment: (node: Ast.Node) =>\n match.comment(node) && node.sameline,\n isOwnLineComment: (node: Ast.Node) =>\n match.comment(node) && !node.sameline,\n };\n}\n\n/**\n * Parse the arguments of a Pgfkeys macro. The `ast`\n * is expected to be a comma separated list of `Item`s.\n * Each item can have 0 or more item parts, which are separated\n * by \"=\". If `itemPart` is undefined,\n *\n * If `options.allowParenGroups === true`, then commas that occur inside groups of parenthesis\n * will not be parsed as separators. This is useful for parsing tikz `\\foreach` loops.\n */\nexport function parsePgfkeys(\n ast: Ast.Node[],\n options?: { allowParenGroups: boolean }\n): Item[] {\n if (!Array.isArray(ast)) {\n throw new Error(\"You must pass an array of nodes\");\n }\n const { allowParenGroups = false } = options || {};\n // We need to at functions to `nodes` so that it imitates\n // a Javascript string. Because we're mutating, make a copy first\n ast = decorateArrayForPegjs([...ast]);\n // matchers are passed in via the second argument (the `options` argument)\n // so they are available from within the Pegjs grammar.\n return PgfkeysPegParser.parse(ast, {\n ...createMatchers(),\n allowParenGroups,\n }) as Item[];\n}\n","import * as Ast from \"@unified-latex/unified-latex-types\";\nimport { match } from \"@unified-latex/unified-latex-util-match\";\nimport { printRaw } from \"@unified-latex/unified-latex-util-print-raw\";\nimport { parsePgfkeys } from \"./pgfkeys-parser\";\n\n/**\n * Parse `arg` as pgfkeys and return a JavaScript object with the results.\n * The keys will be normalized to strings and the values will be arrays of nodes.\n */\nexport function pgfkeysArgToObject(\n arg: Ast.Argument | Ast.Node[]\n): Record {\n function parseFront(nodes: Ast.Node[]): string {\n return printRaw(nodes);\n }\n function parseBack(nodes: Ast.Node[] | undefined): Ast.Node[] {\n if (!nodes) {\n return [];\n }\n // If the only element is a group, we unwrap it\n if (nodes.length === 1 && match.group(nodes[0])) {\n return nodes[0].content;\n }\n return nodes;\n }\n\n let nodeList: Ast.Node[];\n if (match.argument(arg)) {\n nodeList = arg.content;\n } else {\n nodeList = arg;\n }\n const parsedArgs = parsePgfkeys(nodeList);\n return Object.fromEntries(\n parsedArgs\n .filter((part) => part.itemParts)\n .map((part) => [\n parseFront(part.itemParts![0]),\n parseBack(part.itemParts![1]),\n ])\n );\n}\n"],"names":["match","decorateArrayForPegjs","PgfkeysPegParser","printRaw"],"mappings":";;;;;AAcO,SAAS,iBAAiB;AACtB,SAAA;AAAA,IACH,QAAQ,CAAC,MAAgB,SAAiBA,sBAAM,MAAA,OAAO,MAAM,IAAI;AAAA,IACjE,SAAS,CAAC,SAAmBA,sBAAAA,MAAM,OAAO,MAAM,GAAG;AAAA,IACnD,UAAU,CAAC,SAAmBA,sBAAAA,MAAM,OAAO,MAAM,GAAG;AAAA,IACpD,cAAc,CAAC,SAAmBA,4BAAM,WAAW,IAAI;AAAA,IACvD,YAAY,CAAC,SAAmBA,4BAAM,SAAS,IAAI;AAAA,IACnD,mBAAmB,CAAC,SAChBA,4BAAM,QAAQ,IAAI,KAAK,KAAK;AAAA,IAChC,kBAAkB,CAAC,SACfA,sBAAA,MAAM,QAAQ,IAAI,KAAK,CAAC,KAAK;AAAA,EAAA;AAEzC;AAWgB,SAAA,aACZ,KACA,SACM;AACN,MAAI,CAAC,MAAM,QAAQ,GAAG,GAAG;AACf,UAAA,IAAI,MAAM,iCAAiC;AAAA,EACrD;AACA,QAAM,EAAE,mBAAmB,UAAU,WAAW,CAAA;AAGhD,QAAMC,sBAAsB,sBAAA,CAAC,GAAG,GAAG,CAAC;AAG7B,SAAAC,sBAAA,iBAAiB,MAAM,KAAK;AAAA,IAC/B,GAAG,eAAe;AAAA,IAClB;AAAA,EAAA,CACH;AACL;AC7CO,SAAS,mBACZ,KAC0B;AAC1B,WAAS,WAAW,OAA2B;AAC3C,WAAOC,yBAAAA,SAAS,KAAK;AAAA,EACzB;AACA,WAAS,UAAU,OAA2C;AAC1D,QAAI,CAAC,OAAO;AACR,aAAO;IACX;AAEI,QAAA,MAAM,WAAW,KAAKH,sBAAAA,MAAM,MAAM,MAAM,CAAC,CAAC,GAAG;AACtC,aAAA,MAAM,CAAC,EAAE;AAAA,IACpB;AACO,WAAA;AAAA,EACX;AAEI,MAAA;AACA,MAAAA,sBAAA,MAAM,SAAS,GAAG,GAAG;AACrB,eAAW,IAAI;AAAA,EAAA,OACZ;AACQ,eAAA;AAAA,EACf;AACM,QAAA,aAAa,aAAa,QAAQ;AACxC,SAAO,OAAO;AAAA,IACV,WACK,OAAO,CAAC,SAAS,KAAK,SAAS,EAC/B,IAAI,CAAC,SAAS;AAAA,MACX,WAAW,KAAK,UAAW,CAAC,CAAC;AAAA,MAC7B,UAAU,KAAK,UAAW,CAAC,CAAC;AAAA,IAAA,CAC/B;AAAA,EAAA;AAEb;;;;"} \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-util-pgfkeys/index.d.ts b/node_modules/@unified-latex/unified-latex-util-pgfkeys/index.d.ts new file mode 100644 index 0000000..3f1f286 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-util-pgfkeys/index.d.ts @@ -0,0 +1,39 @@ +import * as Ast from '@unified-latex/unified-latex-types'; + +export declare function createMatchers(): { + isChar: (node: Ast.Node, char: string) => node is Ast.String; + isComma: (node: Ast.Node) => node is Ast.String; + isEquals: (node: Ast.Node) => node is Ast.String; + isWhitespace: (node: Ast.Node) => node is Ast.Whitespace; + isParbreak: (node: Ast.Node) => node is Ast.Parbreak; + isSameLineComment: (node: Ast.Node) => boolean | undefined; + isOwnLineComment: (node: Ast.Node) => boolean; +}; + +export declare type Item = { + itemParts?: Ast.Node[][]; + trailingComment: Ast.Comment | null; + trailingComma?: boolean; + leadingParbreak?: boolean; +}; + +/** + * Parse the arguments of a Pgfkeys macro. The `ast` + * is expected to be a comma separated list of `Item`s. + * Each item can have 0 or more item parts, which are separated + * by "=". If `itemPart` is undefined, + * + * If `options.allowParenGroups === true`, then commas that occur inside groups of parenthesis + * will not be parsed as separators. This is useful for parsing tikz `\foreach` loops. + */ +export declare function parsePgfkeys(ast: Ast.Node[], options?: { + allowParenGroups: boolean; +}): Item[]; + +/** + * Parse `arg` as pgfkeys and return a JavaScript object with the results. + * The keys will be normalized to strings and the values will be arrays of nodes. + */ +export declare function pgfkeysArgToObject(arg: Ast.Argument | Ast.Node[]): Record; + +export { } diff --git a/node_modules/@unified-latex/unified-latex-util-pgfkeys/index.js b/node_modules/@unified-latex/unified-latex-util-pgfkeys/index.js new file mode 100644 index 0000000..3f8e3c5 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-util-pgfkeys/index.js @@ -0,0 +1,58 @@ +import { decorateArrayForPegjs, PgfkeysPegParser } from "@unified-latex/unified-latex-util-pegjs"; +import { match } from "@unified-latex/unified-latex-util-match"; +import { printRaw } from "@unified-latex/unified-latex-util-print-raw"; +function createMatchers() { + return { + isChar: (node, char) => match.string(node, char), + isComma: (node) => match.string(node, ","), + isEquals: (node) => match.string(node, "="), + isWhitespace: (node) => match.whitespace(node), + isParbreak: (node) => match.parbreak(node), + isSameLineComment: (node) => match.comment(node) && node.sameline, + isOwnLineComment: (node) => match.comment(node) && !node.sameline + }; +} +function parsePgfkeys(ast, options) { + if (!Array.isArray(ast)) { + throw new Error("You must pass an array of nodes"); + } + const { allowParenGroups = false } = options || {}; + ast = decorateArrayForPegjs([...ast]); + return PgfkeysPegParser.parse(ast, { + ...createMatchers(), + allowParenGroups + }); +} +function pgfkeysArgToObject(arg) { + function parseFront(nodes) { + return printRaw(nodes); + } + function parseBack(nodes) { + if (!nodes) { + return []; + } + if (nodes.length === 1 && match.group(nodes[0])) { + return nodes[0].content; + } + return nodes; + } + let nodeList; + if (match.argument(arg)) { + nodeList = arg.content; + } else { + nodeList = arg; + } + const parsedArgs = parsePgfkeys(nodeList); + return Object.fromEntries( + parsedArgs.filter((part) => part.itemParts).map((part) => [ + parseFront(part.itemParts[0]), + parseBack(part.itemParts[1]) + ]) + ); +} +export { + createMatchers, + parsePgfkeys, + pgfkeysArgToObject +}; +//# sourceMappingURL=index.js.map diff --git a/node_modules/@unified-latex/unified-latex-util-pgfkeys/index.js.map b/node_modules/@unified-latex/unified-latex-util-pgfkeys/index.js.map new file mode 100644 index 0000000..c5887c6 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-util-pgfkeys/index.js.map @@ -0,0 +1 @@ +{"version":3,"file":"index.js","sources":["../libs/pgfkeys-parser.ts","../libs/pgfkeys-to-object.ts"],"sourcesContent":["import { PgfkeysPegParser } from \"@unified-latex/unified-latex-util-pegjs\";\nimport * as Ast from \"@unified-latex/unified-latex-types\";\nimport { match } from \"@unified-latex/unified-latex-util-match\";\nimport { decorateArrayForPegjs } from \"@unified-latex/unified-latex-util-pegjs\";\n\n// The types returned by the grammar\n\nexport type Item = {\n itemParts?: Ast.Node[][];\n trailingComment: Ast.Comment | null;\n trailingComma?: boolean;\n leadingParbreak?: boolean;\n};\n\nexport function createMatchers() {\n return {\n isChar: (node: Ast.Node, char: string) => match.string(node, char),\n isComma: (node: Ast.Node) => match.string(node, \",\"),\n isEquals: (node: Ast.Node) => match.string(node, \"=\"),\n isWhitespace: (node: Ast.Node) => match.whitespace(node),\n isParbreak: (node: Ast.Node) => match.parbreak(node),\n isSameLineComment: (node: Ast.Node) =>\n match.comment(node) && node.sameline,\n isOwnLineComment: (node: Ast.Node) =>\n match.comment(node) && !node.sameline,\n };\n}\n\n/**\n * Parse the arguments of a Pgfkeys macro. The `ast`\n * is expected to be a comma separated list of `Item`s.\n * Each item can have 0 or more item parts, which are separated\n * by \"=\". If `itemPart` is undefined,\n *\n * If `options.allowParenGroups === true`, then commas that occur inside groups of parenthesis\n * will not be parsed as separators. This is useful for parsing tikz `\\foreach` loops.\n */\nexport function parsePgfkeys(\n ast: Ast.Node[],\n options?: { allowParenGroups: boolean }\n): Item[] {\n if (!Array.isArray(ast)) {\n throw new Error(\"You must pass an array of nodes\");\n }\n const { allowParenGroups = false } = options || {};\n // We need to at functions to `nodes` so that it imitates\n // a Javascript string. Because we're mutating, make a copy first\n ast = decorateArrayForPegjs([...ast]);\n // matchers are passed in via the second argument (the `options` argument)\n // so they are available from within the Pegjs grammar.\n return PgfkeysPegParser.parse(ast, {\n ...createMatchers(),\n allowParenGroups,\n }) as Item[];\n}\n","import * as Ast from \"@unified-latex/unified-latex-types\";\nimport { match } from \"@unified-latex/unified-latex-util-match\";\nimport { printRaw } from \"@unified-latex/unified-latex-util-print-raw\";\nimport { parsePgfkeys } from \"./pgfkeys-parser\";\n\n/**\n * Parse `arg` as pgfkeys and return a JavaScript object with the results.\n * The keys will be normalized to strings and the values will be arrays of nodes.\n */\nexport function pgfkeysArgToObject(\n arg: Ast.Argument | Ast.Node[]\n): Record {\n function parseFront(nodes: Ast.Node[]): string {\n return printRaw(nodes);\n }\n function parseBack(nodes: Ast.Node[] | undefined): Ast.Node[] {\n if (!nodes) {\n return [];\n }\n // If the only element is a group, we unwrap it\n if (nodes.length === 1 && match.group(nodes[0])) {\n return nodes[0].content;\n }\n return nodes;\n }\n\n let nodeList: Ast.Node[];\n if (match.argument(arg)) {\n nodeList = arg.content;\n } else {\n nodeList = arg;\n }\n const parsedArgs = parsePgfkeys(nodeList);\n return Object.fromEntries(\n parsedArgs\n .filter((part) => part.itemParts)\n .map((part) => [\n parseFront(part.itemParts![0]),\n parseBack(part.itemParts![1]),\n ])\n );\n}\n"],"names":[],"mappings":";;;AAcO,SAAS,iBAAiB;AACtB,SAAA;AAAA,IACH,QAAQ,CAAC,MAAgB,SAAiB,MAAM,OAAO,MAAM,IAAI;AAAA,IACjE,SAAS,CAAC,SAAmB,MAAM,OAAO,MAAM,GAAG;AAAA,IACnD,UAAU,CAAC,SAAmB,MAAM,OAAO,MAAM,GAAG;AAAA,IACpD,cAAc,CAAC,SAAmB,MAAM,WAAW,IAAI;AAAA,IACvD,YAAY,CAAC,SAAmB,MAAM,SAAS,IAAI;AAAA,IACnD,mBAAmB,CAAC,SAChB,MAAM,QAAQ,IAAI,KAAK,KAAK;AAAA,IAChC,kBAAkB,CAAC,SACf,MAAM,QAAQ,IAAI,KAAK,CAAC,KAAK;AAAA,EAAA;AAEzC;AAWgB,SAAA,aACZ,KACA,SACM;AACN,MAAI,CAAC,MAAM,QAAQ,GAAG,GAAG;AACf,UAAA,IAAI,MAAM,iCAAiC;AAAA,EACrD;AACA,QAAM,EAAE,mBAAmB,UAAU,WAAW,CAAA;AAGhD,QAAM,sBAAsB,CAAC,GAAG,GAAG,CAAC;AAG7B,SAAA,iBAAiB,MAAM,KAAK;AAAA,IAC/B,GAAG,eAAe;AAAA,IAClB;AAAA,EAAA,CACH;AACL;AC7CO,SAAS,mBACZ,KAC0B;AAC1B,WAAS,WAAW,OAA2B;AAC3C,WAAO,SAAS,KAAK;AAAA,EACzB;AACA,WAAS,UAAU,OAA2C;AAC1D,QAAI,CAAC,OAAO;AACR,aAAO;IACX;AAEI,QAAA,MAAM,WAAW,KAAK,MAAM,MAAM,MAAM,CAAC,CAAC,GAAG;AACtC,aAAA,MAAM,CAAC,EAAE;AAAA,IACpB;AACO,WAAA;AAAA,EACX;AAEI,MAAA;AACA,MAAA,MAAM,SAAS,GAAG,GAAG;AACrB,eAAW,IAAI;AAAA,EAAA,OACZ;AACQ,eAAA;AAAA,EACf;AACM,QAAA,aAAa,aAAa,QAAQ;AACxC,SAAO,OAAO;AAAA,IACV,WACK,OAAO,CAAC,SAAS,KAAK,SAAS,EAC/B,IAAI,CAAC,SAAS;AAAA,MACX,WAAW,KAAK,UAAW,CAAC,CAAC;AAAA,MAC7B,UAAU,KAAK,UAAW,CAAC,CAAC;AAAA,IAAA,CAC/B;AAAA,EAAA;AAEb;"} \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-util-pgfkeys/package.json b/node_modules/@unified-latex/unified-latex-util-pgfkeys/package.json new file mode 100644 index 0000000..0e64358 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-util-pgfkeys/package.json @@ -0,0 +1,54 @@ +{ + "name": "@unified-latex/unified-latex-util-pgfkeys", + "version": "1.8.1", + "description": "Functions for manipulating pgfkeys-like arguments in a unified-latex AST", + "main": "index.js", + "type": "module", + "dependencies": { + "@unified-latex/unified-latex-types": "^1.8.0", + "@unified-latex/unified-latex-util-match": "^1.8.0", + "@unified-latex/unified-latex-util-pegjs": "^1.8.1", + "@unified-latex/unified-latex-util-print-raw": "^1.8.0" + }, + "repository": { + "type": "git", + "url": "git+https://github.com/siefkenj/unified-latex.git" + }, + "keywords": [ + "pegjs", + "latex", + "parser", + "prettier", + "unified-latex", + "unified" + ], + "author": "Jason Siefken", + "license": "MIT", + "bugs": { + "url": "https://github.com/siefkenj/unified-latex/issues" + }, + "homepage": "https://github.com/siefkenj/unified-latex#readme", + "exports": { + ".": { + "import": "./index.js", + "require": "./index.cjs", + "types": "./index.d.ts" + }, + "./*js": "./*js", + "./*": { + "import": "./*/index.js", + "require": "./*/index.cjs", + "types": "./*/index.d.ts" + }, + "./*/index": { + "import": "./*/index.js", + "require": "./*/index.cjs" + } + }, + "files": [ + "**/*ts", + "**/*js", + "**/*.map", + "**/*.json" + ] +} \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-util-print-raw/README.md b/node_modules/@unified-latex/unified-latex-util-print-raw/README.md new file mode 100644 index 0000000..24d106f --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-util-print-raw/README.md @@ -0,0 +1,48 @@ + + + + +# unified-latex-util-print-raw + +## What is this? + +Functions to print a `unified-latex` Abstract Syntax Tree (AST) to a string. + +## When should I use this? + +If you want to directly print an `Ast.Ast` to a string without any pretty printing or formatting. + +## Install + +```bash +npm install @unified-latex/unified-latex-util-print-raw +``` + +This package contains both esm and commonjs exports. To explicitly access the esm export, +import the `.js` file. To explicitly access the commonjs export, import the `.cjs` file. + +# Functions + +## `printRaw(node, options)` + +Renders the AST to a string without any pretty printing. + +```typescript +function printRaw( + node: Printable | Printable[], + options: { asArray: false } +): string; +``` + +**Parameters** + +| Param | Type | Description | +| :------ | :------------------------- | ------------------------------------------------------------------------------------------------------------------------------- | +| node | `Printable \| Printable[]` | | +| options | `{ asArray: false; }` | * Setting `asArray` to `true` will return an array of strings and the symbol `linebreak`, so that printing can be customized. | + +# Constants + +| Name | Type | +| :---------- | :------- | +| `linebreak` | `Symbol` | diff --git a/node_modules/@unified-latex/unified-latex-util-print-raw/index.cjs b/node_modules/@unified-latex/unified-latex-util-print-raw/index.cjs new file mode 100644 index 0000000..c8ed3a6 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-util-print-raw/index.cjs @@ -0,0 +1,91 @@ +"use strict"; +Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" }); +const linebreak = Symbol("linebreak"); +const ESCAPE = "\\"; +function _printRaw(node) { + if (typeof node === "string") { + return [node]; + } + if (Array.isArray(node)) { + return [].concat( + ...node.map((n) => _printRaw(n)) + ); + } + let argsString, escape; + switch (node.type) { + case "root": + return _printRaw(node.content); + case "argument": + return [node.openMark, ..._printRaw(node.content), node.closeMark]; + case "comment": + let suffix = node.suffixParbreak ? "" : linebreak; + let leadingWhitespace = ""; + if (node.sameline && node.leadingWhitespace) { + leadingWhitespace = " "; + } + if (node.sameline) { + return [ + leadingWhitespace, + "%", + ..._printRaw(node.content), + suffix + ]; + } + return [linebreak, "%", ..._printRaw(node.content), suffix]; + case "environment": + case "mathenv": + case "verbatim": + let env = _printRaw(node.env); + let envStart = [ESCAPE + "begin{", ...env, "}"]; + let envEnd = [ESCAPE + "end{", ...env, "}"]; + argsString = node.args == null ? [] : _printRaw(node.args); + return [ + ...envStart, + ...argsString, + ..._printRaw(node.content), + ...envEnd + ]; + case "displaymath": + return [ESCAPE + "[", ..._printRaw(node.content), ESCAPE + "]"]; + case "group": + return ["{", ..._printRaw(node.content), "}"]; + case "inlinemath": + return ["$", ..._printRaw(node.content), "$"]; + case "macro": + argsString = node.args == null ? [] : _printRaw(node.args); + escape = node.escapeToken == null ? ESCAPE : node.escapeToken; + return [escape, ..._printRaw(node.content), ...argsString]; + case "parbreak": + return [linebreak, linebreak]; + case "string": + return [node.content]; + case "verb": + return [ + ESCAPE, + node.env, + node.escape, + ..._printRaw(node.content), + node.escape + ]; + case "whitespace": + return [" "]; + default: + console.warn( + "Cannot find render for node ", + node, + `(of type ${typeof node})` + ); + return ["" + node]; + } +} +function printRaw(node, options) { + const asArray = options != null ? options.asArray : false; + const printedTokens = _printRaw(node); + if (asArray) { + return printedTokens; + } + return printedTokens.map((x) => x === linebreak ? "\n" : x).join(""); +} +exports.linebreak = linebreak; +exports.printRaw = printRaw; +//# sourceMappingURL=index.cjs.map diff --git a/node_modules/@unified-latex/unified-latex-util-print-raw/index.cjs.map b/node_modules/@unified-latex/unified-latex-util-print-raw/index.cjs.map new file mode 100644 index 0000000..3c8acc2 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-util-print-raw/index.cjs.map @@ -0,0 +1 @@ +{"version":3,"file":"index.cjs","sources":["../libs/print-raw.ts"],"sourcesContent":["import * as Ast from \"@unified-latex/unified-latex-types\";\n\ntype Printable = Ast.Node | Ast.Argument | string;\ntype PrintToken = string | typeof linebreak;\n\nexport const linebreak = Symbol(\"linebreak\");\nconst ESCAPE = \"\\\\\";\n\n/**\n * Renders the AST to an array inserting `linebreak` where needed;\n * This array may be nested.\n *\n * @param {*} node\n */\nfunction _printRaw(node: Printable | Printable[]): PrintToken[] {\n if (typeof node === \"string\") {\n return [node];\n }\n if (Array.isArray(node)) {\n return ([] as PrintToken[]).concat(\n ...node.map((n: Printable) => _printRaw(n))\n );\n }\n // tmp variables\n let argsString, escape;\n switch (node.type) {\n case \"root\":\n return _printRaw(node.content);\n case \"argument\":\n return [node.openMark, ..._printRaw(node.content), node.closeMark];\n case \"comment\":\n let suffix = node.suffixParbreak ? \"\" : linebreak;\n // A comment is responsible for printing its own leading whitespace\n let leadingWhitespace = \"\";\n if (node.sameline && node.leadingWhitespace) {\n leadingWhitespace = \" \";\n }\n if (node.sameline) {\n return [\n leadingWhitespace,\n \"%\",\n ..._printRaw(node.content),\n suffix,\n ];\n }\n return [linebreak, \"%\", ..._printRaw(node.content), suffix];\n case \"environment\":\n case \"mathenv\":\n case \"verbatim\":\n let env = _printRaw(node.env);\n let envStart: PrintToken[] = [ESCAPE + \"begin{\", ...env, \"}\"];\n let envEnd: PrintToken[] = [ESCAPE + \"end{\", ...env, \"}\"];\n argsString =\n (node as any).args == null ? [] : _printRaw((node as any).args);\n return [\n ...envStart,\n ...argsString,\n ..._printRaw(node.content),\n ...envEnd,\n ];\n case \"displaymath\":\n return [ESCAPE + \"[\", ..._printRaw(node.content), ESCAPE + \"]\"];\n case \"group\":\n return [\"{\", ..._printRaw(node.content), \"}\"];\n case \"inlinemath\":\n return [\"$\", ..._printRaw(node.content), \"$\"];\n case \"macro\":\n argsString = node.args == null ? [] : _printRaw(node.args);\n escape = node.escapeToken == null ? ESCAPE : node.escapeToken;\n return [escape, ..._printRaw(node.content), ...argsString];\n case \"parbreak\":\n return [linebreak, linebreak];\n case \"string\":\n return [node.content];\n case \"verb\":\n return [\n ESCAPE,\n node.env,\n node.escape,\n ..._printRaw(node.content),\n node.escape,\n ];\n case \"whitespace\":\n return [\" \"];\n\n default:\n console.warn(\n \"Cannot find render for node \",\n node,\n `(of type ${typeof node})`\n );\n return [\"\" + node];\n }\n}\n\n/**\n * Renders the AST to a string without any pretty printing.\n *\n * @param {*} node\n * @param {*} options - Setting `asArray` to `true` will return an array of strings and the symbol `linebreak`, so that printing can be customized.\n */\nexport function printRaw(\n node: Printable | Printable[],\n options?: { asArray: false }\n): string;\nexport function printRaw(\n node: Printable | Printable[],\n options: { asArray: true }\n): PrintToken[];\nexport function printRaw(node: Printable | Printable[], options?: object): any {\n const asArray = options != null ? (options as any).asArray : false;\n const printedTokens = _printRaw(node);\n if (asArray) {\n return printedTokens;\n }\n return printedTokens.map((x) => (x === linebreak ? \"\\n\" : x)).join(\"\");\n}\n"],"names":[],"mappings":";;AAKa,MAAA,YAAY,OAAO,WAAW;AAC3C,MAAM,SAAS;AAQf,SAAS,UAAU,MAA6C;AACxD,MAAA,OAAO,SAAS,UAAU;AAC1B,WAAO,CAAC,IAAI;AAAA,EAChB;AACI,MAAA,MAAM,QAAQ,IAAI,GAAG;AACrB,WAAQ,CAAoB,EAAA;AAAA,MACxB,GAAG,KAAK,IAAI,CAAC,MAAiB,UAAU,CAAC,CAAC;AAAA,IAAA;AAAA,EAElD;AAEA,MAAI,YAAY;AAChB,UAAQ,KAAK,MAAM;AAAA,IACf,KAAK;AACM,aAAA,UAAU,KAAK,OAAO;AAAA,IACjC,KAAK;AACM,aAAA,CAAC,KAAK,UAAU,GAAG,UAAU,KAAK,OAAO,GAAG,KAAK,SAAS;AAAA,IACrE,KAAK;AACG,UAAA,SAAS,KAAK,iBAAiB,KAAK;AAExC,UAAI,oBAAoB;AACpB,UAAA,KAAK,YAAY,KAAK,mBAAmB;AACrB,4BAAA;AAAA,MACxB;AACA,UAAI,KAAK,UAAU;AACR,eAAA;AAAA,UACH;AAAA,UACA;AAAA,UACA,GAAG,UAAU,KAAK,OAAO;AAAA,UACzB;AAAA,QAAA;AAAA,MAER;AACO,aAAA,CAAC,WAAW,KAAK,GAAG,UAAU,KAAK,OAAO,GAAG,MAAM;AAAA,IAC9D,KAAK;AAAA,IACL,KAAK;AAAA,IACL,KAAK;AACG,UAAA,MAAM,UAAU,KAAK,GAAG;AAC5B,UAAI,WAAyB,CAAC,SAAS,UAAU,GAAG,KAAK,GAAG;AAC5D,UAAI,SAAuB,CAAC,SAAS,QAAQ,GAAG,KAAK,GAAG;AACxD,mBACK,KAAa,QAAQ,OAAO,CAAK,IAAA,UAAW,KAAa,IAAI;AAC3D,aAAA;AAAA,QACH,GAAG;AAAA,QACH,GAAG;AAAA,QACH,GAAG,UAAU,KAAK,OAAO;AAAA,QACzB,GAAG;AAAA,MAAA;AAAA,IAEX,KAAK;AACM,aAAA,CAAC,SAAS,KAAK,GAAG,UAAU,KAAK,OAAO,GAAG,SAAS,GAAG;AAAA,IAClE,KAAK;AACD,aAAO,CAAC,KAAK,GAAG,UAAU,KAAK,OAAO,GAAG,GAAG;AAAA,IAChD,KAAK;AACD,aAAO,CAAC,KAAK,GAAG,UAAU,KAAK,OAAO,GAAG,GAAG;AAAA,IAChD,KAAK;AACD,mBAAa,KAAK,QAAQ,OAAO,CAAK,IAAA,UAAU,KAAK,IAAI;AACzD,eAAS,KAAK,eAAe,OAAO,SAAS,KAAK;AAC3C,aAAA,CAAC,QAAQ,GAAG,UAAU,KAAK,OAAO,GAAG,GAAG,UAAU;AAAA,IAC7D,KAAK;AACM,aAAA,CAAC,WAAW,SAAS;AAAA,IAChC,KAAK;AACM,aAAA,CAAC,KAAK,OAAO;AAAA,IACxB,KAAK;AACM,aAAA;AAAA,QACH;AAAA,QACA,KAAK;AAAA,QACL,KAAK;AAAA,QACL,GAAG,UAAU,KAAK,OAAO;AAAA,QACzB,KAAK;AAAA,MAAA;AAAA,IAEb,KAAK;AACD,aAAO,CAAC,GAAG;AAAA,IAEf;AACY,cAAA;AAAA,QACJ;AAAA,QACA;AAAA,QACA,YAAY,OAAO,IAAI;AAAA,MAAA;AAEpB,aAAA,CAAC,KAAK,IAAI;AAAA,EACzB;AACJ;AAgBgB,SAAA,SAAS,MAA+B,SAAuB;AAC3E,QAAM,UAAU,WAAW,OAAQ,QAAgB,UAAU;AACvD,QAAA,gBAAgB,UAAU,IAAI;AACpC,MAAI,SAAS;AACF,WAAA;AAAA,EACX;AACO,SAAA,cAAc,IAAI,CAAC,MAAO,MAAM,YAAY,OAAO,CAAE,EAAE,KAAK,EAAE;AACzE;;;"} \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-util-print-raw/index.d.ts b/node_modules/@unified-latex/unified-latex-util-print-raw/index.d.ts new file mode 100644 index 0000000..df46044 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-util-print-raw/index.d.ts @@ -0,0 +1,23 @@ +import * as Ast from '@unified-latex/unified-latex-types'; + +export declare const linebreak: unique symbol; + +declare type Printable = Ast.Node | Ast.Argument | string; + +/** + * Renders the AST to a string without any pretty printing. + * + * @param {*} node + * @param {*} options - Setting `asArray` to `true` will return an array of strings and the symbol `linebreak`, so that printing can be customized. + */ +export declare function printRaw(node: Printable | Printable[], options?: { + asArray: false; +}): string; + +export declare function printRaw(node: Printable | Printable[], options: { + asArray: true; +}): PrintToken[]; + +declare type PrintToken = string | typeof linebreak; + +export { } diff --git a/node_modules/@unified-latex/unified-latex-util-print-raw/index.js b/node_modules/@unified-latex/unified-latex-util-print-raw/index.js new file mode 100644 index 0000000..a6dafb0 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-util-print-raw/index.js @@ -0,0 +1,91 @@ +const linebreak = Symbol("linebreak"); +const ESCAPE = "\\"; +function _printRaw(node) { + if (typeof node === "string") { + return [node]; + } + if (Array.isArray(node)) { + return [].concat( + ...node.map((n) => _printRaw(n)) + ); + } + let argsString, escape; + switch (node.type) { + case "root": + return _printRaw(node.content); + case "argument": + return [node.openMark, ..._printRaw(node.content), node.closeMark]; + case "comment": + let suffix = node.suffixParbreak ? "" : linebreak; + let leadingWhitespace = ""; + if (node.sameline && node.leadingWhitespace) { + leadingWhitespace = " "; + } + if (node.sameline) { + return [ + leadingWhitespace, + "%", + ..._printRaw(node.content), + suffix + ]; + } + return [linebreak, "%", ..._printRaw(node.content), suffix]; + case "environment": + case "mathenv": + case "verbatim": + let env = _printRaw(node.env); + let envStart = [ESCAPE + "begin{", ...env, "}"]; + let envEnd = [ESCAPE + "end{", ...env, "}"]; + argsString = node.args == null ? [] : _printRaw(node.args); + return [ + ...envStart, + ...argsString, + ..._printRaw(node.content), + ...envEnd + ]; + case "displaymath": + return [ESCAPE + "[", ..._printRaw(node.content), ESCAPE + "]"]; + case "group": + return ["{", ..._printRaw(node.content), "}"]; + case "inlinemath": + return ["$", ..._printRaw(node.content), "$"]; + case "macro": + argsString = node.args == null ? [] : _printRaw(node.args); + escape = node.escapeToken == null ? ESCAPE : node.escapeToken; + return [escape, ..._printRaw(node.content), ...argsString]; + case "parbreak": + return [linebreak, linebreak]; + case "string": + return [node.content]; + case "verb": + return [ + ESCAPE, + node.env, + node.escape, + ..._printRaw(node.content), + node.escape + ]; + case "whitespace": + return [" "]; + default: + console.warn( + "Cannot find render for node ", + node, + `(of type ${typeof node})` + ); + return ["" + node]; + } +} +function printRaw(node, options) { + const asArray = options != null ? options.asArray : false; + const printedTokens = _printRaw(node); + if (asArray) { + return printedTokens; + } + return printedTokens.map((x) => x === linebreak ? "\n" : x).join(""); +} +export { + linebreak, + printRaw +}; +//# sourceMappingURL=index.js.map diff --git a/node_modules/@unified-latex/unified-latex-util-print-raw/index.js.map b/node_modules/@unified-latex/unified-latex-util-print-raw/index.js.map new file mode 100644 index 0000000..c85e6dd --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-util-print-raw/index.js.map @@ -0,0 +1 @@ +{"version":3,"file":"index.js","sources":["../libs/print-raw.ts"],"sourcesContent":["import * as Ast from \"@unified-latex/unified-latex-types\";\n\ntype Printable = Ast.Node | Ast.Argument | string;\ntype PrintToken = string | typeof linebreak;\n\nexport const linebreak = Symbol(\"linebreak\");\nconst ESCAPE = \"\\\\\";\n\n/**\n * Renders the AST to an array inserting `linebreak` where needed;\n * This array may be nested.\n *\n * @param {*} node\n */\nfunction _printRaw(node: Printable | Printable[]): PrintToken[] {\n if (typeof node === \"string\") {\n return [node];\n }\n if (Array.isArray(node)) {\n return ([] as PrintToken[]).concat(\n ...node.map((n: Printable) => _printRaw(n))\n );\n }\n // tmp variables\n let argsString, escape;\n switch (node.type) {\n case \"root\":\n return _printRaw(node.content);\n case \"argument\":\n return [node.openMark, ..._printRaw(node.content), node.closeMark];\n case \"comment\":\n let suffix = node.suffixParbreak ? \"\" : linebreak;\n // A comment is responsible for printing its own leading whitespace\n let leadingWhitespace = \"\";\n if (node.sameline && node.leadingWhitespace) {\n leadingWhitespace = \" \";\n }\n if (node.sameline) {\n return [\n leadingWhitespace,\n \"%\",\n ..._printRaw(node.content),\n suffix,\n ];\n }\n return [linebreak, \"%\", ..._printRaw(node.content), suffix];\n case \"environment\":\n case \"mathenv\":\n case \"verbatim\":\n let env = _printRaw(node.env);\n let envStart: PrintToken[] = [ESCAPE + \"begin{\", ...env, \"}\"];\n let envEnd: PrintToken[] = [ESCAPE + \"end{\", ...env, \"}\"];\n argsString =\n (node as any).args == null ? [] : _printRaw((node as any).args);\n return [\n ...envStart,\n ...argsString,\n ..._printRaw(node.content),\n ...envEnd,\n ];\n case \"displaymath\":\n return [ESCAPE + \"[\", ..._printRaw(node.content), ESCAPE + \"]\"];\n case \"group\":\n return [\"{\", ..._printRaw(node.content), \"}\"];\n case \"inlinemath\":\n return [\"$\", ..._printRaw(node.content), \"$\"];\n case \"macro\":\n argsString = node.args == null ? [] : _printRaw(node.args);\n escape = node.escapeToken == null ? ESCAPE : node.escapeToken;\n return [escape, ..._printRaw(node.content), ...argsString];\n case \"parbreak\":\n return [linebreak, linebreak];\n case \"string\":\n return [node.content];\n case \"verb\":\n return [\n ESCAPE,\n node.env,\n node.escape,\n ..._printRaw(node.content),\n node.escape,\n ];\n case \"whitespace\":\n return [\" \"];\n\n default:\n console.warn(\n \"Cannot find render for node \",\n node,\n `(of type ${typeof node})`\n );\n return [\"\" + node];\n }\n}\n\n/**\n * Renders the AST to a string without any pretty printing.\n *\n * @param {*} node\n * @param {*} options - Setting `asArray` to `true` will return an array of strings and the symbol `linebreak`, so that printing can be customized.\n */\nexport function printRaw(\n node: Printable | Printable[],\n options?: { asArray: false }\n): string;\nexport function printRaw(\n node: Printable | Printable[],\n options: { asArray: true }\n): PrintToken[];\nexport function printRaw(node: Printable | Printable[], options?: object): any {\n const asArray = options != null ? (options as any).asArray : false;\n const printedTokens = _printRaw(node);\n if (asArray) {\n return printedTokens;\n }\n return printedTokens.map((x) => (x === linebreak ? \"\\n\" : x)).join(\"\");\n}\n"],"names":[],"mappings":"AAKa,MAAA,YAAY,OAAO,WAAW;AAC3C,MAAM,SAAS;AAQf,SAAS,UAAU,MAA6C;AACxD,MAAA,OAAO,SAAS,UAAU;AAC1B,WAAO,CAAC,IAAI;AAAA,EAChB;AACI,MAAA,MAAM,QAAQ,IAAI,GAAG;AACrB,WAAQ,CAAoB,EAAA;AAAA,MACxB,GAAG,KAAK,IAAI,CAAC,MAAiB,UAAU,CAAC,CAAC;AAAA,IAAA;AAAA,EAElD;AAEA,MAAI,YAAY;AAChB,UAAQ,KAAK,MAAM;AAAA,IACf,KAAK;AACM,aAAA,UAAU,KAAK,OAAO;AAAA,IACjC,KAAK;AACM,aAAA,CAAC,KAAK,UAAU,GAAG,UAAU,KAAK,OAAO,GAAG,KAAK,SAAS;AAAA,IACrE,KAAK;AACG,UAAA,SAAS,KAAK,iBAAiB,KAAK;AAExC,UAAI,oBAAoB;AACpB,UAAA,KAAK,YAAY,KAAK,mBAAmB;AACrB,4BAAA;AAAA,MACxB;AACA,UAAI,KAAK,UAAU;AACR,eAAA;AAAA,UACH;AAAA,UACA;AAAA,UACA,GAAG,UAAU,KAAK,OAAO;AAAA,UACzB;AAAA,QAAA;AAAA,MAER;AACO,aAAA,CAAC,WAAW,KAAK,GAAG,UAAU,KAAK,OAAO,GAAG,MAAM;AAAA,IAC9D,KAAK;AAAA,IACL,KAAK;AAAA,IACL,KAAK;AACG,UAAA,MAAM,UAAU,KAAK,GAAG;AAC5B,UAAI,WAAyB,CAAC,SAAS,UAAU,GAAG,KAAK,GAAG;AAC5D,UAAI,SAAuB,CAAC,SAAS,QAAQ,GAAG,KAAK,GAAG;AACxD,mBACK,KAAa,QAAQ,OAAO,CAAK,IAAA,UAAW,KAAa,IAAI;AAC3D,aAAA;AAAA,QACH,GAAG;AAAA,QACH,GAAG;AAAA,QACH,GAAG,UAAU,KAAK,OAAO;AAAA,QACzB,GAAG;AAAA,MAAA;AAAA,IAEX,KAAK;AACM,aAAA,CAAC,SAAS,KAAK,GAAG,UAAU,KAAK,OAAO,GAAG,SAAS,GAAG;AAAA,IAClE,KAAK;AACD,aAAO,CAAC,KAAK,GAAG,UAAU,KAAK,OAAO,GAAG,GAAG;AAAA,IAChD,KAAK;AACD,aAAO,CAAC,KAAK,GAAG,UAAU,KAAK,OAAO,GAAG,GAAG;AAAA,IAChD,KAAK;AACD,mBAAa,KAAK,QAAQ,OAAO,CAAK,IAAA,UAAU,KAAK,IAAI;AACzD,eAAS,KAAK,eAAe,OAAO,SAAS,KAAK;AAC3C,aAAA,CAAC,QAAQ,GAAG,UAAU,KAAK,OAAO,GAAG,GAAG,UAAU;AAAA,IAC7D,KAAK;AACM,aAAA,CAAC,WAAW,SAAS;AAAA,IAChC,KAAK;AACM,aAAA,CAAC,KAAK,OAAO;AAAA,IACxB,KAAK;AACM,aAAA;AAAA,QACH;AAAA,QACA,KAAK;AAAA,QACL,KAAK;AAAA,QACL,GAAG,UAAU,KAAK,OAAO;AAAA,QACzB,KAAK;AAAA,MAAA;AAAA,IAEb,KAAK;AACD,aAAO,CAAC,GAAG;AAAA,IAEf;AACY,cAAA;AAAA,QACJ;AAAA,QACA;AAAA,QACA,YAAY,OAAO,IAAI;AAAA,MAAA;AAEpB,aAAA,CAAC,KAAK,IAAI;AAAA,EACzB;AACJ;AAgBgB,SAAA,SAAS,MAA+B,SAAuB;AAC3E,QAAM,UAAU,WAAW,OAAQ,QAAgB,UAAU;AACvD,QAAA,gBAAgB,UAAU,IAAI;AACpC,MAAI,SAAS;AACF,WAAA;AAAA,EACX;AACO,SAAA,cAAc,IAAI,CAAC,MAAO,MAAM,YAAY,OAAO,CAAE,EAAE,KAAK,EAAE;AACzE;"} \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-util-print-raw/package.json b/node_modules/@unified-latex/unified-latex-util-print-raw/package.json new file mode 100644 index 0000000..5ea2715 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-util-print-raw/package.json @@ -0,0 +1,51 @@ +{ + "name": "@unified-latex/unified-latex-util-print-raw", + "version": "1.8.0", + "description": "Print a unified-latex AST with no fancy formatting", + "main": "index.js", + "type": "module", + "dependencies": { + "@unified-latex/unified-latex-types": "^1.8.0" + }, + "repository": { + "type": "git", + "url": "git+https://github.com/siefkenj/unified-latex.git" + }, + "keywords": [ + "pegjs", + "latex", + "parser", + "prettier", + "unified-latex", + "unified" + ], + "author": "Jason Siefken", + "license": "MIT", + "bugs": { + "url": "https://github.com/siefkenj/unified-latex/issues" + }, + "homepage": "https://github.com/siefkenj/unified-latex#readme", + "exports": { + ".": { + "import": "./index.js", + "require": "./index.cjs", + "types": "./index.d.ts" + }, + "./*js": "./*js", + "./*": { + "import": "./*/index.js", + "require": "./*/index.cjs", + "types": "./*/index.d.ts" + }, + "./*/index": { + "import": "./*/index.js", + "require": "./*/index.cjs" + } + }, + "files": [ + "**/*ts", + "**/*js", + "**/*.map", + "**/*.json" + ] +} \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-util-render-info/README.md b/node_modules/@unified-latex/unified-latex-util-render-info/README.md new file mode 100644 index 0000000..3e702cb --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-util-render-info/README.md @@ -0,0 +1,63 @@ + + + + +# unified-latex-util-render-info + +## What is this? + +Functions to help modify the `_renderInfo` of a `unified-latex` Abstract Syntax Tree (AST). + +## When should I use this? + +If you want to compare the structure of an AST without position information or extra information +that is kept for pretty-printing, these functions can be used to remove/modify the `_renderInfo` +of an `Ast.Node`. + +## Install + +```bash +npm install @unified-latex/unified-latex-util-render-info +``` + +This package contains both esm and commonjs exports. To explicitly access the esm export, +import the `.js` file. To explicitly access the commonjs export, import the `.cjs` file. + +# Functions + +## `trimRenderInfo(ast)` + +Removes any `_renderInfo` and `position` tags present in the AST. This +operation is *destructive*. + +```typescript +function trimRenderInfo(ast: Ast.Ast): T; +``` + +**Parameters** + +| Param | Type | +| :---- | :-------- | +| ast | `Ast.Ast` | + +## `updateRenderInfo(node, renderInfo)` + +Updates the `._renderInfo` property on a node to include +whatever has been supplied to `renderInfo`. If `renderInfo` +is null, no update is performed. + +*This operation mutates `node`* + +```typescript +function updateRenderInfo( + node: Ast.Node | Ast.Argument, + renderInfo: {} +): Ast.Node | Ast.Argument; +``` + +**Parameters** + +| Param | Type | +| :--------- | :------------------------- | +| node | `Ast.Node \| Ast.Argument` | +| renderInfo | `{}` | diff --git a/node_modules/@unified-latex/unified-latex-util-render-info/index.cjs b/node_modules/@unified-latex/unified-latex-util-render-info/index.cjs new file mode 100644 index 0000000..eee7751 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-util-render-info/index.cjs @@ -0,0 +1,19 @@ +"use strict"; +Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" }); +const unifiedLatexUtilVisit = require("@unified-latex/unified-latex-util-visit"); +function updateRenderInfo(node, renderInfo) { + if (renderInfo != null) { + node._renderInfo = { ...node._renderInfo || {}, ...renderInfo }; + } + return node; +} +function trimRenderInfo(ast) { + unifiedLatexUtilVisit.visit(ast, (node) => { + delete node._renderInfo; + delete node.position; + }); + return ast; +} +exports.trimRenderInfo = trimRenderInfo; +exports.updateRenderInfo = updateRenderInfo; +//# sourceMappingURL=index.cjs.map diff --git a/node_modules/@unified-latex/unified-latex-util-render-info/index.cjs.map b/node_modules/@unified-latex/unified-latex-util-render-info/index.cjs.map new file mode 100644 index 0000000..fa5bc67 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-util-render-info/index.cjs.map @@ -0,0 +1 @@ +{"version":3,"file":"index.cjs","sources":["../index.ts"],"sourcesContent":["import * as Ast from \"@unified-latex/unified-latex-types\";\nimport { visit } from \"@unified-latex/unified-latex-util-visit\";\n\n/**\n * Updates the `._renderInfo` property on a node to include\n * whatever has been supplied to `renderInfo`. If `renderInfo`\n * is null, no update is performed.\n *\n * *This operation mutates `node`*\n */\nexport function updateRenderInfo(\n node: Ast.Node | Ast.Argument,\n renderInfo: object | null | undefined\n) {\n if (renderInfo != null) {\n node._renderInfo = { ...(node._renderInfo || {}), ...renderInfo };\n }\n return node;\n}\n\n/**\n * Removes any `_renderInfo` and `position` tags present in the AST. This\n * operation is _destructive_.\n */\nexport function trimRenderInfo(ast: T) {\n visit(ast, (node) => {\n delete node._renderInfo;\n delete node.position;\n });\n return ast;\n}\n\n// NOTE: The docstring comment must be the last item in the index.ts file!\n/**\n * ## What is this?\n *\n * Functions to help modify the `_renderInfo` of a `unified-latex` Abstract Syntax Tree (AST).\n *\n * ## When should I use this?\n *\n * If you want to compare the structure of an AST without position information or extra information\n * that is kept for pretty-printing, these functions can be used to remove/modify the `_renderInfo`\n * of an `Ast.Node`.\n */\n"],"names":["visit"],"mappings":";;;AAUgB,SAAA,iBACZ,MACA,YACF;AACE,MAAI,cAAc,MAAM;AACf,SAAA,cAAc,EAAE,GAAI,KAAK,eAAe,CAAA,GAAK,GAAG,WAAW;AAAA,EAAA;AAE7D,SAAA;AACX;AAMO,SAAS,eAAkC,KAAQ;AAChDA,8BAAA,KAAK,CAAC,SAAS;AACjB,WAAO,KAAK;AACZ,WAAO,KAAK;AAAA,EAAA,CACf;AACM,SAAA;AACX;;;"} \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-util-render-info/index.d.ts b/node_modules/@unified-latex/unified-latex-util-render-info/index.d.ts new file mode 100644 index 0000000..e917195 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-util-render-info/index.d.ts @@ -0,0 +1,18 @@ +import * as Ast from '@unified-latex/unified-latex-types'; + +/** + * Removes any `_renderInfo` and `position` tags present in the AST. This + * operation is _destructive_. + */ +export declare function trimRenderInfo(ast: T): T; + +/** + * Updates the `._renderInfo` property on a node to include + * whatever has been supplied to `renderInfo`. If `renderInfo` + * is null, no update is performed. + * + * *This operation mutates `node`* + */ +export declare function updateRenderInfo(node: Ast.Node | Ast.Argument, renderInfo: object | null | undefined): Ast.Node | Ast.Argument; + +export { } diff --git a/node_modules/@unified-latex/unified-latex-util-render-info/index.js b/node_modules/@unified-latex/unified-latex-util-render-info/index.js new file mode 100644 index 0000000..fb9463e --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-util-render-info/index.js @@ -0,0 +1,19 @@ +import { visit } from "@unified-latex/unified-latex-util-visit"; +function updateRenderInfo(node, renderInfo) { + if (renderInfo != null) { + node._renderInfo = { ...node._renderInfo || {}, ...renderInfo }; + } + return node; +} +function trimRenderInfo(ast) { + visit(ast, (node) => { + delete node._renderInfo; + delete node.position; + }); + return ast; +} +export { + trimRenderInfo, + updateRenderInfo +}; +//# sourceMappingURL=index.js.map diff --git a/node_modules/@unified-latex/unified-latex-util-render-info/index.js.map b/node_modules/@unified-latex/unified-latex-util-render-info/index.js.map new file mode 100644 index 0000000..4adb167 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-util-render-info/index.js.map @@ -0,0 +1 @@ +{"version":3,"file":"index.js","sources":["../index.ts"],"sourcesContent":["import * as Ast from \"@unified-latex/unified-latex-types\";\nimport { visit } from \"@unified-latex/unified-latex-util-visit\";\n\n/**\n * Updates the `._renderInfo` property on a node to include\n * whatever has been supplied to `renderInfo`. If `renderInfo`\n * is null, no update is performed.\n *\n * *This operation mutates `node`*\n */\nexport function updateRenderInfo(\n node: Ast.Node | Ast.Argument,\n renderInfo: object | null | undefined\n) {\n if (renderInfo != null) {\n node._renderInfo = { ...(node._renderInfo || {}), ...renderInfo };\n }\n return node;\n}\n\n/**\n * Removes any `_renderInfo` and `position` tags present in the AST. This\n * operation is _destructive_.\n */\nexport function trimRenderInfo(ast: T) {\n visit(ast, (node) => {\n delete node._renderInfo;\n delete node.position;\n });\n return ast;\n}\n\n// NOTE: The docstring comment must be the last item in the index.ts file!\n/**\n * ## What is this?\n *\n * Functions to help modify the `_renderInfo` of a `unified-latex` Abstract Syntax Tree (AST).\n *\n * ## When should I use this?\n *\n * If you want to compare the structure of an AST without position information or extra information\n * that is kept for pretty-printing, these functions can be used to remove/modify the `_renderInfo`\n * of an `Ast.Node`.\n */\n"],"names":[],"mappings":";AAUgB,SAAA,iBACZ,MACA,YACF;AACE,MAAI,cAAc,MAAM;AACf,SAAA,cAAc,EAAE,GAAI,KAAK,eAAe,CAAA,GAAK,GAAG,WAAW;AAAA,EAAA;AAE7D,SAAA;AACX;AAMO,SAAS,eAAkC,KAAQ;AAChD,QAAA,KAAK,CAAC,SAAS;AACjB,WAAO,KAAK;AACZ,WAAO,KAAK;AAAA,EAAA,CACf;AACM,SAAA;AACX;"} \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-util-render-info/package.json b/node_modules/@unified-latex/unified-latex-util-render-info/package.json new file mode 100644 index 0000000..9b9191d --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-util-render-info/package.json @@ -0,0 +1,52 @@ +{ + "name": "@unified-latex/unified-latex-util-render-info", + "version": "1.8.2", + "description": "Functions for modifying a unified-latex AST", + "main": "index.js", + "type": "module", + "dependencies": { + "@unified-latex/unified-latex-types": "^1.8.0", + "@unified-latex/unified-latex-util-visit": "^1.8.2" + }, + "repository": { + "type": "git", + "url": "git+https://github.com/siefkenj/unified-latex.git" + }, + "keywords": [ + "pegjs", + "latex", + "parser", + "prettier", + "unified-latex", + "unified" + ], + "author": "Jason Siefken", + "license": "MIT", + "bugs": { + "url": "https://github.com/siefkenj/unified-latex/issues" + }, + "homepage": "https://github.com/siefkenj/unified-latex#readme", + "exports": { + ".": { + "import": "./index.js", + "require": "./index.cjs", + "types": "./index.d.ts" + }, + "./*js": "./*js", + "./*": { + "import": "./*/index.js", + "require": "./*/index.cjs", + "types": "./*/index.d.ts" + }, + "./*/index": { + "import": "./*/index.js", + "require": "./*/index.cjs" + } + }, + "files": [ + "**/*ts", + "**/*js", + "**/*.map", + "**/*.json" + ] +} \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-util-replace/README.md b/node_modules/@unified-latex/unified-latex-util-replace/README.md new file mode 100644 index 0000000..617affc --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-util-replace/README.md @@ -0,0 +1,278 @@ + + + + +# unified-latex-util-replace + +## What is this? + +Functions to help modify a `unified-latex` Abstract Syntax Tree (AST). + +## When should I use this? + +If you want to recursively replace particular AST nodes. + +## Install + +```bash +npm install @unified-latex/unified-latex-util-replace +``` + +This package contains both esm and commonjs exports. To explicitly access the esm export, +import the `.js` file. To explicitly access the commonjs export, import the `.cjs` file. + +# Plugins + +## `unifiedLatexReplaceStreamingCommands` + +Unified plugin to replace all found streaming commands with their argument-style equivalents. +This only applies to sections of the tree with no math ancestor. + +### Usage + +`unified().use(unifiedLatexReplaceStreamingCommands[, options])` + +#### options + +```typescript +PluginOptions +``` + +### Type + +`Plugin` + +```typescript +function unifiedLatexReplaceStreamingCommands( + options: PluginOptions +): (tree: Ast.Root) => void; +``` + +where + +```typescript +type PluginOptions = { + replacers: Record< + string, + (content: Ast.Node[], streamingCommand: Ast.Macro) => Ast.Node | Ast.Node[] + >; +}; +``` + +# Functions + +## `firstSignificantNode(nodes, parbreaksAreInsignificant)` + +Returns the first non-whitespace/non-comment node in `nodes`. If there is no such +node, `null` is returned. + +```typescript +function firstSignificantNode( + nodes: Ast.Node[], + parbreaksAreInsignificant: Boolean +): Ast.Node; +``` + +**Parameters** + +| Param | Type | +| :------------------------ | :----------- | +| nodes | `Ast.Node[]` | +| parbreaksAreInsignificant | `Boolean` | + +## `firstSignificantNodeIndex(nodes, parbreaksAreInsignificant)` + +Returns the index of the first non-whitespace/non-comment node in `nodes`. If there is no such +node, `null` is returned. + +```typescript +function firstSignificantNodeIndex( + nodes: Ast.Node[], + parbreaksAreInsignificant: Boolean +): number; +``` + +**Parameters** + +| Param | Type | +| :------------------------ | :----------- | +| nodes | `Ast.Node[]` | +| parbreaksAreInsignificant | `Boolean` | + +## `lastSignificantNode(nodes, parbreaksAreInsignificant)` + +Returns the last non-whitespace/non-comment node in `nodes`. If there is no such +node, `null` is returned. + +```typescript +function lastSignificantNode( + nodes: Ast.Node[], + parbreaksAreInsignificant: Boolean +): Ast.Node; +``` + +**Parameters** + +| Param | Type | +| :------------------------ | :----------- | +| nodes | `Ast.Node[]` | +| parbreaksAreInsignificant | `Boolean` | + +## `lastSignificantNodeIndex(nodes, parbreaksAreInsignificant)` + +Returns the index of the last non-whitespace/non-comment node in `nodes`. If there is no such +node, `null` is returned. + +```typescript +function lastSignificantNodeIndex( + nodes: Ast.Node[], + parbreaksAreInsignificant: Boolean +): number; +``` + +**Parameters** + +| Param | Type | +| :------------------------ | :----------- | +| nodes | `Ast.Node[]` | +| parbreaksAreInsignificant | `Boolean` | + +## `replaceNode(ast, visitor)` + +Recursively replace nodes in `ast`. The `visitor` function is called on each node. If +`visitor` returns a node or an array of nodes, those nodes replace the node passed to `visitor`. +If `null` is returned, the node is deleted. If `undefined` is returned, no replacement happens. + +```typescript +function replaceNode( + ast: Ast.Ast, + visitor: ( + node: Ast.Node | Ast.Argument, + info: VisitInfo + ) => + | Ast.Node + | Ast.Argument + | (Ast.Node | Ast.Argument)[] + | null + | undefined + | void +): void; +``` + +**Parameters** + +| Param | Type | +| :------ | :-------------------------------- | +| ast | `Ast.Ast` | +| visitor | Omitted | + +## `replaceNodeDuringVisit(replacement, info)` + +Replaces the current node with `replacement`. It is assumed that the current +node is in an array that is a child of a parent element. If this is not the case, +the function will error. + +```typescript +function replaceNodeDuringVisit( + replacement: Ast.Node | Ast.Argument | (Ast.Node | Ast.Argument)[], + info: VisitInfo +): void; +``` + +**Parameters** + +| Param | Type | +| :---------- | :-------------------------------- | +| replacement | Omitted | +| info | `VisitInfo` | + +where + +```typescript +type VisitInfo = { + /** + * If the element was accessed via an attribute, the attribute key is specified. + */ + readonly key: string | undefined; + /** + * If the element was accessed in an array, the index is specified. + */ + readonly index: number | undefined; + /** + * A list of ancestor nodes, `[parent, grandparent, great-grandparent, ...]` + */ + readonly parents: (Ast.Node | Ast.Argument)[]; + /** + * If the element was accessed in an array, the array that it is part of. + */ + readonly containingArray: (Ast.Node | Ast.Argument)[] | undefined; + /** + * The LaTeX context of the current match. + */ + readonly context: VisitorContext; +}; +``` + +## `replaceStreamingCommand(ast, isStreamingCommand, replacer, options)` + +Given a group or a node array, look for streaming commands (e.g., `\bfseries`) and replace them +with the specified macro. The "arguments" of the streaming command are passed to `replacer` and the return +value of `replacer` is inserted into the stream. + +By default, this command will split at parbreaks (since commands like `\textbf{...} do not accept parbreaks in their +contents) and call `replacer\` multiple times, once per paragraph. + +Commands are also split at environments and at any macros listed in `macrosThatBreakPars`. + +```typescript +function replaceStreamingCommand( + ast: Ast.Group | Ast.Node[], + isStreamingCommand: (node: any) => node is Ast.Macro, + replacer: ( + content: Ast.Node[], + streamingCommand: Ast.Macro + ) => Ast.Node | Ast.Node[], + options: { + macrosThatBreakPars?: string[]; + environmentsThatDontBreakPars?: string[]; + } +): Ast.Node[]; +``` + +**Parameters** + +| Param | Type | +| :----------------- | :-------------------------------- | +| ast | `Ast.Group \| Ast.Node[]` | +| isStreamingCommand | Omitted | +| replacer | Omitted | +| options | Omitted | + +## `replaceStreamingCommandInGroup(group, isStreamingCommand, replacer, options)` + +Process streaming commands in a group. If needed, "escape" the group. +For example, `{\bfseries xx}` -> `\textbf{xx}`, but `{foo \bfseries xx}` -> `{foo \textbf{xx}}`. + +```typescript +function replaceStreamingCommandInGroup( + group: Ast.Group, + isStreamingCommand: (node: any) => node is Ast.Macro, + replacer: ( + content: Ast.Node[], + streamingCommand: Ast.Macro + ) => Ast.Node | Ast.Node[], + options: { + macrosThatBreakPars?: string[]; + environmentsThatDontBreakPars?: string[]; + } +): Ast.Node[]; +``` + +**Parameters** + +| Param | Type | +| :----------------- | :-------------------------------- | +| group | `Ast.Group` | +| isStreamingCommand | Omitted | +| replacer | Omitted | +| options | Omitted | diff --git a/node_modules/@unified-latex/unified-latex-util-replace/index.cjs b/node_modules/@unified-latex/unified-latex-util-replace/index.cjs new file mode 100644 index 0000000..23782c9 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-util-replace/index.cjs @@ -0,0 +1,390 @@ +"use strict"; +Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" }); +const unifiedLatexUtilVisit = require("@unified-latex/unified-latex-util-visit"); +const unifiedLatexUtilMatch = require("@unified-latex/unified-latex-util-match"); +const unifiedLatexUtilTrim = require("@unified-latex/unified-latex-util-trim"); +const unifiedLatexUtilSplit = require("@unified-latex/unified-latex-util-split"); +function replaceNode(ast, visitor) { + unifiedLatexUtilVisit.visit(ast, { + leave: (node, info) => { + let replacement = visitor(node, info); + if (typeof replacement === "undefined" || replacement === node) { + return; + } + if (!info.containingArray || info.index == null) { + throw new Error( + "Trying to replace node, but cannot find containing array" + ); + } + if (replacement === null || Array.isArray(replacement) && replacement.length === 0) { + info.containingArray.splice(info.index, 1); + return info.index; + } + if (!Array.isArray(replacement)) { + replacement = [replacement]; + } + info.containingArray.splice(info.index, 1, ...replacement); + return info.index + replacement.length; + } + }); +} +function firstSignificantNode(nodes, parbreaksAreInsignificant) { + const index = firstSignificantNodeIndex(nodes, parbreaksAreInsignificant); + if (index == null) { + return null; + } + return nodes[index]; +} +function lastSignificantNode(nodes, parbreaksAreInsignificant) { + const index = lastSignificantNodeIndex(nodes, parbreaksAreInsignificant); + if (index == null) { + return null; + } + return nodes[index]; +} +function lastSignificantNodeIndex(nodes, parbreaksAreInsignificant) { + for (let i = nodes.length - 1; i >= 0; i--) { + const node = nodes[i]; + if (unifiedLatexUtilMatch.match.whitespace(node) || unifiedLatexUtilMatch.match.comment(node) || parbreaksAreInsignificant && unifiedLatexUtilMatch.match.parbreak(node)) { + continue; + } + return i; + } + return void 0; +} +function firstSignificantNodeIndex(nodes, parbreaksAreInsignificant) { + for (let i = 0; i < nodes.length; i++) { + const node = nodes[i]; + if (unifiedLatexUtilMatch.match.whitespace(node) || unifiedLatexUtilMatch.match.comment(node) || parbreaksAreInsignificant && unifiedLatexUtilMatch.match.parbreak(node)) { + continue; + } + return i; + } + return void 0; +} +function isSpaceLike(node) { + return unifiedLatexUtilMatch.match.whitespace(node) || unifiedLatexUtilMatch.match.comment(node) && Boolean(node.leadingWhitespace); +} +function joinWithoutExcessWhitespace(head, tail) { + if (tail.length === 0) { + return; + } + if (head.length === 0) { + head.push(...tail); + return; + } + const headEnd = head[head.length - 1]; + const tailStart = tail[0]; + if (unifiedLatexUtilMatch.match.whitespace(headEnd) && unifiedLatexUtilMatch.match.whitespace(tailStart)) { + head.push(...tail.slice(1)); + return; + } + if (!isSpaceLike(headEnd) || !isSpaceLike(tailStart)) { + if (unifiedLatexUtilMatch.match.whitespace(headEnd) && unifiedLatexUtilMatch.match.comment(tailStart)) { + const comment2 = { + type: "comment", + content: tailStart.content, + sameline: true, + leadingWhitespace: true + }; + tail = tail.slice(1); + unifiedLatexUtilTrim.trimStart(tail); + head.pop(); + head.push(comment2, ...tail); + return; + } + head.push(...tail); + return; + } + if (unifiedLatexUtilMatch.match.comment(headEnd) && unifiedLatexUtilMatch.match.comment(tailStart)) { + if (tailStart.leadingWhitespace || tailStart.sameline) { + head.push( + { type: "comment", content: tailStart.content }, + ...tail.slice(1) + ); + return; + } + head.push(...tail); + return; + } + let comment = unifiedLatexUtilMatch.match.comment(headEnd) ? headEnd : tailStart; + if (!unifiedLatexUtilMatch.match.comment(comment)) { + throw new Error( + `Expected a comment but found ${JSON.stringify(comment)}` + ); + } + if (!comment.leadingWhitespace || !comment.sameline) { + comment = { + type: "comment", + content: comment.content, + leadingWhitespace: true, + sameline: true + }; + } + head.pop(); + head.push(comment, ...tail.slice(1)); +} +function wrapSignificantContent(content, wrapper) { + let hoistUntil = 0; + let hoistAfter = content.length; + for (let i = 0; i < content.length; i++) { + if (unifiedLatexUtilMatch.match.whitespace(content[i]) || unifiedLatexUtilMatch.match.comment(content[i])) { + hoistUntil = i + 1; + continue; + } + break; + } + for (let j = content.length - 1; j >= 0; j--) { + if (unifiedLatexUtilMatch.match.whitespace(content[j]) || unifiedLatexUtilMatch.match.comment(content[j])) { + hoistAfter = j; + continue; + } + break; + } + if (hoistUntil === 0 && hoistAfter === content.length) { + return ensureArray(wrapper(content)); + } + const frontMatter = content.slice(0, hoistUntil); + const middle = content.slice(hoistUntil, hoistAfter); + const backMatter = content.slice(hoistAfter, content.length); + return frontMatter.concat(wrapper(middle), backMatter); +} +function ensureArray(x) { + if (!Array.isArray(x)) { + return [x]; + } + return x; +} +function replaceStreamingCommandInArray(nodes, isStreamingCommand, replacer) { + while (nodes.length > 0 && isStreamingCommand(nodes[nodes.length - 1])) { + nodes.pop(); + unifiedLatexUtilTrim.trimEnd(nodes); + } + const foundStreamingCommands = []; + for (let i = nodes.length - 1; i >= 0; i--) { + const node = nodes[i]; + if (isStreamingCommand(node)) { + const wrapper = (content) => replacer(content, node); + let tail = nodes.slice(i + 1); + unifiedLatexUtilTrim.trimStart(tail); + tail = wrapSignificantContent(tail, wrapper); + foundStreamingCommands.push(node); + nodes.splice(i); + joinWithoutExcessWhitespace(nodes, tail); + } + } + return { foundStreamingCommands }; +} +function replaceStreamingCommandInGroup(group, isStreamingCommand, replacer, options) { + const content = group.content; + let popFromGroup = isStreamingCommand(firstSignificantNode(content)); + let innerProcessed = replaceStreamingCommand( + content, + isStreamingCommand, + replacer, + options + ); + if (innerProcessed.length === 0) { + return []; + } + if (popFromGroup) { + return innerProcessed; + } else { + return [{ type: "group", content: innerProcessed }]; + } +} +function replaceStreamingCommand(ast, isStreamingCommand, replacer, options) { + if (typeof isStreamingCommand !== "function") { + throw new Error( + `'isStreamingCommand' must be a function, not '${typeof isStreamingCommand}'` + ); + } + const { + macrosThatBreakPars = [ + "part", + "chapter", + "section", + "subsection", + "subsubsection", + "vspace", + "smallskip", + "medskip", + "bigskip", + "hfill" + ], + environmentsThatDontBreakPars = [] + } = options || {}; + let processedContent = []; + if (unifiedLatexUtilMatch.match.group(ast)) { + processedContent = replaceStreamingCommandInGroup( + ast, + isStreamingCommand, + replacer + ); + } + if (Array.isArray(ast)) { + const nodes = ast; + let scanIndex = nodes.length; + let sliceIndex = scanIndex; + while (scanIndex > 0 && (isStreamingCommand(nodes[scanIndex - 1]) || unifiedLatexUtilMatch.match.whitespace(nodes[scanIndex - 1]))) { + scanIndex--; + if (isStreamingCommand(nodes[scanIndex])) { + sliceIndex = scanIndex; + } + } + if (sliceIndex !== nodes.length) { + nodes.splice(sliceIndex); + } + const macroThatBreaks = unifiedLatexUtilMatch.match.createMacroMatcher(macrosThatBreakPars); + const envThatDoesntBreak = unifiedLatexUtilMatch.match.createEnvironmentMatcher( + environmentsThatDontBreakPars + ); + const isPar = (node) => unifiedLatexUtilMatch.match.parbreak(node) || unifiedLatexUtilMatch.match.macro(node, "par") || macroThatBreaks(node) || unifiedLatexUtilMatch.match.environment(node) && !envThatDoesntBreak(node) || node.type === "displaymath"; + const splitByPar = unifiedLatexUtilSplit.splitOnCondition(nodes, isPar); + splitByPar.separators = splitByPar.separators.map( + (sep) => unifiedLatexUtilMatch.match.macro(sep, "par") ? { type: "parbreak" } : sep + ); + const replacers = []; + let segments = splitByPar.segments.map((segment) => { + if (segment.length === 0) { + return segment; + } + function applyAccumulatedReplacers(nodes2) { + if (replacers.length === 0) { + return nodes2; + } + return wrapSignificantContent( + nodes2, + composeReplacers(replacers) + ); + } + const { foundStreamingCommands } = replaceStreamingCommandInArray( + segment, + isStreamingCommand, + replacer + ); + const ret = applyAccumulatedReplacers(segment); + foundStreamingCommands.forEach((macro) => { + replacers.push((nodes2) => { + const ret2 = replacer(nodes2, macro); + if (!Array.isArray(ret2)) { + return [ret2]; + } + return ret2; + }); + }); + return ret; + }); + if (segments.length > 1) { + segments.forEach((segment, i) => { + if (i === 0) { + unifiedLatexUtilTrim.trimEnd(segment); + } else if (i === segments.length - 1) { + unifiedLatexUtilTrim.trimStart(segment); + } else { + unifiedLatexUtilTrim.trim(segment); + } + }); + } + processedContent = unifiedLatexUtilSplit.unsplitOnMacro({ + segments, + macros: splitByPar.separators + }); + } + return processedContent; +} +function composeReplacers(replacers) { + if (replacers.length === 0) { + throw new Error("Cannot compose zero replacement functions"); + } + return (nodes) => { + let ret = nodes; + for (let i = 0; i < replacers.length; i++) { + const func = replacers[i]; + ret = func(ret); + } + return ret; + }; +} +function replaceNodeDuringVisit(replacement, info) { + const parent = info.parents[0]; + if (!parent) { + throw new Error(`Cannot replace node: parent not found`); + } + const container = parent[info.key]; + if (!Array.isArray(container)) { + throw new Error(`Cannot replace node: containing array not found`); + } + if (info.index == null) { + throw new Error(`Cannot replace node: node index undefined`); + } + if (!Array.isArray(replacement)) { + container[info.index] = replacement; + } else { + container.splice(info.index, 1, ...replacement); + } +} +const unifiedLatexReplaceStreamingCommands = function unifiedLatexReplaceStreamingCommands2(options) { + const { replacers = {} } = options || {}; + const isReplaceable = unifiedLatexUtilMatch.match.createMacroMatcher(replacers); + return (tree) => { + unifiedLatexUtilVisit.visit( + tree, + (group, info) => { + if (info.context.hasMathModeAncestor || !group.content.some(isReplaceable)) { + return; + } + let fixed = replaceStreamingCommand( + group, + isReplaceable, + (content, command) => { + return replacers[command.content](content, command); + } + ); + if (!info.containingArray || info.index == null) { + return; + } + const prevToken = info.containingArray[info.index - 1]; + const nextToken = info.containingArray[info.index + 1]; + if (unifiedLatexUtilMatch.match.whitespaceLike(prevToken) && unifiedLatexUtilMatch.match.whitespaceLike(fixed[0])) { + unifiedLatexUtilTrim.trimStart(fixed); + } + if (unifiedLatexUtilMatch.match.whitespaceLike(nextToken) && unifiedLatexUtilMatch.match.whitespaceLike(fixed[fixed.length - 1])) { + unifiedLatexUtilTrim.trimEnd(fixed); + } + replaceNodeDuringVisit(fixed, info); + }, + { test: unifiedLatexUtilMatch.match.group } + ); + unifiedLatexUtilVisit.visit( + tree, + (nodes, info) => { + if (info.context.hasMathModeAncestor || !nodes.some(isReplaceable)) { + return; + } + const replaced = replaceStreamingCommand( + nodes, + isReplaceable, + (content, command) => { + return replacers[command.content](content, command); + } + ); + if (replaced !== nodes) { + nodes.length = 0; + nodes.push(...replaced); + } + }, + { includeArrays: true, test: Array.isArray } + ); + }; +}; +exports.firstSignificantNode = firstSignificantNode; +exports.firstSignificantNodeIndex = firstSignificantNodeIndex; +exports.lastSignificantNode = lastSignificantNode; +exports.lastSignificantNodeIndex = lastSignificantNodeIndex; +exports.replaceNode = replaceNode; +exports.replaceNodeDuringVisit = replaceNodeDuringVisit; +exports.replaceStreamingCommand = replaceStreamingCommand; +exports.replaceStreamingCommandInGroup = replaceStreamingCommandInGroup; +exports.unifiedLatexReplaceStreamingCommands = unifiedLatexReplaceStreamingCommands; +//# sourceMappingURL=index.cjs.map diff --git a/node_modules/@unified-latex/unified-latex-util-replace/index.cjs.map b/node_modules/@unified-latex/unified-latex-util-replace/index.cjs.map new file mode 100644 index 0000000..b26c12d --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-util-replace/index.cjs.map @@ -0,0 +1 @@ +{"version":3,"file":"index.cjs","sources":["../libs/replace-node.ts","../libs/utils/significant-node.ts","../libs/utils/join-without-excess-whitespace.ts","../libs/utils/wrap-significant-content.ts","../libs/utils/replace-streaming-command-in-array.ts","../libs/replace-streaming-command.ts","../libs/replace-node-during-visit.ts","../libs/unified-latex-streaming-command.ts"],"sourcesContent":["import * as Ast from \"@unified-latex/unified-latex-types\";\nimport { visit, VisitInfo } from \"@unified-latex/unified-latex-util-visit\";\n\n/**\n * Recursively replace nodes in `ast`. The `visitor` function is called on each node. If\n * `visitor` returns a node or an array of nodes, those nodes replace the node passed to `visitor`.\n * If `null` is returned, the node is deleted. If `undefined` is returned, no replacement happens.\n */\nexport function replaceNode(\n ast: Ast.Ast,\n visitor: (\n node: Ast.Node | Ast.Argument,\n info: VisitInfo\n ) =>\n | Ast.Node\n | Ast.Argument\n | (Ast.Node | Ast.Argument)[]\n | null\n | undefined\n | void\n) {\n visit(ast, {\n leave: (node, info) => {\n let replacement = visitor(node, info);\n // Returning `undefined` or the same node means we shouldn't replace that node\n if (typeof replacement === \"undefined\" || replacement === node) {\n return;\n }\n\n if (!info.containingArray || info.index == null) {\n throw new Error(\n \"Trying to replace node, but cannot find containing array\"\n );\n }\n\n if (\n replacement === null ||\n (Array.isArray(replacement) && replacement.length === 0)\n ) {\n // A null return means that we delete the current node\n info.containingArray.splice(info.index, 1);\n return info.index;\n }\n\n if (!Array.isArray(replacement)) {\n replacement = [replacement];\n }\n\n info.containingArray.splice(info.index, 1, ...replacement);\n // We don't want to *reprocess* the nodes we just inserted into the array,\n // lest we get stuck in a recursive loop if the replacement contains the original.\n // Thus we jump to the index after our replacements.\n return info.index + replacement.length;\n },\n });\n}\n","import * as Ast from \"@unified-latex/unified-latex-types\";\nimport { match } from \"@unified-latex/unified-latex-util-match\";\n\n/**\n * Returns the first non-whitespace/non-comment node in `nodes`. If there is no such\n * node, `null` is returned.\n */\nexport function firstSignificantNode(\n nodes: Ast.Node[],\n parbreaksAreInsignificant?: boolean\n): Ast.Node | null {\n const index = firstSignificantNodeIndex(nodes, parbreaksAreInsignificant);\n if (index == null) {\n return null;\n }\n return nodes[index];\n}\n\n/**\n * Returns the last non-whitespace/non-comment node in `nodes`. If there is no such\n * node, `null` is returned.\n */\nexport function lastSignificantNode(\n nodes: Ast.Node[],\n parbreaksAreInsignificant?: boolean\n): Ast.Node | null {\n const index = lastSignificantNodeIndex(nodes, parbreaksAreInsignificant);\n if (index == null) {\n return null;\n }\n return nodes[index];\n}\n\n/**\n * Returns the index of the last non-whitespace/non-comment node in `nodes`. If there is no such\n * node, `null` is returned.\n */\nexport function lastSignificantNodeIndex(\n nodes: Ast.Node[],\n parbreaksAreInsignificant?: boolean\n): number | undefined {\n for (let i = nodes.length - 1; i >= 0; i--) {\n const node = nodes[i];\n if (\n match.whitespace(node) ||\n match.comment(node) ||\n (parbreaksAreInsignificant && match.parbreak(node))\n ) {\n continue;\n }\n return i;\n }\n return undefined;\n}\n\n/**\n * Returns the index of the first non-whitespace/non-comment node in `nodes`. If there is no such\n * node, `null` is returned.\n */\nexport function firstSignificantNodeIndex(\n nodes: Ast.Node[],\n parbreaksAreInsignificant?: boolean\n): number | undefined {\n for (let i = 0; i < nodes.length; i++) {\n const node = nodes[i];\n if (\n match.whitespace(node) ||\n match.comment(node) ||\n (parbreaksAreInsignificant && match.parbreak(node))\n ) {\n continue;\n }\n return i;\n }\n return undefined;\n}\n","import * as Ast from \"@unified-latex/unified-latex-types\";\nimport { match } from \"@unified-latex/unified-latex-util-match\";\nimport { trimStart } from \"@unified-latex/unified-latex-util-trim\";\n\n/**\n * Is the node space-like? I.e., is it whitespace or\n * a comment with leading whitespace?\n */\nfunction isSpaceLike(node: Ast.Node): boolean {\n return (\n match.whitespace(node) ||\n (match.comment(node) && Boolean(node.leadingWhitespace))\n );\n}\n\n/**\n * Similar to `head.push(...tail)` except that whitespace at the start\n * of `tail` and the end of `head` is collapsed.\n */\nexport function joinWithoutExcessWhitespace(\n head: Ast.Node[],\n tail: Ast.Node[]\n): void {\n if (tail.length === 0) {\n return;\n }\n if (head.length === 0) {\n head.push(...tail);\n return;\n }\n const headEnd = head[head.length - 1];\n const tailStart = tail[0];\n // Whitespace we can just trim off from either end\n if (match.whitespace(headEnd) && match.whitespace(tailStart)) {\n head.push(...tail.slice(1));\n return;\n }\n // If there's no whitespace at one of the ends, no need to worry\n // unless `tailStart` is a comment, in which case it should \"eat\"\n // the whitespace\n if (!isSpaceLike(headEnd) || !isSpaceLike(tailStart)) {\n if (match.whitespace(headEnd) && match.comment(tailStart)) {\n const comment: Ast.Comment = {\n type: \"comment\",\n content: tailStart.content,\n sameline: true,\n leadingWhitespace: true,\n };\n tail = tail.slice(1);\n trimStart(tail);\n head.pop();\n head.push(comment, ...tail);\n return;\n }\n head.push(...tail);\n return;\n }\n\n // If we're here, we have a comment with leading whitespace on one side\n // and whitespace/comments on the other.\n if (match.comment(headEnd) && match.comment(tailStart)) {\n if (tailStart.leadingWhitespace || tailStart.sameline) {\n head.push(\n { type: \"comment\", content: tailStart.content },\n ...tail.slice(1)\n );\n return;\n }\n head.push(...tail);\n return;\n }\n\n // Exactly one side is a comment, so we should trim the whitespace and keep the comment,\n // but make sure the comment has leading whitespace!\n let comment = match.comment(headEnd) ? headEnd : tailStart;\n if (!match.comment(comment)) {\n throw new Error(\n `Expected a comment but found ${JSON.stringify(comment)}`\n );\n }\n\n if (!comment.leadingWhitespace || !comment.sameline) {\n comment = {\n type: \"comment\",\n content: comment.content,\n leadingWhitespace: true,\n sameline: true,\n };\n }\n\n head.pop();\n head.push(comment, ...tail.slice(1));\n}\n","import * as Ast from \"@unified-latex/unified-latex-types\";\nimport { match } from \"@unified-latex/unified-latex-util-match\";\n\n/**\n * Wraps `content` in the specified wrapper. This command is roughly equivalent to\n * `wrapper(content)` except that leading and trailing whitespace and comments are extracted\n * from `content` and moved to the front or back of the return array. For example,\n * `[\" \", \"foo\", \"bar\", \"% xxx\"]` -> `[\" \", wrapped([\"foo\", \"bar\"]), \"% xxx\"]`.\n *\n */\nexport function wrapSignificantContent(\n content: Ast.Node[],\n wrapper: (content: Ast.Node[]) => Ast.Node[] | Ast.Node\n): Ast.Node[] {\n let hoistUntil = 0;\n let hoistAfter = content.length;\n for (let i = 0; i < content.length; i++) {\n if (match.whitespace(content[i]) || match.comment(content[i])) {\n hoistUntil = i + 1;\n continue;\n }\n break;\n }\n for (let j = content.length - 1; j >= 0; j--) {\n if (match.whitespace(content[j]) || match.comment(content[j])) {\n hoistAfter = j;\n continue;\n }\n break;\n }\n\n if (hoistUntil === 0 && hoistAfter === content.length) {\n return ensureArray(wrapper(content));\n }\n\n const frontMatter = content.slice(0, hoistUntil);\n const middle = content.slice(hoistUntil, hoistAfter);\n const backMatter = content.slice(hoistAfter, content.length);\n\n return frontMatter.concat(wrapper(middle), backMatter);\n}\n\nfunction ensureArray(x: Ast.Node | Ast.Node[]) {\n if (!Array.isArray(x)) {\n return [x];\n }\n return x;\n}\n","import * as Ast from \"@unified-latex/unified-latex-types\";\nimport { trimEnd, trimStart } from \"@unified-latex/unified-latex-util-trim\";\nimport { joinWithoutExcessWhitespace } from \"./join-without-excess-whitespace\";\nimport { wrapSignificantContent } from \"./wrap-significant-content\";\n\n/**\n * Replace commands identified by `isStreamingCommand` with the return value of `replacer`.\n * E.g., the array `[head, streamingCommand, ...tail]` will become `[head, replacer(tail, streamingCommand)]`.\n * This function does not split based on parbreaks/etc.. It is right-associative and returns\n * the streaming commands that were encountered.\n */\nexport function replaceStreamingCommandInArray(\n nodes: Ast.Node[],\n isStreamingCommand: (node: any) => node is Ast.Macro,\n replacer: (\n content: Ast.Node[],\n streamingCommand: Ast.Macro\n ) => Ast.Node | Ast.Node[]\n): { foundStreamingCommands: Ast.Node[] } {\n // Streaming commands that come at the end don't do anything,\n // so we should remove them\n while (nodes.length > 0 && isStreamingCommand(nodes[nodes.length - 1])) {\n nodes.pop();\n trimEnd(nodes);\n }\n\n const foundStreamingCommands: Ast.Node[] = [];\n\n for (let i = nodes.length - 1; i >= 0; i--) {\n const node = nodes[i];\n if (isStreamingCommand(node)) {\n const wrapper = (content: Ast.Node[]) => replacer(content, node);\n let tail = nodes.slice(i + 1);\n // Streaming commands are followed by whitespace, which becomes unneeded when the commands are replaced.\n trimStart(tail);\n tail = wrapSignificantContent(tail, wrapper);\n foundStreamingCommands.push(node);\n\n // Trim off what we're about to replace!\n nodes.splice(i);\n\n joinWithoutExcessWhitespace(nodes, tail);\n }\n }\n\n return { foundStreamingCommands };\n}\n","import * as Ast from \"@unified-latex/unified-latex-types\";\nimport { match } from \"@unified-latex/unified-latex-util-match\";\nimport {\n splitOnCondition,\n unsplitOnMacro,\n} from \"@unified-latex/unified-latex-util-split\";\nimport {\n trim,\n trimEnd,\n trimStart,\n} from \"@unified-latex/unified-latex-util-trim\";\nimport { firstSignificantNode } from \"./utils/significant-node\";\nimport { replaceStreamingCommandInArray } from \"./utils/replace-streaming-command-in-array\";\nimport { wrapSignificantContent } from \"./utils/wrap-significant-content\";\n\ntype Replacer = (nodes: Ast.Node[]) => Ast.Node[];\n\n/**\n * Process streaming commands in a group. If needed, \"escape\" the group.\n * For example, `{\\bfseries xx}` -> `\\textbf{xx}`, but `{foo \\bfseries xx}` -> `{foo \\textbf{xx}}`.\n */\nexport function replaceStreamingCommandInGroup(\n group: Ast.Group,\n isStreamingCommand: (node: any) => node is Ast.Macro,\n replacer: (\n content: Ast.Node[],\n streamingCommand: Ast.Macro\n ) => Ast.Node | Ast.Node[],\n options?: {\n macrosThatBreakPars?: string[];\n environmentsThatDontBreakPars?: string[];\n }\n): Ast.Node[] {\n const content = group.content;\n // If the group started with a streaming command, we want to pop\n // out of the group. E.g. `{\\bfseries foo}` -> `\\textbf{foo}` and not `{\\textbf{foo}}`\n let popFromGroup = isStreamingCommand(firstSignificantNode(content));\n\n let innerProcessed = replaceStreamingCommand(\n content,\n isStreamingCommand,\n replacer,\n options\n );\n\n // If the group consisted of just streaming commands (for some reason...)\n // it should be eliminated\n if (innerProcessed.length === 0) {\n return [];\n }\n\n if (popFromGroup) {\n return innerProcessed;\n } else {\n return [{ type: \"group\", content: innerProcessed }];\n }\n}\n\n/**\n * Given a group or a node array, look for streaming commands (e.g., `\\bfseries`) and replace them\n * with the specified macro. The \"arguments\" of the streaming command are passed to `replacer` and the return\n * value of `replacer` is inserted into the stream.\n *\n * By default, this command will split at parbreaks (since commands like `\\textbf{...} do not accept parbreaks in their\n * contents) and call `replacer` multiple times, once per paragraph.\n *\n * Commands are also split at environments and at any macros listed in `macrosThatBreakPars`.\n */\nexport function replaceStreamingCommand(\n ast: Ast.Group | Ast.Node[],\n isStreamingCommand: (node: any) => node is Ast.Macro,\n replacer: (\n content: Ast.Node[],\n streamingCommand: Ast.Macro\n ) => Ast.Node | Ast.Node[],\n options?: {\n macrosThatBreakPars?: string[];\n environmentsThatDontBreakPars?: string[];\n }\n): Ast.Node[] {\n if (typeof isStreamingCommand !== \"function\") {\n throw new Error(\n `'isStreamingCommand' must be a function, not '${typeof isStreamingCommand}'`\n );\n }\n\n const {\n macrosThatBreakPars = [\n \"part\",\n \"chapter\",\n \"section\",\n \"subsection\",\n \"subsubsection\",\n \"vspace\",\n \"smallskip\",\n \"medskip\",\n \"bigskip\",\n \"hfill\",\n ],\n environmentsThatDontBreakPars = [],\n } = options || {};\n\n let processedContent: Ast.Node[] = [];\n if (match.group(ast)) {\n processedContent = replaceStreamingCommandInGroup(\n ast,\n isStreamingCommand,\n replacer\n );\n }\n\n if (Array.isArray(ast)) {\n // Streaming commands that come at the end of a sequence of nodes don't do anything.\n // They also will consume whitespace, so we should remove them and the whitespace.\n const nodes = ast;\n let scanIndex = nodes.length;\n let sliceIndex = scanIndex;\n while (\n scanIndex > 0 &&\n (isStreamingCommand(nodes[scanIndex - 1]) ||\n match.whitespace(nodes[scanIndex - 1]))\n ) {\n scanIndex--;\n if (isStreamingCommand(nodes[scanIndex])) {\n sliceIndex = scanIndex;\n }\n }\n if (sliceIndex !== nodes.length) {\n nodes.splice(sliceIndex);\n }\n\n const macroThatBreaks = match.createMacroMatcher(macrosThatBreakPars);\n const envThatDoesntBreak = match.createEnvironmentMatcher(\n environmentsThatDontBreakPars\n );\n // A \"par\" is anything that a streaming command shouldn't wrap and breaks the stream.\n // This includes regular pars, but also environments and special macros like \\section\n const isPar = (node: Ast.Node) =>\n match.parbreak(node) ||\n match.macro(node, \"par\") ||\n macroThatBreaks(node) ||\n (match.environment(node) && !envThatDoesntBreak(node)) ||\n node.type === \"displaymath\";\n\n // We split on both a parbreak and a literal `\\par`. But we will\n // normalize everything to be parbreaks\n const splitByPar = splitOnCondition(nodes, isPar);\n splitByPar.separators = splitByPar.separators.map((sep) =>\n match.macro(sep, \"par\") ? { type: \"parbreak\" } : sep\n );\n\n const replacers: Replacer[] = [];\n let segments = splitByPar.segments.map((segment) => {\n if (segment.length === 0) {\n return segment;\n }\n function applyAccumulatedReplacers(nodes: Ast.Node[]): Ast.Node[] {\n if (replacers.length === 0) {\n return nodes;\n }\n return wrapSignificantContent(\n nodes,\n composeReplacers(replacers)\n );\n }\n\n const { foundStreamingCommands } = replaceStreamingCommandInArray(\n segment,\n isStreamingCommand,\n replacer\n );\n\n // All streaming commands in `segment` have now been replaced. However,\n // there might be commands from the previous paragraphs that should wrap\n // the current segment!\n const ret = applyAccumulatedReplacers(segment);\n\n // Any streaming commands from this segment will carry over to the next,\n // so keep track of them.\n foundStreamingCommands.forEach((macro) => {\n replacers.push((nodes: Ast.Node[]) => {\n const ret = replacer(nodes, macro as Ast.Macro);\n if (!Array.isArray(ret)) {\n return [ret];\n }\n return ret;\n });\n });\n\n return ret;\n });\n\n // Leading/trailing whitespace was hoisted in front/back of each replacer.\n // Since we're separated by parbreaks, we can safely trim all that whitespace.\n if (segments.length > 1) {\n segments.forEach((segment, i) => {\n if (i === 0) {\n trimEnd(segment);\n } else if (i === segments.length - 1) {\n trimStart(segment);\n } else {\n trim(segment);\n }\n });\n }\n\n processedContent = unsplitOnMacro({\n segments: segments,\n macros: splitByPar.separators,\n });\n }\n\n return processedContent;\n}\n\n/**\n * Given a sequence of replacer functions `[f, g, h]` return\n * `h \\circ g \\circ f`\n *\n * @param {((nodes: Ast.Node[]) => Ast.Node)[]} replacers\n * @returns {(nodes: Ast.Node[]) => Ast.Node}\n */\nfunction composeReplacers(replacers: Replacer[]): Replacer {\n if (replacers.length === 0) {\n throw new Error(\"Cannot compose zero replacement functions\");\n }\n return (nodes: Ast.Node[]) => {\n let ret = nodes;\n for (let i = 0; i < replacers.length; i++) {\n const func = replacers[i];\n ret = func(ret);\n }\n return ret;\n };\n}\n","import { VisitInfo } from \"@unified-latex/unified-latex-util-visit\";\nimport * as Ast from \"@unified-latex/unified-latex-types\";\n\n/**\n * Replaces the current node with `replacement`. It is assumed that the current\n * node is in an array that is a child of a parent element. If this is not the case,\n * the function will error.\n */\nexport function replaceNodeDuringVisit(\n replacement: Ast.Node | Ast.Argument | (Ast.Node | Ast.Argument)[],\n info: VisitInfo\n) {\n const parent = info.parents[0];\n if (!parent) {\n throw new Error(`Cannot replace node: parent not found`);\n }\n const container = parent[info.key as keyof typeof parent] as\n | (Ast.Node | Ast.Argument)[]\n | undefined;\n if (!Array.isArray(container)) {\n throw new Error(`Cannot replace node: containing array not found`);\n }\n if (info.index == null) {\n throw new Error(`Cannot replace node: node index undefined`);\n }\n if (!Array.isArray(replacement)) {\n container[info.index] = replacement;\n } else {\n container.splice(info.index, 1, ...replacement);\n }\n}\n","import { Plugin } from \"unified\";\nimport * as Ast from \"@unified-latex/unified-latex-types\";\nimport { match } from \"@unified-latex/unified-latex-util-match\";\nimport { trimEnd, trimStart } from \"@unified-latex/unified-latex-util-trim\";\nimport { visit } from \"@unified-latex/unified-latex-util-visit\";\nimport { replaceStreamingCommand } from \"./replace-streaming-command\";\nimport { replaceNodeDuringVisit } from \"./replace-node-during-visit\";\n\ntype PluginOptions = {\n replacers: Record<\n string,\n (\n content: Ast.Node[],\n streamingCommand: Ast.Macro\n ) => Ast.Node | Ast.Node[]\n >;\n};\n\n/**\n * Unified plugin to replace all found streaming commands with their argument-style equivalents.\n * This only applies to sections of the tree with no math ancestor.\n *\n * @param options.replacer A record of macro names and replacer functions. A replacer function accepts content and the original streaming command and is expected to return the argument-style command. It may be called multiple times per streaming command.\n */\nexport const unifiedLatexReplaceStreamingCommands: Plugin<\n PluginOptions[],\n Ast.Root,\n Ast.Root\n> = function unifiedLatexReplaceStreamingCommands(options) {\n const { replacers = {} } = options || {};\n const isReplaceable = match.createMacroMatcher(replacers);\n return (tree) => {\n // We traverse all groups before we replace nodes in other contexts\n visit(\n tree,\n (group, info) => {\n if (\n info.context.hasMathModeAncestor ||\n !group.content.some(isReplaceable)\n ) {\n return;\n }\n\n let fixed = replaceStreamingCommand(\n group,\n isReplaceable,\n (content, command) => {\n return replacers[command.content](content, command);\n }\n );\n\n // We cannot replace the node unless we can access the containing array.\n if (!info.containingArray || info.index == null) {\n return;\n }\n\n // `fixed` may consist of only whitespace. If this is the case,\n // surrounding whitespace must trimmed before\n // inserting the group's contents.\n const prevToken = info.containingArray[info.index - 1];\n const nextToken = info.containingArray[info.index + 1];\n if (\n match.whitespaceLike(prevToken) &&\n match.whitespaceLike(fixed[0])\n ) {\n trimStart(fixed);\n }\n if (\n match.whitespaceLike(nextToken) &&\n match.whitespaceLike(fixed[fixed.length - 1])\n ) {\n trimEnd(fixed);\n }\n replaceNodeDuringVisit(fixed, info);\n },\n { test: match.group }\n );\n\n visit(\n tree,\n (nodes, info) => {\n if (\n info.context.hasMathModeAncestor ||\n !nodes.some(isReplaceable)\n ) {\n return;\n }\n\n const replaced = replaceStreamingCommand(\n nodes,\n isReplaceable,\n (content, command) => {\n return replacers[command.content](content, command);\n }\n );\n\n // If we get back a different array than we input, the replacement did\n // not happen in-place. In this case we need to manipulate `nodes`.\n if (replaced !== nodes) {\n nodes.length = 0;\n nodes.push(...replaced);\n }\n },\n { includeArrays: true, test: Array.isArray }\n );\n };\n};\n"],"names":["visit","match","comment","trimStart","trimEnd","splitOnCondition","nodes","ret","trim","unsplitOnMacro","unifiedLatexReplaceStreamingCommands"],"mappings":"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"} \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-util-replace/index.d.ts b/node_modules/@unified-latex/unified-latex-util-replace/index.d.ts new file mode 100644 index 0000000..a68c4f3 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-util-replace/index.d.ts @@ -0,0 +1,79 @@ +import * as Ast from '@unified-latex/unified-latex-types'; +import { Plugin as Plugin_2 } from 'unified'; +import { VisitInfo } from '@unified-latex/unified-latex-util-visit'; + +/** + * Returns the first non-whitespace/non-comment node in `nodes`. If there is no such + * node, `null` is returned. + */ +export declare function firstSignificantNode(nodes: Ast.Node[], parbreaksAreInsignificant?: boolean): Ast.Node | null; + +/** + * Returns the index of the first non-whitespace/non-comment node in `nodes`. If there is no such + * node, `null` is returned. + */ +export declare function firstSignificantNodeIndex(nodes: Ast.Node[], parbreaksAreInsignificant?: boolean): number | undefined; + +/** + * Returns the last non-whitespace/non-comment node in `nodes`. If there is no such + * node, `null` is returned. + */ +export declare function lastSignificantNode(nodes: Ast.Node[], parbreaksAreInsignificant?: boolean): Ast.Node | null; + +/** + * Returns the index of the last non-whitespace/non-comment node in `nodes`. If there is no such + * node, `null` is returned. + */ +export declare function lastSignificantNodeIndex(nodes: Ast.Node[], parbreaksAreInsignificant?: boolean): number | undefined; + +declare type PluginOptions = { + replacers: Record Ast.Node | Ast.Node[]>; +}; + +/** + * Recursively replace nodes in `ast`. The `visitor` function is called on each node. If + * `visitor` returns a node or an array of nodes, those nodes replace the node passed to `visitor`. + * If `null` is returned, the node is deleted. If `undefined` is returned, no replacement happens. + */ +export declare function replaceNode(ast: Ast.Ast, visitor: (node: Ast.Node | Ast.Argument, info: VisitInfo) => Ast.Node | Ast.Argument | (Ast.Node | Ast.Argument)[] | null | undefined | void): void; + +/** + * Replaces the current node with `replacement`. It is assumed that the current + * node is in an array that is a child of a parent element. If this is not the case, + * the function will error. + */ +export declare function replaceNodeDuringVisit(replacement: Ast.Node | Ast.Argument | (Ast.Node | Ast.Argument)[], info: VisitInfo): void; + +/** + * Given a group or a node array, look for streaming commands (e.g., `\bfseries`) and replace them + * with the specified macro. The "arguments" of the streaming command are passed to `replacer` and the return + * value of `replacer` is inserted into the stream. + * + * By default, this command will split at parbreaks (since commands like `\textbf{...} do not accept parbreaks in their + * contents) and call `replacer` multiple times, once per paragraph. + * + * Commands are also split at environments and at any macros listed in `macrosThatBreakPars`. + */ +export declare function replaceStreamingCommand(ast: Ast.Group | Ast.Node[], isStreamingCommand: (node: any) => node is Ast.Macro, replacer: (content: Ast.Node[], streamingCommand: Ast.Macro) => Ast.Node | Ast.Node[], options?: { + macrosThatBreakPars?: string[]; + environmentsThatDontBreakPars?: string[]; +}): Ast.Node[]; + +/** + * Process streaming commands in a group. If needed, "escape" the group. + * For example, `{\bfseries xx}` -> `\textbf{xx}`, but `{foo \bfseries xx}` -> `{foo \textbf{xx}}`. + */ +export declare function replaceStreamingCommandInGroup(group: Ast.Group, isStreamingCommand: (node: any) => node is Ast.Macro, replacer: (content: Ast.Node[], streamingCommand: Ast.Macro) => Ast.Node | Ast.Node[], options?: { + macrosThatBreakPars?: string[]; + environmentsThatDontBreakPars?: string[]; +}): Ast.Node[]; + +/** + * Unified plugin to replace all found streaming commands with their argument-style equivalents. + * This only applies to sections of the tree with no math ancestor. + * + * @param options.replacer A record of macro names and replacer functions. A replacer function accepts content and the original streaming command and is expected to return the argument-style command. It may be called multiple times per streaming command. + */ +export declare const unifiedLatexReplaceStreamingCommands: Plugin_2; + +export { } diff --git a/node_modules/@unified-latex/unified-latex-util-replace/index.js b/node_modules/@unified-latex/unified-latex-util-replace/index.js new file mode 100644 index 0000000..f4e3b30 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-util-replace/index.js @@ -0,0 +1,390 @@ +import { visit } from "@unified-latex/unified-latex-util-visit"; +import { match } from "@unified-latex/unified-latex-util-match"; +import { trimStart, trimEnd, trim } from "@unified-latex/unified-latex-util-trim"; +import { splitOnCondition, unsplitOnMacro } from "@unified-latex/unified-latex-util-split"; +function replaceNode(ast, visitor) { + visit(ast, { + leave: (node, info) => { + let replacement = visitor(node, info); + if (typeof replacement === "undefined" || replacement === node) { + return; + } + if (!info.containingArray || info.index == null) { + throw new Error( + "Trying to replace node, but cannot find containing array" + ); + } + if (replacement === null || Array.isArray(replacement) && replacement.length === 0) { + info.containingArray.splice(info.index, 1); + return info.index; + } + if (!Array.isArray(replacement)) { + replacement = [replacement]; + } + info.containingArray.splice(info.index, 1, ...replacement); + return info.index + replacement.length; + } + }); +} +function firstSignificantNode(nodes, parbreaksAreInsignificant) { + const index = firstSignificantNodeIndex(nodes, parbreaksAreInsignificant); + if (index == null) { + return null; + } + return nodes[index]; +} +function lastSignificantNode(nodes, parbreaksAreInsignificant) { + const index = lastSignificantNodeIndex(nodes, parbreaksAreInsignificant); + if (index == null) { + return null; + } + return nodes[index]; +} +function lastSignificantNodeIndex(nodes, parbreaksAreInsignificant) { + for (let i = nodes.length - 1; i >= 0; i--) { + const node = nodes[i]; + if (match.whitespace(node) || match.comment(node) || parbreaksAreInsignificant && match.parbreak(node)) { + continue; + } + return i; + } + return void 0; +} +function firstSignificantNodeIndex(nodes, parbreaksAreInsignificant) { + for (let i = 0; i < nodes.length; i++) { + const node = nodes[i]; + if (match.whitespace(node) || match.comment(node) || parbreaksAreInsignificant && match.parbreak(node)) { + continue; + } + return i; + } + return void 0; +} +function isSpaceLike(node) { + return match.whitespace(node) || match.comment(node) && Boolean(node.leadingWhitespace); +} +function joinWithoutExcessWhitespace(head, tail) { + if (tail.length === 0) { + return; + } + if (head.length === 0) { + head.push(...tail); + return; + } + const headEnd = head[head.length - 1]; + const tailStart = tail[0]; + if (match.whitespace(headEnd) && match.whitespace(tailStart)) { + head.push(...tail.slice(1)); + return; + } + if (!isSpaceLike(headEnd) || !isSpaceLike(tailStart)) { + if (match.whitespace(headEnd) && match.comment(tailStart)) { + const comment2 = { + type: "comment", + content: tailStart.content, + sameline: true, + leadingWhitespace: true + }; + tail = tail.slice(1); + trimStart(tail); + head.pop(); + head.push(comment2, ...tail); + return; + } + head.push(...tail); + return; + } + if (match.comment(headEnd) && match.comment(tailStart)) { + if (tailStart.leadingWhitespace || tailStart.sameline) { + head.push( + { type: "comment", content: tailStart.content }, + ...tail.slice(1) + ); + return; + } + head.push(...tail); + return; + } + let comment = match.comment(headEnd) ? headEnd : tailStart; + if (!match.comment(comment)) { + throw new Error( + `Expected a comment but found ${JSON.stringify(comment)}` + ); + } + if (!comment.leadingWhitespace || !comment.sameline) { + comment = { + type: "comment", + content: comment.content, + leadingWhitespace: true, + sameline: true + }; + } + head.pop(); + head.push(comment, ...tail.slice(1)); +} +function wrapSignificantContent(content, wrapper) { + let hoistUntil = 0; + let hoistAfter = content.length; + for (let i = 0; i < content.length; i++) { + if (match.whitespace(content[i]) || match.comment(content[i])) { + hoistUntil = i + 1; + continue; + } + break; + } + for (let j = content.length - 1; j >= 0; j--) { + if (match.whitespace(content[j]) || match.comment(content[j])) { + hoistAfter = j; + continue; + } + break; + } + if (hoistUntil === 0 && hoistAfter === content.length) { + return ensureArray(wrapper(content)); + } + const frontMatter = content.slice(0, hoistUntil); + const middle = content.slice(hoistUntil, hoistAfter); + const backMatter = content.slice(hoistAfter, content.length); + return frontMatter.concat(wrapper(middle), backMatter); +} +function ensureArray(x) { + if (!Array.isArray(x)) { + return [x]; + } + return x; +} +function replaceStreamingCommandInArray(nodes, isStreamingCommand, replacer) { + while (nodes.length > 0 && isStreamingCommand(nodes[nodes.length - 1])) { + nodes.pop(); + trimEnd(nodes); + } + const foundStreamingCommands = []; + for (let i = nodes.length - 1; i >= 0; i--) { + const node = nodes[i]; + if (isStreamingCommand(node)) { + const wrapper = (content) => replacer(content, node); + let tail = nodes.slice(i + 1); + trimStart(tail); + tail = wrapSignificantContent(tail, wrapper); + foundStreamingCommands.push(node); + nodes.splice(i); + joinWithoutExcessWhitespace(nodes, tail); + } + } + return { foundStreamingCommands }; +} +function replaceStreamingCommandInGroup(group, isStreamingCommand, replacer, options) { + const content = group.content; + let popFromGroup = isStreamingCommand(firstSignificantNode(content)); + let innerProcessed = replaceStreamingCommand( + content, + isStreamingCommand, + replacer, + options + ); + if (innerProcessed.length === 0) { + return []; + } + if (popFromGroup) { + return innerProcessed; + } else { + return [{ type: "group", content: innerProcessed }]; + } +} +function replaceStreamingCommand(ast, isStreamingCommand, replacer, options) { + if (typeof isStreamingCommand !== "function") { + throw new Error( + `'isStreamingCommand' must be a function, not '${typeof isStreamingCommand}'` + ); + } + const { + macrosThatBreakPars = [ + "part", + "chapter", + "section", + "subsection", + "subsubsection", + "vspace", + "smallskip", + "medskip", + "bigskip", + "hfill" + ], + environmentsThatDontBreakPars = [] + } = options || {}; + let processedContent = []; + if (match.group(ast)) { + processedContent = replaceStreamingCommandInGroup( + ast, + isStreamingCommand, + replacer + ); + } + if (Array.isArray(ast)) { + const nodes = ast; + let scanIndex = nodes.length; + let sliceIndex = scanIndex; + while (scanIndex > 0 && (isStreamingCommand(nodes[scanIndex - 1]) || match.whitespace(nodes[scanIndex - 1]))) { + scanIndex--; + if (isStreamingCommand(nodes[scanIndex])) { + sliceIndex = scanIndex; + } + } + if (sliceIndex !== nodes.length) { + nodes.splice(sliceIndex); + } + const macroThatBreaks = match.createMacroMatcher(macrosThatBreakPars); + const envThatDoesntBreak = match.createEnvironmentMatcher( + environmentsThatDontBreakPars + ); + const isPar = (node) => match.parbreak(node) || match.macro(node, "par") || macroThatBreaks(node) || match.environment(node) && !envThatDoesntBreak(node) || node.type === "displaymath"; + const splitByPar = splitOnCondition(nodes, isPar); + splitByPar.separators = splitByPar.separators.map( + (sep) => match.macro(sep, "par") ? { type: "parbreak" } : sep + ); + const replacers = []; + let segments = splitByPar.segments.map((segment) => { + if (segment.length === 0) { + return segment; + } + function applyAccumulatedReplacers(nodes2) { + if (replacers.length === 0) { + return nodes2; + } + return wrapSignificantContent( + nodes2, + composeReplacers(replacers) + ); + } + const { foundStreamingCommands } = replaceStreamingCommandInArray( + segment, + isStreamingCommand, + replacer + ); + const ret = applyAccumulatedReplacers(segment); + foundStreamingCommands.forEach((macro) => { + replacers.push((nodes2) => { + const ret2 = replacer(nodes2, macro); + if (!Array.isArray(ret2)) { + return [ret2]; + } + return ret2; + }); + }); + return ret; + }); + if (segments.length > 1) { + segments.forEach((segment, i) => { + if (i === 0) { + trimEnd(segment); + } else if (i === segments.length - 1) { + trimStart(segment); + } else { + trim(segment); + } + }); + } + processedContent = unsplitOnMacro({ + segments, + macros: splitByPar.separators + }); + } + return processedContent; +} +function composeReplacers(replacers) { + if (replacers.length === 0) { + throw new Error("Cannot compose zero replacement functions"); + } + return (nodes) => { + let ret = nodes; + for (let i = 0; i < replacers.length; i++) { + const func = replacers[i]; + ret = func(ret); + } + return ret; + }; +} +function replaceNodeDuringVisit(replacement, info) { + const parent = info.parents[0]; + if (!parent) { + throw new Error(`Cannot replace node: parent not found`); + } + const container = parent[info.key]; + if (!Array.isArray(container)) { + throw new Error(`Cannot replace node: containing array not found`); + } + if (info.index == null) { + throw new Error(`Cannot replace node: node index undefined`); + } + if (!Array.isArray(replacement)) { + container[info.index] = replacement; + } else { + container.splice(info.index, 1, ...replacement); + } +} +const unifiedLatexReplaceStreamingCommands = function unifiedLatexReplaceStreamingCommands2(options) { + const { replacers = {} } = options || {}; + const isReplaceable = match.createMacroMatcher(replacers); + return (tree) => { + visit( + tree, + (group, info) => { + if (info.context.hasMathModeAncestor || !group.content.some(isReplaceable)) { + return; + } + let fixed = replaceStreamingCommand( + group, + isReplaceable, + (content, command) => { + return replacers[command.content](content, command); + } + ); + if (!info.containingArray || info.index == null) { + return; + } + const prevToken = info.containingArray[info.index - 1]; + const nextToken = info.containingArray[info.index + 1]; + if (match.whitespaceLike(prevToken) && match.whitespaceLike(fixed[0])) { + trimStart(fixed); + } + if (match.whitespaceLike(nextToken) && match.whitespaceLike(fixed[fixed.length - 1])) { + trimEnd(fixed); + } + replaceNodeDuringVisit(fixed, info); + }, + { test: match.group } + ); + visit( + tree, + (nodes, info) => { + if (info.context.hasMathModeAncestor || !nodes.some(isReplaceable)) { + return; + } + const replaced = replaceStreamingCommand( + nodes, + isReplaceable, + (content, command) => { + return replacers[command.content](content, command); + } + ); + if (replaced !== nodes) { + nodes.length = 0; + nodes.push(...replaced); + } + }, + { includeArrays: true, test: Array.isArray } + ); + }; +}; +export { + firstSignificantNode, + firstSignificantNodeIndex, + lastSignificantNode, + lastSignificantNodeIndex, + replaceNode, + replaceNodeDuringVisit, + replaceStreamingCommand, + replaceStreamingCommandInGroup, + unifiedLatexReplaceStreamingCommands +}; +//# sourceMappingURL=index.js.map diff --git a/node_modules/@unified-latex/unified-latex-util-replace/index.js.map b/node_modules/@unified-latex/unified-latex-util-replace/index.js.map new file mode 100644 index 0000000..938a5e0 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-util-replace/index.js.map @@ -0,0 +1 @@ +{"version":3,"file":"index.js","sources":["../libs/replace-node.ts","../libs/utils/significant-node.ts","../libs/utils/join-without-excess-whitespace.ts","../libs/utils/wrap-significant-content.ts","../libs/utils/replace-streaming-command-in-array.ts","../libs/replace-streaming-command.ts","../libs/replace-node-during-visit.ts","../libs/unified-latex-streaming-command.ts"],"sourcesContent":["import * as Ast from \"@unified-latex/unified-latex-types\";\nimport { visit, VisitInfo } from \"@unified-latex/unified-latex-util-visit\";\n\n/**\n * Recursively replace nodes in `ast`. The `visitor` function is called on each node. If\n * `visitor` returns a node or an array of nodes, those nodes replace the node passed to `visitor`.\n * If `null` is returned, the node is deleted. If `undefined` is returned, no replacement happens.\n */\nexport function replaceNode(\n ast: Ast.Ast,\n visitor: (\n node: Ast.Node | Ast.Argument,\n info: VisitInfo\n ) =>\n | Ast.Node\n | Ast.Argument\n | (Ast.Node | Ast.Argument)[]\n | null\n | undefined\n | void\n) {\n visit(ast, {\n leave: (node, info) => {\n let replacement = visitor(node, info);\n // Returning `undefined` or the same node means we shouldn't replace that node\n if (typeof replacement === \"undefined\" || replacement === node) {\n return;\n }\n\n if (!info.containingArray || info.index == null) {\n throw new Error(\n \"Trying to replace node, but cannot find containing array\"\n );\n }\n\n if (\n replacement === null ||\n (Array.isArray(replacement) && replacement.length === 0)\n ) {\n // A null return means that we delete the current node\n info.containingArray.splice(info.index, 1);\n return info.index;\n }\n\n if (!Array.isArray(replacement)) {\n replacement = [replacement];\n }\n\n info.containingArray.splice(info.index, 1, ...replacement);\n // We don't want to *reprocess* the nodes we just inserted into the array,\n // lest we get stuck in a recursive loop if the replacement contains the original.\n // Thus we jump to the index after our replacements.\n return info.index + replacement.length;\n },\n });\n}\n","import * as Ast from \"@unified-latex/unified-latex-types\";\nimport { match } from \"@unified-latex/unified-latex-util-match\";\n\n/**\n * Returns the first non-whitespace/non-comment node in `nodes`. If there is no such\n * node, `null` is returned.\n */\nexport function firstSignificantNode(\n nodes: Ast.Node[],\n parbreaksAreInsignificant?: boolean\n): Ast.Node | null {\n const index = firstSignificantNodeIndex(nodes, parbreaksAreInsignificant);\n if (index == null) {\n return null;\n }\n return nodes[index];\n}\n\n/**\n * Returns the last non-whitespace/non-comment node in `nodes`. If there is no such\n * node, `null` is returned.\n */\nexport function lastSignificantNode(\n nodes: Ast.Node[],\n parbreaksAreInsignificant?: boolean\n): Ast.Node | null {\n const index = lastSignificantNodeIndex(nodes, parbreaksAreInsignificant);\n if (index == null) {\n return null;\n }\n return nodes[index];\n}\n\n/**\n * Returns the index of the last non-whitespace/non-comment node in `nodes`. If there is no such\n * node, `null` is returned.\n */\nexport function lastSignificantNodeIndex(\n nodes: Ast.Node[],\n parbreaksAreInsignificant?: boolean\n): number | undefined {\n for (let i = nodes.length - 1; i >= 0; i--) {\n const node = nodes[i];\n if (\n match.whitespace(node) ||\n match.comment(node) ||\n (parbreaksAreInsignificant && match.parbreak(node))\n ) {\n continue;\n }\n return i;\n }\n return undefined;\n}\n\n/**\n * Returns the index of the first non-whitespace/non-comment node in `nodes`. If there is no such\n * node, `null` is returned.\n */\nexport function firstSignificantNodeIndex(\n nodes: Ast.Node[],\n parbreaksAreInsignificant?: boolean\n): number | undefined {\n for (let i = 0; i < nodes.length; i++) {\n const node = nodes[i];\n if (\n match.whitespace(node) ||\n match.comment(node) ||\n (parbreaksAreInsignificant && match.parbreak(node))\n ) {\n continue;\n }\n return i;\n }\n return undefined;\n}\n","import * as Ast from \"@unified-latex/unified-latex-types\";\nimport { match } from \"@unified-latex/unified-latex-util-match\";\nimport { trimStart } from \"@unified-latex/unified-latex-util-trim\";\n\n/**\n * Is the node space-like? I.e., is it whitespace or\n * a comment with leading whitespace?\n */\nfunction isSpaceLike(node: Ast.Node): boolean {\n return (\n match.whitespace(node) ||\n (match.comment(node) && Boolean(node.leadingWhitespace))\n );\n}\n\n/**\n * Similar to `head.push(...tail)` except that whitespace at the start\n * of `tail` and the end of `head` is collapsed.\n */\nexport function joinWithoutExcessWhitespace(\n head: Ast.Node[],\n tail: Ast.Node[]\n): void {\n if (tail.length === 0) {\n return;\n }\n if (head.length === 0) {\n head.push(...tail);\n return;\n }\n const headEnd = head[head.length - 1];\n const tailStart = tail[0];\n // Whitespace we can just trim off from either end\n if (match.whitespace(headEnd) && match.whitespace(tailStart)) {\n head.push(...tail.slice(1));\n return;\n }\n // If there's no whitespace at one of the ends, no need to worry\n // unless `tailStart` is a comment, in which case it should \"eat\"\n // the whitespace\n if (!isSpaceLike(headEnd) || !isSpaceLike(tailStart)) {\n if (match.whitespace(headEnd) && match.comment(tailStart)) {\n const comment: Ast.Comment = {\n type: \"comment\",\n content: tailStart.content,\n sameline: true,\n leadingWhitespace: true,\n };\n tail = tail.slice(1);\n trimStart(tail);\n head.pop();\n head.push(comment, ...tail);\n return;\n }\n head.push(...tail);\n return;\n }\n\n // If we're here, we have a comment with leading whitespace on one side\n // and whitespace/comments on the other.\n if (match.comment(headEnd) && match.comment(tailStart)) {\n if (tailStart.leadingWhitespace || tailStart.sameline) {\n head.push(\n { type: \"comment\", content: tailStart.content },\n ...tail.slice(1)\n );\n return;\n }\n head.push(...tail);\n return;\n }\n\n // Exactly one side is a comment, so we should trim the whitespace and keep the comment,\n // but make sure the comment has leading whitespace!\n let comment = match.comment(headEnd) ? headEnd : tailStart;\n if (!match.comment(comment)) {\n throw new Error(\n `Expected a comment but found ${JSON.stringify(comment)}`\n );\n }\n\n if (!comment.leadingWhitespace || !comment.sameline) {\n comment = {\n type: \"comment\",\n content: comment.content,\n leadingWhitespace: true,\n sameline: true,\n };\n }\n\n head.pop();\n head.push(comment, ...tail.slice(1));\n}\n","import * as Ast from \"@unified-latex/unified-latex-types\";\nimport { match } from \"@unified-latex/unified-latex-util-match\";\n\n/**\n * Wraps `content` in the specified wrapper. This command is roughly equivalent to\n * `wrapper(content)` except that leading and trailing whitespace and comments are extracted\n * from `content` and moved to the front or back of the return array. For example,\n * `[\" \", \"foo\", \"bar\", \"% xxx\"]` -> `[\" \", wrapped([\"foo\", \"bar\"]), \"% xxx\"]`.\n *\n */\nexport function wrapSignificantContent(\n content: Ast.Node[],\n wrapper: (content: Ast.Node[]) => Ast.Node[] | Ast.Node\n): Ast.Node[] {\n let hoistUntil = 0;\n let hoistAfter = content.length;\n for (let i = 0; i < content.length; i++) {\n if (match.whitespace(content[i]) || match.comment(content[i])) {\n hoistUntil = i + 1;\n continue;\n }\n break;\n }\n for (let j = content.length - 1; j >= 0; j--) {\n if (match.whitespace(content[j]) || match.comment(content[j])) {\n hoistAfter = j;\n continue;\n }\n break;\n }\n\n if (hoistUntil === 0 && hoistAfter === content.length) {\n return ensureArray(wrapper(content));\n }\n\n const frontMatter = content.slice(0, hoistUntil);\n const middle = content.slice(hoistUntil, hoistAfter);\n const backMatter = content.slice(hoistAfter, content.length);\n\n return frontMatter.concat(wrapper(middle), backMatter);\n}\n\nfunction ensureArray(x: Ast.Node | Ast.Node[]) {\n if (!Array.isArray(x)) {\n return [x];\n }\n return x;\n}\n","import * as Ast from \"@unified-latex/unified-latex-types\";\nimport { trimEnd, trimStart } from \"@unified-latex/unified-latex-util-trim\";\nimport { joinWithoutExcessWhitespace } from \"./join-without-excess-whitespace\";\nimport { wrapSignificantContent } from \"./wrap-significant-content\";\n\n/**\n * Replace commands identified by `isStreamingCommand` with the return value of `replacer`.\n * E.g., the array `[head, streamingCommand, ...tail]` will become `[head, replacer(tail, streamingCommand)]`.\n * This function does not split based on parbreaks/etc.. It is right-associative and returns\n * the streaming commands that were encountered.\n */\nexport function replaceStreamingCommandInArray(\n nodes: Ast.Node[],\n isStreamingCommand: (node: any) => node is Ast.Macro,\n replacer: (\n content: Ast.Node[],\n streamingCommand: Ast.Macro\n ) => Ast.Node | Ast.Node[]\n): { foundStreamingCommands: Ast.Node[] } {\n // Streaming commands that come at the end don't do anything,\n // so we should remove them\n while (nodes.length > 0 && isStreamingCommand(nodes[nodes.length - 1])) {\n nodes.pop();\n trimEnd(nodes);\n }\n\n const foundStreamingCommands: Ast.Node[] = [];\n\n for (let i = nodes.length - 1; i >= 0; i--) {\n const node = nodes[i];\n if (isStreamingCommand(node)) {\n const wrapper = (content: Ast.Node[]) => replacer(content, node);\n let tail = nodes.slice(i + 1);\n // Streaming commands are followed by whitespace, which becomes unneeded when the commands are replaced.\n trimStart(tail);\n tail = wrapSignificantContent(tail, wrapper);\n foundStreamingCommands.push(node);\n\n // Trim off what we're about to replace!\n nodes.splice(i);\n\n joinWithoutExcessWhitespace(nodes, tail);\n }\n }\n\n return { foundStreamingCommands };\n}\n","import * as Ast from \"@unified-latex/unified-latex-types\";\nimport { match } from \"@unified-latex/unified-latex-util-match\";\nimport {\n splitOnCondition,\n unsplitOnMacro,\n} from \"@unified-latex/unified-latex-util-split\";\nimport {\n trim,\n trimEnd,\n trimStart,\n} from \"@unified-latex/unified-latex-util-trim\";\nimport { firstSignificantNode } from \"./utils/significant-node\";\nimport { replaceStreamingCommandInArray } from \"./utils/replace-streaming-command-in-array\";\nimport { wrapSignificantContent } from \"./utils/wrap-significant-content\";\n\ntype Replacer = (nodes: Ast.Node[]) => Ast.Node[];\n\n/**\n * Process streaming commands in a group. If needed, \"escape\" the group.\n * For example, `{\\bfseries xx}` -> `\\textbf{xx}`, but `{foo \\bfseries xx}` -> `{foo \\textbf{xx}}`.\n */\nexport function replaceStreamingCommandInGroup(\n group: Ast.Group,\n isStreamingCommand: (node: any) => node is Ast.Macro,\n replacer: (\n content: Ast.Node[],\n streamingCommand: Ast.Macro\n ) => Ast.Node | Ast.Node[],\n options?: {\n macrosThatBreakPars?: string[];\n environmentsThatDontBreakPars?: string[];\n }\n): Ast.Node[] {\n const content = group.content;\n // If the group started with a streaming command, we want to pop\n // out of the group. E.g. `{\\bfseries foo}` -> `\\textbf{foo}` and not `{\\textbf{foo}}`\n let popFromGroup = isStreamingCommand(firstSignificantNode(content));\n\n let innerProcessed = replaceStreamingCommand(\n content,\n isStreamingCommand,\n replacer,\n options\n );\n\n // If the group consisted of just streaming commands (for some reason...)\n // it should be eliminated\n if (innerProcessed.length === 0) {\n return [];\n }\n\n if (popFromGroup) {\n return innerProcessed;\n } else {\n return [{ type: \"group\", content: innerProcessed }];\n }\n}\n\n/**\n * Given a group or a node array, look for streaming commands (e.g., `\\bfseries`) and replace them\n * with the specified macro. The \"arguments\" of the streaming command are passed to `replacer` and the return\n * value of `replacer` is inserted into the stream.\n *\n * By default, this command will split at parbreaks (since commands like `\\textbf{...} do not accept parbreaks in their\n * contents) and call `replacer` multiple times, once per paragraph.\n *\n * Commands are also split at environments and at any macros listed in `macrosThatBreakPars`.\n */\nexport function replaceStreamingCommand(\n ast: Ast.Group | Ast.Node[],\n isStreamingCommand: (node: any) => node is Ast.Macro,\n replacer: (\n content: Ast.Node[],\n streamingCommand: Ast.Macro\n ) => Ast.Node | Ast.Node[],\n options?: {\n macrosThatBreakPars?: string[];\n environmentsThatDontBreakPars?: string[];\n }\n): Ast.Node[] {\n if (typeof isStreamingCommand !== \"function\") {\n throw new Error(\n `'isStreamingCommand' must be a function, not '${typeof isStreamingCommand}'`\n );\n }\n\n const {\n macrosThatBreakPars = [\n \"part\",\n \"chapter\",\n \"section\",\n \"subsection\",\n \"subsubsection\",\n \"vspace\",\n \"smallskip\",\n \"medskip\",\n \"bigskip\",\n \"hfill\",\n ],\n environmentsThatDontBreakPars = [],\n } = options || {};\n\n let processedContent: Ast.Node[] = [];\n if (match.group(ast)) {\n processedContent = replaceStreamingCommandInGroup(\n ast,\n isStreamingCommand,\n replacer\n );\n }\n\n if (Array.isArray(ast)) {\n // Streaming commands that come at the end of a sequence of nodes don't do anything.\n // They also will consume whitespace, so we should remove them and the whitespace.\n const nodes = ast;\n let scanIndex = nodes.length;\n let sliceIndex = scanIndex;\n while (\n scanIndex > 0 &&\n (isStreamingCommand(nodes[scanIndex - 1]) ||\n match.whitespace(nodes[scanIndex - 1]))\n ) {\n scanIndex--;\n if (isStreamingCommand(nodes[scanIndex])) {\n sliceIndex = scanIndex;\n }\n }\n if (sliceIndex !== nodes.length) {\n nodes.splice(sliceIndex);\n }\n\n const macroThatBreaks = match.createMacroMatcher(macrosThatBreakPars);\n const envThatDoesntBreak = match.createEnvironmentMatcher(\n environmentsThatDontBreakPars\n );\n // A \"par\" is anything that a streaming command shouldn't wrap and breaks the stream.\n // This includes regular pars, but also environments and special macros like \\section\n const isPar = (node: Ast.Node) =>\n match.parbreak(node) ||\n match.macro(node, \"par\") ||\n macroThatBreaks(node) ||\n (match.environment(node) && !envThatDoesntBreak(node)) ||\n node.type === \"displaymath\";\n\n // We split on both a parbreak and a literal `\\par`. But we will\n // normalize everything to be parbreaks\n const splitByPar = splitOnCondition(nodes, isPar);\n splitByPar.separators = splitByPar.separators.map((sep) =>\n match.macro(sep, \"par\") ? { type: \"parbreak\" } : sep\n );\n\n const replacers: Replacer[] = [];\n let segments = splitByPar.segments.map((segment) => {\n if (segment.length === 0) {\n return segment;\n }\n function applyAccumulatedReplacers(nodes: Ast.Node[]): Ast.Node[] {\n if (replacers.length === 0) {\n return nodes;\n }\n return wrapSignificantContent(\n nodes,\n composeReplacers(replacers)\n );\n }\n\n const { foundStreamingCommands } = replaceStreamingCommandInArray(\n segment,\n isStreamingCommand,\n replacer\n );\n\n // All streaming commands in `segment` have now been replaced. However,\n // there might be commands from the previous paragraphs that should wrap\n // the current segment!\n const ret = applyAccumulatedReplacers(segment);\n\n // Any streaming commands from this segment will carry over to the next,\n // so keep track of them.\n foundStreamingCommands.forEach((macro) => {\n replacers.push((nodes: Ast.Node[]) => {\n const ret = replacer(nodes, macro as Ast.Macro);\n if (!Array.isArray(ret)) {\n return [ret];\n }\n return ret;\n });\n });\n\n return ret;\n });\n\n // Leading/trailing whitespace was hoisted in front/back of each replacer.\n // Since we're separated by parbreaks, we can safely trim all that whitespace.\n if (segments.length > 1) {\n segments.forEach((segment, i) => {\n if (i === 0) {\n trimEnd(segment);\n } else if (i === segments.length - 1) {\n trimStart(segment);\n } else {\n trim(segment);\n }\n });\n }\n\n processedContent = unsplitOnMacro({\n segments: segments,\n macros: splitByPar.separators,\n });\n }\n\n return processedContent;\n}\n\n/**\n * Given a sequence of replacer functions `[f, g, h]` return\n * `h \\circ g \\circ f`\n *\n * @param {((nodes: Ast.Node[]) => Ast.Node)[]} replacers\n * @returns {(nodes: Ast.Node[]) => Ast.Node}\n */\nfunction composeReplacers(replacers: Replacer[]): Replacer {\n if (replacers.length === 0) {\n throw new Error(\"Cannot compose zero replacement functions\");\n }\n return (nodes: Ast.Node[]) => {\n let ret = nodes;\n for (let i = 0; i < replacers.length; i++) {\n const func = replacers[i];\n ret = func(ret);\n }\n return ret;\n };\n}\n","import { VisitInfo } from \"@unified-latex/unified-latex-util-visit\";\nimport * as Ast from \"@unified-latex/unified-latex-types\";\n\n/**\n * Replaces the current node with `replacement`. It is assumed that the current\n * node is in an array that is a child of a parent element. If this is not the case,\n * the function will error.\n */\nexport function replaceNodeDuringVisit(\n replacement: Ast.Node | Ast.Argument | (Ast.Node | Ast.Argument)[],\n info: VisitInfo\n) {\n const parent = info.parents[0];\n if (!parent) {\n throw new Error(`Cannot replace node: parent not found`);\n }\n const container = parent[info.key as keyof typeof parent] as\n | (Ast.Node | Ast.Argument)[]\n | undefined;\n if (!Array.isArray(container)) {\n throw new Error(`Cannot replace node: containing array not found`);\n }\n if (info.index == null) {\n throw new Error(`Cannot replace node: node index undefined`);\n }\n if (!Array.isArray(replacement)) {\n container[info.index] = replacement;\n } else {\n container.splice(info.index, 1, ...replacement);\n }\n}\n","import { Plugin } from \"unified\";\nimport * as Ast from \"@unified-latex/unified-latex-types\";\nimport { match } from \"@unified-latex/unified-latex-util-match\";\nimport { trimEnd, trimStart } from \"@unified-latex/unified-latex-util-trim\";\nimport { visit } from \"@unified-latex/unified-latex-util-visit\";\nimport { replaceStreamingCommand } from \"./replace-streaming-command\";\nimport { replaceNodeDuringVisit } from \"./replace-node-during-visit\";\n\ntype PluginOptions = {\n replacers: Record<\n string,\n (\n content: Ast.Node[],\n streamingCommand: Ast.Macro\n ) => Ast.Node | Ast.Node[]\n >;\n};\n\n/**\n * Unified plugin to replace all found streaming commands with their argument-style equivalents.\n * This only applies to sections of the tree with no math ancestor.\n *\n * @param options.replacer A record of macro names and replacer functions. A replacer function accepts content and the original streaming command and is expected to return the argument-style command. It may be called multiple times per streaming command.\n */\nexport const unifiedLatexReplaceStreamingCommands: Plugin<\n PluginOptions[],\n Ast.Root,\n Ast.Root\n> = function unifiedLatexReplaceStreamingCommands(options) {\n const { replacers = {} } = options || {};\n const isReplaceable = match.createMacroMatcher(replacers);\n return (tree) => {\n // We traverse all groups before we replace nodes in other contexts\n visit(\n tree,\n (group, info) => {\n if (\n info.context.hasMathModeAncestor ||\n !group.content.some(isReplaceable)\n ) {\n return;\n }\n\n let fixed = replaceStreamingCommand(\n group,\n isReplaceable,\n (content, command) => {\n return replacers[command.content](content, command);\n }\n );\n\n // We cannot replace the node unless we can access the containing array.\n if (!info.containingArray || info.index == null) {\n return;\n }\n\n // `fixed` may consist of only whitespace. If this is the case,\n // surrounding whitespace must trimmed before\n // inserting the group's contents.\n const prevToken = info.containingArray[info.index - 1];\n const nextToken = info.containingArray[info.index + 1];\n if (\n match.whitespaceLike(prevToken) &&\n match.whitespaceLike(fixed[0])\n ) {\n trimStart(fixed);\n }\n if (\n match.whitespaceLike(nextToken) &&\n match.whitespaceLike(fixed[fixed.length - 1])\n ) {\n trimEnd(fixed);\n }\n replaceNodeDuringVisit(fixed, info);\n },\n { test: match.group }\n );\n\n visit(\n tree,\n (nodes, info) => {\n if (\n info.context.hasMathModeAncestor ||\n !nodes.some(isReplaceable)\n ) {\n return;\n }\n\n const replaced = replaceStreamingCommand(\n nodes,\n isReplaceable,\n (content, command) => {\n return replacers[command.content](content, command);\n }\n );\n\n // If we get back a different array than we input, the replacement did\n // not happen in-place. In this case we need to manipulate `nodes`.\n if (replaced !== nodes) {\n nodes.length = 0;\n nodes.push(...replaced);\n }\n },\n { includeArrays: true, test: Array.isArray }\n );\n };\n};\n"],"names":["comment","nodes","ret","unifiedLatexReplaceStreamingCommands"],"mappings":"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"} \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-util-replace/package.json b/node_modules/@unified-latex/unified-latex-util-replace/package.json new file mode 100644 index 0000000..9b4963e --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-util-replace/package.json @@ -0,0 +1,56 @@ +{ + "name": "@unified-latex/unified-latex-util-replace", + "version": "1.8.2", + "description": "Functions for modifying a unified-latex AST", + "main": "index.js", + "type": "module", + "dependencies": { + "@unified-latex/unified-latex-types": "^1.8.0", + "@unified-latex/unified-latex-util-match": "^1.8.0", + "@unified-latex/unified-latex-util-split": "^1.8.0", + "@unified-latex/unified-latex-util-trim": "^1.8.2", + "@unified-latex/unified-latex-util-visit": "^1.8.2", + "unified": "^10.1.2" + }, + "repository": { + "type": "git", + "url": "git+https://github.com/siefkenj/unified-latex.git" + }, + "keywords": [ + "pegjs", + "latex", + "parser", + "prettier", + "unified-latex", + "unified" + ], + "author": "Jason Siefken", + "license": "MIT", + "bugs": { + "url": "https://github.com/siefkenj/unified-latex/issues" + }, + "homepage": "https://github.com/siefkenj/unified-latex#readme", + "exports": { + ".": { + "import": "./index.js", + "require": "./index.cjs", + "types": "./index.d.ts" + }, + "./*js": "./*js", + "./*": { + "import": "./*/index.js", + "require": "./*/index.cjs", + "types": "./*/index.d.ts" + }, + "./*/index": { + "import": "./*/index.js", + "require": "./*/index.cjs" + } + }, + "files": [ + "**/*ts", + "**/*js", + "**/*.map", + "**/*.json" + ] +} \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-util-scan/README.md b/node_modules/@unified-latex/unified-latex-util-scan/README.md new file mode 100644 index 0000000..6d5f18e --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-util-scan/README.md @@ -0,0 +1,67 @@ + + + + +# unified-latex-util-scan + +## What is this? + +Functions to analyze `unified-latex` Abstract Syntax Tree (AST). + +## When should I use this? + +If you want to look for particular AST nodes in an array; useful when making plugins. + +## Install + +```bash +npm install @unified-latex/unified-latex-util-scan +``` + +This package contains both esm and commonjs exports. To explicitly access the esm export, +import the `.js` file. To explicitly access the commonjs export, import the `.cjs` file. + +# Functions + +## `prefixMatch(nodes, prefixes, options)` + +Efficiently search for a large number of strings using a prefix-tree. +The longest match is returned. + +```typescript +function prefixMatch(nodes: Ast.Node[], prefixes: string | string[] | { dump(spacer?: number): string; tree(): any; addWord(word: string): ReturnType; removeWord(word: string): ReturnType; ... 7 more ...; getSubAnagrams(word: string): string[]; }, options: { startIndex?: number; matchSubstrings?: boolean; assumeOneCharStrings?: boolean; }): { match: string; endNodeIndex: number; endNodePartialMatch: string | null; } +``` + +**Parameters** + +| Param | Type | +| :------- | :-------------------------------- | +| nodes | `Ast.Node[]` | +| prefixes | Omitted | +| options | Omitted | + +## `scan(nodes, token, options)` + +Scan `nodes` looking for the first occurrence of `token`. +If `options.onlySkipWhitespaceAndComments==true`, then the scan +will only skip whitespace/comment nodes. + +```typescript +function scan( + nodes: (Ast.Node | Ast.Argument)[], + token: string | Ast.Node | Ast.Argument, + options: { + startIndex?: number; + onlySkipWhitespaceAndComments?: boolean; + allowSubstringMatches?: boolean; + } +): number; +``` + +**Parameters** + +| Param | Type | +| :------ | :-------------------------------- | +| nodes | `(Ast.Node \| Ast.Argument)[]` | +| token | Omitted | +| options | Omitted | diff --git a/node_modules/@unified-latex/unified-latex-util-scan/index.cjs b/node_modules/@unified-latex/unified-latex-util-scan/index.cjs new file mode 100644 index 0000000..6b49907 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-util-scan/index.cjs @@ -0,0 +1,123 @@ +"use strict"; +Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" }); +const unifiedLatexUtilMatch = require("@unified-latex/unified-latex-util-match"); +const unifiedLatexUtilPrintRaw = require("@unified-latex/unified-latex-util-print-raw"); +const Trie = require("trie-prefix-tree"); +function scan(nodes, token, options) { + const { startIndex, onlySkipWhitespaceAndComments, allowSubstringMatches } = options || {}; + if (typeof token === "string") { + token = { type: "string", content: token }; + } + for (let i = startIndex || 0; i < nodes.length; i++) { + const node = nodes[i]; + if (node.type === token.type) { + switch (node.type) { + case "comment": + case "displaymath": + case "inlinemath": + case "root": + case "parbreak": + case "whitespace": + case "verb": + case "verbatim": + case "group": + return i; + case "macro": + if (node.content === token.content) { + return i; + } + break; + case "environment": + case "mathenv": + if (unifiedLatexUtilPrintRaw.printRaw(node.env) === unifiedLatexUtilPrintRaw.printRaw(token.env)) { + return i; + } + break; + case "string": + if (node.content === token.content) { + return i; + } + if (allowSubstringMatches && node.content.indexOf(token.content) >= 0) { + return i; + } + break; + } + } + if (onlySkipWhitespaceAndComments && !unifiedLatexUtilMatch.match.whitespace(node) && !unifiedLatexUtilMatch.match.comment(node)) { + return null; + } + } + return null; +} +function prefixMatch(nodes, prefixes, options) { + const { + startIndex = 0, + matchSubstrings = false, + assumeOneCharStrings = false + } = options || {}; + if (typeof prefixes === "string") { + prefixes = [prefixes]; + } + if (Array.isArray(prefixes)) { + prefixes = Trie(prefixes); + } + const prefixTree = prefixes; + const history = { + lastPrefix: "", + lastWord: "", + index: startIndex, + partialMatch: "" + }; + function tryToMatchNextChar(char, index) { + let ret = false; + if (prefixTree.isPrefix(history.lastPrefix + char)) { + history.lastPrefix += char; + history.index = index; + ret = true; + } + if (prefixTree.hasWord(history.lastPrefix)) { + history.lastWord = history.lastPrefix; + } + return ret; + } + for (let i = 0; startIndex + i < nodes.length; i++) { + const node = nodes[startIndex + i]; + if (!unifiedLatexUtilMatch.match.string(node)) { + break; + } + if (assumeOneCharStrings && node.content.length !== 1) { + break; + } + if (matchSubstrings) { + let fullMatch = true; + history.partialMatch = ""; + for (let j = 0; j < node.content.length; j++) { + const char = node.content[j]; + if (tryToMatchNextChar(char, startIndex + i)) { + history.partialMatch += char; + } else { + fullMatch = false; + break; + } + } + if (fullMatch) { + history.partialMatch = ""; + } else { + break; + } + } else { + if (!tryToMatchNextChar(node.content, startIndex + i)) { + break; + } + } + } + return history.lastWord ? { + match: history.lastWord, + endNodeIndex: history.index, + endNodePartialMatch: history.partialMatch ? history.partialMatch : null + } : null; +} +exports.Trie = Trie; +exports.prefixMatch = prefixMatch; +exports.scan = scan; +//# sourceMappingURL=index.cjs.map diff --git a/node_modules/@unified-latex/unified-latex-util-scan/index.cjs.map b/node_modules/@unified-latex/unified-latex-util-scan/index.cjs.map new file mode 100644 index 0000000..d6e37e2 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-util-scan/index.cjs.map @@ -0,0 +1 @@ +{"version":3,"file":"index.cjs","sources":["../libs/scan.ts","../libs/prefix-match.ts"],"sourcesContent":["import * as Ast from \"@unified-latex/unified-latex-types\";\nimport { match } from \"@unified-latex/unified-latex-util-match\";\nimport { printRaw } from \"@unified-latex/unified-latex-util-print-raw\";\n\n/**\n * Scan `nodes` looking for the first occurrence of `token`.\n * If `options.onlySkipWhitespaceAndComments==true`, then the scan\n * will only skip whitespace/comment nodes.\n */\nexport function scan(\n nodes: (Ast.Node | Ast.Argument)[],\n token: string | Ast.Node | Ast.Argument,\n options?: {\n /**\n * Index to start scanning.\n */\n startIndex?: number;\n /**\n * If `true`, whitespace and comments will be skilled but any other\n * node that doesn't match `token` will cause the scan to terminate.\n */\n onlySkipWhitespaceAndComments?: boolean;\n /**\n * If `true`, will look inside `Ast.String` nodes to see if the string contents\n * contain `token`.\n */\n allowSubstringMatches?: boolean;\n }\n): number | null {\n const { startIndex, onlySkipWhitespaceAndComments, allowSubstringMatches } =\n options || {};\n if (typeof token === \"string\") {\n token = { type: \"string\", content: token } as Ast.String;\n }\n\n for (let i = startIndex || 0; i < nodes.length; i++) {\n const node = nodes[i];\n if (node.type === token.type) {\n switch (node.type) {\n case \"comment\":\n case \"displaymath\":\n case \"inlinemath\":\n case \"root\":\n case \"parbreak\":\n case \"whitespace\":\n case \"verb\":\n case \"verbatim\":\n case \"group\":\n return i;\n case \"macro\":\n if (node.content === (token as Ast.Macro).content) {\n return i;\n }\n break;\n case \"environment\":\n case \"mathenv\":\n if (\n printRaw(node.env) ===\n printRaw((token as Ast.Environment).env)\n ) {\n return i;\n }\n break;\n case \"string\":\n if (node.content === (token as Ast.String).content) {\n return i;\n }\n if (\n allowSubstringMatches &&\n node.content.indexOf((token as Ast.String).content) >= 0\n ) {\n return i;\n }\n break;\n }\n }\n if (\n onlySkipWhitespaceAndComments &&\n !match.whitespace(node) &&\n !match.comment(node)\n ) {\n return null;\n }\n }\n\n return null;\n}\n","import Trie from \"trie-prefix-tree\";\nimport * as Ast from \"@unified-latex/unified-latex-types\";\nimport { match } from \"@unified-latex/unified-latex-util-match\";\n\nexport { Trie };\n\n/**\n * Efficiently search for a large number of strings using a prefix-tree.\n * The longest match is returned.\n *\n * @param options.startIndex the index to start scanning at. Defaults to 0.\n * @param options.matchSubstrings whether to allow matching only part of a substring.\n * @param options.assumeOneCharStrings assume that all strings are one character long (for example, like they are in math mode)\n */\nexport function prefixMatch(\n nodes: Ast.Node[],\n prefixes: string | string[] | ReturnType,\n options?: {\n startIndex?: number;\n matchSubstrings?: boolean;\n assumeOneCharStrings?: boolean;\n }\n): {\n match: string;\n endNodeIndex: number;\n endNodePartialMatch: string | null;\n} | null {\n const {\n startIndex = 0,\n matchSubstrings = false,\n assumeOneCharStrings = false,\n } = options || {};\n\n if (typeof prefixes === \"string\") {\n prefixes = [prefixes];\n }\n if (Array.isArray(prefixes)) {\n prefixes = Trie(prefixes);\n }\n const prefixTree = prefixes;\n\n const history = {\n lastPrefix: \"\",\n lastWord: \"\",\n index: startIndex,\n partialMatch: \"\",\n };\n\n /**\n * Try to match the next character. If it matches,\n * record it properly in the `history` object.\n */\n function tryToMatchNextChar(char: string, index: number): boolean {\n let ret = false;\n if (prefixTree.isPrefix(history.lastPrefix + char)) {\n history.lastPrefix += char;\n history.index = index;\n ret = true;\n }\n if (prefixTree.hasWord(history.lastPrefix)) {\n history.lastWord = history.lastPrefix;\n }\n return ret;\n }\n\n // Loop through the nodes looking for the longest prefix match\n for (let i = 0; startIndex + i < nodes.length; i++) {\n const node = nodes[startIndex + i];\n if (!match.string(node)) {\n break;\n }\n if (assumeOneCharStrings && node.content.length !== 1) {\n break;\n }\n if (matchSubstrings) {\n // We need to test letter-by-letter for substring matches\n let fullMatch = true;\n history.partialMatch = \"\";\n for (let j = 0; j < node.content.length; j++) {\n const char = node.content[j];\n if (tryToMatchNextChar(char, startIndex + i)) {\n history.partialMatch += char;\n } else {\n fullMatch = false;\n break;\n }\n }\n if (fullMatch) {\n history.partialMatch = \"\";\n } else {\n break;\n }\n } else {\n if (!tryToMatchNextChar(node.content, startIndex + i)) {\n break;\n }\n }\n }\n\n return history.lastWord\n ? {\n match: history.lastWord,\n endNodeIndex: history.index,\n endNodePartialMatch: history.partialMatch\n ? history.partialMatch\n : null,\n }\n : null;\n}\n"],"names":["printRaw","match"],"mappings":"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"} \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-util-scan/index.d.ts b/node_modules/@unified-latex/unified-latex-util-scan/index.d.ts new file mode 100644 index 0000000..6298247 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-util-scan/index.d.ts @@ -0,0 +1,46 @@ +import * as Ast from '@unified-latex/unified-latex-types'; +import { default as Trie } from 'trie-prefix-tree'; + +/** + * Efficiently search for a large number of strings using a prefix-tree. + * The longest match is returned. + * + * @param options.startIndex the index to start scanning at. Defaults to 0. + * @param options.matchSubstrings whether to allow matching only part of a substring. + * @param options.assumeOneCharStrings assume that all strings are one character long (for example, like they are in math mode) + */ +export declare function prefixMatch(nodes: Ast.Node[], prefixes: string | string[] | ReturnType, options?: { + startIndex?: number; + matchSubstrings?: boolean; + assumeOneCharStrings?: boolean; +}): { + match: string; + endNodeIndex: number; + endNodePartialMatch: string | null; +} | null; + +/** + * Scan `nodes` looking for the first occurrence of `token`. + * If `options.onlySkipWhitespaceAndComments==true`, then the scan + * will only skip whitespace/comment nodes. + */ +export declare function scan(nodes: (Ast.Node | Ast.Argument)[], token: string | Ast.Node | Ast.Argument, options?: { + /** + * Index to start scanning. + */ + startIndex?: number; + /** + * If `true`, whitespace and comments will be skilled but any other + * node that doesn't match `token` will cause the scan to terminate. + */ + onlySkipWhitespaceAndComments?: boolean; + /** + * If `true`, will look inside `Ast.String` nodes to see if the string contents + * contain `token`. + */ + allowSubstringMatches?: boolean; +}): number | null; + +export { Trie } + +export { } diff --git a/node_modules/@unified-latex/unified-latex-util-scan/index.js b/node_modules/@unified-latex/unified-latex-util-scan/index.js new file mode 100644 index 0000000..381ed5a --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-util-scan/index.js @@ -0,0 +1,124 @@ +import { match } from "@unified-latex/unified-latex-util-match"; +import { printRaw } from "@unified-latex/unified-latex-util-print-raw"; +import Trie from "trie-prefix-tree"; +import { default as default2 } from "trie-prefix-tree"; +function scan(nodes, token, options) { + const { startIndex, onlySkipWhitespaceAndComments, allowSubstringMatches } = options || {}; + if (typeof token === "string") { + token = { type: "string", content: token }; + } + for (let i = startIndex || 0; i < nodes.length; i++) { + const node = nodes[i]; + if (node.type === token.type) { + switch (node.type) { + case "comment": + case "displaymath": + case "inlinemath": + case "root": + case "parbreak": + case "whitespace": + case "verb": + case "verbatim": + case "group": + return i; + case "macro": + if (node.content === token.content) { + return i; + } + break; + case "environment": + case "mathenv": + if (printRaw(node.env) === printRaw(token.env)) { + return i; + } + break; + case "string": + if (node.content === token.content) { + return i; + } + if (allowSubstringMatches && node.content.indexOf(token.content) >= 0) { + return i; + } + break; + } + } + if (onlySkipWhitespaceAndComments && !match.whitespace(node) && !match.comment(node)) { + return null; + } + } + return null; +} +function prefixMatch(nodes, prefixes, options) { + const { + startIndex = 0, + matchSubstrings = false, + assumeOneCharStrings = false + } = options || {}; + if (typeof prefixes === "string") { + prefixes = [prefixes]; + } + if (Array.isArray(prefixes)) { + prefixes = Trie(prefixes); + } + const prefixTree = prefixes; + const history = { + lastPrefix: "", + lastWord: "", + index: startIndex, + partialMatch: "" + }; + function tryToMatchNextChar(char, index) { + let ret = false; + if (prefixTree.isPrefix(history.lastPrefix + char)) { + history.lastPrefix += char; + history.index = index; + ret = true; + } + if (prefixTree.hasWord(history.lastPrefix)) { + history.lastWord = history.lastPrefix; + } + return ret; + } + for (let i = 0; startIndex + i < nodes.length; i++) { + const node = nodes[startIndex + i]; + if (!match.string(node)) { + break; + } + if (assumeOneCharStrings && node.content.length !== 1) { + break; + } + if (matchSubstrings) { + let fullMatch = true; + history.partialMatch = ""; + for (let j = 0; j < node.content.length; j++) { + const char = node.content[j]; + if (tryToMatchNextChar(char, startIndex + i)) { + history.partialMatch += char; + } else { + fullMatch = false; + break; + } + } + if (fullMatch) { + history.partialMatch = ""; + } else { + break; + } + } else { + if (!tryToMatchNextChar(node.content, startIndex + i)) { + break; + } + } + } + return history.lastWord ? { + match: history.lastWord, + endNodeIndex: history.index, + endNodePartialMatch: history.partialMatch ? history.partialMatch : null + } : null; +} +export { + default2 as Trie, + prefixMatch, + scan +}; +//# sourceMappingURL=index.js.map diff --git a/node_modules/@unified-latex/unified-latex-util-scan/index.js.map b/node_modules/@unified-latex/unified-latex-util-scan/index.js.map new file mode 100644 index 0000000..93b2d32 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-util-scan/index.js.map @@ -0,0 +1 @@ +{"version":3,"file":"index.js","sources":["../libs/scan.ts","../libs/prefix-match.ts"],"sourcesContent":["import * as Ast from \"@unified-latex/unified-latex-types\";\nimport { match } from \"@unified-latex/unified-latex-util-match\";\nimport { printRaw } from \"@unified-latex/unified-latex-util-print-raw\";\n\n/**\n * Scan `nodes` looking for the first occurrence of `token`.\n * If `options.onlySkipWhitespaceAndComments==true`, then the scan\n * will only skip whitespace/comment nodes.\n */\nexport function scan(\n nodes: (Ast.Node | Ast.Argument)[],\n token: string | Ast.Node | Ast.Argument,\n options?: {\n /**\n * Index to start scanning.\n */\n startIndex?: number;\n /**\n * If `true`, whitespace and comments will be skilled but any other\n * node that doesn't match `token` will cause the scan to terminate.\n */\n onlySkipWhitespaceAndComments?: boolean;\n /**\n * If `true`, will look inside `Ast.String` nodes to see if the string contents\n * contain `token`.\n */\n allowSubstringMatches?: boolean;\n }\n): number | null {\n const { startIndex, onlySkipWhitespaceAndComments, allowSubstringMatches } =\n options || {};\n if (typeof token === \"string\") {\n token = { type: \"string\", content: token } as Ast.String;\n }\n\n for (let i = startIndex || 0; i < nodes.length; i++) {\n const node = nodes[i];\n if (node.type === token.type) {\n switch (node.type) {\n case \"comment\":\n case \"displaymath\":\n case \"inlinemath\":\n case \"root\":\n case \"parbreak\":\n case \"whitespace\":\n case \"verb\":\n case \"verbatim\":\n case \"group\":\n return i;\n case \"macro\":\n if (node.content === (token as Ast.Macro).content) {\n return i;\n }\n break;\n case \"environment\":\n case \"mathenv\":\n if (\n printRaw(node.env) ===\n printRaw((token as Ast.Environment).env)\n ) {\n return i;\n }\n break;\n case \"string\":\n if (node.content === (token as Ast.String).content) {\n return i;\n }\n if (\n allowSubstringMatches &&\n node.content.indexOf((token as Ast.String).content) >= 0\n ) {\n return i;\n }\n break;\n }\n }\n if (\n onlySkipWhitespaceAndComments &&\n !match.whitespace(node) &&\n !match.comment(node)\n ) {\n return null;\n }\n }\n\n return null;\n}\n","import Trie from \"trie-prefix-tree\";\nimport * as Ast from \"@unified-latex/unified-latex-types\";\nimport { match } from \"@unified-latex/unified-latex-util-match\";\n\nexport { Trie };\n\n/**\n * Efficiently search for a large number of strings using a prefix-tree.\n * The longest match is returned.\n *\n * @param options.startIndex the index to start scanning at. Defaults to 0.\n * @param options.matchSubstrings whether to allow matching only part of a substring.\n * @param options.assumeOneCharStrings assume that all strings are one character long (for example, like they are in math mode)\n */\nexport function prefixMatch(\n nodes: Ast.Node[],\n prefixes: string | string[] | ReturnType,\n options?: {\n startIndex?: number;\n matchSubstrings?: boolean;\n assumeOneCharStrings?: boolean;\n }\n): {\n match: string;\n endNodeIndex: number;\n endNodePartialMatch: string | null;\n} | null {\n const {\n startIndex = 0,\n matchSubstrings = false,\n assumeOneCharStrings = false,\n } = options || {};\n\n if (typeof prefixes === \"string\") {\n prefixes = [prefixes];\n }\n if (Array.isArray(prefixes)) {\n prefixes = Trie(prefixes);\n }\n const prefixTree = prefixes;\n\n const history = {\n lastPrefix: \"\",\n lastWord: \"\",\n index: startIndex,\n partialMatch: \"\",\n };\n\n /**\n * Try to match the next character. If it matches,\n * record it properly in the `history` object.\n */\n function tryToMatchNextChar(char: string, index: number): boolean {\n let ret = false;\n if (prefixTree.isPrefix(history.lastPrefix + char)) {\n history.lastPrefix += char;\n history.index = index;\n ret = true;\n }\n if (prefixTree.hasWord(history.lastPrefix)) {\n history.lastWord = history.lastPrefix;\n }\n return ret;\n }\n\n // Loop through the nodes looking for the longest prefix match\n for (let i = 0; startIndex + i < nodes.length; i++) {\n const node = nodes[startIndex + i];\n if (!match.string(node)) {\n break;\n }\n if (assumeOneCharStrings && node.content.length !== 1) {\n break;\n }\n if (matchSubstrings) {\n // We need to test letter-by-letter for substring matches\n let fullMatch = true;\n history.partialMatch = \"\";\n for (let j = 0; j < node.content.length; j++) {\n const char = node.content[j];\n if (tryToMatchNextChar(char, startIndex + i)) {\n history.partialMatch += char;\n } else {\n fullMatch = false;\n break;\n }\n }\n if (fullMatch) {\n history.partialMatch = \"\";\n } else {\n break;\n }\n } else {\n if (!tryToMatchNextChar(node.content, startIndex + i)) {\n break;\n }\n }\n }\n\n return history.lastWord\n ? {\n match: history.lastWord,\n endNodeIndex: history.index,\n endNodePartialMatch: history.partialMatch\n ? history.partialMatch\n : null,\n }\n : null;\n}\n"],"names":[],"mappings":"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"} \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-util-scan/package.json b/node_modules/@unified-latex/unified-latex-util-scan/package.json new file mode 100644 index 0000000..efdcacb --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-util-scan/package.json @@ -0,0 +1,54 @@ +{ + "name": "@unified-latex/unified-latex-util-scan", + "version": "1.8.0", + "description": "Functions for modifying a unified-latex AST", + "main": "index.js", + "type": "module", + "dependencies": { + "@unified-latex/unified-latex-types": "^1.8.0", + "@unified-latex/unified-latex-util-match": "^1.8.0", + "@unified-latex/unified-latex-util-print-raw": "^1.8.0", + "trie-prefix-tree": "^1.5.1" + }, + "repository": { + "type": "git", + "url": "git+https://github.com/siefkenj/unified-latex.git" + }, + "keywords": [ + "pegjs", + "latex", + "parser", + "prettier", + "unified-latex", + "unified" + ], + "author": "Jason Siefken", + "license": "MIT", + "bugs": { + "url": "https://github.com/siefkenj/unified-latex/issues" + }, + "homepage": "https://github.com/siefkenj/unified-latex#readme", + "exports": { + ".": { + "import": "./index.js", + "require": "./index.cjs", + "types": "./index.d.ts" + }, + "./*js": "./*js", + "./*": { + "import": "./*/index.js", + "require": "./*/index.cjs", + "types": "./*/index.d.ts" + }, + "./*/index": { + "import": "./*/index.js", + "require": "./*/index.cjs" + } + }, + "files": [ + "**/*ts", + "**/*js", + "**/*.map", + "**/*.json" + ] +} \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-util-split/README.md b/node_modules/@unified-latex/unified-latex-util-split/README.md new file mode 100644 index 0000000..fb6cb43 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-util-split/README.md @@ -0,0 +1,106 @@ + + + + +# unified-latex-util-split + +## What is this? + +Functions to manipulate `unified-latex` Abstract Syntax Tree (AST). + +## When should I use this? + +If you want break apart or join an array of nodes based on a condition. For example, +this is used to split on `&` characters in the `align` environment. + +## Install + +```bash +npm install @unified-latex/unified-latex-util-split +``` + +This package contains both esm and commonjs exports. To explicitly access the esm export, +import the `.js` file. To explicitly access the commonjs export, import the `.cjs` file. + +# Functions + +## `arrayJoin(array, sep)` + +Joins an array of arrays with the item `sep` + +```typescript +function arrayJoin(array: T[][], sep: T | T[]): T[]; +``` + +**Parameters** + +| Param | Type | +| :---- | :--------- | +| array | `T[][]` | +| sep | `T \| T[]` | + +## `splitOnCondition(nodes, splitFunc, options)` + +Split a list of nodes based on whether `splitFunc` returns `true`. +If `onlySplitOnFirstOccurrence` is set to true in the `options` object, then +there will be at most two segments returned. + +```typescript +function splitOnCondition( + nodes: Ast.Node[], + splitFunc: (node: Ast.Node) => boolean, + options: { onlySplitOnFirstOccurrence?: boolean } +): { segments: Ast.Node[][]; separators: Ast.Node[] }; +``` + +**Parameters** + +| Param | Type | +| :-------- | :-------------------------------- | +| nodes | `Ast.Node[]` | +| splitFunc | `(node: Ast.Node) => boolean` | +| options | Omitted | + +## `splitOnMacro(ast, macroName)` + +Split an array of AST nodes based on a macro. An object `{segments: [], macros: []}` +is returned. The original array is reconstructed as +`segments[0] + macros[0] + segments[1] + ...`. + +```typescript +function splitOnMacro( + ast: Ast.Node[], + macroName: string | string[] +): { segments: Ast.Node[][]; macros: Ast.Macro[] }; +``` + +**Parameters** + +| Param | Type | +| :-------- | :------------------- | +| ast | `Ast.Node[]` | +| macroName | `string \| string[]` | + +`unsplitOnMacro({ + segments, + macros, +})` +--- + +Does the reverse of `splitOnMacro` + +```typescript +function unsplitOnMacro({ + segments, + macros, +}: { + segments: Ast.Node[][]; + macros: Ast.Node[] | Ast.Node[][]; +}): Ast.Node[]; +``` + +**Parameters** + +| Param | Type | +| :---------------------------------------- | :-------------------------------- | +| { segments, macros, } | Omitted | diff --git a/node_modules/@unified-latex/unified-latex-util-split/index.cjs b/node_modules/@unified-latex/unified-latex-util-split/index.cjs new file mode 100644 index 0000000..c5abace --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-util-split/index.cjs @@ -0,0 +1,77 @@ +"use strict"; +Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" }); +const unifiedLatexUtilMatch = require("@unified-latex/unified-latex-util-match"); +function splitOnCondition(nodes, splitFunc = () => false, options) { + if (!Array.isArray(nodes)) { + throw new Error(`Can only split an Array, not ${nodes}`); + } + const { onlySplitOnFirstOccurrence = false } = options || {}; + const splitIndices = []; + for (let i = 0; i < nodes.length; i++) { + if (splitFunc(nodes[i])) { + splitIndices.push(i); + if (onlySplitOnFirstOccurrence) { + break; + } + } + } + if (splitIndices.length === 0) { + return { segments: [nodes], separators: [] }; + } + let separators = splitIndices.map((i) => nodes[i]); + let segments = splitIndices.map((splitEnd, i) => { + const splitStart = i === 0 ? 0 : splitIndices[i - 1] + 1; + return nodes.slice(splitStart, splitEnd); + }); + segments.push( + nodes.slice(splitIndices[splitIndices.length - 1] + 1, nodes.length) + ); + return { segments, separators }; +} +function splitOnMacro(ast, macroName) { + if (typeof macroName === "string") { + macroName = [macroName]; + } + if (!Array.isArray(macroName)) { + throw new Error("Type coercion failed"); + } + const isSeparator = unifiedLatexUtilMatch.match.createMacroMatcher(macroName); + const { segments, separators } = splitOnCondition(ast, isSeparator); + return { segments, macros: separators }; +} +function unsplitOnMacro({ + segments, + macros +}) { + if (segments.length === 0) { + console.warn("Trying to join zero segments"); + return []; + } + if (segments.length !== macros.length + 1) { + console.warn( + "Mismatch between lengths of macros and segments when trying to unsplit" + ); + } + let ret = segments[0]; + for (let i = 0; i < macros.length; i++) { + ret = ret.concat(macros[i]).concat(segments[i + 1]); + } + return ret; +} +function arrayJoin(array, sep) { + return array.flatMap((item, i) => { + if (i === 0) { + return item; + } + if (Array.isArray(sep)) { + return [...sep, ...item]; + } else { + return [sep, ...item]; + } + }); +} +exports.arrayJoin = arrayJoin; +exports.splitOnCondition = splitOnCondition; +exports.splitOnMacro = splitOnMacro; +exports.unsplitOnMacro = unsplitOnMacro; +//# sourceMappingURL=index.cjs.map diff --git a/node_modules/@unified-latex/unified-latex-util-split/index.cjs.map b/node_modules/@unified-latex/unified-latex-util-split/index.cjs.map new file mode 100644 index 0000000..52dff81 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-util-split/index.cjs.map @@ -0,0 +1 @@ +{"version":3,"file":"index.cjs","sources":["../libs/split-on-condition.ts","../libs/split-on-macro.ts","../libs/unsplit-on-macro.ts","../libs/array-join.ts"],"sourcesContent":["import * as Ast from \"@unified-latex/unified-latex-types\";\n\n/**\n * Split a list of nodes based on whether `splitFunc` returns `true`.\n * If `onlySplitOnFirstOccurrence` is set to true in the `options` object, then\n * there will be at most two segments returned.\n */\nexport function splitOnCondition(\n nodes: Ast.Node[],\n splitFunc: (node: Ast.Node) => boolean = () => false,\n options?: { onlySplitOnFirstOccurrence?: boolean }\n): { segments: Ast.Node[][]; separators: Ast.Node[] } {\n if (!Array.isArray(nodes)) {\n throw new Error(`Can only split an Array, not ${nodes}`);\n }\n\n const { onlySplitOnFirstOccurrence = false } = options || {};\n\n const splitIndices: number[] = [];\n for (let i = 0; i < nodes.length; i++) {\n if (splitFunc(nodes[i])) {\n splitIndices.push(i);\n if (onlySplitOnFirstOccurrence) {\n break;\n }\n }\n }\n\n // Short circuit if there is no splitting to be done\n if (splitIndices.length === 0) {\n return { segments: [nodes], separators: [] };\n }\n\n let separators = splitIndices.map((i) => nodes[i]);\n let segments = splitIndices.map((splitEnd, i) => {\n const splitStart = i === 0 ? 0 : splitIndices[i - 1] + 1;\n return nodes.slice(splitStart, splitEnd);\n });\n segments.push(\n nodes.slice(splitIndices[splitIndices.length - 1] + 1, nodes.length)\n );\n\n return { segments, separators };\n}\n","import * as Ast from \"@unified-latex/unified-latex-types\";\nimport { match } from \"@unified-latex/unified-latex-util-match\";\nimport { splitOnCondition } from \"./split-on-condition\";\n\n/**\n * Split an array of AST nodes based on a macro. An object `{segments: [], macros: []}`\n * is returned. The original array is reconstructed as\n * `segments[0] + macros[0] + segments[1] + ...`.\n *\n * @param {[object]} ast\n * @param {(string|[string])} macroName\n * @returns {{segments: [object], macros: [object]}}\n */\nexport function splitOnMacro(\n ast: Ast.Node[],\n macroName: string | string[]\n): { segments: Ast.Node[][]; macros: Ast.Macro[] } {\n if (typeof macroName === \"string\") {\n macroName = [macroName];\n }\n if (!Array.isArray(macroName)) {\n throw new Error(\"Type coercion failed\");\n }\n const isSeparator = match.createMacroMatcher(macroName);\n const { segments, separators } = splitOnCondition(ast, isSeparator);\n return { segments, macros: separators as Ast.Macro[] };\n}\n","import * as Ast from \"@unified-latex/unified-latex-types\";\n\n/**\n * Does the reverse of `splitOnMacro`\n */\nexport function unsplitOnMacro({\n segments,\n macros,\n}: {\n segments: Ast.Node[][];\n macros: Ast.Node[] | Ast.Node[][];\n}) {\n if (segments.length === 0) {\n console.warn(\"Trying to join zero segments\");\n return [];\n }\n if (segments.length !== macros.length + 1) {\n console.warn(\n \"Mismatch between lengths of macros and segments when trying to unsplit\"\n );\n }\n\n let ret = segments[0];\n for (let i = 0; i < macros.length; i++) {\n // Even though the type of macros[i] is node and not array,\n // Array.concat still works\n ret = ret.concat(macros[i]).concat(segments[i + 1]);\n }\n\n return ret;\n}\n","/**\n * Joins an array of arrays with the item `sep`\n */\nexport function arrayJoin(array: T[][], sep: T | T[]): T[] {\n return array.flatMap((item, i) => {\n if (i === 0) {\n return item;\n }\n if (Array.isArray(sep)) {\n return [...sep, ...item];\n } else {\n return [sep, ...item];\n }\n });\n}\n"],"names":["match"],"mappings":";;;AAOO,SAAS,iBACZ,OACA,YAAyC,MAAM,OAC/C,SACkD;AAClD,MAAI,CAAC,MAAM,QAAQ,KAAK,GAAG;AACvB,UAAM,IAAI,MAAM,gCAAgC,KAAK,EAAE;AAAA,EAC3D;AAEA,QAAM,EAAE,6BAA6B,UAAU,WAAW,CAAA;AAE1D,QAAM,eAAyB,CAAA;AAC/B,WAAS,IAAI,GAAG,IAAI,MAAM,QAAQ,KAAK;AACnC,QAAI,UAAU,MAAM,CAAC,CAAC,GAAG;AACrB,mBAAa,KAAK,CAAC;AACnB,UAAI,4BAA4B;AAC5B;AAAA,MACJ;AAAA,IACJ;AAAA,EACJ;AAGI,MAAA,aAAa,WAAW,GAAG;AAC3B,WAAO,EAAE,UAAU,CAAC,KAAK,GAAG,YAAY,CAAG,EAAA;AAAA,EAC/C;AAEA,MAAI,aAAa,aAAa,IAAI,CAAC,MAAM,MAAM,CAAC,CAAC;AACjD,MAAI,WAAW,aAAa,IAAI,CAAC,UAAU,MAAM;AAC7C,UAAM,aAAa,MAAM,IAAI,IAAI,aAAa,IAAI,CAAC,IAAI;AAChD,WAAA,MAAM,MAAM,YAAY,QAAQ;AAAA,EAAA,CAC1C;AACQ,WAAA;AAAA,IACL,MAAM,MAAM,aAAa,aAAa,SAAS,CAAC,IAAI,GAAG,MAAM,MAAM;AAAA,EAAA;AAGhE,SAAA,EAAE,UAAU;AACvB;AC9BgB,SAAA,aACZ,KACA,WAC+C;AAC3C,MAAA,OAAO,cAAc,UAAU;AAC/B,gBAAY,CAAC,SAAS;AAAA,EAC1B;AACA,MAAI,CAAC,MAAM,QAAQ,SAAS,GAAG;AACrB,UAAA,IAAI,MAAM,sBAAsB;AAAA,EAC1C;AACM,QAAA,cAAcA,sBAAAA,MAAM,mBAAmB,SAAS;AACtD,QAAM,EAAE,UAAU,WAAA,IAAe,iBAAiB,KAAK,WAAW;AAC3D,SAAA,EAAE,UAAU,QAAQ;AAC/B;ACrBO,SAAS,eAAe;AAAA,EAC3B;AAAA,EACA;AACJ,GAGG;AACK,MAAA,SAAS,WAAW,GAAG;AACvB,YAAQ,KAAK,8BAA8B;AAC3C,WAAO;EACX;AACA,MAAI,SAAS,WAAW,OAAO,SAAS,GAAG;AAC/B,YAAA;AAAA,MACJ;AAAA,IAAA;AAAA,EAER;AAEI,MAAA,MAAM,SAAS,CAAC;AACpB,WAAS,IAAI,GAAG,IAAI,OAAO,QAAQ,KAAK;AAG9B,UAAA,IAAI,OAAO,OAAO,CAAC,CAAC,EAAE,OAAO,SAAS,IAAI,CAAC,CAAC;AAAA,EACtD;AAEO,SAAA;AACX;AC3BgB,SAAA,UAAa,OAAc,KAAmB;AAC1D,SAAO,MAAM,QAAQ,CAAC,MAAM,MAAM;AAC9B,QAAI,MAAM,GAAG;AACF,aAAA;AAAA,IACX;AACI,QAAA,MAAM,QAAQ,GAAG,GAAG;AACpB,aAAO,CAAC,GAAG,KAAK,GAAG,IAAI;AAAA,IAAA,OACpB;AACI,aAAA,CAAC,KAAK,GAAG,IAAI;AAAA,IACxB;AAAA,EAAA,CACH;AACL;;;;;"} \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-util-split/index.d.ts b/node_modules/@unified-latex/unified-latex-util-split/index.d.ts new file mode 100644 index 0000000..be26411 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-util-split/index.d.ts @@ -0,0 +1,42 @@ +import * as Ast from '@unified-latex/unified-latex-types'; + +/** + * Joins an array of arrays with the item `sep` + */ +export declare function arrayJoin(array: T[][], sep: T | T[]): T[]; + +/** + * Split a list of nodes based on whether `splitFunc` returns `true`. + * If `onlySplitOnFirstOccurrence` is set to true in the `options` object, then + * there will be at most two segments returned. + */ +export declare function splitOnCondition(nodes: Ast.Node[], splitFunc?: (node: Ast.Node) => boolean, options?: { + onlySplitOnFirstOccurrence?: boolean; +}): { + segments: Ast.Node[][]; + separators: Ast.Node[]; +}; + +/** + * Split an array of AST nodes based on a macro. An object `{segments: [], macros: []}` + * is returned. The original array is reconstructed as + * `segments[0] + macros[0] + segments[1] + ...`. + * + * @param {[object]} ast + * @param {(string|[string])} macroName + * @returns {{segments: [object], macros: [object]}} + */ +export declare function splitOnMacro(ast: Ast.Node[], macroName: string | string[]): { + segments: Ast.Node[][]; + macros: Ast.Macro[]; +}; + +/** + * Does the reverse of `splitOnMacro` + */ +export declare function unsplitOnMacro({ segments, macros, }: { + segments: Ast.Node[][]; + macros: Ast.Node[] | Ast.Node[][]; +}): Ast.Node[]; + +export { } diff --git a/node_modules/@unified-latex/unified-latex-util-split/index.js b/node_modules/@unified-latex/unified-latex-util-split/index.js new file mode 100644 index 0000000..cd61dc9 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-util-split/index.js @@ -0,0 +1,77 @@ +import { match } from "@unified-latex/unified-latex-util-match"; +function splitOnCondition(nodes, splitFunc = () => false, options) { + if (!Array.isArray(nodes)) { + throw new Error(`Can only split an Array, not ${nodes}`); + } + const { onlySplitOnFirstOccurrence = false } = options || {}; + const splitIndices = []; + for (let i = 0; i < nodes.length; i++) { + if (splitFunc(nodes[i])) { + splitIndices.push(i); + if (onlySplitOnFirstOccurrence) { + break; + } + } + } + if (splitIndices.length === 0) { + return { segments: [nodes], separators: [] }; + } + let separators = splitIndices.map((i) => nodes[i]); + let segments = splitIndices.map((splitEnd, i) => { + const splitStart = i === 0 ? 0 : splitIndices[i - 1] + 1; + return nodes.slice(splitStart, splitEnd); + }); + segments.push( + nodes.slice(splitIndices[splitIndices.length - 1] + 1, nodes.length) + ); + return { segments, separators }; +} +function splitOnMacro(ast, macroName) { + if (typeof macroName === "string") { + macroName = [macroName]; + } + if (!Array.isArray(macroName)) { + throw new Error("Type coercion failed"); + } + const isSeparator = match.createMacroMatcher(macroName); + const { segments, separators } = splitOnCondition(ast, isSeparator); + return { segments, macros: separators }; +} +function unsplitOnMacro({ + segments, + macros +}) { + if (segments.length === 0) { + console.warn("Trying to join zero segments"); + return []; + } + if (segments.length !== macros.length + 1) { + console.warn( + "Mismatch between lengths of macros and segments when trying to unsplit" + ); + } + let ret = segments[0]; + for (let i = 0; i < macros.length; i++) { + ret = ret.concat(macros[i]).concat(segments[i + 1]); + } + return ret; +} +function arrayJoin(array, sep) { + return array.flatMap((item, i) => { + if (i === 0) { + return item; + } + if (Array.isArray(sep)) { + return [...sep, ...item]; + } else { + return [sep, ...item]; + } + }); +} +export { + arrayJoin, + splitOnCondition, + splitOnMacro, + unsplitOnMacro +}; +//# sourceMappingURL=index.js.map diff --git a/node_modules/@unified-latex/unified-latex-util-split/index.js.map b/node_modules/@unified-latex/unified-latex-util-split/index.js.map new file mode 100644 index 0000000..bf36d25 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-util-split/index.js.map @@ -0,0 +1 @@ +{"version":3,"file":"index.js","sources":["../libs/split-on-condition.ts","../libs/split-on-macro.ts","../libs/unsplit-on-macro.ts","../libs/array-join.ts"],"sourcesContent":["import * as Ast from \"@unified-latex/unified-latex-types\";\n\n/**\n * Split a list of nodes based on whether `splitFunc` returns `true`.\n * If `onlySplitOnFirstOccurrence` is set to true in the `options` object, then\n * there will be at most two segments returned.\n */\nexport function splitOnCondition(\n nodes: Ast.Node[],\n splitFunc: (node: Ast.Node) => boolean = () => false,\n options?: { onlySplitOnFirstOccurrence?: boolean }\n): { segments: Ast.Node[][]; separators: Ast.Node[] } {\n if (!Array.isArray(nodes)) {\n throw new Error(`Can only split an Array, not ${nodes}`);\n }\n\n const { onlySplitOnFirstOccurrence = false } = options || {};\n\n const splitIndices: number[] = [];\n for (let i = 0; i < nodes.length; i++) {\n if (splitFunc(nodes[i])) {\n splitIndices.push(i);\n if (onlySplitOnFirstOccurrence) {\n break;\n }\n }\n }\n\n // Short circuit if there is no splitting to be done\n if (splitIndices.length === 0) {\n return { segments: [nodes], separators: [] };\n }\n\n let separators = splitIndices.map((i) => nodes[i]);\n let segments = splitIndices.map((splitEnd, i) => {\n const splitStart = i === 0 ? 0 : splitIndices[i - 1] + 1;\n return nodes.slice(splitStart, splitEnd);\n });\n segments.push(\n nodes.slice(splitIndices[splitIndices.length - 1] + 1, nodes.length)\n );\n\n return { segments, separators };\n}\n","import * as Ast from \"@unified-latex/unified-latex-types\";\nimport { match } from \"@unified-latex/unified-latex-util-match\";\nimport { splitOnCondition } from \"./split-on-condition\";\n\n/**\n * Split an array of AST nodes based on a macro. An object `{segments: [], macros: []}`\n * is returned. The original array is reconstructed as\n * `segments[0] + macros[0] + segments[1] + ...`.\n *\n * @param {[object]} ast\n * @param {(string|[string])} macroName\n * @returns {{segments: [object], macros: [object]}}\n */\nexport function splitOnMacro(\n ast: Ast.Node[],\n macroName: string | string[]\n): { segments: Ast.Node[][]; macros: Ast.Macro[] } {\n if (typeof macroName === \"string\") {\n macroName = [macroName];\n }\n if (!Array.isArray(macroName)) {\n throw new Error(\"Type coercion failed\");\n }\n const isSeparator = match.createMacroMatcher(macroName);\n const { segments, separators } = splitOnCondition(ast, isSeparator);\n return { segments, macros: separators as Ast.Macro[] };\n}\n","import * as Ast from \"@unified-latex/unified-latex-types\";\n\n/**\n * Does the reverse of `splitOnMacro`\n */\nexport function unsplitOnMacro({\n segments,\n macros,\n}: {\n segments: Ast.Node[][];\n macros: Ast.Node[] | Ast.Node[][];\n}) {\n if (segments.length === 0) {\n console.warn(\"Trying to join zero segments\");\n return [];\n }\n if (segments.length !== macros.length + 1) {\n console.warn(\n \"Mismatch between lengths of macros and segments when trying to unsplit\"\n );\n }\n\n let ret = segments[0];\n for (let i = 0; i < macros.length; i++) {\n // Even though the type of macros[i] is node and not array,\n // Array.concat still works\n ret = ret.concat(macros[i]).concat(segments[i + 1]);\n }\n\n return ret;\n}\n","/**\n * Joins an array of arrays with the item `sep`\n */\nexport function arrayJoin(array: T[][], sep: T | T[]): T[] {\n return array.flatMap((item, i) => {\n if (i === 0) {\n return item;\n }\n if (Array.isArray(sep)) {\n return [...sep, ...item];\n } else {\n return [sep, ...item];\n }\n });\n}\n"],"names":[],"mappings":";AAOO,SAAS,iBACZ,OACA,YAAyC,MAAM,OAC/C,SACkD;AAClD,MAAI,CAAC,MAAM,QAAQ,KAAK,GAAG;AACvB,UAAM,IAAI,MAAM,gCAAgC,KAAK,EAAE;AAAA,EAC3D;AAEA,QAAM,EAAE,6BAA6B,UAAU,WAAW,CAAA;AAE1D,QAAM,eAAyB,CAAA;AAC/B,WAAS,IAAI,GAAG,IAAI,MAAM,QAAQ,KAAK;AACnC,QAAI,UAAU,MAAM,CAAC,CAAC,GAAG;AACrB,mBAAa,KAAK,CAAC;AACnB,UAAI,4BAA4B;AAC5B;AAAA,MACJ;AAAA,IACJ;AAAA,EACJ;AAGI,MAAA,aAAa,WAAW,GAAG;AAC3B,WAAO,EAAE,UAAU,CAAC,KAAK,GAAG,YAAY,CAAG,EAAA;AAAA,EAC/C;AAEA,MAAI,aAAa,aAAa,IAAI,CAAC,MAAM,MAAM,CAAC,CAAC;AACjD,MAAI,WAAW,aAAa,IAAI,CAAC,UAAU,MAAM;AAC7C,UAAM,aAAa,MAAM,IAAI,IAAI,aAAa,IAAI,CAAC,IAAI;AAChD,WAAA,MAAM,MAAM,YAAY,QAAQ;AAAA,EAAA,CAC1C;AACQ,WAAA;AAAA,IACL,MAAM,MAAM,aAAa,aAAa,SAAS,CAAC,IAAI,GAAG,MAAM,MAAM;AAAA,EAAA;AAGhE,SAAA,EAAE,UAAU;AACvB;AC9BgB,SAAA,aACZ,KACA,WAC+C;AAC3C,MAAA,OAAO,cAAc,UAAU;AAC/B,gBAAY,CAAC,SAAS;AAAA,EAC1B;AACA,MAAI,CAAC,MAAM,QAAQ,SAAS,GAAG;AACrB,UAAA,IAAI,MAAM,sBAAsB;AAAA,EAC1C;AACM,QAAA,cAAc,MAAM,mBAAmB,SAAS;AACtD,QAAM,EAAE,UAAU,WAAA,IAAe,iBAAiB,KAAK,WAAW;AAC3D,SAAA,EAAE,UAAU,QAAQ;AAC/B;ACrBO,SAAS,eAAe;AAAA,EAC3B;AAAA,EACA;AACJ,GAGG;AACK,MAAA,SAAS,WAAW,GAAG;AACvB,YAAQ,KAAK,8BAA8B;AAC3C,WAAO;EACX;AACA,MAAI,SAAS,WAAW,OAAO,SAAS,GAAG;AAC/B,YAAA;AAAA,MACJ;AAAA,IAAA;AAAA,EAER;AAEI,MAAA,MAAM,SAAS,CAAC;AACpB,WAAS,IAAI,GAAG,IAAI,OAAO,QAAQ,KAAK;AAG9B,UAAA,IAAI,OAAO,OAAO,CAAC,CAAC,EAAE,OAAO,SAAS,IAAI,CAAC,CAAC;AAAA,EACtD;AAEO,SAAA;AACX;AC3BgB,SAAA,UAAa,OAAc,KAAmB;AAC1D,SAAO,MAAM,QAAQ,CAAC,MAAM,MAAM;AAC9B,QAAI,MAAM,GAAG;AACF,aAAA;AAAA,IACX;AACI,QAAA,MAAM,QAAQ,GAAG,GAAG;AACpB,aAAO,CAAC,GAAG,KAAK,GAAG,IAAI;AAAA,IAAA,OACpB;AACI,aAAA,CAAC,KAAK,GAAG,IAAI;AAAA,IACxB;AAAA,EAAA,CACH;AACL;"} \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-util-split/package.json b/node_modules/@unified-latex/unified-latex-util-split/package.json new file mode 100644 index 0000000..e9c2650 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-util-split/package.json @@ -0,0 +1,52 @@ +{ + "name": "@unified-latex/unified-latex-util-split", + "version": "1.8.0", + "description": "Functions for modifying a unified-latex AST", + "main": "index.js", + "type": "module", + "dependencies": { + "@unified-latex/unified-latex-types": "^1.8.0", + "@unified-latex/unified-latex-util-match": "^1.8.0" + }, + "repository": { + "type": "git", + "url": "git+https://github.com/siefkenj/unified-latex.git" + }, + "keywords": [ + "pegjs", + "latex", + "parser", + "prettier", + "unified-latex", + "unified" + ], + "author": "Jason Siefken", + "license": "MIT", + "bugs": { + "url": "https://github.com/siefkenj/unified-latex/issues" + }, + "homepage": "https://github.com/siefkenj/unified-latex#readme", + "exports": { + ".": { + "import": "./index.js", + "require": "./index.cjs", + "types": "./index.d.ts" + }, + "./*js": "./*js", + "./*": { + "import": "./*/index.js", + "require": "./*/index.cjs", + "types": "./*/index.d.ts" + }, + "./*/index": { + "import": "./*/index.js", + "require": "./*/index.cjs" + } + }, + "files": [ + "**/*ts", + "**/*js", + "**/*.map", + "**/*.json" + ] +} \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-util-trim/README.md b/node_modules/@unified-latex/unified-latex-util-trim/README.md new file mode 100644 index 0000000..b139357 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-util-trim/README.md @@ -0,0 +1,126 @@ + + + + +# unified-latex-util-trim + +## What is this? + +Functions to help modify a `unified-latex` Abstract Syntax Tree (AST). + +## When should I use this? + +If you want to remove whitespace from the ends of an array of nodes. + +Note that whitespace can come from a `Ast.Whitespace` node or from an +`Ast.Comment` node that has leading whitespace. These functions take care +to deal with both situations. + +## Install + +```bash +npm install @unified-latex/unified-latex-util-trim +``` + +This package contains both esm and commonjs exports. To explicitly access the esm export, +import the `.js` file. To explicitly access the commonjs export, import the `.cjs` file. + +# Plugins + +## `unifiedLatexTrimEnvironmentContents` + +Unified plugin to trim the whitespace from the start/end of any environments, including +math environments. + +### Usage + +`unified().use(unifiedLatexTrimEnvironmentContents)` + +### Type + +`Plugin` + +```typescript +function unifiedLatexTrimEnvironmentContents(): (tree: Ast.Root) => void; +``` + +## `unifiedLatexTrimRoot` + +Unified plugin to trim the whitespace from the start/end of the root element. + +### Usage + +`unified().use(unifiedLatexTrimRoot)` + +### Type + +`Plugin` + +```typescript +function unifiedLatexTrimRoot(): (tree: Ast.Root) => void; +``` + +# Functions + +## `hasWhitespaceEquivalent(nodes)` + +Returns whether the array has whitespace at the start/end. Comments with `leadingWhitespace === true` +are counted as whitespace. Other comments are ignored. + +```typescript +function hasWhitespaceEquivalent(nodes: Ast.Node[]): { + start: boolean; + end: boolean; +}; +``` + +**Parameters** + +| Param | Type | +| :---- | :----------- | +| nodes | `Ast.Node[]` | + +## `trim(nodes)` + +Trims whitespace and parbreaks from the start and end +of an array. The number of trimmed nodes is returned. +Special care is taken to preserve comments, though any whitespace +before the first comment(s) or after the last comment(s) is trimmed. + +```typescript +function trim(nodes: Ast.Node[]): { trimmedStart: number; trimmedEnd: number }; +``` + +**Parameters** + +| Param | Type | +| :---- | :----------- | +| nodes | `Ast.Node[]` | + +## `trimEnd(nodes)` + +Trim whitespace and parbreaks from the right of an array. + +```typescript +function trimEnd(nodes: Ast.Node[]): { trimmedEnd: number }; +``` + +**Parameters** + +| Param | Type | +| :---- | :----------- | +| nodes | `Ast.Node[]` | + +## `trimStart(nodes)` + +Trim whitespace and parbreaks from the left of an array. + +```typescript +function trimStart(nodes: Ast.Node[]): { trimmedStart: number }; +``` + +**Parameters** + +| Param | Type | +| :---- | :----------- | +| nodes | `Ast.Node[]` | diff --git a/node_modules/@unified-latex/unified-latex-util-trim/index.cjs b/node_modules/@unified-latex/unified-latex-util-trim/index.cjs new file mode 100644 index 0000000..056f418 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-util-trim/index.cjs @@ -0,0 +1,130 @@ +"use strict"; +Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" }); +const unifiedLatexUtilMatch = require("@unified-latex/unified-latex-util-match"); +const unifiedLatexUtilVisit = require("@unified-latex/unified-latex-util-visit"); +function trim(nodes) { + if (!Array.isArray(nodes)) { + console.warn("Trying to trim a non-array ast", nodes); + return nodes; + } + const { trimmedStart } = trimStart(nodes); + const { trimmedEnd } = trimEnd(nodes); + return { trimmedStart, trimmedEnd }; +} +function trimStart(nodes) { + const { start } = amountOfLeadingAndTrailingWhitespace(nodes); + nodes.splice(0, start); + for (const leadingToken of nodes) { + if (!unifiedLatexUtilMatch.match.comment(leadingToken)) { + break; + } + if (leadingToken.leadingWhitespace || leadingToken.sameline) { + leadingToken.leadingWhitespace = false; + } + if (start > 0 && leadingToken.sameline) { + leadingToken.sameline = false; + } + } + return { trimmedStart: start }; +} +function trimEnd(nodes) { + const { end } = amountOfLeadingAndTrailingWhitespace(nodes); + nodes.splice(nodes.length - end, end); + for (let i = nodes.length - 1; i >= 0; i--) { + const trailingToken = nodes[i]; + if (!unifiedLatexUtilMatch.match.comment(trailingToken)) { + break; + } + delete trailingToken.suffixParbreak; + if (unifiedLatexUtilMatch.match.comment(trailingToken) && trailingToken.leadingWhitespace && !trailingToken.sameline) { + trailingToken.leadingWhitespace = false; + } + } + return { trimmedEnd: end }; +} +function amountOfLeadingAndTrailingWhitespace(ast) { + let start = 0; + let end = 0; + for (const node of ast) { + if (unifiedLatexUtilMatch.match.whitespace(node) || unifiedLatexUtilMatch.match.parbreak(node)) { + start++; + } else { + break; + } + } + if (start === ast.length) { + return { start, end: 0 }; + } + for (let i = ast.length - 1; i >= 0; i--) { + const node = ast[i]; + if (unifiedLatexUtilMatch.match.whitespace(node) || unifiedLatexUtilMatch.match.parbreak(node)) { + end++; + } else { + break; + } + } + return { start, end }; +} +const unifiedLatexTrimEnvironmentContents = function unifiedLatexTrimEnvironmentContents2() { + return (tree) => { + unifiedLatexUtilVisit.visit(tree, (node) => { + if (!(unifiedLatexUtilMatch.match.math(node) || unifiedLatexUtilMatch.match.anyEnvironment(node))) { + return; + } + let firstNode = node.content[0]; + if (unifiedLatexUtilMatch.match.comment(firstNode) && firstNode.sameline) { + firstNode.suffixParbreak = false; + trimEnd(node.content); + const { trimmedStart } = trimStart(node.content.slice(1)); + node.content.splice(1, trimmedStart); + } else { + trim(node.content); + } + }); + }; +}; +const unifiedLatexTrimRoot = function unifiedLatexTrimRoot2() { + return (tree) => { + trim(tree.content); + }; +}; +function hasWhitespaceEquivalent(nodes) { + let start = false; + let end = false; + for (let i = 0; i < nodes.length; i++) { + const node = nodes[i]; + if (unifiedLatexUtilMatch.match.comment(node)) { + if (node.leadingWhitespace) { + start = true; + break; + } + continue; + } + if (unifiedLatexUtilMatch.match.whitespace(node)) { + start = true; + } + break; + } + for (let j = nodes.length - 1; j >= 0; j--) { + const node = nodes[j]; + if (unifiedLatexUtilMatch.match.comment(node)) { + if (node.leadingWhitespace) { + end = true; + break; + } + continue; + } + if (unifiedLatexUtilMatch.match.whitespace(node)) { + end = true; + } + break; + } + return { start, end }; +} +exports.hasWhitespaceEquivalent = hasWhitespaceEquivalent; +exports.trim = trim; +exports.trimEnd = trimEnd; +exports.trimStart = trimStart; +exports.unifiedLatexTrimEnvironmentContents = unifiedLatexTrimEnvironmentContents; +exports.unifiedLatexTrimRoot = unifiedLatexTrimRoot; +//# sourceMappingURL=index.cjs.map diff --git a/node_modules/@unified-latex/unified-latex-util-trim/index.cjs.map b/node_modules/@unified-latex/unified-latex-util-trim/index.cjs.map new file mode 100644 index 0000000..b89d87b --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-util-trim/index.cjs.map @@ -0,0 +1 @@ +{"version":3,"file":"index.cjs","sources":["../libs/trim.ts","../libs/unified-latex-trim-environment-contents.ts","../libs/unified-latex-trim-root.ts","../libs/has-whitespace-equivalent.ts"],"sourcesContent":["import * as Ast from \"@unified-latex/unified-latex-types\";\nimport { match } from \"@unified-latex/unified-latex-util-match\";\n\n/**\n * Trims whitespace and parbreaks from the start and end\n * of an array. The number of trimmed nodes is returned.\n * Special care is taken to preserve comments, though any whitespace\n * before the first comment(s) or after the last comment(s) is trimmed.\n */\nexport function trim(nodes: Ast.Node[]): {\n trimmedStart: number;\n trimmedEnd: number;\n} {\n if (!Array.isArray(nodes)) {\n console.warn(\"Trying to trim a non-array ast\", nodes);\n return nodes;\n }\n\n const { trimmedStart } = trimStart(nodes);\n const { trimmedEnd } = trimEnd(nodes);\n\n return { trimmedStart, trimmedEnd };\n}\n\n/**\n * Trim whitespace and parbreaks from the left of an array.\n */\nexport function trimStart(nodes: Ast.Node[]): { trimmedStart: number } {\n const { start } = amountOfLeadingAndTrailingWhitespace(nodes);\n\n nodes.splice(0, start);\n\n // If there are comments at the start, they might have leading whitespace.\n // This leading whitespace should be trimmed\n for (const leadingToken of nodes) {\n if (!match.comment(leadingToken)) {\n break;\n }\n if (leadingToken.leadingWhitespace || leadingToken.sameline) {\n leadingToken.leadingWhitespace = false;\n }\n // Special care must be taken. If the comment was on the same line as a\n // parskip, it will no longer be on the same line after the trimming.\n // Thus, we must modify the comment.\n if (start > 0 && leadingToken.sameline) {\n leadingToken.sameline = false;\n }\n }\n\n return { trimmedStart: start };\n}\n\n/**\n * Trim whitespace and parbreaks from the right of an array.\n */\nexport function trimEnd(nodes: Ast.Node[]): { trimmedEnd: number } {\n const { end } = amountOfLeadingAndTrailingWhitespace(nodes);\n\n nodes.splice(nodes.length - end, end);\n\n // Trim off any spaces belonging to trailing comments\n for (let i = nodes.length - 1; i >= 0; i--) {\n const trailingToken = nodes[i];\n if (!match.comment(trailingToken)) {\n break;\n }\n\n // Any parbreaks have been trimmed, so there is no suffix parbreak here!\n delete trailingToken.suffixParbreak;\n\n // We don't trim spaces before trailing same-line comments. This is a stylistic choice\n // so that\n // `foo %xxx` does not become `foo%xxx`.\n // The latter is strictly \"correct\" for a trim function, but it is prettier to format\n // code preserving the space before the sameline comment\n if (\n match.comment(trailingToken) &&\n trailingToken.leadingWhitespace &&\n !trailingToken.sameline\n ) {\n trailingToken.leadingWhitespace = false;\n }\n }\n\n return { trimmedEnd: end };\n}\n\n/**\n * Returns the number of whitespace/parbreak nodes at the start and end of an array.\n */\nfunction amountOfLeadingAndTrailingWhitespace(ast: Ast.Node[]): {\n start: number;\n end: number;\n} {\n let start = 0;\n let end = 0;\n for (const node of ast) {\n if (match.whitespace(node) || match.parbreak(node)) {\n start++;\n } else {\n break;\n }\n }\n\n if (start === ast.length) {\n return { start, end: 0 };\n }\n\n // Find the padding on the right\n for (let i = ast.length - 1; i >= 0; i--) {\n const node = ast[i];\n if (match.whitespace(node) || match.parbreak(node)) {\n end++;\n } else {\n break;\n }\n }\n\n return { start, end };\n}\n","import type { Plugin } from \"unified\";\nimport * as Ast from \"@unified-latex/unified-latex-types\";\nimport { match } from \"@unified-latex/unified-latex-util-match\";\nimport { visit } from \"@unified-latex/unified-latex-util-visit\";\nimport { trim, trimEnd, trimStart } from \"./trim\";\n\ntype PluginOptions = void;\n\n/**\n * Unified plugin to trim the whitespace from the start/end of any environments, including\n * math environments.\n */\nexport const unifiedLatexTrimEnvironmentContents: Plugin<\n PluginOptions[],\n Ast.Root,\n Ast.Root\n> = function unifiedLatexTrimEnvironmentContents() {\n return (tree) => {\n visit(tree, (node) => {\n if (!(match.math(node) || match.anyEnvironment(node))) {\n return;\n }\n\n // If the first thing in the environment is a sameline comment,\n // we actually want to start trimming *after* it.\n let firstNode = node.content[0];\n if (match.comment(firstNode) && firstNode.sameline) {\n firstNode.suffixParbreak = false;\n trimEnd(node.content);\n\n // We play a nasty trick here. This call to `trimStart`\n // will actually modify `node.content` if `node.content.slice(1)` starts\n // with a comment that has leading whitespace (it will remove that whitespace).\n // However, it won't remove any elements from `node.content`; we need\n // to do that ourselves.\n const { trimmedStart } = trimStart(node.content.slice(1));\n node.content.splice(1, trimmedStart);\n } else {\n trim(node.content);\n }\n });\n };\n};\n","import type { Plugin } from \"unified\";\nimport * as Ast from \"@unified-latex/unified-latex-types\";\nimport { trim } from \"./trim\";\n\ntype PluginOptions = void;\n\n/**\n * Unified plugin to trim the whitespace from the start/end of the root element.\n */\nexport const unifiedLatexTrimRoot: Plugin =\n function unifiedLatexTrimRoot() {\n return (tree) => {\n trim(tree.content);\n };\n };\n","import * as Ast from \"@unified-latex/unified-latex-types\";\nimport { match } from \"@unified-latex/unified-latex-util-match\";\n\n/**\n * Returns whether the array has whitespace at the start/end. Comments with `leadingWhitespace === true`\n * are counted as whitespace. Other comments are ignored.\n */\nexport function hasWhitespaceEquivalent(nodes: Ast.Node[]): {\n start: boolean;\n end: boolean;\n} {\n let start = false;\n let end = false;\n for (let i = 0; i < nodes.length; i++) {\n const node = nodes[i];\n if (match.comment(node)) {\n // A comment with leading whitespace will render with leading whitespace,\n // so if we encounter one, we should consider ourselves to have leading whitespace.\n if (node.leadingWhitespace) {\n start = true;\n break;\n }\n continue;\n }\n if (match.whitespace(node)) {\n start = true;\n }\n break;\n }\n for (let j = nodes.length - 1; j >= 0; j--) {\n const node = nodes[j];\n if (match.comment(node)) {\n if (node.leadingWhitespace) {\n end = true;\n break;\n }\n continue;\n }\n if (match.whitespace(node)) {\n end = true;\n }\n break;\n }\n return { start, end };\n}\n"],"names":["match","unifiedLatexTrimEnvironmentContents","visit","unifiedLatexTrimRoot"],"mappings":";;;;AASO,SAAS,KAAK,OAGnB;AACE,MAAI,CAAC,MAAM,QAAQ,KAAK,GAAG;AACf,YAAA,KAAK,kCAAkC,KAAK;AAC7C,WAAA;AAAA,EAAA;AAGX,QAAM,EAAE,aAAA,IAAiB,UAAU,KAAK;AACxC,QAAM,EAAE,WAAA,IAAe,QAAQ,KAAK;AAE7B,SAAA,EAAE,cAAc,WAAW;AACtC;AAKO,SAAS,UAAU,OAA6C;AACnE,QAAM,EAAE,MAAA,IAAU,qCAAqC,KAAK;AAEtD,QAAA,OAAO,GAAG,KAAK;AAIrB,aAAW,gBAAgB,OAAO;AAC9B,QAAI,CAACA,sBAAA,MAAM,QAAQ,YAAY,GAAG;AAC9B;AAAA,IAAA;AAEA,QAAA,aAAa,qBAAqB,aAAa,UAAU;AACzD,mBAAa,oBAAoB;AAAA,IAAA;AAKjC,QAAA,QAAQ,KAAK,aAAa,UAAU;AACpC,mBAAa,WAAW;AAAA,IAAA;AAAA,EAC5B;AAGG,SAAA,EAAE,cAAc,MAAM;AACjC;AAKO,SAAS,QAAQ,OAA2C;AAC/D,QAAM,EAAE,IAAA,IAAQ,qCAAqC,KAAK;AAE1D,QAAM,OAAO,MAAM,SAAS,KAAK,GAAG;AAGpC,WAAS,IAAI,MAAM,SAAS,GAAG,KAAK,GAAG,KAAK;AAClC,UAAA,gBAAgB,MAAM,CAAC;AAC7B,QAAI,CAACA,sBAAA,MAAM,QAAQ,aAAa,GAAG;AAC/B;AAAA,IAAA;AAIJ,WAAO,cAAc;AAQjB,QAAAA,sBAAA,MAAM,QAAQ,aAAa,KAC3B,cAAc,qBACd,CAAC,cAAc,UACjB;AACE,oBAAc,oBAAoB;AAAA,IAAA;AAAA,EACtC;AAGG,SAAA,EAAE,YAAY,IAAI;AAC7B;AAKA,SAAS,qCAAqC,KAG5C;AACE,MAAI,QAAQ;AACZ,MAAI,MAAM;AACV,aAAW,QAAQ,KAAK;AACpB,QAAIA,sBAAAA,MAAM,WAAW,IAAI,KAAKA,sBAAAA,MAAM,SAAS,IAAI,GAAG;AAChD;AAAA,IAAA,OACG;AACH;AAAA,IAAA;AAAA,EACJ;AAGA,MAAA,UAAU,IAAI,QAAQ;AACf,WAAA,EAAE,OAAO,KAAK,EAAE;AAAA,EAAA;AAI3B,WAAS,IAAI,IAAI,SAAS,GAAG,KAAK,GAAG,KAAK;AAChC,UAAA,OAAO,IAAI,CAAC;AAClB,QAAIA,sBAAAA,MAAM,WAAW,IAAI,KAAKA,sBAAAA,MAAM,SAAS,IAAI,GAAG;AAChD;AAAA,IAAA,OACG;AACH;AAAA,IAAA;AAAA,EACJ;AAGG,SAAA,EAAE,OAAO,IAAI;AACxB;AC3Ga,MAAA,sCAIT,SAASC,uCAAsC;AAC/C,SAAO,CAAC,SAAS;AACPC,gCAAA,MAAM,CAAC,SAAS;AACd,UAAA,EAAEF,sBAAAA,MAAM,KAAK,IAAI,KAAKA,sBAAAA,MAAM,eAAe,IAAI,IAAI;AACnD;AAAA,MAAA;AAKA,UAAA,YAAY,KAAK,QAAQ,CAAC;AAC9B,UAAIA,sBAAM,MAAA,QAAQ,SAAS,KAAK,UAAU,UAAU;AAChD,kBAAU,iBAAiB;AAC3B,gBAAQ,KAAK,OAAO;AAOd,cAAA,EAAE,iBAAiB,UAAU,KAAK,QAAQ,MAAM,CAAC,CAAC;AACnD,aAAA,QAAQ,OAAO,GAAG,YAAY;AAAA,MAAA,OAChC;AACH,aAAK,KAAK,OAAO;AAAA,MAAA;AAAA,IACrB,CACH;AAAA,EACL;AACJ;ACjCa,MAAA,uBACT,SAASG,wBAAuB;AAC5B,SAAO,CAAC,SAAS;AACb,SAAK,KAAK,OAAO;AAAA,EACrB;AACJ;ACPG,SAAS,wBAAwB,OAGtC;AACE,MAAI,QAAQ;AACZ,MAAI,MAAM;AACV,WAAS,IAAI,GAAG,IAAI,MAAM,QAAQ,KAAK;AAC7B,UAAA,OAAO,MAAM,CAAC;AAChB,QAAAH,sBAAA,MAAM,QAAQ,IAAI,GAAG;AAGrB,UAAI,KAAK,mBAAmB;AAChB,gBAAA;AACR;AAAA,MAAA;AAEJ;AAAA,IAAA;AAEA,QAAAA,sBAAA,MAAM,WAAW,IAAI,GAAG;AAChB,cAAA;AAAA,IAAA;AAEZ;AAAA,EAAA;AAEJ,WAAS,IAAI,MAAM,SAAS,GAAG,KAAK,GAAG,KAAK;AAClC,UAAA,OAAO,MAAM,CAAC;AAChB,QAAAA,sBAAA,MAAM,QAAQ,IAAI,GAAG;AACrB,UAAI,KAAK,mBAAmB;AAClB,cAAA;AACN;AAAA,MAAA;AAEJ;AAAA,IAAA;AAEA,QAAAA,sBAAA,MAAM,WAAW,IAAI,GAAG;AAClB,YAAA;AAAA,IAAA;AAEV;AAAA,EAAA;AAEG,SAAA,EAAE,OAAO,IAAI;AACxB;;;;;;;"} \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-util-trim/index.d.ts b/node_modules/@unified-latex/unified-latex-util-trim/index.d.ts new file mode 100644 index 0000000..2e6aa3f --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-util-trim/index.d.ts @@ -0,0 +1,53 @@ +import * as Ast from '@unified-latex/unified-latex-types'; +import { Plugin as Plugin_2 } from 'unified'; + +/** + * Returns whether the array has whitespace at the start/end. Comments with `leadingWhitespace === true` + * are counted as whitespace. Other comments are ignored. + */ +export declare function hasWhitespaceEquivalent(nodes: Ast.Node[]): { + start: boolean; + end: boolean; +}; + +declare type PluginOptions = void; + +declare type PluginOptions_2 = void; + +/** + * Trims whitespace and parbreaks from the start and end + * of an array. The number of trimmed nodes is returned. + * Special care is taken to preserve comments, though any whitespace + * before the first comment(s) or after the last comment(s) is trimmed. + */ +export declare function trim(nodes: Ast.Node[]): { + trimmedStart: number; + trimmedEnd: number; +}; + +/** + * Trim whitespace and parbreaks from the right of an array. + */ +export declare function trimEnd(nodes: Ast.Node[]): { + trimmedEnd: number; +}; + +/** + * Trim whitespace and parbreaks from the left of an array. + */ +export declare function trimStart(nodes: Ast.Node[]): { + trimmedStart: number; +}; + +/** + * Unified plugin to trim the whitespace from the start/end of any environments, including + * math environments. + */ +export declare const unifiedLatexTrimEnvironmentContents: Plugin_2; + +/** + * Unified plugin to trim the whitespace from the start/end of the root element. + */ +export declare const unifiedLatexTrimRoot: Plugin_2; + +export { } diff --git a/node_modules/@unified-latex/unified-latex-util-trim/index.js b/node_modules/@unified-latex/unified-latex-util-trim/index.js new file mode 100644 index 0000000..c1807fe --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-util-trim/index.js @@ -0,0 +1,130 @@ +import { match } from "@unified-latex/unified-latex-util-match"; +import { visit } from "@unified-latex/unified-latex-util-visit"; +function trim(nodes) { + if (!Array.isArray(nodes)) { + console.warn("Trying to trim a non-array ast", nodes); + return nodes; + } + const { trimmedStart } = trimStart(nodes); + const { trimmedEnd } = trimEnd(nodes); + return { trimmedStart, trimmedEnd }; +} +function trimStart(nodes) { + const { start } = amountOfLeadingAndTrailingWhitespace(nodes); + nodes.splice(0, start); + for (const leadingToken of nodes) { + if (!match.comment(leadingToken)) { + break; + } + if (leadingToken.leadingWhitespace || leadingToken.sameline) { + leadingToken.leadingWhitespace = false; + } + if (start > 0 && leadingToken.sameline) { + leadingToken.sameline = false; + } + } + return { trimmedStart: start }; +} +function trimEnd(nodes) { + const { end } = amountOfLeadingAndTrailingWhitespace(nodes); + nodes.splice(nodes.length - end, end); + for (let i = nodes.length - 1; i >= 0; i--) { + const trailingToken = nodes[i]; + if (!match.comment(trailingToken)) { + break; + } + delete trailingToken.suffixParbreak; + if (match.comment(trailingToken) && trailingToken.leadingWhitespace && !trailingToken.sameline) { + trailingToken.leadingWhitespace = false; + } + } + return { trimmedEnd: end }; +} +function amountOfLeadingAndTrailingWhitespace(ast) { + let start = 0; + let end = 0; + for (const node of ast) { + if (match.whitespace(node) || match.parbreak(node)) { + start++; + } else { + break; + } + } + if (start === ast.length) { + return { start, end: 0 }; + } + for (let i = ast.length - 1; i >= 0; i--) { + const node = ast[i]; + if (match.whitespace(node) || match.parbreak(node)) { + end++; + } else { + break; + } + } + return { start, end }; +} +const unifiedLatexTrimEnvironmentContents = function unifiedLatexTrimEnvironmentContents2() { + return (tree) => { + visit(tree, (node) => { + if (!(match.math(node) || match.anyEnvironment(node))) { + return; + } + let firstNode = node.content[0]; + if (match.comment(firstNode) && firstNode.sameline) { + firstNode.suffixParbreak = false; + trimEnd(node.content); + const { trimmedStart } = trimStart(node.content.slice(1)); + node.content.splice(1, trimmedStart); + } else { + trim(node.content); + } + }); + }; +}; +const unifiedLatexTrimRoot = function unifiedLatexTrimRoot2() { + return (tree) => { + trim(tree.content); + }; +}; +function hasWhitespaceEquivalent(nodes) { + let start = false; + let end = false; + for (let i = 0; i < nodes.length; i++) { + const node = nodes[i]; + if (match.comment(node)) { + if (node.leadingWhitespace) { + start = true; + break; + } + continue; + } + if (match.whitespace(node)) { + start = true; + } + break; + } + for (let j = nodes.length - 1; j >= 0; j--) { + const node = nodes[j]; + if (match.comment(node)) { + if (node.leadingWhitespace) { + end = true; + break; + } + continue; + } + if (match.whitespace(node)) { + end = true; + } + break; + } + return { start, end }; +} +export { + hasWhitespaceEquivalent, + trim, + trimEnd, + trimStart, + unifiedLatexTrimEnvironmentContents, + unifiedLatexTrimRoot +}; +//# sourceMappingURL=index.js.map diff --git a/node_modules/@unified-latex/unified-latex-util-trim/index.js.map b/node_modules/@unified-latex/unified-latex-util-trim/index.js.map new file mode 100644 index 0000000..3e2ed4b --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-util-trim/index.js.map @@ -0,0 +1 @@ +{"version":3,"file":"index.js","sources":["../libs/trim.ts","../libs/unified-latex-trim-environment-contents.ts","../libs/unified-latex-trim-root.ts","../libs/has-whitespace-equivalent.ts"],"sourcesContent":["import * as Ast from \"@unified-latex/unified-latex-types\";\nimport { match } from \"@unified-latex/unified-latex-util-match\";\n\n/**\n * Trims whitespace and parbreaks from the start and end\n * of an array. The number of trimmed nodes is returned.\n * Special care is taken to preserve comments, though any whitespace\n * before the first comment(s) or after the last comment(s) is trimmed.\n */\nexport function trim(nodes: Ast.Node[]): {\n trimmedStart: number;\n trimmedEnd: number;\n} {\n if (!Array.isArray(nodes)) {\n console.warn(\"Trying to trim a non-array ast\", nodes);\n return nodes;\n }\n\n const { trimmedStart } = trimStart(nodes);\n const { trimmedEnd } = trimEnd(nodes);\n\n return { trimmedStart, trimmedEnd };\n}\n\n/**\n * Trim whitespace and parbreaks from the left of an array.\n */\nexport function trimStart(nodes: Ast.Node[]): { trimmedStart: number } {\n const { start } = amountOfLeadingAndTrailingWhitespace(nodes);\n\n nodes.splice(0, start);\n\n // If there are comments at the start, they might have leading whitespace.\n // This leading whitespace should be trimmed\n for (const leadingToken of nodes) {\n if (!match.comment(leadingToken)) {\n break;\n }\n if (leadingToken.leadingWhitespace || leadingToken.sameline) {\n leadingToken.leadingWhitespace = false;\n }\n // Special care must be taken. If the comment was on the same line as a\n // parskip, it will no longer be on the same line after the trimming.\n // Thus, we must modify the comment.\n if (start > 0 && leadingToken.sameline) {\n leadingToken.sameline = false;\n }\n }\n\n return { trimmedStart: start };\n}\n\n/**\n * Trim whitespace and parbreaks from the right of an array.\n */\nexport function trimEnd(nodes: Ast.Node[]): { trimmedEnd: number } {\n const { end } = amountOfLeadingAndTrailingWhitespace(nodes);\n\n nodes.splice(nodes.length - end, end);\n\n // Trim off any spaces belonging to trailing comments\n for (let i = nodes.length - 1; i >= 0; i--) {\n const trailingToken = nodes[i];\n if (!match.comment(trailingToken)) {\n break;\n }\n\n // Any parbreaks have been trimmed, so there is no suffix parbreak here!\n delete trailingToken.suffixParbreak;\n\n // We don't trim spaces before trailing same-line comments. This is a stylistic choice\n // so that\n // `foo %xxx` does not become `foo%xxx`.\n // The latter is strictly \"correct\" for a trim function, but it is prettier to format\n // code preserving the space before the sameline comment\n if (\n match.comment(trailingToken) &&\n trailingToken.leadingWhitespace &&\n !trailingToken.sameline\n ) {\n trailingToken.leadingWhitespace = false;\n }\n }\n\n return { trimmedEnd: end };\n}\n\n/**\n * Returns the number of whitespace/parbreak nodes at the start and end of an array.\n */\nfunction amountOfLeadingAndTrailingWhitespace(ast: Ast.Node[]): {\n start: number;\n end: number;\n} {\n let start = 0;\n let end = 0;\n for (const node of ast) {\n if (match.whitespace(node) || match.parbreak(node)) {\n start++;\n } else {\n break;\n }\n }\n\n if (start === ast.length) {\n return { start, end: 0 };\n }\n\n // Find the padding on the right\n for (let i = ast.length - 1; i >= 0; i--) {\n const node = ast[i];\n if (match.whitespace(node) || match.parbreak(node)) {\n end++;\n } else {\n break;\n }\n }\n\n return { start, end };\n}\n","import type { Plugin } from \"unified\";\nimport * as Ast from \"@unified-latex/unified-latex-types\";\nimport { match } from \"@unified-latex/unified-latex-util-match\";\nimport { visit } from \"@unified-latex/unified-latex-util-visit\";\nimport { trim, trimEnd, trimStart } from \"./trim\";\n\ntype PluginOptions = void;\n\n/**\n * Unified plugin to trim the whitespace from the start/end of any environments, including\n * math environments.\n */\nexport const unifiedLatexTrimEnvironmentContents: Plugin<\n PluginOptions[],\n Ast.Root,\n Ast.Root\n> = function unifiedLatexTrimEnvironmentContents() {\n return (tree) => {\n visit(tree, (node) => {\n if (!(match.math(node) || match.anyEnvironment(node))) {\n return;\n }\n\n // If the first thing in the environment is a sameline comment,\n // we actually want to start trimming *after* it.\n let firstNode = node.content[0];\n if (match.comment(firstNode) && firstNode.sameline) {\n firstNode.suffixParbreak = false;\n trimEnd(node.content);\n\n // We play a nasty trick here. This call to `trimStart`\n // will actually modify `node.content` if `node.content.slice(1)` starts\n // with a comment that has leading whitespace (it will remove that whitespace).\n // However, it won't remove any elements from `node.content`; we need\n // to do that ourselves.\n const { trimmedStart } = trimStart(node.content.slice(1));\n node.content.splice(1, trimmedStart);\n } else {\n trim(node.content);\n }\n });\n };\n};\n","import type { Plugin } from \"unified\";\nimport * as Ast from \"@unified-latex/unified-latex-types\";\nimport { trim } from \"./trim\";\n\ntype PluginOptions = void;\n\n/**\n * Unified plugin to trim the whitespace from the start/end of the root element.\n */\nexport const unifiedLatexTrimRoot: Plugin =\n function unifiedLatexTrimRoot() {\n return (tree) => {\n trim(tree.content);\n };\n };\n","import * as Ast from \"@unified-latex/unified-latex-types\";\nimport { match } from \"@unified-latex/unified-latex-util-match\";\n\n/**\n * Returns whether the array has whitespace at the start/end. Comments with `leadingWhitespace === true`\n * are counted as whitespace. Other comments are ignored.\n */\nexport function hasWhitespaceEquivalent(nodes: Ast.Node[]): {\n start: boolean;\n end: boolean;\n} {\n let start = false;\n let end = false;\n for (let i = 0; i < nodes.length; i++) {\n const node = nodes[i];\n if (match.comment(node)) {\n // A comment with leading whitespace will render with leading whitespace,\n // so if we encounter one, we should consider ourselves to have leading whitespace.\n if (node.leadingWhitespace) {\n start = true;\n break;\n }\n continue;\n }\n if (match.whitespace(node)) {\n start = true;\n }\n break;\n }\n for (let j = nodes.length - 1; j >= 0; j--) {\n const node = nodes[j];\n if (match.comment(node)) {\n if (node.leadingWhitespace) {\n end = true;\n break;\n }\n continue;\n }\n if (match.whitespace(node)) {\n end = true;\n }\n break;\n }\n return { start, end };\n}\n"],"names":["unifiedLatexTrimEnvironmentContents","unifiedLatexTrimRoot"],"mappings":";;AASO,SAAS,KAAK,OAGnB;AACE,MAAI,CAAC,MAAM,QAAQ,KAAK,GAAG;AACf,YAAA,KAAK,kCAAkC,KAAK;AAC7C,WAAA;AAAA,EAAA;AAGX,QAAM,EAAE,aAAA,IAAiB,UAAU,KAAK;AACxC,QAAM,EAAE,WAAA,IAAe,QAAQ,KAAK;AAE7B,SAAA,EAAE,cAAc,WAAW;AACtC;AAKO,SAAS,UAAU,OAA6C;AACnE,QAAM,EAAE,MAAA,IAAU,qCAAqC,KAAK;AAEtD,QAAA,OAAO,GAAG,KAAK;AAIrB,aAAW,gBAAgB,OAAO;AAC9B,QAAI,CAAC,MAAM,QAAQ,YAAY,GAAG;AAC9B;AAAA,IAAA;AAEA,QAAA,aAAa,qBAAqB,aAAa,UAAU;AACzD,mBAAa,oBAAoB;AAAA,IAAA;AAKjC,QAAA,QAAQ,KAAK,aAAa,UAAU;AACpC,mBAAa,WAAW;AAAA,IAAA;AAAA,EAC5B;AAGG,SAAA,EAAE,cAAc,MAAM;AACjC;AAKO,SAAS,QAAQ,OAA2C;AAC/D,QAAM,EAAE,IAAA,IAAQ,qCAAqC,KAAK;AAE1D,QAAM,OAAO,MAAM,SAAS,KAAK,GAAG;AAGpC,WAAS,IAAI,MAAM,SAAS,GAAG,KAAK,GAAG,KAAK;AAClC,UAAA,gBAAgB,MAAM,CAAC;AAC7B,QAAI,CAAC,MAAM,QAAQ,aAAa,GAAG;AAC/B;AAAA,IAAA;AAIJ,WAAO,cAAc;AAQjB,QAAA,MAAM,QAAQ,aAAa,KAC3B,cAAc,qBACd,CAAC,cAAc,UACjB;AACE,oBAAc,oBAAoB;AAAA,IAAA;AAAA,EACtC;AAGG,SAAA,EAAE,YAAY,IAAI;AAC7B;AAKA,SAAS,qCAAqC,KAG5C;AACE,MAAI,QAAQ;AACZ,MAAI,MAAM;AACV,aAAW,QAAQ,KAAK;AACpB,QAAI,MAAM,WAAW,IAAI,KAAK,MAAM,SAAS,IAAI,GAAG;AAChD;AAAA,IAAA,OACG;AACH;AAAA,IAAA;AAAA,EACJ;AAGA,MAAA,UAAU,IAAI,QAAQ;AACf,WAAA,EAAE,OAAO,KAAK,EAAE;AAAA,EAAA;AAI3B,WAAS,IAAI,IAAI,SAAS,GAAG,KAAK,GAAG,KAAK;AAChC,UAAA,OAAO,IAAI,CAAC;AAClB,QAAI,MAAM,WAAW,IAAI,KAAK,MAAM,SAAS,IAAI,GAAG;AAChD;AAAA,IAAA,OACG;AACH;AAAA,IAAA;AAAA,EACJ;AAGG,SAAA,EAAE,OAAO,IAAI;AACxB;AC3Ga,MAAA,sCAIT,SAASA,uCAAsC;AAC/C,SAAO,CAAC,SAAS;AACP,UAAA,MAAM,CAAC,SAAS;AACd,UAAA,EAAE,MAAM,KAAK,IAAI,KAAK,MAAM,eAAe,IAAI,IAAI;AACnD;AAAA,MAAA;AAKA,UAAA,YAAY,KAAK,QAAQ,CAAC;AAC9B,UAAI,MAAM,QAAQ,SAAS,KAAK,UAAU,UAAU;AAChD,kBAAU,iBAAiB;AAC3B,gBAAQ,KAAK,OAAO;AAOd,cAAA,EAAE,iBAAiB,UAAU,KAAK,QAAQ,MAAM,CAAC,CAAC;AACnD,aAAA,QAAQ,OAAO,GAAG,YAAY;AAAA,MAAA,OAChC;AACH,aAAK,KAAK,OAAO;AAAA,MAAA;AAAA,IACrB,CACH;AAAA,EACL;AACJ;ACjCa,MAAA,uBACT,SAASC,wBAAuB;AAC5B,SAAO,CAAC,SAAS;AACb,SAAK,KAAK,OAAO;AAAA,EACrB;AACJ;ACPG,SAAS,wBAAwB,OAGtC;AACE,MAAI,QAAQ;AACZ,MAAI,MAAM;AACV,WAAS,IAAI,GAAG,IAAI,MAAM,QAAQ,KAAK;AAC7B,UAAA,OAAO,MAAM,CAAC;AAChB,QAAA,MAAM,QAAQ,IAAI,GAAG;AAGrB,UAAI,KAAK,mBAAmB;AAChB,gBAAA;AACR;AAAA,MAAA;AAEJ;AAAA,IAAA;AAEA,QAAA,MAAM,WAAW,IAAI,GAAG;AAChB,cAAA;AAAA,IAAA;AAEZ;AAAA,EAAA;AAEJ,WAAS,IAAI,MAAM,SAAS,GAAG,KAAK,GAAG,KAAK;AAClC,UAAA,OAAO,MAAM,CAAC;AAChB,QAAA,MAAM,QAAQ,IAAI,GAAG;AACrB,UAAI,KAAK,mBAAmB;AAClB,cAAA;AACN;AAAA,MAAA;AAEJ;AAAA,IAAA;AAEA,QAAA,MAAM,WAAW,IAAI,GAAG;AAClB,YAAA;AAAA,IAAA;AAEV;AAAA,EAAA;AAEG,SAAA,EAAE,OAAO,IAAI;AACxB;"} \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-util-trim/package.json b/node_modules/@unified-latex/unified-latex-util-trim/package.json new file mode 100644 index 0000000..e29c8d9 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-util-trim/package.json @@ -0,0 +1,54 @@ +{ + "name": "@unified-latex/unified-latex-util-trim", + "version": "1.8.2", + "description": "Functions for modifying a unified-latex AST", + "main": "index.js", + "type": "module", + "dependencies": { + "@unified-latex/unified-latex-types": "^1.8.0", + "@unified-latex/unified-latex-util-match": "^1.8.0", + "@unified-latex/unified-latex-util-visit": "^1.8.2", + "unified": "^10.1.2" + }, + "repository": { + "type": "git", + "url": "git+https://github.com/siefkenj/unified-latex.git" + }, + "keywords": [ + "pegjs", + "latex", + "parser", + "prettier", + "unified-latex", + "unified" + ], + "author": "Jason Siefken", + "license": "MIT", + "bugs": { + "url": "https://github.com/siefkenj/unified-latex/issues" + }, + "homepage": "https://github.com/siefkenj/unified-latex#readme", + "exports": { + ".": { + "import": "./index.js", + "require": "./index.cjs", + "types": "./index.d.ts" + }, + "./*js": "./*js", + "./*": { + "import": "./*/index.js", + "require": "./*/index.cjs", + "types": "./*/index.d.ts" + }, + "./*/index": { + "import": "./*/index.js", + "require": "./*/index.cjs" + } + }, + "files": [ + "**/*ts", + "**/*js", + "**/*.map", + "**/*.json" + ] +} \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-util-visit/README.md b/node_modules/@unified-latex/unified-latex-util-visit/README.md new file mode 100644 index 0000000..0fa493d --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-util-visit/README.md @@ -0,0 +1,122 @@ + + + + +# unified-latex-util-visit + +## What is this? + +Functions to traverse a `unified-latex` Abstract Syntax Tree (AST). `visit` is +very similar to [estree-util-visit](https://github.com/syntax-tree/estree-util-visit). + +## When should I use this? + +If you want to recursively replace particular AST nodes. + +## Install + +```bash +npm install @unified-latex/unified-latex-util-visit +``` + +This package contains both esm and commonjs exports. To explicitly access the esm export, +import the `.js` file. To explicitly access the commonjs export, import the `.cjs` file. + +# Functions + +## `visit(tree, visitor, options)` + +Visit children of tree which pass a test + +```typescript +function visit( + tree: Ast.Ast, + visitor: + | Visitor, Opts>> + | Visitors< + NarrowArraysBasedOnOptions, Opts> + >, + options: VisitOptions +): void; +``` + +**Parameters** + +| Param | Type | Description | +| :------ | :-------------------------------- | ----------------------------- | +| tree | `Ast.Ast` | Abstract syntax tree to walk | +| visitor | Omitted | Function to run for each node | +| options | `VisitOptions` | *see below* | + +where + +```typescript +type VisitOptions = { + startingContext?: VisitorContext; + /** + * Type guard for types that are passed to the `visitor` function. + */ + test?: (node: Ast.Ast, info: VisitInfo) => boolean; + /** + * Whether arrays will be sent to the `visitor` function. If falsy, + * only nodes will be past to `visitor`. + */ + includeArrays?: boolean; +}; +``` + +# Constants + +| Name | Type | Description | +| :--------- | :------- | :----------------------------------- | +| `CONTINUE` | `Symbol` | Continue traversing as normal | +| `EXIT` | `Symbol` | Stop traversing immediately | +| `SKIP` | `Symbol` | Do not traverse this node’s children | + +# Types + +## `VisitInfo` + +```typescript +export type VisitInfo = { + /** + * If the element was accessed via an attribute, the attribute key is specified. + */ + readonly key: string | undefined; + /** + * If the element was accessed in an array, the index is specified. + */ + readonly index: number | undefined; + /** + * A list of ancestor nodes, `[parent, grandparent, great-grandparent, ...]` + */ + readonly parents: (Ast.Node | Ast.Argument)[]; + /** + * If the element was accessed in an array, the array that it is part of. + */ + readonly containingArray: (Ast.Node | Ast.Argument)[] | undefined; + /** + * The LaTeX context of the current match. + */ + readonly context: VisitorContext; +}; +``` + +## `VisitorContext` + +```typescript +export type VisitorContext = { + /** + * Whether the node is being processed in math mode. + * + * This happens when the node is a director or indirect child + * of a math environment (e.g. `$abc$`), but not when an environment + * re-establishes text mode (e.g. `$\text{abc}$`) + */ + inMathMode?: boolean; + /** + * Whether the node has any ancestor that is processed in math mode. + */ + hasMathModeAncestor?: boolean; +}; +``` diff --git a/node_modules/@unified-latex/unified-latex-util-visit/index.cjs b/node_modules/@unified-latex/unified-latex-util-visit/index.cjs new file mode 100644 index 0000000..2f6ce5f --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-util-visit/index.cjs @@ -0,0 +1,168 @@ +"use strict"; +Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" }); +const unifiedLatexUtilMatch = require("@unified-latex/unified-latex-util-match"); +function listMathChildren(node) { + const NULL_RETURN = { enter: [], leave: [] }; + if (Array.isArray(node)) { + return NULL_RETURN; + } + if (unifiedLatexUtilMatch.match.math(node)) { + return { enter: ["content"], leave: [] }; + } + const renderInfo = node._renderInfo || {}; + if (renderInfo.inMathMode == null) { + return NULL_RETURN; + } + if (unifiedLatexUtilMatch.match.macro(node)) { + if (renderInfo.inMathMode === true) { + return { enter: ["args"], leave: [] }; + } else if (renderInfo.inMathMode === false) { + return { enter: [], leave: ["args"] }; + } + } + if (unifiedLatexUtilMatch.match.environment(node)) { + if (renderInfo.inMathMode === true) { + return { enter: ["content"], leave: [] }; + } else { + return { enter: [], leave: ["content"] }; + } + } + return NULL_RETURN; +} +const CONTINUE = Symbol("continue"); +const SKIP = Symbol("skip"); +const EXIT = Symbol("exit"); +const DEFAULT_CONTEXT = { + inMathMode: false, + hasMathModeAncestor: false +}; +function visit(tree, visitor, options) { + const { + startingContext = DEFAULT_CONTEXT, + test = () => true, + includeArrays = false + } = options || {}; + let enter; + let leave; + if (typeof visitor === "function") { + enter = visitor; + } else if (visitor && typeof visitor === "object") { + enter = visitor.enter; + leave = visitor.leave; + } + walk(tree, { + key: void 0, + index: void 0, + parents: [], + containingArray: void 0, + context: { ...startingContext } + }); + function walk(node, { key, index, parents, context, containingArray }) { + const nodePassesTest = includeArrays ? test(node, { key, index, parents, context, containingArray }) : !Array.isArray(node) && test(node, { key, index, parents, context, containingArray }); + const result = enter && nodePassesTest ? toResult( + enter(node, { + key, + index, + parents, + context, + containingArray + }) + ) : [CONTINUE]; + if (result[0] === EXIT) { + return result; + } + if (result[0] === SKIP) { + return leave && nodePassesTest ? toResult( + leave(node, { + key, + index, + parents, + context, + containingArray + }) + ) : result; + } + if (Array.isArray(node)) { + for (let index2 = 0; index2 > -1 && index2 < node.length; index2++) { + const item = node[index2]; + const result2 = walk(item, { + key, + index: index2, + parents, + context, + containingArray: node + }); + if (result2[0] === EXIT) { + return result2; + } + if (typeof result2[1] === "number") { + index2 = result2[1] - 1; + } + } + } else { + let childProps = ["content", "args"]; + switch (node.type) { + case "macro": + childProps = ["args"]; + break; + case "comment": + case "string": + case "verb": + case "verbatim": + childProps = []; + break; + } + const mathModeProps = listMathChildren(node); + for (const key2 of childProps) { + const value = node[key2]; + const grandparents = [node].concat(parents); + if (value == null) { + continue; + } + const newContext = { ...context }; + if (mathModeProps.enter.includes(key2)) { + newContext.inMathMode = true; + newContext.hasMathModeAncestor = true; + } else if (mathModeProps.leave.includes(key2)) { + newContext.inMathMode = false; + } + const result2 = walk(value, { + key: key2, + index: void 0, + parents: grandparents, + context: newContext, + containingArray: void 0 + }); + if (result2[0] === EXIT) { + return result2; + } + } + } + return leave && nodePassesTest ? toResult( + leave(node, { + key, + index, + parents, + context, + containingArray + }) + ) : result; + } +} +function toResult(value) { + if (value == null) { + return [CONTINUE]; + } + if (Array.isArray(value)) { + return value; + } + if (typeof value === "number") { + return [CONTINUE, value]; + } + return [value]; +} +exports.CONTINUE = CONTINUE; +exports.EXIT = EXIT; +exports.SKIP = SKIP; +exports.visit = visit; +//# sourceMappingURL=index.cjs.map diff --git a/node_modules/@unified-latex/unified-latex-util-visit/index.cjs.map b/node_modules/@unified-latex/unified-latex-util-visit/index.cjs.map new file mode 100644 index 0000000..5561e6c --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-util-visit/index.cjs.map @@ -0,0 +1 @@ +{"version":3,"file":"index.cjs","sources":["../libs/list-math-children.ts","../libs/visit.ts"],"sourcesContent":["import * as Ast from \"@unified-latex/unified-latex-types\";\nimport { match } from \"@unified-latex/unified-latex-util-match\";\n\n/**\n * List all props of the current node that should be processed\n * in math mode or not in math mode. If math mode is not specified in the node's render\n * info, empty lists are returned.\n *\n * For example `\\text{foo}` will report that `args` should *not* be processed in math mode,\n * since it's contents should always be processed in text mode.\n */\nexport function listMathChildren(node: Ast.Ast): {\n enter: string[];\n leave: string[];\n} {\n const NULL_RETURN = { enter: [], leave: [] };\n if (Array.isArray(node)) {\n return NULL_RETURN;\n }\n if (match.math(node)) {\n // When we enter a math environment, our content is always\n // considered math mode\n return { enter: [\"content\"], leave: [] };\n }\n\n const renderInfo: { inMathMode?: boolean } = node._renderInfo || {};\n if (renderInfo.inMathMode == null) {\n return NULL_RETURN;\n }\n if (match.macro(node)) {\n if (renderInfo.inMathMode === true) {\n return { enter: [\"args\"], leave: [] };\n } else if (renderInfo.inMathMode === false) {\n return { enter: [], leave: [\"args\"] };\n }\n }\n if (match.environment(node)) {\n if (renderInfo.inMathMode === true) {\n return { enter: [\"content\"], leave: [] };\n } else {\n return { enter: [], leave: [\"content\"] };\n }\n }\n return NULL_RETURN;\n}\n","import * as Ast from \"@unified-latex/unified-latex-types\";\nimport { listMathChildren } from \"./list-math-children\";\n\nexport type VisitorContext = {\n /**\n * Whether the node is being processed in math mode.\n *\n * This happens when the node is a director or indirect child\n * of a math environment (e.g. `$abc$`), but not when an environment\n * re-establishes text mode (e.g. `$\\text{abc}$`)\n */\n inMathMode?: boolean;\n /**\n * Whether the node has any ancestor that is processed in math mode.\n */\n hasMathModeAncestor?: boolean;\n};\n\ntype GetGuard = T extends (x: any, ...y: any[]) => x is infer R ? R : never;\n/**\n * Gets the type that a type-guard function is guarding. If\n * the guard type cannot be determined, the input type is returned.\n */\ntype GuardTypeOf boolean> =\n GetGuard extends never\n ? T extends (x: infer A) => any\n ? A\n : never\n : GetGuard;\n\n/**\n * Extracts the guard type from the `test` function provided in a\n * `VisitOptions` argument.\n */\ntype GuardFromOptions<\n Opts extends VisitOptions,\n PossibleTypes = Ast.Ast\n> = Opts extends {\n test: infer R;\n}\n ? R extends (x: any, ...y: any[]) => boolean\n ? // A guard like `typeof Array.isArray` will return `any[]` as the type.\n // This type cannot be narrowed, so instead we use it to pick from\n // the set of all possible types.\n Extract>\n : PossibleTypes\n : PossibleTypes;\n\n/**\n * Narrow the type `T` based on the `VisitOptions` supplied. If `{includeArrays: false}`\n * is specified in the `VisitOptions`, then arrays are excluded from `T`.\n */\ntype NarrowArraysBasedOnOptions = Opts extends {\n includeArrays: infer A;\n}\n ? A extends true\n ? T\n : Exclude\n : Exclude;\n\n/**\n * Get the type of the parameter to the `Visitor` function based on the\n * `VisitOptions` that are supplied.\n */\ntype VisitorTypeFromOptions =\n NarrowArraysBasedOnOptions, Opts>;\n\n/**\n * Continue traversing as normal\n */\nexport const CONTINUE = Symbol(\"continue\");\n/**\n * Do not traverse this node’s children\n */\nexport const SKIP = Symbol(\"skip\");\n/**\n * Stop traversing immediately\n */\nexport const EXIT = Symbol(\"exit\");\n\ntype Action = typeof CONTINUE | typeof SKIP | typeof EXIT;\ntype Index = number;\ntype ActionTuple = [Action] | [typeof SKIP, Index] | [typeof CONTINUE, Index];\n\n/**\n * A visitor takes a `node`, `key`, `index`, and ...\n *\n * @param key - The key of the parent that we were accessed through.\n */\ntype Visitor = (\n node: T,\n info: VisitInfo\n) => null | undefined | Action | Index | ActionTuple | void;\ntype Visitors = { enter?: Visitor; leave?: Visitor };\n\ntype VisitOptions = {\n startingContext?: VisitorContext;\n /**\n * Type guard for types that are passed to the `visitor` function.\n */\n test?: (node: Ast.Ast, info: VisitInfo) => boolean;\n /**\n * Whether arrays will be sent to the `visitor` function. If falsy,\n * only nodes will be past to `visitor`.\n */\n includeArrays?: boolean;\n};\n\nconst DEFAULT_CONTEXT: VisitorContext = {\n inMathMode: false,\n hasMathModeAncestor: false,\n};\n\nexport type VisitInfo = {\n /**\n * If the element was accessed via an attribute, the attribute key is specified.\n */\n readonly key: string | undefined;\n /**\n * If the element was accessed in an array, the index is specified.\n */\n readonly index: number | undefined;\n /**\n * A list of ancestor nodes, `[parent, grandparent, great-grandparent, ...]`\n */\n readonly parents: (Ast.Node | Ast.Argument)[];\n /**\n * If the element was accessed in an array, the array that it is part of.\n */\n readonly containingArray: (Ast.Node | Ast.Argument)[] | undefined;\n /**\n * The LaTeX context of the current match.\n */\n readonly context: VisitorContext;\n};\n\n/**\n * Visit children of tree which pass a test\n *\n * @param {Node} tree Abstract syntax tree to walk\n * @param {Visitor|Visitors} [visitor] Function to run for each node\n */\nexport function visit(\n tree: Ast.Ast,\n visitor:\n | Visitor>\n | Visitors>,\n options?: Opts\n) {\n const {\n startingContext = DEFAULT_CONTEXT,\n test = () => true,\n includeArrays = false,\n } = options || {};\n let enter: Visitor> | undefined;\n let leave: Visitor> | undefined;\n\n if (typeof visitor === \"function\") {\n enter = visitor;\n } else if (visitor && typeof visitor === \"object\") {\n enter = visitor.enter;\n leave = visitor.leave;\n }\n\n walk(tree, {\n key: undefined,\n index: undefined,\n parents: [],\n containingArray: undefined,\n context: { ...startingContext },\n });\n\n /**\n * @param {Node} node\n * @param {string?} key\n * @param {number?} index\n * @param {Array.} parents\n */\n function walk(\n node: Ast.Ast,\n { key, index, parents, context, containingArray }: VisitInfo\n ): ActionTuple {\n const nodePassesTest = includeArrays\n ? test(node, { key, index, parents, context, containingArray })\n : !Array.isArray(node) &&\n test(node, { key, index, parents, context, containingArray });\n\n const result: ActionTuple =\n enter && nodePassesTest\n ? toResult(\n enter(node as any, {\n key,\n index,\n parents,\n context,\n containingArray,\n })\n )\n : [CONTINUE];\n\n if (result[0] === EXIT) {\n return result;\n }\n\n if (result[0] === SKIP) {\n return leave && nodePassesTest\n ? toResult(\n leave(node as any, {\n key,\n index,\n parents,\n context,\n containingArray,\n })\n )\n : result;\n }\n\n if (Array.isArray(node)) {\n // The `value` array might be modified in place as we traverse it, so\n // we use a traditional for loop.\n for (let index = 0; index > -1 && index < node.length; index++) {\n const item = node[index];\n const result = walk(item, {\n key,\n index,\n parents,\n context,\n containingArray: node,\n });\n if (result[0] === EXIT) {\n return result;\n }\n if (typeof result[1] === \"number\") {\n // The for loop will increment i every pass. However,\n // if an index was returned, that's where we want to start next time.\n index = result[1] - 1;\n }\n }\n } else {\n // We don't want to recursively apply to the `content`\n // of all types (e.g., comments and macros), so specify\n // a blacklist.\n let childProps: (\"content\" | \"args\")[] = [\"content\", \"args\"];\n switch (node.type) {\n case \"macro\":\n childProps = [\"args\"];\n break;\n case \"comment\":\n case \"string\":\n case \"verb\":\n case \"verbatim\":\n childProps = [];\n break;\n default:\n break;\n }\n\n const mathModeProps = listMathChildren(node);\n for (const key of childProps) {\n const value = node[key as keyof typeof node] as\n | Ast.Ast\n | undefined;\n const grandparents = [node].concat(parents);\n\n if (value == null) {\n continue;\n }\n\n // We may switch in/out of math mode as we pass to node[key]\n const newContext = { ...context };\n if (mathModeProps.enter.includes(key)) {\n newContext.inMathMode = true;\n newContext.hasMathModeAncestor = true;\n } else if (mathModeProps.leave.includes(key)) {\n newContext.inMathMode = false;\n }\n\n const result = walk(value, {\n key,\n index: undefined,\n parents: grandparents,\n context: newContext,\n containingArray: undefined,\n });\n if (result[0] === EXIT) {\n return result;\n }\n }\n }\n\n return leave && nodePassesTest\n ? toResult(\n leave(node as any, {\n key,\n index,\n parents,\n context,\n containingArray,\n })\n )\n : result;\n }\n}\n\n/**\n * Ensures a result is an `ActionTuple`s\n */\nfunction toResult(\n value: null | undefined | void | Action | Index | ActionTuple\n): ActionTuple {\n if (value == null) {\n return [CONTINUE];\n }\n\n if (Array.isArray(value)) {\n return value;\n }\n\n if (typeof value === \"number\") {\n return [CONTINUE, value];\n }\n\n return [value];\n}\n"],"names":["match","index","result","key"],"mappings":"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"} \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-util-visit/index.d.ts b/node_modules/@unified-latex/unified-latex-util-visit/index.d.ts new file mode 100644 index 0000000..5d6311e --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-util-visit/index.d.ts @@ -0,0 +1,125 @@ +import * as Ast from '@unified-latex/unified-latex-types'; + +declare type Action = typeof CONTINUE | typeof SKIP | typeof EXIT; + +declare type ActionTuple = [Action] | [typeof SKIP, Index] | [typeof CONTINUE, Index]; + +/** + * Continue traversing as normal + */ +export declare const CONTINUE: unique symbol; + +/** + * Stop traversing immediately + */ +export declare const EXIT: unique symbol; + +declare type GetGuard = T extends (x: any, ...y: any[]) => x is infer R ? R : never; + +/** + * Extracts the guard type from the `test` function provided in a + * `VisitOptions` argument. + */ +declare type GuardFromOptions = Opts extends { + test: infer R; +} ? R extends (x: any, ...y: any[]) => boolean ? Extract> : PossibleTypes : PossibleTypes; + +/** + * Gets the type that a type-guard function is guarding. If + * the guard type cannot be determined, the input type is returned. + */ +declare type GuardTypeOf boolean> = GetGuard extends never ? T extends (x: infer A) => any ? A : never : GetGuard; + +declare type Index = number; + +/** + * Narrow the type `T` based on the `VisitOptions` supplied. If `{includeArrays: false}` + * is specified in the `VisitOptions`, then arrays are excluded from `T`. + */ +declare type NarrowArraysBasedOnOptions = Opts extends { + includeArrays: infer A; +} ? A extends true ? T : Exclude : Exclude; + +/** + * Do not traverse this node’s children + */ +export declare const SKIP: unique symbol; + +/** + * Visit children of tree which pass a test + * + * @param {Node} tree Abstract syntax tree to walk + * @param {Visitor|Visitors} [visitor] Function to run for each node + */ +export declare function visit(tree: Ast.Ast, visitor: Visitor> | Visitors>, options?: Opts): void; + +export declare type VisitInfo = { + /** + * If the element was accessed via an attribute, the attribute key is specified. + */ + readonly key: string | undefined; + /** + * If the element was accessed in an array, the index is specified. + */ + readonly index: number | undefined; + /** + * A list of ancestor nodes, `[parent, grandparent, great-grandparent, ...]` + */ + readonly parents: (Ast.Node | Ast.Argument)[]; + /** + * If the element was accessed in an array, the array that it is part of. + */ + readonly containingArray: (Ast.Node | Ast.Argument)[] | undefined; + /** + * The LaTeX context of the current match. + */ + readonly context: VisitorContext; +}; + +declare type VisitOptions = { + startingContext?: VisitorContext; + /** + * Type guard for types that are passed to the `visitor` function. + */ + test?: (node: Ast.Ast, info: VisitInfo) => boolean; + /** + * Whether arrays will be sent to the `visitor` function. If falsy, + * only nodes will be past to `visitor`. + */ + includeArrays?: boolean; +}; + +/** + * A visitor takes a `node`, `key`, `index`, and ... + * + * @param key - The key of the parent that we were accessed through. + */ +declare type Visitor = (node: T, info: VisitInfo) => null | undefined | Action | Index | ActionTuple | void; + +export declare type VisitorContext = { + /** + * Whether the node is being processed in math mode. + * + * This happens when the node is a director or indirect child + * of a math environment (e.g. `$abc$`), but not when an environment + * re-establishes text mode (e.g. `$\text{abc}$`) + */ + inMathMode?: boolean; + /** + * Whether the node has any ancestor that is processed in math mode. + */ + hasMathModeAncestor?: boolean; +}; + +declare type Visitors = { + enter?: Visitor; + leave?: Visitor; +}; + +/** + * Get the type of the parameter to the `Visitor` function based on the + * `VisitOptions` that are supplied. + */ +declare type VisitorTypeFromOptions = NarrowArraysBasedOnOptions, Opts>; + +export { } diff --git a/node_modules/@unified-latex/unified-latex-util-visit/index.js b/node_modules/@unified-latex/unified-latex-util-visit/index.js new file mode 100644 index 0000000..a547af6 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-util-visit/index.js @@ -0,0 +1,168 @@ +import { match } from "@unified-latex/unified-latex-util-match"; +function listMathChildren(node) { + const NULL_RETURN = { enter: [], leave: [] }; + if (Array.isArray(node)) { + return NULL_RETURN; + } + if (match.math(node)) { + return { enter: ["content"], leave: [] }; + } + const renderInfo = node._renderInfo || {}; + if (renderInfo.inMathMode == null) { + return NULL_RETURN; + } + if (match.macro(node)) { + if (renderInfo.inMathMode === true) { + return { enter: ["args"], leave: [] }; + } else if (renderInfo.inMathMode === false) { + return { enter: [], leave: ["args"] }; + } + } + if (match.environment(node)) { + if (renderInfo.inMathMode === true) { + return { enter: ["content"], leave: [] }; + } else { + return { enter: [], leave: ["content"] }; + } + } + return NULL_RETURN; +} +const CONTINUE = Symbol("continue"); +const SKIP = Symbol("skip"); +const EXIT = Symbol("exit"); +const DEFAULT_CONTEXT = { + inMathMode: false, + hasMathModeAncestor: false +}; +function visit(tree, visitor, options) { + const { + startingContext = DEFAULT_CONTEXT, + test = () => true, + includeArrays = false + } = options || {}; + let enter; + let leave; + if (typeof visitor === "function") { + enter = visitor; + } else if (visitor && typeof visitor === "object") { + enter = visitor.enter; + leave = visitor.leave; + } + walk(tree, { + key: void 0, + index: void 0, + parents: [], + containingArray: void 0, + context: { ...startingContext } + }); + function walk(node, { key, index, parents, context, containingArray }) { + const nodePassesTest = includeArrays ? test(node, { key, index, parents, context, containingArray }) : !Array.isArray(node) && test(node, { key, index, parents, context, containingArray }); + const result = enter && nodePassesTest ? toResult( + enter(node, { + key, + index, + parents, + context, + containingArray + }) + ) : [CONTINUE]; + if (result[0] === EXIT) { + return result; + } + if (result[0] === SKIP) { + return leave && nodePassesTest ? toResult( + leave(node, { + key, + index, + parents, + context, + containingArray + }) + ) : result; + } + if (Array.isArray(node)) { + for (let index2 = 0; index2 > -1 && index2 < node.length; index2++) { + const item = node[index2]; + const result2 = walk(item, { + key, + index: index2, + parents, + context, + containingArray: node + }); + if (result2[0] === EXIT) { + return result2; + } + if (typeof result2[1] === "number") { + index2 = result2[1] - 1; + } + } + } else { + let childProps = ["content", "args"]; + switch (node.type) { + case "macro": + childProps = ["args"]; + break; + case "comment": + case "string": + case "verb": + case "verbatim": + childProps = []; + break; + } + const mathModeProps = listMathChildren(node); + for (const key2 of childProps) { + const value = node[key2]; + const grandparents = [node].concat(parents); + if (value == null) { + continue; + } + const newContext = { ...context }; + if (mathModeProps.enter.includes(key2)) { + newContext.inMathMode = true; + newContext.hasMathModeAncestor = true; + } else if (mathModeProps.leave.includes(key2)) { + newContext.inMathMode = false; + } + const result2 = walk(value, { + key: key2, + index: void 0, + parents: grandparents, + context: newContext, + containingArray: void 0 + }); + if (result2[0] === EXIT) { + return result2; + } + } + } + return leave && nodePassesTest ? toResult( + leave(node, { + key, + index, + parents, + context, + containingArray + }) + ) : result; + } +} +function toResult(value) { + if (value == null) { + return [CONTINUE]; + } + if (Array.isArray(value)) { + return value; + } + if (typeof value === "number") { + return [CONTINUE, value]; + } + return [value]; +} +export { + CONTINUE, + EXIT, + SKIP, + visit +}; +//# sourceMappingURL=index.js.map diff --git a/node_modules/@unified-latex/unified-latex-util-visit/index.js.map b/node_modules/@unified-latex/unified-latex-util-visit/index.js.map new file mode 100644 index 0000000..b9b1352 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-util-visit/index.js.map @@ -0,0 +1 @@ +{"version":3,"file":"index.js","sources":["../libs/list-math-children.ts","../libs/visit.ts"],"sourcesContent":["import * as Ast from \"@unified-latex/unified-latex-types\";\nimport { match } from \"@unified-latex/unified-latex-util-match\";\n\n/**\n * List all props of the current node that should be processed\n * in math mode or not in math mode. If math mode is not specified in the node's render\n * info, empty lists are returned.\n *\n * For example `\\text{foo}` will report that `args` should *not* be processed in math mode,\n * since it's contents should always be processed in text mode.\n */\nexport function listMathChildren(node: Ast.Ast): {\n enter: string[];\n leave: string[];\n} {\n const NULL_RETURN = { enter: [], leave: [] };\n if (Array.isArray(node)) {\n return NULL_RETURN;\n }\n if (match.math(node)) {\n // When we enter a math environment, our content is always\n // considered math mode\n return { enter: [\"content\"], leave: [] };\n }\n\n const renderInfo: { inMathMode?: boolean } = node._renderInfo || {};\n if (renderInfo.inMathMode == null) {\n return NULL_RETURN;\n }\n if (match.macro(node)) {\n if (renderInfo.inMathMode === true) {\n return { enter: [\"args\"], leave: [] };\n } else if (renderInfo.inMathMode === false) {\n return { enter: [], leave: [\"args\"] };\n }\n }\n if (match.environment(node)) {\n if (renderInfo.inMathMode === true) {\n return { enter: [\"content\"], leave: [] };\n } else {\n return { enter: [], leave: [\"content\"] };\n }\n }\n return NULL_RETURN;\n}\n","import * as Ast from \"@unified-latex/unified-latex-types\";\nimport { listMathChildren } from \"./list-math-children\";\n\nexport type VisitorContext = {\n /**\n * Whether the node is being processed in math mode.\n *\n * This happens when the node is a director or indirect child\n * of a math environment (e.g. `$abc$`), but not when an environment\n * re-establishes text mode (e.g. `$\\text{abc}$`)\n */\n inMathMode?: boolean;\n /**\n * Whether the node has any ancestor that is processed in math mode.\n */\n hasMathModeAncestor?: boolean;\n};\n\ntype GetGuard = T extends (x: any, ...y: any[]) => x is infer R ? R : never;\n/**\n * Gets the type that a type-guard function is guarding. If\n * the guard type cannot be determined, the input type is returned.\n */\ntype GuardTypeOf boolean> =\n GetGuard extends never\n ? T extends (x: infer A) => any\n ? A\n : never\n : GetGuard;\n\n/**\n * Extracts the guard type from the `test` function provided in a\n * `VisitOptions` argument.\n */\ntype GuardFromOptions<\n Opts extends VisitOptions,\n PossibleTypes = Ast.Ast\n> = Opts extends {\n test: infer R;\n}\n ? R extends (x: any, ...y: any[]) => boolean\n ? // A guard like `typeof Array.isArray` will return `any[]` as the type.\n // This type cannot be narrowed, so instead we use it to pick from\n // the set of all possible types.\n Extract>\n : PossibleTypes\n : PossibleTypes;\n\n/**\n * Narrow the type `T` based on the `VisitOptions` supplied. If `{includeArrays: false}`\n * is specified in the `VisitOptions`, then arrays are excluded from `T`.\n */\ntype NarrowArraysBasedOnOptions = Opts extends {\n includeArrays: infer A;\n}\n ? A extends true\n ? T\n : Exclude\n : Exclude;\n\n/**\n * Get the type of the parameter to the `Visitor` function based on the\n * `VisitOptions` that are supplied.\n */\ntype VisitorTypeFromOptions =\n NarrowArraysBasedOnOptions, Opts>;\n\n/**\n * Continue traversing as normal\n */\nexport const CONTINUE = Symbol(\"continue\");\n/**\n * Do not traverse this node’s children\n */\nexport const SKIP = Symbol(\"skip\");\n/**\n * Stop traversing immediately\n */\nexport const EXIT = Symbol(\"exit\");\n\ntype Action = typeof CONTINUE | typeof SKIP | typeof EXIT;\ntype Index = number;\ntype ActionTuple = [Action] | [typeof SKIP, Index] | [typeof CONTINUE, Index];\n\n/**\n * A visitor takes a `node`, `key`, `index`, and ...\n *\n * @param key - The key of the parent that we were accessed through.\n */\ntype Visitor = (\n node: T,\n info: VisitInfo\n) => null | undefined | Action | Index | ActionTuple | void;\ntype Visitors = { enter?: Visitor; leave?: Visitor };\n\ntype VisitOptions = {\n startingContext?: VisitorContext;\n /**\n * Type guard for types that are passed to the `visitor` function.\n */\n test?: (node: Ast.Ast, info: VisitInfo) => boolean;\n /**\n * Whether arrays will be sent to the `visitor` function. If falsy,\n * only nodes will be past to `visitor`.\n */\n includeArrays?: boolean;\n};\n\nconst DEFAULT_CONTEXT: VisitorContext = {\n inMathMode: false,\n hasMathModeAncestor: false,\n};\n\nexport type VisitInfo = {\n /**\n * If the element was accessed via an attribute, the attribute key is specified.\n */\n readonly key: string | undefined;\n /**\n * If the element was accessed in an array, the index is specified.\n */\n readonly index: number | undefined;\n /**\n * A list of ancestor nodes, `[parent, grandparent, great-grandparent, ...]`\n */\n readonly parents: (Ast.Node | Ast.Argument)[];\n /**\n * If the element was accessed in an array, the array that it is part of.\n */\n readonly containingArray: (Ast.Node | Ast.Argument)[] | undefined;\n /**\n * The LaTeX context of the current match.\n */\n readonly context: VisitorContext;\n};\n\n/**\n * Visit children of tree which pass a test\n *\n * @param {Node} tree Abstract syntax tree to walk\n * @param {Visitor|Visitors} [visitor] Function to run for each node\n */\nexport function visit(\n tree: Ast.Ast,\n visitor:\n | Visitor>\n | Visitors>,\n options?: Opts\n) {\n const {\n startingContext = DEFAULT_CONTEXT,\n test = () => true,\n includeArrays = false,\n } = options || {};\n let enter: Visitor> | undefined;\n let leave: Visitor> | undefined;\n\n if (typeof visitor === \"function\") {\n enter = visitor;\n } else if (visitor && typeof visitor === \"object\") {\n enter = visitor.enter;\n leave = visitor.leave;\n }\n\n walk(tree, {\n key: undefined,\n index: undefined,\n parents: [],\n containingArray: undefined,\n context: { ...startingContext },\n });\n\n /**\n * @param {Node} node\n * @param {string?} key\n * @param {number?} index\n * @param {Array.} parents\n */\n function walk(\n node: Ast.Ast,\n { key, index, parents, context, containingArray }: VisitInfo\n ): ActionTuple {\n const nodePassesTest = includeArrays\n ? test(node, { key, index, parents, context, containingArray })\n : !Array.isArray(node) &&\n test(node, { key, index, parents, context, containingArray });\n\n const result: ActionTuple =\n enter && nodePassesTest\n ? toResult(\n enter(node as any, {\n key,\n index,\n parents,\n context,\n containingArray,\n })\n )\n : [CONTINUE];\n\n if (result[0] === EXIT) {\n return result;\n }\n\n if (result[0] === SKIP) {\n return leave && nodePassesTest\n ? toResult(\n leave(node as any, {\n key,\n index,\n parents,\n context,\n containingArray,\n })\n )\n : result;\n }\n\n if (Array.isArray(node)) {\n // The `value` array might be modified in place as we traverse it, so\n // we use a traditional for loop.\n for (let index = 0; index > -1 && index < node.length; index++) {\n const item = node[index];\n const result = walk(item, {\n key,\n index,\n parents,\n context,\n containingArray: node,\n });\n if (result[0] === EXIT) {\n return result;\n }\n if (typeof result[1] === \"number\") {\n // The for loop will increment i every pass. However,\n // if an index was returned, that's where we want to start next time.\n index = result[1] - 1;\n }\n }\n } else {\n // We don't want to recursively apply to the `content`\n // of all types (e.g., comments and macros), so specify\n // a blacklist.\n let childProps: (\"content\" | \"args\")[] = [\"content\", \"args\"];\n switch (node.type) {\n case \"macro\":\n childProps = [\"args\"];\n break;\n case \"comment\":\n case \"string\":\n case \"verb\":\n case \"verbatim\":\n childProps = [];\n break;\n default:\n break;\n }\n\n const mathModeProps = listMathChildren(node);\n for (const key of childProps) {\n const value = node[key as keyof typeof node] as\n | Ast.Ast\n | undefined;\n const grandparents = [node].concat(parents);\n\n if (value == null) {\n continue;\n }\n\n // We may switch in/out of math mode as we pass to node[key]\n const newContext = { ...context };\n if (mathModeProps.enter.includes(key)) {\n newContext.inMathMode = true;\n newContext.hasMathModeAncestor = true;\n } else if (mathModeProps.leave.includes(key)) {\n newContext.inMathMode = false;\n }\n\n const result = walk(value, {\n key,\n index: undefined,\n parents: grandparents,\n context: newContext,\n containingArray: undefined,\n });\n if (result[0] === EXIT) {\n return result;\n }\n }\n }\n\n return leave && nodePassesTest\n ? toResult(\n leave(node as any, {\n key,\n index,\n parents,\n context,\n containingArray,\n })\n )\n : result;\n }\n}\n\n/**\n * Ensures a result is an `ActionTuple`s\n */\nfunction toResult(\n value: null | undefined | void | Action | Index | ActionTuple\n): ActionTuple {\n if (value == null) {\n return [CONTINUE];\n }\n\n if (Array.isArray(value)) {\n return value;\n }\n\n if (typeof value === \"number\") {\n return [CONTINUE, value];\n }\n\n return [value];\n}\n"],"names":["index","result","key"],"mappings":";AAWO,SAAS,iBAAiB,MAG/B;AACE,QAAM,cAAc,EAAE,OAAO,CAAA,GAAI,OAAO,CAAA,EAAG;AACvC,MAAA,MAAM,QAAQ,IAAI,GAAG;AACd,WAAA;AAAA,EAAA;AAEP,MAAA,MAAM,KAAK,IAAI,GAAG;AAGlB,WAAO,EAAE,OAAO,CAAC,SAAS,GAAG,OAAO,CAAA,EAAG;AAAA,EAAA;AAGrC,QAAA,aAAuC,KAAK,eAAe,CAAC;AAC9D,MAAA,WAAW,cAAc,MAAM;AACxB,WAAA;AAAA,EAAA;AAEP,MAAA,MAAM,MAAM,IAAI,GAAG;AACf,QAAA,WAAW,eAAe,MAAM;AAChC,aAAO,EAAE,OAAO,CAAC,MAAM,GAAG,OAAO,CAAA,EAAG;AAAA,IAAA,WAC7B,WAAW,eAAe,OAAO;AACxC,aAAO,EAAE,OAAO,CAAA,GAAI,OAAO,CAAC,MAAM,EAAE;AAAA,IAAA;AAAA,EACxC;AAEA,MAAA,MAAM,YAAY,IAAI,GAAG;AACrB,QAAA,WAAW,eAAe,MAAM;AAChC,aAAO,EAAE,OAAO,CAAC,SAAS,GAAG,OAAO,CAAA,EAAG;AAAA,IAAA,OACpC;AACH,aAAO,EAAE,OAAO,CAAA,GAAI,OAAO,CAAC,SAAS,EAAE;AAAA,IAAA;AAAA,EAC3C;AAEG,SAAA;AACX;AC0Ba,MAAA,WAAW,OAAO,UAAU;AAI5B,MAAA,OAAO,OAAO,MAAM;AAIpB,MAAA,OAAO,OAAO,MAAM;AA8BjC,MAAM,kBAAkC;AAAA,EACpC,YAAY;AAAA,EACZ,qBAAqB;AACzB;AA+BgB,SAAA,MACZ,MACA,SAGA,SACF;AACQ,QAAA;AAAA,IACF,kBAAkB;AAAA,IAClB,OAAO,MAAM;AAAA,IACb,gBAAgB;AAAA,EACpB,IAAI,WAAW,CAAC;AACZ,MAAA;AACA,MAAA;AAEA,MAAA,OAAO,YAAY,YAAY;AACvB,YAAA;AAAA,EACD,WAAA,WAAW,OAAO,YAAY,UAAU;AAC/C,YAAQ,QAAQ;AAChB,YAAQ,QAAQ;AAAA,EAAA;AAGpB,OAAK,MAAM;AAAA,IACP,KAAK;AAAA,IACL,OAAO;AAAA,IACP,SAAS,CAAC;AAAA,IACV,iBAAiB;AAAA,IACjB,SAAS,EAAE,GAAG,gBAAgB;AAAA,EAAA,CACjC;AAQQ,WAAA,KACL,MACA,EAAE,KAAK,OAAO,SAAS,SAAS,mBACrB;AACL,UAAA,iBAAiB,gBACjB,KAAK,MAAM,EAAE,KAAK,OAAO,SAAS,SAAS,iBAAiB,IAC5D,CAAC,MAAM,QAAQ,IAAI,KACnB,KAAK,MAAM,EAAE,KAAK,OAAO,SAAS,SAAS,gBAAA,CAAiB;AAE5D,UAAA,SACF,SAAS,iBACH;AAAA,MACI,MAAM,MAAa;AAAA,QACf;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,MACH,CAAA;AAAA,IACL,IACA,CAAC,QAAQ;AAEf,QAAA,OAAO,CAAC,MAAM,MAAM;AACb,aAAA;AAAA,IAAA;AAGP,QAAA,OAAO,CAAC,MAAM,MAAM;AACpB,aAAO,SAAS,iBACV;AAAA,QACI,MAAM,MAAa;AAAA,UACf;AAAA,UACA;AAAA,UACA;AAAA,UACA;AAAA,UACA;AAAA,QACH,CAAA;AAAA,MAAA,IAEL;AAAA,IAAA;AAGN,QAAA,MAAM,QAAQ,IAAI,GAAG;AAGrB,eAASA,SAAQ,GAAGA,SAAQ,MAAMA,SAAQ,KAAK,QAAQA,UAAS;AACtD,cAAA,OAAO,KAAKA,MAAK;AACjBC,cAAAA,UAAS,KAAK,MAAM;AAAA,UACtB;AAAA,UACA,OAAAD;AAAAA,UACA;AAAA,UACA;AAAA,UACA,iBAAiB;AAAA,QAAA,CACpB;AACGC,YAAAA,QAAO,CAAC,MAAM,MAAM;AACbA,iBAAAA;AAAAA,QAAA;AAEX,YAAI,OAAOA,QAAO,CAAC,MAAM,UAAU;AAG/BD,mBAAQC,QAAO,CAAC,IAAI;AAAA,QAAA;AAAA,MACxB;AAAA,IACJ,OACG;AAIC,UAAA,aAAqC,CAAC,WAAW,MAAM;AAC3D,cAAQ,KAAK,MAAM;AAAA,QACf,KAAK;AACD,uBAAa,CAAC,MAAM;AACpB;AAAA,QACJ,KAAK;AAAA,QACL,KAAK;AAAA,QACL,KAAK;AAAA,QACL,KAAK;AACD,uBAAa,CAAC;AACd;AAAA,MAEA;AAGF,YAAA,gBAAgB,iBAAiB,IAAI;AAC3C,iBAAWC,QAAO,YAAY;AACpB,cAAA,QAAQ,KAAKA,IAAwB;AAG3C,cAAM,eAAe,CAAC,IAAI,EAAE,OAAO,OAAO;AAE1C,YAAI,SAAS,MAAM;AACf;AAAA,QAAA;AAIE,cAAA,aAAa,EAAE,GAAG,QAAQ;AAChC,YAAI,cAAc,MAAM,SAASA,IAAG,GAAG;AACnC,qBAAW,aAAa;AACxB,qBAAW,sBAAsB;AAAA,QAC1B,WAAA,cAAc,MAAM,SAASA,IAAG,GAAG;AAC1C,qBAAW,aAAa;AAAA,QAAA;AAGtBD,cAAAA,UAAS,KAAK,OAAO;AAAA,UACvB,KAAAC;AAAAA,UACA,OAAO;AAAA,UACP,SAAS;AAAA,UACT,SAAS;AAAA,UACT,iBAAiB;AAAA,QAAA,CACpB;AACGD,YAAAA,QAAO,CAAC,MAAM,MAAM;AACbA,iBAAAA;AAAAA,QAAA;AAAA,MACX;AAAA,IACJ;AAGJ,WAAO,SAAS,iBACV;AAAA,MACI,MAAM,MAAa;AAAA,QACf;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,MACH,CAAA;AAAA,IAAA,IAEL;AAAA,EAAA;AAEd;AAKA,SAAS,SACL,OACW;AACX,MAAI,SAAS,MAAM;AACf,WAAO,CAAC,QAAQ;AAAA,EAAA;AAGhB,MAAA,MAAM,QAAQ,KAAK,GAAG;AACf,WAAA;AAAA,EAAA;AAGP,MAAA,OAAO,UAAU,UAAU;AACpB,WAAA,CAAC,UAAU,KAAK;AAAA,EAAA;AAG3B,SAAO,CAAC,KAAK;AACjB;"} \ No newline at end of file diff --git a/node_modules/@unified-latex/unified-latex-util-visit/package.json b/node_modules/@unified-latex/unified-latex-util-visit/package.json new file mode 100644 index 0000000..e7f15a0 --- /dev/null +++ b/node_modules/@unified-latex/unified-latex-util-visit/package.json @@ -0,0 +1,52 @@ +{ + "name": "@unified-latex/unified-latex-util-visit", + "version": "1.8.2", + "description": "Functions for traversing a unified-latex AST", + "main": "index.js", + "type": "module", + "dependencies": { + "@unified-latex/unified-latex-types": "^1.8.0", + "@unified-latex/unified-latex-util-match": "^1.8.0" + }, + "repository": { + "type": "git", + "url": "git+https://github.com/siefkenj/unified-latex.git" + }, + "keywords": [ + "pegjs", + "latex", + "parser", + "prettier", + "unified-latex", + "unified" + ], + "author": "Jason Siefken", + "license": "MIT", + "bugs": { + "url": "https://github.com/siefkenj/unified-latex/issues" + }, + "homepage": "https://github.com/siefkenj/unified-latex#readme", + "exports": { + ".": { + "import": "./index.js", + "require": "./index.cjs", + "types": "./index.d.ts" + }, + "./*js": "./*js", + "./*": { + "import": "./*/index.js", + "require": "./*/index.cjs", + "types": "./*/index.d.ts" + }, + "./*/index": { + "import": "./*/index.js", + "require": "./*/index.cjs" + } + }, + "files": [ + "**/*ts", + "**/*js", + "**/*.map", + "**/*.json" + ] +} \ No newline at end of file diff --git a/node_modules/bail/index.d.ts b/node_modules/bail/index.d.ts new file mode 100644 index 0000000..88fe9aa --- /dev/null +++ b/node_modules/bail/index.d.ts @@ -0,0 +1,10 @@ +/** + * Throw a given error. + * + * @param {Error|null|undefined} [error] + * Maybe error. + * @returns {asserts error is null|undefined} + */ +export function bail( + error?: Error | null | undefined +): asserts error is null | undefined diff --git a/node_modules/bail/index.js b/node_modules/bail/index.js new file mode 100644 index 0000000..d0bc442 --- /dev/null +++ b/node_modules/bail/index.js @@ -0,0 +1,12 @@ +/** + * Throw a given error. + * + * @param {Error|null|undefined} [error] + * Maybe error. + * @returns {asserts error is null|undefined} + */ +export function bail(error) { + if (error) { + throw error + } +} diff --git a/node_modules/bail/license b/node_modules/bail/license new file mode 100644 index 0000000..32e7a3d --- /dev/null +++ b/node_modules/bail/license @@ -0,0 +1,22 @@ +(The MIT License) + +Copyright (c) 2015 Titus Wormer + +Permission is hereby granted, free of charge, to any person obtaining +a copy of this software and associated documentation files (the +'Software'), to deal in the Software without restriction, including +without limitation the rights to use, copy, modify, merge, publish, +distribute, sublicense, and/or sell copies of the Software, and to +permit persons to whom the Software is furnished to do so, subject to +the following conditions: + +The above copyright notice and this permission notice shall be +included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. +IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY +CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, +TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE +SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. diff --git a/node_modules/bail/package.json b/node_modules/bail/package.json new file mode 100644 index 0000000..d56f6fa --- /dev/null +++ b/node_modules/bail/package.json @@ -0,0 +1,73 @@ +{ + "name": "bail", + "version": "2.0.2", + "description": "Throw a given error", + "license": "MIT", + "keywords": [ + "fail", + "bail", + "throw", + "callback", + "error" + ], + "repository": "wooorm/bail", + "bugs": "https://github.com/wooorm/bail/issues", + "funding": { + "type": "github", + "url": "https://github.com/sponsors/wooorm" + }, + "author": "Titus Wormer (https://wooorm.com)", + "contributors": [ + "Titus Wormer (https://wooorm.com)" + ], + "sideEffects": false, + "type": "module", + "main": "index.js", + "types": "index.d.ts", + "files": [ + "index.d.ts", + "index.js" + ], + "devDependencies": { + "@types/tape": "^4.0.0", + "c8": "^7.0.0", + "prettier": "^2.0.0", + "remark-cli": "^10.0.0", + "remark-preset-wooorm": "^9.0.0", + "rimraf": "^3.0.0", + "tape": "^5.0.0", + "tsd": "^0.18.0", + "type-coverage": "^2.0.0", + "typescript": "^4.0.0", + "xo": "^0.46.0" + }, + "scripts": { + "prepublishOnly": "npm run build && npm run format", + "build": "rimraf \"*.d.ts\" && tsc && tsd && type-coverage", + "format": "remark . -qfo && prettier . -w --loglevel warn && xo --fix", + "test-api": "node --conditions development test.js", + "test-coverage": "c8 --check-coverage --branches 100 --functions 100 --lines 100 --statements 100 --reporter lcov npm run test-api", + "test": "npm run build && npm run format && npm run test-coverage" + }, + "prettier": { + "tabWidth": 2, + "useTabs": false, + "singleQuote": true, + "bracketSpacing": false, + "semi": false, + "trailingComma": "none" + }, + "xo": { + "prettier": true + }, + "remarkConfig": { + "plugins": [ + "preset-wooorm" + ] + }, + "typeCoverage": { + "atLeast": 100, + "detail": true, + "strict": true + } +} diff --git a/node_modules/bail/readme.md b/node_modules/bail/readme.md new file mode 100644 index 0000000..8cd1823 --- /dev/null +++ b/node_modules/bail/readme.md @@ -0,0 +1,147 @@ +# bail + +[![Build][build-badge]][build] +[![Coverage][coverage-badge]][coverage] +[![Downloads][downloads-badge]][downloads] +[![Size][size-badge]][size] + +Throw if given an error. + +## Contents + +* [What is this?](#what-is-this) +* [When should I use this?](#when-should-i-use-this) +* [Install](#install) +* [Use](#use) +* [API](#api) + * [`bail(err?)`](#bailerr) +* [Types](#types) +* [Compatibility](#compatibility) +* [Security](#security) +* [Related](#related) +* [Contribute](#contribute) +* [License](#license) + +## What is this? + +This package throws a given error. + +## When should I use this? + +Use this package if you’re building some scripts that might theoretically get +errors but frequently don’t and you keep writing `if (error) throw error` over +and over again and you’re just really done with that. + +## Install + +This package is [ESM only][esm]. +In Node.js (version 12.20+, 14.14+, or 16.0+), install with [npm][]: + +```sh +npm install bail +``` + +In Deno with [Skypack][]: + +```js +import {bail} from 'https://cdn.skypack.dev/bail@2?dts' +``` + +In browsers with [Skypack][]: + +```html + +``` + +## Use + +```js +import {bail} from 'bail' + +bail() + +bail(new Error('failure')) +// Error: failure +// at repl:1:6 +// at REPLServer.defaultEval (repl.js:154:27) +// … +``` + +## API + +This package exports the following identifier: `bail`. +There is no default export. + +### `bail(err?)` + +Throw a given error (`Error?`). + +## Types + +This package is fully typed with [TypeScript][]. +There are no extra exported types. + +## Compatibility + +This package is at least compatible with all maintained versions of Node.js. +As of now, that is Node.js 12.20+, 14.14+, and 16.0+. +It also works in Deno and modern browsers. + +## Security + +This package is safe. + +## Related + +* [`noop`][noop] +* [`noop2`][noop2] +* [`noop3`][noop3] + +## Contribute + +Yes please! +See [How to Contribute to Open Source][contribute]. + +## License + +[MIT][license] © [Titus Wormer][author] + + + +[build-badge]: https://github.com/wooorm/bail/workflows/main/badge.svg + +[build]: https://github.com/wooorm/bail/actions + +[coverage-badge]: https://img.shields.io/codecov/c/github/wooorm/bail.svg + +[coverage]: https://codecov.io/github/wooorm/bail + +[downloads-badge]: https://img.shields.io/npm/dm/bail.svg + +[downloads]: https://www.npmjs.com/package/bail + +[size-badge]: https://img.shields.io/bundlephobia/minzip/bail.svg + +[size]: https://bundlephobia.com/result?p=bail + +[npm]: https://docs.npmjs.com/cli/install + +[skypack]: https://www.skypack.dev + +[license]: license + +[author]: https://wooorm.com + +[esm]: https://gist.github.com/sindresorhus/a39789f98801d908bbc7ff3ecc99d99c + +[typescript]: https://www.typescriptlang.org + +[contribute]: https://opensource.guide/how-to-contribute/ + +[noop]: https://www.npmjs.com/package/noop + +[noop2]: https://www.npmjs.com/package/noop2 + +[noop3]: https://www.npmjs.com/package/noop3 diff --git a/node_modules/color-convert/CHANGELOG.md b/node_modules/color-convert/CHANGELOG.md new file mode 100644 index 0000000..0a7bce4 --- /dev/null +++ b/node_modules/color-convert/CHANGELOG.md @@ -0,0 +1,54 @@ +# 1.0.0 - 2016-01-07 + +- Removed: unused speed test +- Added: Automatic routing between previously unsupported conversions +([#27](https://github.com/Qix-/color-convert/pull/27)) +- Removed: `xxx2xxx()` and `xxx2xxxRaw()` functions +([#27](https://github.com/Qix-/color-convert/pull/27)) +- Removed: `convert()` class +([#27](https://github.com/Qix-/color-convert/pull/27)) +- Changed: all functions to lookup dictionary +([#27](https://github.com/Qix-/color-convert/pull/27)) +- Changed: `ansi` to `ansi256` +([#27](https://github.com/Qix-/color-convert/pull/27)) +- Fixed: argument grouping for functions requiring only one argument +([#27](https://github.com/Qix-/color-convert/pull/27)) + +# 0.6.0 - 2015-07-23 + +- Added: methods to handle +[ANSI](https://en.wikipedia.org/wiki/ANSI_escape_code#Colors) 16/256 colors: + - rgb2ansi16 + - rgb2ansi + - hsl2ansi16 + - hsl2ansi + - hsv2ansi16 + - hsv2ansi + - hwb2ansi16 + - hwb2ansi + - cmyk2ansi16 + - cmyk2ansi + - keyword2ansi16 + - keyword2ansi + - ansi162rgb + - ansi162hsl + - ansi162hsv + - ansi162hwb + - ansi162cmyk + - ansi162keyword + - ansi2rgb + - ansi2hsl + - ansi2hsv + - ansi2hwb + - ansi2cmyk + - ansi2keyword +([#18](https://github.com/harthur/color-convert/pull/18)) + +# 0.5.3 - 2015-06-02 + +- Fixed: hsl2hsv does not return `NaN` anymore when using `[0,0,0]` +([#15](https://github.com/harthur/color-convert/issues/15)) + +--- + +Check out commit logs for older releases diff --git a/node_modules/color-convert/LICENSE b/node_modules/color-convert/LICENSE new file mode 100644 index 0000000..5b4c386 --- /dev/null +++ b/node_modules/color-convert/LICENSE @@ -0,0 +1,21 @@ +Copyright (c) 2011-2016 Heather Arthur + +Permission is hereby granted, free of charge, to any person obtaining +a copy of this software and associated documentation files (the +"Software"), to deal in the Software without restriction, including +without limitation the rights to use, copy, modify, merge, publish, +distribute, sublicense, and/or sell copies of the Software, and to +permit persons to whom the Software is furnished to do so, subject to +the following conditions: + +The above copyright notice and this permission notice shall be +included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE +LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION +OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + diff --git a/node_modules/color-convert/README.md b/node_modules/color-convert/README.md new file mode 100644 index 0000000..d4b08fc --- /dev/null +++ b/node_modules/color-convert/README.md @@ -0,0 +1,68 @@ +# color-convert + +[![Build Status](https://travis-ci.org/Qix-/color-convert.svg?branch=master)](https://travis-ci.org/Qix-/color-convert) + +Color-convert is a color conversion library for JavaScript and node. +It converts all ways between `rgb`, `hsl`, `hsv`, `hwb`, `cmyk`, `ansi`, `ansi16`, `hex` strings, and CSS `keyword`s (will round to closest): + +```js +var convert = require('color-convert'); + +convert.rgb.hsl(140, 200, 100); // [96, 48, 59] +convert.keyword.rgb('blue'); // [0, 0, 255] + +var rgbChannels = convert.rgb.channels; // 3 +var cmykChannels = convert.cmyk.channels; // 4 +var ansiChannels = convert.ansi16.channels; // 1 +``` + +# Install + +```console +$ npm install color-convert +``` + +# API + +Simply get the property of the _from_ and _to_ conversion that you're looking for. + +All functions have a rounded and unrounded variant. By default, return values are rounded. To get the unrounded (raw) results, simply tack on `.raw` to the function. + +All 'from' functions have a hidden property called `.channels` that indicates the number of channels the function expects (not including alpha). + +```js +var convert = require('color-convert'); + +// Hex to LAB +convert.hex.lab('DEADBF'); // [ 76, 21, -2 ] +convert.hex.lab.raw('DEADBF'); // [ 75.56213190997677, 20.653827952644754, -2.290532499330533 ] + +// RGB to CMYK +convert.rgb.cmyk(167, 255, 4); // [ 35, 0, 98, 0 ] +convert.rgb.cmyk.raw(167, 255, 4); // [ 34.509803921568626, 0, 98.43137254901961, 0 ] +``` + +### Arrays +All functions that accept multiple arguments also support passing an array. + +Note that this does **not** apply to functions that convert from a color that only requires one value (e.g. `keyword`, `ansi256`, `hex`, etc.) + +```js +var convert = require('color-convert'); + +convert.rgb.hex(123, 45, 67); // '7B2D43' +convert.rgb.hex([123, 45, 67]); // '7B2D43' +``` + +## Routing + +Conversions that don't have an _explicitly_ defined conversion (in [conversions.js](conversions.js)), but can be converted by means of sub-conversions (e.g. XYZ -> **RGB** -> CMYK), are automatically routed together. This allows just about any color model supported by `color-convert` to be converted to any other model, so long as a sub-conversion path exists. This is also true for conversions requiring more than one step in between (e.g. LCH -> **LAB** -> **XYZ** -> **RGB** -> Hex). + +Keep in mind that extensive conversions _may_ result in a loss of precision, and exist only to be complete. For a list of "direct" (single-step) conversions, see [conversions.js](conversions.js). + +# Contribute + +If there is a new model you would like to support, or want to add a direct conversion between two existing models, please send us a pull request. + +# License +Copyright © 2011-2016, Heather Arthur and Josh Junon. Licensed under the [MIT License](LICENSE). diff --git a/node_modules/color-convert/conversions.js b/node_modules/color-convert/conversions.js new file mode 100644 index 0000000..2657f26 --- /dev/null +++ b/node_modules/color-convert/conversions.js @@ -0,0 +1,839 @@ +/* MIT license */ +/* eslint-disable no-mixed-operators */ +const cssKeywords = require('color-name'); + +// NOTE: conversions should only return primitive values (i.e. arrays, or +// values that give correct `typeof` results). +// do not use box values types (i.e. Number(), String(), etc.) + +const reverseKeywords = {}; +for (const key of Object.keys(cssKeywords)) { + reverseKeywords[cssKeywords[key]] = key; +} + +const convert = { + rgb: {channels: 3, labels: 'rgb'}, + hsl: {channels: 3, labels: 'hsl'}, + hsv: {channels: 3, labels: 'hsv'}, + hwb: {channels: 3, labels: 'hwb'}, + cmyk: {channels: 4, labels: 'cmyk'}, + xyz: {channels: 3, labels: 'xyz'}, + lab: {channels: 3, labels: 'lab'}, + lch: {channels: 3, labels: 'lch'}, + hex: {channels: 1, labels: ['hex']}, + keyword: {channels: 1, labels: ['keyword']}, + ansi16: {channels: 1, labels: ['ansi16']}, + ansi256: {channels: 1, labels: ['ansi256']}, + hcg: {channels: 3, labels: ['h', 'c', 'g']}, + apple: {channels: 3, labels: ['r16', 'g16', 'b16']}, + gray: {channels: 1, labels: ['gray']} +}; + +module.exports = convert; + +// Hide .channels and .labels properties +for (const model of Object.keys(convert)) { + if (!('channels' in convert[model])) { + throw new Error('missing channels property: ' + model); + } + + if (!('labels' in convert[model])) { + throw new Error('missing channel labels property: ' + model); + } + + if (convert[model].labels.length !== convert[model].channels) { + throw new Error('channel and label counts mismatch: ' + model); + } + + const {channels, labels} = convert[model]; + delete convert[model].channels; + delete convert[model].labels; + Object.defineProperty(convert[model], 'channels', {value: channels}); + Object.defineProperty(convert[model], 'labels', {value: labels}); +} + +convert.rgb.hsl = function (rgb) { + const r = rgb[0] / 255; + const g = rgb[1] / 255; + const b = rgb[2] / 255; + const min = Math.min(r, g, b); + const max = Math.max(r, g, b); + const delta = max - min; + let h; + let s; + + if (max === min) { + h = 0; + } else if (r === max) { + h = (g - b) / delta; + } else if (g === max) { + h = 2 + (b - r) / delta; + } else if (b === max) { + h = 4 + (r - g) / delta; + } + + h = Math.min(h * 60, 360); + + if (h < 0) { + h += 360; + } + + const l = (min + max) / 2; + + if (max === min) { + s = 0; + } else if (l <= 0.5) { + s = delta / (max + min); + } else { + s = delta / (2 - max - min); + } + + return [h, s * 100, l * 100]; +}; + +convert.rgb.hsv = function (rgb) { + let rdif; + let gdif; + let bdif; + let h; + let s; + + const r = rgb[0] / 255; + const g = rgb[1] / 255; + const b = rgb[2] / 255; + const v = Math.max(r, g, b); + const diff = v - Math.min(r, g, b); + const diffc = function (c) { + return (v - c) / 6 / diff + 1 / 2; + }; + + if (diff === 0) { + h = 0; + s = 0; + } else { + s = diff / v; + rdif = diffc(r); + gdif = diffc(g); + bdif = diffc(b); + + if (r === v) { + h = bdif - gdif; + } else if (g === v) { + h = (1 / 3) + rdif - bdif; + } else if (b === v) { + h = (2 / 3) + gdif - rdif; + } + + if (h < 0) { + h += 1; + } else if (h > 1) { + h -= 1; + } + } + + return [ + h * 360, + s * 100, + v * 100 + ]; +}; + +convert.rgb.hwb = function (rgb) { + const r = rgb[0]; + const g = rgb[1]; + let b = rgb[2]; + const h = convert.rgb.hsl(rgb)[0]; + const w = 1 / 255 * Math.min(r, Math.min(g, b)); + + b = 1 - 1 / 255 * Math.max(r, Math.max(g, b)); + + return [h, w * 100, b * 100]; +}; + +convert.rgb.cmyk = function (rgb) { + const r = rgb[0] / 255; + const g = rgb[1] / 255; + const b = rgb[2] / 255; + + const k = Math.min(1 - r, 1 - g, 1 - b); + const c = (1 - r - k) / (1 - k) || 0; + const m = (1 - g - k) / (1 - k) || 0; + const y = (1 - b - k) / (1 - k) || 0; + + return [c * 100, m * 100, y * 100, k * 100]; +}; + +function comparativeDistance(x, y) { + /* + See https://en.m.wikipedia.org/wiki/Euclidean_distance#Squared_Euclidean_distance + */ + return ( + ((x[0] - y[0]) ** 2) + + ((x[1] - y[1]) ** 2) + + ((x[2] - y[2]) ** 2) + ); +} + +convert.rgb.keyword = function (rgb) { + const reversed = reverseKeywords[rgb]; + if (reversed) { + return reversed; + } + + let currentClosestDistance = Infinity; + let currentClosestKeyword; + + for (const keyword of Object.keys(cssKeywords)) { + const value = cssKeywords[keyword]; + + // Compute comparative distance + const distance = comparativeDistance(rgb, value); + + // Check if its less, if so set as closest + if (distance < currentClosestDistance) { + currentClosestDistance = distance; + currentClosestKeyword = keyword; + } + } + + return currentClosestKeyword; +}; + +convert.keyword.rgb = function (keyword) { + return cssKeywords[keyword]; +}; + +convert.rgb.xyz = function (rgb) { + let r = rgb[0] / 255; + let g = rgb[1] / 255; + let b = rgb[2] / 255; + + // Assume sRGB + r = r > 0.04045 ? (((r + 0.055) / 1.055) ** 2.4) : (r / 12.92); + g = g > 0.04045 ? (((g + 0.055) / 1.055) ** 2.4) : (g / 12.92); + b = b > 0.04045 ? (((b + 0.055) / 1.055) ** 2.4) : (b / 12.92); + + const x = (r * 0.4124) + (g * 0.3576) + (b * 0.1805); + const y = (r * 0.2126) + (g * 0.7152) + (b * 0.0722); + const z = (r * 0.0193) + (g * 0.1192) + (b * 0.9505); + + return [x * 100, y * 100, z * 100]; +}; + +convert.rgb.lab = function (rgb) { + const xyz = convert.rgb.xyz(rgb); + let x = xyz[0]; + let y = xyz[1]; + let z = xyz[2]; + + x /= 95.047; + y /= 100; + z /= 108.883; + + x = x > 0.008856 ? (x ** (1 / 3)) : (7.787 * x) + (16 / 116); + y = y > 0.008856 ? (y ** (1 / 3)) : (7.787 * y) + (16 / 116); + z = z > 0.008856 ? (z ** (1 / 3)) : (7.787 * z) + (16 / 116); + + const l = (116 * y) - 16; + const a = 500 * (x - y); + const b = 200 * (y - z); + + return [l, a, b]; +}; + +convert.hsl.rgb = function (hsl) { + const h = hsl[0] / 360; + const s = hsl[1] / 100; + const l = hsl[2] / 100; + let t2; + let t3; + let val; + + if (s === 0) { + val = l * 255; + return [val, val, val]; + } + + if (l < 0.5) { + t2 = l * (1 + s); + } else { + t2 = l + s - l * s; + } + + const t1 = 2 * l - t2; + + const rgb = [0, 0, 0]; + for (let i = 0; i < 3; i++) { + t3 = h + 1 / 3 * -(i - 1); + if (t3 < 0) { + t3++; + } + + if (t3 > 1) { + t3--; + } + + if (6 * t3 < 1) { + val = t1 + (t2 - t1) * 6 * t3; + } else if (2 * t3 < 1) { + val = t2; + } else if (3 * t3 < 2) { + val = t1 + (t2 - t1) * (2 / 3 - t3) * 6; + } else { + val = t1; + } + + rgb[i] = val * 255; + } + + return rgb; +}; + +convert.hsl.hsv = function (hsl) { + const h = hsl[0]; + let s = hsl[1] / 100; + let l = hsl[2] / 100; + let smin = s; + const lmin = Math.max(l, 0.01); + + l *= 2; + s *= (l <= 1) ? l : 2 - l; + smin *= lmin <= 1 ? lmin : 2 - lmin; + const v = (l + s) / 2; + const sv = l === 0 ? (2 * smin) / (lmin + smin) : (2 * s) / (l + s); + + return [h, sv * 100, v * 100]; +}; + +convert.hsv.rgb = function (hsv) { + const h = hsv[0] / 60; + const s = hsv[1] / 100; + let v = hsv[2] / 100; + const hi = Math.floor(h) % 6; + + const f = h - Math.floor(h); + const p = 255 * v * (1 - s); + const q = 255 * v * (1 - (s * f)); + const t = 255 * v * (1 - (s * (1 - f))); + v *= 255; + + switch (hi) { + case 0: + return [v, t, p]; + case 1: + return [q, v, p]; + case 2: + return [p, v, t]; + case 3: + return [p, q, v]; + case 4: + return [t, p, v]; + case 5: + return [v, p, q]; + } +}; + +convert.hsv.hsl = function (hsv) { + const h = hsv[0]; + const s = hsv[1] / 100; + const v = hsv[2] / 100; + const vmin = Math.max(v, 0.01); + let sl; + let l; + + l = (2 - s) * v; + const lmin = (2 - s) * vmin; + sl = s * vmin; + sl /= (lmin <= 1) ? lmin : 2 - lmin; + sl = sl || 0; + l /= 2; + + return [h, sl * 100, l * 100]; +}; + +// http://dev.w3.org/csswg/css-color/#hwb-to-rgb +convert.hwb.rgb = function (hwb) { + const h = hwb[0] / 360; + let wh = hwb[1] / 100; + let bl = hwb[2] / 100; + const ratio = wh + bl; + let f; + + // Wh + bl cant be > 1 + if (ratio > 1) { + wh /= ratio; + bl /= ratio; + } + + const i = Math.floor(6 * h); + const v = 1 - bl; + f = 6 * h - i; + + if ((i & 0x01) !== 0) { + f = 1 - f; + } + + const n = wh + f * (v - wh); // Linear interpolation + + let r; + let g; + let b; + /* eslint-disable max-statements-per-line,no-multi-spaces */ + switch (i) { + default: + case 6: + case 0: r = v; g = n; b = wh; break; + case 1: r = n; g = v; b = wh; break; + case 2: r = wh; g = v; b = n; break; + case 3: r = wh; g = n; b = v; break; + case 4: r = n; g = wh; b = v; break; + case 5: r = v; g = wh; b = n; break; + } + /* eslint-enable max-statements-per-line,no-multi-spaces */ + + return [r * 255, g * 255, b * 255]; +}; + +convert.cmyk.rgb = function (cmyk) { + const c = cmyk[0] / 100; + const m = cmyk[1] / 100; + const y = cmyk[2] / 100; + const k = cmyk[3] / 100; + + const r = 1 - Math.min(1, c * (1 - k) + k); + const g = 1 - Math.min(1, m * (1 - k) + k); + const b = 1 - Math.min(1, y * (1 - k) + k); + + return [r * 255, g * 255, b * 255]; +}; + +convert.xyz.rgb = function (xyz) { + const x = xyz[0] / 100; + const y = xyz[1] / 100; + const z = xyz[2] / 100; + let r; + let g; + let b; + + r = (x * 3.2406) + (y * -1.5372) + (z * -0.4986); + g = (x * -0.9689) + (y * 1.8758) + (z * 0.0415); + b = (x * 0.0557) + (y * -0.2040) + (z * 1.0570); + + // Assume sRGB + r = r > 0.0031308 + ? ((1.055 * (r ** (1.0 / 2.4))) - 0.055) + : r * 12.92; + + g = g > 0.0031308 + ? ((1.055 * (g ** (1.0 / 2.4))) - 0.055) + : g * 12.92; + + b = b > 0.0031308 + ? ((1.055 * (b ** (1.0 / 2.4))) - 0.055) + : b * 12.92; + + r = Math.min(Math.max(0, r), 1); + g = Math.min(Math.max(0, g), 1); + b = Math.min(Math.max(0, b), 1); + + return [r * 255, g * 255, b * 255]; +}; + +convert.xyz.lab = function (xyz) { + let x = xyz[0]; + let y = xyz[1]; + let z = xyz[2]; + + x /= 95.047; + y /= 100; + z /= 108.883; + + x = x > 0.008856 ? (x ** (1 / 3)) : (7.787 * x) + (16 / 116); + y = y > 0.008856 ? (y ** (1 / 3)) : (7.787 * y) + (16 / 116); + z = z > 0.008856 ? (z ** (1 / 3)) : (7.787 * z) + (16 / 116); + + const l = (116 * y) - 16; + const a = 500 * (x - y); + const b = 200 * (y - z); + + return [l, a, b]; +}; + +convert.lab.xyz = function (lab) { + const l = lab[0]; + const a = lab[1]; + const b = lab[2]; + let x; + let y; + let z; + + y = (l + 16) / 116; + x = a / 500 + y; + z = y - b / 200; + + const y2 = y ** 3; + const x2 = x ** 3; + const z2 = z ** 3; + y = y2 > 0.008856 ? y2 : (y - 16 / 116) / 7.787; + x = x2 > 0.008856 ? x2 : (x - 16 / 116) / 7.787; + z = z2 > 0.008856 ? z2 : (z - 16 / 116) / 7.787; + + x *= 95.047; + y *= 100; + z *= 108.883; + + return [x, y, z]; +}; + +convert.lab.lch = function (lab) { + const l = lab[0]; + const a = lab[1]; + const b = lab[2]; + let h; + + const hr = Math.atan2(b, a); + h = hr * 360 / 2 / Math.PI; + + if (h < 0) { + h += 360; + } + + const c = Math.sqrt(a * a + b * b); + + return [l, c, h]; +}; + +convert.lch.lab = function (lch) { + const l = lch[0]; + const c = lch[1]; + const h = lch[2]; + + const hr = h / 360 * 2 * Math.PI; + const a = c * Math.cos(hr); + const b = c * Math.sin(hr); + + return [l, a, b]; +}; + +convert.rgb.ansi16 = function (args, saturation = null) { + const [r, g, b] = args; + let value = saturation === null ? convert.rgb.hsv(args)[2] : saturation; // Hsv -> ansi16 optimization + + value = Math.round(value / 50); + + if (value === 0) { + return 30; + } + + let ansi = 30 + + ((Math.round(b / 255) << 2) + | (Math.round(g / 255) << 1) + | Math.round(r / 255)); + + if (value === 2) { + ansi += 60; + } + + return ansi; +}; + +convert.hsv.ansi16 = function (args) { + // Optimization here; we already know the value and don't need to get + // it converted for us. + return convert.rgb.ansi16(convert.hsv.rgb(args), args[2]); +}; + +convert.rgb.ansi256 = function (args) { + const r = args[0]; + const g = args[1]; + const b = args[2]; + + // We use the extended greyscale palette here, with the exception of + // black and white. normal palette only has 4 greyscale shades. + if (r === g && g === b) { + if (r < 8) { + return 16; + } + + if (r > 248) { + return 231; + } + + return Math.round(((r - 8) / 247) * 24) + 232; + } + + const ansi = 16 + + (36 * Math.round(r / 255 * 5)) + + (6 * Math.round(g / 255 * 5)) + + Math.round(b / 255 * 5); + + return ansi; +}; + +convert.ansi16.rgb = function (args) { + let color = args % 10; + + // Handle greyscale + if (color === 0 || color === 7) { + if (args > 50) { + color += 3.5; + } + + color = color / 10.5 * 255; + + return [color, color, color]; + } + + const mult = (~~(args > 50) + 1) * 0.5; + const r = ((color & 1) * mult) * 255; + const g = (((color >> 1) & 1) * mult) * 255; + const b = (((color >> 2) & 1) * mult) * 255; + + return [r, g, b]; +}; + +convert.ansi256.rgb = function (args) { + // Handle greyscale + if (args >= 232) { + const c = (args - 232) * 10 + 8; + return [c, c, c]; + } + + args -= 16; + + let rem; + const r = Math.floor(args / 36) / 5 * 255; + const g = Math.floor((rem = args % 36) / 6) / 5 * 255; + const b = (rem % 6) / 5 * 255; + + return [r, g, b]; +}; + +convert.rgb.hex = function (args) { + const integer = ((Math.round(args[0]) & 0xFF) << 16) + + ((Math.round(args[1]) & 0xFF) << 8) + + (Math.round(args[2]) & 0xFF); + + const string = integer.toString(16).toUpperCase(); + return '000000'.substring(string.length) + string; +}; + +convert.hex.rgb = function (args) { + const match = args.toString(16).match(/[a-f0-9]{6}|[a-f0-9]{3}/i); + if (!match) { + return [0, 0, 0]; + } + + let colorString = match[0]; + + if (match[0].length === 3) { + colorString = colorString.split('').map(char => { + return char + char; + }).join(''); + } + + const integer = parseInt(colorString, 16); + const r = (integer >> 16) & 0xFF; + const g = (integer >> 8) & 0xFF; + const b = integer & 0xFF; + + return [r, g, b]; +}; + +convert.rgb.hcg = function (rgb) { + const r = rgb[0] / 255; + const g = rgb[1] / 255; + const b = rgb[2] / 255; + const max = Math.max(Math.max(r, g), b); + const min = Math.min(Math.min(r, g), b); + const chroma = (max - min); + let grayscale; + let hue; + + if (chroma < 1) { + grayscale = min / (1 - chroma); + } else { + grayscale = 0; + } + + if (chroma <= 0) { + hue = 0; + } else + if (max === r) { + hue = ((g - b) / chroma) % 6; + } else + if (max === g) { + hue = 2 + (b - r) / chroma; + } else { + hue = 4 + (r - g) / chroma; + } + + hue /= 6; + hue %= 1; + + return [hue * 360, chroma * 100, grayscale * 100]; +}; + +convert.hsl.hcg = function (hsl) { + const s = hsl[1] / 100; + const l = hsl[2] / 100; + + const c = l < 0.5 ? (2.0 * s * l) : (2.0 * s * (1.0 - l)); + + let f = 0; + if (c < 1.0) { + f = (l - 0.5 * c) / (1.0 - c); + } + + return [hsl[0], c * 100, f * 100]; +}; + +convert.hsv.hcg = function (hsv) { + const s = hsv[1] / 100; + const v = hsv[2] / 100; + + const c = s * v; + let f = 0; + + if (c < 1.0) { + f = (v - c) / (1 - c); + } + + return [hsv[0], c * 100, f * 100]; +}; + +convert.hcg.rgb = function (hcg) { + const h = hcg[0] / 360; + const c = hcg[1] / 100; + const g = hcg[2] / 100; + + if (c === 0.0) { + return [g * 255, g * 255, g * 255]; + } + + const pure = [0, 0, 0]; + const hi = (h % 1) * 6; + const v = hi % 1; + const w = 1 - v; + let mg = 0; + + /* eslint-disable max-statements-per-line */ + switch (Math.floor(hi)) { + case 0: + pure[0] = 1; pure[1] = v; pure[2] = 0; break; + case 1: + pure[0] = w; pure[1] = 1; pure[2] = 0; break; + case 2: + pure[0] = 0; pure[1] = 1; pure[2] = v; break; + case 3: + pure[0] = 0; pure[1] = w; pure[2] = 1; break; + case 4: + pure[0] = v; pure[1] = 0; pure[2] = 1; break; + default: + pure[0] = 1; pure[1] = 0; pure[2] = w; + } + /* eslint-enable max-statements-per-line */ + + mg = (1.0 - c) * g; + + return [ + (c * pure[0] + mg) * 255, + (c * pure[1] + mg) * 255, + (c * pure[2] + mg) * 255 + ]; +}; + +convert.hcg.hsv = function (hcg) { + const c = hcg[1] / 100; + const g = hcg[2] / 100; + + const v = c + g * (1.0 - c); + let f = 0; + + if (v > 0.0) { + f = c / v; + } + + return [hcg[0], f * 100, v * 100]; +}; + +convert.hcg.hsl = function (hcg) { + const c = hcg[1] / 100; + const g = hcg[2] / 100; + + const l = g * (1.0 - c) + 0.5 * c; + let s = 0; + + if (l > 0.0 && l < 0.5) { + s = c / (2 * l); + } else + if (l >= 0.5 && l < 1.0) { + s = c / (2 * (1 - l)); + } + + return [hcg[0], s * 100, l * 100]; +}; + +convert.hcg.hwb = function (hcg) { + const c = hcg[1] / 100; + const g = hcg[2] / 100; + const v = c + g * (1.0 - c); + return [hcg[0], (v - c) * 100, (1 - v) * 100]; +}; + +convert.hwb.hcg = function (hwb) { + const w = hwb[1] / 100; + const b = hwb[2] / 100; + const v = 1 - b; + const c = v - w; + let g = 0; + + if (c < 1) { + g = (v - c) / (1 - c); + } + + return [hwb[0], c * 100, g * 100]; +}; + +convert.apple.rgb = function (apple) { + return [(apple[0] / 65535) * 255, (apple[1] / 65535) * 255, (apple[2] / 65535) * 255]; +}; + +convert.rgb.apple = function (rgb) { + return [(rgb[0] / 255) * 65535, (rgb[1] / 255) * 65535, (rgb[2] / 255) * 65535]; +}; + +convert.gray.rgb = function (args) { + return [args[0] / 100 * 255, args[0] / 100 * 255, args[0] / 100 * 255]; +}; + +convert.gray.hsl = function (args) { + return [0, 0, args[0]]; +}; + +convert.gray.hsv = convert.gray.hsl; + +convert.gray.hwb = function (gray) { + return [0, 100, gray[0]]; +}; + +convert.gray.cmyk = function (gray) { + return [0, 0, 0, gray[0]]; +}; + +convert.gray.lab = function (gray) { + return [gray[0], 0, 0]; +}; + +convert.gray.hex = function (gray) { + const val = Math.round(gray[0] / 100 * 255) & 0xFF; + const integer = (val << 16) + (val << 8) + val; + + const string = integer.toString(16).toUpperCase(); + return '000000'.substring(string.length) + string; +}; + +convert.rgb.gray = function (rgb) { + const val = (rgb[0] + rgb[1] + rgb[2]) / 3; + return [val / 255 * 100]; +}; diff --git a/node_modules/color-convert/index.js b/node_modules/color-convert/index.js new file mode 100644 index 0000000..b648e57 --- /dev/null +++ b/node_modules/color-convert/index.js @@ -0,0 +1,81 @@ +const conversions = require('./conversions'); +const route = require('./route'); + +const convert = {}; + +const models = Object.keys(conversions); + +function wrapRaw(fn) { + const wrappedFn = function (...args) { + const arg0 = args[0]; + if (arg0 === undefined || arg0 === null) { + return arg0; + } + + if (arg0.length > 1) { + args = arg0; + } + + return fn(args); + }; + + // Preserve .conversion property if there is one + if ('conversion' in fn) { + wrappedFn.conversion = fn.conversion; + } + + return wrappedFn; +} + +function wrapRounded(fn) { + const wrappedFn = function (...args) { + const arg0 = args[0]; + + if (arg0 === undefined || arg0 === null) { + return arg0; + } + + if (arg0.length > 1) { + args = arg0; + } + + const result = fn(args); + + // We're assuming the result is an array here. + // see notice in conversions.js; don't use box types + // in conversion functions. + if (typeof result === 'object') { + for (let len = result.length, i = 0; i < len; i++) { + result[i] = Math.round(result[i]); + } + } + + return result; + }; + + // Preserve .conversion property if there is one + if ('conversion' in fn) { + wrappedFn.conversion = fn.conversion; + } + + return wrappedFn; +} + +models.forEach(fromModel => { + convert[fromModel] = {}; + + Object.defineProperty(convert[fromModel], 'channels', {value: conversions[fromModel].channels}); + Object.defineProperty(convert[fromModel], 'labels', {value: conversions[fromModel].labels}); + + const routes = route(fromModel); + const routeModels = Object.keys(routes); + + routeModels.forEach(toModel => { + const fn = routes[toModel]; + + convert[fromModel][toModel] = wrapRounded(fn); + convert[fromModel][toModel].raw = wrapRaw(fn); + }); +}); + +module.exports = convert; diff --git a/node_modules/color-convert/package.json b/node_modules/color-convert/package.json new file mode 100644 index 0000000..6e48000 --- /dev/null +++ b/node_modules/color-convert/package.json @@ -0,0 +1,48 @@ +{ + "name": "color-convert", + "description": "Plain color conversion functions", + "version": "2.0.1", + "author": "Heather Arthur ", + "license": "MIT", + "repository": "Qix-/color-convert", + "scripts": { + "pretest": "xo", + "test": "node test/basic.js" + }, + "engines": { + "node": ">=7.0.0" + }, + "keywords": [ + "color", + "colour", + "convert", + "converter", + "conversion", + "rgb", + "hsl", + "hsv", + "hwb", + "cmyk", + "ansi", + "ansi16" + ], + "files": [ + "index.js", + "conversions.js", + "route.js" + ], + "xo": { + "rules": { + "default-case": 0, + "no-inline-comments": 0, + "operator-linebreak": 0 + } + }, + "devDependencies": { + "chalk": "^2.4.2", + "xo": "^0.24.0" + }, + "dependencies": { + "color-name": "~1.1.4" + } +} diff --git a/node_modules/color-convert/route.js b/node_modules/color-convert/route.js new file mode 100644 index 0000000..1a08521 --- /dev/null +++ b/node_modules/color-convert/route.js @@ -0,0 +1,97 @@ +const conversions = require('./conversions'); + +/* + This function routes a model to all other models. + + all functions that are routed have a property `.conversion` attached + to the returned synthetic function. This property is an array + of strings, each with the steps in between the 'from' and 'to' + color models (inclusive). + + conversions that are not possible simply are not included. +*/ + +function buildGraph() { + const graph = {}; + // https://jsperf.com/object-keys-vs-for-in-with-closure/3 + const models = Object.keys(conversions); + + for (let len = models.length, i = 0; i < len; i++) { + graph[models[i]] = { + // http://jsperf.com/1-vs-infinity + // micro-opt, but this is simple. + distance: -1, + parent: null + }; + } + + return graph; +} + +// https://en.wikipedia.org/wiki/Breadth-first_search +function deriveBFS(fromModel) { + const graph = buildGraph(); + const queue = [fromModel]; // Unshift -> queue -> pop + + graph[fromModel].distance = 0; + + while (queue.length) { + const current = queue.pop(); + const adjacents = Object.keys(conversions[current]); + + for (let len = adjacents.length, i = 0; i < len; i++) { + const adjacent = adjacents[i]; + const node = graph[adjacent]; + + if (node.distance === -1) { + node.distance = graph[current].distance + 1; + node.parent = current; + queue.unshift(adjacent); + } + } + } + + return graph; +} + +function link(from, to) { + return function (args) { + return to(from(args)); + }; +} + +function wrapConversion(toModel, graph) { + const path = [graph[toModel].parent, toModel]; + let fn = conversions[graph[toModel].parent][toModel]; + + let cur = graph[toModel].parent; + while (graph[cur].parent) { + path.unshift(graph[cur].parent); + fn = link(conversions[graph[cur].parent][cur], fn); + cur = graph[cur].parent; + } + + fn.conversion = path; + return fn; +} + +module.exports = function (fromModel) { + const graph = deriveBFS(fromModel); + const conversion = {}; + + const models = Object.keys(graph); + for (let len = models.length, i = 0; i < len; i++) { + const toModel = models[i]; + const node = graph[toModel]; + + if (node.parent === null) { + // No possible conversion, or this node is the source model. + continue; + } + + conversion[toModel] = wrapConversion(toModel, graph); + } + + return conversion; +}; + diff --git a/node_modules/color-name/LICENSE b/node_modules/color-name/LICENSE new file mode 100644 index 0000000..4d9802a --- /dev/null +++ b/node_modules/color-name/LICENSE @@ -0,0 +1,8 @@ +The MIT License (MIT) +Copyright (c) 2015 Dmitry Ivanov + +Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. \ No newline at end of file diff --git a/node_modules/color-name/README.md b/node_modules/color-name/README.md new file mode 100644 index 0000000..3611a6b --- /dev/null +++ b/node_modules/color-name/README.md @@ -0,0 +1,11 @@ +A JSON with color names and its values. Based on http://dev.w3.org/csswg/css-color/#named-colors. + +[![NPM](https://nodei.co/npm/color-name.png?mini=true)](https://nodei.co/npm/color-name/) + + +```js +var colors = require('color-name'); +colors.red //[255,0,0] +``` + + diff --git a/node_modules/color-name/index.js b/node_modules/color-name/index.js new file mode 100644 index 0000000..e42aa68 --- /dev/null +++ b/node_modules/color-name/index.js @@ -0,0 +1,152 @@ +'use strict' + +module.exports = { + "aliceblue": [240, 248, 255], + "antiquewhite": [250, 235, 215], + "aqua": [0, 255, 255], + "aquamarine": [127, 255, 212], + "azure": [240, 255, 255], + "beige": [245, 245, 220], + "bisque": [255, 228, 196], + "black": [0, 0, 0], + "blanchedalmond": [255, 235, 205], + "blue": [0, 0, 255], + "blueviolet": [138, 43, 226], + "brown": [165, 42, 42], + "burlywood": [222, 184, 135], + "cadetblue": [95, 158, 160], + "chartreuse": [127, 255, 0], + "chocolate": [210, 105, 30], + "coral": [255, 127, 80], + "cornflowerblue": [100, 149, 237], + "cornsilk": [255, 248, 220], + "crimson": [220, 20, 60], + "cyan": [0, 255, 255], + "darkblue": [0, 0, 139], + "darkcyan": [0, 139, 139], + "darkgoldenrod": [184, 134, 11], + "darkgray": [169, 169, 169], + "darkgreen": [0, 100, 0], + "darkgrey": [169, 169, 169], + "darkkhaki": [189, 183, 107], + "darkmagenta": [139, 0, 139], + "darkolivegreen": [85, 107, 47], + "darkorange": [255, 140, 0], + "darkorchid": [153, 50, 204], + "darkred": [139, 0, 0], + "darksalmon": [233, 150, 122], + "darkseagreen": [143, 188, 143], + "darkslateblue": [72, 61, 139], + "darkslategray": [47, 79, 79], + "darkslategrey": [47, 79, 79], + "darkturquoise": [0, 206, 209], + "darkviolet": [148, 0, 211], + "deeppink": [255, 20, 147], + "deepskyblue": [0, 191, 255], + "dimgray": [105, 105, 105], + "dimgrey": [105, 105, 105], + "dodgerblue": [30, 144, 255], + "firebrick": [178, 34, 34], + "floralwhite": [255, 250, 240], + "forestgreen": [34, 139, 34], + "fuchsia": [255, 0, 255], + "gainsboro": [220, 220, 220], + "ghostwhite": [248, 248, 255], + "gold": [255, 215, 0], + "goldenrod": [218, 165, 32], + "gray": [128, 128, 128], + "green": [0, 128, 0], + "greenyellow": [173, 255, 47], + "grey": [128, 128, 128], + "honeydew": [240, 255, 240], + "hotpink": [255, 105, 180], + "indianred": [205, 92, 92], + "indigo": [75, 0, 130], + "ivory": [255, 255, 240], + "khaki": [240, 230, 140], + "lavender": [230, 230, 250], + "lavenderblush": [255, 240, 245], + "lawngreen": [124, 252, 0], + "lemonchiffon": [255, 250, 205], + "lightblue": [173, 216, 230], + "lightcoral": [240, 128, 128], + "lightcyan": [224, 255, 255], + "lightgoldenrodyellow": [250, 250, 210], + "lightgray": [211, 211, 211], + "lightgreen": [144, 238, 144], + "lightgrey": [211, 211, 211], + "lightpink": [255, 182, 193], + "lightsalmon": [255, 160, 122], + "lightseagreen": [32, 178, 170], + "lightskyblue": [135, 206, 250], + "lightslategray": [119, 136, 153], + "lightslategrey": [119, 136, 153], + "lightsteelblue": [176, 196, 222], + "lightyellow": [255, 255, 224], + "lime": [0, 255, 0], + "limegreen": [50, 205, 50], + "linen": [250, 240, 230], + "magenta": [255, 0, 255], + "maroon": [128, 0, 0], + "mediumaquamarine": [102, 205, 170], + "mediumblue": [0, 0, 205], + "mediumorchid": [186, 85, 211], + "mediumpurple": [147, 112, 219], + "mediumseagreen": [60, 179, 113], + "mediumslateblue": [123, 104, 238], + "mediumspringgreen": [0, 250, 154], + "mediumturquoise": [72, 209, 204], + "mediumvioletred": [199, 21, 133], + "midnightblue": [25, 25, 112], + "mintcream": [245, 255, 250], + "mistyrose": [255, 228, 225], + "moccasin": [255, 228, 181], + "navajowhite": [255, 222, 173], + "navy": [0, 0, 128], + "oldlace": [253, 245, 230], + "olive": [128, 128, 0], + "olivedrab": [107, 142, 35], + "orange": [255, 165, 0], + "orangered": [255, 69, 0], + "orchid": [218, 112, 214], + "palegoldenrod": [238, 232, 170], + "palegreen": [152, 251, 152], + "paleturquoise": [175, 238, 238], + "palevioletred": [219, 112, 147], + "papayawhip": [255, 239, 213], + "peachpuff": [255, 218, 185], + "peru": [205, 133, 63], + "pink": [255, 192, 203], + "plum": [221, 160, 221], + "powderblue": [176, 224, 230], + "purple": [128, 0, 128], + "rebeccapurple": [102, 51, 153], + "red": [255, 0, 0], + "rosybrown": [188, 143, 143], + "royalblue": [65, 105, 225], + "saddlebrown": [139, 69, 19], + "salmon": [250, 128, 114], + "sandybrown": [244, 164, 96], + "seagreen": [46, 139, 87], + "seashell": [255, 245, 238], + "sienna": [160, 82, 45], + "silver": [192, 192, 192], + "skyblue": [135, 206, 235], + "slateblue": [106, 90, 205], + "slategray": [112, 128, 144], + "slategrey": [112, 128, 144], + "snow": [255, 250, 250], + "springgreen": [0, 255, 127], + "steelblue": [70, 130, 180], + "tan": [210, 180, 140], + "teal": [0, 128, 128], + "thistle": [216, 191, 216], + "tomato": [255, 99, 71], + "turquoise": [64, 224, 208], + "violet": [238, 130, 238], + "wheat": [245, 222, 179], + "white": [255, 255, 255], + "whitesmoke": [245, 245, 245], + "yellow": [255, 255, 0], + "yellowgreen": [154, 205, 50] +}; diff --git a/node_modules/color-name/package.json b/node_modules/color-name/package.json new file mode 100644 index 0000000..7acc902 --- /dev/null +++ b/node_modules/color-name/package.json @@ -0,0 +1,28 @@ +{ + "name": "color-name", + "version": "1.1.4", + "description": "A list of color names and its values", + "main": "index.js", + "files": [ + "index.js" + ], + "scripts": { + "test": "node test.js" + }, + "repository": { + "type": "git", + "url": "git@github.com:colorjs/color-name.git" + }, + "keywords": [ + "color-name", + "color", + "color-keyword", + "keyword" + ], + "author": "DY ", + "license": "MIT", + "bugs": { + "url": "https://github.com/colorjs/color-name/issues" + }, + "homepage": "https://github.com/colorjs/color-name" +} diff --git a/node_modules/color-string/LICENSE b/node_modules/color-string/LICENSE new file mode 100644 index 0000000..a8b08d4 --- /dev/null +++ b/node_modules/color-string/LICENSE @@ -0,0 +1,21 @@ +Copyright (c) 2011 Heather Arthur + +Permission is hereby granted, free of charge, to any person obtaining +a copy of this software and associated documentation files (the +"Software"), to deal in the Software without restriction, including +without limitation the rights to use, copy, modify, merge, publish, +distribute, sublicense, and/or sell copies of the Software, and to +permit persons to whom the Software is furnished to do so, subject to +the following conditions: + +The above copyright notice and this permission notice shall be +included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE +LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION +OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + diff --git a/node_modules/color-string/README.md b/node_modules/color-string/README.md new file mode 100644 index 0000000..e58670c --- /dev/null +++ b/node_modules/color-string/README.md @@ -0,0 +1,62 @@ +# color-string + +> library for parsing and generating CSS color strings. + +## Install + +With [npm](http://npmjs.org/): + +```console +$ npm install color-string +``` + +## Usage + +### Parsing + +```js +colorString.get('#FFF') // {model: 'rgb', value: [255, 255, 255, 1]} +colorString.get('#FFFA') // {model: 'rgb', value: [255, 255, 255, 0.67]} +colorString.get('#FFFFFFAA') // {model: 'rgb', value: [255, 255, 255, 0.67]} +colorString.get('hsl(360, 100%, 50%)') // {model: 'hsl', value: [0, 100, 50, 1]} +colorString.get('hsl(360 100% 50%)') // {model: 'hsl', value: [0, 100, 50, 1]} +colorString.get('hwb(60, 3%, 60%)') // {model: 'hwb', value: [60, 3, 60, 1]} + +colorString.get.rgb('#FFF') // [255, 255, 255, 1] +colorString.get.rgb('blue') // [0, 0, 255, 1] +colorString.get.rgb('rgba(200, 60, 60, 0.3)') // [200, 60, 60, 0.3] +colorString.get.rgb('rgba(200 60 60 / 0.3)') // [200, 60, 60, 0.3] +colorString.get.rgb('rgba(200 60 60 / 30%)') // [200, 60, 60, 0.3] +colorString.get.rgb('rgb(200, 200, 200)') // [200, 200, 200, 1] +colorString.get.rgb('rgb(200 200 200)') // [200, 200, 200, 1] + +colorString.get.hsl('hsl(360, 100%, 50%)') // [0, 100, 50, 1] +colorString.get.hsl('hsl(360 100% 50%)') // [0, 100, 50, 1] +colorString.get.hsl('hsla(360, 60%, 50%, 0.4)') // [0, 60, 50, 0.4] +colorString.get.hsl('hsl(360 60% 50% / 0.4)') // [0, 60, 50, 0.4] + +colorString.get.hwb('hwb(60, 3%, 60%)') // [60, 3, 60, 1] +colorString.get.hwb('hwb(60, 3%, 60%, 0.6)') // [60, 3, 60, 0.6] + +colorString.get.rgb('invalid color string') // null +``` + +### Generation + +```js +colorString.to.hex([255, 255, 255]) // "#FFFFFF" +colorString.to.hex([0, 0, 255, 0.4]) // "#0000FF66" +colorString.to.hex([0, 0, 255], 0.4) // "#0000FF66" +colorString.to.rgb([255, 255, 255]) // "rgb(255, 255, 255)" +colorString.to.rgb([0, 0, 255, 0.4]) // "rgba(0, 0, 255, 0.4)" +colorString.to.rgb([0, 0, 255], 0.4) // "rgba(0, 0, 255, 0.4)" +colorString.to.rgb.percent([0, 0, 255]) // "rgb(0%, 0%, 100%)" +colorString.to.keyword([255, 255, 0]) // "yellow" +colorString.to.hsl([360, 100, 100]) // "hsl(360, 100%, 100%)" +colorString.to.hwb([50, 3, 15]) // "hwb(50, 3%, 15%)" + +// all functions also support swizzling +colorString.to.rgb(0, [0, 255], 0.4) // "rgba(0, 0, 255, 0.4)" +colorString.to.rgb([0, 0], [255], 0.4) // "rgba(0, 0, 255, 0.4)" +colorString.to.rgb([0], 0, [255, 0.4]) // "rgba(0, 0, 255, 0.4)" +``` diff --git a/node_modules/color-string/index.js b/node_modules/color-string/index.js new file mode 100644 index 0000000..dd5d2b7 --- /dev/null +++ b/node_modules/color-string/index.js @@ -0,0 +1,242 @@ +/* MIT license */ +var colorNames = require('color-name'); +var swizzle = require('simple-swizzle'); +var hasOwnProperty = Object.hasOwnProperty; + +var reverseNames = Object.create(null); + +// create a list of reverse color names +for (var name in colorNames) { + if (hasOwnProperty.call(colorNames, name)) { + reverseNames[colorNames[name]] = name; + } +} + +var cs = module.exports = { + to: {}, + get: {} +}; + +cs.get = function (string) { + var prefix = string.substring(0, 3).toLowerCase(); + var val; + var model; + switch (prefix) { + case 'hsl': + val = cs.get.hsl(string); + model = 'hsl'; + break; + case 'hwb': + val = cs.get.hwb(string); + model = 'hwb'; + break; + default: + val = cs.get.rgb(string); + model = 'rgb'; + break; + } + + if (!val) { + return null; + } + + return {model: model, value: val}; +}; + +cs.get.rgb = function (string) { + if (!string) { + return null; + } + + var abbr = /^#([a-f0-9]{3,4})$/i; + var hex = /^#([a-f0-9]{6})([a-f0-9]{2})?$/i; + var rgba = /^rgba?\(\s*([+-]?\d+)(?=[\s,])\s*(?:,\s*)?([+-]?\d+)(?=[\s,])\s*(?:,\s*)?([+-]?\d+)\s*(?:[,|\/]\s*([+-]?[\d\.]+)(%?)\s*)?\)$/; + var per = /^rgba?\(\s*([+-]?[\d\.]+)\%\s*,?\s*([+-]?[\d\.]+)\%\s*,?\s*([+-]?[\d\.]+)\%\s*(?:[,|\/]\s*([+-]?[\d\.]+)(%?)\s*)?\)$/; + var keyword = /^(\w+)$/; + + var rgb = [0, 0, 0, 1]; + var match; + var i; + var hexAlpha; + + if (match = string.match(hex)) { + hexAlpha = match[2]; + match = match[1]; + + for (i = 0; i < 3; i++) { + // https://jsperf.com/slice-vs-substr-vs-substring-methods-long-string/19 + var i2 = i * 2; + rgb[i] = parseInt(match.slice(i2, i2 + 2), 16); + } + + if (hexAlpha) { + rgb[3] = parseInt(hexAlpha, 16) / 255; + } + } else if (match = string.match(abbr)) { + match = match[1]; + hexAlpha = match[3]; + + for (i = 0; i < 3; i++) { + rgb[i] = parseInt(match[i] + match[i], 16); + } + + if (hexAlpha) { + rgb[3] = parseInt(hexAlpha + hexAlpha, 16) / 255; + } + } else if (match = string.match(rgba)) { + for (i = 0; i < 3; i++) { + rgb[i] = parseInt(match[i + 1], 0); + } + + if (match[4]) { + if (match[5]) { + rgb[3] = parseFloat(match[4]) * 0.01; + } else { + rgb[3] = parseFloat(match[4]); + } + } + } else if (match = string.match(per)) { + for (i = 0; i < 3; i++) { + rgb[i] = Math.round(parseFloat(match[i + 1]) * 2.55); + } + + if (match[4]) { + if (match[5]) { + rgb[3] = parseFloat(match[4]) * 0.01; + } else { + rgb[3] = parseFloat(match[4]); + } + } + } else if (match = string.match(keyword)) { + if (match[1] === 'transparent') { + return [0, 0, 0, 0]; + } + + if (!hasOwnProperty.call(colorNames, match[1])) { + return null; + } + + rgb = colorNames[match[1]]; + rgb[3] = 1; + + return rgb; + } else { + return null; + } + + for (i = 0; i < 3; i++) { + rgb[i] = clamp(rgb[i], 0, 255); + } + rgb[3] = clamp(rgb[3], 0, 1); + + return rgb; +}; + +cs.get.hsl = function (string) { + if (!string) { + return null; + } + + var hsl = /^hsla?\(\s*([+-]?(?:\d{0,3}\.)?\d+)(?:deg)?\s*,?\s*([+-]?[\d\.]+)%\s*,?\s*([+-]?[\d\.]+)%\s*(?:[,|\/]\s*([+-]?(?=\.\d|\d)(?:0|[1-9]\d*)?(?:\.\d*)?(?:[eE][+-]?\d+)?)\s*)?\)$/; + var match = string.match(hsl); + + if (match) { + var alpha = parseFloat(match[4]); + var h = ((parseFloat(match[1]) % 360) + 360) % 360; + var s = clamp(parseFloat(match[2]), 0, 100); + var l = clamp(parseFloat(match[3]), 0, 100); + var a = clamp(isNaN(alpha) ? 1 : alpha, 0, 1); + + return [h, s, l, a]; + } + + return null; +}; + +cs.get.hwb = function (string) { + if (!string) { + return null; + } + + var hwb = /^hwb\(\s*([+-]?\d{0,3}(?:\.\d+)?)(?:deg)?\s*,\s*([+-]?[\d\.]+)%\s*,\s*([+-]?[\d\.]+)%\s*(?:,\s*([+-]?(?=\.\d|\d)(?:0|[1-9]\d*)?(?:\.\d*)?(?:[eE][+-]?\d+)?)\s*)?\)$/; + var match = string.match(hwb); + + if (match) { + var alpha = parseFloat(match[4]); + var h = ((parseFloat(match[1]) % 360) + 360) % 360; + var w = clamp(parseFloat(match[2]), 0, 100); + var b = clamp(parseFloat(match[3]), 0, 100); + var a = clamp(isNaN(alpha) ? 1 : alpha, 0, 1); + return [h, w, b, a]; + } + + return null; +}; + +cs.to.hex = function () { + var rgba = swizzle(arguments); + + return ( + '#' + + hexDouble(rgba[0]) + + hexDouble(rgba[1]) + + hexDouble(rgba[2]) + + (rgba[3] < 1 + ? (hexDouble(Math.round(rgba[3] * 255))) + : '') + ); +}; + +cs.to.rgb = function () { + var rgba = swizzle(arguments); + + return rgba.length < 4 || rgba[3] === 1 + ? 'rgb(' + Math.round(rgba[0]) + ', ' + Math.round(rgba[1]) + ', ' + Math.round(rgba[2]) + ')' + : 'rgba(' + Math.round(rgba[0]) + ', ' + Math.round(rgba[1]) + ', ' + Math.round(rgba[2]) + ', ' + rgba[3] + ')'; +}; + +cs.to.rgb.percent = function () { + var rgba = swizzle(arguments); + + var r = Math.round(rgba[0] / 255 * 100); + var g = Math.round(rgba[1] / 255 * 100); + var b = Math.round(rgba[2] / 255 * 100); + + return rgba.length < 4 || rgba[3] === 1 + ? 'rgb(' + r + '%, ' + g + '%, ' + b + '%)' + : 'rgba(' + r + '%, ' + g + '%, ' + b + '%, ' + rgba[3] + ')'; +}; + +cs.to.hsl = function () { + var hsla = swizzle(arguments); + return hsla.length < 4 || hsla[3] === 1 + ? 'hsl(' + hsla[0] + ', ' + hsla[1] + '%, ' + hsla[2] + '%)' + : 'hsla(' + hsla[0] + ', ' + hsla[1] + '%, ' + hsla[2] + '%, ' + hsla[3] + ')'; +}; + +// hwb is a bit different than rgb(a) & hsl(a) since there is no alpha specific syntax +// (hwb have alpha optional & 1 is default value) +cs.to.hwb = function () { + var hwba = swizzle(arguments); + + var a = ''; + if (hwba.length >= 4 && hwba[3] !== 1) { + a = ', ' + hwba[3]; + } + + return 'hwb(' + hwba[0] + ', ' + hwba[1] + '%, ' + hwba[2] + '%' + a + ')'; +}; + +cs.to.keyword = function (rgb) { + return reverseNames[rgb.slice(0, 3)]; +}; + +// helpers +function clamp(num, min, max) { + return Math.min(Math.max(min, num), max); +} + +function hexDouble(num) { + var str = Math.round(num).toString(16).toUpperCase(); + return (str.length < 2) ? '0' + str : str; +} diff --git a/node_modules/color-string/package.json b/node_modules/color-string/package.json new file mode 100644 index 0000000..f34ee98 --- /dev/null +++ b/node_modules/color-string/package.json @@ -0,0 +1,39 @@ +{ + "name": "color-string", + "description": "Parser and generator for CSS color strings", + "version": "1.9.1", + "author": "Heather Arthur ", + "contributors": [ + "Maxime Thirouin", + "Dyma Ywanov ", + "Josh Junon" + ], + "repository": "Qix-/color-string", + "scripts": { + "pretest": "xo", + "test": "node test/basic.js" + }, + "license": "MIT", + "files": [ + "index.js" + ], + "xo": { + "rules": { + "no-cond-assign": 0, + "operator-linebreak": 0 + } + }, + "dependencies": { + "color-name": "^1.0.0", + "simple-swizzle": "^0.2.2" + }, + "devDependencies": { + "xo": "^0.12.1" + }, + "keywords": [ + "color", + "colour", + "rgb", + "css" + ] +} diff --git a/node_modules/color/LICENSE b/node_modules/color/LICENSE new file mode 100644 index 0000000..68c864e --- /dev/null +++ b/node_modules/color/LICENSE @@ -0,0 +1,21 @@ +Copyright (c) 2012 Heather Arthur + +Permission is hereby granted, free of charge, to any person obtaining +a copy of this software and associated documentation files (the +"Software"), to deal in the Software without restriction, including +without limitation the rights to use, copy, modify, merge, publish, +distribute, sublicense, and/or sell copies of the Software, and to +permit persons to whom the Software is furnished to do so, subject to +the following conditions: + +The above copyright notice and this permission notice shall be +included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE +LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION +OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + diff --git a/node_modules/color/README.md b/node_modules/color/README.md new file mode 100644 index 0000000..674a731 --- /dev/null +++ b/node_modules/color/README.md @@ -0,0 +1,123 @@ +# color + +> JavaScript library for immutable color conversion and manipulation with support for CSS color strings. + +```js +const color = Color('#7743CE').alpha(0.5).lighten(0.5); +console.log(color.hsl().string()); // 'hsla(262, 59%, 81%, 0.5)' + +console.log(color.cmyk().round().array()); // [ 16, 25, 0, 8, 0.5 ] + +console.log(color.ansi256().object()); // { ansi256: 183, alpha: 0.5 } +``` + +## Install +```console +$ npm install color +``` + +## Usage +```js +const Color = require('color'); +``` + +### Constructors +```js +const color = Color('rgb(255, 255, 255)') +const color = Color({r: 255, g: 255, b: 255}) +const color = Color.rgb(255, 255, 255) +const color = Color.rgb([255, 255, 255]) +``` + +Set the values for individual channels with `alpha`, `red`, `green`, `blue`, `hue`, `saturationl` (hsl), `saturationv` (hsv), `lightness`, `whiteness`, `blackness`, `cyan`, `magenta`, `yellow`, `black` + +String constructors are handled by [color-string](https://www.npmjs.com/package/color-string) + +### Getters +```js +color.hsl(); +``` +Convert a color to a different space (`hsl()`, `cmyk()`, etc.). + +```js +color.object(); // {r: 255, g: 255, b: 255} +``` +Get a hash of the color value. Reflects the color's current model (see above). + +```js +color.rgb().array() // [255, 255, 255] +``` +Get an array of the values with `array()`. Reflects the color's current model (see above). + +```js +color.rgbNumber() // 16777215 (0xffffff) +``` +Get the rgb number value. + +```js +color.hex() // #ffffff +``` +Get the hex value. (**NOTE:** `.hex()` does not return alpha values; use `.hexa()` for an RGBA representation) + +```js +color.red() // 255 +``` +Get the value for an individual channel. + +### CSS Strings +```js +color.hsl().string() // 'hsl(320, 50%, 100%)' +``` + +Calling `.string()` with a number rounds the numbers to that decimal place. It defaults to 1. + +### Luminosity +```js +color.luminosity(); // 0.412 +``` +The [WCAG luminosity](http://www.w3.org/TR/WCAG20/#relativeluminancedef) of the color. 0 is black, 1 is white. + +```js +color.contrast(Color("blue")) // 12 +``` +The [WCAG contrast ratio](http://www.w3.org/TR/WCAG20/#contrast-ratiodef) to another color, from 1 (same color) to 21 (contrast b/w white and black). + +```js +color.isLight(); // true +color.isDark(); // false +``` +Get whether the color is "light" or "dark", useful for deciding text color. + +### Manipulation +```js +color.negate() // rgb(0, 100, 255) -> rgb(255, 155, 0) + +color.lighten(0.5) // hsl(100, 50%, 50%) -> hsl(100, 50%, 75%) +color.lighten(0.5) // hsl(100, 50%, 0) -> hsl(100, 50%, 0) +color.darken(0.5) // hsl(100, 50%, 50%) -> hsl(100, 50%, 25%) +color.darken(0.5) // hsl(100, 50%, 0) -> hsl(100, 50%, 0) + +color.lightness(50) // hsl(100, 50%, 10%) -> hsl(100, 50%, 50%) + +color.saturate(0.5) // hsl(100, 50%, 50%) -> hsl(100, 75%, 50%) +color.desaturate(0.5) // hsl(100, 50%, 50%) -> hsl(100, 25%, 50%) +color.grayscale() // #5CBF54 -> #969696 + +color.whiten(0.5) // hwb(100, 50%, 50%) -> hwb(100, 75%, 50%) +color.blacken(0.5) // hwb(100, 50%, 50%) -> hwb(100, 50%, 75%) + +color.fade(0.5) // rgba(10, 10, 10, 0.8) -> rgba(10, 10, 10, 0.4) +color.opaquer(0.5) // rgba(10, 10, 10, 0.8) -> rgba(10, 10, 10, 1.0) + +color.rotate(180) // hsl(60, 20%, 20%) -> hsl(240, 20%, 20%) +color.rotate(-90) // hsl(60, 20%, 20%) -> hsl(330, 20%, 20%) + +color.mix(Color("yellow")) // cyan -> rgb(128, 255, 128) +color.mix(Color("yellow"), 0.3) // cyan -> rgb(77, 255, 179) + +// chaining +color.green(100).grayscale().lighten(0.6) +``` + +## Propers +The API was inspired by [color-js](https://github.com/brehaut/color-js). Manipulation functions by CSS tools like Sass, LESS, and Stylus. diff --git a/node_modules/color/index.js b/node_modules/color/index.js new file mode 100644 index 0000000..ddb0b5d --- /dev/null +++ b/node_modules/color/index.js @@ -0,0 +1,496 @@ +const colorString = require('color-string'); +const convert = require('color-convert'); + +const skippedModels = [ + // To be honest, I don't really feel like keyword belongs in color convert, but eh. + 'keyword', + + // Gray conflicts with some method names, and has its own method defined. + 'gray', + + // Shouldn't really be in color-convert either... + 'hex', +]; + +const hashedModelKeys = {}; +for (const model of Object.keys(convert)) { + hashedModelKeys[[...convert[model].labels].sort().join('')] = model; +} + +const limiters = {}; + +function Color(object, model) { + if (!(this instanceof Color)) { + return new Color(object, model); + } + + if (model && model in skippedModels) { + model = null; + } + + if (model && !(model in convert)) { + throw new Error('Unknown model: ' + model); + } + + let i; + let channels; + + if (object == null) { // eslint-disable-line no-eq-null,eqeqeq + this.model = 'rgb'; + this.color = [0, 0, 0]; + this.valpha = 1; + } else if (object instanceof Color) { + this.model = object.model; + this.color = [...object.color]; + this.valpha = object.valpha; + } else if (typeof object === 'string') { + const result = colorString.get(object); + if (result === null) { + throw new Error('Unable to parse color from string: ' + object); + } + + this.model = result.model; + channels = convert[this.model].channels; + this.color = result.value.slice(0, channels); + this.valpha = typeof result.value[channels] === 'number' ? result.value[channels] : 1; + } else if (object.length > 0) { + this.model = model || 'rgb'; + channels = convert[this.model].channels; + const newArray = Array.prototype.slice.call(object, 0, channels); + this.color = zeroArray(newArray, channels); + this.valpha = typeof object[channels] === 'number' ? object[channels] : 1; + } else if (typeof object === 'number') { + // This is always RGB - can be converted later on. + this.model = 'rgb'; + this.color = [ + (object >> 16) & 0xFF, + (object >> 8) & 0xFF, + object & 0xFF, + ]; + this.valpha = 1; + } else { + this.valpha = 1; + + const keys = Object.keys(object); + if ('alpha' in object) { + keys.splice(keys.indexOf('alpha'), 1); + this.valpha = typeof object.alpha === 'number' ? object.alpha : 0; + } + + const hashedKeys = keys.sort().join(''); + if (!(hashedKeys in hashedModelKeys)) { + throw new Error('Unable to parse color from object: ' + JSON.stringify(object)); + } + + this.model = hashedModelKeys[hashedKeys]; + + const {labels} = convert[this.model]; + const color = []; + for (i = 0; i < labels.length; i++) { + color.push(object[labels[i]]); + } + + this.color = zeroArray(color); + } + + // Perform limitations (clamping, etc.) + if (limiters[this.model]) { + channels = convert[this.model].channels; + for (i = 0; i < channels; i++) { + const limit = limiters[this.model][i]; + if (limit) { + this.color[i] = limit(this.color[i]); + } + } + } + + this.valpha = Math.max(0, Math.min(1, this.valpha)); + + if (Object.freeze) { + Object.freeze(this); + } +} + +Color.prototype = { + toString() { + return this.string(); + }, + + toJSON() { + return this[this.model](); + }, + + string(places) { + let self = this.model in colorString.to ? this : this.rgb(); + self = self.round(typeof places === 'number' ? places : 1); + const args = self.valpha === 1 ? self.color : [...self.color, this.valpha]; + return colorString.to[self.model](args); + }, + + percentString(places) { + const self = this.rgb().round(typeof places === 'number' ? places : 1); + const args = self.valpha === 1 ? self.color : [...self.color, this.valpha]; + return colorString.to.rgb.percent(args); + }, + + array() { + return this.valpha === 1 ? [...this.color] : [...this.color, this.valpha]; + }, + + object() { + const result = {}; + const {channels} = convert[this.model]; + const {labels} = convert[this.model]; + + for (let i = 0; i < channels; i++) { + result[labels[i]] = this.color[i]; + } + + if (this.valpha !== 1) { + result.alpha = this.valpha; + } + + return result; + }, + + unitArray() { + const rgb = this.rgb().color; + rgb[0] /= 255; + rgb[1] /= 255; + rgb[2] /= 255; + + if (this.valpha !== 1) { + rgb.push(this.valpha); + } + + return rgb; + }, + + unitObject() { + const rgb = this.rgb().object(); + rgb.r /= 255; + rgb.g /= 255; + rgb.b /= 255; + + if (this.valpha !== 1) { + rgb.alpha = this.valpha; + } + + return rgb; + }, + + round(places) { + places = Math.max(places || 0, 0); + return new Color([...this.color.map(roundToPlace(places)), this.valpha], this.model); + }, + + alpha(value) { + if (value !== undefined) { + return new Color([...this.color, Math.max(0, Math.min(1, value))], this.model); + } + + return this.valpha; + }, + + // Rgb + red: getset('rgb', 0, maxfn(255)), + green: getset('rgb', 1, maxfn(255)), + blue: getset('rgb', 2, maxfn(255)), + + hue: getset(['hsl', 'hsv', 'hsl', 'hwb', 'hcg'], 0, value => ((value % 360) + 360) % 360), + + saturationl: getset('hsl', 1, maxfn(100)), + lightness: getset('hsl', 2, maxfn(100)), + + saturationv: getset('hsv', 1, maxfn(100)), + value: getset('hsv', 2, maxfn(100)), + + chroma: getset('hcg', 1, maxfn(100)), + gray: getset('hcg', 2, maxfn(100)), + + white: getset('hwb', 1, maxfn(100)), + wblack: getset('hwb', 2, maxfn(100)), + + cyan: getset('cmyk', 0, maxfn(100)), + magenta: getset('cmyk', 1, maxfn(100)), + yellow: getset('cmyk', 2, maxfn(100)), + black: getset('cmyk', 3, maxfn(100)), + + x: getset('xyz', 0, maxfn(95.047)), + y: getset('xyz', 1, maxfn(100)), + z: getset('xyz', 2, maxfn(108.833)), + + l: getset('lab', 0, maxfn(100)), + a: getset('lab', 1), + b: getset('lab', 2), + + keyword(value) { + if (value !== undefined) { + return new Color(value); + } + + return convert[this.model].keyword(this.color); + }, + + hex(value) { + if (value !== undefined) { + return new Color(value); + } + + return colorString.to.hex(this.rgb().round().color); + }, + + hexa(value) { + if (value !== undefined) { + return new Color(value); + } + + const rgbArray = this.rgb().round().color; + + let alphaHex = Math.round(this.valpha * 255).toString(16).toUpperCase(); + if (alphaHex.length === 1) { + alphaHex = '0' + alphaHex; + } + + return colorString.to.hex(rgbArray) + alphaHex; + }, + + rgbNumber() { + const rgb = this.rgb().color; + return ((rgb[0] & 0xFF) << 16) | ((rgb[1] & 0xFF) << 8) | (rgb[2] & 0xFF); + }, + + luminosity() { + // http://www.w3.org/TR/WCAG20/#relativeluminancedef + const rgb = this.rgb().color; + + const lum = []; + for (const [i, element] of rgb.entries()) { + const chan = element / 255; + lum[i] = (chan <= 0.04045) ? chan / 12.92 : ((chan + 0.055) / 1.055) ** 2.4; + } + + return 0.2126 * lum[0] + 0.7152 * lum[1] + 0.0722 * lum[2]; + }, + + contrast(color2) { + // http://www.w3.org/TR/WCAG20/#contrast-ratiodef + const lum1 = this.luminosity(); + const lum2 = color2.luminosity(); + + if (lum1 > lum2) { + return (lum1 + 0.05) / (lum2 + 0.05); + } + + return (lum2 + 0.05) / (lum1 + 0.05); + }, + + level(color2) { + // https://www.w3.org/TR/WCAG/#contrast-enhanced + const contrastRatio = this.contrast(color2); + if (contrastRatio >= 7) { + return 'AAA'; + } + + return (contrastRatio >= 4.5) ? 'AA' : ''; + }, + + isDark() { + // YIQ equation from http://24ways.org/2010/calculating-color-contrast + const rgb = this.rgb().color; + const yiq = (rgb[0] * 2126 + rgb[1] * 7152 + rgb[2] * 722) / 10000; + return yiq < 128; + }, + + isLight() { + return !this.isDark(); + }, + + negate() { + const rgb = this.rgb(); + for (let i = 0; i < 3; i++) { + rgb.color[i] = 255 - rgb.color[i]; + } + + return rgb; + }, + + lighten(ratio) { + const hsl = this.hsl(); + hsl.color[2] += hsl.color[2] * ratio; + return hsl; + }, + + darken(ratio) { + const hsl = this.hsl(); + hsl.color[2] -= hsl.color[2] * ratio; + return hsl; + }, + + saturate(ratio) { + const hsl = this.hsl(); + hsl.color[1] += hsl.color[1] * ratio; + return hsl; + }, + + desaturate(ratio) { + const hsl = this.hsl(); + hsl.color[1] -= hsl.color[1] * ratio; + return hsl; + }, + + whiten(ratio) { + const hwb = this.hwb(); + hwb.color[1] += hwb.color[1] * ratio; + return hwb; + }, + + blacken(ratio) { + const hwb = this.hwb(); + hwb.color[2] += hwb.color[2] * ratio; + return hwb; + }, + + grayscale() { + // http://en.wikipedia.org/wiki/Grayscale#Converting_color_to_grayscale + const rgb = this.rgb().color; + const value = rgb[0] * 0.3 + rgb[1] * 0.59 + rgb[2] * 0.11; + return Color.rgb(value, value, value); + }, + + fade(ratio) { + return this.alpha(this.valpha - (this.valpha * ratio)); + }, + + opaquer(ratio) { + return this.alpha(this.valpha + (this.valpha * ratio)); + }, + + rotate(degrees) { + const hsl = this.hsl(); + let hue = hsl.color[0]; + hue = (hue + degrees) % 360; + hue = hue < 0 ? 360 + hue : hue; + hsl.color[0] = hue; + return hsl; + }, + + mix(mixinColor, weight) { + // Ported from sass implementation in C + // https://github.com/sass/libsass/blob/0e6b4a2850092356aa3ece07c6b249f0221caced/functions.cpp#L209 + if (!mixinColor || !mixinColor.rgb) { + throw new Error('Argument to "mix" was not a Color instance, but rather an instance of ' + typeof mixinColor); + } + + const color1 = mixinColor.rgb(); + const color2 = this.rgb(); + const p = weight === undefined ? 0.5 : weight; + + const w = 2 * p - 1; + const a = color1.alpha() - color2.alpha(); + + const w1 = (((w * a === -1) ? w : (w + a) / (1 + w * a)) + 1) / 2; + const w2 = 1 - w1; + + return Color.rgb( + w1 * color1.red() + w2 * color2.red(), + w1 * color1.green() + w2 * color2.green(), + w1 * color1.blue() + w2 * color2.blue(), + color1.alpha() * p + color2.alpha() * (1 - p)); + }, +}; + +// Model conversion methods and static constructors +for (const model of Object.keys(convert)) { + if (skippedModels.includes(model)) { + continue; + } + + const {channels} = convert[model]; + + // Conversion methods + Color.prototype[model] = function (...args) { + if (this.model === model) { + return new Color(this); + } + + if (args.length > 0) { + return new Color(args, model); + } + + return new Color([...assertArray(convert[this.model][model].raw(this.color)), this.valpha], model); + }; + + // 'static' construction methods + Color[model] = function (...args) { + let color = args[0]; + if (typeof color === 'number') { + color = zeroArray(args, channels); + } + + return new Color(color, model); + }; +} + +function roundTo(number, places) { + return Number(number.toFixed(places)); +} + +function roundToPlace(places) { + return function (number) { + return roundTo(number, places); + }; +} + +function getset(model, channel, modifier) { + model = Array.isArray(model) ? model : [model]; + + for (const m of model) { + (limiters[m] || (limiters[m] = []))[channel] = modifier; + } + + model = model[0]; + + return function (value) { + let result; + + if (value !== undefined) { + if (modifier) { + value = modifier(value); + } + + result = this[model](); + result.color[channel] = value; + return result; + } + + result = this[model]().color[channel]; + if (modifier) { + result = modifier(result); + } + + return result; + }; +} + +function maxfn(max) { + return function (v) { + return Math.max(0, Math.min(max, v)); + }; +} + +function assertArray(value) { + return Array.isArray(value) ? value : [value]; +} + +function zeroArray(array, length) { + for (let i = 0; i < length; i++) { + if (typeof array[i] !== 'number') { + array[i] = 0; + } + } + + return array; +} + +module.exports = Color; diff --git a/node_modules/color/package.json b/node_modules/color/package.json new file mode 100644 index 0000000..4cdb6e3 --- /dev/null +++ b/node_modules/color/package.json @@ -0,0 +1,47 @@ +{ + "name": "color", + "version": "4.2.3", + "description": "Color conversion and manipulation with CSS string support", + "sideEffects": false, + "keywords": [ + "color", + "colour", + "css" + ], + "authors": [ + "Josh Junon ", + "Heather Arthur ", + "Maxime Thirouin" + ], + "license": "MIT", + "repository": "Qix-/color", + "xo": { + "rules": { + "no-cond-assign": 0, + "new-cap": 0, + "unicorn/prefer-module": 0, + "no-mixed-operators": 0, + "complexity": 0, + "unicorn/numeric-separators-style": 0 + } + }, + "files": [ + "LICENSE", + "index.js" + ], + "scripts": { + "pretest": "xo", + "test": "mocha" + }, + "engines": { + "node": ">=12.5.0" + }, + "dependencies": { + "color-convert": "^2.0.1", + "color-string": "^1.9.0" + }, + "devDependencies": { + "mocha": "9.0.2", + "xo": "0.42.0" + } +} diff --git a/node_modules/extend/.editorconfig b/node_modules/extend/.editorconfig new file mode 100644 index 0000000..bc228f8 --- /dev/null +++ b/node_modules/extend/.editorconfig @@ -0,0 +1,20 @@ +root = true + +[*] +indent_style = tab +indent_size = 4 +end_of_line = lf +charset = utf-8 +trim_trailing_whitespace = true +insert_final_newline = true +max_line_length = 150 + +[CHANGELOG.md] +indent_style = space +indent_size = 2 + +[*.json] +max_line_length = off + +[Makefile] +max_line_length = off diff --git a/node_modules/extend/.eslintrc b/node_modules/extend/.eslintrc new file mode 100644 index 0000000..a34cf28 --- /dev/null +++ b/node_modules/extend/.eslintrc @@ -0,0 +1,17 @@ +{ + "root": true, + + "extends": "@ljharb", + + "rules": { + "complexity": [2, 20], + "eqeqeq": [2, "allow-null"], + "func-name-matching": [1], + "max-depth": [1, 4], + "max-statements": [2, 26], + "no-extra-parens": [1], + "no-magic-numbers": [0], + "no-restricted-syntax": [2, "BreakStatement", "ContinueStatement", "DebuggerStatement", "LabeledStatement", "WithStatement"], + "sort-keys": [0], + } +} diff --git a/node_modules/extend/.jscs.json b/node_modules/extend/.jscs.json new file mode 100644 index 0000000..3cce01d --- /dev/null +++ b/node_modules/extend/.jscs.json @@ -0,0 +1,175 @@ +{ + "es3": true, + + "additionalRules": [], + + "requireSemicolons": true, + + "disallowMultipleSpaces": true, + + "disallowIdentifierNames": [], + + "requireCurlyBraces": { + "allExcept": [], + "keywords": ["if", "else", "for", "while", "do", "try", "catch"] + }, + + "requireSpaceAfterKeywords": ["if", "else", "for", "while", "do", "switch", "return", "try", "catch", "function"], + + "disallowSpaceAfterKeywords": [], + + "disallowSpaceBeforeComma": true, + "disallowSpaceAfterComma": false, + "disallowSpaceBeforeSemicolon": true, + + "disallowNodeTypes": [ + "DebuggerStatement", + "LabeledStatement", + "SwitchCase", + "SwitchStatement", + "WithStatement" + ], + + "requireObjectKeysOnNewLine": { "allExcept": ["sameLine"] }, + + "requireSpacesInAnonymousFunctionExpression": { "beforeOpeningRoundBrace": true, "beforeOpeningCurlyBrace": true }, + "requireSpacesInNamedFunctionExpression": { "beforeOpeningCurlyBrace": true }, + "disallowSpacesInNamedFunctionExpression": { "beforeOpeningRoundBrace": true }, + "requireSpacesInFunctionDeclaration": { "beforeOpeningCurlyBrace": true }, + "disallowSpacesInFunctionDeclaration": { "beforeOpeningRoundBrace": true }, + + "requireSpaceBetweenArguments": true, + + "disallowSpacesInsideParentheses": true, + + "disallowSpacesInsideArrayBrackets": true, + + "disallowQuotedKeysInObjects": { "allExcept": ["reserved"] }, + + "disallowSpaceAfterObjectKeys": true, + + "requireCommaBeforeLineBreak": true, + + "disallowSpaceAfterPrefixUnaryOperators": ["++", "--", "+", "-", "~", "!"], + "requireSpaceAfterPrefixUnaryOperators": [], + + "disallowSpaceBeforePostfixUnaryOperators": ["++", "--"], + "requireSpaceBeforePostfixUnaryOperators": [], + + "disallowSpaceBeforeBinaryOperators": [], + "requireSpaceBeforeBinaryOperators": ["+", "-", "/", "*", "=", "==", "===", "!=", "!=="], + + "requireSpaceAfterBinaryOperators": ["+", "-", "/", "*", "=", "==", "===", "!=", "!=="], + "disallowSpaceAfterBinaryOperators": [], + + "disallowImplicitTypeConversion": ["binary", "string"], + + "disallowKeywords": ["with", "eval"], + + "requireKeywordsOnNewLine": [], + "disallowKeywordsOnNewLine": ["else"], + + "requireLineFeedAtFileEnd": true, + + "disallowTrailingWhitespace": true, + + "disallowTrailingComma": true, + + "excludeFiles": ["node_modules/**", "vendor/**"], + + "disallowMultipleLineStrings": true, + + "requireDotNotation": { "allExcept": ["keywords"] }, + + "requireParenthesesAroundIIFE": true, + + "validateLineBreaks": "LF", + + "validateQuoteMarks": { + "escape": true, + "mark": "'" + }, + + "disallowOperatorBeforeLineBreak": [], + + "requireSpaceBeforeKeywords": [ + "do", + "for", + "if", + "else", + "switch", + "case", + "try", + "catch", + "finally", + "while", + "with", + "return" + ], + + "validateAlignedFunctionParameters": { + "lineBreakAfterOpeningBraces": true, + "lineBreakBeforeClosingBraces": true + }, + + "requirePaddingNewLinesBeforeExport": true, + + "validateNewlineAfterArrayElements": { + "maximum": 6 + }, + + "requirePaddingNewLinesAfterUseStrict": true, + + "disallowArrowFunctions": true, + + "disallowMultiLineTernary": true, + + "validateOrderInObjectKeys": false, + + "disallowIdenticalDestructuringNames": true, + + "disallowNestedTernaries": { "maxLevel": 1 }, + + "requireSpaceAfterComma": { "allExcept": ["trailing"] }, + "requireAlignedMultilineParams": false, + + "requireSpacesInGenerator": { + "afterStar": true + }, + + "disallowSpacesInGenerator": { + "beforeStar": true + }, + + "disallowVar": false, + + "requireArrayDestructuring": false, + + "requireEnhancedObjectLiterals": false, + + "requireObjectDestructuring": false, + + "requireEarlyReturn": false, + + "requireCapitalizedConstructorsNew": { + "allExcept": ["Function", "String", "Object", "Symbol", "Number", "Date", "RegExp", "Error", "Boolean", "Array"] + }, + + "requireImportAlphabetized": false, + + "requireSpaceBeforeObjectValues": true, + "requireSpaceBeforeDestructuredValues": true, + + "disallowSpacesInsideTemplateStringPlaceholders": true, + + "disallowArrayDestructuringReturn": false, + + "requireNewlineBeforeSingleStatementsInIf": false, + + "disallowUnusedVariables": true, + + "requireSpacesInsideImportedObjectBraces": true, + + "requireUseStrict": true +} + diff --git a/node_modules/extend/.travis.yml b/node_modules/extend/.travis.yml new file mode 100644 index 0000000..5ccdfc4 --- /dev/null +++ b/node_modules/extend/.travis.yml @@ -0,0 +1,230 @@ +language: node_js +os: + - linux +node_js: + - "10.7" + - "9.11" + - "8.11" + - "7.10" + - "6.14" + - "5.12" + - "4.9" + - "iojs-v3.3" + - "iojs-v2.5" + - "iojs-v1.8" + - "0.12" + - "0.10" + - "0.8" +before_install: + - 'case "${TRAVIS_NODE_VERSION}" in 0.*) export NPM_CONFIG_STRICT_SSL=false ;; esac' + - 'nvm install-latest-npm' +install: + - 'if [ "${TRAVIS_NODE_VERSION}" = "0.6" ] || [ "${TRAVIS_NODE_VERSION}" = "0.9" ]; then nvm install --latest-npm 0.8 && npm install && nvm use "${TRAVIS_NODE_VERSION}"; else npm install; fi;' +script: + - 'if [ -n "${PRETEST-}" ]; then npm run pretest ; fi' + - 'if [ -n "${POSTTEST-}" ]; then npm run posttest ; fi' + - 'if [ -n "${COVERAGE-}" ]; then npm run coverage ; fi' + - 'if [ -n "${TEST-}" ]; then npm run tests-only ; fi' +sudo: false +env: + - TEST=true +matrix: + fast_finish: true + include: + - node_js: "lts/*" + env: PRETEST=true + - node_js: "lts/*" + env: POSTTEST=true + - node_js: "4" + env: COVERAGE=true + - node_js: "10.6" + env: TEST=true ALLOW_FAILURE=true + - node_js: "10.5" + env: TEST=true ALLOW_FAILURE=true + - node_js: "10.4" + env: TEST=true ALLOW_FAILURE=true + - node_js: "10.3" + env: TEST=true ALLOW_FAILURE=true + - node_js: "10.2" + env: TEST=true ALLOW_FAILURE=true + - node_js: "10.1" + env: TEST=true ALLOW_FAILURE=true + - node_js: "10.0" + env: TEST=true ALLOW_FAILURE=true + - node_js: "9.10" + env: TEST=true ALLOW_FAILURE=true + - node_js: "9.9" + env: TEST=true ALLOW_FAILURE=true + - node_js: "9.8" + env: TEST=true ALLOW_FAILURE=true + - node_js: "9.7" + env: TEST=true ALLOW_FAILURE=true + - node_js: "9.6" + env: TEST=true ALLOW_FAILURE=true + - node_js: "9.5" + env: TEST=true ALLOW_FAILURE=true + - node_js: "9.4" + env: TEST=true ALLOW_FAILURE=true + - node_js: "9.3" + env: TEST=true ALLOW_FAILURE=true + - node_js: "9.2" + env: TEST=true ALLOW_FAILURE=true + - node_js: "9.1" + env: TEST=true ALLOW_FAILURE=true + - node_js: "9.0" + env: TEST=true ALLOW_FAILURE=true + - node_js: "8.10" + env: TEST=true ALLOW_FAILURE=true + - node_js: "8.9" + env: TEST=true ALLOW_FAILURE=true + - node_js: "8.8" + env: TEST=true ALLOW_FAILURE=true + - node_js: "8.7" + env: TEST=true ALLOW_FAILURE=true + - node_js: "8.6" + env: TEST=true ALLOW_FAILURE=true + - node_js: "8.5" + env: TEST=true ALLOW_FAILURE=true + - node_js: "8.4" + env: TEST=true ALLOW_FAILURE=true + - node_js: "8.3" + env: TEST=true ALLOW_FAILURE=true + - node_js: "8.2" + env: TEST=true ALLOW_FAILURE=true + - node_js: "8.1" + env: TEST=true ALLOW_FAILURE=true + - node_js: "8.0" + env: TEST=true ALLOW_FAILURE=true + - node_js: "7.9" + env: TEST=true ALLOW_FAILURE=true + - node_js: "7.8" + env: TEST=true ALLOW_FAILURE=true + - node_js: "7.7" + env: TEST=true ALLOW_FAILURE=true + - node_js: "7.6" + env: TEST=true ALLOW_FAILURE=true + - node_js: "7.5" + env: TEST=true ALLOW_FAILURE=true + - node_js: "7.4" + env: TEST=true ALLOW_FAILURE=true + - node_js: "7.3" + env: TEST=true ALLOW_FAILURE=true + - node_js: "7.2" + env: TEST=true ALLOW_FAILURE=true + - node_js: "7.1" + env: TEST=true ALLOW_FAILURE=true + - node_js: "7.0" + env: TEST=true ALLOW_FAILURE=true + - node_js: "6.13" + env: TEST=true ALLOW_FAILURE=true + - node_js: "6.12" + env: TEST=true ALLOW_FAILURE=true + - node_js: "6.11" + env: TEST=true ALLOW_FAILURE=true + - node_js: "6.10" + env: TEST=true ALLOW_FAILURE=true + - node_js: "6.9" + env: TEST=true ALLOW_FAILURE=true + - node_js: "6.8" + env: TEST=true ALLOW_FAILURE=true + - node_js: "6.7" + env: TEST=true ALLOW_FAILURE=true + - node_js: "6.6" + env: TEST=true ALLOW_FAILURE=true + - node_js: "6.5" + env: TEST=true ALLOW_FAILURE=true + - node_js: "6.4" + env: TEST=true ALLOW_FAILURE=true + - node_js: "6.3" + env: TEST=true ALLOW_FAILURE=true + - node_js: "6.2" + env: TEST=true ALLOW_FAILURE=true + - node_js: "6.1" + env: TEST=true ALLOW_FAILURE=true + - node_js: "6.0" + env: TEST=true ALLOW_FAILURE=true + - node_js: "5.11" + env: TEST=true ALLOW_FAILURE=true + - node_js: "5.10" + env: TEST=true ALLOW_FAILURE=true + - node_js: "5.9" + env: TEST=true ALLOW_FAILURE=true + - node_js: "5.8" + env: TEST=true ALLOW_FAILURE=true + - node_js: "5.7" + env: TEST=true ALLOW_FAILURE=true + - node_js: "5.6" + env: TEST=true ALLOW_FAILURE=true + - node_js: "5.5" + env: TEST=true ALLOW_FAILURE=true + - node_js: "5.4" + env: TEST=true ALLOW_FAILURE=true + - node_js: "5.3" + env: TEST=true ALLOW_FAILURE=true + - node_js: "5.2" + env: TEST=true ALLOW_FAILURE=true + - node_js: "5.1" + env: TEST=true ALLOW_FAILURE=true + - node_js: "5.0" + env: TEST=true ALLOW_FAILURE=true + - node_js: "4.8" + env: TEST=true ALLOW_FAILURE=true + - node_js: "4.7" + env: TEST=true ALLOW_FAILURE=true + - node_js: "4.6" + env: TEST=true ALLOW_FAILURE=true + - node_js: "4.5" + env: TEST=true ALLOW_FAILURE=true + - node_js: "4.4" + env: TEST=true ALLOW_FAILURE=true + - node_js: "4.3" + env: TEST=true ALLOW_FAILURE=true + - node_js: "4.2" + env: TEST=true ALLOW_FAILURE=true + - node_js: "4.1" + env: TEST=true ALLOW_FAILURE=true + - node_js: "4.0" + env: TEST=true ALLOW_FAILURE=true + - node_js: "iojs-v3.2" + env: TEST=true ALLOW_FAILURE=true + - node_js: "iojs-v3.1" + env: TEST=true ALLOW_FAILURE=true + - node_js: "iojs-v3.0" + env: TEST=true ALLOW_FAILURE=true + - node_js: "iojs-v2.4" + env: TEST=true ALLOW_FAILURE=true + - node_js: "iojs-v2.3" + env: TEST=true ALLOW_FAILURE=true + - node_js: "iojs-v2.2" + env: TEST=true ALLOW_FAILURE=true + - node_js: "iojs-v2.1" + env: TEST=true ALLOW_FAILURE=true + - node_js: "iojs-v2.0" + env: TEST=true ALLOW_FAILURE=true + - node_js: "iojs-v1.7" + env: TEST=true ALLOW_FAILURE=true + - node_js: "iojs-v1.6" + env: TEST=true ALLOW_FAILURE=true + - node_js: "iojs-v1.5" + env: TEST=true ALLOW_FAILURE=true + - node_js: "iojs-v1.4" + env: TEST=true ALLOW_FAILURE=true + - node_js: "iojs-v1.3" + env: TEST=true ALLOW_FAILURE=true + - node_js: "iojs-v1.2" + env: TEST=true ALLOW_FAILURE=true + - node_js: "iojs-v1.1" + env: TEST=true ALLOW_FAILURE=true + - node_js: "iojs-v1.0" + env: TEST=true ALLOW_FAILURE=true + - node_js: "0.11" + env: TEST=true ALLOW_FAILURE=true + - node_js: "0.9" + env: TEST=true ALLOW_FAILURE=true + - node_js: "0.6" + env: TEST=true ALLOW_FAILURE=true + - node_js: "0.4" + env: TEST=true ALLOW_FAILURE=true + allow_failures: + - os: osx + - env: TEST=true ALLOW_FAILURE=true diff --git a/node_modules/extend/CHANGELOG.md b/node_modules/extend/CHANGELOG.md new file mode 100644 index 0000000..2cf7de6 --- /dev/null +++ b/node_modules/extend/CHANGELOG.md @@ -0,0 +1,83 @@ +3.0.2 / 2018-07-19 +================== + * [Fix] Prevent merging `__proto__` property (#48) + * [Dev Deps] update `eslint`, `@ljharb/eslint-config`, `tape` + * [Tests] up to `node` `v10.7`, `v9.11`, `v8.11`, `v7.10`, `v6.14`, `v4.9`; use `nvm install-latest-npm` + +3.0.1 / 2017-04-27 +================== + * [Fix] deep extending should work with a non-object (#46) + * [Dev Deps] update `tape`, `eslint`, `@ljharb/eslint-config` + * [Tests] up to `node` `v7.9`, `v6.10`, `v4.8`; improve matrix + * [Docs] Switch from vb.teelaun.ch to versionbadg.es for the npm version badge SVG. + * [Docs] Add example to readme (#34) + +3.0.0 / 2015-07-01 +================== + * [Possible breaking change] Use global "strict" directive (#32) + * [Tests] `int` is an ES3 reserved word + * [Tests] Test up to `io.js` `v2.3` + * [Tests] Add `npm run eslint` + * [Dev Deps] Update `covert`, `jscs` + +2.0.1 / 2015-04-25 +================== + * Use an inline `isArray` check, for ES3 browsers. (#27) + * Some old browsers fail when an identifier is `toString` + * Test latest `node` and `io.js` versions on `travis-ci`; speed up builds + * Add license info to package.json (#25) + * Update `tape`, `jscs` + * Adding a CHANGELOG + +2.0.0 / 2014-10-01 +================== + * Increase code coverage to 100%; run code coverage as part of tests + * Add `npm run lint`; Run linter as part of tests + * Remove nodeType and setInterval checks in isPlainObject + * Updating `tape`, `jscs`, `covert` + * General style and README cleanup + +1.3.0 / 2014-06-20 +================== + * Add component.json for browser support (#18) + * Use SVG for badges in README (#16) + * Updating `tape`, `covert` + * Updating travis-ci to work with multiple node versions + * Fix `deep === false` bug (returning target as {}) (#14) + * Fixing constructor checks in isPlainObject + * Adding additional test coverage + * Adding `npm run coverage` + * Add LICENSE (#13) + * Adding a warning about `false`, per #11 + * General style and whitespace cleanup + +1.2.1 / 2013-09-14 +================== + * Fixing hasOwnProperty bugs that would only have shown up in specific browsers. Fixes #8 + * Updating `tape` + +1.2.0 / 2013-09-02 +================== + * Updating the README: add badges + * Adding a missing variable reference. + * Using `tape` instead of `buster` for tests; add more tests (#7) + * Adding node 0.10 to Travis CI (#6) + * Enabling "npm test" and cleaning up package.json (#5) + * Add Travis CI. + +1.1.3 / 2012-12-06 +================== + * Added unit tests. + * Ensure extend function is named. (Looks nicer in a stack trace.) + * README cleanup. + +1.1.1 / 2012-11-07 +================== + * README cleanup. + * Added installation instructions. + * Added a missing semicolon + +1.0.0 / 2012-04-08 +================== + * Initial commit + diff --git a/node_modules/extend/LICENSE b/node_modules/extend/LICENSE new file mode 100644 index 0000000..e16d6a5 --- /dev/null +++ b/node_modules/extend/LICENSE @@ -0,0 +1,23 @@ +The MIT License (MIT) + +Copyright (c) 2014 Stefan Thomas + +Permission is hereby granted, free of charge, to any person obtaining +a copy of this software and associated documentation files (the +"Software"), to deal in the Software without restriction, including +without limitation the rights to use, copy, modify, merge, publish, +distribute, sublicense, and/or sell copies of the Software, and to +permit persons to whom the Software is furnished to do so, subject to +the following conditions: + +The above copyright notice and this permission notice shall be +included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE +LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION +OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + diff --git a/node_modules/extend/README.md b/node_modules/extend/README.md new file mode 100644 index 0000000..5b8249a --- /dev/null +++ b/node_modules/extend/README.md @@ -0,0 +1,81 @@ +[![Build Status][travis-svg]][travis-url] +[![dependency status][deps-svg]][deps-url] +[![dev dependency status][dev-deps-svg]][dev-deps-url] + +# extend() for Node.js [![Version Badge][npm-version-png]][npm-url] + +`node-extend` is a port of the classic extend() method from jQuery. It behaves as you expect. It is simple, tried and true. + +Notes: + +* Since Node.js >= 4, + [`Object.assign`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/assign) + now offers the same functionality natively (but without the "deep copy" option). + See [ECMAScript 2015 (ES6) in Node.js](https://nodejs.org/en/docs/es6). +* Some native implementations of `Object.assign` in both Node.js and many + browsers (since NPM modules are for the browser too) may not be fully + spec-compliant. + Check [`object.assign`](https://www.npmjs.com/package/object.assign) module for + a compliant candidate. + +## Installation + +This package is available on [npm][npm-url] as: `extend` + +``` sh +npm install extend +``` + +## Usage + +**Syntax:** extend **(** [`deep`], `target`, `object1`, [`objectN`] **)** + +*Extend one object with one or more others, returning the modified object.* + +**Example:** + +``` js +var extend = require('extend'); +extend(targetObject, object1, object2); +``` + +Keep in mind that the target object will be modified, and will be returned from extend(). + +If a boolean true is specified as the first argument, extend performs a deep copy, recursively copying any objects it finds. Otherwise, the copy will share structure with the original object(s). +Undefined properties are not copied. However, properties inherited from the object's prototype will be copied over. +Warning: passing `false` as the first argument is not supported. + +### Arguments + +* `deep` *Boolean* (optional) +If set, the merge becomes recursive (i.e. deep copy). +* `target` *Object* +The object to extend. +* `object1` *Object* +The object that will be merged into the first. +* `objectN` *Object* (Optional) +More objects to merge into the first. + +## License + +`node-extend` is licensed under the [MIT License][mit-license-url]. + +## Acknowledgements + +All credit to the jQuery authors for perfecting this amazing utility. + +Ported to Node.js by [Stefan Thomas][github-justmoon] with contributions by [Jonathan Buchanan][github-insin] and [Jordan Harband][github-ljharb]. + +[travis-svg]: https://travis-ci.org/justmoon/node-extend.svg +[travis-url]: https://travis-ci.org/justmoon/node-extend +[npm-url]: https://npmjs.org/package/extend +[mit-license-url]: http://opensource.org/licenses/MIT +[github-justmoon]: https://github.com/justmoon +[github-insin]: https://github.com/insin +[github-ljharb]: https://github.com/ljharb +[npm-version-png]: http://versionbadg.es/justmoon/node-extend.svg +[deps-svg]: https://david-dm.org/justmoon/node-extend.svg +[deps-url]: https://david-dm.org/justmoon/node-extend +[dev-deps-svg]: https://david-dm.org/justmoon/node-extend/dev-status.svg +[dev-deps-url]: https://david-dm.org/justmoon/node-extend#info=devDependencies + diff --git a/node_modules/extend/component.json b/node_modules/extend/component.json new file mode 100644 index 0000000..1500a2f --- /dev/null +++ b/node_modules/extend/component.json @@ -0,0 +1,32 @@ +{ + "name": "extend", + "author": "Stefan Thomas (http://www.justmoon.net)", + "version": "3.0.0", + "description": "Port of jQuery.extend for node.js and the browser.", + "scripts": [ + "index.js" + ], + "contributors": [ + { + "name": "Jordan Harband", + "url": "https://github.com/ljharb" + } + ], + "keywords": [ + "extend", + "clone", + "merge" + ], + "repository" : { + "type": "git", + "url": "https://github.com/justmoon/node-extend.git" + }, + "dependencies": { + }, + "devDependencies": { + "tape" : "~3.0.0", + "covert": "~0.4.0", + "jscs": "~1.6.2" + } +} + diff --git a/node_modules/extend/index.js b/node_modules/extend/index.js new file mode 100644 index 0000000..2aa3faa --- /dev/null +++ b/node_modules/extend/index.js @@ -0,0 +1,117 @@ +'use strict'; + +var hasOwn = Object.prototype.hasOwnProperty; +var toStr = Object.prototype.toString; +var defineProperty = Object.defineProperty; +var gOPD = Object.getOwnPropertyDescriptor; + +var isArray = function isArray(arr) { + if (typeof Array.isArray === 'function') { + return Array.isArray(arr); + } + + return toStr.call(arr) === '[object Array]'; +}; + +var isPlainObject = function isPlainObject(obj) { + if (!obj || toStr.call(obj) !== '[object Object]') { + return false; + } + + var hasOwnConstructor = hasOwn.call(obj, 'constructor'); + var hasIsPrototypeOf = obj.constructor && obj.constructor.prototype && hasOwn.call(obj.constructor.prototype, 'isPrototypeOf'); + // Not own constructor property must be Object + if (obj.constructor && !hasOwnConstructor && !hasIsPrototypeOf) { + return false; + } + + // Own properties are enumerated firstly, so to speed up, + // if last one is own, then all properties are own. + var key; + for (key in obj) { /**/ } + + return typeof key === 'undefined' || hasOwn.call(obj, key); +}; + +// If name is '__proto__', and Object.defineProperty is available, define __proto__ as an own property on target +var setProperty = function setProperty(target, options) { + if (defineProperty && options.name === '__proto__') { + defineProperty(target, options.name, { + enumerable: true, + configurable: true, + value: options.newValue, + writable: true + }); + } else { + target[options.name] = options.newValue; + } +}; + +// Return undefined instead of __proto__ if '__proto__' is not an own property +var getProperty = function getProperty(obj, name) { + if (name === '__proto__') { + if (!hasOwn.call(obj, name)) { + return void 0; + } else if (gOPD) { + // In early versions of node, obj['__proto__'] is buggy when obj has + // __proto__ as an own property. Object.getOwnPropertyDescriptor() works. + return gOPD(obj, name).value; + } + } + + return obj[name]; +}; + +module.exports = function extend() { + var options, name, src, copy, copyIsArray, clone; + var target = arguments[0]; + var i = 1; + var length = arguments.length; + var deep = false; + + // Handle a deep copy situation + if (typeof target === 'boolean') { + deep = target; + target = arguments[1] || {}; + // skip the boolean and the target + i = 2; + } + if (target == null || (typeof target !== 'object' && typeof target !== 'function')) { + target = {}; + } + + for (; i < length; ++i) { + options = arguments[i]; + // Only deal with non-null/undefined values + if (options != null) { + // Extend the base object + for (name in options) { + src = getProperty(target, name); + copy = getProperty(options, name); + + // Prevent never-ending loop + if (target !== copy) { + // Recurse if we're merging plain objects or arrays + if (deep && copy && (isPlainObject(copy) || (copyIsArray = isArray(copy)))) { + if (copyIsArray) { + copyIsArray = false; + clone = src && isArray(src) ? src : []; + } else { + clone = src && isPlainObject(src) ? src : {}; + } + + // Never move original objects, clone them + setProperty(target, { name: name, newValue: extend(deep, clone, copy) }); + + // Don't bring in undefined values + } else if (typeof copy !== 'undefined') { + setProperty(target, { name: name, newValue: copy }); + } + } + } + } + } + + // Return the modified object + return target; +}; diff --git a/node_modules/extend/package.json b/node_modules/extend/package.json new file mode 100644 index 0000000..85279f7 --- /dev/null +++ b/node_modules/extend/package.json @@ -0,0 +1,42 @@ +{ + "name": "extend", + "author": "Stefan Thomas (http://www.justmoon.net)", + "version": "3.0.2", + "description": "Port of jQuery.extend for node.js and the browser", + "main": "index", + "scripts": { + "pretest": "npm run lint", + "test": "npm run tests-only", + "posttest": "npm run coverage-quiet", + "tests-only": "node test", + "coverage": "covert test/index.js", + "coverage-quiet": "covert test/index.js --quiet", + "lint": "npm run jscs && npm run eslint", + "jscs": "jscs *.js */*.js", + "eslint": "eslint *.js */*.js" + }, + "contributors": [ + { + "name": "Jordan Harband", + "url": "https://github.com/ljharb" + } + ], + "keywords": [ + "extend", + "clone", + "merge" + ], + "repository": { + "type": "git", + "url": "https://github.com/justmoon/node-extend.git" + }, + "dependencies": {}, + "devDependencies": { + "@ljharb/eslint-config": "^12.2.1", + "covert": "^1.1.0", + "eslint": "^4.19.1", + "jscs": "^3.0.7", + "tape": "^4.9.1" + }, + "license": "MIT" +} diff --git a/node_modules/is-arrayish/LICENSE b/node_modules/is-arrayish/LICENSE new file mode 100644 index 0000000..0a5f461 --- /dev/null +++ b/node_modules/is-arrayish/LICENSE @@ -0,0 +1,21 @@ +The MIT License (MIT) + +Copyright (c) 2015 JD Ballard + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +THE SOFTWARE. diff --git a/node_modules/is-arrayish/README.md b/node_modules/is-arrayish/README.md new file mode 100644 index 0000000..7d36072 --- /dev/null +++ b/node_modules/is-arrayish/README.md @@ -0,0 +1,16 @@ +# node-is-arrayish [![Travis-CI.org Build Status](https://img.shields.io/travis/Qix-/node-is-arrayish.svg?style=flat-square)](https://travis-ci.org/Qix-/node-is-arrayish) [![Coveralls.io Coverage Rating](https://img.shields.io/coveralls/Qix-/node-is-arrayish.svg?style=flat-square)](https://coveralls.io/r/Qix-/node-is-arrayish) +> Determines if an object can be used like an Array + +## Example +```javascript +var isArrayish = require('is-arrayish'); + +isArrayish([]); // true +isArrayish({__proto__: []}); // true +isArrayish({}); // false +isArrayish({length:10}); // false +``` + +## License +Licensed under the [MIT License](http://opensource.org/licenses/MIT). +You can find a copy of it in [LICENSE](LICENSE). diff --git a/node_modules/is-arrayish/index.js b/node_modules/is-arrayish/index.js new file mode 100644 index 0000000..729ca40 --- /dev/null +++ b/node_modules/is-arrayish/index.js @@ -0,0 +1,9 @@ +module.exports = function isArrayish(obj) { + if (!obj || typeof obj === 'string') { + return false; + } + + return obj instanceof Array || Array.isArray(obj) || + (obj.length >= 0 && (obj.splice instanceof Function || + (Object.getOwnPropertyDescriptor(obj, (obj.length - 1)) && obj.constructor.name !== 'String'))); +}; diff --git a/node_modules/is-arrayish/package.json b/node_modules/is-arrayish/package.json new file mode 100644 index 0000000..8a54e33 --- /dev/null +++ b/node_modules/is-arrayish/package.json @@ -0,0 +1,45 @@ +{ + "name": "is-arrayish", + "description": "Determines if an object can be used as an array", + "version": "0.3.2", + "author": "Qix (http://github.com/qix-)", + "keywords": [ + "is", + "array", + "duck", + "type", + "arrayish", + "similar", + "proto", + "prototype", + "type" + ], + "license": "MIT", + "scripts": { + "test": "mocha --require coffeescript/register ./test/**/*.coffee", + "lint": "zeit-eslint --ext .jsx,.js .", + "lint-staged": "git diff --diff-filter=ACMRT --cached --name-only '*.js' '*.jsx' | xargs zeit-eslint" + }, + "repository": { + "type": "git", + "url": "https://github.com/qix-/node-is-arrayish.git" + }, + "devDependencies": { + "@zeit/eslint-config-node": "^0.3.0", + "@zeit/git-hooks": "^0.1.4", + "coffeescript": "^2.3.1", + "coveralls": "^3.0.1", + "eslint": "^4.19.1", + "istanbul": "^0.4.5", + "mocha": "^5.2.0", + "should": "^13.2.1" + }, + "eslintConfig": { + "extends": [ + "@zeit/eslint-config-node" + ] + }, + "git": { + "pre-commit": "lint-staged" + } +} diff --git a/node_modules/is-buffer/LICENSE b/node_modules/is-buffer/LICENSE new file mode 100644 index 0000000..0c068ce --- /dev/null +++ b/node_modules/is-buffer/LICENSE @@ -0,0 +1,21 @@ +The MIT License (MIT) + +Copyright (c) Feross Aboukhadijeh + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +THE SOFTWARE. diff --git a/node_modules/is-buffer/README.md b/node_modules/is-buffer/README.md new file mode 100644 index 0000000..8c9785f --- /dev/null +++ b/node_modules/is-buffer/README.md @@ -0,0 +1,54 @@ +# is-buffer [![travis][travis-image]][travis-url] [![npm][npm-image]][npm-url] [![downloads][downloads-image]][downloads-url] [![javascript style guide][standard-image]][standard-url] + +[travis-image]: https://img.shields.io/travis/feross/is-buffer/master.svg +[travis-url]: https://travis-ci.org/feross/is-buffer +[npm-image]: https://img.shields.io/npm/v/is-buffer.svg +[npm-url]: https://npmjs.org/package/is-buffer +[downloads-image]: https://img.shields.io/npm/dm/is-buffer.svg +[downloads-url]: https://npmjs.org/package/is-buffer +[standard-image]: https://img.shields.io/badge/code_style-standard-brightgreen.svg +[standard-url]: https://standardjs.com + +#### Determine if an object is a [`Buffer`](http://nodejs.org/api/buffer.html) (including the [browserify Buffer](https://github.com/feross/buffer)) + +[![saucelabs][saucelabs-image]][saucelabs-url] + +[saucelabs-image]: https://saucelabs.com/browser-matrix/is-buffer.svg +[saucelabs-url]: https://saucelabs.com/u/is-buffer + +## Why not use `Buffer.isBuffer`? + +This module lets you check if an object is a `Buffer` without using `Buffer.isBuffer` (which includes the whole [buffer](https://github.com/feross/buffer) module in [browserify](http://browserify.org/)). + +It's future-proof and works in node too! + +## install + +```bash +npm install is-buffer +``` + +## usage + +```js +var isBuffer = require('is-buffer') + +isBuffer(new Buffer(4)) // true +isBuffer(Buffer.alloc(4)) //true + +isBuffer(undefined) // false +isBuffer(null) // false +isBuffer('') // false +isBuffer(true) // false +isBuffer(false) // false +isBuffer(0) // false +isBuffer(1) // false +isBuffer(1.0) // false +isBuffer('string') // false +isBuffer({}) // false +isBuffer(function foo () {}) // false +``` + +## license + +MIT. Copyright (C) [Feross Aboukhadijeh](http://feross.org). diff --git a/node_modules/is-buffer/index.d.ts b/node_modules/is-buffer/index.d.ts new file mode 100644 index 0000000..7065c69 --- /dev/null +++ b/node_modules/is-buffer/index.d.ts @@ -0,0 +1,2 @@ +declare function isBuffer(obj: any): boolean +export = isBuffer diff --git a/node_modules/is-buffer/index.js b/node_modules/is-buffer/index.js new file mode 100644 index 0000000..da9bfdd --- /dev/null +++ b/node_modules/is-buffer/index.js @@ -0,0 +1,11 @@ +/*! + * Determine if an object is a Buffer + * + * @author Feross Aboukhadijeh + * @license MIT + */ + +module.exports = function isBuffer (obj) { + return obj != null && obj.constructor != null && + typeof obj.constructor.isBuffer === 'function' && obj.constructor.isBuffer(obj) +} diff --git a/node_modules/is-buffer/package.json b/node_modules/is-buffer/package.json new file mode 100644 index 0000000..7cd70d4 --- /dev/null +++ b/node_modules/is-buffer/package.json @@ -0,0 +1,65 @@ +{ + "name": "is-buffer", + "description": "Determine if an object is a Buffer", + "version": "2.0.5", + "author": { + "name": "Feross Aboukhadijeh", + "email": "feross@feross.org", + "url": "https://feross.org" + }, + "bugs": { + "url": "https://github.com/feross/is-buffer/issues" + }, + "dependencies": {}, + "devDependencies": { + "airtap": "^3.0.0", + "standard": "*", + "tape": "^5.0.1" + }, + "engines": { + "node": ">=4" + }, + "keywords": [ + "arraybuffer", + "browser", + "browser buffer", + "browserify", + "buffer", + "buffers", + "core buffer", + "dataview", + "float32array", + "float64array", + "int16array", + "int32array", + "type", + "typed array", + "uint32array" + ], + "license": "MIT", + "main": "index.js", + "repository": { + "type": "git", + "url": "git://github.com/feross/is-buffer.git" + }, + "scripts": { + "test": "standard && npm run test-node && npm run test-browser", + "test-browser": "airtap -- test/*.js", + "test-browser-local": "airtap --local -- test/*.js", + "test-node": "tape test/*.js" + }, + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/feross" + }, + { + "type": "patreon", + "url": "https://www.patreon.com/feross" + }, + { + "type": "consulting", + "url": "https://feross.org/support" + } + ] +} diff --git a/node_modules/is-plain-obj/index.d.ts b/node_modules/is-plain-obj/index.d.ts new file mode 100644 index 0000000..3794c42 --- /dev/null +++ b/node_modules/is-plain-obj/index.d.ts @@ -0,0 +1,35 @@ +/** +Check if a value is a plain object. + +An object is plain if it's created by either `{}`, `new Object()`, or `Object.create(null)`. + +@example +``` +import isPlainObject from 'is-plain-obj'; +import {runInNewContext} from 'node:vm'; + +isPlainObject({foo: 'bar'}); +//=> true + +isPlainObject(new Object()); +//=> true + +isPlainObject(Object.create(null)); +//=> true + +// This works across realms +isPlainObject(runInNewContext('({})')); +//=> true + +isPlainObject([1, 2, 3]); +//=> false + +class Unicorn {} +isPlainObject(new Unicorn()); +//=> false + +isPlainObject(Math); +//=> false +``` +*/ +export default function isPlainObject(value: unknown): value is Record; diff --git a/node_modules/is-plain-obj/index.js b/node_modules/is-plain-obj/index.js new file mode 100644 index 0000000..92555c3 --- /dev/null +++ b/node_modules/is-plain-obj/index.js @@ -0,0 +1,8 @@ +export default function isPlainObject(value) { + if (typeof value !== 'object' || value === null) { + return false; + } + + const prototype = Object.getPrototypeOf(value); + return (prototype === null || prototype === Object.prototype || Object.getPrototypeOf(prototype) === null) && !(Symbol.toStringTag in value) && !(Symbol.iterator in value); +} diff --git a/node_modules/is-plain-obj/license b/node_modules/is-plain-obj/license new file mode 100644 index 0000000..fa7ceba --- /dev/null +++ b/node_modules/is-plain-obj/license @@ -0,0 +1,9 @@ +MIT License + +Copyright (c) Sindre Sorhus (https://sindresorhus.com) + +Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. diff --git a/node_modules/is-plain-obj/package.json b/node_modules/is-plain-obj/package.json new file mode 100644 index 0000000..2ee5a14 --- /dev/null +++ b/node_modules/is-plain-obj/package.json @@ -0,0 +1,41 @@ +{ + "name": "is-plain-obj", + "version": "4.1.0", + "description": "Check if a value is a plain object", + "license": "MIT", + "repository": "sindresorhus/is-plain-obj", + "funding": "https://github.com/sponsors/sindresorhus", + "author": { + "name": "Sindre Sorhus", + "email": "sindresorhus@gmail.com", + "url": "https://sindresorhus.com" + }, + "type": "module", + "exports": "./index.js", + "engines": { + "node": ">=12" + }, + "scripts": { + "test": "xo && ava && tsd" + }, + "files": [ + "index.js", + "index.d.ts" + ], + "keywords": [ + "object", + "is", + "check", + "test", + "type", + "plain", + "vanilla", + "pure", + "simple" + ], + "devDependencies": { + "ava": "^3.15.0", + "tsd": "^0.14.0", + "xo": "^0.38.2" + } +} diff --git a/node_modules/is-plain-obj/readme.md b/node_modules/is-plain-obj/readme.md new file mode 100644 index 0000000..28de6fb --- /dev/null +++ b/node_modules/is-plain-obj/readme.md @@ -0,0 +1,58 @@ +# is-plain-obj + +> Check if a value is a plain object + +An object is plain if it's created by either `{}`, `new Object()`, or `Object.create(null)`. + +## Install + +``` +$ npm install is-plain-obj +``` + +## Usage + +```js +import isPlainObject from 'is-plain-obj'; +import {runInNewContext} from 'node:vm'; + +isPlainObject({foo: 'bar'}); +//=> true + +isPlainObject(new Object()); +//=> true + +isPlainObject(Object.create(null)); +//=> true + +// This works across realms +isPlainObject(runInNewContext('({})')); +//=> true + +isPlainObject([1, 2, 3]); +//=> false + +class Unicorn {} +isPlainObject(new Unicorn()); +//=> false + +isPlainObject(Math); +//=> false +``` + +## Related + +- [is-obj](https://github.com/sindresorhus/is-obj) - Check if a value is an object +- [is](https://github.com/sindresorhus/is) - Type check values + +--- + +
+ + Get professional support for this package with a Tidelift subscription + +
+ + Tidelift helps make open source sustainable for maintainers while giving companies
assurances about security, maintenance, and licensing for their dependencies. + +
diff --git a/node_modules/prettier-plugin-latex/LICENSE b/node_modules/prettier-plugin-latex/LICENSE new file mode 100644 index 0000000..07d89d5 --- /dev/null +++ b/node_modules/prettier-plugin-latex/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2020-2021 Jason Siefken + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/node_modules/prettier-plugin-latex/README.md b/node_modules/prettier-plugin-latex/README.md new file mode 100644 index 0000000..8a4ef7f --- /dev/null +++ b/node_modules/prettier-plugin-latex/README.md @@ -0,0 +1,126 @@ +# prettier-plugin-latex + +A prettier plugin for formatting LaTeX documents. You can try it out online in the [playground](https://siefkenj.github.io/latex-parser-playground/) + +## Intro + +Prettier is an opinionated code formatter. It enforces a consistent style by parsing your code and re-printing it with its own rules that take the maximum line length into account, wrapping code when necessary. + +This plugin adds support for the LaTex to Prettier. While TeX itself cannot be parsed without being executed, `prettier-plugin-latex` makes the assumption that your document uses "standard" LaTeX, and parses it to the best of its ability. + +### Input + +```latex +\begin{enumerate} + \item[55,4] Hi there +\item$e^2$ is math mode! \[\begin{matrix}12&3^e\\pi&0\end{matrix}\] +\end{enumerate} +``` + +### Output + +```latex +\begin{enumerate} + \item[55,4] Hi there + + \item $e^{2}$ is math mode! + \[ + \begin{matrix} + 12 & 3^e \\ + pi & 0 + \end{matrix} + \] +\end{enumerate} +``` + +## Install + +yarn: + +```bash +yarn add --dev prettier prettier-plugin-latex +# or globally +yarn global add prettier prettier-plugin-latex +``` + +npm: + +```bash +npm install --save-dev prettier prettier-plugin-latex +# or globally +npm install --global prettier prettier-plugin-latex +``` + +## Use + +### With Node.js + +If you installed prettier as a local dependency, you can add prettier as a +script in your `package.json`, + +```json +{ + "scripts": { + "prettier": "prettier" + } +} +``` + +and then run it via + +```bash +yarn run prettier path/to/file.tex --write +# or +npm run prettier path/to/file.tex --write +``` + +If you installed globally, run + +```bash +prettier path/to/file.tex --write +``` + +**Node:** For Prettier v3, automatic plugin resolution was removed, so you must specify the directory of `prettier-plugin-latex` +manually with the `--plugin=...` command line argument. + +### In the Browser + +This package exposes a `standalone.js` that wraps prettier and exports a +`printPrettier` function that can be called as + +```js +printPrettier(YOUR_CODE, { + // example option + tabWidth: 2, +}); +``` + +## Options + +The standard Prettier options (such as `tabWidth`) can be used. + +## Development + +To make a production build, run + +``` +npm run build +``` + +To develop, run + +``` +npm run watch +``` + +You can then execute Prettier with + +``` +prettier --plugin=./dist/prettier-plugin-latex.js ... +``` + +and the LaTeX plugin will load from the current directory. + +### Code structure + +`prettier-plugin-latex` uses the [@unified-latex/unified-latex-prettier](https://github.com/siefkenj/unified-latex) library to parse the latex file and convert it to a prettier AST. This library is just a thin layer over `latex-ast-parser` diff --git a/node_modules/prettier-plugin-latex/dist/prettier-plugin-latex-9db821d0.mjs b/node_modules/prettier-plugin-latex/dist/prettier-plugin-latex-9db821d0.mjs new file mode 100644 index 0000000..ffbd194 --- /dev/null +++ b/node_modules/prettier-plugin-latex/dist/prettier-plugin-latex-9db821d0.mjs @@ -0,0 +1,24909 @@ +var __defProp = Object.defineProperty; +var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value; +var __publicField = (obj, key, value) => { + __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value); + return value; +}; +var linebreak = Symbol("linebreak"); +var ESCAPE$1 = "\\"; +function _printRaw(node) { + if (typeof node === "string") { + return [node]; + } + if (Array.isArray(node)) { + return [].concat( + ...node.map((n) => _printRaw(n)) + ); + } + let argsString, escape; + switch (node.type) { + case "root": + return _printRaw(node.content); + case "argument": + return [node.openMark, ..._printRaw(node.content), node.closeMark]; + case "comment": + var suffix = node.suffixParbreak ? "" : linebreak; + var leadingWhitespace = ""; + if (node.sameline && node.leadingWhitespace) { + leadingWhitespace = " "; + } + if (node.sameline) { + return [ + leadingWhitespace, + "%", + ..._printRaw(node.content), + suffix + ]; + } + return [linebreak, "%", ..._printRaw(node.content), suffix]; + case "environment": + case "mathenv": + case "verbatim": + var env = _printRaw(node.env); + var envStart = [ESCAPE$1 + "begin{", ...env, "}"]; + var envEnd = [ESCAPE$1 + "end{", ...env, "}"]; + argsString = node.args == null ? [] : _printRaw(node.args); + return [ + ...envStart, + ...argsString, + ..._printRaw(node.content), + ...envEnd + ]; + case "displaymath": + return [ESCAPE$1 + "[", ..._printRaw(node.content), ESCAPE$1 + "]"]; + case "group": + return ["{", ..._printRaw(node.content), "}"]; + case "inlinemath": + return ["$", ..._printRaw(node.content), "$"]; + case "macro": + argsString = node.args == null ? [] : _printRaw(node.args); + escape = node.escapeToken == null ? ESCAPE$1 : node.escapeToken; + return [escape, ..._printRaw(node.content), ...argsString]; + case "parbreak": + return [linebreak, linebreak]; + case "string": + return [node.content]; + case "verb": + return [ + ESCAPE$1, + node.env, + node.escape, + ..._printRaw(node.content), + node.escape + ]; + case "whitespace": + return [" "]; + default: + console.warn( + "Cannot find render for node ", + node, + `(of type ${typeof node})` + ); + return ["" + node]; + } +} +function printRaw(node, options2) { + const asArray = options2 != null ? options2.asArray : false; + const printedTokens = _printRaw(node); + if (asArray) { + return printedTokens; + } + return printedTokens.map((x) => x === linebreak ? "\n" : x).join(""); +} +function createMacroMatcher(macros17) { + const macrosHash = Array.isArray(macros17) ? macros17.length > 0 ? typeof macros17[0] === "string" ? Object.fromEntries( + macros17.map((macro2) => { + if (typeof macro2 !== "string") { + throw new Error("Wrong branch of map function"); + } + return [macro2, {}]; + }) + ) : Object.fromEntries( + macros17.map((macro2) => { + if (typeof macro2 === "string") { + throw new Error("Wrong branch of map function"); + } + if (macro2.escapeToken != null) { + return [ + macro2.content, + { escapeToken: macro2.escapeToken } + ]; + } + return [macro2.content, {}]; + }) + ) : {} : macros17; + return function matchAgainstMacros(node) { + if (node == null || node.type !== "macro") { + return false; + } + const spec = macrosHash[node.content]; + if (!spec) { + return false; + } + if (typeof spec === "object" && "escapeToken" in spec) { + return spec.escapeToken == null || spec.escapeToken === node.escapeToken; + } + return true; + }; +} +function createEnvironmentMatcher(macros17) { + const environmentsHash = Array.isArray(macros17) ? Object.fromEntries( + macros17.map((str) => { + return [str, {}]; + }) + ) : macros17; + return function matchAgainstEnvironments(node) { + if (!match.anyEnvironment(node)) { + return false; + } + const envName = printRaw(node.env); + const spec = environmentsHash[envName]; + if (!spec) { + return false; + } + return true; + }; +} +var match = { + macro(node, macroName) { + if (node == null) { + return false; + } + return node.type === "macro" && (macroName == null || node.content === macroName); + }, + anyMacro(node) { + return match.macro(node); + }, + environment(node, envName) { + if (node == null) { + return false; + } + return (node.type === "environment" || node.type === "mathenv") && (envName == null || printRaw(node.env) === envName); + }, + anyEnvironment(node) { + return match.environment(node); + }, + comment(node) { + if (node == null) { + return false; + } + return node.type === "comment"; + }, + parbreak(node) { + if (node == null) { + return false; + } + return node.type === "parbreak"; + }, + whitespace(node) { + if (node == null) { + return false; + } + return node.type === "whitespace"; + }, + /** + * Matches whitespace or a comment with leading whitespace. + */ + whitespaceLike(node) { + if (node == null) { + return false; + } + return node.type === "whitespace" || node.type === "whitespace" && node.leadingWhitespace === true; + }, + string(node, value) { + if (node == null) { + return false; + } + return node.type === "string" && (value == null || node.content === value); + }, + anyString(node) { + return match.string(node); + }, + group(node) { + if (node == null) { + return false; + } + return node.type === "group"; + }, + argument(node) { + if (node == null) { + return false; + } + return node.type === "argument"; + }, + blankArgument(node) { + if (!match.argument(node)) { + return false; + } + return node.openMark === "" && node.closeMark === "" && node.content.length === 0; + }, + math(node) { + if (node == null) { + return false; + } + return node.type === "displaymath" || node.type === "inlinemath"; + }, + createMacroMatcher, + createEnvironmentMatcher +}; +function listMathChildren(node) { + const NULL_RETURN = { enter: [], leave: [] }; + if (Array.isArray(node)) { + return NULL_RETURN; + } + if (match.math(node)) { + return { enter: ["content"], leave: [] }; + } + const renderInfo = node._renderInfo || {}; + if (renderInfo.inMathMode == null) { + return NULL_RETURN; + } + if (match.macro(node)) { + if (renderInfo.inMathMode === true) { + return { enter: ["args"], leave: [] }; + } else if (renderInfo.inMathMode === false) { + return { enter: [], leave: ["args"] }; + } + } + if (match.environment(node)) { + if (renderInfo.inMathMode === true) { + return { enter: ["content"], leave: [] }; + } else { + return { enter: [], leave: ["content"] }; + } + } + return NULL_RETURN; +} +var CONTINUE = Symbol("continue"); +var SKIP = Symbol("skip"); +var EXIT = Symbol("exit"); +var DEFAULT_CONTEXT = { + inMathMode: false, + hasMathModeAncestor: false +}; +function visit(tree, visitor, options2) { + const { + startingContext = DEFAULT_CONTEXT, + test = () => true, + includeArrays = false + } = options2 || {}; + let enter; + let leave; + if (typeof visitor === "function") { + enter = visitor; + } else if (visitor && typeof visitor === "object") { + enter = visitor.enter; + leave = visitor.leave; + } + walk(tree, { + key: void 0, + index: void 0, + parents: [], + containingArray: void 0, + context: { ...startingContext } + }); + function walk(node, { key, index: index2, parents, context, containingArray }) { + const nodePassesTest = includeArrays ? test(node, { key, index: index2, parents, context, containingArray }) : !Array.isArray(node) && test(node, { key, index: index2, parents, context, containingArray }); + const result = enter && nodePassesTest ? toResult( + enter(node, { + key, + index: index2, + parents, + context, + containingArray + }) + ) : [CONTINUE]; + if (result[0] === EXIT) { + return result; + } + if (result[0] === SKIP) { + return leave && nodePassesTest ? toResult( + leave(node, { + key, + index: index2, + parents, + context, + containingArray + }) + ) : result; + } + if (Array.isArray(node)) { + for (let index22 = 0; index22 > -1 && index22 < node.length; index22++) { + const item = node[index22]; + const result2 = walk(item, { + key, + index: index22, + parents, + context, + containingArray: node + }); + if (result2[0] === EXIT) { + return result2; + } + if (typeof result2[1] === "number") { + index22 = result2[1] - 1; + } + } + } else { + let childProps = ["content", "args"]; + switch (node.type) { + case "macro": + childProps = ["args"]; + break; + case "comment": + case "string": + case "verb": + case "verbatim": + childProps = []; + break; + } + const mathModeProps = listMathChildren(node); + for (const key2 of childProps) { + const value = node[key2]; + const grandparents = [node].concat(parents); + if (value == null) { + continue; + } + const newContext = { ...context }; + if (mathModeProps.enter.includes(key2)) { + newContext.inMathMode = true; + newContext.hasMathModeAncestor = true; + } else if (mathModeProps.leave.includes(key2)) { + newContext.inMathMode = false; + } + const result2 = walk(value, { + key: key2, + index: void 0, + parents: grandparents, + context: newContext, + containingArray: void 0 + }); + if (result2[0] === EXIT) { + return result2; + } + } + } + return leave && nodePassesTest ? toResult( + leave(node, { + key, + index: index2, + parents, + context, + containingArray + }) + ) : result; + } +} +function toResult(value) { + if (value == null) { + return [CONTINUE]; + } + if (Array.isArray(value)) { + return value; + } + if (typeof value === "number") { + return [CONTINUE, value]; + } + return [value]; +} +function trim$1(nodes) { + if (!Array.isArray(nodes)) { + console.warn("Trying to trim a non-array ast", nodes); + return nodes; + } + const { trimmedStart } = trimStart(nodes); + const { trimmedEnd } = trimEnd(nodes); + return { trimmedStart, trimmedEnd }; +} +function trimStart(nodes) { + const { start } = amountOfLeadingAndTrailingWhitespace(nodes); + nodes.splice(0, start); + for (const leadingToken of nodes) { + if (!match.comment(leadingToken)) { + break; + } + if (leadingToken.leadingWhitespace || leadingToken.sameline) { + leadingToken.leadingWhitespace = false; + delete leadingToken.position; + } + if (start > 0 && leadingToken.sameline) { + leadingToken.sameline = false; + delete leadingToken.position; + } + } + return { trimmedStart: start }; +} +function trimEnd(nodes) { + const { end } = amountOfLeadingAndTrailingWhitespace(nodes); + nodes.splice(nodes.length - end, end); + for (let i = nodes.length - 1; i >= 0; i--) { + const trailingToken = nodes[i]; + if (!match.comment(trailingToken)) { + break; + } + delete trailingToken.suffixParbreak; + if (match.comment(trailingToken) && trailingToken.leadingWhitespace && !trailingToken.sameline) { + trailingToken.leadingWhitespace = false; + delete trailingToken.position; + } + } + return { trimmedEnd: end }; +} +function amountOfLeadingAndTrailingWhitespace(ast) { + let start = 0; + let end = 0; + for (const node of ast) { + if (match.whitespace(node) || match.parbreak(node)) { + start++; + } else { + break; + } + } + if (start === ast.length) { + return { start, end: 0 }; + } + for (let i = ast.length - 1; i >= 0; i--) { + const node = ast[i]; + if (match.whitespace(node) || match.parbreak(node)) { + end++; + } else { + break; + } + } + return { start, end }; +} +var unifiedLatexTrimEnvironmentContents = function unifiedLatexTrimEnvironmentContents2() { + return (tree) => { + visit(tree, (node) => { + if (!(match.math(node) || match.anyEnvironment(node))) { + return; + } + let firstNode = node.content[0]; + if (match.comment(firstNode) && firstNode.sameline) { + firstNode.suffixParbreak = false; + trimEnd(node.content); + const { trimmedStart } = trimStart(node.content.slice(1)); + node.content.splice(1, trimmedStart); + } else { + trim$1(node.content); + } + }); + }; +}; +var unifiedLatexTrimRoot = function unifiedLatexTrimRoot2() { + return (tree) => { + trim$1(tree.content); + }; +}; +function decorateArrayForPegjs(array) { + array.charAt = function(i) { + return this[i]; + }; + array.charCodeAt = () => 0; + array.substring = function(i, j) { + return this.slice(i, j); + }; + array.replace = function(a, b) { + const ret = JSON.stringify(this); + return ret.replace(a, b); + }; + return array; +} +var latex_default = ( + // Generated by Peggy 2.0.1. + // + // https://peggyjs.org/ + function() { + function peg$subclass(child, parent) { + function C() { + this.constructor = child; + } + C.prototype = parent.prototype; + child.prototype = new C(); + } + function peg$SyntaxError(message, expected, found, location) { + var self = Error.call(this, message); + if (Object.setPrototypeOf) { + Object.setPrototypeOf(self, peg$SyntaxError.prototype); + } + self.expected = expected; + self.found = found; + self.location = location; + self.name = "SyntaxError"; + return self; + } + peg$subclass(peg$SyntaxError, Error); + function peg$padEnd(str, targetLength, padString) { + padString = padString || " "; + if (str.length > targetLength) { + return str; + } + targetLength -= str.length; + padString += padString.repeat(targetLength); + return str + padString.slice(0, targetLength); + } + peg$SyntaxError.prototype.format = function(sources) { + var str = "Error: " + this.message; + if (this.location) { + var src = null; + var k; + for (k = 0; k < sources.length; k++) { + if (sources[k].source === this.location.source) { + src = sources[k].text.split(/\r\n|\n|\r/g); + break; + } + } + var s2 = this.location.start; + var loc = this.location.source + ":" + s2.line + ":" + s2.column; + if (src) { + var e = this.location.end; + var filler = peg$padEnd("", s2.line.toString().length, " "); + var line3 = src[s2.line - 1]; + var last = s2.line === e.line ? e.column : line3.length + 1; + var hatLen = last - s2.column || 1; + str += "\n --> " + loc + "\n" + filler + " |\n" + s2.line + " | " + line3 + "\n" + filler + " | " + peg$padEnd("", s2.column - 1, " ") + peg$padEnd("", hatLen, "^"); + } else { + str += "\n at " + loc; + } + } + return str; + }; + peg$SyntaxError.buildMessage = function(expected, found) { + var DESCRIBE_EXPECTATION_FNS = { + literal: function(expectation) { + return '"' + literalEscape(expectation.text) + '"'; + }, + class: function(expectation) { + var escapedParts = expectation.parts.map(function(part) { + return Array.isArray(part) ? classEscape(part[0]) + "-" + classEscape(part[1]) : classEscape(part); + }); + return "[" + (expectation.inverted ? "^" : "") + escapedParts.join("") + "]"; + }, + any: function() { + return "any character"; + }, + end: function() { + return "end of input"; + }, + other: function(expectation) { + return expectation.description; + } + }; + function hex(ch) { + return ch.charCodeAt(0).toString(16).toUpperCase(); + } + function literalEscape(s2) { + return s2.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\0/g, "\\0").replace(/\t/g, "\\t").replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/[\x00-\x0F]/g, function(ch) { + return "\\x0" + hex(ch); + }).replace(/[\x10-\x1F\x7F-\x9F]/g, function(ch) { + return "\\x" + hex(ch); + }); + } + function classEscape(s2) { + return s2.replace(/\\/g, "\\\\").replace(/\]/g, "\\]").replace(/\^/g, "\\^").replace(/-/g, "\\-").replace(/\0/g, "\\0").replace(/\t/g, "\\t").replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/[\x00-\x0F]/g, function(ch) { + return "\\x0" + hex(ch); + }).replace(/[\x10-\x1F\x7F-\x9F]/g, function(ch) { + return "\\x" + hex(ch); + }); + } + function describeExpectation(expectation) { + return DESCRIBE_EXPECTATION_FNS[expectation.type](expectation); + } + function describeExpected(expected2) { + var descriptions = expected2.map(describeExpectation); + var i, j; + descriptions.sort(); + if (descriptions.length > 0) { + for (i = 1, j = 1; i < descriptions.length; i++) { + if (descriptions[i - 1] !== descriptions[i]) { + descriptions[j] = descriptions[i]; + j++; + } + } + descriptions.length = j; + } + switch (descriptions.length) { + case 1: + return descriptions[0]; + case 2: + return descriptions[0] + " or " + descriptions[1]; + default: + return descriptions.slice(0, -1).join(", ") + ", or " + descriptions[descriptions.length - 1]; + } + } + function describeFound(found2) { + return found2 ? '"' + literalEscape(found2) + '"' : "end of input"; + } + return "Expected " + describeExpected(expected) + " but " + describeFound(found) + " found."; + }; + function peg$parse(input, options2) { + options2 = options2 !== void 0 ? options2 : {}; + var peg$FAILED = {}; + var peg$source = options2.grammarSource; + var peg$startRuleFunctions = { document: peg$parsedocument, math: peg$parsemath }; + var peg$startRuleFunction = peg$parsedocument; + var peg$c0 = "%"; + var peg$c1 = "."; + var peg$c2 = "verb*"; + var peg$c3 = "verb"; + var peg$c4 = "["; + var peg$c5 = "]"; + var peg$c6 = "lstinline"; + var peg$c7 = "mintinline"; + var peg$c8 = "mint"; + var peg$c10 = "verbatim*"; + var peg$c11 = "verbatim"; + var peg$c12 = "filecontents*"; + var peg$c13 = "filecontents"; + var peg$c14 = "comment"; + var peg$c15 = "lstlisting"; + var peg$c16 = "("; + var peg$c17 = ")"; + var peg$c18 = "begin"; + var peg$c19 = "end"; + var peg$c20 = "equation*"; + var peg$c21 = "equation"; + var peg$c22 = "align*"; + var peg$c23 = "align"; + var peg$c24 = "alignat*"; + var peg$c25 = "alignat"; + var peg$c26 = "gather*"; + var peg$c27 = "gather"; + var peg$c28 = "multline*"; + var peg$c29 = "multline"; + var peg$c30 = "flalign*"; + var peg$c31 = "flalign"; + var peg$c32 = "split"; + var peg$c33 = "math"; + var peg$c34 = "displaymath"; + var peg$c35 = "\\"; + var peg$c36 = "{"; + var peg$c37 = "}"; + var peg$c38 = "$"; + var peg$c39 = "&"; + var peg$c40 = "\r"; + var peg$c41 = "\n"; + var peg$c42 = "\r\n"; + var peg$c43 = "#"; + var peg$c44 = "^"; + var peg$c45 = "_"; + var peg$c46 = "\0"; + var peg$r0 = /^[^ \t\n\r]/; + var peg$r1 = /^[ \t]/; + var peg$r2 = /^[a-zA-Z]/; + var peg$r3 = /^[0-9]/; + var peg$r4 = /^[.,;:\-*\/()!?=+<>[\]`'"~]/; + var peg$e0 = peg$otherExpectation("document"); + var peg$e1 = peg$otherExpectation("math"); + var peg$e2 = peg$otherExpectation("token"); + var peg$e3 = peg$anyExpectation(); + var peg$e4 = peg$otherExpectation("parbreak"); + var peg$e5 = peg$otherExpectation("math token"); + var peg$e6 = peg$otherExpectation("nonchar token"); + var peg$e7 = peg$literalExpectation("%", false); + var peg$e8 = peg$otherExpectation("whitespace"); + var peg$e9 = peg$otherExpectation("number"); + var peg$e10 = peg$literalExpectation(".", false); + var peg$e11 = peg$otherExpectation("special macro"); + var peg$e12 = peg$literalExpectation("verb*", false); + var peg$e13 = peg$literalExpectation("verb", false); + var peg$e14 = peg$literalExpectation("[", false); + var peg$e15 = peg$literalExpectation("]", false); + var peg$e16 = peg$classExpectation([" ", " ", "\n", "\r"], true, false); + var peg$e17 = peg$otherExpectation("verbatim listings"); + var peg$e18 = peg$literalExpectation("lstinline", false); + var peg$e19 = peg$otherExpectation("verbatim minted"); + var peg$e20 = peg$literalExpectation("mintinline", false); + var peg$e21 = peg$literalExpectation("mint", false); + var peg$e24 = peg$otherExpectation("verbatim environment"); + var peg$e25 = peg$literalExpectation("verbatim*", false); + var peg$e26 = peg$literalExpectation("verbatim", false); + var peg$e27 = peg$literalExpectation("filecontents*", false); + var peg$e28 = peg$literalExpectation("filecontents", false); + var peg$e29 = peg$literalExpectation("comment", false); + var peg$e30 = peg$literalExpectation("lstlisting", false); + var peg$e31 = peg$otherExpectation("macro"); + var peg$e32 = peg$otherExpectation("group"); + var peg$e33 = peg$otherExpectation("environment"); + var peg$e34 = peg$otherExpectation("math environment"); + var peg$e36 = peg$literalExpectation("(", false); + var peg$e37 = peg$literalExpectation(")", false); + var peg$e38 = peg$literalExpectation("begin", false); + var peg$e39 = peg$literalExpectation("end", false); + var peg$e40 = peg$literalExpectation("equation*", false); + var peg$e41 = peg$literalExpectation("equation", false); + var peg$e42 = peg$literalExpectation("align*", false); + var peg$e43 = peg$literalExpectation("align", false); + var peg$e44 = peg$literalExpectation("alignat*", false); + var peg$e45 = peg$literalExpectation("alignat", false); + var peg$e46 = peg$literalExpectation("gather*", false); + var peg$e47 = peg$literalExpectation("gather", false); + var peg$e48 = peg$literalExpectation("multline*", false); + var peg$e49 = peg$literalExpectation("multline", false); + var peg$e50 = peg$literalExpectation("flalign*", false); + var peg$e51 = peg$literalExpectation("flalign", false); + var peg$e52 = peg$literalExpectation("split", false); + var peg$e53 = peg$literalExpectation("math", false); + var peg$e54 = peg$literalExpectation("displaymath", false); + var peg$e55 = peg$otherExpectation("escape"); + var peg$e56 = peg$literalExpectation("\\", false); + var peg$e57 = peg$literalExpectation("{", false); + var peg$e58 = peg$literalExpectation("}", false); + var peg$e59 = peg$literalExpectation("$", false); + var peg$e60 = peg$literalExpectation("&", false); + var peg$e61 = peg$otherExpectation("newline"); + var peg$e62 = peg$literalExpectation("\r", false); + var peg$e63 = peg$literalExpectation("\n", false); + var peg$e64 = peg$literalExpectation("\r\n", false); + var peg$e65 = peg$literalExpectation("#", false); + var peg$e66 = peg$literalExpectation("^", false); + var peg$e67 = peg$literalExpectation("_", false); + var peg$e68 = peg$literalExpectation("\0", false); + var peg$e69 = peg$classExpectation([" ", " "], false, false); + var peg$e70 = peg$otherExpectation("letter"); + var peg$e71 = peg$classExpectation([["a", "z"], ["A", "Z"]], false, false); + var peg$e72 = peg$otherExpectation("digit"); + var peg$e73 = peg$classExpectation([["0", "9"]], false, false); + var peg$e74 = peg$otherExpectation("punctuation"); + var peg$e75 = peg$classExpectation([".", ",", ";", ":", "-", "*", "/", "(", ")", "!", "?", "=", "+", "<", ">", "[", "]", "`", "'", '"', "~"], false, false); + var peg$e76 = peg$otherExpectation("full comment"); + var peg$e77 = peg$otherExpectation("comment"); + var peg$f0 = function(content) { + return createNode("root", { content: content.flatMap((x) => x) }); + }; + var peg$f1 = function(t) { + return t; + }; + var peg$f2 = function(eq) { + return createNode("inlinemath", { content: eq.flatMap((x) => x) }); + }; + var peg$f3 = function(s2) { + return createNode("string", { content: s2 }); + }; + var peg$f4 = function(s2) { + return createNode("string", { content: s2 }); + }; + var peg$f5 = function() { + return createNode("parbreak"); + }; + var peg$f6 = function(x) { + return x; + }; + var peg$f7 = function(x) { + return x; + }; + var peg$f8 = function() { + return createNode("macro", { content: "^", escapeToken: "" }); + }; + var peg$f9 = function() { + return createNode("macro", { content: "_", escapeToken: "" }); + }; + var peg$f10 = function(s2) { + return createNode("string", { content: s2 }); + }; + var peg$f11 = function() { + return createNode("whitespace"); + }; + var peg$f12 = function(a, b) { + return a.join("") + "." + b.join(""); + }; + var peg$f13 = function(b) { + return "." + b.join(""); + }; + var peg$f14 = function(a) { + return a.join("") + "."; + }; + var peg$f15 = function(s2) { + return createNode("string", { content: s2 }); + }; + var peg$f16 = function(env, e, end) { + return end == e; + }; + var peg$f17 = function(env, e, x) { + return x; + }; + var peg$f18 = function(env, e, x, end) { + return end == e; + }; + var peg$f19 = function(env, e, x) { + return createNode("verb", { + env, + escape: e, + content: x.join("") + }); + }; + var peg$f20 = function(x) { + return x; + }; + var peg$f21 = function(x) { + return createNode("displaymath", { content: x.flatMap((x2) => x2) }); + }; + var peg$f22 = function(x) { + return x; + }; + var peg$f23 = function(x) { + return createNode("inlinemath", { content: x.flatMap((x2) => x2) }); + }; + var peg$f24 = function(x) { + return x; + }; + var peg$f25 = function(x) { + return createNode("displaymath", { content: x.flatMap((x2) => x2) }); + }; + var peg$f26 = function(end) { + return end.type === "string" && end.content === "]"; + }; + var peg$f27 = function(x) { + return x; + }; + var peg$f28 = function(o) { + return [ + createNode("string", { content: "[" }), + ...o, + createNode("string", { content: "]" }) + ]; + }; + var peg$f29 = function(x) { + return x; + }; + var peg$f30 = function(v) { + return createNode("group", { + content: createNode("string", { content: v.join("") }) + }); + }; + var peg$f31 = function(d, end) { + return end == d; + }; + var peg$f32 = function(d, x) { + return x; + }; + var peg$f33 = function(d, v, end) { + return end == d; + }; + var peg$f34 = function(d, v) { + return [ + createNode("string", { content: d }), + createNode("string", { content: v.join("") }), + createNode("string", { content: d }) + ]; + }; + var peg$f35 = function(macro, option, verbatim) { + return [ + createNode("macro", { content: macro }), + ...option || [], + ...[].concat(verbatim) + ]; + }; + var peg$f36 = function(macro, option, language, verbatim) { + return [ + createNode("macro", { content: macro }), + ...option || [], + language, + ...[].concat(verbatim) + ]; + }; + var peg$f40 = function(env, end_env) { + return compare_env({ content: [env] }, end_env); + }; + var peg$f41 = function(env, x) { + return x; + }; + var peg$f42 = function(env, body) { + return createNode("verbatim", { + env, + content: body.join("") + }); + }; + var peg$f43 = function(n) { + return n.join(""); + }; + var peg$f44 = function(n) { + return n; + }; + var peg$f45 = function(m) { + return createNode("macro", { content: m }); + }; + var peg$f46 = function(c) { + return c; + }; + var peg$f47 = function(x) { + return createNode("group", { content: x.flatMap((x2) => x2) }); + }; + var peg$f48 = function(g) { + return text().slice(1, -1); + }; + var peg$f49 = function(env, env_comment, end_env) { + return compare_env(env, end_env); + }; + var peg$f50 = function(env, env_comment, x) { + return x; + }; + var peg$f51 = function(env, env_comment, body) { + body = body.flatMap((x) => x); + return createNode("environment", { + env, + content: env_comment ? [env_comment, ...body] : body + }); + }; + var peg$f52 = function(env, env_comment, end_env) { + return compare_env({ content: [env] }, end_env); + }; + var peg$f53 = function(env, env_comment, x) { + return x; + }; + var peg$f54 = function(env, env_comment, body) { + body = body.flatMap((x) => x); + return createNode("mathenv", { + env, + content: env_comment ? [env_comment, ...body] : body + }); + }; + var peg$f57 = function(e) { + return createNode("string", { content: e }); + }; + var peg$f58 = function() { + return createNode("string", { content: "\\" }); + }; + var peg$f59 = function(s2) { + return createNode("string", { content: s2 }); + }; + var peg$f60 = function(s2) { + return createNode("string", { content: s2 }); + }; + var peg$f61 = function(s2) { + return createNode("string", { content: s2 }); + }; + var peg$f62 = function(s2) { + return createNode("string", { content: s2 }); + }; + var peg$f63 = function(s2) { + return createNode("string", { content: s2 }); + }; + var peg$f64 = function(s2) { + return createNode("string", { content: s2 }); + }; + var peg$f65 = function(s2) { + return createNode("string", { content: s2 }); + }; + var peg$f66 = function() { + return " "; + }; + var peg$f67 = function(p) { + return createNode("string", { content: p }); + }; + var peg$f68 = function(leading_sp, comment) { + return createNode("comment", { + ...comment, + sameline: false, + leadingWhitespace: leading_sp.length > 0 + }); + }; + var peg$f69 = function(spaces, x) { + return createNode("comment", { + ...x, + sameline: true, + leadingWhitespace: spaces.length > 0 + }); + }; + var peg$f70 = function(c) { + return c; + }; + var peg$f71 = function(c) { + return { content: c.join(""), suffixParbreak: true }; + }; + var peg$f72 = function(c) { + return c; + }; + var peg$f73 = function(c) { + return { content: c.join("") }; + }; + var peg$f74 = function() { + var loc = location(); + return loc.start.column === 1; + }; + var peg$currPos = 0; + var peg$savedPos = 0; + var peg$posDetailsCache = [{ line: 1, column: 1 }]; + var peg$maxFailPos = 0; + var peg$maxFailExpected = []; + var peg$silentFails = 0; + var peg$result; + if ("startRule" in options2) { + if (!(options2.startRule in peg$startRuleFunctions)) { + throw new Error(`Can't start parsing from rule "` + options2.startRule + '".'); + } + peg$startRuleFunction = peg$startRuleFunctions[options2.startRule]; + } + function text() { + return input.substring(peg$savedPos, peg$currPos); + } + function location() { + return peg$computeLocation(peg$savedPos, peg$currPos); + } + function peg$literalExpectation(text2, ignoreCase) { + return { type: "literal", text: text2, ignoreCase }; + } + function peg$classExpectation(parts, inverted, ignoreCase) { + return { type: "class", parts, inverted, ignoreCase }; + } + function peg$anyExpectation() { + return { type: "any" }; + } + function peg$endExpectation() { + return { type: "end" }; + } + function peg$otherExpectation(description) { + return { type: "other", description }; + } + function peg$computePosDetails(pos) { + var details = peg$posDetailsCache[pos]; + var p; + if (details) { + return details; + } else { + p = pos - 1; + while (!peg$posDetailsCache[p]) { + p--; + } + details = peg$posDetailsCache[p]; + details = { + line: details.line, + column: details.column + }; + while (p < pos) { + if (input.charCodeAt(p) === 10) { + details.line++; + details.column = 1; + } else { + details.column++; + } + p++; + } + peg$posDetailsCache[pos] = details; + return details; + } + } + function peg$computeLocation(startPos, endPos) { + var startPosDetails = peg$computePosDetails(startPos); + var endPosDetails = peg$computePosDetails(endPos); + return { + source: peg$source, + start: { + offset: startPos, + line: startPosDetails.line, + column: startPosDetails.column + }, + end: { + offset: endPos, + line: endPosDetails.line, + column: endPosDetails.column + } + }; + } + function peg$fail(expected2) { + if (peg$currPos < peg$maxFailPos) { + return; + } + if (peg$currPos > peg$maxFailPos) { + peg$maxFailPos = peg$currPos; + peg$maxFailExpected = []; + } + peg$maxFailExpected.push(expected2); + } + function peg$buildStructuredError(expected2, found, location2) { + return new peg$SyntaxError( + peg$SyntaxError.buildMessage(expected2, found), + expected2, + found, + location2 + ); + } + function peg$parsedocument() { + var s0, s1, s2; + peg$silentFails++; + s0 = peg$currPos; + s1 = []; + s2 = peg$parsetoken(); + while (s2 !== peg$FAILED) { + s1.push(s2); + s2 = peg$parsetoken(); + } + peg$savedPos = s0; + s1 = peg$f0(s1); + s0 = s1; + peg$silentFails--; + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + return s0; + } + function peg$parsemath() { + var s0, s1; + peg$silentFails++; + s0 = []; + s1 = peg$parsemath_token(); + while (s1 !== peg$FAILED) { + s0.push(s1); + s1 = peg$parsemath_token(); + } + peg$silentFails--; + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e1); + } + return s0; + } + function peg$parsetoken() { + var s0, s1, s2, s3, s4, s5; + peg$silentFails++; + s0 = peg$parsespecial_macro(); + if (s0 === peg$FAILED) { + s0 = peg$parsemacro(); + if (s0 === peg$FAILED) { + s0 = peg$parsefull_comment(); + if (s0 === peg$FAILED) { + s0 = peg$parsegroup(); + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$parsemath_shift(); + if (s1 !== peg$FAILED) { + s2 = []; + s3 = peg$currPos; + s4 = peg$currPos; + peg$silentFails++; + s5 = peg$parsemath_shift(); + peg$silentFails--; + if (s5 === peg$FAILED) { + s4 = void 0; + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + if (s4 !== peg$FAILED) { + s5 = peg$parsemath_token(); + if (s5 !== peg$FAILED) { + peg$savedPos = s3; + s3 = peg$f1(s5); + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + if (s3 !== peg$FAILED) { + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$currPos; + s4 = peg$currPos; + peg$silentFails++; + s5 = peg$parsemath_shift(); + peg$silentFails--; + if (s5 === peg$FAILED) { + s4 = void 0; + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + if (s4 !== peg$FAILED) { + s5 = peg$parsemath_token(); + if (s5 !== peg$FAILED) { + peg$savedPos = s3; + s3 = peg$f1(s5); + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s3 = peg$parsemath_shift(); + if (s3 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f2(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$parsealignment_tab(); + if (s0 === peg$FAILED) { + s0 = peg$parseparbreak(); + if (s0 === peg$FAILED) { + s0 = peg$parsemacro_parameter(); + if (s0 === peg$FAILED) { + s0 = peg$parseignore(); + if (s0 === peg$FAILED) { + s0 = peg$parsenumber(); + if (s0 === peg$FAILED) { + s0 = peg$parsewhitespace(); + if (s0 === peg$FAILED) { + s0 = peg$parsepunctuation(); + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$currPos; + s2 = []; + s3 = peg$currPos; + s4 = peg$currPos; + peg$silentFails++; + s5 = peg$parsenonchar_token(); + peg$silentFails--; + if (s5 === peg$FAILED) { + s4 = void 0; + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + if (s4 !== peg$FAILED) { + if (input.length > peg$currPos) { + s5 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s5 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s5 !== peg$FAILED) { + s4 = [s4, s5]; + s3 = s4; + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + if (s3 !== peg$FAILED) { + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$currPos; + s4 = peg$currPos; + peg$silentFails++; + s5 = peg$parsenonchar_token(); + peg$silentFails--; + if (s5 === peg$FAILED) { + s4 = void 0; + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + if (s4 !== peg$FAILED) { + if (input.length > peg$currPos) { + s5 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s5 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s5 !== peg$FAILED) { + s4 = [s4, s5]; + s3 = s4; + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s1 = input.substring(s1, peg$currPos); + } else { + s1 = s2; + } + if (s1 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$f3(s1); + } + s0 = s1; + if (s0 === peg$FAILED) { + s0 = peg$parsebegin_group(); + if (s0 === peg$FAILED) { + s0 = peg$parseend_group(); + if (s0 === peg$FAILED) { + s0 = peg$parsemath_shift(); + if (s0 === peg$FAILED) { + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s1 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$f4(s1); + } + s0 = s1; + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e2); + } + } + return s0; + } + function peg$parseparbreak() { + var s0, s1, s2, s3, s4, s5, s6, s7; + peg$silentFails++; + s0 = peg$currPos; + s1 = peg$currPos; + s2 = []; + s3 = peg$parsesp(); + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$parsesp(); + } + s3 = peg$parsenl(); + if (s3 !== peg$FAILED) { + s4 = []; + s5 = peg$currPos; + s6 = []; + s7 = peg$parsesp(); + while (s7 !== peg$FAILED) { + s6.push(s7); + s7 = peg$parsesp(); + } + s7 = peg$parsenl(); + if (s7 !== peg$FAILED) { + s6 = [s6, s7]; + s5 = s6; + } else { + peg$currPos = s5; + s5 = peg$FAILED; + } + if (s5 !== peg$FAILED) { + while (s5 !== peg$FAILED) { + s4.push(s5); + s5 = peg$currPos; + s6 = []; + s7 = peg$parsesp(); + while (s7 !== peg$FAILED) { + s6.push(s7); + s7 = peg$parsesp(); + } + s7 = peg$parsenl(); + if (s7 !== peg$FAILED) { + s6 = [s6, s7]; + s5 = s6; + } else { + peg$currPos = s5; + s5 = peg$FAILED; + } + } + } else { + s4 = peg$FAILED; + } + if (s4 !== peg$FAILED) { + s5 = []; + s6 = peg$parsesp(); + while (s6 !== peg$FAILED) { + s5.push(s6); + s6 = peg$parsesp(); + } + s6 = peg$currPos; + peg$silentFails++; + s7 = peg$parsecomment_start(); + peg$silentFails--; + if (s7 === peg$FAILED) { + s6 = void 0; + } else { + peg$currPos = s6; + s6 = peg$FAILED; + } + if (s6 !== peg$FAILED) { + s2 = [s2, s3, s4, s5, s6]; + s1 = s2; + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + if (s1 === peg$FAILED) { + s1 = peg$currPos; + s2 = []; + s3 = peg$parsesp(); + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$parsesp(); + } + s3 = peg$parsenl(); + if (s3 !== peg$FAILED) { + s4 = []; + s5 = peg$currPos; + s6 = []; + s7 = peg$parsesp(); + while (s7 !== peg$FAILED) { + s6.push(s7); + s7 = peg$parsesp(); + } + s7 = peg$parsenl(); + if (s7 !== peg$FAILED) { + s6 = [s6, s7]; + s5 = s6; + } else { + peg$currPos = s5; + s5 = peg$FAILED; + } + if (s5 !== peg$FAILED) { + while (s5 !== peg$FAILED) { + s4.push(s5); + s5 = peg$currPos; + s6 = []; + s7 = peg$parsesp(); + while (s7 !== peg$FAILED) { + s6.push(s7); + s7 = peg$parsesp(); + } + s7 = peg$parsenl(); + if (s7 !== peg$FAILED) { + s6 = [s6, s7]; + s5 = s6; + } else { + peg$currPos = s5; + s5 = peg$FAILED; + } + } + } else { + s4 = peg$FAILED; + } + if (s4 !== peg$FAILED) { + s2 = [s2, s3, s4]; + s1 = s2; + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + } + if (s1 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$f5(); + } + s0 = s1; + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e4); + } + } + return s0; + } + function peg$parsemath_token() { + var s0, s1, s2, s3, s4; + peg$silentFails++; + s0 = peg$parsespecial_macro(); + if (s0 === peg$FAILED) { + s0 = peg$parsemacro(); + if (s0 === peg$FAILED) { + s0 = peg$parsefull_comment(); + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = []; + s2 = peg$parsewhitespace(); + while (s2 !== peg$FAILED) { + s1.push(s2); + s2 = peg$parsewhitespace(); + } + s2 = peg$parsegroup(); + if (s2 !== peg$FAILED) { + s3 = []; + s4 = peg$parsewhitespace(); + while (s4 !== peg$FAILED) { + s3.push(s4); + s4 = peg$parsewhitespace(); + } + peg$savedPos = s0; + s0 = peg$f6(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = []; + s2 = peg$parsewhitespace(); + while (s2 !== peg$FAILED) { + s1.push(s2); + s2 = peg$parsewhitespace(); + } + s2 = peg$parsealignment_tab(); + if (s2 !== peg$FAILED) { + s3 = []; + s4 = peg$parsewhitespace(); + while (s4 !== peg$FAILED) { + s3.push(s4); + s4 = peg$parsewhitespace(); + } + peg$savedPos = s0; + s0 = peg$f7(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$parsemacro_parameter(); + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = []; + s2 = peg$parsewhitespace(); + while (s2 !== peg$FAILED) { + s1.push(s2); + s2 = peg$parsewhitespace(); + } + s2 = peg$parsesuperscript(); + if (s2 !== peg$FAILED) { + s3 = []; + s4 = peg$parsewhitespace(); + while (s4 !== peg$FAILED) { + s3.push(s4); + s4 = peg$parsewhitespace(); + } + peg$savedPos = s0; + s0 = peg$f8(); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = []; + s2 = peg$parsewhitespace(); + while (s2 !== peg$FAILED) { + s1.push(s2); + s2 = peg$parsewhitespace(); + } + s2 = peg$parsesubscript(); + if (s2 !== peg$FAILED) { + s3 = []; + s4 = peg$parsewhitespace(); + while (s4 !== peg$FAILED) { + s3.push(s4); + s4 = peg$parsewhitespace(); + } + peg$savedPos = s0; + s0 = peg$f9(); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$parseignore(); + if (s0 === peg$FAILED) { + s0 = peg$parsewhitespace(); + if (s0 === peg$FAILED) { + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s1 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$f10(s1); + } + s0 = s1; + } + } + } + } + } + } + } + } + } + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e5); + } + } + return s0; + } + function peg$parsenonchar_token() { + var s0; + peg$silentFails++; + s0 = peg$parseescape(); + if (s0 === peg$FAILED) { + if (input.charCodeAt(peg$currPos) === 37) { + s0 = peg$c0; + peg$currPos++; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e7); + } + } + if (s0 === peg$FAILED) { + s0 = peg$parsebegin_group(); + if (s0 === peg$FAILED) { + s0 = peg$parseend_group(); + if (s0 === peg$FAILED) { + s0 = peg$parsemath_shift(); + if (s0 === peg$FAILED) { + s0 = peg$parsealignment_tab(); + if (s0 === peg$FAILED) { + s0 = peg$parsenl(); + if (s0 === peg$FAILED) { + s0 = peg$parsemacro_parameter(); + if (s0 === peg$FAILED) { + s0 = peg$parseignore(); + if (s0 === peg$FAILED) { + s0 = peg$parsesp(); + if (s0 === peg$FAILED) { + s0 = peg$parsepunctuation(); + if (s0 === peg$FAILED) { + s0 = peg$parseEOF(); + } + } + } + } + } + } + } + } + } + } + } + peg$silentFails--; + if (s0 === peg$FAILED) { + if (peg$silentFails === 0) { + peg$fail(peg$e6); + } + } + return s0; + } + function peg$parsewhitespace() { + var s0, s1, s2, s3, s4, s5, s6, s7; + peg$silentFails++; + s0 = peg$currPos; + s1 = peg$currPos; + s2 = peg$parsenl(); + if (s2 !== peg$FAILED) { + s3 = []; + s4 = peg$parsesp(); + while (s4 !== peg$FAILED) { + s3.push(s4); + s4 = peg$parsesp(); + } + s2 = [s2, s3]; + s1 = s2; + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + if (s1 === peg$FAILED) { + s1 = peg$currPos; + s2 = []; + s3 = peg$parsesp(); + if (s3 !== peg$FAILED) { + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$parsesp(); + } + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s3 = peg$parsenl(); + if (s3 !== peg$FAILED) { + s4 = peg$currPos; + peg$silentFails++; + s5 = peg$parsecomment_start(); + peg$silentFails--; + if (s5 === peg$FAILED) { + s4 = void 0; + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + if (s4 !== peg$FAILED) { + s5 = []; + s6 = peg$parsesp(); + while (s6 !== peg$FAILED) { + s5.push(s6); + s6 = peg$parsesp(); + } + s6 = peg$currPos; + peg$silentFails++; + s7 = peg$parsenl(); + peg$silentFails--; + if (s7 === peg$FAILED) { + s6 = void 0; + } else { + peg$currPos = s6; + s6 = peg$FAILED; + } + if (s6 !== peg$FAILED) { + s2 = [s2, s3, s4, s5, s6]; + s1 = s2; + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + if (s1 === peg$FAILED) { + s1 = []; + s2 = peg$parsesp(); + if (s2 !== peg$FAILED) { + while (s2 !== peg$FAILED) { + s1.push(s2); + s2 = peg$parsesp(); + } + } else { + s1 = peg$FAILED; + } + } + } + if (s1 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$f11(); + } + s0 = s1; + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e8); + } + } + return s0; + } + function peg$parsenumber() { + var s0, s1, s2, s3, s4, s5; + peg$silentFails++; + s0 = peg$currPos; + s1 = peg$currPos; + s2 = []; + s3 = peg$parsenum(); + if (s3 !== peg$FAILED) { + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$parsenum(); + } + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + if (input.charCodeAt(peg$currPos) === 46) { + s3 = peg$c1; + peg$currPos++; + } else { + s3 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e10); + } + } + if (s3 !== peg$FAILED) { + s4 = []; + s5 = peg$parsenum(); + if (s5 !== peg$FAILED) { + while (s5 !== peg$FAILED) { + s4.push(s5); + s5 = peg$parsenum(); + } + } else { + s4 = peg$FAILED; + } + if (s4 !== peg$FAILED) { + peg$savedPos = s1; + s1 = peg$f12(s2, s4); + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + if (s1 === peg$FAILED) { + s1 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 46) { + s2 = peg$c1; + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e10); + } + } + if (s2 !== peg$FAILED) { + s3 = []; + s4 = peg$parsenum(); + if (s4 !== peg$FAILED) { + while (s4 !== peg$FAILED) { + s3.push(s4); + s4 = peg$parsenum(); + } + } else { + s3 = peg$FAILED; + } + if (s3 !== peg$FAILED) { + peg$savedPos = s1; + s1 = peg$f13(s3); + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + if (s1 === peg$FAILED) { + s1 = peg$currPos; + s2 = []; + s3 = peg$parsenum(); + if (s3 !== peg$FAILED) { + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$parsenum(); + } + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + if (input.charCodeAt(peg$currPos) === 46) { + s3 = peg$c1; + peg$currPos++; + } else { + s3 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e10); + } + } + if (s3 !== peg$FAILED) { + peg$savedPos = s1; + s1 = peg$f14(s2); + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + } + } + if (s1 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$f15(s1); + } + s0 = s1; + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e9); + } + } + return s0; + } + function peg$parsespecial_macro() { + var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9; + peg$silentFails++; + s0 = peg$currPos; + s1 = peg$parseescape(); + if (s1 !== peg$FAILED) { + if (input.substr(peg$currPos, 5) === peg$c2) { + s2 = peg$c2; + peg$currPos += 5; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e12); + } + } + if (s2 === peg$FAILED) { + if (input.substr(peg$currPos, 4) === peg$c3) { + s2 = peg$c3; + peg$currPos += 4; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e13); + } + } + } + if (s2 !== peg$FAILED) { + if (input.length > peg$currPos) { + s3 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s3 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s3 !== peg$FAILED) { + s4 = []; + s5 = peg$currPos; + s6 = peg$currPos; + peg$silentFails++; + s7 = peg$currPos; + if (input.length > peg$currPos) { + s8 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s8 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s8 !== peg$FAILED) { + peg$savedPos = peg$currPos; + s9 = peg$f16(s2, s3, s8); + if (s9) { + s9 = void 0; + } else { + s9 = peg$FAILED; + } + if (s9 !== peg$FAILED) { + s8 = [s8, s9]; + s7 = s8; + } else { + peg$currPos = s7; + s7 = peg$FAILED; + } + } else { + peg$currPos = s7; + s7 = peg$FAILED; + } + peg$silentFails--; + if (s7 === peg$FAILED) { + s6 = void 0; + } else { + peg$currPos = s6; + s6 = peg$FAILED; + } + if (s6 !== peg$FAILED) { + if (input.length > peg$currPos) { + s7 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s7 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s7 !== peg$FAILED) { + peg$savedPos = s5; + s5 = peg$f17(s2, s3, s7); + } else { + peg$currPos = s5; + s5 = peg$FAILED; + } + } else { + peg$currPos = s5; + s5 = peg$FAILED; + } + while (s5 !== peg$FAILED) { + s4.push(s5); + s5 = peg$currPos; + s6 = peg$currPos; + peg$silentFails++; + s7 = peg$currPos; + if (input.length > peg$currPos) { + s8 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s8 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s8 !== peg$FAILED) { + peg$savedPos = peg$currPos; + s9 = peg$f16(s2, s3, s8); + if (s9) { + s9 = void 0; + } else { + s9 = peg$FAILED; + } + if (s9 !== peg$FAILED) { + s8 = [s8, s9]; + s7 = s8; + } else { + peg$currPos = s7; + s7 = peg$FAILED; + } + } else { + peg$currPos = s7; + s7 = peg$FAILED; + } + peg$silentFails--; + if (s7 === peg$FAILED) { + s6 = void 0; + } else { + peg$currPos = s6; + s6 = peg$FAILED; + } + if (s6 !== peg$FAILED) { + if (input.length > peg$currPos) { + s7 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s7 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s7 !== peg$FAILED) { + peg$savedPos = s5; + s5 = peg$f17(s2, s3, s7); + } else { + peg$currPos = s5; + s5 = peg$FAILED; + } + } else { + peg$currPos = s5; + s5 = peg$FAILED; + } + } + s5 = peg$currPos; + if (input.length > peg$currPos) { + s6 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s6 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s6 !== peg$FAILED) { + peg$savedPos = peg$currPos; + s7 = peg$f18(s2, s3, s4, s6); + if (s7) { + s7 = void 0; + } else { + s7 = peg$FAILED; + } + if (s7 !== peg$FAILED) { + s6 = [s6, s7]; + s5 = s6; + } else { + peg$currPos = s5; + s5 = peg$FAILED; + } + } else { + peg$currPos = s5; + s5 = peg$FAILED; + } + if (s5 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f19(s2, s3, s4); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$parseverbatim_listings(); + if (s0 === peg$FAILED) { + s0 = peg$parseverbatim_minted(); + if (s0 === peg$FAILED) { + s0 = peg$parseverbatim_environment(); + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$parsebegin_display_math(); + if (s1 !== peg$FAILED) { + s2 = []; + s3 = peg$currPos; + s4 = peg$currPos; + peg$silentFails++; + s5 = peg$parseend_display_math(); + peg$silentFails--; + if (s5 === peg$FAILED) { + s4 = void 0; + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + if (s4 !== peg$FAILED) { + s5 = peg$parsemath_token(); + if (s5 !== peg$FAILED) { + peg$savedPos = s3; + s3 = peg$f20(s5); + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$currPos; + s4 = peg$currPos; + peg$silentFails++; + s5 = peg$parseend_display_math(); + peg$silentFails--; + if (s5 === peg$FAILED) { + s4 = void 0; + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + if (s4 !== peg$FAILED) { + s5 = peg$parsemath_token(); + if (s5 !== peg$FAILED) { + peg$savedPos = s3; + s3 = peg$f20(s5); + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } + s3 = peg$parseend_display_math(); + if (s3 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f21(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$parsebegin_inline_math(); + if (s1 !== peg$FAILED) { + s2 = []; + s3 = peg$currPos; + s4 = peg$currPos; + peg$silentFails++; + s5 = peg$parseend_inline_math(); + peg$silentFails--; + if (s5 === peg$FAILED) { + s4 = void 0; + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + if (s4 !== peg$FAILED) { + s5 = peg$parsemath_token(); + if (s5 !== peg$FAILED) { + peg$savedPos = s3; + s3 = peg$f22(s5); + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$currPos; + s4 = peg$currPos; + peg$silentFails++; + s5 = peg$parseend_inline_math(); + peg$silentFails--; + if (s5 === peg$FAILED) { + s4 = void 0; + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + if (s4 !== peg$FAILED) { + s5 = peg$parsemath_token(); + if (s5 !== peg$FAILED) { + peg$savedPos = s3; + s3 = peg$f22(s5); + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } + s3 = peg$parseend_inline_math(); + if (s3 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f23(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$parsemath_shift(); + if (s1 !== peg$FAILED) { + s2 = peg$parsemath_shift(); + if (s2 !== peg$FAILED) { + s3 = []; + s4 = peg$currPos; + s5 = peg$currPos; + peg$silentFails++; + s6 = peg$currPos; + s7 = peg$parsemath_shift(); + if (s7 !== peg$FAILED) { + s8 = peg$parsemath_shift(); + if (s8 !== peg$FAILED) { + s7 = [s7, s8]; + s6 = s7; + } else { + peg$currPos = s6; + s6 = peg$FAILED; + } + } else { + peg$currPos = s6; + s6 = peg$FAILED; + } + peg$silentFails--; + if (s6 === peg$FAILED) { + s5 = void 0; + } else { + peg$currPos = s5; + s5 = peg$FAILED; + } + if (s5 !== peg$FAILED) { + s6 = peg$parsemath_token(); + if (s6 !== peg$FAILED) { + peg$savedPos = s4; + s4 = peg$f24(s6); + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + while (s4 !== peg$FAILED) { + s3.push(s4); + s4 = peg$currPos; + s5 = peg$currPos; + peg$silentFails++; + s6 = peg$currPos; + s7 = peg$parsemath_shift(); + if (s7 !== peg$FAILED) { + s8 = peg$parsemath_shift(); + if (s8 !== peg$FAILED) { + s7 = [s7, s8]; + s6 = s7; + } else { + peg$currPos = s6; + s6 = peg$FAILED; + } + } else { + peg$currPos = s6; + s6 = peg$FAILED; + } + peg$silentFails--; + if (s6 === peg$FAILED) { + s5 = void 0; + } else { + peg$currPos = s5; + s5 = peg$FAILED; + } + if (s5 !== peg$FAILED) { + s6 = peg$parsemath_token(); + if (s6 !== peg$FAILED) { + peg$savedPos = s4; + s4 = peg$f24(s6); + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + } + s4 = peg$parsemath_shift(); + if (s4 !== peg$FAILED) { + s5 = peg$parsemath_shift(); + if (s5 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f25(s3); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$parsemath_environment(); + if (s0 === peg$FAILED) { + s0 = peg$parseenvironment(); + } + } + } + } + } + } + } + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e11); + } + } + return s0; + } + function peg$parsesquare_bracket_argument() { + var s0, s1, s2, s3, s4, s5, s6, s7; + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 91) { + s1 = peg$c4; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e14); + } + } + if (s1 !== peg$FAILED) { + s2 = []; + s3 = peg$currPos; + s4 = peg$currPos; + peg$silentFails++; + s5 = peg$currPos; + s6 = peg$parsetoken(); + if (s6 !== peg$FAILED) { + peg$savedPos = peg$currPos; + s7 = peg$f26(s6); + if (s7) { + s7 = void 0; + } else { + s7 = peg$FAILED; + } + if (s7 !== peg$FAILED) { + s6 = [s6, s7]; + s5 = s6; + } else { + peg$currPos = s5; + s5 = peg$FAILED; + } + } else { + peg$currPos = s5; + s5 = peg$FAILED; + } + peg$silentFails--; + if (s5 === peg$FAILED) { + s4 = void 0; + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + if (s4 !== peg$FAILED) { + s5 = peg$parsetoken(); + if (s5 !== peg$FAILED) { + peg$savedPos = s3; + s3 = peg$f27(s5); + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$currPos; + s4 = peg$currPos; + peg$silentFails++; + s5 = peg$currPos; + s6 = peg$parsetoken(); + if (s6 !== peg$FAILED) { + peg$savedPos = peg$currPos; + s7 = peg$f26(s6); + if (s7) { + s7 = void 0; + } else { + s7 = peg$FAILED; + } + if (s7 !== peg$FAILED) { + s6 = [s6, s7]; + s5 = s6; + } else { + peg$currPos = s5; + s5 = peg$FAILED; + } + } else { + peg$currPos = s5; + s5 = peg$FAILED; + } + peg$silentFails--; + if (s5 === peg$FAILED) { + s4 = void 0; + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + if (s4 !== peg$FAILED) { + s5 = peg$parsetoken(); + if (s5 !== peg$FAILED) { + peg$savedPos = s3; + s3 = peg$f27(s5); + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } + if (input.charCodeAt(peg$currPos) === 93) { + s3 = peg$c5; + peg$currPos++; + } else { + s3 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e15); + } + } + if (s3 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f28(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parseverbatim_group() { + var s0, s1, s2, s3, s4, s5; + s0 = peg$currPos; + s1 = peg$parsebegin_group(); + if (s1 !== peg$FAILED) { + s2 = []; + s3 = peg$currPos; + s4 = peg$currPos; + peg$silentFails++; + s5 = peg$parseend_group(); + peg$silentFails--; + if (s5 === peg$FAILED) { + s4 = void 0; + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + if (s4 !== peg$FAILED) { + if (input.length > peg$currPos) { + s5 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s5 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s5 !== peg$FAILED) { + peg$savedPos = s3; + s3 = peg$f29(s5); + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$currPos; + s4 = peg$currPos; + peg$silentFails++; + s5 = peg$parseend_group(); + peg$silentFails--; + if (s5 === peg$FAILED) { + s4 = void 0; + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + if (s4 !== peg$FAILED) { + if (input.length > peg$currPos) { + s5 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s5 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s5 !== peg$FAILED) { + peg$savedPos = s3; + s3 = peg$f29(s5); + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } + s3 = peg$parseend_group(); + if (s3 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f30(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parseverbatim_delimited_by_char() { + var s0, s1, s2, s3, s4, s5, s6, s7; + s0 = peg$currPos; + if (peg$r0.test(input.charAt(peg$currPos))) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e16); + } + } + if (s1 !== peg$FAILED) { + s2 = []; + s3 = peg$currPos; + s4 = peg$currPos; + peg$silentFails++; + s5 = peg$currPos; + if (input.length > peg$currPos) { + s6 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s6 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s6 !== peg$FAILED) { + peg$savedPos = peg$currPos; + s7 = peg$f31(s1, s6); + if (s7) { + s7 = void 0; + } else { + s7 = peg$FAILED; + } + if (s7 !== peg$FAILED) { + s6 = [s6, s7]; + s5 = s6; + } else { + peg$currPos = s5; + s5 = peg$FAILED; + } + } else { + peg$currPos = s5; + s5 = peg$FAILED; + } + peg$silentFails--; + if (s5 === peg$FAILED) { + s4 = void 0; + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + if (s4 !== peg$FAILED) { + if (input.length > peg$currPos) { + s5 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s5 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s5 !== peg$FAILED) { + peg$savedPos = s3; + s3 = peg$f32(s1, s5); + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$currPos; + s4 = peg$currPos; + peg$silentFails++; + s5 = peg$currPos; + if (input.length > peg$currPos) { + s6 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s6 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s6 !== peg$FAILED) { + peg$savedPos = peg$currPos; + s7 = peg$f31(s1, s6); + if (s7) { + s7 = void 0; + } else { + s7 = peg$FAILED; + } + if (s7 !== peg$FAILED) { + s6 = [s6, s7]; + s5 = s6; + } else { + peg$currPos = s5; + s5 = peg$FAILED; + } + } else { + peg$currPos = s5; + s5 = peg$FAILED; + } + peg$silentFails--; + if (s5 === peg$FAILED) { + s4 = void 0; + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + if (s4 !== peg$FAILED) { + if (input.length > peg$currPos) { + s5 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s5 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s5 !== peg$FAILED) { + peg$savedPos = s3; + s3 = peg$f32(s1, s5); + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } + s3 = peg$currPos; + if (input.length > peg$currPos) { + s4 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s4 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s4 !== peg$FAILED) { + peg$savedPos = peg$currPos; + s5 = peg$f33(s1, s2, s4); + if (s5) { + s5 = void 0; + } else { + s5 = peg$FAILED; + } + if (s5 !== peg$FAILED) { + s4 = [s4, s5]; + s3 = s4; + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + if (s3 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f34(s1, s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parseverbatim_listings() { + var s0, s1, s2, s3, s4; + peg$silentFails++; + s0 = peg$currPos; + s1 = peg$parseescape(); + if (s1 !== peg$FAILED) { + if (input.substr(peg$currPos, 9) === peg$c6) { + s2 = peg$c6; + peg$currPos += 9; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e18); + } + } + if (s2 !== peg$FAILED) { + s3 = peg$parsesquare_bracket_argument(); + if (s3 === peg$FAILED) { + s3 = null; + } + s4 = peg$parseverbatim_group(); + if (s4 === peg$FAILED) { + s4 = peg$parseverbatim_delimited_by_char(); + } + if (s4 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f35(s2, s3, s4); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e17); + } + } + return s0; + } + function peg$parseverbatim_minted() { + var s0, s1, s2, s3, s4, s5; + peg$silentFails++; + s0 = peg$currPos; + s1 = peg$parseescape(); + if (s1 !== peg$FAILED) { + if (input.substr(peg$currPos, 10) === peg$c7) { + s2 = peg$c7; + peg$currPos += 10; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e20); + } + } + if (s2 === peg$FAILED) { + if (input.substr(peg$currPos, 4) === peg$c8) { + s2 = peg$c8; + peg$currPos += 4; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e21); + } + } + } + if (s2 !== peg$FAILED) { + s3 = peg$parsesquare_bracket_argument(); + if (s3 === peg$FAILED) { + s3 = null; + } + s4 = peg$parsegroup(); + if (s4 !== peg$FAILED) { + s5 = peg$parseverbatim_group(); + if (s5 === peg$FAILED) { + s5 = peg$parseverbatim_delimited_by_char(); + } + if (s5 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f36(s2, s3, s4, s5); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e19); + } + } + return s0; + } + function peg$parseverbatim_environment() { + var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11; + peg$silentFails++; + s0 = peg$currPos; + s1 = peg$parsebegin_env(); + if (s1 !== peg$FAILED) { + s2 = peg$parsebegin_group(); + if (s2 !== peg$FAILED) { + s3 = peg$parseverbatim_env_name(); + if (s3 !== peg$FAILED) { + s4 = peg$parseend_group(); + if (s4 !== peg$FAILED) { + s5 = []; + s6 = peg$currPos; + s7 = peg$currPos; + peg$silentFails++; + s8 = peg$currPos; + s9 = peg$parseend_env(); + if (s9 !== peg$FAILED) { + s10 = peg$parsegroup(); + if (s10 !== peg$FAILED) { + peg$savedPos = peg$currPos; + s11 = peg$f40(s3, s10); + if (s11) { + s11 = void 0; + } else { + s11 = peg$FAILED; + } + if (s11 !== peg$FAILED) { + s9 = [s9, s10, s11]; + s8 = s9; + } else { + peg$currPos = s8; + s8 = peg$FAILED; + } + } else { + peg$currPos = s8; + s8 = peg$FAILED; + } + } else { + peg$currPos = s8; + s8 = peg$FAILED; + } + peg$silentFails--; + if (s8 === peg$FAILED) { + s7 = void 0; + } else { + peg$currPos = s7; + s7 = peg$FAILED; + } + if (s7 !== peg$FAILED) { + if (input.length > peg$currPos) { + s8 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s8 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s8 !== peg$FAILED) { + peg$savedPos = s6; + s6 = peg$f41(s3, s8); + } else { + peg$currPos = s6; + s6 = peg$FAILED; + } + } else { + peg$currPos = s6; + s6 = peg$FAILED; + } + while (s6 !== peg$FAILED) { + s5.push(s6); + s6 = peg$currPos; + s7 = peg$currPos; + peg$silentFails++; + s8 = peg$currPos; + s9 = peg$parseend_env(); + if (s9 !== peg$FAILED) { + s10 = peg$parsegroup(); + if (s10 !== peg$FAILED) { + peg$savedPos = peg$currPos; + s11 = peg$f40(s3, s10); + if (s11) { + s11 = void 0; + } else { + s11 = peg$FAILED; + } + if (s11 !== peg$FAILED) { + s9 = [s9, s10, s11]; + s8 = s9; + } else { + peg$currPos = s8; + s8 = peg$FAILED; + } + } else { + peg$currPos = s8; + s8 = peg$FAILED; + } + } else { + peg$currPos = s8; + s8 = peg$FAILED; + } + peg$silentFails--; + if (s8 === peg$FAILED) { + s7 = void 0; + } else { + peg$currPos = s7; + s7 = peg$FAILED; + } + if (s7 !== peg$FAILED) { + if (input.length > peg$currPos) { + s8 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s8 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s8 !== peg$FAILED) { + peg$savedPos = s6; + s6 = peg$f41(s3, s8); + } else { + peg$currPos = s6; + s6 = peg$FAILED; + } + } else { + peg$currPos = s6; + s6 = peg$FAILED; + } + } + s6 = peg$parseend_env(); + if (s6 !== peg$FAILED) { + s7 = peg$parsebegin_group(); + if (s7 !== peg$FAILED) { + s8 = peg$parseverbatim_env_name(); + if (s8 !== peg$FAILED) { + s9 = peg$parseend_group(); + if (s9 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f42(s3, s5); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e24); + } + } + return s0; + } + function peg$parseverbatim_env_name() { + var s0; + if (input.substr(peg$currPos, 9) === peg$c10) { + s0 = peg$c10; + peg$currPos += 9; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e25); + } + } + if (s0 === peg$FAILED) { + if (input.substr(peg$currPos, 8) === peg$c11) { + s0 = peg$c11; + peg$currPos += 8; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e26); + } + } + if (s0 === peg$FAILED) { + if (input.substr(peg$currPos, 13) === peg$c12) { + s0 = peg$c12; + peg$currPos += 13; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e27); + } + } + if (s0 === peg$FAILED) { + if (input.substr(peg$currPos, 12) === peg$c13) { + s0 = peg$c13; + peg$currPos += 12; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e28); + } + } + if (s0 === peg$FAILED) { + if (input.substr(peg$currPos, 7) === peg$c14) { + s0 = peg$c14; + peg$currPos += 7; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e29); + } + } + if (s0 === peg$FAILED) { + if (input.substr(peg$currPos, 10) === peg$c15) { + s0 = peg$c15; + peg$currPos += 10; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e30); + } + } + } + } + } + } + } + return s0; + } + function peg$parsemacro() { + var s0, s1, s2, s3, s4; + peg$silentFails++; + s0 = peg$currPos; + s1 = peg$currPos; + s2 = peg$parseescape(); + if (s2 !== peg$FAILED) { + s3 = []; + s4 = peg$parsechar(); + if (s4 !== peg$FAILED) { + while (s4 !== peg$FAILED) { + s3.push(s4); + s4 = peg$parsechar(); + } + } else { + s3 = peg$FAILED; + } + if (s3 !== peg$FAILED) { + peg$savedPos = s1; + s1 = peg$f43(s3); + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + if (s1 === peg$FAILED) { + s1 = peg$currPos; + s2 = peg$parseescape(); + if (s2 !== peg$FAILED) { + if (input.length > peg$currPos) { + s3 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s3 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s3 !== peg$FAILED) { + peg$savedPos = s1; + s1 = peg$f44(s3); + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + } + if (s1 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$f45(s1); + } + s0 = s1; + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e31); + } + } + return s0; + } + function peg$parsegroup() { + var s0, s1, s2, s3, s4, s5; + peg$silentFails++; + s0 = peg$currPos; + s1 = peg$parsebegin_group(); + if (s1 !== peg$FAILED) { + s2 = []; + s3 = peg$currPos; + s4 = peg$currPos; + peg$silentFails++; + s5 = peg$parseend_group(); + peg$silentFails--; + if (s5 === peg$FAILED) { + s4 = void 0; + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + if (s4 !== peg$FAILED) { + s5 = peg$parsetoken(); + if (s5 !== peg$FAILED) { + peg$savedPos = s3; + s3 = peg$f46(s5); + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$currPos; + s4 = peg$currPos; + peg$silentFails++; + s5 = peg$parseend_group(); + peg$silentFails--; + if (s5 === peg$FAILED) { + s4 = void 0; + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + if (s4 !== peg$FAILED) { + s5 = peg$parsetoken(); + if (s5 !== peg$FAILED) { + peg$savedPos = s3; + s3 = peg$f46(s5); + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } + s3 = peg$parseend_group(); + if (s3 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f47(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e32); + } + } + return s0; + } + function peg$parsegroup_contents_as_string() { + var s0, s1; + s0 = peg$currPos; + s1 = peg$parsegroup(); + if (s1 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$f48(); + } + s0 = s1; + return s0; + } + function peg$parseenvironment() { + var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10; + peg$silentFails++; + s0 = peg$currPos; + s1 = peg$parsebegin_env(); + if (s1 !== peg$FAILED) { + s2 = peg$parsegroup_contents_as_string(); + if (s2 !== peg$FAILED) { + s3 = peg$parsesameline_comment(); + if (s3 === peg$FAILED) { + s3 = null; + } + s4 = []; + s5 = peg$currPos; + s6 = peg$currPos; + peg$silentFails++; + s7 = peg$currPos; + s8 = peg$parseend_env(); + if (s8 !== peg$FAILED) { + s9 = peg$parsegroup_contents_as_string(); + if (s9 !== peg$FAILED) { + peg$savedPos = peg$currPos; + s10 = peg$f49(s2, s3, s9); + if (s10) { + s10 = void 0; + } else { + s10 = peg$FAILED; + } + if (s10 !== peg$FAILED) { + s8 = [s8, s9, s10]; + s7 = s8; + } else { + peg$currPos = s7; + s7 = peg$FAILED; + } + } else { + peg$currPos = s7; + s7 = peg$FAILED; + } + } else { + peg$currPos = s7; + s7 = peg$FAILED; + } + peg$silentFails--; + if (s7 === peg$FAILED) { + s6 = void 0; + } else { + peg$currPos = s6; + s6 = peg$FAILED; + } + if (s6 !== peg$FAILED) { + s7 = peg$parsetoken(); + if (s7 !== peg$FAILED) { + peg$savedPos = s5; + s5 = peg$f50(s2, s3, s7); + } else { + peg$currPos = s5; + s5 = peg$FAILED; + } + } else { + peg$currPos = s5; + s5 = peg$FAILED; + } + while (s5 !== peg$FAILED) { + s4.push(s5); + s5 = peg$currPos; + s6 = peg$currPos; + peg$silentFails++; + s7 = peg$currPos; + s8 = peg$parseend_env(); + if (s8 !== peg$FAILED) { + s9 = peg$parsegroup_contents_as_string(); + if (s9 !== peg$FAILED) { + peg$savedPos = peg$currPos; + s10 = peg$f49(s2, s3, s9); + if (s10) { + s10 = void 0; + } else { + s10 = peg$FAILED; + } + if (s10 !== peg$FAILED) { + s8 = [s8, s9, s10]; + s7 = s8; + } else { + peg$currPos = s7; + s7 = peg$FAILED; + } + } else { + peg$currPos = s7; + s7 = peg$FAILED; + } + } else { + peg$currPos = s7; + s7 = peg$FAILED; + } + peg$silentFails--; + if (s7 === peg$FAILED) { + s6 = void 0; + } else { + peg$currPos = s6; + s6 = peg$FAILED; + } + if (s6 !== peg$FAILED) { + s7 = peg$parsetoken(); + if (s7 !== peg$FAILED) { + peg$savedPos = s5; + s5 = peg$f50(s2, s3, s7); + } else { + peg$currPos = s5; + s5 = peg$FAILED; + } + } else { + peg$currPos = s5; + s5 = peg$FAILED; + } + } + s5 = peg$parseend_env(); + if (s5 !== peg$FAILED) { + s6 = peg$parsegroup_contents_as_string(); + if (s6 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f51(s2, s3, s4); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e33); + } + } + return s0; + } + function peg$parsemath_environment() { + var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12; + peg$silentFails++; + s0 = peg$currPos; + s1 = peg$parsebegin_env(); + if (s1 !== peg$FAILED) { + s2 = peg$parsebegin_group(); + if (s2 !== peg$FAILED) { + s3 = peg$parsemath_env_name(); + if (s3 !== peg$FAILED) { + s4 = peg$parseend_group(); + if (s4 !== peg$FAILED) { + s5 = peg$parsesameline_comment(); + if (s5 === peg$FAILED) { + s5 = null; + } + s6 = []; + s7 = peg$currPos; + s8 = peg$currPos; + peg$silentFails++; + s9 = peg$currPos; + s10 = peg$parseend_env(); + if (s10 !== peg$FAILED) { + s11 = peg$parsegroup(); + if (s11 !== peg$FAILED) { + peg$savedPos = peg$currPos; + s12 = peg$f52(s3, s5, s11); + if (s12) { + s12 = void 0; + } else { + s12 = peg$FAILED; + } + if (s12 !== peg$FAILED) { + s10 = [s10, s11, s12]; + s9 = s10; + } else { + peg$currPos = s9; + s9 = peg$FAILED; + } + } else { + peg$currPos = s9; + s9 = peg$FAILED; + } + } else { + peg$currPos = s9; + s9 = peg$FAILED; + } + peg$silentFails--; + if (s9 === peg$FAILED) { + s8 = void 0; + } else { + peg$currPos = s8; + s8 = peg$FAILED; + } + if (s8 !== peg$FAILED) { + s9 = peg$parsemath_token(); + if (s9 !== peg$FAILED) { + peg$savedPos = s7; + s7 = peg$f53(s3, s5, s9); + } else { + peg$currPos = s7; + s7 = peg$FAILED; + } + } else { + peg$currPos = s7; + s7 = peg$FAILED; + } + while (s7 !== peg$FAILED) { + s6.push(s7); + s7 = peg$currPos; + s8 = peg$currPos; + peg$silentFails++; + s9 = peg$currPos; + s10 = peg$parseend_env(); + if (s10 !== peg$FAILED) { + s11 = peg$parsegroup(); + if (s11 !== peg$FAILED) { + peg$savedPos = peg$currPos; + s12 = peg$f52(s3, s5, s11); + if (s12) { + s12 = void 0; + } else { + s12 = peg$FAILED; + } + if (s12 !== peg$FAILED) { + s10 = [s10, s11, s12]; + s9 = s10; + } else { + peg$currPos = s9; + s9 = peg$FAILED; + } + } else { + peg$currPos = s9; + s9 = peg$FAILED; + } + } else { + peg$currPos = s9; + s9 = peg$FAILED; + } + peg$silentFails--; + if (s9 === peg$FAILED) { + s8 = void 0; + } else { + peg$currPos = s8; + s8 = peg$FAILED; + } + if (s8 !== peg$FAILED) { + s9 = peg$parsemath_token(); + if (s9 !== peg$FAILED) { + peg$savedPos = s7; + s7 = peg$f53(s3, s5, s9); + } else { + peg$currPos = s7; + s7 = peg$FAILED; + } + } else { + peg$currPos = s7; + s7 = peg$FAILED; + } + } + s7 = peg$parseend_env(); + if (s7 !== peg$FAILED) { + s8 = peg$parsebegin_group(); + if (s8 !== peg$FAILED) { + s9 = peg$parsemath_env_name(); + if (s9 !== peg$FAILED) { + s10 = peg$parseend_group(); + if (s10 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f54(s3, s5, s6); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e34); + } + } + return s0; + } + function peg$parsebegin_display_math() { + var s0, s1, s2; + s0 = peg$currPos; + s1 = peg$parseescape(); + if (s1 !== peg$FAILED) { + if (input.charCodeAt(peg$currPos) === 91) { + s2 = peg$c4; + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e14); + } + } + if (s2 !== peg$FAILED) { + s1 = [s1, s2]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parseend_display_math() { + var s0, s1, s2; + s0 = peg$currPos; + s1 = peg$parseescape(); + if (s1 !== peg$FAILED) { + if (input.charCodeAt(peg$currPos) === 93) { + s2 = peg$c5; + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e15); + } + } + if (s2 !== peg$FAILED) { + s1 = [s1, s2]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsebegin_inline_math() { + var s0, s1, s2; + s0 = peg$currPos; + s1 = peg$parseescape(); + if (s1 !== peg$FAILED) { + if (input.charCodeAt(peg$currPos) === 40) { + s2 = peg$c16; + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e36); + } + } + if (s2 !== peg$FAILED) { + s1 = [s1, s2]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parseend_inline_math() { + var s0, s1, s2; + s0 = peg$currPos; + s1 = peg$parseescape(); + if (s1 !== peg$FAILED) { + if (input.charCodeAt(peg$currPos) === 41) { + s2 = peg$c17; + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e37); + } + } + if (s2 !== peg$FAILED) { + s1 = [s1, s2]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsebegin_env() { + var s0, s1, s2; + s0 = peg$currPos; + s1 = peg$parseescape(); + if (s1 !== peg$FAILED) { + if (input.substr(peg$currPos, 5) === peg$c18) { + s2 = peg$c18; + peg$currPos += 5; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e38); + } + } + if (s2 !== peg$FAILED) { + s1 = [s1, s2]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parseend_env() { + var s0, s1, s2; + s0 = peg$currPos; + s1 = peg$parseescape(); + if (s1 !== peg$FAILED) { + if (input.substr(peg$currPos, 3) === peg$c19) { + s2 = peg$c19; + peg$currPos += 3; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e39); + } + } + if (s2 !== peg$FAILED) { + s1 = [s1, s2]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsemath_env_name() { + var s0, s1; + s0 = peg$currPos; + if (input.substr(peg$currPos, 9) === peg$c20) { + s1 = peg$c20; + peg$currPos += 9; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e40); + } + } + if (s1 === peg$FAILED) { + if (input.substr(peg$currPos, 8) === peg$c21) { + s1 = peg$c21; + peg$currPos += 8; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e41); + } + } + if (s1 === peg$FAILED) { + if (input.substr(peg$currPos, 6) === peg$c22) { + s1 = peg$c22; + peg$currPos += 6; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e42); + } + } + if (s1 === peg$FAILED) { + if (input.substr(peg$currPos, 5) === peg$c23) { + s1 = peg$c23; + peg$currPos += 5; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e43); + } + } + if (s1 === peg$FAILED) { + if (input.substr(peg$currPos, 8) === peg$c24) { + s1 = peg$c24; + peg$currPos += 8; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e44); + } + } + if (s1 === peg$FAILED) { + if (input.substr(peg$currPos, 7) === peg$c25) { + s1 = peg$c25; + peg$currPos += 7; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e45); + } + } + if (s1 === peg$FAILED) { + if (input.substr(peg$currPos, 7) === peg$c26) { + s1 = peg$c26; + peg$currPos += 7; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e46); + } + } + if (s1 === peg$FAILED) { + if (input.substr(peg$currPos, 6) === peg$c27) { + s1 = peg$c27; + peg$currPos += 6; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e47); + } + } + if (s1 === peg$FAILED) { + if (input.substr(peg$currPos, 9) === peg$c28) { + s1 = peg$c28; + peg$currPos += 9; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e48); + } + } + if (s1 === peg$FAILED) { + if (input.substr(peg$currPos, 8) === peg$c29) { + s1 = peg$c29; + peg$currPos += 8; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e49); + } + } + if (s1 === peg$FAILED) { + if (input.substr(peg$currPos, 8) === peg$c30) { + s1 = peg$c30; + peg$currPos += 8; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e50); + } + } + if (s1 === peg$FAILED) { + if (input.substr(peg$currPos, 7) === peg$c31) { + s1 = peg$c31; + peg$currPos += 7; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e51); + } + } + if (s1 === peg$FAILED) { + if (input.substr(peg$currPos, 5) === peg$c32) { + s1 = peg$c32; + peg$currPos += 5; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e52); + } + } + if (s1 === peg$FAILED) { + if (input.substr(peg$currPos, 4) === peg$c33) { + s1 = peg$c33; + peg$currPos += 4; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e53); + } + } + if (s1 === peg$FAILED) { + if (input.substr(peg$currPos, 11) === peg$c34) { + s1 = peg$c34; + peg$currPos += 11; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e54); + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + if (s1 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$f57(s1); + } + s0 = s1; + return s0; + } + function peg$parseescape() { + var s0, s1; + peg$silentFails++; + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 92) { + s1 = peg$c35; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e56); + } + } + if (s1 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$f58(); + } + s0 = s1; + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e55); + } + } + return s0; + } + function peg$parsebegin_group() { + var s0, s1; + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 123) { + s1 = peg$c36; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e57); + } + } + if (s1 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$f59(s1); + } + s0 = s1; + return s0; + } + function peg$parseend_group() { + var s0, s1; + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 125) { + s1 = peg$c37; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e58); + } + } + if (s1 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$f60(s1); + } + s0 = s1; + return s0; + } + function peg$parsemath_shift() { + var s0, s1; + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 36) { + s1 = peg$c38; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e59); + } + } + if (s1 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$f61(s1); + } + s0 = s1; + return s0; + } + function peg$parsealignment_tab() { + var s0, s1; + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 38) { + s1 = peg$c39; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e60); + } + } + if (s1 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$f62(s1); + } + s0 = s1; + return s0; + } + function peg$parsenl() { + var s0, s1, s2; + peg$silentFails++; + s0 = peg$currPos; + s1 = peg$currPos; + peg$silentFails++; + if (input.charCodeAt(peg$currPos) === 13) { + s2 = peg$c40; + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e62); + } + } + peg$silentFails--; + if (s2 === peg$FAILED) { + s1 = void 0; + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + if (s1 !== peg$FAILED) { + if (input.charCodeAt(peg$currPos) === 10) { + s2 = peg$c41; + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e63); + } + } + if (s2 !== peg$FAILED) { + s1 = [s1, s2]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + if (input.charCodeAt(peg$currPos) === 13) { + s0 = peg$c40; + peg$currPos++; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e62); + } + } + if (s0 === peg$FAILED) { + if (input.substr(peg$currPos, 2) === peg$c42) { + s0 = peg$c42; + peg$currPos += 2; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e64); + } + } + } + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e61); + } + } + return s0; + } + function peg$parsemacro_parameter() { + var s0, s1; + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 35) { + s1 = peg$c43; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e65); + } + } + if (s1 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$f63(s1); + } + s0 = s1; + return s0; + } + function peg$parsesuperscript() { + var s0, s1; + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 94) { + s1 = peg$c44; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e66); + } + } + if (s1 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$f64(s1); + } + s0 = s1; + return s0; + } + function peg$parsesubscript() { + var s0, s1; + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 95) { + s1 = peg$c45; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e67); + } + } + if (s1 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$f65(s1); + } + s0 = s1; + return s0; + } + function peg$parseignore() { + var s0; + if (input.charCodeAt(peg$currPos) === 0) { + s0 = peg$c46; + peg$currPos++; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e68); + } + } + return s0; + } + function peg$parsesp() { + var s0, s1, s2; + peg$silentFails++; + s0 = peg$currPos; + s1 = []; + if (peg$r1.test(input.charAt(peg$currPos))) { + s2 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e69); + } + } + if (s2 !== peg$FAILED) { + while (s2 !== peg$FAILED) { + s1.push(s2); + if (peg$r1.test(input.charAt(peg$currPos))) { + s2 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e69); + } + } + } + } else { + s1 = peg$FAILED; + } + if (s1 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$f66(); + } + s0 = s1; + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e8); + } + } + return s0; + } + function peg$parsechar() { + var s0; + peg$silentFails++; + if (peg$r2.test(input.charAt(peg$currPos))) { + s0 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e71); + } + } + peg$silentFails--; + if (s0 === peg$FAILED) { + if (peg$silentFails === 0) { + peg$fail(peg$e70); + } + } + return s0; + } + function peg$parsenum() { + var s0; + peg$silentFails++; + if (peg$r3.test(input.charAt(peg$currPos))) { + s0 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e73); + } + } + peg$silentFails--; + if (s0 === peg$FAILED) { + if (peg$silentFails === 0) { + peg$fail(peg$e72); + } + } + return s0; + } + function peg$parsepunctuation() { + var s0, s1; + peg$silentFails++; + s0 = peg$currPos; + if (peg$r4.test(input.charAt(peg$currPos))) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e75); + } + } + if (s1 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$f67(s1); + } + s0 = s1; + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e74); + } + } + return s0; + } + function peg$parsecomment_start() { + var s0; + if (input.charCodeAt(peg$currPos) === 37) { + s0 = peg$c0; + peg$currPos++; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e7); + } + } + return s0; + } + function peg$parsefull_comment() { + var s0; + peg$silentFails++; + s0 = peg$parseownline_comment(); + if (s0 === peg$FAILED) { + s0 = peg$parsesameline_comment(); + } + peg$silentFails--; + if (s0 === peg$FAILED) { + if (peg$silentFails === 0) { + peg$fail(peg$e76); + } + } + return s0; + } + function peg$parseownline_comment() { + var s0, s1, s2, s3; + s0 = peg$currPos; + s1 = peg$currPos; + s2 = []; + s3 = peg$parsesp(); + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$parsesp(); + } + s3 = peg$parsenl(); + if (s3 !== peg$FAILED) { + s2 = [s2, s3]; + s1 = s2; + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + if (s1 === peg$FAILED) { + s1 = null; + } + s2 = peg$parseleading_sp(); + if (s2 !== peg$FAILED) { + s3 = peg$parsecomment(); + if (s3 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f68(s2, s3); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsesameline_comment() { + var s0, s1, s2; + s0 = peg$currPos; + s1 = []; + s2 = peg$parsesp(); + while (s2 !== peg$FAILED) { + s1.push(s2); + s2 = peg$parsesp(); + } + s2 = peg$parsecomment(); + if (s2 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f69(s1, s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsecomment() { + var s0, s1, s2, s3, s4, s5, s6, s7; + peg$silentFails++; + s0 = peg$currPos; + s1 = peg$parsecomment_start(); + if (s1 !== peg$FAILED) { + s2 = []; + s3 = peg$currPos; + s4 = peg$currPos; + peg$silentFails++; + s5 = peg$parsenl(); + peg$silentFails--; + if (s5 === peg$FAILED) { + s4 = void 0; + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + if (s4 !== peg$FAILED) { + if (input.length > peg$currPos) { + s5 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s5 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s5 !== peg$FAILED) { + peg$savedPos = s3; + s3 = peg$f70(s5); + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$currPos; + s4 = peg$currPos; + peg$silentFails++; + s5 = peg$parsenl(); + peg$silentFails--; + if (s5 === peg$FAILED) { + s4 = void 0; + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + if (s4 !== peg$FAILED) { + if (input.length > peg$currPos) { + s5 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s5 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s5 !== peg$FAILED) { + peg$savedPos = s3; + s3 = peg$f70(s5); + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } + s3 = peg$currPos; + peg$silentFails++; + s4 = peg$parseparbreak(); + peg$silentFails--; + if (s4 !== peg$FAILED) { + peg$currPos = s3; + s3 = void 0; + } else { + s3 = peg$FAILED; + } + if (s3 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f71(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$parsecomment_start(); + if (s1 !== peg$FAILED) { + s2 = []; + s3 = peg$currPos; + s4 = peg$currPos; + peg$silentFails++; + s5 = peg$parsenl(); + peg$silentFails--; + if (s5 === peg$FAILED) { + s4 = void 0; + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + if (s4 !== peg$FAILED) { + if (input.length > peg$currPos) { + s5 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s5 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s5 !== peg$FAILED) { + peg$savedPos = s3; + s3 = peg$f72(s5); + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$currPos; + s4 = peg$currPos; + peg$silentFails++; + s5 = peg$parsenl(); + peg$silentFails--; + if (s5 === peg$FAILED) { + s4 = void 0; + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + if (s4 !== peg$FAILED) { + if (input.length > peg$currPos) { + s5 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s5 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s5 !== peg$FAILED) { + peg$savedPos = s3; + s3 = peg$f72(s5); + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } + s3 = peg$currPos; + s4 = peg$parsenl(); + if (s4 !== peg$FAILED) { + s5 = []; + s6 = peg$parsesp(); + while (s6 !== peg$FAILED) { + s5.push(s6); + s6 = peg$parsesp(); + } + s6 = peg$currPos; + peg$silentFails++; + s7 = peg$parsecomment_start(); + peg$silentFails--; + if (s7 === peg$FAILED) { + s6 = void 0; + } else { + peg$currPos = s6; + s6 = peg$FAILED; + } + if (s6 !== peg$FAILED) { + s4 = [s4, s5, s6]; + s3 = s4; + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + if (s3 === peg$FAILED) { + s3 = peg$parsenl(); + if (s3 === peg$FAILED) { + s3 = peg$parseEOF(); + } + } + if (s3 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f73(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e77); + } + } + return s0; + } + function peg$parseleading_sp() { + var s0, s1, s2, s3, s4; + s0 = peg$currPos; + s1 = peg$currPos; + s2 = peg$parsestart_of_line(); + if (s2 !== peg$FAILED) { + s3 = []; + s4 = peg$parsesp(); + while (s4 !== peg$FAILED) { + s3.push(s4); + s4 = peg$parsesp(); + } + s2 = [s2, s3]; + s1 = s2; + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + if (s1 !== peg$FAILED) { + s0 = input.substring(s0, peg$currPos); + } else { + s0 = s1; + } + return s0; + } + function peg$parsestart_of_line() { + var s0; + peg$savedPos = peg$currPos; + s0 = peg$f74(); + if (s0) { + s0 = void 0; + } else { + s0 = peg$FAILED; + } + return s0; + } + function peg$parseEOF() { + var s0, s1; + s0 = peg$currPos; + peg$silentFails++; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + peg$silentFails--; + if (s1 === peg$FAILED) { + s0 = void 0; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function toString(e) { + if (typeof e === "string") { + return e; + } + if (typeof e.content === "string") { + return e.content; + } + if (e && e.type === "whitespace") { + return " "; + } + return e; + } + function compare_env(g1, g2) { + const g1Name = typeof g1 === "string" ? g1 : g1.content.map(toString).join(""); + const g2Name = typeof g2 === "string" ? g2 : g2.content.map(toString).join(""); + return g1Name === g2Name; + } + function createNode(type, extra = {}) { + return { type, ...extra, position: location() }; + } + peg$result = peg$startRuleFunction(); + if (peg$result !== peg$FAILED && peg$currPos === input.length) { + return peg$result; + } else { + if (peg$result !== peg$FAILED && peg$currPos < input.length) { + peg$fail(peg$endExpectation()); + } + throw peg$buildStructuredError( + peg$maxFailExpected, + peg$maxFailPos < input.length ? input.charAt(peg$maxFailPos) : null, + peg$maxFailPos < input.length ? peg$computeLocation(peg$maxFailPos, peg$maxFailPos + 1) : peg$computeLocation(peg$maxFailPos, peg$maxFailPos) + ); + } + } + return { + SyntaxError: peg$SyntaxError, + parse: peg$parse + }; + }() +); +var align_environment_default = ( + // Generated by Peggy 2.0.1. + // + // https://peggyjs.org/ + function() { + function peg$subclass(child, parent) { + function C() { + this.constructor = child; + } + C.prototype = parent.prototype; + child.prototype = new C(); + } + function peg$SyntaxError(message, expected, found, location) { + var self = Error.call(this, message); + if (Object.setPrototypeOf) { + Object.setPrototypeOf(self, peg$SyntaxError.prototype); + } + self.expected = expected; + self.found = found; + self.location = location; + self.name = "SyntaxError"; + return self; + } + peg$subclass(peg$SyntaxError, Error); + function peg$padEnd(str, targetLength, padString) { + padString = padString || " "; + if (str.length > targetLength) { + return str; + } + targetLength -= str.length; + padString += padString.repeat(targetLength); + return str + padString.slice(0, targetLength); + } + peg$SyntaxError.prototype.format = function(sources) { + var str = "Error: " + this.message; + if (this.location) { + var src = null; + var k; + for (k = 0; k < sources.length; k++) { + if (sources[k].source === this.location.source) { + src = sources[k].text.split(/\r\n|\n|\r/g); + break; + } + } + var s2 = this.location.start; + var loc = this.location.source + ":" + s2.line + ":" + s2.column; + if (src) { + var e = this.location.end; + var filler = peg$padEnd("", s2.line.toString().length, " "); + var line3 = src[s2.line - 1]; + var last = s2.line === e.line ? e.column : line3.length + 1; + var hatLen = last - s2.column || 1; + str += "\n --> " + loc + "\n" + filler + " |\n" + s2.line + " | " + line3 + "\n" + filler + " | " + peg$padEnd("", s2.column - 1, " ") + peg$padEnd("", hatLen, "^"); + } else { + str += "\n at " + loc; + } + } + return str; + }; + peg$SyntaxError.buildMessage = function(expected, found) { + var DESCRIBE_EXPECTATION_FNS = { + literal: function(expectation) { + return '"' + literalEscape(expectation.text) + '"'; + }, + class: function(expectation) { + var escapedParts = expectation.parts.map(function(part) { + return Array.isArray(part) ? classEscape(part[0]) + "-" + classEscape(part[1]) : classEscape(part); + }); + return "[" + (expectation.inverted ? "^" : "") + escapedParts.join("") + "]"; + }, + any: function() { + return "any character"; + }, + end: function() { + return "end of input"; + }, + other: function(expectation) { + return expectation.description; + } + }; + function hex(ch) { + return ch.charCodeAt(0).toString(16).toUpperCase(); + } + function literalEscape(s2) { + return s2.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\0/g, "\\0").replace(/\t/g, "\\t").replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/[\x00-\x0F]/g, function(ch) { + return "\\x0" + hex(ch); + }).replace(/[\x10-\x1F\x7F-\x9F]/g, function(ch) { + return "\\x" + hex(ch); + }); + } + function classEscape(s2) { + return s2.replace(/\\/g, "\\\\").replace(/\]/g, "\\]").replace(/\^/g, "\\^").replace(/-/g, "\\-").replace(/\0/g, "\\0").replace(/\t/g, "\\t").replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/[\x00-\x0F]/g, function(ch) { + return "\\x0" + hex(ch); + }).replace(/[\x10-\x1F\x7F-\x9F]/g, function(ch) { + return "\\x" + hex(ch); + }); + } + function describeExpectation(expectation) { + return DESCRIBE_EXPECTATION_FNS[expectation.type](expectation); + } + function describeExpected(expected2) { + var descriptions = expected2.map(describeExpectation); + var i, j; + descriptions.sort(); + if (descriptions.length > 0) { + for (i = 1, j = 1; i < descriptions.length; i++) { + if (descriptions[i - 1] !== descriptions[i]) { + descriptions[j] = descriptions[i]; + j++; + } + } + descriptions.length = j; + } + switch (descriptions.length) { + case 1: + return descriptions[0]; + case 2: + return descriptions[0] + " or " + descriptions[1]; + default: + return descriptions.slice(0, -1).join(", ") + ", or " + descriptions[descriptions.length - 1]; + } + } + function describeFound(found2) { + return found2 ? '"' + literalEscape(found2) + '"' : "end of input"; + } + return "Expected " + describeExpected(expected) + " but " + describeFound(found) + " found."; + }; + function peg$parse(input, options2) { + options2 = options2 !== void 0 ? options2 : {}; + var peg$FAILED = {}; + var peg$source = options2.grammarSource; + var peg$startRuleFunctions = { body: peg$parsebody }; + var peg$startRuleFunction = peg$parsebody; + var peg$e0 = peg$anyExpectation(); + var peg$f0 = function() { + return []; + }; + var peg$f1 = function(x) { + return { cells: [], colSeps: [], ...x }; + }; + var peg$f2 = function(rowItems, rowSep, trailingComment) { + return { ...rowItems, rowSep, trailingComment }; + }; + var peg$f3 = function(rowItems, trailingComment) { + return { ...rowItems, rowSep: null, trailingComment }; + }; + var peg$f4 = function(x) { + return x; + }; + var peg$f5 = function(x) { + return { + cells: [], + colSeps: [], + rowSep: null, + trailingComment: x + }; + }; + var peg$f6 = function(x) { + return x; + }; + var peg$f7 = function(colSep, cell) { + return { colSep, cell }; + }; + var peg$f8 = function(colSep) { + return { colSep }; + }; + var peg$f9 = function(a, b) { + return processRow(a, b); + }; + var peg$f10 = function(b) { + return processRow(null, b); + }; + var peg$f11 = function(tok) { + return options2.isSameLineComment(tok); + }; + var peg$f12 = function(tok) { + return tok; + }; + var peg$f13 = function(tok) { + return options2.isOwnLineComment(tok); + }; + var peg$f14 = function(tok) { + return tok; + }; + var peg$f15 = function(tok) { + return options2.isWhitespace(tok); + }; + var peg$f16 = function(tok) { + return tok; + }; + var peg$f17 = function(tok) { + return options2.isRowSep(tok); + }; + var peg$f18 = function(tok) { + return tok; + }; + var peg$f19 = function(tok) { + return options2.isColSep(tok); + }; + var peg$f20 = function(tok) { + return tok; + }; + var peg$currPos = 0; + var peg$posDetailsCache = [{ line: 1, column: 1 }]; + var peg$maxFailPos = 0; + var peg$maxFailExpected = []; + var peg$silentFails = 0; + var peg$result; + if ("startRule" in options2) { + if (!(options2.startRule in peg$startRuleFunctions)) { + throw new Error(`Can't start parsing from rule "` + options2.startRule + '".'); + } + peg$startRuleFunction = peg$startRuleFunctions[options2.startRule]; + } + function peg$anyExpectation() { + return { type: "any" }; + } + function peg$endExpectation() { + return { type: "end" }; + } + function peg$computePosDetails(pos) { + var details = peg$posDetailsCache[pos]; + var p; + if (details) { + return details; + } else { + p = pos - 1; + while (!peg$posDetailsCache[p]) { + p--; + } + details = peg$posDetailsCache[p]; + details = { + line: details.line, + column: details.column + }; + while (p < pos) { + if (input.charCodeAt(p) === 10) { + details.line++; + details.column = 1; + } else { + details.column++; + } + p++; + } + peg$posDetailsCache[pos] = details; + return details; + } + } + function peg$computeLocation(startPos, endPos) { + var startPosDetails = peg$computePosDetails(startPos); + var endPosDetails = peg$computePosDetails(endPos); + return { + source: peg$source, + start: { + offset: startPos, + line: startPosDetails.line, + column: startPosDetails.column + }, + end: { + offset: endPos, + line: endPosDetails.line, + column: endPosDetails.column + } + }; + } + function peg$fail(expected2) { + if (peg$currPos < peg$maxFailPos) { + return; + } + if (peg$currPos > peg$maxFailPos) { + peg$maxFailPos = peg$currPos; + peg$maxFailExpected = []; + } + peg$maxFailExpected.push(expected2); + } + function peg$buildStructuredError(expected2, found, location2) { + return new peg$SyntaxError( + peg$SyntaxError.buildMessage(expected2, found), + expected2, + found, + location2 + ); + } + function peg$parsebody() { + var s0, s1; + s0 = []; + s1 = peg$parsecomment_only_line(); + if (s1 === peg$FAILED) { + s1 = peg$parserow_with_end(); + if (s1 === peg$FAILED) { + s1 = peg$parserow_without_end(); + } + } + if (s1 !== peg$FAILED) { + while (s1 !== peg$FAILED) { + s0.push(s1); + s1 = peg$parsecomment_only_line(); + if (s1 === peg$FAILED) { + s1 = peg$parserow_with_end(); + if (s1 === peg$FAILED) { + s1 = peg$parserow_without_end(); + } + } + } + } else { + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$parseEOL(); + if (s1 !== peg$FAILED) { + s1 = peg$f0(); + } + s0 = s1; + } + return s0; + } + function peg$parserow_with_end() { + var s0, s1, s2, s3; + s0 = peg$currPos; + s1 = peg$currPos; + s2 = peg$parserow_items(); + if (s2 === peg$FAILED) { + s2 = null; + } + s2 = peg$f1(s2); + s1 = s2; + s2 = peg$parserow_sep(); + if (s2 !== peg$FAILED) { + s3 = peg$parsetrailing_comment(); + if (s3 === peg$FAILED) { + s3 = null; + } + s0 = peg$f2(s1, s2, s3); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parserow_without_end() { + var s0, s1, s2; + s0 = peg$currPos; + s1 = peg$parserow_items(); + if (s1 !== peg$FAILED) { + s2 = peg$parsetrailing_comment(); + if (s2 === peg$FAILED) { + s2 = null; + } + s0 = peg$f3(s1, s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsetrailing_comment() { + var s0, s1, s2; + s0 = peg$currPos; + s1 = []; + s2 = peg$parsewhitespace(); + while (s2 !== peg$FAILED) { + s1.push(s2); + s2 = peg$parsewhitespace(); + } + s2 = peg$parsesame_line_comment(); + if (s2 !== peg$FAILED) { + s0 = peg$f4(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsecomment_only_line() { + var s0, s1, s2; + s0 = peg$currPos; + s1 = []; + s2 = peg$parsewhitespace(); + while (s2 !== peg$FAILED) { + s1.push(s2); + s2 = peg$parsewhitespace(); + } + s2 = peg$parseown_line_comment(); + if (s2 !== peg$FAILED) { + s0 = peg$f5(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsetoken() { + var s0, s1, s2; + s0 = peg$currPos; + s1 = peg$currPos; + peg$silentFails++; + s2 = peg$parserow_sep(); + if (s2 === peg$FAILED) { + s2 = peg$parsecol_sep(); + if (s2 === peg$FAILED) { + s2 = peg$parsetrailing_comment(); + if (s2 === peg$FAILED) { + s2 = peg$parseown_line_comment(); + } + } + } + peg$silentFails--; + if (s2 === peg$FAILED) { + s1 = void 0; + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + if (s1 !== peg$FAILED) { + if (input.length > peg$currPos) { + s2 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s2 !== peg$FAILED) { + s0 = peg$f6(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsecell() { + var s0, s1, s2; + s0 = peg$currPos; + s1 = []; + s2 = peg$parsetoken(); + if (s2 !== peg$FAILED) { + while (s2 !== peg$FAILED) { + s1.push(s2); + s2 = peg$parsetoken(); + } + } else { + s1 = peg$FAILED; + } + if (s1 !== peg$FAILED) { + s0 = input.substring(s0, peg$currPos); + } else { + s0 = s1; + } + return s0; + } + function peg$parseseparated_cell() { + var s0, s1, s2; + s0 = peg$currPos; + s1 = peg$parsecol_sep(); + if (s1 !== peg$FAILED) { + s2 = peg$parsecell(); + if (s2 !== peg$FAILED) { + s0 = peg$f7(s1, s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$parsecol_sep(); + if (s1 !== peg$FAILED) { + s1 = peg$f8(s1); + } + s0 = s1; + } + return s0; + } + function peg$parserow_items() { + var s0, s1, s2, s3; + s0 = peg$currPos; + s1 = peg$parsecell(); + if (s1 !== peg$FAILED) { + s2 = []; + s3 = peg$parseseparated_cell(); + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$parseseparated_cell(); + } + s0 = peg$f9(s1, s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = []; + s2 = peg$parseseparated_cell(); + if (s2 !== peg$FAILED) { + while (s2 !== peg$FAILED) { + s1.push(s2); + s2 = peg$parseseparated_cell(); + } + } else { + s1 = peg$FAILED; + } + if (s1 !== peg$FAILED) { + s1 = peg$f10(s1); + } + s0 = s1; + } + return s0; + } + function peg$parsesame_line_comment() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f11(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s0 = peg$f12(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parseown_line_comment() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f13(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s0 = peg$f14(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsewhitespace() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f15(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s0 = peg$f16(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parserow_sep() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f17(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s0 = peg$f18(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsecol_sep() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f19(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s0 = peg$f20(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parseEOL() { + var s0, s1; + s0 = peg$currPos; + peg$silentFails++; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + peg$silentFails--; + if (s1 === peg$FAILED) { + s0 = void 0; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function processRow(leadCell, otherCells) { + const cells = [leadCell || []]; + const seps = []; + for (const x of otherCells) { + cells.push(x.cell || []); + seps.push(x.colSep); + } + return { cells, colSeps: seps }; + } + if (!options2.isWhitespace) { + try { + Object.assign( + options2, + createMatchers(["\\", "hline", "cr"], ["&"]) + ); + } catch (e) { + console.warn("Error when initializing parser", e); + } + } + peg$result = peg$startRuleFunction(); + if (peg$result !== peg$FAILED && peg$currPos === input.length) { + return peg$result; + } else { + if (peg$result !== peg$FAILED && peg$currPos < input.length) { + peg$fail(peg$endExpectation()); + } + throw peg$buildStructuredError( + peg$maxFailExpected, + peg$maxFailPos < input.length ? input.charAt(peg$maxFailPos) : null, + peg$maxFailPos < input.length ? peg$computeLocation(peg$maxFailPos, peg$maxFailPos + 1) : peg$computeLocation(peg$maxFailPos, peg$maxFailPos) + ); + } + } + return { + SyntaxError: peg$SyntaxError, + parse: peg$parse + }; + }() +); +var xparse_argspec_default = ( + // Generated by Peggy 2.0.1. + // + // https://peggyjs.org/ + function() { + function peg$subclass(child, parent) { + function C() { + this.constructor = child; + } + C.prototype = parent.prototype; + child.prototype = new C(); + } + function peg$SyntaxError(message, expected, found, location) { + var self = Error.call(this, message); + if (Object.setPrototypeOf) { + Object.setPrototypeOf(self, peg$SyntaxError.prototype); + } + self.expected = expected; + self.found = found; + self.location = location; + self.name = "SyntaxError"; + return self; + } + peg$subclass(peg$SyntaxError, Error); + function peg$padEnd(str, targetLength, padString) { + padString = padString || " "; + if (str.length > targetLength) { + return str; + } + targetLength -= str.length; + padString += padString.repeat(targetLength); + return str + padString.slice(0, targetLength); + } + peg$SyntaxError.prototype.format = function(sources) { + var str = "Error: " + this.message; + if (this.location) { + var src = null; + var k; + for (k = 0; k < sources.length; k++) { + if (sources[k].source === this.location.source) { + src = sources[k].text.split(/\r\n|\n|\r/g); + break; + } + } + var s2 = this.location.start; + var loc = this.location.source + ":" + s2.line + ":" + s2.column; + if (src) { + var e = this.location.end; + var filler = peg$padEnd("", s2.line.toString().length, " "); + var line3 = src[s2.line - 1]; + var last = s2.line === e.line ? e.column : line3.length + 1; + var hatLen = last - s2.column || 1; + str += "\n --> " + loc + "\n" + filler + " |\n" + s2.line + " | " + line3 + "\n" + filler + " | " + peg$padEnd("", s2.column - 1, " ") + peg$padEnd("", hatLen, "^"); + } else { + str += "\n at " + loc; + } + } + return str; + }; + peg$SyntaxError.buildMessage = function(expected, found) { + var DESCRIBE_EXPECTATION_FNS = { + literal: function(expectation) { + return '"' + literalEscape(expectation.text) + '"'; + }, + class: function(expectation) { + var escapedParts = expectation.parts.map(function(part) { + return Array.isArray(part) ? classEscape(part[0]) + "-" + classEscape(part[1]) : classEscape(part); + }); + return "[" + (expectation.inverted ? "^" : "") + escapedParts.join("") + "]"; + }, + any: function() { + return "any character"; + }, + end: function() { + return "end of input"; + }, + other: function(expectation) { + return expectation.description; + } + }; + function hex(ch) { + return ch.charCodeAt(0).toString(16).toUpperCase(); + } + function literalEscape(s2) { + return s2.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\0/g, "\\0").replace(/\t/g, "\\t").replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/[\x00-\x0F]/g, function(ch) { + return "\\x0" + hex(ch); + }).replace(/[\x10-\x1F\x7F-\x9F]/g, function(ch) { + return "\\x" + hex(ch); + }); + } + function classEscape(s2) { + return s2.replace(/\\/g, "\\\\").replace(/\]/g, "\\]").replace(/\^/g, "\\^").replace(/-/g, "\\-").replace(/\0/g, "\\0").replace(/\t/g, "\\t").replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/[\x00-\x0F]/g, function(ch) { + return "\\x0" + hex(ch); + }).replace(/[\x10-\x1F\x7F-\x9F]/g, function(ch) { + return "\\x" + hex(ch); + }); + } + function describeExpectation(expectation) { + return DESCRIBE_EXPECTATION_FNS[expectation.type](expectation); + } + function describeExpected(expected2) { + var descriptions = expected2.map(describeExpectation); + var i, j; + descriptions.sort(); + if (descriptions.length > 0) { + for (i = 1, j = 1; i < descriptions.length; i++) { + if (descriptions[i - 1] !== descriptions[i]) { + descriptions[j] = descriptions[i]; + j++; + } + } + descriptions.length = j; + } + switch (descriptions.length) { + case 1: + return descriptions[0]; + case 2: + return descriptions[0] + " or " + descriptions[1]; + default: + return descriptions.slice(0, -1).join(", ") + ", or " + descriptions[descriptions.length - 1]; + } + } + function describeFound(found2) { + return found2 ? '"' + literalEscape(found2) + '"' : "end of input"; + } + return "Expected " + describeExpected(expected) + " but " + describeFound(found) + " found."; + }; + function peg$parse(input, options2) { + options2 = options2 !== void 0 ? options2 : {}; + var peg$FAILED = {}; + var peg$source = options2.grammarSource; + var peg$startRuleFunctions = { args_spec_list: peg$parseargs_spec_list }; + var peg$startRuleFunction = peg$parseargs_spec_list; + var peg$c1 = "v"; + var peg$c2 = "b"; + var peg$c3 = "!"; + var peg$c4 = "D"; + var peg$c5 = "d"; + var peg$c6 = "s"; + var peg$c7 = "O"; + var peg$c8 = "o"; + var peg$c9 = "e"; + var peg$c10 = "E"; + var peg$c11 = "t"; + var peg$c12 = "R"; + var peg$c13 = "r"; + var peg$c14 = "u"; + var peg$c15 = "m"; + var peg$c16 = "{"; + var peg$c17 = "}"; + var peg$c18 = " "; + var peg$c19 = "\n"; + var peg$c20 = "\r"; + var peg$r0 = /^[{ ]/; + var peg$e0 = peg$literalExpectation("+", false); + var peg$e1 = peg$literalExpectation("v", false); + var peg$e2 = peg$anyExpectation(); + var peg$e3 = peg$literalExpectation("b", false); + var peg$e4 = peg$literalExpectation("!", false); + var peg$e5 = peg$literalExpectation("D", false); + var peg$e6 = peg$literalExpectation("d", false); + var peg$e7 = peg$literalExpectation("s", false); + var peg$e8 = peg$literalExpectation("O", false); + var peg$e9 = peg$literalExpectation("o", false); + var peg$e10 = peg$literalExpectation("e", false); + var peg$e11 = peg$literalExpectation("E", false); + var peg$e12 = peg$literalExpectation("t", false); + var peg$e13 = peg$literalExpectation("R", false); + var peg$e14 = peg$literalExpectation("r", false); + var peg$e15 = peg$literalExpectation("u", false); + var peg$e16 = peg$classExpectation(["{", " "], false, false); + var peg$e17 = peg$literalExpectation("m", false); + var peg$e18 = peg$literalExpectation("{", false); + var peg$e19 = peg$literalExpectation("}", false); + var peg$e20 = peg$literalExpectation(" ", false); + var peg$e21 = peg$literalExpectation("\n", false); + var peg$e22 = peg$literalExpectation("\r", false); + var peg$f0 = function(x) { + return x; + }; + var peg$f1 = function(spec) { + return spec; + }; + var peg$f2 = function(spec) { + return spec; + }; + var peg$f3 = function(openBrace) { + return createNode("verbatim", { openBrace, closeBrace: openBrace }); + }; + var peg$f4 = function() { + return createNode("body"); + }; + var peg$f5 = function(leading_bang, spec) { + return leading_bang ? { ...spec, noLeadingWhitespace: true } : spec; + }; + var peg$f6 = function(braceSpec, defaultArg) { + return createNode("optional", { ...braceSpec, defaultArg }); + }; + var peg$f7 = function(braceSpec) { + return createNode("optional", braceSpec); + }; + var peg$f8 = function() { + return createNode("optionalStar"); + }; + var peg$f9 = function(g) { + return createNode("optional", { defaultArg: g }); + }; + var peg$f10 = function() { + return createNode("optional"); + }; + var peg$f11 = function(args) { + return createNode("embellishment", { + embellishmentTokens: args.content + }); + }; + var peg$f12 = function(args, g) { + return createNode("embellishment", { + embellishmentTokens: args.content, + defaultArg: g + }); + }; + var peg$f13 = function(tok) { + return createNode("optionalToken", { token: tok }); + }; + var peg$f14 = function(braceSpec, defaultArg) { + return createNode("mandatory", { ...braceSpec, defaultArg }); + }; + var peg$f15 = function(braceSpec) { + return createNode("mandatory", braceSpec); + }; + var peg$f16 = function(stopTokens) { + return createNode("until", { stopTokens }); + }; + var peg$f17 = function(x) { + return [x]; + }; + var peg$f18 = function(g) { + return g.content; + }; + var peg$f19 = function() { + return createNode("mandatory"); + }; + var peg$f20 = function(openBrace, closeBrace) { + return { openBrace, closeBrace }; + }; + var peg$f21 = function(content) { + return { type: "group", content }; + }; + var peg$f22 = function() { + return ""; + }; + var peg$currPos = 0; + var peg$posDetailsCache = [{ line: 1, column: 1 }]; + var peg$maxFailPos = 0; + var peg$maxFailExpected = []; + var peg$silentFails = 0; + var peg$result; + if ("startRule" in options2) { + if (!(options2.startRule in peg$startRuleFunctions)) { + throw new Error(`Can't start parsing from rule "` + options2.startRule + '".'); + } + peg$startRuleFunction = peg$startRuleFunctions[options2.startRule]; + } + function peg$literalExpectation(text2, ignoreCase) { + return { type: "literal", text: text2, ignoreCase }; + } + function peg$classExpectation(parts, inverted, ignoreCase) { + return { type: "class", parts, inverted, ignoreCase }; + } + function peg$anyExpectation() { + return { type: "any" }; + } + function peg$endExpectation() { + return { type: "end" }; + } + function peg$computePosDetails(pos) { + var details = peg$posDetailsCache[pos]; + var p; + if (details) { + return details; + } else { + p = pos - 1; + while (!peg$posDetailsCache[p]) { + p--; + } + details = peg$posDetailsCache[p]; + details = { + line: details.line, + column: details.column + }; + while (p < pos) { + if (input.charCodeAt(p) === 10) { + details.line++; + details.column = 1; + } else { + details.column++; + } + p++; + } + peg$posDetailsCache[pos] = details; + return details; + } + } + function peg$computeLocation(startPos, endPos) { + var startPosDetails = peg$computePosDetails(startPos); + var endPosDetails = peg$computePosDetails(endPos); + return { + source: peg$source, + start: { + offset: startPos, + line: startPosDetails.line, + column: startPosDetails.column + }, + end: { + offset: endPos, + line: endPosDetails.line, + column: endPosDetails.column + } + }; + } + function peg$fail(expected2) { + if (peg$currPos < peg$maxFailPos) { + return; + } + if (peg$currPos > peg$maxFailPos) { + peg$maxFailPos = peg$currPos; + peg$maxFailExpected = []; + } + peg$maxFailExpected.push(expected2); + } + function peg$buildStructuredError(expected2, found, location2) { + return new peg$SyntaxError( + peg$SyntaxError.buildMessage(expected2, found), + expected2, + found, + location2 + ); + } + function peg$parseargs_spec_list() { + var s0, s1, s2, s4; + s0 = peg$currPos; + s1 = []; + s2 = peg$currPos; + peg$parsewhitespace(); + s4 = peg$parsearg_spec(); + if (s4 !== peg$FAILED) { + s2 = peg$f0(s4); + } else { + peg$currPos = s2; + s2 = peg$FAILED; + } + while (s2 !== peg$FAILED) { + s1.push(s2); + s2 = peg$currPos; + peg$parsewhitespace(); + s4 = peg$parsearg_spec(); + if (s4 !== peg$FAILED) { + s2 = peg$f0(s4); + } else { + peg$currPos = s2; + s2 = peg$FAILED; + } + } + s2 = peg$parsewhitespace(); + s0 = peg$f1(s1); + return s0; + } + function peg$parsearg_spec() { + var s0, s2; + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 43) { + peg$currPos++; + } else { + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + s2 = peg$parseoptional(); + if (s2 === peg$FAILED) { + s2 = peg$parsemandatory(); + if (s2 === peg$FAILED) { + s2 = peg$parseverbatim(); + if (s2 === peg$FAILED) { + s2 = peg$parserequired(); + if (s2 === peg$FAILED) { + s2 = peg$parsebody(); + if (s2 === peg$FAILED) { + s2 = peg$parseuntil(); + } + } + } + } + } + if (s2 !== peg$FAILED) { + s0 = peg$f2(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parseverbatim() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 118) { + s1 = peg$c1; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e1); + } + } + if (s1 !== peg$FAILED) { + if (input.length > peg$currPos) { + s2 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e2); + } + } + if (s2 !== peg$FAILED) { + s0 = peg$f3(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsebody() { + var s0, s1; + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 98) { + s1 = peg$c2; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s1 !== peg$FAILED) { + s1 = peg$f4(); + } + s0 = s1; + return s0; + } + function peg$parseoptional() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 33) { + s1 = peg$c3; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e4); + } + } + if (s1 === peg$FAILED) { + s1 = null; + } + s2 = peg$parseoptional_star(); + if (s2 === peg$FAILED) { + s2 = peg$parseoptional_standard(); + if (s2 === peg$FAILED) { + s2 = peg$parseoptional_delimited(); + if (s2 === peg$FAILED) { + s2 = peg$parseoptional_embellishment(); + if (s2 === peg$FAILED) { + s2 = peg$parseoptional_token(); + } + } + } + } + if (s2 !== peg$FAILED) { + s0 = peg$f5(s1, s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parseoptional_delimited() { + var s0, s1, s2, s3; + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 68) { + s1 = peg$c4; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e5); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$parsebrace_spec(); + s3 = peg$parsebraced_group(); + if (s3 !== peg$FAILED) { + s0 = peg$f6(s2, s3); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 100) { + s1 = peg$c5; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e6); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$parsebrace_spec(); + s0 = peg$f7(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } + return s0; + } + function peg$parseoptional_star() { + var s0, s1; + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 115) { + s1 = peg$c6; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e7); + } + } + if (s1 !== peg$FAILED) { + s1 = peg$f8(); + } + s0 = s1; + return s0; + } + function peg$parseoptional_standard() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 79) { + s1 = peg$c7; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e8); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$parsebraced_group(); + if (s2 !== peg$FAILED) { + s0 = peg$f9(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 111) { + s1 = peg$c8; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e9); + } + } + if (s1 !== peg$FAILED) { + s1 = peg$f10(); + } + s0 = s1; + } + return s0; + } + function peg$parseoptional_embellishment() { + var s0, s1, s2, s3; + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 101) { + s1 = peg$c9; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e10); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$parsebraced_group(); + if (s2 !== peg$FAILED) { + s0 = peg$f11(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 69) { + s1 = peg$c10; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e11); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$parsebraced_group(); + if (s2 !== peg$FAILED) { + s3 = peg$parsebraced_group(); + if (s3 !== peg$FAILED) { + s0 = peg$f12(s2, s3); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } + return s0; + } + function peg$parseoptional_token() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 116) { + s1 = peg$c11; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e12); + } + } + if (s1 !== peg$FAILED) { + if (input.length > peg$currPos) { + s2 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e2); + } + } + if (s2 !== peg$FAILED) { + s0 = peg$f13(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parserequired() { + var s0, s1, s2, s3; + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 82) { + s1 = peg$c12; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e13); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$parsebrace_spec(); + s3 = peg$parsebraced_group(); + if (s3 !== peg$FAILED) { + s0 = peg$f14(s2, s3); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 114) { + s1 = peg$c13; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e14); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$parsebrace_spec(); + s0 = peg$f15(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } + return s0; + } + function peg$parseuntil() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 117) { + s1 = peg$c14; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e15); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$parseuntil_stop_token(); + if (s2 !== peg$FAILED) { + s0 = peg$f16(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parseuntil_stop_token() { + var s0, s1, s2; + s0 = peg$currPos; + s1 = peg$currPos; + peg$silentFails++; + if (peg$r0.test(input.charAt(peg$currPos))) { + s2 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e16); + } + } + peg$silentFails--; + if (s2 === peg$FAILED) { + s1 = void 0; + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + if (s1 !== peg$FAILED) { + if (input.length > peg$currPos) { + s2 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e2); + } + } + if (s2 !== peg$FAILED) { + s0 = peg$f17(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$parsebraced_group(); + if (s1 !== peg$FAILED) { + s1 = peg$f18(s1); + } + s0 = s1; + } + return s0; + } + function peg$parsemandatory() { + var s0, s1; + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 109) { + s1 = peg$c15; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e17); + } + } + if (s1 !== peg$FAILED) { + s1 = peg$f19(); + } + s0 = s1; + return s0; + } + function peg$parsebrace_spec() { + var s0, s1, s2, s3, s4, s5; + s0 = peg$currPos; + s1 = peg$currPos; + s2 = peg$currPos; + s3 = peg$currPos; + peg$silentFails++; + s4 = peg$parsewhitespace_token(); + peg$silentFails--; + if (s4 === peg$FAILED) { + s3 = void 0; + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + if (s3 !== peg$FAILED) { + if (input.length > peg$currPos) { + s4 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s4 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e2); + } + } + if (s4 !== peg$FAILED) { + s3 = [s3, s4]; + s2 = s3; + } else { + peg$currPos = s2; + s2 = peg$FAILED; + } + } else { + peg$currPos = s2; + s2 = peg$FAILED; + } + if (s2 === peg$FAILED) { + s2 = null; + } + s1 = input.substring(s1, peg$currPos); + s2 = peg$currPos; + s3 = peg$currPos; + s4 = peg$currPos; + peg$silentFails++; + s5 = peg$parsewhitespace_token(); + peg$silentFails--; + if (s5 === peg$FAILED) { + s4 = void 0; + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + if (s4 !== peg$FAILED) { + if (input.length > peg$currPos) { + s5 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s5 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e2); + } + } + if (s5 !== peg$FAILED) { + s4 = [s4, s5]; + s3 = s4; + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + if (s3 === peg$FAILED) { + s3 = null; + } + s2 = input.substring(s2, peg$currPos); + s0 = peg$f20(s1, s2); + return s0; + } + function peg$parsebraced_group() { + var s0, s1, s2, s3, s4, s5, s6, s7; + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 123) { + s1 = peg$c16; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e18); + } + } + if (s1 !== peg$FAILED) { + s2 = []; + s3 = peg$currPos; + s4 = peg$currPos; + s5 = peg$currPos; + peg$silentFails++; + if (input.charCodeAt(peg$currPos) === 125) { + s6 = peg$c17; + peg$currPos++; + } else { + s6 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e19); + } + } + peg$silentFails--; + if (s6 === peg$FAILED) { + s5 = void 0; + } else { + peg$currPos = s5; + s5 = peg$FAILED; + } + if (s5 !== peg$FAILED) { + s6 = peg$currPos; + peg$silentFails++; + s7 = peg$parsebraced_group(); + peg$silentFails--; + if (s7 === peg$FAILED) { + s6 = void 0; + } else { + peg$currPos = s6; + s6 = peg$FAILED; + } + if (s6 !== peg$FAILED) { + if (input.length > peg$currPos) { + s7 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s7 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e2); + } + } + if (s7 !== peg$FAILED) { + s5 = [s5, s6, s7]; + s4 = s5; + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + if (s4 !== peg$FAILED) { + s3 = input.substring(s3, peg$currPos); + } else { + s3 = s4; + } + if (s3 === peg$FAILED) { + s3 = peg$parsebraced_group(); + } + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$currPos; + s4 = peg$currPos; + s5 = peg$currPos; + peg$silentFails++; + if (input.charCodeAt(peg$currPos) === 125) { + s6 = peg$c17; + peg$currPos++; + } else { + s6 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e19); + } + } + peg$silentFails--; + if (s6 === peg$FAILED) { + s5 = void 0; + } else { + peg$currPos = s5; + s5 = peg$FAILED; + } + if (s5 !== peg$FAILED) { + s6 = peg$currPos; + peg$silentFails++; + s7 = peg$parsebraced_group(); + peg$silentFails--; + if (s7 === peg$FAILED) { + s6 = void 0; + } else { + peg$currPos = s6; + s6 = peg$FAILED; + } + if (s6 !== peg$FAILED) { + if (input.length > peg$currPos) { + s7 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s7 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e2); + } + } + if (s7 !== peg$FAILED) { + s5 = [s5, s6, s7]; + s4 = s5; + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + if (s4 !== peg$FAILED) { + s3 = input.substring(s3, peg$currPos); + } else { + s3 = s4; + } + if (s3 === peg$FAILED) { + s3 = peg$parsebraced_group(); + } + } + if (input.charCodeAt(peg$currPos) === 125) { + s3 = peg$c17; + peg$currPos++; + } else { + s3 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e19); + } + } + if (s3 !== peg$FAILED) { + s0 = peg$f21(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsewhitespace() { + var s0, s1, s2; + s0 = peg$currPos; + s1 = []; + s2 = peg$parsewhitespace_token(); + while (s2 !== peg$FAILED) { + s1.push(s2); + s2 = peg$parsewhitespace_token(); + } + s1 = peg$f22(); + s0 = s1; + return s0; + } + function peg$parsewhitespace_token() { + var s0; + if (input.charCodeAt(peg$currPos) === 32) { + s0 = peg$c18; + peg$currPos++; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e20); + } + } + if (s0 === peg$FAILED) { + if (input.charCodeAt(peg$currPos) === 10) { + s0 = peg$c19; + peg$currPos++; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e21); + } + } + if (s0 === peg$FAILED) { + if (input.charCodeAt(peg$currPos) === 13) { + s0 = peg$c20; + peg$currPos++; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e22); + } + } + } + } + return s0; + } + const DEFAULT_OPTIONS = { + optional: { openBrace: "[", closeBrace: "]" }, + mandatory: { openBrace: "{", closeBrace: "}" } + }; + function createNode(type, options22) { + const computedOptions = DEFAULT_OPTIONS[type] || {}; + return { type, ...computedOptions, ...options22 }; + } + peg$result = peg$startRuleFunction(); + if (peg$result !== peg$FAILED && peg$currPos === input.length) { + return peg$result; + } else { + if (peg$result !== peg$FAILED && peg$currPos < input.length) { + peg$fail(peg$endExpectation()); + } + throw peg$buildStructuredError( + peg$maxFailExpected, + peg$maxFailPos < input.length ? input.charAt(peg$maxFailPos) : null, + peg$maxFailPos < input.length ? peg$computeLocation(peg$maxFailPos, peg$maxFailPos + 1) : peg$computeLocation(peg$maxFailPos, peg$maxFailPos) + ); + } + } + return { + SyntaxError: peg$SyntaxError, + parse: peg$parse + }; + }() +); +var pgfkeys_default = ( + // Generated by Peggy 2.0.1. + // + // https://peggyjs.org/ + function() { + function peg$subclass(child, parent) { + function C() { + this.constructor = child; + } + C.prototype = parent.prototype; + child.prototype = new C(); + } + function peg$SyntaxError(message, expected, found, location) { + var self = Error.call(this, message); + if (Object.setPrototypeOf) { + Object.setPrototypeOf(self, peg$SyntaxError.prototype); + } + self.expected = expected; + self.found = found; + self.location = location; + self.name = "SyntaxError"; + return self; + } + peg$subclass(peg$SyntaxError, Error); + function peg$padEnd(str, targetLength, padString) { + padString = padString || " "; + if (str.length > targetLength) { + return str; + } + targetLength -= str.length; + padString += padString.repeat(targetLength); + return str + padString.slice(0, targetLength); + } + peg$SyntaxError.prototype.format = function(sources) { + var str = "Error: " + this.message; + if (this.location) { + var src = null; + var k; + for (k = 0; k < sources.length; k++) { + if (sources[k].source === this.location.source) { + src = sources[k].text.split(/\r\n|\n|\r/g); + break; + } + } + var s2 = this.location.start; + var loc = this.location.source + ":" + s2.line + ":" + s2.column; + if (src) { + var e = this.location.end; + var filler = peg$padEnd("", s2.line.toString().length, " "); + var line3 = src[s2.line - 1]; + var last = s2.line === e.line ? e.column : line3.length + 1; + var hatLen = last - s2.column || 1; + str += "\n --> " + loc + "\n" + filler + " |\n" + s2.line + " | " + line3 + "\n" + filler + " | " + peg$padEnd("", s2.column - 1, " ") + peg$padEnd("", hatLen, "^"); + } else { + str += "\n at " + loc; + } + } + return str; + }; + peg$SyntaxError.buildMessage = function(expected, found) { + var DESCRIBE_EXPECTATION_FNS = { + literal: function(expectation) { + return '"' + literalEscape(expectation.text) + '"'; + }, + class: function(expectation) { + var escapedParts = expectation.parts.map(function(part) { + return Array.isArray(part) ? classEscape(part[0]) + "-" + classEscape(part[1]) : classEscape(part); + }); + return "[" + (expectation.inverted ? "^" : "") + escapedParts.join("") + "]"; + }, + any: function() { + return "any character"; + }, + end: function() { + return "end of input"; + }, + other: function(expectation) { + return expectation.description; + } + }; + function hex(ch) { + return ch.charCodeAt(0).toString(16).toUpperCase(); + } + function literalEscape(s2) { + return s2.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\0/g, "\\0").replace(/\t/g, "\\t").replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/[\x00-\x0F]/g, function(ch) { + return "\\x0" + hex(ch); + }).replace(/[\x10-\x1F\x7F-\x9F]/g, function(ch) { + return "\\x" + hex(ch); + }); + } + function classEscape(s2) { + return s2.replace(/\\/g, "\\\\").replace(/\]/g, "\\]").replace(/\^/g, "\\^").replace(/-/g, "\\-").replace(/\0/g, "\\0").replace(/\t/g, "\\t").replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/[\x00-\x0F]/g, function(ch) { + return "\\x0" + hex(ch); + }).replace(/[\x10-\x1F\x7F-\x9F]/g, function(ch) { + return "\\x" + hex(ch); + }); + } + function describeExpectation(expectation) { + return DESCRIBE_EXPECTATION_FNS[expectation.type](expectation); + } + function describeExpected(expected2) { + var descriptions = expected2.map(describeExpectation); + var i, j; + descriptions.sort(); + if (descriptions.length > 0) { + for (i = 1, j = 1; i < descriptions.length; i++) { + if (descriptions[i - 1] !== descriptions[i]) { + descriptions[j] = descriptions[i]; + j++; + } + } + descriptions.length = j; + } + switch (descriptions.length) { + case 1: + return descriptions[0]; + case 2: + return descriptions[0] + " or " + descriptions[1]; + default: + return descriptions.slice(0, -1).join(", ") + ", or " + descriptions[descriptions.length - 1]; + } + } + function describeFound(found2) { + return found2 ? '"' + literalEscape(found2) + '"' : "end of input"; + } + return "Expected " + describeExpected(expected) + " but " + describeFound(found) + " found."; + }; + function peg$parse(input, options2) { + options2 = options2 !== void 0 ? options2 : {}; + var peg$FAILED = {}; + var peg$source = options2.grammarSource; + var peg$startRuleFunctions = { body: peg$parsebody }; + var peg$startRuleFunction = peg$parsebody; + var peg$e0 = peg$anyExpectation(); + var peg$f0 = function() { + return []; + }; + var peg$f1 = function(rowItems, trailingComment) { + return { + itemParts: [], + ...rowItems, + trailingComment, + trailingComma: true + }; + }; + var peg$f2 = function(rowItems, trailingComment) { + return { ...rowItems, trailingComment }; + }; + var peg$f3 = function(a, b) { + return processItem(a, b); + }; + var peg$f4 = function(b) { + return processItem(null, b); + }; + var peg$f5 = function(cell) { + return { cell }; + }; + var peg$f6 = function() { + return {}; + }; + var peg$f7 = function(part) { + return part; + }; + var peg$f8 = function(x) { + return x; + }; + var peg$f9 = function(space, x) { + return { + trailingComment: x, + leadingParbreak: space.parbreak > 0 + }; + }; + var peg$f10 = function(list) { + return { + whitespace: list.filter((x) => options2.isWhitespace(x)).length, + parbreak: list.filter((x) => options2.isParbreak(x)).length + }; + }; + var peg$f11 = function() { + return !options2.allowParenGroups; + }; + var peg$f12 = function(tok) { + return options2.isSameLineComment(tok); + }; + var peg$f13 = function(tok) { + return tok; + }; + var peg$f14 = function(tok) { + return options2.isOwnLineComment(tok); + }; + var peg$f15 = function(tok) { + return tok; + }; + var peg$f16 = function(tok) { + return options2.isWhitespace(tok); + }; + var peg$f17 = function(tok) { + return tok; + }; + var peg$f18 = function(tok) { + return options2.isParbreak(tok); + }; + var peg$f19 = function(tok) { + return tok; + }; + var peg$f20 = function(tok) { + return options2.isComma(tok); + }; + var peg$f21 = function(tok) { + return tok; + }; + var peg$f22 = function(tok) { + return options2.isEquals(tok); + }; + var peg$f23 = function(tok) { + return tok; + }; + var peg$f24 = function(tok) { + return options2.isChar(tok, "("); + }; + var peg$f25 = function(tok) { + return tok; + }; + var peg$f26 = function(tok) { + return options2.isChar(tok, ")"); + }; + var peg$f27 = function(tok) { + return tok; + }; + var peg$currPos = 0; + var peg$posDetailsCache = [{ line: 1, column: 1 }]; + var peg$maxFailPos = 0; + var peg$maxFailExpected = []; + var peg$silentFails = 0; + var peg$result; + if ("startRule" in options2) { + if (!(options2.startRule in peg$startRuleFunctions)) { + throw new Error(`Can't start parsing from rule "` + options2.startRule + '".'); + } + peg$startRuleFunction = peg$startRuleFunctions[options2.startRule]; + } + function peg$anyExpectation() { + return { type: "any" }; + } + function peg$endExpectation() { + return { type: "end" }; + } + function peg$computePosDetails(pos) { + var details = peg$posDetailsCache[pos]; + var p; + if (details) { + return details; + } else { + p = pos - 1; + while (!peg$posDetailsCache[p]) { + p--; + } + details = peg$posDetailsCache[p]; + details = { + line: details.line, + column: details.column + }; + while (p < pos) { + if (input.charCodeAt(p) === 10) { + details.line++; + details.column = 1; + } else { + details.column++; + } + p++; + } + peg$posDetailsCache[pos] = details; + return details; + } + } + function peg$computeLocation(startPos, endPos) { + var startPosDetails = peg$computePosDetails(startPos); + var endPosDetails = peg$computePosDetails(endPos); + return { + source: peg$source, + start: { + offset: startPos, + line: startPosDetails.line, + column: startPosDetails.column + }, + end: { + offset: endPos, + line: endPosDetails.line, + column: endPosDetails.column + } + }; + } + function peg$fail(expected2) { + if (peg$currPos < peg$maxFailPos) { + return; + } + if (peg$currPos > peg$maxFailPos) { + peg$maxFailPos = peg$currPos; + peg$maxFailExpected = []; + } + peg$maxFailExpected.push(expected2); + } + function peg$buildStructuredError(expected2, found, location2) { + return new peg$SyntaxError( + peg$SyntaxError.buildMessage(expected2, found), + expected2, + found, + location2 + ); + } + function peg$parsebody() { + var s0, s1, s2; + s0 = []; + s1 = peg$parsecomment_only_line(); + if (s1 === peg$FAILED) { + s1 = peg$parseitem_with_end(); + if (s1 === peg$FAILED) { + s1 = peg$parseitem_without_end(); + } + } + if (s1 !== peg$FAILED) { + while (s1 !== peg$FAILED) { + s0.push(s1); + s1 = peg$parsecomment_only_line(); + if (s1 === peg$FAILED) { + s1 = peg$parseitem_with_end(); + if (s1 === peg$FAILED) { + s1 = peg$parseitem_without_end(); + } + } + } + } else { + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = []; + s2 = peg$parsewhitespace(); + while (s2 !== peg$FAILED) { + s1.push(s2); + s2 = peg$parsewhitespace(); + } + s2 = peg$parseEOL(); + if (s2 !== peg$FAILED) { + s0 = peg$f0(); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } + return s0; + } + function peg$parseitem_with_end() { + var s0, s2, s4, s5, s6, s7, s8; + s0 = peg$currPos; + peg$parsewhitespace_or_parbreaks(); + s2 = peg$parserow_items(); + if (s2 === peg$FAILED) { + s2 = null; + } + peg$parsewhitespace_or_parbreaks(); + s4 = peg$parseitem_sep(); + if (s4 !== peg$FAILED) { + s5 = []; + s6 = peg$parsewhitespace(); + while (s6 !== peg$FAILED) { + s5.push(s6); + s6 = peg$parsewhitespace(); + } + s6 = peg$parsetrailing_comment(); + if (s6 === peg$FAILED) { + s6 = null; + } + s7 = []; + s8 = peg$parsewhitespace(); + while (s8 !== peg$FAILED) { + s7.push(s8); + s8 = peg$parsewhitespace(); + } + s0 = peg$f1(s2, s6); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parseitem_without_end() { + var s0, s2, s3; + s0 = peg$currPos; + peg$parsewhitespace_or_parbreaks(); + s2 = peg$parserow_items(); + if (s2 !== peg$FAILED) { + s3 = peg$parsetrailing_comment(); + if (s3 === peg$FAILED) { + s3 = null; + } + s0 = peg$f2(s2, s3); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parserow_items() { + var s0, s1, s2, s3; + s0 = peg$currPos; + s1 = peg$parseitem_part(); + if (s1 !== peg$FAILED) { + s2 = []; + s3 = peg$parseseparated_part(); + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$parseseparated_part(); + } + s0 = peg$f3(s1, s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = []; + s2 = peg$parseseparated_part(); + if (s2 !== peg$FAILED) { + while (s2 !== peg$FAILED) { + s1.push(s2); + s2 = peg$parseseparated_part(); + } + } else { + s1 = peg$FAILED; + } + if (s1 !== peg$FAILED) { + s1 = peg$f4(s1); + } + s0 = s1; + } + return s0; + } + function peg$parseseparated_part() { + var s0, s1, s2, s3, s4; + s0 = peg$currPos; + s1 = []; + s2 = peg$parseparbreak(); + while (s2 !== peg$FAILED) { + s1.push(s2); + s2 = peg$parseparbreak(); + } + s2 = peg$parseequals(); + if (s2 !== peg$FAILED) { + s3 = []; + s4 = peg$parseparbreak(); + while (s4 !== peg$FAILED) { + s3.push(s4); + s4 = peg$parseparbreak(); + } + s4 = peg$parseitem_part(); + if (s4 !== peg$FAILED) { + s0 = peg$f5(s4); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = []; + s2 = peg$parseparbreak(); + while (s2 !== peg$FAILED) { + s1.push(s2); + s2 = peg$parseparbreak(); + } + s2 = peg$parseequals(); + if (s2 !== peg$FAILED) { + s0 = peg$f6(); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } + return s0; + } + function peg$parseitem_part() { + var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9; + s0 = peg$currPos; + s1 = []; + s2 = peg$parsewhitespace(); + while (s2 !== peg$FAILED) { + s1.push(s2); + s2 = peg$parsewhitespace(); + } + s2 = peg$currPos; + s3 = []; + s4 = peg$parsenon_whitespace_non_parbreak_token(); + if (s4 === peg$FAILED) { + s4 = peg$currPos; + s5 = peg$parsewhitespace(); + if (s5 === peg$FAILED) { + s5 = peg$parseparbreak(); + } + if (s5 !== peg$FAILED) { + s6 = peg$currPos; + peg$silentFails++; + s7 = peg$currPos; + s8 = []; + s9 = peg$parsewhitespace(); + if (s9 === peg$FAILED) { + s9 = peg$parseparbreak(); + } + while (s9 !== peg$FAILED) { + s8.push(s9); + s9 = peg$parsewhitespace(); + if (s9 === peg$FAILED) { + s9 = peg$parseparbreak(); + } + } + s9 = peg$parsenon_whitespace_non_parbreak_token(); + if (s9 !== peg$FAILED) { + s8 = [s8, s9]; + s7 = s8; + } else { + peg$currPos = s7; + s7 = peg$FAILED; + } + peg$silentFails--; + if (s7 !== peg$FAILED) { + peg$currPos = s6; + s6 = void 0; + } else { + s6 = peg$FAILED; + } + if (s6 !== peg$FAILED) { + s5 = [s5, s6]; + s4 = s5; + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + } + if (s4 !== peg$FAILED) { + while (s4 !== peg$FAILED) { + s3.push(s4); + s4 = peg$parsenon_whitespace_non_parbreak_token(); + if (s4 === peg$FAILED) { + s4 = peg$currPos; + s5 = peg$parsewhitespace(); + if (s5 === peg$FAILED) { + s5 = peg$parseparbreak(); + } + if (s5 !== peg$FAILED) { + s6 = peg$currPos; + peg$silentFails++; + s7 = peg$currPos; + s8 = []; + s9 = peg$parsewhitespace(); + if (s9 === peg$FAILED) { + s9 = peg$parseparbreak(); + } + while (s9 !== peg$FAILED) { + s8.push(s9); + s9 = peg$parsewhitespace(); + if (s9 === peg$FAILED) { + s9 = peg$parseparbreak(); + } + } + s9 = peg$parsenon_whitespace_non_parbreak_token(); + if (s9 !== peg$FAILED) { + s8 = [s8, s9]; + s7 = s8; + } else { + peg$currPos = s7; + s7 = peg$FAILED; + } + peg$silentFails--; + if (s7 !== peg$FAILED) { + peg$currPos = s6; + s6 = void 0; + } else { + s6 = peg$FAILED; + } + if (s6 !== peg$FAILED) { + s5 = [s5, s6]; + s4 = s5; + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + } + } + } else { + s3 = peg$FAILED; + } + if (s3 !== peg$FAILED) { + s2 = input.substring(s2, peg$currPos); + } else { + s2 = s3; + } + if (s2 !== peg$FAILED) { + s3 = []; + s4 = peg$parsewhitespace(); + while (s4 !== peg$FAILED) { + s3.push(s4); + s4 = peg$parsewhitespace(); + } + s0 = peg$f7(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsetrailing_comment() { + var s0, s1, s2; + s0 = peg$currPos; + s1 = []; + s2 = peg$parsewhitespace(); + while (s2 !== peg$FAILED) { + s1.push(s2); + s2 = peg$parsewhitespace(); + } + s2 = peg$parsesame_line_comment(); + if (s2 !== peg$FAILED) { + s0 = peg$f8(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsecomment_only_line() { + var s0, s1, s2; + s0 = peg$currPos; + s1 = peg$parsewhitespace_or_parbreaks(); + s2 = peg$parseown_line_comment(); + if (s2 !== peg$FAILED) { + s0 = peg$f9(s1, s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsetoken() { + var s0, s1, s2, s3; + s0 = peg$currPos; + s1 = peg$currPos; + s2 = peg$currPos; + peg$silentFails++; + s3 = peg$parsenon_token(); + peg$silentFails--; + if (s3 === peg$FAILED) { + s2 = void 0; + } else { + peg$currPos = s2; + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + if (input.length > peg$currPos) { + s3 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s3 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s3 !== peg$FAILED) { + s2 = [s2, s3]; + s1 = s2; + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + if (s1 !== peg$FAILED) { + s0 = input.substring(s0, peg$currPos); + } else { + s0 = s1; + } + return s0; + } + function peg$parsenon_whitespace_non_parbreak_token() { + var s0, s1, s2, s3; + s0 = peg$currPos; + s1 = peg$currPos; + s2 = peg$currPos; + peg$silentFails++; + s3 = peg$parsewhitespace(); + if (s3 === peg$FAILED) { + s3 = peg$parseparbreak(); + } + peg$silentFails--; + if (s3 === peg$FAILED) { + s2 = void 0; + } else { + peg$currPos = s2; + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s3 = peg$parseparen_block(); + if (s3 === peg$FAILED) { + s3 = peg$parsetoken(); + } + if (s3 !== peg$FAILED) { + s2 = [s2, s3]; + s1 = s2; + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + if (s1 !== peg$FAILED) { + s0 = input.substring(s0, peg$currPos); + } else { + s0 = s1; + } + return s0; + } + function peg$parsenon_token() { + var s0; + s0 = peg$parseitem_sep(); + if (s0 === peg$FAILED) { + s0 = peg$parseequals(); + if (s0 === peg$FAILED) { + s0 = peg$parsetrailing_comment(); + if (s0 === peg$FAILED) { + s0 = peg$parseown_line_comment(); + } + } + } + return s0; + } + function peg$parsewhitespace_or_parbreaks() { + var s0, s1, s2; + s0 = peg$currPos; + s1 = []; + s2 = peg$parsewhitespace(); + if (s2 === peg$FAILED) { + s2 = peg$parseparbreak(); + } + while (s2 !== peg$FAILED) { + s1.push(s2); + s2 = peg$parsewhitespace(); + if (s2 === peg$FAILED) { + s2 = peg$parseparbreak(); + } + } + s1 = peg$f10(s1); + s0 = s1; + return s0; + } + function peg$parseparen_block() { + var s0, s1, s2, s3, s4, s5, s6, s7, s8; + s0 = peg$currPos; + s1 = peg$f11(); + if (s1) { + s1 = peg$FAILED; + } else { + s1 = void 0; + } + if (s1 !== peg$FAILED) { + s2 = peg$currPos; + s3 = peg$currPos; + s4 = peg$parseopen_paren(); + if (s4 !== peg$FAILED) { + s5 = []; + s6 = peg$currPos; + s7 = peg$currPos; + peg$silentFails++; + s8 = peg$parseclose_paren(); + peg$silentFails--; + if (s8 === peg$FAILED) { + s7 = void 0; + } else { + peg$currPos = s7; + s7 = peg$FAILED; + } + if (s7 !== peg$FAILED) { + if (input.length > peg$currPos) { + s8 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s8 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s8 !== peg$FAILED) { + s7 = [s7, s8]; + s6 = s7; + } else { + peg$currPos = s6; + s6 = peg$FAILED; + } + } else { + peg$currPos = s6; + s6 = peg$FAILED; + } + while (s6 !== peg$FAILED) { + s5.push(s6); + s6 = peg$currPos; + s7 = peg$currPos; + peg$silentFails++; + s8 = peg$parseclose_paren(); + peg$silentFails--; + if (s8 === peg$FAILED) { + s7 = void 0; + } else { + peg$currPos = s7; + s7 = peg$FAILED; + } + if (s7 !== peg$FAILED) { + if (input.length > peg$currPos) { + s8 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s8 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s8 !== peg$FAILED) { + s7 = [s7, s8]; + s6 = s7; + } else { + peg$currPos = s6; + s6 = peg$FAILED; + } + } else { + peg$currPos = s6; + s6 = peg$FAILED; + } + } + s6 = peg$parseclose_paren(); + if (s6 !== peg$FAILED) { + s4 = [s4, s5, s6]; + s3 = s4; + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + if (s3 !== peg$FAILED) { + s2 = input.substring(s2, peg$currPos); + } else { + s2 = s3; + } + if (s2 !== peg$FAILED) { + s1 = [s1, s2]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsesame_line_comment() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f12(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s0 = peg$f13(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parseown_line_comment() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f14(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s0 = peg$f15(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsewhitespace() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f16(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s0 = peg$f17(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parseparbreak() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f18(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s0 = peg$f19(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parseitem_sep() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f20(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s0 = peg$f21(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parseequals() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f22(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s0 = peg$f23(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parseopen_paren() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f24(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s0 = peg$f25(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parseclose_paren() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f26(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s0 = peg$f27(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parseEOL() { + var s0, s1; + s0 = peg$currPos; + peg$silentFails++; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + peg$silentFails--; + if (s1 === peg$FAILED) { + s0 = void 0; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function processItem(leadCell, otherCells) { + const cells = [leadCell || []]; + for (const x of otherCells) { + cells.push(x.cell || []); + } + return { itemParts: cells }; + } + if (!options2.isWhitespace) { + try { + Object.assign(options2, { + isChar: (node, char) => node.type === "string" && node.content === char, + isComma(node) { + return node.type === "string" && node.content === ","; + }, + isEquals(node) { + return node.type === "string" && node.content === "="; + }, + isParbreak(node) { + return node.type === "parbreak"; + }, + isWhitespace(node) { + return node.type === "whitespace"; + }, + isSameLineComment: (node) => node.type === "comment" && node.sameline, + isOwnLineComment: (node) => node.type === "comment" && !node.sameline, + isComment: (node) => node.type === "comment", + allowParenGroups: true + }); + } catch (e) { + console.warn("Error when initializing parser", e); + } + } + peg$result = peg$startRuleFunction(); + if (peg$result !== peg$FAILED && peg$currPos === input.length) { + return peg$result; + } else { + if (peg$result !== peg$FAILED && peg$currPos < input.length) { + peg$fail(peg$endExpectation()); + } + throw peg$buildStructuredError( + peg$maxFailExpected, + peg$maxFailPos < input.length ? input.charAt(peg$maxFailPos) : null, + peg$maxFailPos < input.length ? peg$computeLocation(peg$maxFailPos, peg$maxFailPos + 1) : peg$computeLocation(peg$maxFailPos, peg$maxFailPos) + ); + } + } + return { + SyntaxError: peg$SyntaxError, + parse: peg$parse + }; + }() +); +// Generated by Peggy 2.0.1. +// +// https://peggyjs.org/ +(function() { + function peg$subclass(child, parent) { + function C() { + this.constructor = child; + } + C.prototype = parent.prototype; + child.prototype = new C(); + } + function peg$SyntaxError(message, expected, found, location) { + var self = Error.call(this, message); + if (Object.setPrototypeOf) { + Object.setPrototypeOf(self, peg$SyntaxError.prototype); + } + self.expected = expected; + self.found = found; + self.location = location; + self.name = "SyntaxError"; + return self; + } + peg$subclass(peg$SyntaxError, Error); + function peg$padEnd(str, targetLength, padString) { + padString = padString || " "; + if (str.length > targetLength) { + return str; + } + targetLength -= str.length; + padString += padString.repeat(targetLength); + return str + padString.slice(0, targetLength); + } + peg$SyntaxError.prototype.format = function(sources) { + var str = "Error: " + this.message; + if (this.location) { + var src = null; + var k; + for (k = 0; k < sources.length; k++) { + if (sources[k].source === this.location.source) { + src = sources[k].text.split(/\r\n|\n|\r/g); + break; + } + } + var s2 = this.location.start; + var loc = this.location.source + ":" + s2.line + ":" + s2.column; + if (src) { + var e = this.location.end; + var filler = peg$padEnd("", s2.line.toString().length, " "); + var line3 = src[s2.line - 1]; + var last = s2.line === e.line ? e.column : line3.length + 1; + var hatLen = last - s2.column || 1; + str += "\n --> " + loc + "\n" + filler + " |\n" + s2.line + " | " + line3 + "\n" + filler + " | " + peg$padEnd("", s2.column - 1, " ") + peg$padEnd("", hatLen, "^"); + } else { + str += "\n at " + loc; + } + } + return str; + }; + peg$SyntaxError.buildMessage = function(expected, found) { + var DESCRIBE_EXPECTATION_FNS = { + literal: function(expectation) { + return '"' + literalEscape(expectation.text) + '"'; + }, + class: function(expectation) { + var escapedParts = expectation.parts.map(function(part) { + return Array.isArray(part) ? classEscape(part[0]) + "-" + classEscape(part[1]) : classEscape(part); + }); + return "[" + (expectation.inverted ? "^" : "") + escapedParts.join("") + "]"; + }, + any: function() { + return "any character"; + }, + end: function() { + return "end of input"; + }, + other: function(expectation) { + return expectation.description; + } + }; + function hex(ch) { + return ch.charCodeAt(0).toString(16).toUpperCase(); + } + function literalEscape(s2) { + return s2.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\0/g, "\\0").replace(/\t/g, "\\t").replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/[\x00-\x0F]/g, function(ch) { + return "\\x0" + hex(ch); + }).replace(/[\x10-\x1F\x7F-\x9F]/g, function(ch) { + return "\\x" + hex(ch); + }); + } + function classEscape(s2) { + return s2.replace(/\\/g, "\\\\").replace(/\]/g, "\\]").replace(/\^/g, "\\^").replace(/-/g, "\\-").replace(/\0/g, "\\0").replace(/\t/g, "\\t").replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/[\x00-\x0F]/g, function(ch) { + return "\\x0" + hex(ch); + }).replace(/[\x10-\x1F\x7F-\x9F]/g, function(ch) { + return "\\x" + hex(ch); + }); + } + function describeExpectation(expectation) { + return DESCRIBE_EXPECTATION_FNS[expectation.type](expectation); + } + function describeExpected(expected2) { + var descriptions = expected2.map(describeExpectation); + var i, j; + descriptions.sort(); + if (descriptions.length > 0) { + for (i = 1, j = 1; i < descriptions.length; i++) { + if (descriptions[i - 1] !== descriptions[i]) { + descriptions[j] = descriptions[i]; + j++; + } + } + descriptions.length = j; + } + switch (descriptions.length) { + case 1: + return descriptions[0]; + case 2: + return descriptions[0] + " or " + descriptions[1]; + default: + return descriptions.slice(0, -1).join(", ") + ", or " + descriptions[descriptions.length - 1]; + } + } + function describeFound(found2) { + return found2 ? '"' + literalEscape(found2) + '"' : "end of input"; + } + return "Expected " + describeExpected(expected) + " but " + describeFound(found) + " found."; + }; + function peg$parse(input, options2) { + options2 = options2 !== void 0 ? options2 : {}; + var peg$FAILED = {}; + var peg$source = options2.grammarSource; + var peg$startRuleFunctions = { body: peg$parsebody }; + var peg$startRuleFunction = peg$parsebody; + var peg$e0 = peg$anyExpectation(); + var peg$f0 = function(e) { + return [].concat(...e).filter((n) => !!n); + }; + var peg$f1 = function() { + return []; + }; + var peg$f2 = function(tok) { + return options2.isHash(tok); + }; + var peg$f3 = function(tok) { + return tok; + }; + var peg$f4 = function(tok) { + return options2.isNumber(tok); + }; + var peg$f5 = function(tok) { + return tok; + }; + var peg$f6 = function() { + return { type: "string", content: "#" }; + }; + var peg$f7 = function(num) { + const split = options2.splitNumber(num); + return [{ type: "hash_number", number: split.number }, split.rest]; + }; + var peg$currPos = 0; + var peg$posDetailsCache = [{ line: 1, column: 1 }]; + var peg$maxFailPos = 0; + var peg$maxFailExpected = []; + var peg$silentFails = 0; + var peg$result; + if ("startRule" in options2) { + if (!(options2.startRule in peg$startRuleFunctions)) { + throw new Error(`Can't start parsing from rule "` + options2.startRule + '".'); + } + peg$startRuleFunction = peg$startRuleFunctions[options2.startRule]; + } + function peg$anyExpectation() { + return { type: "any" }; + } + function peg$endExpectation() { + return { type: "end" }; + } + function peg$computePosDetails(pos) { + var details = peg$posDetailsCache[pos]; + var p; + if (details) { + return details; + } else { + p = pos - 1; + while (!peg$posDetailsCache[p]) { + p--; + } + details = peg$posDetailsCache[p]; + details = { + line: details.line, + column: details.column + }; + while (p < pos) { + if (input.charCodeAt(p) === 10) { + details.line++; + details.column = 1; + } else { + details.column++; + } + p++; + } + peg$posDetailsCache[pos] = details; + return details; + } + } + function peg$computeLocation(startPos, endPos) { + var startPosDetails = peg$computePosDetails(startPos); + var endPosDetails = peg$computePosDetails(endPos); + return { + source: peg$source, + start: { + offset: startPos, + line: startPosDetails.line, + column: startPosDetails.column + }, + end: { + offset: endPos, + line: endPosDetails.line, + column: endPosDetails.column + } + }; + } + function peg$fail(expected2) { + if (peg$currPos < peg$maxFailPos) { + return; + } + if (peg$currPos > peg$maxFailPos) { + peg$maxFailPos = peg$currPos; + peg$maxFailExpected = []; + } + peg$maxFailExpected.push(expected2); + } + function peg$buildStructuredError(expected2, found, location2) { + return new peg$SyntaxError( + peg$SyntaxError.buildMessage(expected2, found), + expected2, + found, + location2 + ); + } + function peg$parsebody() { + var s0, s1, s2; + s0 = peg$currPos; + s1 = []; + s2 = peg$parsedouble_hash(); + if (s2 === peg$FAILED) { + s2 = peg$parsehash_number(); + if (s2 === peg$FAILED) { + if (input.length > peg$currPos) { + s2 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + } + } + if (s2 !== peg$FAILED) { + while (s2 !== peg$FAILED) { + s1.push(s2); + s2 = peg$parsedouble_hash(); + if (s2 === peg$FAILED) { + s2 = peg$parsehash_number(); + if (s2 === peg$FAILED) { + if (input.length > peg$currPos) { + s2 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + } + } + } + } else { + s1 = peg$FAILED; + } + if (s1 !== peg$FAILED) { + s1 = peg$f0(s1); + } + s0 = s1; + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$parseEOL(); + if (s1 !== peg$FAILED) { + s1 = peg$f1(); + } + s0 = s1; + } + return s0; + } + function peg$parsehash() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f2(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s0 = peg$f3(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsenumber() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f4(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s0 = peg$f5(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsedouble_hash() { + var s0, s1, s2; + s0 = peg$currPos; + s1 = peg$parsehash(); + if (s1 !== peg$FAILED) { + s2 = peg$parsehash(); + if (s2 !== peg$FAILED) { + s0 = peg$f6(); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsehash_number() { + var s0, s1, s2; + s0 = peg$currPos; + s1 = peg$parsehash(); + if (s1 !== peg$FAILED) { + s2 = peg$parsenumber(); + if (s2 !== peg$FAILED) { + s0 = peg$f7(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parseEOL() { + var s0, s1; + s0 = peg$currPos; + peg$silentFails++; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + peg$silentFails--; + if (s1 === peg$FAILED) { + s0 = void 0; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + if (!options2.isHash) { + try { + Object.assign(options2, { + isHash: (node) => node.type === "string" && node.content === "#", + isNumber: (node) => node.type === "string" && 0 < +node.content.charAt(0), + splitNumber: (node) => { + const number = +node.content.charAt(0); + if (node.content.length > 1) { + return { + number, + rest: { + type: "string", + content: node.content.slice(1) + } + }; + } + return { number }; + } + }); + } catch (e) { + console.warn("Error when initializing parser", e); + } + } + peg$result = peg$startRuleFunction(); + if (peg$result !== peg$FAILED && peg$currPos === input.length) { + return peg$result; + } else { + if (peg$result !== peg$FAILED && peg$currPos < input.length) { + peg$fail(peg$endExpectation()); + } + throw peg$buildStructuredError( + peg$maxFailExpected, + peg$maxFailPos < input.length ? input.charAt(peg$maxFailPos) : null, + peg$maxFailPos < input.length ? peg$computeLocation(peg$maxFailPos, peg$maxFailPos + 1) : peg$computeLocation(peg$maxFailPos, peg$maxFailPos) + ); + } + } + return { + SyntaxError: peg$SyntaxError, + parse: peg$parse + }; +})(); +// Generated by Peggy 2.0.1. +// +// https://peggyjs.org/ +(function() { + function peg$subclass(child, parent) { + function C() { + this.constructor = child; + } + C.prototype = parent.prototype; + child.prototype = new C(); + } + function peg$SyntaxError(message, expected, found, location) { + var self = Error.call(this, message); + if (Object.setPrototypeOf) { + Object.setPrototypeOf(self, peg$SyntaxError.prototype); + } + self.expected = expected; + self.found = found; + self.location = location; + self.name = "SyntaxError"; + return self; + } + peg$subclass(peg$SyntaxError, Error); + function peg$padEnd(str, targetLength, padString) { + padString = padString || " "; + if (str.length > targetLength) { + return str; + } + targetLength -= str.length; + padString += padString.repeat(targetLength); + return str + padString.slice(0, targetLength); + } + peg$SyntaxError.prototype.format = function(sources) { + var str = "Error: " + this.message; + if (this.location) { + var src = null; + var k; + for (k = 0; k < sources.length; k++) { + if (sources[k].source === this.location.source) { + src = sources[k].text.split(/\r\n|\n|\r/g); + break; + } + } + var s2 = this.location.start; + var loc = this.location.source + ":" + s2.line + ":" + s2.column; + if (src) { + var e = this.location.end; + var filler = peg$padEnd("", s2.line.toString().length, " "); + var line3 = src[s2.line - 1]; + var last = s2.line === e.line ? e.column : line3.length + 1; + var hatLen = last - s2.column || 1; + str += "\n --> " + loc + "\n" + filler + " |\n" + s2.line + " | " + line3 + "\n" + filler + " | " + peg$padEnd("", s2.column - 1, " ") + peg$padEnd("", hatLen, "^"); + } else { + str += "\n at " + loc; + } + } + return str; + }; + peg$SyntaxError.buildMessage = function(expected, found) { + var DESCRIBE_EXPECTATION_FNS = { + literal: function(expectation) { + return '"' + literalEscape(expectation.text) + '"'; + }, + class: function(expectation) { + var escapedParts = expectation.parts.map(function(part) { + return Array.isArray(part) ? classEscape(part[0]) + "-" + classEscape(part[1]) : classEscape(part); + }); + return "[" + (expectation.inverted ? "^" : "") + escapedParts.join("") + "]"; + }, + any: function() { + return "any character"; + }, + end: function() { + return "end of input"; + }, + other: function(expectation) { + return expectation.description; + } + }; + function hex(ch) { + return ch.charCodeAt(0).toString(16).toUpperCase(); + } + function literalEscape(s2) { + return s2.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\0/g, "\\0").replace(/\t/g, "\\t").replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/[\x00-\x0F]/g, function(ch) { + return "\\x0" + hex(ch); + }).replace(/[\x10-\x1F\x7F-\x9F]/g, function(ch) { + return "\\x" + hex(ch); + }); + } + function classEscape(s2) { + return s2.replace(/\\/g, "\\\\").replace(/\]/g, "\\]").replace(/\^/g, "\\^").replace(/-/g, "\\-").replace(/\0/g, "\\0").replace(/\t/g, "\\t").replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/[\x00-\x0F]/g, function(ch) { + return "\\x0" + hex(ch); + }).replace(/[\x10-\x1F\x7F-\x9F]/g, function(ch) { + return "\\x" + hex(ch); + }); + } + function describeExpectation(expectation) { + return DESCRIBE_EXPECTATION_FNS[expectation.type](expectation); + } + function describeExpected(expected2) { + var descriptions = expected2.map(describeExpectation); + var i, j; + descriptions.sort(); + if (descriptions.length > 0) { + for (i = 1, j = 1; i < descriptions.length; i++) { + if (descriptions[i - 1] !== descriptions[i]) { + descriptions[j] = descriptions[i]; + j++; + } + } + descriptions.length = j; + } + switch (descriptions.length) { + case 1: + return descriptions[0]; + case 2: + return descriptions[0] + " or " + descriptions[1]; + default: + return descriptions.slice(0, -1).join(", ") + ", or " + descriptions[descriptions.length - 1]; + } + } + function describeFound(found2) { + return found2 ? '"' + literalEscape(found2) + '"' : "end of input"; + } + return "Expected " + describeExpected(expected) + " but " + describeFound(found) + " found."; + }; + function peg$parse(input, options2) { + options2 = options2 !== void 0 ? options2 : {}; + var peg$FAILED = {}; + var peg$source = options2.grammarSource; + var peg$startRuleFunctions = { body: peg$parsebody }; + var peg$startRuleFunction = peg$parsebody; + var peg$e0 = peg$anyExpectation(); + var peg$f0 = function(e) { + return [].concat(...e).filter((n) => !!n); + }; + var peg$f1 = function() { + return []; + }; + var peg$f2 = function(toks) { + return options2.isRecognized(toks); + }; + var peg$f3 = function(toks) { + return options2.isRecognized(toks); + }; + var peg$f4 = function(tok1, tok2) { + const split = options2.split(tok2); + return options2.isRecognized([tok1, split[0]]); + }; + var peg$f5 = function(tok1, tok2) { + const split = options2.split(tok2); + return [options2.isRecognized([tok1, split[0]]), split[1]]; + }; + var peg$f6 = function(tok1, tok2) { + return options2.isRecognized([tok1, tok2]); + }; + var peg$f7 = function(tok1, tok2) { + return options2.isRecognized([tok1, tok2]); + }; + var peg$f8 = function(toks) { + return options2.isRecognized(toks); + }; + var peg$f9 = function(toks) { + return options2.isRecognized(toks); + }; + var peg$f10 = function(tok) { + return options2.isRecognized([tok]); + }; + var peg$f11 = function(tok) { + return options2.isRecognized([tok]); + }; + var peg$f12 = function(tok) { + return options2.isMacro(tok); + }; + var peg$f13 = function(tok) { + return tok; + }; + var peg$f14 = function(tok) { + return options2.isWhitespace(tok); + }; + var peg$f15 = function(tok) { + return tok; + }; + var peg$f16 = function(tok) { + return options2.isSplitable(tok); + }; + var peg$f17 = function(tok) { + return tok; + }; + var peg$currPos = 0; + var peg$posDetailsCache = [{ line: 1, column: 1 }]; + var peg$maxFailPos = 0; + var peg$maxFailExpected = []; + var peg$silentFails = 0; + var peg$result; + if ("startRule" in options2) { + if (!(options2.startRule in peg$startRuleFunctions)) { + throw new Error(`Can't start parsing from rule "` + options2.startRule + '".'); + } + peg$startRuleFunction = peg$startRuleFunctions[options2.startRule]; + } + function peg$anyExpectation() { + return { type: "any" }; + } + function peg$endExpectation() { + return { type: "end" }; + } + function peg$computePosDetails(pos) { + var details = peg$posDetailsCache[pos]; + var p; + if (details) { + return details; + } else { + p = pos - 1; + while (!peg$posDetailsCache[p]) { + p--; + } + details = peg$posDetailsCache[p]; + details = { + line: details.line, + column: details.column + }; + while (p < pos) { + if (input.charCodeAt(p) === 10) { + details.line++; + details.column = 1; + } else { + details.column++; + } + p++; + } + peg$posDetailsCache[pos] = details; + return details; + } + } + function peg$computeLocation(startPos, endPos) { + var startPosDetails = peg$computePosDetails(startPos); + var endPosDetails = peg$computePosDetails(endPos); + return { + source: peg$source, + start: { + offset: startPos, + line: startPosDetails.line, + column: startPosDetails.column + }, + end: { + offset: endPos, + line: endPosDetails.line, + column: endPosDetails.column + } + }; + } + function peg$fail(expected2) { + if (peg$currPos < peg$maxFailPos) { + return; + } + if (peg$currPos > peg$maxFailPos) { + peg$maxFailPos = peg$currPos; + peg$maxFailExpected = []; + } + peg$maxFailExpected.push(expected2); + } + function peg$buildStructuredError(expected2, found, location2) { + return new peg$SyntaxError( + peg$SyntaxError.buildMessage(expected2, found), + expected2, + found, + location2 + ); + } + function peg$parsebody() { + var s0, s1, s2; + s0 = peg$currPos; + s1 = []; + s2 = peg$parsetriple_ligature(); + if (s2 === peg$FAILED) { + s2 = peg$parsedouble_ligature(); + if (s2 === peg$FAILED) { + s2 = peg$parsemono_ligature(); + if (s2 === peg$FAILED) { + if (input.length > peg$currPos) { + s2 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + } + } + } + if (s2 !== peg$FAILED) { + while (s2 !== peg$FAILED) { + s1.push(s2); + s2 = peg$parsetriple_ligature(); + if (s2 === peg$FAILED) { + s2 = peg$parsedouble_ligature(); + if (s2 === peg$FAILED) { + s2 = peg$parsemono_ligature(); + if (s2 === peg$FAILED) { + if (input.length > peg$currPos) { + s2 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + } + } + } + } + } else { + s1 = peg$FAILED; + } + if (s1 !== peg$FAILED) { + s1 = peg$f0(s1); + } + s0 = s1; + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$parseEOL(); + if (s1 !== peg$FAILED) { + s1 = peg$f1(); + } + s0 = s1; + } + return s0; + } + function peg$parsetriple_ligature() { + var s0, s1, s2, s3, s4; + s0 = peg$currPos; + s1 = peg$currPos; + if (input.length > peg$currPos) { + s2 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s2 !== peg$FAILED) { + if (input.length > peg$currPos) { + s3 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s3 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s3 !== peg$FAILED) { + if (input.length > peg$currPos) { + s4 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s4 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s4 !== peg$FAILED) { + s2 = [s2, s3, s4]; + s1 = s2; + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + if (s1 !== peg$FAILED) { + s2 = peg$f2(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s0 = peg$f3(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsedouble_ligature() { + var s0; + s0 = peg$parsedouble_macro_ligature(); + if (s0 === peg$FAILED) { + s0 = peg$parsedouble_macro_ligature_extracted(); + if (s0 === peg$FAILED) { + s0 = peg$parsedouble_char_ligature(); + } + } + return s0; + } + function peg$parsedouble_macro_ligature_extracted() { + var s0, s1, s2, s3, s4; + s0 = peg$currPos; + s1 = peg$parsemacro(); + if (s1 !== peg$FAILED) { + s2 = []; + s3 = peg$parsewhitespace(); + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$parsewhitespace(); + } + s3 = peg$parsesplitable(); + if (s3 !== peg$FAILED) { + s4 = peg$f4(s1, s3); + if (s4) { + s4 = void 0; + } else { + s4 = peg$FAILED; + } + if (s4 !== peg$FAILED) { + s0 = peg$f5(s1, s3); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsedouble_macro_ligature() { + var s0, s1, s2, s3, s4; + s0 = peg$currPos; + s1 = peg$parsemacro(); + if (s1 !== peg$FAILED) { + s2 = []; + s3 = peg$parsewhitespace(); + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$parsewhitespace(); + } + if (input.length > peg$currPos) { + s3 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s3 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s3 !== peg$FAILED) { + s4 = peg$f6(s1, s3); + if (s4) { + s4 = void 0; + } else { + s4 = peg$FAILED; + } + if (s4 !== peg$FAILED) { + s0 = peg$f7(s1, s3); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsedouble_char_ligature() { + var s0, s1, s2, s3; + s0 = peg$currPos; + s1 = peg$currPos; + if (input.length > peg$currPos) { + s2 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s2 !== peg$FAILED) { + if (input.length > peg$currPos) { + s3 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s3 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s3 !== peg$FAILED) { + s2 = [s2, s3]; + s1 = s2; + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + if (s1 !== peg$FAILED) { + s2 = peg$f8(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s0 = peg$f9(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsemono_ligature() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f10(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s0 = peg$f11(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsemacro() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f12(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s0 = peg$f13(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsewhitespace() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f14(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s0 = peg$f15(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsesplitable() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f16(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s0 = peg$f17(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parseEOL() { + var s0, s1; + s0 = peg$currPos; + peg$silentFails++; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + peg$silentFails--; + if (s1 === peg$FAILED) { + s0 = void 0; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + if (!options2.isWhitespace) { + try { + Object.assign(options2, { + isMacro: (node) => node.type === "macro", + isWhitespace: (node) => node.type === "whitespace", + isRecognized: (nodes) => { + if (nodes.length == 2 && nodes[0].content === "^" && nodes[1].content === "o") { + return { type: "string", content: "ô" }; + } + return null; + }, + isSplitable: (node) => node.type === "string" && node.content.length > 1, + split: (node) => [ + { type: "string", content: node.content.charAt(0) }, + { type: "string", content: node.content.slice(1) } + ] + }); + } catch (e) { + console.warn("Error when initializing parser", e); + } + } + peg$result = peg$startRuleFunction(); + if (peg$result !== peg$FAILED && peg$currPos === input.length) { + return peg$result; + } else { + if (peg$result !== peg$FAILED && peg$currPos < input.length) { + peg$fail(peg$endExpectation()); + } + throw peg$buildStructuredError( + peg$maxFailExpected, + peg$maxFailPos < input.length ? input.charAt(peg$maxFailPos) : null, + peg$maxFailPos < input.length ? peg$computeLocation(peg$maxFailPos, peg$maxFailPos + 1) : peg$computeLocation(peg$maxFailPos, peg$maxFailPos) + ); + } + } + return { + SyntaxError: peg$SyntaxError, + parse: peg$parse + }; +})(); +// Generated by Peggy 2.0.1. +// +// https://peggyjs.org/ +(function() { + function peg$subclass(child, parent) { + function C() { + this.constructor = child; + } + C.prototype = parent.prototype; + child.prototype = new C(); + } + function peg$SyntaxError(message, expected, found, location) { + var self = Error.call(this, message); + if (Object.setPrototypeOf) { + Object.setPrototypeOf(self, peg$SyntaxError.prototype); + } + self.expected = expected; + self.found = found; + self.location = location; + self.name = "SyntaxError"; + return self; + } + peg$subclass(peg$SyntaxError, Error); + function peg$padEnd(str, targetLength, padString) { + padString = padString || " "; + if (str.length > targetLength) { + return str; + } + targetLength -= str.length; + padString += padString.repeat(targetLength); + return str + padString.slice(0, targetLength); + } + peg$SyntaxError.prototype.format = function(sources) { + var str = "Error: " + this.message; + if (this.location) { + var src = null; + var k; + for (k = 0; k < sources.length; k++) { + if (sources[k].source === this.location.source) { + src = sources[k].text.split(/\r\n|\n|\r/g); + break; + } + } + var s2 = this.location.start; + var loc = this.location.source + ":" + s2.line + ":" + s2.column; + if (src) { + var e = this.location.end; + var filler = peg$padEnd("", s2.line.toString().length, " "); + var line3 = src[s2.line - 1]; + var last = s2.line === e.line ? e.column : line3.length + 1; + var hatLen = last - s2.column || 1; + str += "\n --> " + loc + "\n" + filler + " |\n" + s2.line + " | " + line3 + "\n" + filler + " | " + peg$padEnd("", s2.column - 1, " ") + peg$padEnd("", hatLen, "^"); + } else { + str += "\n at " + loc; + } + } + return str; + }; + peg$SyntaxError.buildMessage = function(expected, found) { + var DESCRIBE_EXPECTATION_FNS = { + literal: function(expectation) { + return '"' + literalEscape(expectation.text) + '"'; + }, + class: function(expectation) { + var escapedParts = expectation.parts.map(function(part) { + return Array.isArray(part) ? classEscape(part[0]) + "-" + classEscape(part[1]) : classEscape(part); + }); + return "[" + (expectation.inverted ? "^" : "") + escapedParts.join("") + "]"; + }, + any: function() { + return "any character"; + }, + end: function() { + return "end of input"; + }, + other: function(expectation) { + return expectation.description; + } + }; + function hex(ch) { + return ch.charCodeAt(0).toString(16).toUpperCase(); + } + function literalEscape(s2) { + return s2.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\0/g, "\\0").replace(/\t/g, "\\t").replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/[\x00-\x0F]/g, function(ch) { + return "\\x0" + hex(ch); + }).replace(/[\x10-\x1F\x7F-\x9F]/g, function(ch) { + return "\\x" + hex(ch); + }); + } + function classEscape(s2) { + return s2.replace(/\\/g, "\\\\").replace(/\]/g, "\\]").replace(/\^/g, "\\^").replace(/-/g, "\\-").replace(/\0/g, "\\0").replace(/\t/g, "\\t").replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/[\x00-\x0F]/g, function(ch) { + return "\\x0" + hex(ch); + }).replace(/[\x10-\x1F\x7F-\x9F]/g, function(ch) { + return "\\x" + hex(ch); + }); + } + function describeExpectation(expectation) { + return DESCRIBE_EXPECTATION_FNS[expectation.type](expectation); + } + function describeExpected(expected2) { + var descriptions = expected2.map(describeExpectation); + var i, j; + descriptions.sort(); + if (descriptions.length > 0) { + for (i = 1, j = 1; i < descriptions.length; i++) { + if (descriptions[i - 1] !== descriptions[i]) { + descriptions[j] = descriptions[i]; + j++; + } + } + descriptions.length = j; + } + switch (descriptions.length) { + case 1: + return descriptions[0]; + case 2: + return descriptions[0] + " or " + descriptions[1]; + default: + return descriptions.slice(0, -1).join(", ") + ", or " + descriptions[descriptions.length - 1]; + } + } + function describeFound(found2) { + return found2 ? '"' + literalEscape(found2) + '"' : "end of input"; + } + return "Expected " + describeExpected(expected) + " but " + describeFound(found) + " found."; + }; + function peg$parse(input, options2) { + options2 = options2 !== void 0 ? options2 : {}; + var peg$FAILED = {}; + var peg$source = options2.grammarSource; + var peg$startRuleFunctions = { start: peg$parsestart }; + var peg$startRuleFunction = peg$parsestart; + var peg$c0 = ";"; + var peg$c1 = ","; + var peg$c2 = ":"; + var peg$c3 = "/"; + var peg$c4 = ">"; + var peg$c5 = "!"; + var peg$c6 = "."; + var peg$c7 = "!!["; + var peg$c8 = "]"; + var peg$c9 = "!!"; + var peg$c10 = "+"; + var peg$c11 = "-"; + var peg$r0 = /^[a-zA-Z0-9]/; + var peg$r1 = /^[0-9]/; + var peg$r2 = /^[ \t\n\r]/; + var peg$r3 = /^[0-9a-fA-F]/; + var peg$e0 = peg$anyExpectation(); + var peg$e1 = peg$literalExpectation(";", false); + var peg$e2 = peg$literalExpectation(",", false); + var peg$e3 = peg$otherExpectation("model list"); + var peg$e4 = peg$literalExpectation(":", false); + var peg$e5 = peg$literalExpectation("/", false); + var peg$e6 = peg$otherExpectation("model"); + var peg$e7 = peg$otherExpectation("color spec list"); + var peg$e8 = peg$otherExpectation("color spec"); + var peg$e9 = peg$otherExpectation("color"); + var peg$e10 = peg$otherExpectation("function expression"); + var peg$e11 = peg$literalExpectation(">", false); + var peg$e12 = peg$otherExpectation("function"); + var peg$e13 = peg$otherExpectation("extended expression"); + var peg$e14 = peg$otherExpectation("core model"); + var peg$e15 = peg$otherExpectation("expr"); + var peg$e16 = peg$literalExpectation("!", false); + var peg$e17 = peg$otherExpectation("mix expr"); + var peg$e18 = peg$otherExpectation("name"); + var peg$e19 = peg$literalExpectation(".", false); + var peg$e20 = peg$classExpectation([["a", "z"], ["A", "Z"], ["0", "9"]], false, false); + var peg$e21 = peg$otherExpectation("postfix"); + var peg$e22 = peg$literalExpectation("!![", false); + var peg$e23 = peg$literalExpectation("]", false); + var peg$e24 = peg$literalExpectation("!!", false); + var peg$e25 = peg$otherExpectation("prefix"); + var peg$e26 = peg$otherExpectation("plus"); + var peg$e27 = peg$literalExpectation("+", false); + var peg$e28 = peg$otherExpectation("minus"); + var peg$e29 = peg$literalExpectation("-", false); + var peg$e30 = peg$otherExpectation("num"); + var peg$e31 = peg$classExpectation([["0", "9"]], false, false); + var peg$e32 = peg$otherExpectation("positive float"); + var peg$e33 = peg$otherExpectation("divisor"); + var peg$e34 = peg$otherExpectation("int"); + var peg$e36 = peg$classExpectation([" ", " ", "\n", "\r"], false, false); + var peg$e37 = peg$classExpectation([["0", "9"], ["a", "f"], ["A", "F"]], false, false); + var peg$f0 = function(m) { + return m; + }; + var peg$f1 = function(m) { + return m; + }; + var peg$f2 = function(m) { + return m; + }; + var peg$f3 = function(m) { + return m; + }; + var peg$f4 = function(m) { + return m; + }; + var peg$f5 = function(a) { + return { type: "invalid_spec", content: a }; + }; + var peg$f6 = function(f, c) { + return c; + }; + var peg$f7 = function(f, r) { + return { type: "color_set", content: [f].concat(r) }; + }; + var peg$f8 = function(n, s2) { + return { type: "color_set_item", name: n, spec_list: s2 }; + }; + var peg$f9 = function(c, m) { + return { type: "model_list", contents: m, core_model: c }; + }; + var peg$f10 = function(m) { + return { type: "model_list", contents: m, core_model: null }; + }; + var peg$f11 = function(m, a) { + return a; + }; + var peg$f12 = function(m, r) { + return [m].concat(r); + }; + var peg$f13 = function(s2, a) { + return a; + }; + var peg$f14 = function(s2, r) { + return { type: "spec_list", content: [s2].concat(r) }; + }; + var peg$f15 = function(c) { + return { type: "hex_spec", content: [c] }; + }; + var peg$f16 = function(c, d) { + return d; + }; + var peg$f17 = function(c, d) { + return d; + }; + var peg$f18 = function(c, r) { + return { type: "num_spec", content: r ? [c].concat(r) : [c] }; + }; + var peg$f19 = function(c, fs) { + return { type: "color", color: c, functions: fs }; + }; + var peg$f20 = function(f, n) { + return n; + }; + var peg$f21 = function(f, args) { + return { type: "function", name: f, args }; + }; + var peg$f22 = function(core, d, e, es) { + return { + type: "extended_expr", + core_model: core, + div: d, + expressions: [e].concat(es) + }; + }; + var peg$f23 = function(core, e, es) { + return { + type: "extended_expr", + core_model: core, + div: null, + expressions: [e].concat(es) + }; + }; + var peg$f24 = function(e, d) { + return { type: "weighted_expr", color: e, weight: d }; + }; + var peg$f25 = function(e) { + return e; + }; + var peg$f26 = function(p, n, e, po) { + return { + type: "expr", + prefix: p, + name: n, + mix_expr: e, + postfix: po + }; + }; + var peg$f27 = function(p, n) { + return { type: "complete_mix", mix_percent: p, name: n }; + }; + var peg$f28 = function(p) { + return { type: "partial_mix", mix_percent: p }; + }; + var peg$f29 = function(c, p) { + return c.concat(p || []); + }; + var peg$f30 = function(n) { + return { type: "postfix", num: n }; + }; + var peg$f31 = function(p) { + return { type: "postfix", plusses: p }; + }; + var peg$f32 = function(n) { + return parseInt(n, 10); + }; + var peg$f33 = function(n) { + return parseFloat(n); + }; + var peg$f34 = function(n) { + return n; + }; + var peg$f35 = function(n) { + return -n; + }; + var peg$f36 = function(m, n) { + return m ? -n : n; + }; + var peg$f37 = function(h) { + return h.toUpperCase(); + }; + var peg$currPos = 0; + var peg$posDetailsCache = [{ line: 1, column: 1 }]; + var peg$maxFailPos = 0; + var peg$maxFailExpected = []; + var peg$silentFails = 0; + var peg$result; + if ("startRule" in options2) { + if (!(options2.startRule in peg$startRuleFunctions)) { + throw new Error(`Can't start parsing from rule "` + options2.startRule + '".'); + } + peg$startRuleFunction = peg$startRuleFunctions[options2.startRule]; + } + function peg$literalExpectation(text2, ignoreCase) { + return { type: "literal", text: text2, ignoreCase }; + } + function peg$classExpectation(parts, inverted, ignoreCase) { + return { type: "class", parts, inverted, ignoreCase }; + } + function peg$anyExpectation() { + return { type: "any" }; + } + function peg$endExpectation() { + return { type: "end" }; + } + function peg$otherExpectation(description) { + return { type: "other", description }; + } + function peg$computePosDetails(pos) { + var details = peg$posDetailsCache[pos]; + var p; + if (details) { + return details; + } else { + p = pos - 1; + while (!peg$posDetailsCache[p]) { + p--; + } + details = peg$posDetailsCache[p]; + details = { + line: details.line, + column: details.column + }; + while (p < pos) { + if (input.charCodeAt(p) === 10) { + details.line++; + details.column = 1; + } else { + details.column++; + } + p++; + } + peg$posDetailsCache[pos] = details; + return details; + } + } + function peg$computeLocation(startPos, endPos) { + var startPosDetails = peg$computePosDetails(startPos); + var endPosDetails = peg$computePosDetails(endPos); + return { + source: peg$source, + start: { + offset: startPos, + line: startPosDetails.line, + column: startPosDetails.column + }, + end: { + offset: endPos, + line: endPosDetails.line, + column: endPosDetails.column + } + }; + } + function peg$fail(expected2) { + if (peg$currPos < peg$maxFailPos) { + return; + } + if (peg$currPos > peg$maxFailPos) { + peg$maxFailPos = peg$currPos; + peg$maxFailExpected = []; + } + peg$maxFailExpected.push(expected2); + } + function peg$buildStructuredError(expected2, found, location2) { + return new peg$SyntaxError( + peg$SyntaxError.buildMessage(expected2, found), + expected2, + found, + location2 + ); + } + function peg$parsestart() { + var s0, s1, s2, s3; + s0 = peg$currPos; + s1 = peg$parsespec(); + if (s1 !== peg$FAILED) { + s2 = peg$parseEOL(); + if (s2 !== peg$FAILED) { + s0 = peg$f0(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$parsespec_list(); + if (s1 !== peg$FAILED) { + s2 = peg$parseEOL(); + if (s2 !== peg$FAILED) { + s0 = peg$f1(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$parsecolor(); + if (s1 !== peg$FAILED) { + s2 = peg$parseEOL(); + if (s2 !== peg$FAILED) { + s0 = peg$f2(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$parsemodel_list(); + if (s1 !== peg$FAILED) { + s2 = peg$parseEOL(); + if (s2 !== peg$FAILED) { + s0 = peg$f3(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$parsecolor_set_spec(); + if (s1 !== peg$FAILED) { + s2 = peg$parseEOL(); + if (s2 !== peg$FAILED) { + s0 = peg$f4(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$currPos; + s2 = []; + if (input.length > peg$currPos) { + s3 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s3 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + while (s3 !== peg$FAILED) { + s2.push(s3); + if (input.length > peg$currPos) { + s3 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s3 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + } + s1 = input.substring(s1, peg$currPos); + s1 = peg$f5(s1); + s0 = s1; + } + } + } + } + } + return s0; + } + function peg$parsecolor_set_spec() { + var s0, s1, s2, s3, s4, s5; + s0 = peg$currPos; + s1 = peg$parsecolor_set_item(); + if (s1 !== peg$FAILED) { + s2 = []; + s3 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 59) { + s4 = peg$c0; + peg$currPos++; + } else { + s4 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e1); + } + } + if (s4 !== peg$FAILED) { + s5 = peg$parsecolor_set_item(); + if (s5 !== peg$FAILED) { + s3 = peg$f6(s1, s5); + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 59) { + s4 = peg$c0; + peg$currPos++; + } else { + s4 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e1); + } + } + if (s4 !== peg$FAILED) { + s5 = peg$parsecolor_set_item(); + if (s5 !== peg$FAILED) { + s3 = peg$f6(s1, s5); + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } + s0 = peg$f7(s1, s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsecolor_set_item() { + var s0, s1, s2, s3; + s0 = peg$currPos; + s1 = peg$parsename(); + if (s1 !== peg$FAILED) { + if (input.charCodeAt(peg$currPos) === 44) { + s2 = peg$c1; + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e2); + } + } + if (s2 !== peg$FAILED) { + s3 = peg$parsespec_list(); + if (s3 !== peg$FAILED) { + s0 = peg$f8(s1, s3); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsemodel_list() { + var s0, s1, s2, s3; + peg$silentFails++; + s0 = peg$currPos; + s1 = peg$parsecore_model(); + if (s1 !== peg$FAILED) { + if (input.charCodeAt(peg$currPos) === 58) { + s2 = peg$c2; + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e4); + } + } + if (s2 !== peg$FAILED) { + s3 = peg$parsemodel_list_tail(); + if (s3 !== peg$FAILED) { + s0 = peg$f9(s1, s3); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$parsemodel_list_tail(); + if (s1 !== peg$FAILED) { + s1 = peg$f10(s1); + } + s0 = s1; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + return s0; + } + function peg$parsemodel_list_tail() { + var s0, s1, s2, s3, s4, s5; + s0 = peg$currPos; + s1 = peg$parsemodel(); + if (s1 !== peg$FAILED) { + s2 = []; + s3 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 47) { + s4 = peg$c3; + peg$currPos++; + } else { + s4 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e5); + } + } + if (s4 !== peg$FAILED) { + s5 = peg$parsemodel(); + if (s5 !== peg$FAILED) { + s3 = peg$f11(s1, s5); + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 47) { + s4 = peg$c3; + peg$currPos++; + } else { + s4 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e5); + } + } + if (s4 !== peg$FAILED) { + s5 = peg$parsemodel(); + if (s5 !== peg$FAILED) { + s3 = peg$f11(s1, s5); + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } + s0 = peg$f12(s1, s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsemodel() { + var s0; + peg$silentFails++; + s0 = peg$parsecore_model(); + peg$silentFails--; + if (s0 === peg$FAILED) { + if (peg$silentFails === 0) { + peg$fail(peg$e6); + } + } + return s0; + } + function peg$parsespec_list() { + var s0, s1, s2, s3, s4, s5; + peg$silentFails++; + s0 = peg$currPos; + s1 = peg$parsespec(); + if (s1 !== peg$FAILED) { + s2 = []; + s3 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 47) { + s4 = peg$c3; + peg$currPos++; + } else { + s4 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e5); + } + } + if (s4 !== peg$FAILED) { + s5 = peg$parsespec(); + if (s5 !== peg$FAILED) { + s3 = peg$f13(s1, s5); + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 47) { + s4 = peg$c3; + peg$currPos++; + } else { + s4 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e5); + } + } + if (s4 !== peg$FAILED) { + s5 = peg$parsespec(); + if (s5 !== peg$FAILED) { + s3 = peg$f13(s1, s5); + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } + s0 = peg$f14(s1, s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e7); + } + } + return s0; + } + function peg$parsespec() { + var s0, s1, s2, s3, s4, s5, s6, s7, s8; + peg$silentFails++; + s0 = peg$currPos; + s1 = peg$currPos; + s2 = peg$currPos; + s3 = peg$parsehex(); + if (s3 !== peg$FAILED) { + s4 = peg$parsehex(); + if (s4 !== peg$FAILED) { + s5 = peg$parsehex(); + if (s5 !== peg$FAILED) { + s6 = peg$parsehex(); + if (s6 !== peg$FAILED) { + s7 = peg$parsehex(); + if (s7 !== peg$FAILED) { + s8 = peg$parsehex(); + if (s8 !== peg$FAILED) { + s3 = [s3, s4, s5, s6, s7, s8]; + s2 = s3; + } else { + peg$currPos = s2; + s2 = peg$FAILED; + } + } else { + peg$currPos = s2; + s2 = peg$FAILED; + } + } else { + peg$currPos = s2; + s2 = peg$FAILED; + } + } else { + peg$currPos = s2; + s2 = peg$FAILED; + } + } else { + peg$currPos = s2; + s2 = peg$FAILED; + } + } else { + peg$currPos = s2; + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s1 = input.substring(s1, peg$currPos); + } else { + s1 = s2; + } + if (s1 !== peg$FAILED) { + s1 = peg$f15(s1); + } + s0 = s1; + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$parsedec(); + if (s1 !== peg$FAILED) { + s2 = []; + s3 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 44) { + s4 = peg$c1; + peg$currPos++; + } else { + s4 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e2); + } + } + if (s4 !== peg$FAILED) { + s5 = peg$parsedec(); + if (s5 !== peg$FAILED) { + s3 = peg$f16(s1, s5); + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + if (s3 !== peg$FAILED) { + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 44) { + s4 = peg$c1; + peg$currPos++; + } else { + s4 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e2); + } + } + if (s4 !== peg$FAILED) { + s5 = peg$parsedec(); + if (s5 !== peg$FAILED) { + s3 = peg$f16(s1, s5); + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } + } else { + s2 = peg$FAILED; + } + if (s2 === peg$FAILED) { + s2 = []; + s3 = peg$currPos; + s4 = peg$parsesp(); + if (s4 !== peg$FAILED) { + s5 = peg$parsedec(); + if (s5 !== peg$FAILED) { + s3 = peg$f17(s1, s5); + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + if (s3 !== peg$FAILED) { + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$currPos; + s4 = peg$parsesp(); + if (s4 !== peg$FAILED) { + s5 = peg$parsedec(); + if (s5 !== peg$FAILED) { + s3 = peg$f17(s1, s5); + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } + } else { + s2 = peg$FAILED; + } + } + if (s2 === peg$FAILED) { + s2 = null; + } + s0 = peg$f18(s1, s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e8); + } + } + return s0; + } + function peg$parsecolor() { + var s0, s1, s2, s3; + peg$silentFails++; + s0 = peg$currPos; + s1 = peg$parsecolor_expr(); + if (s1 !== peg$FAILED) { + s2 = []; + s3 = peg$parsefunc_expr(); + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$parsefunc_expr(); + } + s0 = peg$f19(s1, s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e9); + } + } + return s0; + } + function peg$parsecolor_expr() { + var s0; + s0 = peg$parseext_expr(); + if (s0 === peg$FAILED) { + s0 = peg$parseexpr(); + if (s0 === peg$FAILED) { + s0 = peg$parsename(); + } + } + return s0; + } + function peg$parsefunc_expr() { + var s0, s1, s2, s3, s4, s5, s6; + peg$silentFails++; + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 62) { + s1 = peg$c4; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e11); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$parsefunction(); + if (s2 !== peg$FAILED) { + s3 = []; + s4 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 44) { + s5 = peg$c1; + peg$currPos++; + } else { + s5 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e2); + } + } + if (s5 !== peg$FAILED) { + s6 = peg$parseint(); + if (s6 !== peg$FAILED) { + s4 = peg$f20(s2, s6); + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + while (s4 !== peg$FAILED) { + s3.push(s4); + s4 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 44) { + s5 = peg$c1; + peg$currPos++; + } else { + s5 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e2); + } + } + if (s5 !== peg$FAILED) { + s6 = peg$parseint(); + if (s6 !== peg$FAILED) { + s4 = peg$f20(s2, s6); + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + } + s0 = peg$f21(s2, s3); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e10); + } + } + return s0; + } + function peg$parsefunction() { + var s0; + peg$silentFails++; + s0 = peg$parsename(); + peg$silentFails--; + if (s0 === peg$FAILED) { + if (peg$silentFails === 0) { + peg$fail(peg$e12); + } + } + return s0; + } + function peg$parseext_expr() { + var s0, s1, s2, s3, s4, s5, s6, s7; + peg$silentFails++; + s0 = peg$currPos; + s1 = peg$parsecore_model(); + if (s1 !== peg$FAILED) { + if (input.charCodeAt(peg$currPos) === 44) { + s2 = peg$c1; + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e2); + } + } + if (s2 !== peg$FAILED) { + s3 = peg$parsediv(); + if (s3 !== peg$FAILED) { + if (input.charCodeAt(peg$currPos) === 58) { + s4 = peg$c2; + peg$currPos++; + } else { + s4 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e4); + } + } + if (s4 !== peg$FAILED) { + s5 = peg$parseweighted_expr(); + if (s5 !== peg$FAILED) { + s6 = []; + s7 = peg$parseadditional_weighted_expr(); + while (s7 !== peg$FAILED) { + s6.push(s7); + s7 = peg$parseadditional_weighted_expr(); + } + s0 = peg$f22(s1, s3, s5, s6); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$parsecore_model(); + if (s1 !== peg$FAILED) { + if (input.charCodeAt(peg$currPos) === 58) { + s2 = peg$c2; + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e4); + } + } + if (s2 !== peg$FAILED) { + s3 = peg$parseweighted_expr(); + if (s3 !== peg$FAILED) { + s4 = []; + s5 = peg$parseadditional_weighted_expr(); + while (s5 !== peg$FAILED) { + s4.push(s5); + s5 = peg$parseadditional_weighted_expr(); + } + s0 = peg$f23(s1, s3, s4); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e13); + } + } + return s0; + } + function peg$parseweighted_expr() { + var s0, s1, s2, s3; + s0 = peg$currPos; + s1 = peg$parseexpr(); + if (s1 !== peg$FAILED) { + if (input.charCodeAt(peg$currPos) === 44) { + s2 = peg$c1; + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e2); + } + } + if (s2 !== peg$FAILED) { + s3 = peg$parsedec(); + if (s3 !== peg$FAILED) { + s0 = peg$f24(s1, s3); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parseadditional_weighted_expr() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 59) { + s1 = peg$c0; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e1); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$parseweighted_expr(); + if (s2 !== peg$FAILED) { + s0 = peg$f25(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsecore_model() { + var s0; + peg$silentFails++; + s0 = peg$parsename(); + peg$silentFails--; + if (s0 === peg$FAILED) { + if (peg$silentFails === 0) { + peg$fail(peg$e14); + } + } + return s0; + } + function peg$parseexpr() { + var s0, s1, s2, s3, s4; + peg$silentFails++; + s0 = peg$currPos; + s1 = peg$parseprefix(); + s2 = peg$parsename(); + if (s2 !== peg$FAILED) { + s3 = peg$parsemix_expr(); + s4 = peg$parsepostfix(); + if (s4 === peg$FAILED) { + s4 = null; + } + s0 = peg$f26(s1, s2, s3, s4); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e15); + } + } + return s0; + } + function peg$parsecomplete_mix() { + var s0, s1, s2, s3, s4; + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 33) { + s1 = peg$c5; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e16); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$parsepct(); + if (s2 !== peg$FAILED) { + if (input.charCodeAt(peg$currPos) === 33) { + s3 = peg$c5; + peg$currPos++; + } else { + s3 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e16); + } + } + if (s3 !== peg$FAILED) { + s4 = peg$parsename(); + if (s4 !== peg$FAILED) { + s0 = peg$f27(s2, s4); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsepartial_mix() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 33) { + s1 = peg$c5; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e16); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$parsepct(); + if (s2 !== peg$FAILED) { + s0 = peg$f28(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsemix_expr() { + var s0, s1, s2; + peg$silentFails++; + s0 = peg$currPos; + s1 = []; + s2 = peg$parsecomplete_mix(); + while (s2 !== peg$FAILED) { + s1.push(s2); + s2 = peg$parsecomplete_mix(); + } + s2 = peg$parsepartial_mix(); + if (s2 === peg$FAILED) { + s2 = null; + } + s0 = peg$f29(s1, s2); + peg$silentFails--; + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e17); + } + return s0; + } + function peg$parsename() { + var s0, s1, s2; + peg$silentFails++; + if (input.charCodeAt(peg$currPos) === 46) { + s0 = peg$c6; + peg$currPos++; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e19); + } + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = []; + if (peg$r0.test(input.charAt(peg$currPos))) { + s2 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e20); + } + } + if (s2 !== peg$FAILED) { + while (s2 !== peg$FAILED) { + s1.push(s2); + if (peg$r0.test(input.charAt(peg$currPos))) { + s2 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e20); + } + } + } + } else { + s1 = peg$FAILED; + } + if (s1 !== peg$FAILED) { + s0 = input.substring(s0, peg$currPos); + } else { + s0 = s1; + } + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e18); + } + } + return s0; + } + function peg$parsepostfix() { + var s0, s1, s2, s3, s4; + peg$silentFails++; + s0 = peg$currPos; + if (input.substr(peg$currPos, 3) === peg$c7) { + s1 = peg$c7; + peg$currPos += 3; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e22); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$parsenum(); + if (s2 !== peg$FAILED) { + if (input.charCodeAt(peg$currPos) === 93) { + s3 = peg$c8; + peg$currPos++; + } else { + s3 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e23); + } + } + if (s3 !== peg$FAILED) { + s0 = peg$f30(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + if (input.substr(peg$currPos, 2) === peg$c9) { + s1 = peg$c9; + peg$currPos += 2; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e24); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$currPos; + s3 = []; + s4 = peg$parseplus(); + if (s4 !== peg$FAILED) { + while (s4 !== peg$FAILED) { + s3.push(s4); + s4 = peg$parseplus(); + } + } else { + s3 = peg$FAILED; + } + if (s3 !== peg$FAILED) { + s2 = input.substring(s2, peg$currPos); + } else { + s2 = s3; + } + if (s2 !== peg$FAILED) { + s0 = peg$f31(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e21); + } + } + return s0; + } + function peg$parseprefix() { + var s0; + peg$silentFails++; + s0 = peg$parseminus(); + if (s0 === peg$FAILED) { + s0 = null; + } + peg$silentFails--; + if (peg$silentFails === 0) { + peg$fail(peg$e25); + } + return s0; + } + function peg$parseplus() { + var s0, s1, s2; + peg$silentFails++; + s0 = peg$currPos; + s1 = []; + if (input.charCodeAt(peg$currPos) === 43) { + s2 = peg$c10; + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e27); + } + } + if (s2 !== peg$FAILED) { + while (s2 !== peg$FAILED) { + s1.push(s2); + if (input.charCodeAt(peg$currPos) === 43) { + s2 = peg$c10; + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e27); + } + } + } + } else { + s1 = peg$FAILED; + } + if (s1 !== peg$FAILED) { + s0 = input.substring(s0, peg$currPos); + } else { + s0 = s1; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e26); + } + } + return s0; + } + function peg$parseminus() { + var s0, s1, s2; + peg$silentFails++; + s0 = peg$currPos; + s1 = []; + if (input.charCodeAt(peg$currPos) === 45) { + s2 = peg$c11; + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e29); + } + } + if (s2 !== peg$FAILED) { + while (s2 !== peg$FAILED) { + s1.push(s2); + if (input.charCodeAt(peg$currPos) === 45) { + s2 = peg$c11; + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e29); + } + } + } + } else { + s1 = peg$FAILED; + } + if (s1 !== peg$FAILED) { + s0 = input.substring(s0, peg$currPos); + } else { + s0 = s1; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e28); + } + } + return s0; + } + function peg$parsenum() { + var s0, s1, s2, s3; + peg$silentFails++; + s0 = peg$currPos; + s1 = peg$currPos; + s2 = []; + if (peg$r1.test(input.charAt(peg$currPos))) { + s3 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s3 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e31); + } + } + if (s3 !== peg$FAILED) { + while (s3 !== peg$FAILED) { + s2.push(s3); + if (peg$r1.test(input.charAt(peg$currPos))) { + s3 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s3 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e31); + } + } + } + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s1 = input.substring(s1, peg$currPos); + } else { + s1 = s2; + } + if (s1 !== peg$FAILED) { + s1 = peg$f32(s1); + } + s0 = s1; + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e30); + } + } + return s0; + } + function peg$parsepct() { + var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9; + peg$silentFails++; + s0 = peg$currPos; + s1 = peg$currPos; + s2 = peg$currPos; + s3 = peg$currPos; + s4 = []; + if (peg$r1.test(input.charAt(peg$currPos))) { + s5 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s5 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e31); + } + } + if (s5 !== peg$FAILED) { + while (s5 !== peg$FAILED) { + s4.push(s5); + if (peg$r1.test(input.charAt(peg$currPos))) { + s5 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s5 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e31); + } + } + } + } else { + s4 = peg$FAILED; + } + if (s4 !== peg$FAILED) { + s3 = input.substring(s3, peg$currPos); + } else { + s3 = s4; + } + if (s3 !== peg$FAILED) { + s4 = peg$currPos; + s5 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 46) { + s6 = peg$c6; + peg$currPos++; + } else { + s6 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e19); + } + } + if (s6 !== peg$FAILED) { + s7 = peg$currPos; + s8 = []; + if (peg$r1.test(input.charAt(peg$currPos))) { + s9 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s9 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e31); + } + } + while (s9 !== peg$FAILED) { + s8.push(s9); + if (peg$r1.test(input.charAt(peg$currPos))) { + s9 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s9 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e31); + } + } + } + s7 = input.substring(s7, peg$currPos); + s6 = [s6, s7]; + s5 = s6; + } else { + peg$currPos = s5; + s5 = peg$FAILED; + } + if (s5 === peg$FAILED) { + s5 = null; + } + s4 = input.substring(s4, peg$currPos); + s3 = [s3, s4]; + s2 = s3; + } else { + peg$currPos = s2; + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s1 = input.substring(s1, peg$currPos); + } else { + s1 = s2; + } + if (s1 === peg$FAILED) { + s1 = peg$currPos; + s2 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 46) { + s3 = peg$c6; + peg$currPos++; + } else { + s3 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e19); + } + } + if (s3 !== peg$FAILED) { + s4 = peg$currPos; + s5 = []; + if (peg$r1.test(input.charAt(peg$currPos))) { + s6 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s6 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e31); + } + } + if (s6 !== peg$FAILED) { + while (s6 !== peg$FAILED) { + s5.push(s6); + if (peg$r1.test(input.charAt(peg$currPos))) { + s6 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s6 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e31); + } + } + } + } else { + s5 = peg$FAILED; + } + if (s5 !== peg$FAILED) { + s4 = input.substring(s4, peg$currPos); + } else { + s4 = s5; + } + if (s4 !== peg$FAILED) { + s3 = [s3, s4]; + s2 = s3; + } else { + peg$currPos = s2; + s2 = peg$FAILED; + } + } else { + peg$currPos = s2; + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s1 = input.substring(s1, peg$currPos); + } else { + s1 = s2; + } + } + if (s1 !== peg$FAILED) { + s1 = peg$f33(s1); + } + s0 = s1; + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e32); + } + } + return s0; + } + function peg$parsediv() { + var s0; + peg$silentFails++; + s0 = peg$parsepct(); + peg$silentFails--; + if (s0 === peg$FAILED) { + if (peg$silentFails === 0) { + peg$fail(peg$e33); + } + } + return s0; + } + function peg$parsedec() { + var s0, s1, s2; + s0 = peg$parsepct(); + if (s0 === peg$FAILED) { + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 43) { + s1 = peg$c10; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e27); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$parsepct(); + if (s2 !== peg$FAILED) { + s0 = peg$f34(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 45) { + s1 = peg$c11; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e29); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$parsepct(); + if (s2 !== peg$FAILED) { + s0 = peg$f35(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } + } + return s0; + } + function peg$parseint() { + var s0, s1, s2; + peg$silentFails++; + s0 = peg$currPos; + s1 = peg$parseminus(); + if (s1 === peg$FAILED) { + s1 = null; + } + s2 = peg$parsenum(); + if (s2 !== peg$FAILED) { + s0 = peg$f36(s1, s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e34); + } + } + return s0; + } + function peg$parsesp() { + var s0, s1; + s0 = []; + if (peg$r2.test(input.charAt(peg$currPos))) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e36); + } + } + if (s1 !== peg$FAILED) { + while (s1 !== peg$FAILED) { + s0.push(s1); + if (peg$r2.test(input.charAt(peg$currPos))) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e36); + } + } + } + } else { + s0 = peg$FAILED; + } + return s0; + } + function peg$parsehex() { + var s0, s1; + s0 = peg$currPos; + if (peg$r3.test(input.charAt(peg$currPos))) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e37); + } + } + if (s1 !== peg$FAILED) { + s1 = peg$f37(s1); + } + s0 = s1; + return s0; + } + function peg$parseEOL() { + var s0, s1; + s0 = peg$currPos; + peg$silentFails++; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + peg$silentFails--; + if (s1 === peg$FAILED) { + s0 = void 0; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + peg$result = peg$startRuleFunction(); + if (peg$result !== peg$FAILED && peg$currPos === input.length) { + return peg$result; + } else { + if (peg$result !== peg$FAILED && peg$currPos < input.length) { + peg$fail(peg$endExpectation()); + } + throw peg$buildStructuredError( + peg$maxFailExpected, + peg$maxFailPos < input.length ? input.charAt(peg$maxFailPos) : null, + peg$maxFailPos < input.length ? peg$computeLocation(peg$maxFailPos, peg$maxFailPos + 1) : peg$computeLocation(peg$maxFailPos, peg$maxFailPos) + ); + } + } + return { + SyntaxError: peg$SyntaxError, + parse: peg$parse + }; +})(); +// Generated by Peggy 2.0.1. +// +// https://peggyjs.org/ +(function() { + function peg$subclass(child, parent) { + function C() { + this.constructor = child; + } + C.prototype = parent.prototype; + child.prototype = new C(); + } + function peg$SyntaxError(message, expected, found, location) { + var self = Error.call(this, message); + if (Object.setPrototypeOf) { + Object.setPrototypeOf(self, peg$SyntaxError.prototype); + } + self.expected = expected; + self.found = found; + self.location = location; + self.name = "SyntaxError"; + return self; + } + peg$subclass(peg$SyntaxError, Error); + function peg$padEnd(str, targetLength, padString) { + padString = padString || " "; + if (str.length > targetLength) { + return str; + } + targetLength -= str.length; + padString += padString.repeat(targetLength); + return str + padString.slice(0, targetLength); + } + peg$SyntaxError.prototype.format = function(sources) { + var str = "Error: " + this.message; + if (this.location) { + var src = null; + var k; + for (k = 0; k < sources.length; k++) { + if (sources[k].source === this.location.source) { + src = sources[k].text.split(/\r\n|\n|\r/g); + break; + } + } + var s2 = this.location.start; + var loc = this.location.source + ":" + s2.line + ":" + s2.column; + if (src) { + var e = this.location.end; + var filler = peg$padEnd("", s2.line.toString().length, " "); + var line3 = src[s2.line - 1]; + var last = s2.line === e.line ? e.column : line3.length + 1; + var hatLen = last - s2.column || 1; + str += "\n --> " + loc + "\n" + filler + " |\n" + s2.line + " | " + line3 + "\n" + filler + " | " + peg$padEnd("", s2.column - 1, " ") + peg$padEnd("", hatLen, "^"); + } else { + str += "\n at " + loc; + } + } + return str; + }; + peg$SyntaxError.buildMessage = function(expected, found) { + var DESCRIBE_EXPECTATION_FNS = { + literal: function(expectation) { + return '"' + literalEscape(expectation.text) + '"'; + }, + class: function(expectation) { + var escapedParts = expectation.parts.map(function(part) { + return Array.isArray(part) ? classEscape(part[0]) + "-" + classEscape(part[1]) : classEscape(part); + }); + return "[" + (expectation.inverted ? "^" : "") + escapedParts.join("") + "]"; + }, + any: function() { + return "any character"; + }, + end: function() { + return "end of input"; + }, + other: function(expectation) { + return expectation.description; + } + }; + function hex(ch) { + return ch.charCodeAt(0).toString(16).toUpperCase(); + } + function literalEscape(s2) { + return s2.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\0/g, "\\0").replace(/\t/g, "\\t").replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/[\x00-\x0F]/g, function(ch) { + return "\\x0" + hex(ch); + }).replace(/[\x10-\x1F\x7F-\x9F]/g, function(ch) { + return "\\x" + hex(ch); + }); + } + function classEscape(s2) { + return s2.replace(/\\/g, "\\\\").replace(/\]/g, "\\]").replace(/\^/g, "\\^").replace(/-/g, "\\-").replace(/\0/g, "\\0").replace(/\t/g, "\\t").replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/[\x00-\x0F]/g, function(ch) { + return "\\x0" + hex(ch); + }).replace(/[\x10-\x1F\x7F-\x9F]/g, function(ch) { + return "\\x" + hex(ch); + }); + } + function describeExpectation(expectation) { + return DESCRIBE_EXPECTATION_FNS[expectation.type](expectation); + } + function describeExpected(expected2) { + var descriptions = expected2.map(describeExpectation); + var i, j; + descriptions.sort(); + if (descriptions.length > 0) { + for (i = 1, j = 1; i < descriptions.length; i++) { + if (descriptions[i - 1] !== descriptions[i]) { + descriptions[j] = descriptions[i]; + j++; + } + } + descriptions.length = j; + } + switch (descriptions.length) { + case 1: + return descriptions[0]; + case 2: + return descriptions[0] + " or " + descriptions[1]; + default: + return descriptions.slice(0, -1).join(", ") + ", or " + descriptions[descriptions.length - 1]; + } + } + function describeFound(found2) { + return found2 ? '"' + literalEscape(found2) + '"' : "end of input"; + } + return "Expected " + describeExpected(expected) + " but " + describeFound(found) + " found."; + }; + function peg$parse(input, options2) { + options2 = options2 !== void 0 ? options2 : {}; + var peg$FAILED = {}; + var peg$source = options2.grammarSource; + var peg$startRuleFunctions = { body: peg$parsebody }; + var peg$startRuleFunction = peg$parsebody; + var peg$e0 = peg$otherExpectation("decl_start"); + var peg$e1 = peg$otherExpectation("decl_end"); + var peg$e2 = peg$otherExpectation("vert"); + var peg$e3 = peg$anyExpectation(); + var peg$e4 = peg$otherExpectation("l"); + var peg$e5 = peg$otherExpectation("r"); + var peg$e6 = peg$otherExpectation("c"); + var peg$e7 = peg$otherExpectation("p"); + var peg$e8 = peg$otherExpectation("m"); + var peg$e9 = peg$otherExpectation("b"); + var peg$e10 = peg$otherExpectation("w"); + var peg$e11 = peg$otherExpectation("W"); + var peg$e12 = peg$otherExpectation("X"); + var peg$e13 = peg$otherExpectation("!"); + var peg$e14 = peg$otherExpectation("@"); + var peg$e15 = peg$otherExpectation("<"); + var peg$e16 = peg$otherExpectation(">"); + var peg$e17 = peg$otherExpectation("group"); + var peg$e18 = peg$otherExpectation("whitespace"); + var peg$f0 = function(c) { + return c; + }; + var peg$f1 = function(cols) { + return cols; + }; + var peg$f2 = function() { + return []; + }; + var peg$f3 = function(divs1, start, a, end, divs2) { + return { + type: "column", + pre_dividers: divs1, + post_dividers: divs2, + before_start_code: start, + before_end_code: end, + alignment: a + }; + }; + var peg$f4 = function() { + return { + type: "vert_divider" + }; + }; + var peg$f5 = function(b, g) { + return { + type: "bang_divider", + content: g[0].content + }; + }; + var peg$f6 = function(g) { + return { + type: "at_divider", + content: g[0].content + }; + }; + var peg$f7 = function(div) { + return div; + }; + var peg$f8 = function(g) { + return { type: "decl_code", code: g[0].content }; + }; + var peg$f9 = function(g) { + return { type: "decl_code", code: g[0].content }; + }; + var peg$f10 = function() { + return { type: "alignment", alignment: "left" }; + }; + var peg$f11 = function() { + return { type: "alignment", alignment: "center" }; + }; + var peg$f12 = function() { + return { type: "alignment", alignment: "right" }; + }; + var peg$f13 = function() { + return { type: "alignment", alignment: "X" }; + }; + var peg$f14 = function() { + return "top"; + }; + var peg$f15 = function() { + return "default"; + }; + var peg$f16 = function() { + return "bottom"; + }; + var peg$f17 = function(a, g) { + return { + type: "alignment", + alignment: "parbox", + baseline: a, + size: g[0].content + }; + }; + var peg$f18 = function(g1, g2) { + return { + type: "alignment", + alignment: "parbox", + baseline: g1[0].content, + size: g2[0].content + }; + }; + var peg$f19 = function(tok) { + return options2.matchChar(tok, "|"); + }; + var peg$f20 = function(tok) { + return options2.matchChar(tok, "l"); + }; + var peg$f21 = function(tok) { + return options2.matchChar(tok, "r"); + }; + var peg$f22 = function(tok) { + return options2.matchChar(tok, "c"); + }; + var peg$f23 = function(tok) { + return options2.matchChar(tok, "p"); + }; + var peg$f24 = function(tok) { + return options2.matchChar(tok, "m"); + }; + var peg$f25 = function(tok) { + return options2.matchChar(tok, "b"); + }; + var peg$f26 = function(tok) { + return options2.matchChar(tok, "w"); + }; + var peg$f27 = function(tok) { + return options2.matchChar(tok, "W"); + }; + var peg$f28 = function(tok) { + return options2.matchChar(tok, "X"); + }; + var peg$f29 = function(tok) { + return options2.matchChar(tok, "!"); + }; + var peg$f30 = function(tok) { + return options2.matchChar(tok, "@"); + }; + var peg$f31 = function(tok) { + return options2.matchChar(tok, "<"); + }; + var peg$f32 = function(tok) { + return options2.matchChar(tok, ">"); + }; + var peg$f33 = function(tok) { + return options2.isGroup(tok); + }; + var peg$f34 = function(tok) { + return options2.isWhitespace(tok); + }; + var peg$currPos = 0; + var peg$posDetailsCache = [{ line: 1, column: 1 }]; + var peg$maxFailPos = 0; + var peg$maxFailExpected = []; + var peg$silentFails = 0; + var peg$result; + if ("startRule" in options2) { + if (!(options2.startRule in peg$startRuleFunctions)) { + throw new Error(`Can't start parsing from rule "` + options2.startRule + '".'); + } + peg$startRuleFunction = peg$startRuleFunctions[options2.startRule]; + } + function peg$anyExpectation() { + return { type: "any" }; + } + function peg$endExpectation() { + return { type: "end" }; + } + function peg$otherExpectation(description) { + return { type: "other", description }; + } + function peg$computePosDetails(pos) { + var details = peg$posDetailsCache[pos]; + var p; + if (details) { + return details; + } else { + p = pos - 1; + while (!peg$posDetailsCache[p]) { + p--; + } + details = peg$posDetailsCache[p]; + details = { + line: details.line, + column: details.column + }; + while (p < pos) { + if (input.charCodeAt(p) === 10) { + details.line++; + details.column = 1; + } else { + details.column++; + } + p++; + } + peg$posDetailsCache[pos] = details; + return details; + } + } + function peg$computeLocation(startPos, endPos) { + var startPosDetails = peg$computePosDetails(startPos); + var endPosDetails = peg$computePosDetails(endPos); + return { + source: peg$source, + start: { + offset: startPos, + line: startPosDetails.line, + column: startPosDetails.column + }, + end: { + offset: endPos, + line: endPosDetails.line, + column: endPosDetails.column + } + }; + } + function peg$fail(expected2) { + if (peg$currPos < peg$maxFailPos) { + return; + } + if (peg$currPos > peg$maxFailPos) { + peg$maxFailPos = peg$currPos; + peg$maxFailExpected = []; + } + peg$maxFailExpected.push(expected2); + } + function peg$buildStructuredError(expected2, found, location2) { + return new peg$SyntaxError( + peg$SyntaxError.buildMessage(expected2, found), + expected2, + found, + location2 + ); + } + function peg$parsebody() { + var s0, s1, s2, s3, s4, s5; + s0 = peg$currPos; + s1 = []; + s2 = peg$currPos; + s3 = peg$parsecolumn(); + if (s3 !== peg$FAILED) { + s4 = []; + s5 = peg$parse_(); + while (s5 !== peg$FAILED) { + s4.push(s5); + s5 = peg$parse_(); + } + s2 = peg$f0(s3); + } else { + peg$currPos = s2; + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + while (s2 !== peg$FAILED) { + s1.push(s2); + s2 = peg$currPos; + s3 = peg$parsecolumn(); + if (s3 !== peg$FAILED) { + s4 = []; + s5 = peg$parse_(); + while (s5 !== peg$FAILED) { + s4.push(s5); + s5 = peg$parse_(); + } + s2 = peg$f0(s3); + } else { + peg$currPos = s2; + s2 = peg$FAILED; + } + } + } else { + s1 = peg$FAILED; + } + if (s1 !== peg$FAILED) { + s1 = peg$f1(s1); + } + s0 = s1; + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$parseEOL(); + if (s1 !== peg$FAILED) { + s1 = peg$f2(); + } + s0 = s1; + } + return s0; + } + function peg$parsecolumn() { + var s0, s1, s2, s3, s4, s5, s6; + s0 = peg$currPos; + s1 = []; + s2 = peg$parsecolumn_divider(); + while (s2 !== peg$FAILED) { + s1.push(s2); + s2 = peg$parsecolumn_divider(); + } + s2 = peg$parsedecl_start(); + if (s2 === peg$FAILED) { + s2 = null; + } + s3 = peg$parsealignment(); + if (s3 !== peg$FAILED) { + s4 = peg$parsedecl_end(); + if (s4 === peg$FAILED) { + s4 = null; + } + s5 = []; + s6 = peg$parsecolumn_divider(); + while (s6 !== peg$FAILED) { + s5.push(s6); + s6 = peg$parsecolumn_divider(); + } + s0 = peg$f3(s1, s2, s3, s4, s5); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsecolumn_divider() { + var s0, s1, s2, s3, s4; + s0 = peg$currPos; + s1 = []; + s2 = peg$parse_(); + while (s2 !== peg$FAILED) { + s1.push(s2); + s2 = peg$parse_(); + } + s2 = peg$currPos; + s3 = peg$parsevert(); + if (s3 !== peg$FAILED) { + s3 = peg$f4(); + } + s2 = s3; + if (s2 === peg$FAILED) { + s2 = peg$currPos; + s3 = peg$parsebang(); + if (s3 !== peg$FAILED) { + s4 = peg$parsegroup(); + if (s4 !== peg$FAILED) { + s2 = peg$f5(s3, s4); + } else { + peg$currPos = s2; + s2 = peg$FAILED; + } + } else { + peg$currPos = s2; + s2 = peg$FAILED; + } + if (s2 === peg$FAILED) { + s2 = peg$currPos; + s3 = peg$parseat(); + if (s3 !== peg$FAILED) { + s4 = peg$parsegroup(); + if (s4 !== peg$FAILED) { + s2 = peg$f6(s4); + } else { + peg$currPos = s2; + s2 = peg$FAILED; + } + } else { + peg$currPos = s2; + s2 = peg$FAILED; + } + } + } + if (s2 !== peg$FAILED) { + s3 = []; + s4 = peg$parse_(); + while (s4 !== peg$FAILED) { + s3.push(s4); + s4 = peg$parse_(); + } + s0 = peg$f7(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsedecl_start() { + var s0, s1, s2; + peg$silentFails++; + s0 = peg$currPos; + s1 = peg$parsegreater(); + if (s1 !== peg$FAILED) { + s2 = peg$parsegroup(); + if (s2 !== peg$FAILED) { + s0 = peg$f8(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + return s0; + } + function peg$parsedecl_end() { + var s0, s1, s2; + peg$silentFails++; + s0 = peg$currPos; + s1 = peg$parseless(); + if (s1 !== peg$FAILED) { + s2 = peg$parsegroup(); + if (s2 !== peg$FAILED) { + s0 = peg$f9(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e1); + } + } + return s0; + } + function peg$parsealignment() { + var s0, s1, s2, s3, s4, s5; + s0 = peg$currPos; + s1 = peg$parsel(); + if (s1 !== peg$FAILED) { + s1 = peg$f10(); + } + s0 = s1; + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$parsec(); + if (s1 !== peg$FAILED) { + s1 = peg$f11(); + } + s0 = s1; + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$parser(); + if (s1 !== peg$FAILED) { + s1 = peg$f12(); + } + s0 = s1; + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$parseX(); + if (s1 !== peg$FAILED) { + s1 = peg$f13(); + } + s0 = s1; + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$currPos; + s2 = peg$parsep(); + if (s2 !== peg$FAILED) { + s2 = peg$f14(); + } + s1 = s2; + if (s1 === peg$FAILED) { + s1 = peg$currPos; + s2 = peg$parsem(); + if (s2 !== peg$FAILED) { + s2 = peg$f15(); + } + s1 = s2; + if (s1 === peg$FAILED) { + s1 = peg$currPos; + s2 = peg$parseb(); + if (s2 !== peg$FAILED) { + s2 = peg$f16(); + } + s1 = s2; + } + } + if (s1 !== peg$FAILED) { + s2 = []; + s3 = peg$parse_(); + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$parse_(); + } + s3 = peg$parsegroup(); + if (s3 !== peg$FAILED) { + s0 = peg$f17(s1, s3); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$parsew(); + if (s1 === peg$FAILED) { + s1 = peg$parseW(); + } + if (s1 !== peg$FAILED) { + s2 = []; + s3 = peg$parse_(); + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$parse_(); + } + s3 = peg$parsegroup(); + if (s3 !== peg$FAILED) { + s4 = []; + s5 = peg$parse_(); + while (s5 !== peg$FAILED) { + s4.push(s5); + s5 = peg$parse_(); + } + s5 = peg$parsegroup(); + if (s5 !== peg$FAILED) { + s0 = peg$f18(s3, s5); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } + } + } + } + } + return s0; + } + function peg$parsevert() { + var s0, s1, s2; + peg$silentFails++; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f19(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s1 = [s1, s2]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e2); + } + } + return s0; + } + function peg$parsel() { + var s0, s1, s2; + peg$silentFails++; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f20(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s1 = [s1, s2]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e4); + } + } + return s0; + } + function peg$parser() { + var s0, s1, s2; + peg$silentFails++; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f21(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s1 = [s1, s2]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e5); + } + } + return s0; + } + function peg$parsec() { + var s0, s1, s2; + peg$silentFails++; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f22(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s1 = [s1, s2]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e6); + } + } + return s0; + } + function peg$parsep() { + var s0, s1, s2; + peg$silentFails++; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f23(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s1 = [s1, s2]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e7); + } + } + return s0; + } + function peg$parsem() { + var s0, s1, s2; + peg$silentFails++; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f24(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s1 = [s1, s2]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e8); + } + } + return s0; + } + function peg$parseb() { + var s0, s1, s2; + peg$silentFails++; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f25(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s1 = [s1, s2]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e9); + } + } + return s0; + } + function peg$parsew() { + var s0, s1, s2; + peg$silentFails++; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f26(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s1 = [s1, s2]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e10); + } + } + return s0; + } + function peg$parseW() { + var s0, s1, s2; + peg$silentFails++; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f27(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s1 = [s1, s2]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e11); + } + } + return s0; + } + function peg$parseX() { + var s0, s1, s2; + peg$silentFails++; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f28(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s1 = [s1, s2]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e12); + } + } + return s0; + } + function peg$parsebang() { + var s0, s1, s2; + peg$silentFails++; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f29(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s1 = [s1, s2]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e13); + } + } + return s0; + } + function peg$parseat() { + var s0, s1, s2; + peg$silentFails++; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f30(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s1 = [s1, s2]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e14); + } + } + return s0; + } + function peg$parseless() { + var s0, s1, s2; + peg$silentFails++; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f31(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s1 = [s1, s2]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e15); + } + } + return s0; + } + function peg$parsegreater() { + var s0, s1, s2; + peg$silentFails++; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f32(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s1 = [s1, s2]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e16); + } + } + return s0; + } + function peg$parsegroup() { + var s0, s1, s2; + peg$silentFails++; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f33(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s1 = [s1, s2]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e17); + } + } + return s0; + } + function peg$parse_() { + var s0, s1, s2; + peg$silentFails++; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f34(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s1 = [s1, s2]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e18); + } + } + return s0; + } + function peg$parseEOL() { + var s0, s1; + s0 = peg$currPos; + peg$silentFails++; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + peg$silentFails--; + if (s1 === peg$FAILED) { + s0 = void 0; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + if (!options2.isHash) { + try { + Object.assign(options2, { + matchChar: (node, char) => node.type === "string" && node.content === char, + isGroup: (node) => node.type === "group", + isWhitespace: (node) => node.type === "whitespace" + }); + } catch (e) { + console.warn("Error when initializing parser", e); + } + } + peg$result = peg$startRuleFunction(); + if (peg$result !== peg$FAILED && peg$currPos === input.length) { + return peg$result; + } else { + if (peg$result !== peg$FAILED && peg$currPos < input.length) { + peg$fail(peg$endExpectation()); + } + throw peg$buildStructuredError( + peg$maxFailExpected, + peg$maxFailPos < input.length ? input.charAt(peg$maxFailPos) : null, + peg$maxFailPos < input.length ? peg$computeLocation(peg$maxFailPos, peg$maxFailPos + 1) : peg$computeLocation(peg$maxFailPos, peg$maxFailPos) + ); + } + } + return { + SyntaxError: peg$SyntaxError, + parse: peg$parse + }; +})(); +// Generated by Peggy 2.0.1. +// +// https://peggyjs.org/ +(function() { + function peg$subclass(child, parent) { + function C() { + this.constructor = child; + } + C.prototype = parent.prototype; + child.prototype = new C(); + } + function peg$SyntaxError(message, expected, found, location) { + var self = Error.call(this, message); + if (Object.setPrototypeOf) { + Object.setPrototypeOf(self, peg$SyntaxError.prototype); + } + self.expected = expected; + self.found = found; + self.location = location; + self.name = "SyntaxError"; + return self; + } + peg$subclass(peg$SyntaxError, Error); + function peg$padEnd(str, targetLength, padString) { + padString = padString || " "; + if (str.length > targetLength) { + return str; + } + targetLength -= str.length; + padString += padString.repeat(targetLength); + return str + padString.slice(0, targetLength); + } + peg$SyntaxError.prototype.format = function(sources) { + var str = "Error: " + this.message; + if (this.location) { + var src = null; + var k; + for (k = 0; k < sources.length; k++) { + if (sources[k].source === this.location.source) { + src = sources[k].text.split(/\r\n|\n|\r/g); + break; + } + } + var s2 = this.location.start; + var loc = this.location.source + ":" + s2.line + ":" + s2.column; + if (src) { + var e = this.location.end; + var filler = peg$padEnd("", s2.line.toString().length, " "); + var line3 = src[s2.line - 1]; + var last = s2.line === e.line ? e.column : line3.length + 1; + var hatLen = last - s2.column || 1; + str += "\n --> " + loc + "\n" + filler + " |\n" + s2.line + " | " + line3 + "\n" + filler + " | " + peg$padEnd("", s2.column - 1, " ") + peg$padEnd("", hatLen, "^"); + } else { + str += "\n at " + loc; + } + } + return str; + }; + peg$SyntaxError.buildMessage = function(expected, found) { + var DESCRIBE_EXPECTATION_FNS = { + literal: function(expectation) { + return '"' + literalEscape(expectation.text) + '"'; + }, + class: function(expectation) { + var escapedParts = expectation.parts.map(function(part) { + return Array.isArray(part) ? classEscape(part[0]) + "-" + classEscape(part[1]) : classEscape(part); + }); + return "[" + (expectation.inverted ? "^" : "") + escapedParts.join("") + "]"; + }, + any: function() { + return "any character"; + }, + end: function() { + return "end of input"; + }, + other: function(expectation) { + return expectation.description; + } + }; + function hex(ch) { + return ch.charCodeAt(0).toString(16).toUpperCase(); + } + function literalEscape(s2) { + return s2.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\0/g, "\\0").replace(/\t/g, "\\t").replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/[\x00-\x0F]/g, function(ch) { + return "\\x0" + hex(ch); + }).replace(/[\x10-\x1F\x7F-\x9F]/g, function(ch) { + return "\\x" + hex(ch); + }); + } + function classEscape(s2) { + return s2.replace(/\\/g, "\\\\").replace(/\]/g, "\\]").replace(/\^/g, "\\^").replace(/-/g, "\\-").replace(/\0/g, "\\0").replace(/\t/g, "\\t").replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/[\x00-\x0F]/g, function(ch) { + return "\\x0" + hex(ch); + }).replace(/[\x10-\x1F\x7F-\x9F]/g, function(ch) { + return "\\x" + hex(ch); + }); + } + function describeExpectation(expectation) { + return DESCRIBE_EXPECTATION_FNS[expectation.type](expectation); + } + function describeExpected(expected2) { + var descriptions = expected2.map(describeExpectation); + var i, j; + descriptions.sort(); + if (descriptions.length > 0) { + for (i = 1, j = 1; i < descriptions.length; i++) { + if (descriptions[i - 1] !== descriptions[i]) { + descriptions[j] = descriptions[i]; + j++; + } + } + descriptions.length = j; + } + switch (descriptions.length) { + case 1: + return descriptions[0]; + case 2: + return descriptions[0] + " or " + descriptions[1]; + default: + return descriptions.slice(0, -1).join(", ") + ", or " + descriptions[descriptions.length - 1]; + } + } + function describeFound(found2) { + return found2 ? '"' + literalEscape(found2) + '"' : "end of input"; + } + return "Expected " + describeExpected(expected) + " but " + describeFound(found) + " found."; + }; + function peg$parse(input, options2) { + options2 = options2 !== void 0 ? options2 : {}; + var peg$FAILED = {}; + var peg$source = options2.grammarSource; + var peg$startRuleFunctions = { body: peg$parsebody }; + var peg$startRuleFunction = peg$parsebody; + var peg$e1 = peg$otherExpectation("item"); + var peg$e2 = peg$anyExpectation(); + var peg$e3 = peg$otherExpectation("equation"); + var peg$e4 = peg$otherExpectation("trailing comment"); + var peg$e5 = peg$otherExpectation("comment only line"); + var peg$e6 = peg$otherExpectation("non-var token"); + var peg$e7 = peg$otherExpectation("token"); + var peg$e8 = peg$otherExpectation("same line comment"); + var peg$e9 = peg$otherExpectation("own line comment"); + var peg$e10 = peg$otherExpectation(","); + var peg$e11 = peg$otherExpectation("@"); + var peg$e12 = peg$otherExpectation("variable token"); + var peg$e13 = peg$otherExpectation("+/-"); + var peg$e14 = peg$otherExpectation("="); + var peg$f0 = function(a, b) { + return a.concat(b ? b : []); + }; + var peg$f1 = function() { + return []; + }; + var peg$f3 = function(op, a, b, c) { + return { type: "item", op, variable: b, content: a.concat(b, c) }; + }; + var peg$f4 = function(op, a) { + return { type: "item", op, variable: null, content: a }; + }; + var peg$f5 = function(line3, sep, comment) { + return { ...line3, sep: [].concat(sep), trailingComment: comment }; + }; + var peg$f6 = function(line3, comment) { + return { ...line3, trailingComment: comment }; + }; + var peg$f7 = function(eq, ann) { + return { + type: "line", + equation: eq, + annotation: ann, + sep: null + }; + }; + var peg$f8 = function(at2, ann) { + return at2 ? { type: "annotation", marker: at2, content: ann } : null; + }; + var peg$f9 = function(left, eq, right) { + return { type: "equation", left, right, equals: eq }; + }; + var peg$f10 = function(x) { + return x; + }; + var peg$f11 = function(x) { + return { + type: "line", + trailingComment: x + }; + }; + var peg$f12 = function(v, s2) { + return [v].concat(s2 ? s2 : []); + }; + var peg$f13 = function(t) { + return t; + }; + var peg$f14 = function(x) { + return x; + }; + var peg$f15 = function(x) { + return x; + }; + var peg$f16 = function(tok) { + return options2.isSameLineComment(tok); + }; + var peg$f17 = function(tok) { + return tok; + }; + var peg$f18 = function(tok) { + return options2.isOwnLineComment(tok); + }; + var peg$f19 = function(tok) { + return tok; + }; + var peg$f20 = function(tok) { + return options2.isWhitespace(tok); + }; + var peg$f21 = function(tok) { + return tok; + }; + var peg$f22 = function(tok) { + return options2.isSep(tok); + }; + var peg$f23 = function(tok) { + return tok; + }; + var peg$f24 = function(tok) { + return options2.isAt(tok); + }; + var peg$f25 = function(tok) { + return tok; + }; + var peg$f26 = function(tok) { + return options2.isVar(tok); + }; + var peg$f27 = function(tok) { + return tok; + }; + var peg$f28 = function(tok) { + return options2.isOperation(tok); + }; + var peg$f29 = function(tok) { + return tok; + }; + var peg$f30 = function(tok) { + return options2.isEquals(tok); + }; + var peg$f31 = function(tok) { + return tok; + }; + var peg$f32 = function(tok) { + return options2.isSubscript(tok); + }; + var peg$f33 = function(tok) { + return tok; + }; + var peg$currPos = 0; + var peg$posDetailsCache = [{ line: 1, column: 1 }]; + var peg$maxFailPos = 0; + var peg$maxFailExpected = []; + var peg$silentFails = 0; + var peg$result; + if ("startRule" in options2) { + if (!(options2.startRule in peg$startRuleFunctions)) { + throw new Error(`Can't start parsing from rule "` + options2.startRule + '".'); + } + peg$startRuleFunction = peg$startRuleFunctions[options2.startRule]; + } + function peg$anyExpectation() { + return { type: "any" }; + } + function peg$endExpectation() { + return { type: "end" }; + } + function peg$otherExpectation(description) { + return { type: "other", description }; + } + function peg$computePosDetails(pos) { + var details = peg$posDetailsCache[pos]; + var p; + if (details) { + return details; + } else { + p = pos - 1; + while (!peg$posDetailsCache[p]) { + p--; + } + details = peg$posDetailsCache[p]; + details = { + line: details.line, + column: details.column + }; + while (p < pos) { + if (input.charCodeAt(p) === 10) { + details.line++; + details.column = 1; + } else { + details.column++; + } + p++; + } + peg$posDetailsCache[pos] = details; + return details; + } + } + function peg$computeLocation(startPos, endPos) { + var startPosDetails = peg$computePosDetails(startPos); + var endPosDetails = peg$computePosDetails(endPos); + return { + source: peg$source, + start: { + offset: startPos, + line: startPosDetails.line, + column: startPosDetails.column + }, + end: { + offset: endPos, + line: endPosDetails.line, + column: endPosDetails.column + } + }; + } + function peg$fail(expected2) { + if (peg$currPos < peg$maxFailPos) { + return; + } + if (peg$currPos > peg$maxFailPos) { + peg$maxFailPos = peg$currPos; + peg$maxFailExpected = []; + } + peg$maxFailExpected.push(expected2); + } + function peg$buildStructuredError(expected2, found, location2) { + return new peg$SyntaxError( + peg$SyntaxError.buildMessage(expected2, found), + expected2, + found, + location2 + ); + } + function peg$parsebody() { + var s0, s1, s2; + s0 = peg$currPos; + s1 = []; + s2 = peg$parsecomment_only_line(); + if (s2 === peg$FAILED) { + s2 = peg$parseline_with_sep(); + if (s2 === peg$FAILED) { + s2 = peg$parsepartial_line_with_comment(); + } + } + while (s2 !== peg$FAILED) { + s1.push(s2); + s2 = peg$parsecomment_only_line(); + if (s2 === peg$FAILED) { + s2 = peg$parseline_with_sep(); + if (s2 === peg$FAILED) { + s2 = peg$parsepartial_line_with_comment(); + } + } + } + s2 = peg$parseline_without_sep(); + if (s2 === peg$FAILED) { + s2 = peg$parseEOL(); + } + if (s2 !== peg$FAILED) { + s0 = peg$f0(s1, s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$parseEOL(); + if (s1 !== peg$FAILED) { + s1 = peg$f1(); + } + s0 = s1; + } + return s0; + } + function peg$parseitem() { + var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9; + peg$silentFails++; + s0 = peg$currPos; + s1 = peg$parseoperation(); + if (s1 === peg$FAILED) { + s1 = null; + } + s2 = []; + s3 = peg$parse_(); + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$parse_(); + } + s3 = []; + s4 = peg$parsenon_var_token(); + while (s4 !== peg$FAILED) { + s3.push(s4); + s4 = peg$parsenon_var_token(); + } + s4 = []; + s5 = peg$parse_(); + while (s5 !== peg$FAILED) { + s4.push(s5); + s5 = peg$parse_(); + } + s5 = peg$parsevar(); + if (s5 !== peg$FAILED) { + s6 = []; + s7 = peg$parse_(); + while (s7 !== peg$FAILED) { + s6.push(s7); + s7 = peg$parse_(); + } + s7 = []; + s8 = peg$parsetoken(); + while (s8 !== peg$FAILED) { + s7.push(s8); + s8 = peg$parsetoken(); + } + s8 = []; + s9 = peg$parse_(); + while (s9 !== peg$FAILED) { + s8.push(s9); + s9 = peg$parse_(); + } + s0 = peg$f3(s1, s3, s5, s7); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$parseoperation(); + if (s1 === peg$FAILED) { + s1 = null; + } + s2 = []; + s3 = peg$parse_(); + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$parse_(); + } + s3 = []; + s4 = peg$parsenon_var_token(); + if (s4 !== peg$FAILED) { + while (s4 !== peg$FAILED) { + s3.push(s4); + s4 = peg$parsenon_var_token(); + } + } else { + s3 = peg$FAILED; + } + if (s3 !== peg$FAILED) { + s4 = []; + s5 = peg$parse_(); + while (s5 !== peg$FAILED) { + s4.push(s5); + s5 = peg$parse_(); + } + s0 = peg$f4(s1, s3); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e1); + } + } + return s0; + } + function peg$parseline_with_sep() { + var s0, s1, s2, s3; + s0 = peg$currPos; + s1 = peg$parseline_without_sep(); + if (s1 !== peg$FAILED) { + s2 = peg$parsesep(); + if (s2 !== peg$FAILED) { + s3 = peg$parsetrailing_comment(); + if (s3 === peg$FAILED) { + s3 = null; + } + s0 = peg$f5(s1, s2, s3); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsepartial_line_with_comment() { + var s0, s1, s2; + s0 = peg$currPos; + s1 = peg$parseline_without_sep(); + if (s1 !== peg$FAILED) { + s2 = peg$parsetrailing_comment(); + if (s2 !== peg$FAILED) { + s0 = peg$f6(s1, s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parseline_without_sep() { + var s0, s1, s2, s3; + s0 = peg$currPos; + s1 = peg$currPos; + peg$silentFails++; + if (input.length > peg$currPos) { + s2 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e2); + } + } + peg$silentFails--; + if (s2 !== peg$FAILED) { + peg$currPos = s1; + s1 = void 0; + } else { + s1 = peg$FAILED; + } + if (s1 !== peg$FAILED) { + s2 = peg$parseequation(); + s3 = peg$parseannotation(); + if (s3 === peg$FAILED) { + s3 = null; + } + s0 = peg$f7(s2, s3); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parseannotation() { + var s0, s1, s2, s3; + s0 = peg$currPos; + s1 = peg$parseat(); + if (s1 !== peg$FAILED) { + s2 = []; + s3 = peg$parsenon_sep_token(); + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$parsenon_sep_token(); + } + s0 = peg$f8(s1, s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parseequation() { + var s0, s1, s2, s3, s4; + peg$silentFails++; + s0 = peg$currPos; + s1 = []; + s2 = peg$parseitem(); + while (s2 !== peg$FAILED) { + s1.push(s2); + s2 = peg$parseitem(); + } + s2 = peg$parseequals(); + if (s2 === peg$FAILED) { + s2 = null; + } + s3 = []; + s4 = peg$parsetoken(); + if (s4 === peg$FAILED) { + s4 = peg$parseoperation(); + } + while (s4 !== peg$FAILED) { + s3.push(s4); + s4 = peg$parsetoken(); + if (s4 === peg$FAILED) { + s4 = peg$parseoperation(); + } + } + s0 = peg$f9(s1, s2, s3); + peg$silentFails--; + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + return s0; + } + function peg$parsetrailing_comment() { + var s0, s1, s2; + peg$silentFails++; + s0 = peg$currPos; + s1 = []; + s2 = peg$parse_(); + while (s2 !== peg$FAILED) { + s1.push(s2); + s2 = peg$parse_(); + } + s2 = peg$parsesame_line_comment(); + if (s2 !== peg$FAILED) { + s0 = peg$f10(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e4); + } + } + return s0; + } + function peg$parsecomment_only_line() { + var s0, s1, s2; + peg$silentFails++; + s0 = peg$currPos; + s1 = []; + s2 = peg$parse_(); + while (s2 !== peg$FAILED) { + s1.push(s2); + s2 = peg$parse_(); + } + s2 = peg$parseown_line_comment(); + if (s2 !== peg$FAILED) { + s0 = peg$f11(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e5); + } + } + return s0; + } + function peg$parsevar() { + var s0, s1, s2, s3; + s0 = peg$currPos; + s1 = peg$parsevar_token(); + if (s1 !== peg$FAILED) { + s2 = []; + s3 = peg$parse_(); + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$parse_(); + } + s3 = peg$parsesubscript(); + if (s3 === peg$FAILED) { + s3 = null; + } + s0 = peg$f12(s1, s3); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsenon_var_token() { + var s0, s1, s2; + peg$silentFails++; + s0 = peg$currPos; + s1 = peg$currPos; + peg$silentFails++; + s2 = peg$parsevar(); + peg$silentFails--; + if (s2 === peg$FAILED) { + s1 = void 0; + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + if (s1 !== peg$FAILED) { + s2 = peg$parsetoken(); + if (s2 !== peg$FAILED) { + s0 = peg$f13(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e6); + } + } + return s0; + } + function peg$parsenon_sep_token() { + var s0, s1, s2; + s0 = peg$currPos; + s1 = peg$currPos; + peg$silentFails++; + s2 = peg$parsesep(); + if (s2 === peg$FAILED) { + s2 = peg$parsetrailing_comment(); + if (s2 === peg$FAILED) { + s2 = peg$parseown_line_comment(); + } + } + peg$silentFails--; + if (s2 === peg$FAILED) { + s1 = void 0; + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + if (s1 !== peg$FAILED) { + if (input.length > peg$currPos) { + s2 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e2); + } + } + if (s2 !== peg$FAILED) { + s0 = peg$f14(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsetoken() { + var s0, s1, s2; + peg$silentFails++; + s0 = peg$currPos; + s1 = peg$currPos; + peg$silentFails++; + s2 = peg$parsesep(); + if (s2 === peg$FAILED) { + s2 = peg$parseat(); + if (s2 === peg$FAILED) { + s2 = peg$parseoperation(); + if (s2 === peg$FAILED) { + s2 = peg$parseequals(); + if (s2 === peg$FAILED) { + s2 = peg$parsetrailing_comment(); + if (s2 === peg$FAILED) { + s2 = peg$parseown_line_comment(); + } + } + } + } + } + peg$silentFails--; + if (s2 === peg$FAILED) { + s1 = void 0; + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + if (s1 !== peg$FAILED) { + if (input.length > peg$currPos) { + s2 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e2); + } + } + if (s2 !== peg$FAILED) { + s0 = peg$f15(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e7); + } + } + return s0; + } + function peg$parsesame_line_comment() { + var s0, s1, s2; + peg$silentFails++; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e2); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f16(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s0 = peg$f17(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e8); + } + } + return s0; + } + function peg$parseown_line_comment() { + var s0, s1, s2; + peg$silentFails++; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e2); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f18(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s0 = peg$f19(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e9); + } + } + return s0; + } + function peg$parse_() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e2); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f20(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s0 = peg$f21(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsesep() { + var s0, s1, s2; + peg$silentFails++; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e2); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f22(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s0 = peg$f23(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e10); + } + } + return s0; + } + function peg$parseat() { + var s0, s1, s2; + peg$silentFails++; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e2); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f24(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s0 = peg$f25(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e11); + } + } + return s0; + } + function peg$parsevar_token() { + var s0, s1, s2; + peg$silentFails++; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e2); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f26(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s0 = peg$f27(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e12); + } + } + return s0; + } + function peg$parseoperation() { + var s0, s1, s2, s3, s4; + peg$silentFails++; + s0 = peg$currPos; + s1 = []; + s2 = peg$parse_(); + while (s2 !== peg$FAILED) { + s1.push(s2); + s2 = peg$parse_(); + } + if (input.length > peg$currPos) { + s2 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e2); + } + } + if (s2 !== peg$FAILED) { + s3 = []; + s4 = peg$parse_(); + while (s4 !== peg$FAILED) { + s3.push(s4); + s4 = peg$parse_(); + } + s4 = peg$f28(s2); + if (s4) { + s4 = void 0; + } else { + s4 = peg$FAILED; + } + if (s4 !== peg$FAILED) { + s0 = peg$f29(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e13); + } + } + return s0; + } + function peg$parseequals() { + var s0, s1, s2; + peg$silentFails++; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e2); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f30(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s0 = peg$f31(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e14); + } + } + return s0; + } + function peg$parsesubscript() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e2); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f32(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s0 = peg$f33(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parseEOL() { + var s0, s1; + s0 = peg$currPos; + peg$silentFails++; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e2); + } + } + peg$silentFails--; + if (s1 === peg$FAILED) { + s0 = void 0; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + if (!options2.isWhitespace) { + try { + Object.assign(options2, { + isSep: (node) => node.type === "string" && node.content === ",", + isVar: (node) => node.type === "string" && node.content.match(/[a-zA-Z]/), + isOperation: (node) => node.type === "string" && node.content.match(/[+-]/), + isEquals: (node) => node.type === "string" && node.content === "=", + isAt: (node) => node.type === "string" && node.content === "@", + isSubscript: (node) => node.content === "_", + isWhitespace: (node) => node.type === "whitespace", + isSameLineComment: (node) => node.type === "comment" && node.sameline, + isOwnLineComment: (node) => node.type === "comment" && !node.sameline + }); + } catch (e) { + console.warn("Error when initializing parser", e); + } + } + peg$result = peg$startRuleFunction(); + if (peg$result !== peg$FAILED && peg$currPos === input.length) { + return peg$result; + } else { + if (peg$result !== peg$FAILED && peg$currPos < input.length) { + peg$fail(peg$endExpectation()); + } + throw peg$buildStructuredError( + peg$maxFailExpected, + peg$maxFailPos < input.length ? input.charAt(peg$maxFailPos) : null, + peg$maxFailPos < input.length ? peg$computeLocation(peg$maxFailPos, peg$maxFailPos + 1) : peg$computeLocation(peg$maxFailPos, peg$maxFailPos) + ); + } + } + return { + SyntaxError: peg$SyntaxError, + parse: peg$parse + }; +})(); +// Generated by Peggy 2.0.1. +// +// https://peggyjs.org/ +(function() { + function peg$subclass(child, parent) { + function C() { + this.constructor = child; + } + C.prototype = parent.prototype; + child.prototype = new C(); + } + function peg$SyntaxError(message, expected, found, location) { + var self = Error.call(this, message); + if (Object.setPrototypeOf) { + Object.setPrototypeOf(self, peg$SyntaxError.prototype); + } + self.expected = expected; + self.found = found; + self.location = location; + self.name = "SyntaxError"; + return self; + } + peg$subclass(peg$SyntaxError, Error); + function peg$padEnd(str, targetLength, padString) { + padString = padString || " "; + if (str.length > targetLength) { + return str; + } + targetLength -= str.length; + padString += padString.repeat(targetLength); + return str + padString.slice(0, targetLength); + } + peg$SyntaxError.prototype.format = function(sources) { + var str = "Error: " + this.message; + if (this.location) { + var src = null; + var k; + for (k = 0; k < sources.length; k++) { + if (sources[k].source === this.location.source) { + src = sources[k].text.split(/\r\n|\n|\r/g); + break; + } + } + var s2 = this.location.start; + var loc = this.location.source + ":" + s2.line + ":" + s2.column; + if (src) { + var e = this.location.end; + var filler = peg$padEnd("", s2.line.toString().length, " "); + var line3 = src[s2.line - 1]; + var last = s2.line === e.line ? e.column : line3.length + 1; + var hatLen = last - s2.column || 1; + str += "\n --> " + loc + "\n" + filler + " |\n" + s2.line + " | " + line3 + "\n" + filler + " | " + peg$padEnd("", s2.column - 1, " ") + peg$padEnd("", hatLen, "^"); + } else { + str += "\n at " + loc; + } + } + return str; + }; + peg$SyntaxError.buildMessage = function(expected, found) { + var DESCRIBE_EXPECTATION_FNS = { + literal: function(expectation) { + return '"' + literalEscape(expectation.text) + '"'; + }, + class: function(expectation) { + var escapedParts = expectation.parts.map(function(part) { + return Array.isArray(part) ? classEscape(part[0]) + "-" + classEscape(part[1]) : classEscape(part); + }); + return "[" + (expectation.inverted ? "^" : "") + escapedParts.join("") + "]"; + }, + any: function() { + return "any character"; + }, + end: function() { + return "end of input"; + }, + other: function(expectation) { + return expectation.description; + } + }; + function hex(ch) { + return ch.charCodeAt(0).toString(16).toUpperCase(); + } + function literalEscape(s2) { + return s2.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\0/g, "\\0").replace(/\t/g, "\\t").replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/[\x00-\x0F]/g, function(ch) { + return "\\x0" + hex(ch); + }).replace(/[\x10-\x1F\x7F-\x9F]/g, function(ch) { + return "\\x" + hex(ch); + }); + } + function classEscape(s2) { + return s2.replace(/\\/g, "\\\\").replace(/\]/g, "\\]").replace(/\^/g, "\\^").replace(/-/g, "\\-").replace(/\0/g, "\\0").replace(/\t/g, "\\t").replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/[\x00-\x0F]/g, function(ch) { + return "\\x0" + hex(ch); + }).replace(/[\x10-\x1F\x7F-\x9F]/g, function(ch) { + return "\\x" + hex(ch); + }); + } + function describeExpectation(expectation) { + return DESCRIBE_EXPECTATION_FNS[expectation.type](expectation); + } + function describeExpected(expected2) { + var descriptions = expected2.map(describeExpectation); + var i, j; + descriptions.sort(); + if (descriptions.length > 0) { + for (i = 1, j = 1; i < descriptions.length; i++) { + if (descriptions[i - 1] !== descriptions[i]) { + descriptions[j] = descriptions[i]; + j++; + } + } + descriptions.length = j; + } + switch (descriptions.length) { + case 1: + return descriptions[0]; + case 2: + return descriptions[0] + " or " + descriptions[1]; + default: + return descriptions.slice(0, -1).join(", ") + ", or " + descriptions[descriptions.length - 1]; + } + } + function describeFound(found2) { + return found2 ? '"' + literalEscape(found2) + '"' : "end of input"; + } + return "Expected " + describeExpected(expected) + " but " + describeFound(found) + " found."; + }; + function peg$parse(input, options2) { + options2 = options2 !== void 0 ? options2 : {}; + var peg$FAILED = {}; + var peg$source = options2.grammarSource; + var peg$startRuleFunctions = { root: peg$parseroot }; + var peg$startRuleFunction = peg$parseroot; + var peg$c0 = "plus"; + var peg$c1 = "minus"; + var peg$c2 = "pt"; + var peg$c3 = "mm"; + var peg$c4 = "cm"; + var peg$c5 = "in"; + var peg$c6 = "ex"; + var peg$c7 = "em"; + var peg$c8 = "bp"; + var peg$c9 = "pc"; + var peg$c10 = "dd"; + var peg$c11 = "cc"; + var peg$c12 = "nd"; + var peg$c13 = "nc"; + var peg$c14 = "sp"; + var peg$c15 = "filll"; + var peg$c16 = "fill"; + var peg$c17 = "fil"; + var peg$c18 = "."; + var peg$c19 = "+"; + var peg$c20 = "-"; + var peg$r0 = /^[0-9]/; + var peg$e0 = peg$anyExpectation(); + var peg$e1 = peg$literalExpectation("plus", false); + var peg$e2 = peg$literalExpectation("minus", false); + var peg$e3 = peg$literalExpectation("pt", false); + var peg$e4 = peg$literalExpectation("mm", false); + var peg$e5 = peg$literalExpectation("cm", false); + var peg$e6 = peg$literalExpectation("in", false); + var peg$e7 = peg$literalExpectation("ex", false); + var peg$e8 = peg$literalExpectation("em", false); + var peg$e9 = peg$literalExpectation("bp", false); + var peg$e10 = peg$literalExpectation("pc", false); + var peg$e11 = peg$literalExpectation("dd", false); + var peg$e12 = peg$literalExpectation("cc", false); + var peg$e13 = peg$literalExpectation("nd", false); + var peg$e14 = peg$literalExpectation("nc", false); + var peg$e15 = peg$literalExpectation("sp", false); + var peg$e16 = peg$literalExpectation("filll", false); + var peg$e17 = peg$literalExpectation("fill", false); + var peg$e18 = peg$literalExpectation("fil", false); + var peg$e19 = peg$otherExpectation("number"); + var peg$e20 = peg$classExpectation([["0", "9"]], false, false); + var peg$e21 = peg$literalExpectation(".", false); + var peg$e22 = peg$literalExpectation("+", false); + var peg$e23 = peg$literalExpectation("-", false); + var peg$f0 = function(b, st, sh) { + return { + type: "glue", + fixed: b, + stretchable: st, + shrinkable: sh, + position: location() + }; + }; + var peg$f1 = function(glue) { + return glue; + }; + var peg$f2 = function(n, u) { + return { type: "dim", value: n, unit: u }; + }; + var peg$f3 = function(n, u) { + return { type: "dim", value: n, unit: u }; + }; + var peg$f4 = function(n, u) { + return { type: "dim", value: n, unit: u }; + }; + var peg$f5 = function(n) { + return parseFloat(n); + }; + var peg$currPos = 0; + var peg$savedPos = 0; + var peg$posDetailsCache = [{ line: 1, column: 1 }]; + var peg$maxFailPos = 0; + var peg$maxFailExpected = []; + var peg$silentFails = 0; + var peg$result; + if ("startRule" in options2) { + if (!(options2.startRule in peg$startRuleFunctions)) { + throw new Error(`Can't start parsing from rule "` + options2.startRule + '".'); + } + peg$startRuleFunction = peg$startRuleFunctions[options2.startRule]; + } + function location() { + return peg$computeLocation(peg$savedPos, peg$currPos); + } + function peg$literalExpectation(text2, ignoreCase) { + return { type: "literal", text: text2, ignoreCase }; + } + function peg$classExpectation(parts, inverted, ignoreCase) { + return { type: "class", parts, inverted, ignoreCase }; + } + function peg$anyExpectation() { + return { type: "any" }; + } + function peg$endExpectation() { + return { type: "end" }; + } + function peg$otherExpectation(description) { + return { type: "other", description }; + } + function peg$computePosDetails(pos) { + var details = peg$posDetailsCache[pos]; + var p; + if (details) { + return details; + } else { + p = pos - 1; + while (!peg$posDetailsCache[p]) { + p--; + } + details = peg$posDetailsCache[p]; + details = { + line: details.line, + column: details.column + }; + while (p < pos) { + if (input.charCodeAt(p) === 10) { + details.line++; + details.column = 1; + } else { + details.column++; + } + p++; + } + peg$posDetailsCache[pos] = details; + return details; + } + } + function peg$computeLocation(startPos, endPos) { + var startPosDetails = peg$computePosDetails(startPos); + var endPosDetails = peg$computePosDetails(endPos); + return { + source: peg$source, + start: { + offset: startPos, + line: startPosDetails.line, + column: startPosDetails.column + }, + end: { + offset: endPos, + line: endPosDetails.line, + column: endPosDetails.column + } + }; + } + function peg$fail(expected2) { + if (peg$currPos < peg$maxFailPos) { + return; + } + if (peg$currPos > peg$maxFailPos) { + peg$maxFailPos = peg$currPos; + peg$maxFailExpected = []; + } + peg$maxFailExpected.push(expected2); + } + function peg$buildStructuredError(expected2, found, location2) { + return new peg$SyntaxError( + peg$SyntaxError.buildMessage(expected2, found), + expected2, + found, + location2 + ); + } + function peg$parseroot() { + var s0, s1, s2, s3, s4; + s0 = peg$currPos; + s1 = peg$currPos; + s2 = peg$parsebase(); + if (s2 !== peg$FAILED) { + s3 = peg$parsestretchable(); + if (s3 === peg$FAILED) { + s3 = null; + } + s4 = peg$parseshrinkable(); + if (s4 === peg$FAILED) { + s4 = null; + } + peg$savedPos = s1; + s1 = peg$f0(s2, s3, s4); + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + if (s1 !== peg$FAILED) { + s2 = []; + if (input.length > peg$currPos) { + s3 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s3 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + while (s3 !== peg$FAILED) { + s2.push(s3); + if (input.length > peg$currPos) { + s3 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s3 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + } + peg$savedPos = s0; + s0 = peg$f1(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsebase() { + var s0, s1, s2; + s0 = peg$currPos; + s1 = peg$parsenumber(); + if (s1 !== peg$FAILED) { + s2 = peg$parseunit(); + if (s2 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f2(s1, s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsestretchable() { + var s0, s1, s2, s3; + s0 = peg$currPos; + if (input.substr(peg$currPos, 4) === peg$c0) { + s1 = peg$c0; + peg$currPos += 4; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e1); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$parsenumber(); + if (s2 !== peg$FAILED) { + s3 = peg$parserubber_unit(); + if (s3 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f3(s2, s3); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parseshrinkable() { + var s0, s1, s2, s3; + s0 = peg$currPos; + if (input.substr(peg$currPos, 5) === peg$c1) { + s1 = peg$c1; + peg$currPos += 5; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e2); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$parsenumber(); + if (s2 !== peg$FAILED) { + s3 = peg$parserubber_unit(); + if (s3 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f4(s2, s3); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parseunit() { + var s0; + if (input.substr(peg$currPos, 2) === peg$c2) { + s0 = peg$c2; + peg$currPos += 2; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s0 === peg$FAILED) { + if (input.substr(peg$currPos, 2) === peg$c3) { + s0 = peg$c3; + peg$currPos += 2; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e4); + } + } + if (s0 === peg$FAILED) { + if (input.substr(peg$currPos, 2) === peg$c4) { + s0 = peg$c4; + peg$currPos += 2; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e5); + } + } + if (s0 === peg$FAILED) { + if (input.substr(peg$currPos, 2) === peg$c5) { + s0 = peg$c5; + peg$currPos += 2; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e6); + } + } + if (s0 === peg$FAILED) { + if (input.substr(peg$currPos, 2) === peg$c6) { + s0 = peg$c6; + peg$currPos += 2; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e7); + } + } + if (s0 === peg$FAILED) { + if (input.substr(peg$currPos, 2) === peg$c7) { + s0 = peg$c7; + peg$currPos += 2; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e8); + } + } + if (s0 === peg$FAILED) { + if (input.substr(peg$currPos, 2) === peg$c8) { + s0 = peg$c8; + peg$currPos += 2; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e9); + } + } + if (s0 === peg$FAILED) { + if (input.substr(peg$currPos, 2) === peg$c9) { + s0 = peg$c9; + peg$currPos += 2; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e10); + } + } + if (s0 === peg$FAILED) { + if (input.substr(peg$currPos, 2) === peg$c10) { + s0 = peg$c10; + peg$currPos += 2; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e11); + } + } + if (s0 === peg$FAILED) { + if (input.substr(peg$currPos, 2) === peg$c11) { + s0 = peg$c11; + peg$currPos += 2; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e12); + } + } + if (s0 === peg$FAILED) { + if (input.substr(peg$currPos, 2) === peg$c12) { + s0 = peg$c12; + peg$currPos += 2; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e13); + } + } + if (s0 === peg$FAILED) { + if (input.substr(peg$currPos, 2) === peg$c13) { + s0 = peg$c13; + peg$currPos += 2; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e14); + } + } + if (s0 === peg$FAILED) { + if (input.substr(peg$currPos, 2) === peg$c14) { + s0 = peg$c14; + peg$currPos += 2; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e15); + } + } + } + } + } + } + } + } + } + } + } + } + } + } + return s0; + } + function peg$parserubber_unit() { + var s0; + s0 = peg$parseunit(); + if (s0 === peg$FAILED) { + if (input.substr(peg$currPos, 5) === peg$c15) { + s0 = peg$c15; + peg$currPos += 5; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e16); + } + } + if (s0 === peg$FAILED) { + if (input.substr(peg$currPos, 4) === peg$c16) { + s0 = peg$c16; + peg$currPos += 4; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e17); + } + } + if (s0 === peg$FAILED) { + if (input.substr(peg$currPos, 3) === peg$c17) { + s0 = peg$c17; + peg$currPos += 3; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e18); + } + } + } + } + } + return s0; + } + function peg$parsenumber() { + var s0, s1, s2, s3, s4, s5, s6, s7, s8; + peg$silentFails++; + s0 = peg$currPos; + s1 = peg$currPos; + s2 = peg$currPos; + s3 = peg$parsesign(); + if (s3 === peg$FAILED) { + s3 = null; + } + s4 = peg$currPos; + s5 = []; + if (peg$r0.test(input.charAt(peg$currPos))) { + s6 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s6 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e20); + } + } + while (s6 !== peg$FAILED) { + s5.push(s6); + if (peg$r0.test(input.charAt(peg$currPos))) { + s6 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s6 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e20); + } + } + } + if (input.charCodeAt(peg$currPos) === 46) { + s6 = peg$c18; + peg$currPos++; + } else { + s6 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e21); + } + } + if (s6 !== peg$FAILED) { + s7 = []; + if (peg$r0.test(input.charAt(peg$currPos))) { + s8 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s8 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e20); + } + } + if (s8 !== peg$FAILED) { + while (s8 !== peg$FAILED) { + s7.push(s8); + if (peg$r0.test(input.charAt(peg$currPos))) { + s8 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s8 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e20); + } + } + } + } else { + s7 = peg$FAILED; + } + if (s7 !== peg$FAILED) { + s5 = [s5, s6, s7]; + s4 = s5; + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + if (s4 === peg$FAILED) { + s4 = []; + if (peg$r0.test(input.charAt(peg$currPos))) { + s5 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s5 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e20); + } + } + if (s5 !== peg$FAILED) { + while (s5 !== peg$FAILED) { + s4.push(s5); + if (peg$r0.test(input.charAt(peg$currPos))) { + s5 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s5 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e20); + } + } + } + } else { + s4 = peg$FAILED; + } + } + if (s4 !== peg$FAILED) { + s3 = [s3, s4]; + s2 = s3; + } else { + peg$currPos = s2; + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s1 = input.substring(s1, peg$currPos); + } else { + s1 = s2; + } + if (s1 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$f5(s1); + } + s0 = s1; + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e19); + } + } + return s0; + } + function peg$parsesign() { + var s0; + if (input.charCodeAt(peg$currPos) === 43) { + s0 = peg$c19; + peg$currPos++; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e22); + } + } + if (s0 === peg$FAILED) { + if (input.charCodeAt(peg$currPos) === 45) { + s0 = peg$c20; + peg$currPos++; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e23); + } + } + } + return s0; + } + peg$result = peg$startRuleFunction(); + if (peg$result !== peg$FAILED && peg$currPos === input.length) { + return peg$result; + } else { + if (peg$result !== peg$FAILED && peg$currPos < input.length) { + peg$fail(peg$endExpectation()); + } + throw peg$buildStructuredError( + peg$maxFailExpected, + peg$maxFailPos < input.length ? input.charAt(peg$maxFailPos) : null, + peg$maxFailPos < input.length ? peg$computeLocation(peg$maxFailPos, peg$maxFailPos + 1) : peg$computeLocation(peg$maxFailPos, peg$maxFailPos) + ); + } + } + return { + SyntaxError: peg$SyntaxError, + parse: peg$parse + }; +})(); +var tikz_default = ( + // Generated by Peggy 2.0.1. + // + // https://peggyjs.org/ + function() { + function peg$subclass(child, parent) { + function C() { + this.constructor = child; + } + C.prototype = parent.prototype; + child.prototype = new C(); + } + function peg$SyntaxError(message, expected, found, location) { + var self = Error.call(this, message); + if (Object.setPrototypeOf) { + Object.setPrototypeOf(self, peg$SyntaxError.prototype); + } + self.expected = expected; + self.found = found; + self.location = location; + self.name = "SyntaxError"; + return self; + } + peg$subclass(peg$SyntaxError, Error); + function peg$padEnd(str, targetLength, padString) { + padString = padString || " "; + if (str.length > targetLength) { + return str; + } + targetLength -= str.length; + padString += padString.repeat(targetLength); + return str + padString.slice(0, targetLength); + } + peg$SyntaxError.prototype.format = function(sources) { + var str = "Error: " + this.message; + if (this.location) { + var src = null; + var k; + for (k = 0; k < sources.length; k++) { + if (sources[k].source === this.location.source) { + src = sources[k].text.split(/\r\n|\n|\r/g); + break; + } + } + var s2 = this.location.start; + var loc = this.location.source + ":" + s2.line + ":" + s2.column; + if (src) { + var e = this.location.end; + var filler = peg$padEnd("", s2.line.toString().length, " "); + var line3 = src[s2.line - 1]; + var last = s2.line === e.line ? e.column : line3.length + 1; + var hatLen = last - s2.column || 1; + str += "\n --> " + loc + "\n" + filler + " |\n" + s2.line + " | " + line3 + "\n" + filler + " | " + peg$padEnd("", s2.column - 1, " ") + peg$padEnd("", hatLen, "^"); + } else { + str += "\n at " + loc; + } + } + return str; + }; + peg$SyntaxError.buildMessage = function(expected, found) { + var DESCRIBE_EXPECTATION_FNS = { + literal: function(expectation) { + return '"' + literalEscape(expectation.text) + '"'; + }, + class: function(expectation) { + var escapedParts = expectation.parts.map(function(part) { + return Array.isArray(part) ? classEscape(part[0]) + "-" + classEscape(part[1]) : classEscape(part); + }); + return "[" + (expectation.inverted ? "^" : "") + escapedParts.join("") + "]"; + }, + any: function() { + return "any character"; + }, + end: function() { + return "end of input"; + }, + other: function(expectation) { + return expectation.description; + } + }; + function hex(ch) { + return ch.charCodeAt(0).toString(16).toUpperCase(); + } + function literalEscape(s2) { + return s2.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\0/g, "\\0").replace(/\t/g, "\\t").replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/[\x00-\x0F]/g, function(ch) { + return "\\x0" + hex(ch); + }).replace(/[\x10-\x1F\x7F-\x9F]/g, function(ch) { + return "\\x" + hex(ch); + }); + } + function classEscape(s2) { + return s2.replace(/\\/g, "\\\\").replace(/\]/g, "\\]").replace(/\^/g, "\\^").replace(/-/g, "\\-").replace(/\0/g, "\\0").replace(/\t/g, "\\t").replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/[\x00-\x0F]/g, function(ch) { + return "\\x0" + hex(ch); + }).replace(/[\x10-\x1F\x7F-\x9F]/g, function(ch) { + return "\\x" + hex(ch); + }); + } + function describeExpectation(expectation) { + return DESCRIBE_EXPECTATION_FNS[expectation.type](expectation); + } + function describeExpected(expected2) { + var descriptions = expected2.map(describeExpectation); + var i, j; + descriptions.sort(); + if (descriptions.length > 0) { + for (i = 1, j = 1; i < descriptions.length; i++) { + if (descriptions[i - 1] !== descriptions[i]) { + descriptions[j] = descriptions[i]; + j++; + } + } + descriptions.length = j; + } + switch (descriptions.length) { + case 1: + return descriptions[0]; + case 2: + return descriptions[0] + " or " + descriptions[1]; + default: + return descriptions.slice(0, -1).join(", ") + ", or " + descriptions[descriptions.length - 1]; + } + } + function describeFound(found2) { + return found2 ? '"' + literalEscape(found2) + '"' : "end of input"; + } + return "Expected " + describeExpected(expected) + " but " + describeFound(found) + " found."; + }; + function peg$parse(input, options2) { + options2 = options2 !== void 0 ? options2 : {}; + var peg$FAILED = {}; + var peg$source = options2.grammarSource; + var peg$startRuleFunctions = { path_spec: peg$parsepath_spec, foreach_body: peg$parseforeach_body }; + var peg$startRuleFunction = peg$parsepath_spec; + var peg$e0 = peg$anyExpectation(); + var peg$e3 = peg$otherExpectation("comment"); + var peg$e4 = peg$otherExpectation("floating comment"); + var peg$e5 = peg$otherExpectation("operation"); + var peg$e6 = peg$otherExpectation("="); + var peg$f0 = function(v) { + return v; + }; + var peg$f1 = function(ops) { + return { type: "path_spec", content: ops }; + }; + var peg$f2 = function(c1, op, comment) { + return { op, comment }; + }; + var peg$f3 = function(c1, ops, c2, body) { + const comments = [c1, ...ops.map((x) => x.comment), c2].filter( + (x) => x + ); + const attribute = ops.map((x) => x.op.content.content).join(" "); + return { + type: "animation", + comments, + attribute, + content: body.content + }; + }; + var peg$f4 = function(start, b) { + return { ...b, start, type: "foreach" }; + }; + var peg$f5 = function(c1, variables, options22, c2, c3, list, c4, command) { + const comments = [c1, c2, c3, c4].filter((x) => x); + return { + type: "foreach_body", + variables, + options: options22 && options22.content, + list, + command, + comments + }; + }; + var peg$f6 = function(c1, options22, c2, body) { + const comments = [c1, c2].filter((x) => x); + return { + type: "svg_operation", + options: options22 && options22.content, + content: body, + comments + }; + }; + var peg$f7 = function(c1, c2, coord, c3, c4, x) { + return { coord: x, comment: c4 }; + }; + var peg$f8 = function(c1, c2, coord, c3, a, c5) { + const comments = [c1, c2, c3, a && a.comment, c5].filter((x) => x); + return { + type: "curve_to", + controls: a ? [coord, a.coord] : [coord], + comments + }; + }; + var peg$f9 = function() { + return { type: "line_to", command: "|-" }; + }; + var peg$f10 = function() { + return { type: "line_to", command: "-|" }; + }; + var peg$f11 = function() { + return { type: "line_to", command: "--" }; + }; + var peg$f12 = function(prefix, content) { + return { type: "coordinate", content, prefix }; + }; + var peg$f13 = function(content) { + return { type: "square_brace_group", content }; + }; + var peg$f14 = function(v) { + return { type: "unknown", content: v }; + }; + var peg$f19 = function(tok) { + return options2.isComment(tok); + }; + var peg$f20 = function(tok) { + return tok; + }; + var peg$f21 = function(tok) { + return options2.isWhitespace(tok); + }; + var peg$f22 = function(tok) { + return tok; + }; + var peg$f23 = function(c) { + return c; + }; + var peg$f24 = function(tok) { + return options2.isOperation(tok); + }; + var peg$f25 = function(tok) { + return { type: "operation", content: tok }; + }; + var peg$f26 = function(tok) { + return options2.isChar(tok, "="); + }; + var peg$f27 = function(tok) { + return tok; + }; + var peg$f28 = function(tok) { + return options2.isChar(tok, "["); + }; + var peg$f29 = function(tok) { + return tok; + }; + var peg$f30 = function(tok) { + return options2.isChar(tok, "]"); + }; + var peg$f31 = function(tok) { + return tok; + }; + var peg$f32 = function(tok) { + return options2.isChar(tok, "("); + }; + var peg$f33 = function(tok) { + return tok; + }; + var peg$f34 = function(tok) { + return options2.isChar(tok, ")"); + }; + var peg$f35 = function(tok) { + return tok; + }; + var peg$f36 = function(tok) { + return options2.isChar(tok, "+"); + }; + var peg$f37 = function(tok) { + return tok; + }; + var peg$f38 = function(tok) { + return options2.isChar(tok, "-"); + }; + var peg$f39 = function(tok) { + return tok; + }; + var peg$f40 = function(tok) { + return options2.isChar(tok, "|"); + }; + var peg$f41 = function(tok) { + return tok; + }; + var peg$f42 = function(tok) { + return options2.isChar(tok, "."); + }; + var peg$f43 = function(tok) { + return tok; + }; + var peg$f44 = function(tok) { + return options2.isChar(tok, "controls"); + }; + var peg$f45 = function(tok) { + return tok; + }; + var peg$f46 = function(tok) { + return options2.isChar(tok, "and"); + }; + var peg$f47 = function(tok) { + return tok; + }; + var peg$f48 = function(tok) { + return options2.isChar(tok, "svg"); + }; + var peg$f49 = function(tok) { + return tok; + }; + var peg$f50 = function(tok) { + return options2.isGroup(tok); + }; + var peg$f51 = function(tok) { + return tok; + }; + var peg$f52 = function(tok) { + return options2.isAnyMacro(tok); + }; + var peg$f53 = function(tok) { + return tok; + }; + var peg$f54 = function(tok) { + return options2.isChar(tok, "foreach"); + }; + var peg$f55 = function(tok) { + return tok; + }; + var peg$f56 = function(tok) { + return options2.isMacro(tok, "foreach"); + }; + var peg$f57 = function(tok) { + return tok; + }; + var peg$f58 = function(tok) { + return options2.isChar(tok, "in"); + }; + var peg$f59 = function(tok) { + return tok; + }; + var peg$f60 = function(tok) { + return options2.isChar(tok, ":"); + }; + var peg$f61 = function(tok) { + return tok; + }; + var peg$currPos = 0; + var peg$posDetailsCache = [{ line: 1, column: 1 }]; + var peg$maxFailPos = 0; + var peg$maxFailExpected = []; + var peg$silentFails = 0; + var peg$result; + if ("startRule" in options2) { + if (!(options2.startRule in peg$startRuleFunctions)) { + throw new Error(`Can't start parsing from rule "` + options2.startRule + '".'); + } + peg$startRuleFunction = peg$startRuleFunctions[options2.startRule]; + } + function peg$anyExpectation() { + return { type: "any" }; + } + function peg$endExpectation() { + return { type: "end" }; + } + function peg$otherExpectation(description) { + return { type: "other", description }; + } + function peg$computePosDetails(pos) { + var details = peg$posDetailsCache[pos]; + var p; + if (details) { + return details; + } else { + p = pos - 1; + while (!peg$posDetailsCache[p]) { + p--; + } + details = peg$posDetailsCache[p]; + details = { + line: details.line, + column: details.column + }; + while (p < pos) { + if (input.charCodeAt(p) === 10) { + details.line++; + details.column = 1; + } else { + details.column++; + } + p++; + } + peg$posDetailsCache[pos] = details; + return details; + } + } + function peg$computeLocation(startPos, endPos) { + var startPosDetails = peg$computePosDetails(startPos); + var endPosDetails = peg$computePosDetails(endPos); + return { + source: peg$source, + start: { + offset: startPos, + line: startPosDetails.line, + column: startPosDetails.column + }, + end: { + offset: endPos, + line: endPosDetails.line, + column: endPosDetails.column + } + }; + } + function peg$fail(expected2) { + if (peg$currPos < peg$maxFailPos) { + return; + } + if (peg$currPos > peg$maxFailPos) { + peg$maxFailPos = peg$currPos; + peg$maxFailExpected = []; + } + peg$maxFailExpected.push(expected2); + } + function peg$buildStructuredError(expected2, found, location2) { + return new peg$SyntaxError( + peg$SyntaxError.buildMessage(expected2, found), + expected2, + found, + location2 + ); + } + function peg$parsepath_spec() { + var s0, s1, s2, s3, s4, s5; + s0 = peg$currPos; + s1 = []; + s2 = peg$currPos; + s3 = peg$parsesquare_brace_group(); + if (s3 === peg$FAILED) { + s3 = peg$parsecoordinate(); + if (s3 === peg$FAILED) { + s3 = peg$parsecurve_to(); + if (s3 === peg$FAILED) { + s3 = peg$parseline_to(); + if (s3 === peg$FAILED) { + s3 = peg$parsesvg(); + if (s3 === peg$FAILED) { + s3 = peg$parseforeach(); + if (s3 === peg$FAILED) { + s3 = peg$parseoperation(); + if (s3 === peg$FAILED) { + s3 = peg$parsecomment(); + if (s3 === peg$FAILED) { + s3 = peg$parseanimation(); + if (s3 === peg$FAILED) { + s3 = peg$parseunknown(); + } + } + } + } + } + } + } + } + } + if (s3 !== peg$FAILED) { + s4 = []; + s5 = peg$parse_(); + while (s5 !== peg$FAILED) { + s4.push(s5); + s5 = peg$parse_(); + } + s2 = peg$f0(s3); + } else { + peg$currPos = s2; + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + while (s2 !== peg$FAILED) { + s1.push(s2); + s2 = peg$currPos; + s3 = peg$parsesquare_brace_group(); + if (s3 === peg$FAILED) { + s3 = peg$parsecoordinate(); + if (s3 === peg$FAILED) { + s3 = peg$parsecurve_to(); + if (s3 === peg$FAILED) { + s3 = peg$parseline_to(); + if (s3 === peg$FAILED) { + s3 = peg$parsesvg(); + if (s3 === peg$FAILED) { + s3 = peg$parseforeach(); + if (s3 === peg$FAILED) { + s3 = peg$parseoperation(); + if (s3 === peg$FAILED) { + s3 = peg$parsecomment(); + if (s3 === peg$FAILED) { + s3 = peg$parseanimation(); + if (s3 === peg$FAILED) { + s3 = peg$parseunknown(); + } + } + } + } + } + } + } + } + } + if (s3 !== peg$FAILED) { + s4 = []; + s5 = peg$parse_(); + while (s5 !== peg$FAILED) { + s4.push(s5); + s5 = peg$parse_(); + } + s2 = peg$f0(s3); + } else { + peg$currPos = s2; + s2 = peg$FAILED; + } + } + } else { + s1 = peg$FAILED; + } + if (s1 !== peg$FAILED) { + s1 = peg$f1(s1); + } + s0 = s1; + return s0; + } + function peg$parseanimation() { + var s0, s1, s2, s3, s4, s5, s6; + s0 = peg$currPos; + s1 = peg$parsecolon(); + if (s1 !== peg$FAILED) { + s2 = peg$parse_comment_(); + s3 = []; + s4 = peg$currPos; + s5 = peg$parseoperation(); + if (s5 !== peg$FAILED) { + s6 = peg$parse_comment_(); + s4 = peg$f2(s2, s5, s6); + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + if (s4 !== peg$FAILED) { + while (s4 !== peg$FAILED) { + s3.push(s4); + s4 = peg$currPos; + s5 = peg$parseoperation(); + if (s5 !== peg$FAILED) { + s6 = peg$parse_comment_(); + s4 = peg$f2(s2, s5, s6); + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + } + } else { + s3 = peg$FAILED; + } + if (s3 !== peg$FAILED) { + s4 = peg$parseequals(); + if (s4 !== peg$FAILED) { + s5 = peg$parse_comment_(); + s6 = peg$parsegroup(); + if (s6 !== peg$FAILED) { + s0 = peg$f3(s2, s3, s5, s6); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parseforeach() { + var s0, s1, s2; + s0 = peg$currPos; + s1 = peg$parseforeach_keyword(); + if (s1 === peg$FAILED) { + s1 = peg$parseforeach_macro(); + } + if (s1 !== peg$FAILED) { + s2 = peg$parseforeach_body(); + if (s2 !== peg$FAILED) { + s0 = peg$f4(s1, s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parseforeach_body() { + var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9; + s0 = peg$currPos; + s1 = peg$parse_comment_(); + s2 = peg$currPos; + s3 = []; + s4 = peg$currPos; + s5 = peg$currPos; + peg$silentFails++; + s6 = peg$parsein_keyword(); + if (s6 === peg$FAILED) { + s6 = peg$parsesquare_brace_group(); + } + peg$silentFails--; + if (s6 === peg$FAILED) { + s5 = void 0; + } else { + peg$currPos = s5; + s5 = peg$FAILED; + } + if (s5 !== peg$FAILED) { + if (input.length > peg$currPos) { + s6 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s6 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s6 !== peg$FAILED) { + s5 = [s5, s6]; + s4 = s5; + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + while (s4 !== peg$FAILED) { + s3.push(s4); + s4 = peg$currPos; + s5 = peg$currPos; + peg$silentFails++; + s6 = peg$parsein_keyword(); + if (s6 === peg$FAILED) { + s6 = peg$parsesquare_brace_group(); + } + peg$silentFails--; + if (s6 === peg$FAILED) { + s5 = void 0; + } else { + peg$currPos = s5; + s5 = peg$FAILED; + } + if (s5 !== peg$FAILED) { + if (input.length > peg$currPos) { + s6 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s6 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s6 !== peg$FAILED) { + s5 = [s5, s6]; + s4 = s5; + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + } + s2 = input.substring(s2, peg$currPos); + s3 = peg$parsesquare_brace_group(); + if (s3 === peg$FAILED) { + s3 = null; + } + s4 = peg$parse_comment_(); + s5 = peg$parsein_keyword(); + if (s5 !== peg$FAILED) { + s6 = peg$parse_comment_(); + s7 = peg$parsegroup(); + if (s7 === peg$FAILED) { + s7 = peg$parsemacro(); + } + if (s7 !== peg$FAILED) { + s8 = peg$parse_comment_(); + s9 = peg$parseforeach(); + if (s9 === peg$FAILED) { + s9 = peg$parsegroup(); + if (s9 === peg$FAILED) { + s9 = peg$parsemacro(); + } + } + if (s9 !== peg$FAILED) { + s0 = peg$f5(s1, s2, s3, s4, s6, s7, s8, s9); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsesvg() { + var s0, s1, s2, s3, s4, s5; + s0 = peg$currPos; + s1 = peg$parsesvg_keyword(); + if (s1 !== peg$FAILED) { + s2 = peg$parse_comment_(); + s3 = peg$parsesquare_brace_group(); + if (s3 === peg$FAILED) { + s3 = null; + } + s4 = peg$parse_comment_(); + s5 = peg$parsegroup(); + if (s5 !== peg$FAILED) { + s0 = peg$f6(s2, s3, s4, s5); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsecurve_to() { + var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10; + s0 = peg$currPos; + s1 = peg$parsedotdot(); + if (s1 !== peg$FAILED) { + s2 = peg$parse_comment_(); + s3 = peg$parsecontrols_keyword(); + if (s3 !== peg$FAILED) { + s4 = peg$parse_comment_(); + s5 = peg$parsecoordinate(); + if (s5 !== peg$FAILED) { + s6 = peg$parse_comment_(); + s7 = peg$currPos; + s8 = peg$parseand_keyword(); + if (s8 !== peg$FAILED) { + s9 = peg$parse_comment_(); + s10 = peg$parsecoordinate(); + if (s10 !== peg$FAILED) { + s7 = peg$f7(s2, s4, s5, s6, s9, s10); + } else { + peg$currPos = s7; + s7 = peg$FAILED; + } + } else { + peg$currPos = s7; + s7 = peg$FAILED; + } + if (s7 === peg$FAILED) { + s7 = null; + } + s8 = peg$parse_comment_(); + s9 = peg$parsedotdot(); + if (s9 !== peg$FAILED) { + s0 = peg$f8(s2, s4, s5, s6, s7, s8); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parseline_to() { + var s0, s1, s2; + s0 = peg$currPos; + s1 = peg$parsepipe(); + if (s1 !== peg$FAILED) { + s2 = peg$parseminus(); + if (s2 !== peg$FAILED) { + s0 = peg$f9(); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$parseminus(); + if (s1 !== peg$FAILED) { + s2 = peg$parsepipe(); + if (s2 !== peg$FAILED) { + s0 = peg$f10(); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$parseminus(); + if (s1 !== peg$FAILED) { + s2 = peg$parseminus(); + if (s2 !== peg$FAILED) { + s0 = peg$f11(); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } + } + return s0; + } + function peg$parsecoordinate() { + var s0, s1, s2, s3, s4, s5, s6, s7; + s0 = peg$currPos; + s1 = peg$currPos; + s2 = peg$currPos; + s3 = peg$parseplus(); + if (s3 !== peg$FAILED) { + s4 = peg$parseplus(); + if (s4 === peg$FAILED) { + s4 = null; + } + s3 = [s3, s4]; + s2 = s3; + } else { + peg$currPos = s2; + s2 = peg$FAILED; + } + if (s2 === peg$FAILED) { + s2 = null; + } + s1 = input.substring(s1, peg$currPos); + s2 = peg$parseopen_paren(); + if (s2 !== peg$FAILED) { + s3 = peg$currPos; + s4 = []; + s5 = peg$currPos; + s6 = peg$currPos; + peg$silentFails++; + s7 = peg$parseclose_paren(); + peg$silentFails--; + if (s7 === peg$FAILED) { + s6 = void 0; + } else { + peg$currPos = s6; + s6 = peg$FAILED; + } + if (s6 !== peg$FAILED) { + if (input.length > peg$currPos) { + s7 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s7 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s7 !== peg$FAILED) { + s6 = [s6, s7]; + s5 = s6; + } else { + peg$currPos = s5; + s5 = peg$FAILED; + } + } else { + peg$currPos = s5; + s5 = peg$FAILED; + } + while (s5 !== peg$FAILED) { + s4.push(s5); + s5 = peg$currPos; + s6 = peg$currPos; + peg$silentFails++; + s7 = peg$parseclose_paren(); + peg$silentFails--; + if (s7 === peg$FAILED) { + s6 = void 0; + } else { + peg$currPos = s6; + s6 = peg$FAILED; + } + if (s6 !== peg$FAILED) { + if (input.length > peg$currPos) { + s7 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s7 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s7 !== peg$FAILED) { + s6 = [s6, s7]; + s5 = s6; + } else { + peg$currPos = s5; + s5 = peg$FAILED; + } + } else { + peg$currPos = s5; + s5 = peg$FAILED; + } + } + s3 = input.substring(s3, peg$currPos); + s4 = peg$parseclose_paren(); + if (s4 !== peg$FAILED) { + s0 = peg$f12(s1, s3); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsesquare_brace_group() { + var s0, s1, s2, s3, s4, s5, s6; + s0 = peg$currPos; + s1 = peg$parseopen_square_brace(); + if (s1 !== peg$FAILED) { + s2 = peg$currPos; + s3 = []; + s4 = peg$currPos; + s5 = peg$currPos; + peg$silentFails++; + s6 = peg$parseclose_square_brace(); + peg$silentFails--; + if (s6 === peg$FAILED) { + s5 = void 0; + } else { + peg$currPos = s5; + s5 = peg$FAILED; + } + if (s5 !== peg$FAILED) { + if (input.length > peg$currPos) { + s6 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s6 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s6 !== peg$FAILED) { + s5 = [s5, s6]; + s4 = s5; + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + while (s4 !== peg$FAILED) { + s3.push(s4); + s4 = peg$currPos; + s5 = peg$currPos; + peg$silentFails++; + s6 = peg$parseclose_square_brace(); + peg$silentFails--; + if (s6 === peg$FAILED) { + s5 = void 0; + } else { + peg$currPos = s5; + s5 = peg$FAILED; + } + if (s5 !== peg$FAILED) { + if (input.length > peg$currPos) { + s6 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s6 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s6 !== peg$FAILED) { + s5 = [s5, s6]; + s4 = s5; + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + } + s2 = input.substring(s2, peg$currPos); + s3 = peg$parseclose_square_brace(); + if (s3 !== peg$FAILED) { + s0 = peg$f13(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsedotdot() { + var s0, s1, s2; + s0 = peg$currPos; + s1 = peg$parsedot(); + if (s1 !== peg$FAILED) { + s2 = peg$parsedot(); + if (s2 !== peg$FAILED) { + s1 = [s1, s2]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parseunknown() { + var s0, s1; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + s1 = peg$f14(s1); + } + s0 = s1; + return s0; + } + function peg$parsecomment() { + var s0, s1, s2; + peg$silentFails++; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f19(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s0 = peg$f20(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + return s0; + } + function peg$parse_() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f21(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s0 = peg$f22(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parse_comment_() { + var s0, s1, s2, s3, s4; + peg$silentFails++; + s0 = peg$currPos; + s1 = []; + s2 = peg$parse_(); + while (s2 !== peg$FAILED) { + s1.push(s2); + s2 = peg$parse_(); + } + s2 = peg$parsecomment(); + if (s2 === peg$FAILED) { + s2 = null; + } + s3 = []; + s4 = peg$parse_(); + while (s4 !== peg$FAILED) { + s3.push(s4); + s4 = peg$parse_(); + } + s0 = peg$f23(s2); + peg$silentFails--; + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e4); + } + return s0; + } + function peg$parseoperation() { + var s0, s1, s2; + peg$silentFails++; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f24(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s0 = peg$f25(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e5); + } + } + return s0; + } + function peg$parseequals() { + var s0, s1, s2; + peg$silentFails++; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f26(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s0 = peg$f27(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e6); + } + } + return s0; + } + function peg$parseopen_square_brace() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f28(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s0 = peg$f29(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parseclose_square_brace() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f30(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s0 = peg$f31(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parseopen_paren() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f32(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s0 = peg$f33(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parseclose_paren() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f34(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s0 = peg$f35(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parseplus() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f36(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s0 = peg$f37(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parseminus() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f38(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s0 = peg$f39(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsepipe() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f40(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s0 = peg$f41(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsedot() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f42(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s0 = peg$f43(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsecontrols_keyword() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f44(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s0 = peg$f45(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parseand_keyword() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f46(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s0 = peg$f47(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsesvg_keyword() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f48(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s0 = peg$f49(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsegroup() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f50(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s0 = peg$f51(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsemacro() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f52(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s0 = peg$f53(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parseforeach_keyword() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f54(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s0 = peg$f55(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parseforeach_macro() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f56(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s0 = peg$f57(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsein_keyword() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f58(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s0 = peg$f59(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsecolon() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f60(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s0 = peg$f61(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + if (!options2.isWhitespace) { + try { + Object.assign(options2, { + isChar: (node, char) => node.type === "string" && node.content === char, + isOperation: (node) => node.type === "string" && node.content.match(/[a-zA-Z]/), + isWhitespace: (node) => node.type === "whitespace" || node.type === "parbreak", + isSameLineComment: (node) => node.type === "comment" && node.sameline, + isOwnLineComment: (node) => node.type === "comment" && !node.sameline, + isComment: (node) => node.type === "comment", + isGroup: (node) => node.type === "group", + isMacro: (node, name) => node.type === "macro" && node.content === name, + isAnyMacro: (node) => node.type === "macro" + }); + } catch (e) { + console.warn("Error when initializing parser", e); + } + } + peg$result = peg$startRuleFunction(); + if (peg$result !== peg$FAILED && peg$currPos === input.length) { + return peg$result; + } else { + if (peg$result !== peg$FAILED && peg$currPos < input.length) { + peg$fail(peg$endExpectation()); + } + throw peg$buildStructuredError( + peg$maxFailExpected, + peg$maxFailPos < input.length ? input.charAt(peg$maxFailPos) : null, + peg$maxFailPos < input.length ? peg$computeLocation(peg$maxFailPos, peg$maxFailPos + 1) : peg$computeLocation(peg$maxFailPos, peg$maxFailPos) + ); + } + } + return { + SyntaxError: peg$SyntaxError, + parse: peg$parse + }; + }() +); +var LatexPegParser = latex_default; +var AlignEnvironmentPegParser = align_environment_default; +var ArgSpecPegParser = xparse_argspec_default; +var PgfkeysPegParser = pgfkeys_default; +var TikzPegParser = tikz_default; +var parseCache = {}; +function parse$2(str = "") { + parseCache[str] = parseCache[str] || ArgSpecPegParser.parse(str); + return parseCache[str]; +} +var BRACES_MAP = { + "*": { openMark: "", closeMark: "" }, + "{": { openMark: "{", closeMark: "}" }, + "[": { openMark: "[", closeMark: "]" }, + "(": { openMark: "(", closeMark: ")" }, + "<": { openMark: "<", closeMark: ">" } +}; +var CLOSE_BRACES = new Set( + Object.values(BRACES_MAP).map((x) => x.closeMark).filter((x) => x) +); +function bracesToOpenAndCloseMarks(braces) { + const ret = []; + for (const char of braces.split("")) { + if (CLOSE_BRACES.has(char)) { + continue; + } + const braces2 = BRACES_MAP[char]; + if (braces2 == null) { + throw new Error(`Unknown open/close mark type "${char}"`); + } + ret.push(braces2); + } + return ret; +} +function arg(args2, special) { + if (args2 == null) { + return { type: "argument", content: [], openMark: "", closeMark: "" }; + } + if (typeof args2 === "string") { + args2 = s(args2); + } + if (!Array.isArray(args2) && args2.type === "argument") { + return args2; + } + let openMark = (special == null ? void 0 : special.openMark) ?? "{"; + let closeMark = (special == null ? void 0 : special.closeMark) ?? "}"; + if (special == null ? void 0 : special.braces) { + const braces = bracesToOpenAndCloseMarks(special.braces); + if (braces[0]) { + openMark = braces[0].openMark; + closeMark = braces[0].closeMark; + } + } + if (!Array.isArray(args2)) { + args2 = [args2]; + } + return { type: "argument", content: args2, openMark, closeMark }; +} +function s(value) { + if (typeof value === "string") { + return { type: "string", content: value }; + } + return value; +} +function getDefaultExportFromCjs(x) { + return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, "default") ? x["default"] : x; +} +var dist = { exports: {} }; +var create = { exports: {} }; +var append = { exports: {} }; +var config = { exports: {} }; +(function(module, exports) { + Object.defineProperty(exports, "__esModule", { + value: true + }); + exports.default = { + END_WORD: "$", + END_WORD_REPLACER: "9a219a89-91cd-42e2-abd5-eb113af08ca8", + PERMS_MIN_LEN: 2 + }; + module.exports = exports["default"]; +})(config, config.exports); +var configExports = config.exports; +(function(module, exports) { + Object.defineProperty(exports, "__esModule", { + value: true + }); + exports.default = append2; + var _config = configExports; + var _config2 = _interopRequireDefault(_config); + function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : { default: obj }; + } + function append2(trie, letter, index2, array) { + var isEndWordLetter = letter === _config2.default.END_WORD; + var isLastLetter = index2 === array.length - 1; + if (isEndWordLetter && !isLastLetter) { + trie[_config2.default.END_WORD] = 1; + trie[_config2.default.END_WORD_REPLACER] = {}; + trie = trie[_config2.default.END_WORD_REPLACER]; + } else { + trie[letter] = trie[letter] || {}; + trie = trie[letter]; + } + if (isLastLetter) { + trie[_config2.default.END_WORD] = 1; + } + return trie; + } + module.exports = exports["default"]; +})(append, append.exports); +var appendExports = append.exports; +(function(module, exports) { + Object.defineProperty(exports, "__esModule", { + value: true + }); + var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function(obj) { + return typeof obj; + } : function(obj) { + return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; + }; + exports.default = create2; + var _append = appendExports; + var _append2 = _interopRequireDefault(_append); + function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : { default: obj }; + } + function create2(input) { + if (!Array.isArray(input)) { + throw "Expected parameter Array, received " + (typeof input === "undefined" ? "undefined" : _typeof(input)); + } + var trie = input.reduce(function(accumulator, item) { + item.toLowerCase().split("").reduce(_append2.default, accumulator); + return accumulator; + }, {}); + return trie; + } + module.exports = exports["default"]; +})(create, create.exports); +var createExports = create.exports; +var checkPrefix = { exports: {} }; +var utils$1 = { exports: {} }; +(function(module, exports) { + Object.defineProperty(exports, "__esModule", { + value: true + }); + exports.default = { + objectCopy: function objectCopy(obj) { + if (typeof obj === "undefined") { + return {}; + } + return JSON.parse(JSON.stringify(obj)); + }, + stringify: function stringify(obj) { + var spacer = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : 2; + if (typeof obj === "undefined") { + return ""; + } + return JSON.stringify(obj, null, spacer); + } + }; + module.exports = exports["default"]; +})(utils$1, utils$1.exports); +var utilsExports = utils$1.exports; +(function(module, exports) { + Object.defineProperty(exports, "__esModule", { + value: true + }); + exports.default = checkPrefix2; + var _utils = utilsExports; + _interopRequireDefault(_utils); + function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : { default: obj }; + } + function checkPrefix2(prefixNode, prefix) { + var input = prefix.toLowerCase().split(""); + var prefixFound = input.every(function(letter, index2) { + if (!prefixNode[letter]) { + return false; + } + return prefixNode = prefixNode[letter]; + }); + return { + prefixFound, + prefixNode + }; + } + module.exports = exports["default"]; +})(checkPrefix, checkPrefix.exports); +var checkPrefixExports = checkPrefix.exports; +var recursePrefix = { exports: {} }; +(function(module, exports) { + Object.defineProperty(exports, "__esModule", { + value: true + }); + exports.default = recursePrefix2; + var _config = configExports; + var _config2 = _interopRequireDefault(_config); + function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : { default: obj }; + } + var pushInOrder = function pushInOrder2(word, prefixes) { + var i = 0; + while (i < prefixes.length) { + if (word < prefixes[i]) { + break; + } + i += 1; + } + prefixes.splice(i, 0, word); + return prefixes; + }; + function recursePrefix2(node, prefix, sorted) { + var prefixes = arguments.length > 3 && arguments[3] !== void 0 ? arguments[3] : []; + var word = prefix; + for (var branch in node) { + var currentLetter = branch; + if (branch === _config2.default.END_WORD && typeof node[branch] === "number") { + if (sorted) { + pushInOrder(word, prefixes); + } else { + prefixes.push(word); + } + word = ""; + } else if (branch === _config2.default.END_WORD_REPLACER) { + currentLetter = _config2.default.END_WORD; + } + recursePrefix2(node[branch], prefix + currentLetter, sorted, prefixes); + } + return prefixes; + } + module.exports = exports["default"]; +})(recursePrefix, recursePrefix.exports); +var recursePrefixExports = recursePrefix.exports; +var recurseRandomWord = { exports: {} }; +(function(module, exports) { + Object.defineProperty(exports, "__esModule", { + value: true + }); + exports.default = recurseRandomWord2; + var _config = configExports; + var _config2 = _interopRequireDefault(_config); + function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : { default: obj }; + } + function recurseRandomWord2(node, prefix) { + var word = prefix; + var branches = Object.keys(node); + var branch = branches[Math.floor(Math.random() * branches.length)]; + if (branch === _config2.default.END_WORD) { + return word; + } + return recurseRandomWord2(node[branch], prefix + branch); + } + module.exports = exports["default"]; +})(recurseRandomWord, recurseRandomWord.exports); +var recurseRandomWordExports = recurseRandomWord.exports; +var permutations = { exports: {} }; +(function(module, exports) { + Object.defineProperty(exports, "__esModule", { + value: true + }); + var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function(obj) { + return typeof obj; + } : function(obj) { + return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; + }; + exports.default = permutations2; + var _config = configExports; + var _config2 = _interopRequireDefault(_config); + function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : { default: obj }; + } + function permutations2(letters, trie) { + var opts = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : { + type: "anagram" + }; + if (typeof letters !== "string") { + throw "Permutations expects string letters, received " + (typeof letters === "undefined" ? "undefined" : _typeof(letters)); + } + var words = []; + var permute = function permute2(word, node) { + var prefix = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : ""; + var wordIsEmpty = word.length === 0; + var wordFound = words.indexOf(prefix) !== -1; + var endWordFound = node[_config2.default.END_WORD] === 1; + if (wordIsEmpty && endWordFound && !wordFound) { + words.push(prefix); + } + for (var i = 0, len = word.length; i < len; i++) { + var letter = word[i]; + if (opts.type === "sub-anagram") { + if (endWordFound && !(words.indexOf(prefix) !== -1)) { + words.push(prefix); + } + } + if (node[letter]) { + var remaining = word.substring(0, i) + word.substring(i + 1, len); + permute2(remaining, node[letter], prefix + letter, words); + } + } + return words.sort(); + }; + return permute(letters, trie); + } + module.exports = exports["default"]; +})(permutations, permutations.exports); +var permutationsExports = permutations.exports; +(function(module, exports) { + Object.defineProperty(exports, "__esModule", { + value: true + }); + var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function(obj) { + return typeof obj; + } : function(obj) { + return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; + }; + exports.default = function(input) { + if (!Array.isArray(input)) { + throw "Expected parameter Array, received " + (typeof input === "undefined" ? "undefined" : _typeof(input)); + } + var trie = (0, _create2.default)([].concat(_toConsumableArray(input))); + return { + /** + * Get the generated raw trie object + */ + tree: function tree() { + return trie; + }, + /** + * Get a string representation of the trie + */ + dump: function dump() { + var spacer = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : 0; + return _utils2.default.stringify(trie, spacer); + }, + /** + * Add a new word to the trie + */ + addWord: function addWord(word) { + if (typeof word !== "string" || word === "") { + throw "Expected parameter string, received " + (typeof word === "undefined" ? "undefined" : _typeof(word)); + } + var reducer = function reducer2() { + return _append2.default.apply(void 0, arguments); + }; + var input2 = word.toLowerCase().split(""); + input2.reduce(reducer, trie); + return this; + }, + /** + * Remove an existing word from the trie + */ + removeWord: function removeWord(word) { + if (typeof word !== "string" || word === "") { + throw "Expected parameter string, received " + (typeof word === "undefined" ? "undefined" : _typeof(word)); + } + var _checkPrefix = (0, _checkPrefix6.default)(trie, word), prefixFound = _checkPrefix.prefixFound, prefixNode = _checkPrefix.prefixNode; + if (prefixFound) { + delete prefixNode[_config2.default.END_WORD]; + } + return this; + }, + /** + * Check a prefix is valid + * @returns Boolean + */ + isPrefix: function isPrefix(prefix) { + if (typeof prefix !== "string") { + throw "Expected string prefix, received " + (typeof prefix === "undefined" ? "undefined" : _typeof(prefix)); + } + var _checkPrefix2 = (0, _checkPrefix6.default)(trie, prefix), prefixFound = _checkPrefix2.prefixFound; + return prefixFound; + }, + /** + * Get a list of all words in the trie with the given prefix + * @returns Array + */ + getPrefix: function getPrefix(strPrefix) { + var sorted = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : true; + if (typeof strPrefix !== "string") { + throw "Expected string prefix, received " + (typeof strPrefix === "undefined" ? "undefined" : _typeof(strPrefix)); + } + if (typeof sorted !== "boolean") { + throw "Expected sort parameter as boolean, received " + (typeof sorted === "undefined" ? "undefined" : _typeof(sorted)); + } + if (!this.isPrefix(strPrefix)) { + return []; + } + var prefixNode = strPrefix.length ? (0, _checkPrefix6.default)(trie, strPrefix).prefixNode : trie; + return (0, _recursePrefix2.default)(prefixNode, strPrefix, sorted); + }, + /** + * Get a random word in the trie with the given prefix + * @returns Array + */ + getRandomWordWithPrefix: function getRandomWordWithPrefix(strPrefix) { + if (typeof strPrefix !== "string") { + throw "Expected string prefix, received " + (typeof strPrefix === "undefined" ? "undefined" : _typeof(strPrefix)); + } + if (!this.isPrefix(strPrefix)) { + return ""; + } + var _checkPrefix3 = (0, _checkPrefix6.default)(trie, strPrefix), prefixNode = _checkPrefix3.prefixNode; + return (0, _recurseRandomWord2.default)(prefixNode, strPrefix); + }, + /** + * Count the number of words with the given prefixSearch + * @returns Number + */ + countPrefix: function countPrefix(strPrefix) { + var prefixes = this.getPrefix(strPrefix); + return prefixes.length; + }, + /** + * Get all words in the trie + * @returns Array + */ + getWords: function getWords() { + var sorted = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : true; + return this.getPrefix("", sorted); + }, + /** + * Check the existence of a word in the trie + * @returns Boolean + */ + hasWord: function hasWord(word) { + if (typeof word !== "string") { + throw "Expected string word, received " + (typeof word === "undefined" ? "undefined" : _typeof(word)); + } + var _checkPrefix4 = (0, _checkPrefix6.default)(trie, word), prefixFound = _checkPrefix4.prefixFound, prefixNode = _checkPrefix4.prefixNode; + if (prefixFound) { + return prefixNode[_config2.default.END_WORD] === 1; + } + return false; + }, + /** + * Get a list of valid anagrams that can be made from the given letters + * @returns Array + */ + getAnagrams: function getAnagrams(letters) { + if (typeof letters !== "string") { + throw "Anagrams expected string letters, received " + (typeof letters === "undefined" ? "undefined" : _typeof(letters)); + } + if (letters.length < PERMS_MIN_LEN) { + throw "getAnagrams expects at least " + PERMS_MIN_LEN + " letters"; + } + return (0, _permutations2.default)(letters, trie, { + type: "anagram" + }); + }, + /** + * Get a list of all sub-anagrams that can be made from the given letters + * @returns Array + */ + getSubAnagrams: function getSubAnagrams(letters) { + if (typeof letters !== "string") { + throw "Expected string letters, received " + (typeof letters === "undefined" ? "undefined" : _typeof(letters)); + } + if (letters.length < PERMS_MIN_LEN) { + throw "getSubAnagrams expects at least " + PERMS_MIN_LEN + " letters"; + } + return (0, _permutations2.default)(letters, trie, { + type: "sub-anagram" + }); + } + }; + }; + var _create = createExports; + var _create2 = _interopRequireDefault(_create); + var _append = appendExports; + var _append2 = _interopRequireDefault(_append); + var _checkPrefix5 = checkPrefixExports; + var _checkPrefix6 = _interopRequireDefault(_checkPrefix5); + var _recursePrefix = recursePrefixExports; + var _recursePrefix2 = _interopRequireDefault(_recursePrefix); + var _recurseRandomWord = recurseRandomWordExports; + var _recurseRandomWord2 = _interopRequireDefault(_recurseRandomWord); + var _utils = utilsExports; + var _utils2 = _interopRequireDefault(_utils); + var _config = configExports; + var _config2 = _interopRequireDefault(_config); + var _permutations = permutationsExports; + var _permutations2 = _interopRequireDefault(_permutations); + function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : { default: obj }; + } + function _toConsumableArray(arr) { + if (Array.isArray(arr)) { + for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { + arr2[i] = arr[i]; + } + return arr2; + } else { + return Array.from(arr); + } + } + var PERMS_MIN_LEN = _config2.default.PERMS_MIN_LEN; + module.exports = exports["default"]; +})(dist, dist.exports); +function scan(nodes, token, options2) { + const { startIndex, onlySkipWhitespaceAndComments, allowSubstringMatches } = options2 || {}; + if (typeof token === "string") { + token = { type: "string", content: token }; + } + for (let i = startIndex || 0; i < nodes.length; i++) { + const node = nodes[i]; + if (node.type === token.type) { + switch (node.type) { + case "comment": + case "displaymath": + case "inlinemath": + case "root": + case "parbreak": + case "whitespace": + case "verb": + case "verbatim": + case "group": + return i; + case "macro": + if (node.content === token.content) { + return i; + } + break; + case "environment": + case "mathenv": + if (printRaw(node.env) === printRaw(token.env)) { + return i; + } + break; + case "string": + if (node.content === token.content) { + return i; + } + if (allowSubstringMatches && node.content.indexOf(token.content) >= 0) { + return i; + } + break; + } + } + if (onlySkipWhitespaceAndComments && !match.whitespace(node) && !match.comment(node)) { + return null; + } + } + return null; +} +function updateRenderInfo(node, renderInfo) { + if (renderInfo != null) { + node._renderInfo = { ...node._renderInfo || {}, ...renderInfo }; + } + return node; +} +function gobbleSingleArgument(nodes, argSpec, startPos = 0) { + if (typeof argSpec === "string" || !argSpec.type) { + throw new Error( + `argSpec must be an already-parsed argument specification, not "${JSON.stringify( + argSpec + )}"` + ); + } + let argument = null; + let currPos = startPos; + const gobbleWhitespace = argSpec.noLeadingWhitespace ? () => { + } : () => { + while (currPos < nodes.length) { + if (!match.whitespace(nodes[currPos])) { + break; + } + currPos++; + } + }; + const openMark = argSpec.openBrace || ""; + const closeMark = argSpec.closeBrace || ""; + const acceptGroup = (argSpec.type === "mandatory" || argSpec.type === "optional") && openMark === "{" && closeMark === "}"; + function findBracePositions() { + let openMarkPos = null; + if (openMark) { + openMarkPos = nodes.findIndex( + (node, i) => i >= currPos && match.string(node, openMark) + ); + if (openMarkPos < currPos) { + openMarkPos = null; + } + } + let closeMarkPos = null; + if (openMarkPos != null) { + closeMarkPos = nodes.findIndex( + (node, i) => i >= openMarkPos + 1 && match.string(node, closeMark) + ); + if (closeMarkPos < openMarkPos + 1) { + closeMarkPos = null; + } + } + return [openMarkPos, closeMarkPos]; + } + gobbleWhitespace(); + const currNode = nodes[currPos]; + if (currNode == null || match.comment(currNode) || match.parbreak(currNode)) { + return { argument, nodesRemoved: 0 }; + } + switch (argSpec.type) { + case "mandatory": + if (acceptGroup) { + let content = [currNode]; + if (match.group(currNode)) { + content = currNode.content; + } + argument = arg(content, { + openMark, + closeMark + }); + currPos++; + break; + } + case "optional": + if (acceptGroup && match.group(currNode)) { + argument = arg(currNode.content, { + openMark, + closeMark + }); + currPos++; + break; + } + if (match.string(currNode, openMark)) { + const [openMarkPos, closeMarkPos] = findBracePositions(); + if (openMarkPos != null && closeMarkPos != null) { + argument = arg(nodes.slice(openMarkPos + 1, closeMarkPos), { + openMark, + closeMark + }); + currPos = closeMarkPos + 1; + break; + } + } + break; + case "optionalStar": + case "optionalToken": + if (match.string( + currNode, + argSpec.type === "optionalStar" ? "*" : argSpec.token + )) { + argument = arg([currNode], { openMark: "", closeMark: "" }); + currPos++; + break; + } + break; + case "until": { + if (argSpec.stopTokens.length > 1) { + console.warn( + `"until" matches with multi-token stop conditions are not yet implemented` + ); + break; + } + const rawToken = argSpec.stopTokens[0]; + const stopToken = rawToken === " " ? { type: "whitespace" } : { type: "string", content: argSpec.stopTokens[0] }; + let matchPos = scan(nodes, stopToken, { + startIndex: startPos, + allowSubstringMatches: true + }); + if (matchPos != null && partialStringMatch(nodes[matchPos], stopToken)) { + console.warn( + `"until" arguments that stop at non-punctuation symbols is not yet implemented` + ); + break; + } + if (matchPos == null) { + break; + } + argument = arg(nodes.slice(startPos, matchPos), { + openMark: "", + closeMark: rawToken + }); + currPos = matchPos; + if (currPos < nodes.length) { + currPos++; + } + break; + } + default: + console.warn( + `Don't know how to find an argument of argspec type "${argSpec.type}"` + ); + } + const nodesRemoved = argument ? currPos - startPos : 0; + nodes.splice(startPos, nodesRemoved); + return { argument, nodesRemoved }; +} +function partialStringMatch(node, token) { + return match.anyString(node) && match.anyString(token) && node.content.length > token.content.length; +} +function gobbleArguments(nodes, argSpec, startPos = 0) { + if (typeof argSpec === "function") { + return argSpec(nodes, startPos); + } + if (typeof argSpec === "string") { + argSpec = parse$2(argSpec); + } + const args = []; + let nodesRemoved = 0; + for (const spec of argSpec) { + const { argument, nodesRemoved: removed } = gobbleSingleArgument( + nodes, + spec, + startPos + ); + if (argument) { + args.push(argument); + nodesRemoved += removed; + } else { + args.push(arg([], { openMark: "", closeMark: "" })); + } + } + return { args, nodesRemoved }; +} +function attachMacroArgsInArray(nodes, macros17) { + let currIndex; + const isRelevantMacro = match.createMacroMatcher(macros17); + function gobbleUntilMacro() { + while (currIndex >= 0 && !isRelevantMacro(nodes[currIndex])) { + currIndex--; + } + } + currIndex = nodes.length - 1; + while (currIndex >= 0) { + gobbleUntilMacro(); + if (currIndex < 0) { + return; + } + const macroIndex = currIndex; + const macro = nodes[macroIndex]; + const macroName = macro.content; + const macroInfo2 = macros17[macroName]; + updateRenderInfo(macro, macroInfo2.renderInfo); + const signatureOrParser = macroInfo2.argumentParser || macroInfo2.signature; + if (signatureOrParser == null) { + currIndex--; + continue; + } + if (macro.args != null) { + currIndex = macroIndex - 1; + continue; + } + currIndex++; + const { args } = gobbleArguments(nodes, signatureOrParser, currIndex); + macro.args = args; + currIndex = macroIndex - 1; + } +} +parse$2("o")[0]; +function createMatchers$3() { + return { + isChar: match.string, + isTerminal: (node) => match.string(node, ";"), + isOperation: (node) => match.anyString(node) && node.content.match(/[a-zA-Z]/), + isWhitespace: (node) => match.whitespace(node) || match.parbreak(node), + isComment: match.comment, + isGroup: match.group, + isMacro: match.macro, + isAnyMacro: match.anyMacro + }; +} +var matchers = createMatchers$3(); +function parse$1(ast, options2) { + const { startRule = "path_spec" } = options2 || {}; + if (!Array.isArray(ast)) { + throw new Error("You must pass an array of nodes"); + } + ast = decorateArrayForPegjs([...ast]); + return TikzPegParser.parse(ast, { + ...matchers, + startRule + }); +} +function createMatchers$2() { + return { + isChar: (node, char) => match.string(node, char), + isComma: (node) => match.string(node, ","), + isEquals: (node) => match.string(node, "="), + isWhitespace: (node) => match.whitespace(node), + isParbreak: (node) => match.parbreak(node), + isSameLineComment: (node) => match.comment(node) && node.sameline, + isOwnLineComment: (node) => match.comment(node) && !node.sameline + }; +} +function parsePgfkeys(ast, options2) { + if (!Array.isArray(ast)) { + throw new Error("You must pass an array of nodes"); + } + const { allowParenGroups = false } = options2 || {}; + ast = decorateArrayForPegjs([...ast]); + return PgfkeysPegParser.parse(ast, { + ...createMatchers$2(), + allowParenGroups + }); +} +function createMatchers$1(rowSepMacros, colSep) { + const isRowSep = match.createMacroMatcher(rowSepMacros); + return { + isRowSep, + isColSep: (node) => colSep.some((sep) => match.string(node, sep)), + isWhitespace: (node) => match.whitespace(node), + isSameLineComment: (node) => match.comment(node) && node.sameline, + isOwnLineComment: (node) => match.comment(node) && !node.sameline + }; +} +function parseAlignEnvironment(ast, colSep = ["&"], rowSepMacros = ["\\", "hline", "cr"]) { + if (!Array.isArray(ast)) { + throw new Error("You must pass an array of nodes"); + } + ast = decorateArrayForPegjs([...ast]); + return AlignEnvironmentPegParser.parse( + ast, + createMatchers$1(rowSepMacros, colSep) + ); +} +function bail(error) { + if (error) { + throw error; + } +} +/*! + * Determine if an object is a Buffer + * + * @author Feross Aboukhadijeh + * @license MIT + */ +var isBuffer = function isBuffer2(obj) { + return obj != null && obj.constructor != null && typeof obj.constructor.isBuffer === "function" && obj.constructor.isBuffer(obj); +}; +const isBuffer$1 = /* @__PURE__ */ getDefaultExportFromCjs(isBuffer); +var hasOwn = Object.prototype.hasOwnProperty; +var toStr = Object.prototype.toString; +var defineProperty = Object.defineProperty; +var gOPD = Object.getOwnPropertyDescriptor; +var isArray = function isArray2(arr) { + if (typeof Array.isArray === "function") { + return Array.isArray(arr); + } + return toStr.call(arr) === "[object Array]"; +}; +var isPlainObject$1 = function isPlainObject(obj) { + if (!obj || toStr.call(obj) !== "[object Object]") { + return false; + } + var hasOwnConstructor = hasOwn.call(obj, "constructor"); + var hasIsPrototypeOf = obj.constructor && obj.constructor.prototype && hasOwn.call(obj.constructor.prototype, "isPrototypeOf"); + if (obj.constructor && !hasOwnConstructor && !hasIsPrototypeOf) { + return false; + } + var key; + for (key in obj) { + } + return typeof key === "undefined" || hasOwn.call(obj, key); +}; +var setProperty = function setProperty2(target, options2) { + if (defineProperty && options2.name === "__proto__") { + defineProperty(target, options2.name, { + enumerable: true, + configurable: true, + value: options2.newValue, + writable: true + }); + } else { + target[options2.name] = options2.newValue; + } +}; +var getProperty = function getProperty2(obj, name) { + if (name === "__proto__") { + if (!hasOwn.call(obj, name)) { + return void 0; + } else if (gOPD) { + return gOPD(obj, name).value; + } + } + return obj[name]; +}; +var extend = function extend2() { + var options2, name, src, copy, copyIsArray, clone; + var target = arguments[0]; + var i = 1; + var length = arguments.length; + var deep = false; + if (typeof target === "boolean") { + deep = target; + target = arguments[1] || {}; + i = 2; + } + if (target == null || typeof target !== "object" && typeof target !== "function") { + target = {}; + } + for (; i < length; ++i) { + options2 = arguments[i]; + if (options2 != null) { + for (name in options2) { + src = getProperty(target, name); + copy = getProperty(options2, name); + if (target !== copy) { + if (deep && copy && (isPlainObject$1(copy) || (copyIsArray = isArray(copy)))) { + if (copyIsArray) { + copyIsArray = false; + clone = src && isArray(src) ? src : []; + } else { + clone = src && isPlainObject$1(src) ? src : {}; + } + setProperty(target, { name, newValue: extend2(deep, clone, copy) }); + } else if (typeof copy !== "undefined") { + setProperty(target, { name, newValue: copy }); + } + } + } + } + } + return target; +}; +const extend$1 = /* @__PURE__ */ getDefaultExportFromCjs(extend); +function isPlainObject2(value) { + if (typeof value !== "object" || value === null) { + return false; + } + const prototype = Object.getPrototypeOf(value); + return (prototype === null || prototype === Object.prototype || Object.getPrototypeOf(prototype) === null) && !(Symbol.toStringTag in value) && !(Symbol.iterator in value); +} +function trough() { + const fns = []; + const pipeline = { run, use }; + return pipeline; + function run(...values) { + let middlewareIndex = -1; + const callback = values.pop(); + if (typeof callback !== "function") { + throw new TypeError("Expected function as last argument, not " + callback); + } + next(null, ...values); + function next(error, ...output) { + const fn = fns[++middlewareIndex]; + let index2 = -1; + if (error) { + callback(error); + return; + } + while (++index2 < values.length) { + if (output[index2] === null || output[index2] === void 0) { + output[index2] = values[index2]; + } + } + values = output; + if (fn) { + wrap(fn, next)(...output); + } else { + callback(null, ...output); + } + } + } + function use(middelware) { + if (typeof middelware !== "function") { + throw new TypeError( + "Expected `middelware` to be a function, not " + middelware + ); + } + fns.push(middelware); + return pipeline; + } +} +function wrap(middleware, callback) { + let called; + return wrapped; + function wrapped(...parameters) { + const fnExpectsCallback = middleware.length > parameters.length; + let result; + if (fnExpectsCallback) { + parameters.push(done); + } + try { + result = middleware.apply(this, parameters); + } catch (error) { + const exception = ( + /** @type {Error} */ + error + ); + if (fnExpectsCallback && called) { + throw exception; + } + return done(exception); + } + if (!fnExpectsCallback) { + if (result instanceof Promise) { + result.then(then, done); + } else if (result instanceof Error) { + done(result); + } else { + then(result); + } + } + } + function done(error, ...output) { + if (!called) { + called = true; + callback(error, ...output); + } + } + function then(value) { + done(null, value); + } +} +function stringifyPosition(value) { + if (!value || typeof value !== "object") { + return ""; + } + if ("position" in value || "type" in value) { + return position(value.position); + } + if ("start" in value || "end" in value) { + return position(value); + } + if ("line" in value || "column" in value) { + return point(value); + } + return ""; +} +function point(point2) { + return index(point2 && point2.line) + ":" + index(point2 && point2.column); +} +function position(pos) { + return point(pos && pos.start) + "-" + point(pos && pos.end); +} +function index(value) { + return value && typeof value === "number" ? value : 1; +} +class VFileMessage extends Error { + /** + * Create a message for `reason` at `place` from `origin`. + * + * When an error is passed in as `reason`, the `stack` is copied. + * + * @param {string | Error | VFileMessage} reason + * Reason for message, uses the stack and message of the error if given. + * + * > 👉 **Note**: you should use markdown. + * @param {Node | NodeLike | Position | Point | null | undefined} [place] + * Place in file where the message occurred. + * @param {string | null | undefined} [origin] + * Place in code where the message originates (example: + * `'my-package:my-rule'` or `'my-rule'`). + * @returns + * Instance of `VFileMessage`. + */ + // To do: next major: expose `undefined` everywhere instead of `null`. + constructor(reason, place, origin) { + const parts = [null, null]; + let position2 = { + // @ts-expect-error: we always follows the structure of `position`. + start: { line: null, column: null }, + // @ts-expect-error: " + end: { line: null, column: null } + }; + super(); + if (typeof place === "string") { + origin = place; + place = void 0; + } + if (typeof origin === "string") { + const index2 = origin.indexOf(":"); + if (index2 === -1) { + parts[1] = origin; + } else { + parts[0] = origin.slice(0, index2); + parts[1] = origin.slice(index2 + 1); + } + } + if (place) { + if ("type" in place || "position" in place) { + if (place.position) { + position2 = place.position; + } + } else if ("start" in place || "end" in place) { + position2 = place; + } else if ("line" in place || "column" in place) { + position2.start = place; + } + } + this.name = stringifyPosition(place) || "1:1"; + this.message = typeof reason === "object" ? reason.message : reason; + this.stack = ""; + if (typeof reason === "object" && reason.stack) { + this.stack = reason.stack; + } + this.reason = this.message; + this.fatal; + this.line = position2.start.line; + this.column = position2.start.column; + this.position = position2; + this.source = parts[0]; + this.ruleId = parts[1]; + this.file; + this.actual; + this.expected; + this.url; + this.note; + } +} +VFileMessage.prototype.file = ""; +VFileMessage.prototype.name = ""; +VFileMessage.prototype.reason = ""; +VFileMessage.prototype.message = ""; +VFileMessage.prototype.stack = ""; +VFileMessage.prototype.fatal = null; +VFileMessage.prototype.column = null; +VFileMessage.prototype.line = null; +VFileMessage.prototype.source = null; +VFileMessage.prototype.ruleId = null; +VFileMessage.prototype.position = null; +const path = { basename, dirname, extname, join: join$1, sep: "/" }; +function basename(path2, ext) { + if (ext !== void 0 && typeof ext !== "string") { + throw new TypeError('"ext" argument must be a string'); + } + assertPath$1(path2); + let start = 0; + let end = -1; + let index2 = path2.length; + let seenNonSlash; + if (ext === void 0 || ext.length === 0 || ext.length > path2.length) { + while (index2--) { + if (path2.charCodeAt(index2) === 47) { + if (seenNonSlash) { + start = index2 + 1; + break; + } + } else if (end < 0) { + seenNonSlash = true; + end = index2 + 1; + } + } + return end < 0 ? "" : path2.slice(start, end); + } + if (ext === path2) { + return ""; + } + let firstNonSlashEnd = -1; + let extIndex = ext.length - 1; + while (index2--) { + if (path2.charCodeAt(index2) === 47) { + if (seenNonSlash) { + start = index2 + 1; + break; + } + } else { + if (firstNonSlashEnd < 0) { + seenNonSlash = true; + firstNonSlashEnd = index2 + 1; + } + if (extIndex > -1) { + if (path2.charCodeAt(index2) === ext.charCodeAt(extIndex--)) { + if (extIndex < 0) { + end = index2; + } + } else { + extIndex = -1; + end = firstNonSlashEnd; + } + } + } + } + if (start === end) { + end = firstNonSlashEnd; + } else if (end < 0) { + end = path2.length; + } + return path2.slice(start, end); +} +function dirname(path2) { + assertPath$1(path2); + if (path2.length === 0) { + return "."; + } + let end = -1; + let index2 = path2.length; + let unmatchedSlash; + while (--index2) { + if (path2.charCodeAt(index2) === 47) { + if (unmatchedSlash) { + end = index2; + break; + } + } else if (!unmatchedSlash) { + unmatchedSlash = true; + } + } + return end < 0 ? path2.charCodeAt(0) === 47 ? "/" : "." : end === 1 && path2.charCodeAt(0) === 47 ? "//" : path2.slice(0, end); +} +function extname(path2) { + assertPath$1(path2); + let index2 = path2.length; + let end = -1; + let startPart = 0; + let startDot = -1; + let preDotState = 0; + let unmatchedSlash; + while (index2--) { + const code = path2.charCodeAt(index2); + if (code === 47) { + if (unmatchedSlash) { + startPart = index2 + 1; + break; + } + continue; + } + if (end < 0) { + unmatchedSlash = true; + end = index2 + 1; + } + if (code === 46) { + if (startDot < 0) { + startDot = index2; + } else if (preDotState !== 1) { + preDotState = 1; + } + } else if (startDot > -1) { + preDotState = -1; + } + } + if (startDot < 0 || end < 0 || // We saw a non-dot character immediately before the dot. + preDotState === 0 || // The (right-most) trimmed path component is exactly `..`. + preDotState === 1 && startDot === end - 1 && startDot === startPart + 1) { + return ""; + } + return path2.slice(startDot, end); +} +function join$1(...segments) { + let index2 = -1; + let joined; + while (++index2 < segments.length) { + assertPath$1(segments[index2]); + if (segments[index2]) { + joined = joined === void 0 ? segments[index2] : joined + "/" + segments[index2]; + } + } + return joined === void 0 ? "." : normalize(joined); +} +function normalize(path2) { + assertPath$1(path2); + const absolute = path2.charCodeAt(0) === 47; + let value = normalizeString(path2, !absolute); + if (value.length === 0 && !absolute) { + value = "."; + } + if (value.length > 0 && path2.charCodeAt(path2.length - 1) === 47) { + value += "/"; + } + return absolute ? "/" + value : value; +} +function normalizeString(path2, allowAboveRoot) { + let result = ""; + let lastSegmentLength = 0; + let lastSlash = -1; + let dots = 0; + let index2 = -1; + let code; + let lastSlashIndex; + while (++index2 <= path2.length) { + if (index2 < path2.length) { + code = path2.charCodeAt(index2); + } else if (code === 47) { + break; + } else { + code = 47; + } + if (code === 47) { + if (lastSlash === index2 - 1 || dots === 1) + ; + else if (lastSlash !== index2 - 1 && dots === 2) { + if (result.length < 2 || lastSegmentLength !== 2 || result.charCodeAt(result.length - 1) !== 46 || result.charCodeAt(result.length - 2) !== 46) { + if (result.length > 2) { + lastSlashIndex = result.lastIndexOf("/"); + if (lastSlashIndex !== result.length - 1) { + if (lastSlashIndex < 0) { + result = ""; + lastSegmentLength = 0; + } else { + result = result.slice(0, lastSlashIndex); + lastSegmentLength = result.length - 1 - result.lastIndexOf("/"); + } + lastSlash = index2; + dots = 0; + continue; + } + } else if (result.length > 0) { + result = ""; + lastSegmentLength = 0; + lastSlash = index2; + dots = 0; + continue; + } + } + if (allowAboveRoot) { + result = result.length > 0 ? result + "/.." : ".."; + lastSegmentLength = 2; + } + } else { + if (result.length > 0) { + result += "/" + path2.slice(lastSlash + 1, index2); + } else { + result = path2.slice(lastSlash + 1, index2); + } + lastSegmentLength = index2 - lastSlash - 1; + } + lastSlash = index2; + dots = 0; + } else if (code === 46 && dots > -1) { + dots++; + } else { + dots = -1; + } + } + return result; +} +function assertPath$1(path2) { + if (typeof path2 !== "string") { + throw new TypeError( + "Path must be a string. Received " + JSON.stringify(path2) + ); + } +} +const proc = { cwd }; +function cwd() { + return "/"; +} +function isUrl(fileUrlOrPath) { + return fileUrlOrPath !== null && typeof fileUrlOrPath === "object" && // @ts-expect-error: indexable. + fileUrlOrPath.href && // @ts-expect-error: indexable. + fileUrlOrPath.origin; +} +function urlToPath(path2) { + if (typeof path2 === "string") { + path2 = new URL(path2); + } else if (!isUrl(path2)) { + const error = new TypeError( + 'The "path" argument must be of type string or an instance of URL. Received `' + path2 + "`" + ); + error.code = "ERR_INVALID_ARG_TYPE"; + throw error; + } + if (path2.protocol !== "file:") { + const error = new TypeError("The URL must be of scheme file"); + error.code = "ERR_INVALID_URL_SCHEME"; + throw error; + } + return getPathFromURLPosix(path2); +} +function getPathFromURLPosix(url) { + if (url.hostname !== "") { + const error = new TypeError( + 'File URL host must be "localhost" or empty on darwin' + ); + error.code = "ERR_INVALID_FILE_URL_HOST"; + throw error; + } + const pathname = url.pathname; + let index2 = -1; + while (++index2 < pathname.length) { + if (pathname.charCodeAt(index2) === 37 && pathname.charCodeAt(index2 + 1) === 50) { + const third = pathname.charCodeAt(index2 + 2); + if (third === 70 || third === 102) { + const error = new TypeError( + "File URL path must not include encoded / characters" + ); + error.code = "ERR_INVALID_FILE_URL_PATH"; + throw error; + } + } + } + return decodeURIComponent(pathname); +} +const order = ["history", "path", "basename", "stem", "extname", "dirname"]; +class VFile { + /** + * Create a new virtual file. + * + * `options` is treated as: + * + * * `string` or `Buffer` — `{value: options}` + * * `URL` — `{path: options}` + * * `VFile` — shallow copies its data over to the new file + * * `object` — all fields are shallow copied over to the new file + * + * Path related fields are set in the following order (least specific to + * most specific): `history`, `path`, `basename`, `stem`, `extname`, + * `dirname`. + * + * You cannot set `dirname` or `extname` without setting either `history`, + * `path`, `basename`, or `stem` too. + * + * @param {Compatible | null | undefined} [value] + * File value. + * @returns + * New instance. + */ + constructor(value) { + let options2; + if (!value) { + options2 = {}; + } else if (typeof value === "string" || buffer(value)) { + options2 = { value }; + } else if (isUrl(value)) { + options2 = { path: value }; + } else { + options2 = value; + } + this.data = {}; + this.messages = []; + this.history = []; + this.cwd = proc.cwd(); + this.value; + this.stored; + this.result; + this.map; + let index2 = -1; + while (++index2 < order.length) { + const prop2 = order[index2]; + if (prop2 in options2 && options2[prop2] !== void 0 && options2[prop2] !== null) { + this[prop2] = prop2 === "history" ? [...options2[prop2]] : options2[prop2]; + } + } + let prop; + for (prop in options2) { + if (!order.includes(prop)) { + this[prop] = options2[prop]; + } + } + } + /** + * Get the full path (example: `'~/index.min.js'`). + * + * @returns {string} + */ + get path() { + return this.history[this.history.length - 1]; + } + /** + * Set the full path (example: `'~/index.min.js'`). + * + * Cannot be nullified. + * You can set a file URL (a `URL` object with a `file:` protocol) which will + * be turned into a path with `url.fileURLToPath`. + * + * @param {string | URL} path + */ + set path(path2) { + if (isUrl(path2)) { + path2 = urlToPath(path2); + } + assertNonEmpty(path2, "path"); + if (this.path !== path2) { + this.history.push(path2); + } + } + /** + * Get the parent path (example: `'~'`). + */ + get dirname() { + return typeof this.path === "string" ? path.dirname(this.path) : void 0; + } + /** + * Set the parent path (example: `'~'`). + * + * Cannot be set if there’s no `path` yet. + */ + set dirname(dirname2) { + assertPath(this.basename, "dirname"); + this.path = path.join(dirname2 || "", this.basename); + } + /** + * Get the basename (including extname) (example: `'index.min.js'`). + */ + get basename() { + return typeof this.path === "string" ? path.basename(this.path) : void 0; + } + /** + * Set basename (including extname) (`'index.min.js'`). + * + * Cannot contain path separators (`'/'` on unix, macOS, and browsers, `'\'` + * on windows). + * Cannot be nullified (use `file.path = file.dirname` instead). + */ + set basename(basename2) { + assertNonEmpty(basename2, "basename"); + assertPart(basename2, "basename"); + this.path = path.join(this.dirname || "", basename2); + } + /** + * Get the extname (including dot) (example: `'.js'`). + */ + get extname() { + return typeof this.path === "string" ? path.extname(this.path) : void 0; + } + /** + * Set the extname (including dot) (example: `'.js'`). + * + * Cannot contain path separators (`'/'` on unix, macOS, and browsers, `'\'` + * on windows). + * Cannot be set if there’s no `path` yet. + */ + set extname(extname2) { + assertPart(extname2, "extname"); + assertPath(this.dirname, "extname"); + if (extname2) { + if (extname2.charCodeAt(0) !== 46) { + throw new Error("`extname` must start with `.`"); + } + if (extname2.includes(".", 1)) { + throw new Error("`extname` cannot contain multiple dots"); + } + } + this.path = path.join(this.dirname, this.stem + (extname2 || "")); + } + /** + * Get the stem (basename w/o extname) (example: `'index.min'`). + */ + get stem() { + return typeof this.path === "string" ? path.basename(this.path, this.extname) : void 0; + } + /** + * Set the stem (basename w/o extname) (example: `'index.min'`). + * + * Cannot contain path separators (`'/'` on unix, macOS, and browsers, `'\'` + * on windows). + * Cannot be nullified (use `file.path = file.dirname` instead). + */ + set stem(stem) { + assertNonEmpty(stem, "stem"); + assertPart(stem, "stem"); + this.path = path.join(this.dirname || "", stem + (this.extname || "")); + } + /** + * Serialize the file. + * + * @param {BufferEncoding | null | undefined} [encoding='utf8'] + * Character encoding to understand `value` as when it’s a `Buffer` + * (default: `'utf8'`). + * @returns {string} + * Serialized file. + */ + toString(encoding) { + return (this.value || "").toString(encoding || void 0); + } + /** + * Create a warning message associated with the file. + * + * Its `fatal` is set to `false` and `file` is set to the current file path. + * Its added to `file.messages`. + * + * @param {string | Error | VFileMessage} reason + * Reason for message, uses the stack and message of the error if given. + * @param {Node | NodeLike | Position | Point | null | undefined} [place] + * Place in file where the message occurred. + * @param {string | null | undefined} [origin] + * Place in code where the message originates (example: + * `'my-package:my-rule'` or `'my-rule'`). + * @returns {VFileMessage} + * Message. + */ + message(reason, place, origin) { + const message = new VFileMessage(reason, place, origin); + if (this.path) { + message.name = this.path + ":" + message.name; + message.file = this.path; + } + message.fatal = false; + this.messages.push(message); + return message; + } + /** + * Create an info message associated with the file. + * + * Its `fatal` is set to `null` and `file` is set to the current file path. + * Its added to `file.messages`. + * + * @param {string | Error | VFileMessage} reason + * Reason for message, uses the stack and message of the error if given. + * @param {Node | NodeLike | Position | Point | null | undefined} [place] + * Place in file where the message occurred. + * @param {string | null | undefined} [origin] + * Place in code where the message originates (example: + * `'my-package:my-rule'` or `'my-rule'`). + * @returns {VFileMessage} + * Message. + */ + info(reason, place, origin) { + const message = this.message(reason, place, origin); + message.fatal = null; + return message; + } + /** + * Create a fatal error associated with the file. + * + * Its `fatal` is set to `true` and `file` is set to the current file path. + * Its added to `file.messages`. + * + * > 👉 **Note**: a fatal error means that a file is no longer processable. + * + * @param {string | Error | VFileMessage} reason + * Reason for message, uses the stack and message of the error if given. + * @param {Node | NodeLike | Position | Point | null | undefined} [place] + * Place in file where the message occurred. + * @param {string | null | undefined} [origin] + * Place in code where the message originates (example: + * `'my-package:my-rule'` or `'my-rule'`). + * @returns {never} + * Message. + * @throws {VFileMessage} + * Message. + */ + fail(reason, place, origin) { + const message = this.message(reason, place, origin); + message.fatal = true; + throw message; + } +} +function assertPart(part, name) { + if (part && part.includes(path.sep)) { + throw new Error( + "`" + name + "` cannot be a path: did not expect `" + path.sep + "`" + ); + } +} +function assertNonEmpty(part, name) { + if (!part) { + throw new Error("`" + name + "` cannot be empty"); + } +} +function assertPath(path2, name) { + if (!path2) { + throw new Error("Setting `" + name + "` requires `path` to be set too"); + } +} +function buffer(value) { + return isBuffer$1(value); +} +const unified = base().freeze(); +const own = {}.hasOwnProperty; +function base() { + const transformers = trough(); + const attachers = []; + let namespace = {}; + let frozen; + let freezeIndex = -1; + processor.data = data; + processor.Parser = void 0; + processor.Compiler = void 0; + processor.freeze = freeze; + processor.attachers = attachers; + processor.use = use; + processor.parse = parse2; + processor.stringify = stringify; + processor.run = run; + processor.runSync = runSync; + processor.process = process; + processor.processSync = processSync; + return processor; + function processor() { + const destination = base(); + let index2 = -1; + while (++index2 < attachers.length) { + destination.use(...attachers[index2]); + } + destination.data(extend$1(true, {}, namespace)); + return destination; + } + function data(key, value) { + if (typeof key === "string") { + if (arguments.length === 2) { + assertUnfrozen("data", frozen); + namespace[key] = value; + return processor; + } + return own.call(namespace, key) && namespace[key] || null; + } + if (key) { + assertUnfrozen("data", frozen); + namespace = key; + return processor; + } + return namespace; + } + function freeze() { + if (frozen) { + return processor; + } + while (++freezeIndex < attachers.length) { + const [attacher, ...options2] = attachers[freezeIndex]; + if (options2[0] === false) { + continue; + } + if (options2[0] === true) { + options2[0] = void 0; + } + const transformer = attacher.call(processor, ...options2); + if (typeof transformer === "function") { + transformers.use(transformer); + } + } + frozen = true; + freezeIndex = Number.POSITIVE_INFINITY; + return processor; + } + function use(value, ...options2) { + let settings; + assertUnfrozen("use", frozen); + if (value === null || value === void 0) + ; + else if (typeof value === "function") { + addPlugin(value, ...options2); + } else if (typeof value === "object") { + if (Array.isArray(value)) { + addList(value); + } else { + addPreset(value); + } + } else { + throw new TypeError("Expected usable value, not `" + value + "`"); + } + if (settings) { + namespace.settings = Object.assign(namespace.settings || {}, settings); + } + return processor; + function add(value2) { + if (typeof value2 === "function") { + addPlugin(value2); + } else if (typeof value2 === "object") { + if (Array.isArray(value2)) { + const [plugin, ...options3] = value2; + addPlugin(plugin, ...options3); + } else { + addPreset(value2); + } + } else { + throw new TypeError("Expected usable value, not `" + value2 + "`"); + } + } + function addPreset(result) { + addList(result.plugins); + if (result.settings) { + settings = Object.assign(settings || {}, result.settings); + } + } + function addList(plugins) { + let index2 = -1; + if (plugins === null || plugins === void 0) + ; + else if (Array.isArray(plugins)) { + while (++index2 < plugins.length) { + const thing = plugins[index2]; + add(thing); + } + } else { + throw new TypeError("Expected a list of plugins, not `" + plugins + "`"); + } + } + function addPlugin(plugin, value2) { + let index2 = -1; + let entry; + while (++index2 < attachers.length) { + if (attachers[index2][0] === plugin) { + entry = attachers[index2]; + break; + } + } + if (entry) { + if (isPlainObject2(entry[1]) && isPlainObject2(value2)) { + value2 = extend$1(true, entry[1], value2); + } + entry[1] = value2; + } else { + attachers.push([...arguments]); + } + } + } + function parse2(doc) { + processor.freeze(); + const file = vfile(doc); + const Parser = processor.Parser; + assertParser("parse", Parser); + if (newable(Parser, "parse")) { + return new Parser(String(file), file).parse(); + } + return Parser(String(file), file); + } + function stringify(node, doc) { + processor.freeze(); + const file = vfile(doc); + const Compiler = processor.Compiler; + assertCompiler("stringify", Compiler); + assertNode(node); + if (newable(Compiler, "compile")) { + return new Compiler(node, file).compile(); + } + return Compiler(node, file); + } + function run(node, doc, callback) { + assertNode(node); + processor.freeze(); + if (!callback && typeof doc === "function") { + callback = doc; + doc = void 0; + } + if (!callback) { + return new Promise(executor); + } + executor(null, callback); + function executor(resolve, reject) { + transformers.run(node, vfile(doc), done); + function done(error, tree, file) { + tree = tree || node; + if (error) { + reject(error); + } else if (resolve) { + resolve(tree); + } else { + callback(null, tree, file); + } + } + } + } + function runSync(node, file) { + let result; + let complete; + processor.run(node, file, done); + assertDone("runSync", "run", complete); + return result; + function done(error, tree) { + bail(error); + result = tree; + complete = true; + } + } + function process(doc, callback) { + processor.freeze(); + assertParser("process", processor.Parser); + assertCompiler("process", processor.Compiler); + if (!callback) { + return new Promise(executor); + } + executor(null, callback); + function executor(resolve, reject) { + const file = vfile(doc); + processor.run(processor.parse(file), file, (error, tree, file2) => { + if (error || !tree || !file2) { + done(error); + } else { + const result = processor.stringify(tree, file2); + if (result === void 0 || result === null) + ; + else if (looksLikeAVFileValue(result)) { + file2.value = result; + } else { + file2.result = result; + } + done(error, file2); + } + }); + function done(error, file2) { + if (error || !file2) { + reject(error); + } else if (resolve) { + resolve(file2); + } else { + callback(null, file2); + } + } + } + } + function processSync(doc) { + let complete; + processor.freeze(); + assertParser("processSync", processor.Parser); + assertCompiler("processSync", processor.Compiler); + const file = vfile(doc); + processor.process(file, done); + assertDone("processSync", "process", complete); + return file; + function done(error) { + complete = true; + bail(error); + } + } +} +function newable(value, name) { + return typeof value === "function" && // Prototypes do exist. + // type-coverage:ignore-next-line + value.prototype && // A function with keys in its prototype is probably a constructor. + // Classes’ prototype methods are not enumerable, so we check if some value + // exists in the prototype. + // type-coverage:ignore-next-line + (keys(value.prototype) || name in value.prototype); +} +function keys(value) { + let key; + for (key in value) { + if (own.call(value, key)) { + return true; + } + } + return false; +} +function assertParser(name, value) { + if (typeof value !== "function") { + throw new TypeError("Cannot `" + name + "` without `Parser`"); + } +} +function assertCompiler(name, value) { + if (typeof value !== "function") { + throw new TypeError("Cannot `" + name + "` without `Compiler`"); + } +} +function assertUnfrozen(name, frozen) { + if (frozen) { + throw new Error( + "Cannot call `" + name + "` on a frozen processor.\nCreate a new processor first, by calling it: use `processor()` instead of `processor`." + ); + } +} +function assertNode(node) { + if (!isPlainObject2(node) || typeof node.type !== "string") { + throw new TypeError("Expected node, got `" + node + "`"); + } +} +function assertDone(name, asyncName, complete) { + if (!complete) { + throw new Error( + "`" + name + "` finished async. Use `" + asyncName + "` instead" + ); + } +} +function vfile(value) { + return looksLikeAVFile(value) ? value : new VFile(value); +} +function looksLikeAVFile(value) { + return Boolean( + value && typeof value === "object" && "message" in value && "messages" in value + ); +} +function looksLikeAVFileValue(value) { + return typeof value === "string" || isBuffer$1(value); +} +function splitOnCondition(nodes, splitFunc = () => false, options2) { + if (!Array.isArray(nodes)) { + throw new Error(`Can only split an Array, not ${nodes}`); + } + const { onlySplitOnFirstOccurrence = false } = options2 || {}; + const splitIndices = []; + for (let i = 0; i < nodes.length; i++) { + if (splitFunc(nodes[i])) { + splitIndices.push(i); + if (onlySplitOnFirstOccurrence) { + break; + } + } + } + if (splitIndices.length === 0) { + return { segments: [nodes], separators: [] }; + } + let separators = splitIndices.map((i) => nodes[i]); + let segments = splitIndices.map((splitEnd, i) => { + const splitStart = i === 0 ? 0 : splitIndices[i - 1] + 1; + return nodes.slice(splitStart, splitEnd); + }); + segments.push( + nodes.slice(splitIndices[splitIndices.length - 1] + 1, nodes.length) + ); + return { segments, separators }; +} +function splitOnMacro(ast, macroName) { + if (typeof macroName === "string") { + macroName = [macroName]; + } + if (!Array.isArray(macroName)) { + throw new Error("Type coercion failed"); + } + const isSeparator = match.createMacroMatcher(macroName); + const { segments, separators } = splitOnCondition(ast, isSeparator); + return { segments, macros: separators }; +} +function lastSignificantNodeIndex(nodes, parbreaksAreInsignificant) { + for (let i = nodes.length - 1; i >= 0; i--) { + const node = nodes[i]; + if (match.whitespace(node) || match.comment(node) || parbreaksAreInsignificant && match.parbreak(node)) { + continue; + } + return i; + } + return void 0; +} +var colorString$1 = { exports: {} }; +var colorName = { + "aliceblue": [240, 248, 255], + "antiquewhite": [250, 235, 215], + "aqua": [0, 255, 255], + "aquamarine": [127, 255, 212], + "azure": [240, 255, 255], + "beige": [245, 245, 220], + "bisque": [255, 228, 196], + "black": [0, 0, 0], + "blanchedalmond": [255, 235, 205], + "blue": [0, 0, 255], + "blueviolet": [138, 43, 226], + "brown": [165, 42, 42], + "burlywood": [222, 184, 135], + "cadetblue": [95, 158, 160], + "chartreuse": [127, 255, 0], + "chocolate": [210, 105, 30], + "coral": [255, 127, 80], + "cornflowerblue": [100, 149, 237], + "cornsilk": [255, 248, 220], + "crimson": [220, 20, 60], + "cyan": [0, 255, 255], + "darkblue": [0, 0, 139], + "darkcyan": [0, 139, 139], + "darkgoldenrod": [184, 134, 11], + "darkgray": [169, 169, 169], + "darkgreen": [0, 100, 0], + "darkgrey": [169, 169, 169], + "darkkhaki": [189, 183, 107], + "darkmagenta": [139, 0, 139], + "darkolivegreen": [85, 107, 47], + "darkorange": [255, 140, 0], + "darkorchid": [153, 50, 204], + "darkred": [139, 0, 0], + "darksalmon": [233, 150, 122], + "darkseagreen": [143, 188, 143], + "darkslateblue": [72, 61, 139], + "darkslategray": [47, 79, 79], + "darkslategrey": [47, 79, 79], + "darkturquoise": [0, 206, 209], + "darkviolet": [148, 0, 211], + "deeppink": [255, 20, 147], + "deepskyblue": [0, 191, 255], + "dimgray": [105, 105, 105], + "dimgrey": [105, 105, 105], + "dodgerblue": [30, 144, 255], + "firebrick": [178, 34, 34], + "floralwhite": [255, 250, 240], + "forestgreen": [34, 139, 34], + "fuchsia": [255, 0, 255], + "gainsboro": [220, 220, 220], + "ghostwhite": [248, 248, 255], + "gold": [255, 215, 0], + "goldenrod": [218, 165, 32], + "gray": [128, 128, 128], + "green": [0, 128, 0], + "greenyellow": [173, 255, 47], + "grey": [128, 128, 128], + "honeydew": [240, 255, 240], + "hotpink": [255, 105, 180], + "indianred": [205, 92, 92], + "indigo": [75, 0, 130], + "ivory": [255, 255, 240], + "khaki": [240, 230, 140], + "lavender": [230, 230, 250], + "lavenderblush": [255, 240, 245], + "lawngreen": [124, 252, 0], + "lemonchiffon": [255, 250, 205], + "lightblue": [173, 216, 230], + "lightcoral": [240, 128, 128], + "lightcyan": [224, 255, 255], + "lightgoldenrodyellow": [250, 250, 210], + "lightgray": [211, 211, 211], + "lightgreen": [144, 238, 144], + "lightgrey": [211, 211, 211], + "lightpink": [255, 182, 193], + "lightsalmon": [255, 160, 122], + "lightseagreen": [32, 178, 170], + "lightskyblue": [135, 206, 250], + "lightslategray": [119, 136, 153], + "lightslategrey": [119, 136, 153], + "lightsteelblue": [176, 196, 222], + "lightyellow": [255, 255, 224], + "lime": [0, 255, 0], + "limegreen": [50, 205, 50], + "linen": [250, 240, 230], + "magenta": [255, 0, 255], + "maroon": [128, 0, 0], + "mediumaquamarine": [102, 205, 170], + "mediumblue": [0, 0, 205], + "mediumorchid": [186, 85, 211], + "mediumpurple": [147, 112, 219], + "mediumseagreen": [60, 179, 113], + "mediumslateblue": [123, 104, 238], + "mediumspringgreen": [0, 250, 154], + "mediumturquoise": [72, 209, 204], + "mediumvioletred": [199, 21, 133], + "midnightblue": [25, 25, 112], + "mintcream": [245, 255, 250], + "mistyrose": [255, 228, 225], + "moccasin": [255, 228, 181], + "navajowhite": [255, 222, 173], + "navy": [0, 0, 128], + "oldlace": [253, 245, 230], + "olive": [128, 128, 0], + "olivedrab": [107, 142, 35], + "orange": [255, 165, 0], + "orangered": [255, 69, 0], + "orchid": [218, 112, 214], + "palegoldenrod": [238, 232, 170], + "palegreen": [152, 251, 152], + "paleturquoise": [175, 238, 238], + "palevioletred": [219, 112, 147], + "papayawhip": [255, 239, 213], + "peachpuff": [255, 218, 185], + "peru": [205, 133, 63], + "pink": [255, 192, 203], + "plum": [221, 160, 221], + "powderblue": [176, 224, 230], + "purple": [128, 0, 128], + "rebeccapurple": [102, 51, 153], + "red": [255, 0, 0], + "rosybrown": [188, 143, 143], + "royalblue": [65, 105, 225], + "saddlebrown": [139, 69, 19], + "salmon": [250, 128, 114], + "sandybrown": [244, 164, 96], + "seagreen": [46, 139, 87], + "seashell": [255, 245, 238], + "sienna": [160, 82, 45], + "silver": [192, 192, 192], + "skyblue": [135, 206, 235], + "slateblue": [106, 90, 205], + "slategray": [112, 128, 144], + "slategrey": [112, 128, 144], + "snow": [255, 250, 250], + "springgreen": [0, 255, 127], + "steelblue": [70, 130, 180], + "tan": [210, 180, 140], + "teal": [0, 128, 128], + "thistle": [216, 191, 216], + "tomato": [255, 99, 71], + "turquoise": [64, 224, 208], + "violet": [238, 130, 238], + "wheat": [245, 222, 179], + "white": [255, 255, 255], + "whitesmoke": [245, 245, 245], + "yellow": [255, 255, 0], + "yellowgreen": [154, 205, 50] +}; +var simpleSwizzle = { exports: {} }; +var isArrayish$1 = function isArrayish(obj) { + if (!obj || typeof obj === "string") { + return false; + } + return obj instanceof Array || Array.isArray(obj) || obj.length >= 0 && (obj.splice instanceof Function || Object.getOwnPropertyDescriptor(obj, obj.length - 1) && obj.constructor.name !== "String"); +}; +var isArrayish2 = isArrayish$1; +var concat = Array.prototype.concat; +var slice = Array.prototype.slice; +var swizzle$1 = simpleSwizzle.exports = function swizzle(args) { + var results = []; + for (var i = 0, len = args.length; i < len; i++) { + var arg2 = args[i]; + if (isArrayish2(arg2)) { + results = concat.call(results, slice.call(arg2)); + } else { + results.push(arg2); + } + } + return results; +}; +swizzle$1.wrap = function(fn) { + return function() { + return fn(swizzle$1(arguments)); + }; +}; +var simpleSwizzleExports = simpleSwizzle.exports; +var colorNames = colorName; +var swizzle2 = simpleSwizzleExports; +var hasOwnProperty = Object.hasOwnProperty; +var reverseNames = /* @__PURE__ */ Object.create(null); +for (var name in colorNames) { + if (hasOwnProperty.call(colorNames, name)) { + reverseNames[colorNames[name]] = name; + } +} +var cs = colorString$1.exports = { + to: {}, + get: {} +}; +cs.get = function(string) { + var prefix = string.substring(0, 3).toLowerCase(); + var val; + var model; + switch (prefix) { + case "hsl": + val = cs.get.hsl(string); + model = "hsl"; + break; + case "hwb": + val = cs.get.hwb(string); + model = "hwb"; + break; + default: + val = cs.get.rgb(string); + model = "rgb"; + break; + } + if (!val) { + return null; + } + return { model, value: val }; +}; +cs.get.rgb = function(string) { + if (!string) { + return null; + } + var abbr = /^#([a-f0-9]{3,4})$/i; + var hex = /^#([a-f0-9]{6})([a-f0-9]{2})?$/i; + var rgba = /^rgba?\(\s*([+-]?\d+)(?=[\s,])\s*(?:,\s*)?([+-]?\d+)(?=[\s,])\s*(?:,\s*)?([+-]?\d+)\s*(?:[,|\/]\s*([+-]?[\d\.]+)(%?)\s*)?\)$/; + var per = /^rgba?\(\s*([+-]?[\d\.]+)\%\s*,?\s*([+-]?[\d\.]+)\%\s*,?\s*([+-]?[\d\.]+)\%\s*(?:[,|\/]\s*([+-]?[\d\.]+)(%?)\s*)?\)$/; + var keyword = /^(\w+)$/; + var rgb = [0, 0, 0, 1]; + var match2; + var i; + var hexAlpha; + if (match2 = string.match(hex)) { + hexAlpha = match2[2]; + match2 = match2[1]; + for (i = 0; i < 3; i++) { + var i2 = i * 2; + rgb[i] = parseInt(match2.slice(i2, i2 + 2), 16); + } + if (hexAlpha) { + rgb[3] = parseInt(hexAlpha, 16) / 255; + } + } else if (match2 = string.match(abbr)) { + match2 = match2[1]; + hexAlpha = match2[3]; + for (i = 0; i < 3; i++) { + rgb[i] = parseInt(match2[i] + match2[i], 16); + } + if (hexAlpha) { + rgb[3] = parseInt(hexAlpha + hexAlpha, 16) / 255; + } + } else if (match2 = string.match(rgba)) { + for (i = 0; i < 3; i++) { + rgb[i] = parseInt(match2[i + 1], 0); + } + if (match2[4]) { + if (match2[5]) { + rgb[3] = parseFloat(match2[4]) * 0.01; + } else { + rgb[3] = parseFloat(match2[4]); + } + } + } else if (match2 = string.match(per)) { + for (i = 0; i < 3; i++) { + rgb[i] = Math.round(parseFloat(match2[i + 1]) * 2.55); + } + if (match2[4]) { + if (match2[5]) { + rgb[3] = parseFloat(match2[4]) * 0.01; + } else { + rgb[3] = parseFloat(match2[4]); + } + } + } else if (match2 = string.match(keyword)) { + if (match2[1] === "transparent") { + return [0, 0, 0, 0]; + } + if (!hasOwnProperty.call(colorNames, match2[1])) { + return null; + } + rgb = colorNames[match2[1]]; + rgb[3] = 1; + return rgb; + } else { + return null; + } + for (i = 0; i < 3; i++) { + rgb[i] = clamp(rgb[i], 0, 255); + } + rgb[3] = clamp(rgb[3], 0, 1); + return rgb; +}; +cs.get.hsl = function(string) { + if (!string) { + return null; + } + var hsl = /^hsla?\(\s*([+-]?(?:\d{0,3}\.)?\d+)(?:deg)?\s*,?\s*([+-]?[\d\.]+)%\s*,?\s*([+-]?[\d\.]+)%\s*(?:[,|\/]\s*([+-]?(?=\.\d|\d)(?:0|[1-9]\d*)?(?:\.\d*)?(?:[eE][+-]?\d+)?)\s*)?\)$/; + var match2 = string.match(hsl); + if (match2) { + var alpha = parseFloat(match2[4]); + var h = (parseFloat(match2[1]) % 360 + 360) % 360; + var s2 = clamp(parseFloat(match2[2]), 0, 100); + var l = clamp(parseFloat(match2[3]), 0, 100); + var a = clamp(isNaN(alpha) ? 1 : alpha, 0, 1); + return [h, s2, l, a]; + } + return null; +}; +cs.get.hwb = function(string) { + if (!string) { + return null; + } + var hwb = /^hwb\(\s*([+-]?\d{0,3}(?:\.\d+)?)(?:deg)?\s*,\s*([+-]?[\d\.]+)%\s*,\s*([+-]?[\d\.]+)%\s*(?:,\s*([+-]?(?=\.\d|\d)(?:0|[1-9]\d*)?(?:\.\d*)?(?:[eE][+-]?\d+)?)\s*)?\)$/; + var match2 = string.match(hwb); + if (match2) { + var alpha = parseFloat(match2[4]); + var h = (parseFloat(match2[1]) % 360 + 360) % 360; + var w = clamp(parseFloat(match2[2]), 0, 100); + var b = clamp(parseFloat(match2[3]), 0, 100); + var a = clamp(isNaN(alpha) ? 1 : alpha, 0, 1); + return [h, w, b, a]; + } + return null; +}; +cs.to.hex = function() { + var rgba = swizzle2(arguments); + return "#" + hexDouble(rgba[0]) + hexDouble(rgba[1]) + hexDouble(rgba[2]) + (rgba[3] < 1 ? hexDouble(Math.round(rgba[3] * 255)) : ""); +}; +cs.to.rgb = function() { + var rgba = swizzle2(arguments); + return rgba.length < 4 || rgba[3] === 1 ? "rgb(" + Math.round(rgba[0]) + ", " + Math.round(rgba[1]) + ", " + Math.round(rgba[2]) + ")" : "rgba(" + Math.round(rgba[0]) + ", " + Math.round(rgba[1]) + ", " + Math.round(rgba[2]) + ", " + rgba[3] + ")"; +}; +cs.to.rgb.percent = function() { + var rgba = swizzle2(arguments); + var r = Math.round(rgba[0] / 255 * 100); + var g = Math.round(rgba[1] / 255 * 100); + var b = Math.round(rgba[2] / 255 * 100); + return rgba.length < 4 || rgba[3] === 1 ? "rgb(" + r + "%, " + g + "%, " + b + "%)" : "rgba(" + r + "%, " + g + "%, " + b + "%, " + rgba[3] + ")"; +}; +cs.to.hsl = function() { + var hsla = swizzle2(arguments); + return hsla.length < 4 || hsla[3] === 1 ? "hsl(" + hsla[0] + ", " + hsla[1] + "%, " + hsla[2] + "%)" : "hsla(" + hsla[0] + ", " + hsla[1] + "%, " + hsla[2] + "%, " + hsla[3] + ")"; +}; +cs.to.hwb = function() { + var hwba = swizzle2(arguments); + var a = ""; + if (hwba.length >= 4 && hwba[3] !== 1) { + a = ", " + hwba[3]; + } + return "hwb(" + hwba[0] + ", " + hwba[1] + "%, " + hwba[2] + "%" + a + ")"; +}; +cs.to.keyword = function(rgb) { + return reverseNames[rgb.slice(0, 3)]; +}; +function clamp(num, min, max) { + return Math.min(Math.max(min, num), max); +} +function hexDouble(num) { + var str = Math.round(num).toString(16).toUpperCase(); + return str.length < 2 ? "0" + str : str; +} +var colorStringExports = colorString$1.exports; +const cssKeywords = colorName; +const reverseKeywords = {}; +for (const key of Object.keys(cssKeywords)) { + reverseKeywords[cssKeywords[key]] = key; +} +const convert$2 = { + rgb: { channels: 3, labels: "rgb" }, + hsl: { channels: 3, labels: "hsl" }, + hsv: { channels: 3, labels: "hsv" }, + hwb: { channels: 3, labels: "hwb" }, + cmyk: { channels: 4, labels: "cmyk" }, + xyz: { channels: 3, labels: "xyz" }, + lab: { channels: 3, labels: "lab" }, + lch: { channels: 3, labels: "lch" }, + hex: { channels: 1, labels: ["hex"] }, + keyword: { channels: 1, labels: ["keyword"] }, + ansi16: { channels: 1, labels: ["ansi16"] }, + ansi256: { channels: 1, labels: ["ansi256"] }, + hcg: { channels: 3, labels: ["h", "c", "g"] }, + apple: { channels: 3, labels: ["r16", "g16", "b16"] }, + gray: { channels: 1, labels: ["gray"] } +}; +var conversions$2 = convert$2; +for (const model of Object.keys(convert$2)) { + if (!("channels" in convert$2[model])) { + throw new Error("missing channels property: " + model); + } + if (!("labels" in convert$2[model])) { + throw new Error("missing channel labels property: " + model); + } + if (convert$2[model].labels.length !== convert$2[model].channels) { + throw new Error("channel and label counts mismatch: " + model); + } + const { channels, labels } = convert$2[model]; + delete convert$2[model].channels; + delete convert$2[model].labels; + Object.defineProperty(convert$2[model], "channels", { value: channels }); + Object.defineProperty(convert$2[model], "labels", { value: labels }); +} +convert$2.rgb.hsl = function(rgb) { + const r = rgb[0] / 255; + const g = rgb[1] / 255; + const b = rgb[2] / 255; + const min = Math.min(r, g, b); + const max = Math.max(r, g, b); + const delta = max - min; + let h; + let s2; + if (max === min) { + h = 0; + } else if (r === max) { + h = (g - b) / delta; + } else if (g === max) { + h = 2 + (b - r) / delta; + } else if (b === max) { + h = 4 + (r - g) / delta; + } + h = Math.min(h * 60, 360); + if (h < 0) { + h += 360; + } + const l = (min + max) / 2; + if (max === min) { + s2 = 0; + } else if (l <= 0.5) { + s2 = delta / (max + min); + } else { + s2 = delta / (2 - max - min); + } + return [h, s2 * 100, l * 100]; +}; +convert$2.rgb.hsv = function(rgb) { + let rdif; + let gdif; + let bdif; + let h; + let s2; + const r = rgb[0] / 255; + const g = rgb[1] / 255; + const b = rgb[2] / 255; + const v = Math.max(r, g, b); + const diff = v - Math.min(r, g, b); + const diffc = function(c) { + return (v - c) / 6 / diff + 1 / 2; + }; + if (diff === 0) { + h = 0; + s2 = 0; + } else { + s2 = diff / v; + rdif = diffc(r); + gdif = diffc(g); + bdif = diffc(b); + if (r === v) { + h = bdif - gdif; + } else if (g === v) { + h = 1 / 3 + rdif - bdif; + } else if (b === v) { + h = 2 / 3 + gdif - rdif; + } + if (h < 0) { + h += 1; + } else if (h > 1) { + h -= 1; + } + } + return [ + h * 360, + s2 * 100, + v * 100 + ]; +}; +convert$2.rgb.hwb = function(rgb) { + const r = rgb[0]; + const g = rgb[1]; + let b = rgb[2]; + const h = convert$2.rgb.hsl(rgb)[0]; + const w = 1 / 255 * Math.min(r, Math.min(g, b)); + b = 1 - 1 / 255 * Math.max(r, Math.max(g, b)); + return [h, w * 100, b * 100]; +}; +convert$2.rgb.cmyk = function(rgb) { + const r = rgb[0] / 255; + const g = rgb[1] / 255; + const b = rgb[2] / 255; + const k = Math.min(1 - r, 1 - g, 1 - b); + const c = (1 - r - k) / (1 - k) || 0; + const m = (1 - g - k) / (1 - k) || 0; + const y = (1 - b - k) / (1 - k) || 0; + return [c * 100, m * 100, y * 100, k * 100]; +}; +function comparativeDistance(x, y) { + return (x[0] - y[0]) ** 2 + (x[1] - y[1]) ** 2 + (x[2] - y[2]) ** 2; +} +convert$2.rgb.keyword = function(rgb) { + const reversed = reverseKeywords[rgb]; + if (reversed) { + return reversed; + } + let currentClosestDistance = Infinity; + let currentClosestKeyword; + for (const keyword of Object.keys(cssKeywords)) { + const value = cssKeywords[keyword]; + const distance = comparativeDistance(rgb, value); + if (distance < currentClosestDistance) { + currentClosestDistance = distance; + currentClosestKeyword = keyword; + } + } + return currentClosestKeyword; +}; +convert$2.keyword.rgb = function(keyword) { + return cssKeywords[keyword]; +}; +convert$2.rgb.xyz = function(rgb) { + let r = rgb[0] / 255; + let g = rgb[1] / 255; + let b = rgb[2] / 255; + r = r > 0.04045 ? ((r + 0.055) / 1.055) ** 2.4 : r / 12.92; + g = g > 0.04045 ? ((g + 0.055) / 1.055) ** 2.4 : g / 12.92; + b = b > 0.04045 ? ((b + 0.055) / 1.055) ** 2.4 : b / 12.92; + const x = r * 0.4124 + g * 0.3576 + b * 0.1805; + const y = r * 0.2126 + g * 0.7152 + b * 0.0722; + const z = r * 0.0193 + g * 0.1192 + b * 0.9505; + return [x * 100, y * 100, z * 100]; +}; +convert$2.rgb.lab = function(rgb) { + const xyz = convert$2.rgb.xyz(rgb); + let x = xyz[0]; + let y = xyz[1]; + let z = xyz[2]; + x /= 95.047; + y /= 100; + z /= 108.883; + x = x > 8856e-6 ? x ** (1 / 3) : 7.787 * x + 16 / 116; + y = y > 8856e-6 ? y ** (1 / 3) : 7.787 * y + 16 / 116; + z = z > 8856e-6 ? z ** (1 / 3) : 7.787 * z + 16 / 116; + const l = 116 * y - 16; + const a = 500 * (x - y); + const b = 200 * (y - z); + return [l, a, b]; +}; +convert$2.hsl.rgb = function(hsl) { + const h = hsl[0] / 360; + const s2 = hsl[1] / 100; + const l = hsl[2] / 100; + let t2; + let t3; + let val; + if (s2 === 0) { + val = l * 255; + return [val, val, val]; + } + if (l < 0.5) { + t2 = l * (1 + s2); + } else { + t2 = l + s2 - l * s2; + } + const t1 = 2 * l - t2; + const rgb = [0, 0, 0]; + for (let i = 0; i < 3; i++) { + t3 = h + 1 / 3 * -(i - 1); + if (t3 < 0) { + t3++; + } + if (t3 > 1) { + t3--; + } + if (6 * t3 < 1) { + val = t1 + (t2 - t1) * 6 * t3; + } else if (2 * t3 < 1) { + val = t2; + } else if (3 * t3 < 2) { + val = t1 + (t2 - t1) * (2 / 3 - t3) * 6; + } else { + val = t1; + } + rgb[i] = val * 255; + } + return rgb; +}; +convert$2.hsl.hsv = function(hsl) { + const h = hsl[0]; + let s2 = hsl[1] / 100; + let l = hsl[2] / 100; + let smin = s2; + const lmin = Math.max(l, 0.01); + l *= 2; + s2 *= l <= 1 ? l : 2 - l; + smin *= lmin <= 1 ? lmin : 2 - lmin; + const v = (l + s2) / 2; + const sv = l === 0 ? 2 * smin / (lmin + smin) : 2 * s2 / (l + s2); + return [h, sv * 100, v * 100]; +}; +convert$2.hsv.rgb = function(hsv) { + const h = hsv[0] / 60; + const s2 = hsv[1] / 100; + let v = hsv[2] / 100; + const hi = Math.floor(h) % 6; + const f = h - Math.floor(h); + const p = 255 * v * (1 - s2); + const q = 255 * v * (1 - s2 * f); + const t = 255 * v * (1 - s2 * (1 - f)); + v *= 255; + switch (hi) { + case 0: + return [v, t, p]; + case 1: + return [q, v, p]; + case 2: + return [p, v, t]; + case 3: + return [p, q, v]; + case 4: + return [t, p, v]; + case 5: + return [v, p, q]; + } +}; +convert$2.hsv.hsl = function(hsv) { + const h = hsv[0]; + const s2 = hsv[1] / 100; + const v = hsv[2] / 100; + const vmin = Math.max(v, 0.01); + let sl; + let l; + l = (2 - s2) * v; + const lmin = (2 - s2) * vmin; + sl = s2 * vmin; + sl /= lmin <= 1 ? lmin : 2 - lmin; + sl = sl || 0; + l /= 2; + return [h, sl * 100, l * 100]; +}; +convert$2.hwb.rgb = function(hwb) { + const h = hwb[0] / 360; + let wh = hwb[1] / 100; + let bl = hwb[2] / 100; + const ratio = wh + bl; + let f; + if (ratio > 1) { + wh /= ratio; + bl /= ratio; + } + const i = Math.floor(6 * h); + const v = 1 - bl; + f = 6 * h - i; + if ((i & 1) !== 0) { + f = 1 - f; + } + const n = wh + f * (v - wh); + let r; + let g; + let b; + switch (i) { + default: + case 6: + case 0: + r = v; + g = n; + b = wh; + break; + case 1: + r = n; + g = v; + b = wh; + break; + case 2: + r = wh; + g = v; + b = n; + break; + case 3: + r = wh; + g = n; + b = v; + break; + case 4: + r = n; + g = wh; + b = v; + break; + case 5: + r = v; + g = wh; + b = n; + break; + } + return [r * 255, g * 255, b * 255]; +}; +convert$2.cmyk.rgb = function(cmyk) { + const c = cmyk[0] / 100; + const m = cmyk[1] / 100; + const y = cmyk[2] / 100; + const k = cmyk[3] / 100; + const r = 1 - Math.min(1, c * (1 - k) + k); + const g = 1 - Math.min(1, m * (1 - k) + k); + const b = 1 - Math.min(1, y * (1 - k) + k); + return [r * 255, g * 255, b * 255]; +}; +convert$2.xyz.rgb = function(xyz) { + const x = xyz[0] / 100; + const y = xyz[1] / 100; + const z = xyz[2] / 100; + let r; + let g; + let b; + r = x * 3.2406 + y * -1.5372 + z * -0.4986; + g = x * -0.9689 + y * 1.8758 + z * 0.0415; + b = x * 0.0557 + y * -0.204 + z * 1.057; + r = r > 31308e-7 ? 1.055 * r ** (1 / 2.4) - 0.055 : r * 12.92; + g = g > 31308e-7 ? 1.055 * g ** (1 / 2.4) - 0.055 : g * 12.92; + b = b > 31308e-7 ? 1.055 * b ** (1 / 2.4) - 0.055 : b * 12.92; + r = Math.min(Math.max(0, r), 1); + g = Math.min(Math.max(0, g), 1); + b = Math.min(Math.max(0, b), 1); + return [r * 255, g * 255, b * 255]; +}; +convert$2.xyz.lab = function(xyz) { + let x = xyz[0]; + let y = xyz[1]; + let z = xyz[2]; + x /= 95.047; + y /= 100; + z /= 108.883; + x = x > 8856e-6 ? x ** (1 / 3) : 7.787 * x + 16 / 116; + y = y > 8856e-6 ? y ** (1 / 3) : 7.787 * y + 16 / 116; + z = z > 8856e-6 ? z ** (1 / 3) : 7.787 * z + 16 / 116; + const l = 116 * y - 16; + const a = 500 * (x - y); + const b = 200 * (y - z); + return [l, a, b]; +}; +convert$2.lab.xyz = function(lab) { + const l = lab[0]; + const a = lab[1]; + const b = lab[2]; + let x; + let y; + let z; + y = (l + 16) / 116; + x = a / 500 + y; + z = y - b / 200; + const y2 = y ** 3; + const x2 = x ** 3; + const z2 = z ** 3; + y = y2 > 8856e-6 ? y2 : (y - 16 / 116) / 7.787; + x = x2 > 8856e-6 ? x2 : (x - 16 / 116) / 7.787; + z = z2 > 8856e-6 ? z2 : (z - 16 / 116) / 7.787; + x *= 95.047; + y *= 100; + z *= 108.883; + return [x, y, z]; +}; +convert$2.lab.lch = function(lab) { + const l = lab[0]; + const a = lab[1]; + const b = lab[2]; + let h; + const hr = Math.atan2(b, a); + h = hr * 360 / 2 / Math.PI; + if (h < 0) { + h += 360; + } + const c = Math.sqrt(a * a + b * b); + return [l, c, h]; +}; +convert$2.lch.lab = function(lch) { + const l = lch[0]; + const c = lch[1]; + const h = lch[2]; + const hr = h / 360 * 2 * Math.PI; + const a = c * Math.cos(hr); + const b = c * Math.sin(hr); + return [l, a, b]; +}; +convert$2.rgb.ansi16 = function(args, saturation = null) { + const [r, g, b] = args; + let value = saturation === null ? convert$2.rgb.hsv(args)[2] : saturation; + value = Math.round(value / 50); + if (value === 0) { + return 30; + } + let ansi = 30 + (Math.round(b / 255) << 2 | Math.round(g / 255) << 1 | Math.round(r / 255)); + if (value === 2) { + ansi += 60; + } + return ansi; +}; +convert$2.hsv.ansi16 = function(args) { + return convert$2.rgb.ansi16(convert$2.hsv.rgb(args), args[2]); +}; +convert$2.rgb.ansi256 = function(args) { + const r = args[0]; + const g = args[1]; + const b = args[2]; + if (r === g && g === b) { + if (r < 8) { + return 16; + } + if (r > 248) { + return 231; + } + return Math.round((r - 8) / 247 * 24) + 232; + } + const ansi = 16 + 36 * Math.round(r / 255 * 5) + 6 * Math.round(g / 255 * 5) + Math.round(b / 255 * 5); + return ansi; +}; +convert$2.ansi16.rgb = function(args) { + let color2 = args % 10; + if (color2 === 0 || color2 === 7) { + if (args > 50) { + color2 += 3.5; + } + color2 = color2 / 10.5 * 255; + return [color2, color2, color2]; + } + const mult = (~~(args > 50) + 1) * 0.5; + const r = (color2 & 1) * mult * 255; + const g = (color2 >> 1 & 1) * mult * 255; + const b = (color2 >> 2 & 1) * mult * 255; + return [r, g, b]; +}; +convert$2.ansi256.rgb = function(args) { + if (args >= 232) { + const c = (args - 232) * 10 + 8; + return [c, c, c]; + } + args -= 16; + let rem; + const r = Math.floor(args / 36) / 5 * 255; + const g = Math.floor((rem = args % 36) / 6) / 5 * 255; + const b = rem % 6 / 5 * 255; + return [r, g, b]; +}; +convert$2.rgb.hex = function(args) { + const integer = ((Math.round(args[0]) & 255) << 16) + ((Math.round(args[1]) & 255) << 8) + (Math.round(args[2]) & 255); + const string = integer.toString(16).toUpperCase(); + return "000000".substring(string.length) + string; +}; +convert$2.hex.rgb = function(args) { + const match2 = args.toString(16).match(/[a-f0-9]{6}|[a-f0-9]{3}/i); + if (!match2) { + return [0, 0, 0]; + } + let colorString2 = match2[0]; + if (match2[0].length === 3) { + colorString2 = colorString2.split("").map((char) => { + return char + char; + }).join(""); + } + const integer = parseInt(colorString2, 16); + const r = integer >> 16 & 255; + const g = integer >> 8 & 255; + const b = integer & 255; + return [r, g, b]; +}; +convert$2.rgb.hcg = function(rgb) { + const r = rgb[0] / 255; + const g = rgb[1] / 255; + const b = rgb[2] / 255; + const max = Math.max(Math.max(r, g), b); + const min = Math.min(Math.min(r, g), b); + const chroma = max - min; + let grayscale; + let hue; + if (chroma < 1) { + grayscale = min / (1 - chroma); + } else { + grayscale = 0; + } + if (chroma <= 0) { + hue = 0; + } else if (max === r) { + hue = (g - b) / chroma % 6; + } else if (max === g) { + hue = 2 + (b - r) / chroma; + } else { + hue = 4 + (r - g) / chroma; + } + hue /= 6; + hue %= 1; + return [hue * 360, chroma * 100, grayscale * 100]; +}; +convert$2.hsl.hcg = function(hsl) { + const s2 = hsl[1] / 100; + const l = hsl[2] / 100; + const c = l < 0.5 ? 2 * s2 * l : 2 * s2 * (1 - l); + let f = 0; + if (c < 1) { + f = (l - 0.5 * c) / (1 - c); + } + return [hsl[0], c * 100, f * 100]; +}; +convert$2.hsv.hcg = function(hsv) { + const s2 = hsv[1] / 100; + const v = hsv[2] / 100; + const c = s2 * v; + let f = 0; + if (c < 1) { + f = (v - c) / (1 - c); + } + return [hsv[0], c * 100, f * 100]; +}; +convert$2.hcg.rgb = function(hcg) { + const h = hcg[0] / 360; + const c = hcg[1] / 100; + const g = hcg[2] / 100; + if (c === 0) { + return [g * 255, g * 255, g * 255]; + } + const pure = [0, 0, 0]; + const hi = h % 1 * 6; + const v = hi % 1; + const w = 1 - v; + let mg = 0; + switch (Math.floor(hi)) { + case 0: + pure[0] = 1; + pure[1] = v; + pure[2] = 0; + break; + case 1: + pure[0] = w; + pure[1] = 1; + pure[2] = 0; + break; + case 2: + pure[0] = 0; + pure[1] = 1; + pure[2] = v; + break; + case 3: + pure[0] = 0; + pure[1] = w; + pure[2] = 1; + break; + case 4: + pure[0] = v; + pure[1] = 0; + pure[2] = 1; + break; + default: + pure[0] = 1; + pure[1] = 0; + pure[2] = w; + } + mg = (1 - c) * g; + return [ + (c * pure[0] + mg) * 255, + (c * pure[1] + mg) * 255, + (c * pure[2] + mg) * 255 + ]; +}; +convert$2.hcg.hsv = function(hcg) { + const c = hcg[1] / 100; + const g = hcg[2] / 100; + const v = c + g * (1 - c); + let f = 0; + if (v > 0) { + f = c / v; + } + return [hcg[0], f * 100, v * 100]; +}; +convert$2.hcg.hsl = function(hcg) { + const c = hcg[1] / 100; + const g = hcg[2] / 100; + const l = g * (1 - c) + 0.5 * c; + let s2 = 0; + if (l > 0 && l < 0.5) { + s2 = c / (2 * l); + } else if (l >= 0.5 && l < 1) { + s2 = c / (2 * (1 - l)); + } + return [hcg[0], s2 * 100, l * 100]; +}; +convert$2.hcg.hwb = function(hcg) { + const c = hcg[1] / 100; + const g = hcg[2] / 100; + const v = c + g * (1 - c); + return [hcg[0], (v - c) * 100, (1 - v) * 100]; +}; +convert$2.hwb.hcg = function(hwb) { + const w = hwb[1] / 100; + const b = hwb[2] / 100; + const v = 1 - b; + const c = v - w; + let g = 0; + if (c < 1) { + g = (v - c) / (1 - c); + } + return [hwb[0], c * 100, g * 100]; +}; +convert$2.apple.rgb = function(apple) { + return [apple[0] / 65535 * 255, apple[1] / 65535 * 255, apple[2] / 65535 * 255]; +}; +convert$2.rgb.apple = function(rgb) { + return [rgb[0] / 255 * 65535, rgb[1] / 255 * 65535, rgb[2] / 255 * 65535]; +}; +convert$2.gray.rgb = function(args) { + return [args[0] / 100 * 255, args[0] / 100 * 255, args[0] / 100 * 255]; +}; +convert$2.gray.hsl = function(args) { + return [0, 0, args[0]]; +}; +convert$2.gray.hsv = convert$2.gray.hsl; +convert$2.gray.hwb = function(gray) { + return [0, 100, gray[0]]; +}; +convert$2.gray.cmyk = function(gray) { + return [0, 0, 0, gray[0]]; +}; +convert$2.gray.lab = function(gray) { + return [gray[0], 0, 0]; +}; +convert$2.gray.hex = function(gray) { + const val = Math.round(gray[0] / 100 * 255) & 255; + const integer = (val << 16) + (val << 8) + val; + const string = integer.toString(16).toUpperCase(); + return "000000".substring(string.length) + string; +}; +convert$2.rgb.gray = function(rgb) { + const val = (rgb[0] + rgb[1] + rgb[2]) / 3; + return [val / 255 * 100]; +}; +const conversions$1 = conversions$2; +function buildGraph() { + const graph = {}; + const models2 = Object.keys(conversions$1); + for (let len = models2.length, i = 0; i < len; i++) { + graph[models2[i]] = { + // http://jsperf.com/1-vs-infinity + // micro-opt, but this is simple. + distance: -1, + parent: null + }; + } + return graph; +} +function deriveBFS(fromModel) { + const graph = buildGraph(); + const queue = [fromModel]; + graph[fromModel].distance = 0; + while (queue.length) { + const current = queue.pop(); + const adjacents = Object.keys(conversions$1[current]); + for (let len = adjacents.length, i = 0; i < len; i++) { + const adjacent = adjacents[i]; + const node = graph[adjacent]; + if (node.distance === -1) { + node.distance = graph[current].distance + 1; + node.parent = current; + queue.unshift(adjacent); + } + } + } + return graph; +} +function link(from, to) { + return function(args) { + return to(from(args)); + }; +} +function wrapConversion(toModel, graph) { + const path2 = [graph[toModel].parent, toModel]; + let fn = conversions$1[graph[toModel].parent][toModel]; + let cur = graph[toModel].parent; + while (graph[cur].parent) { + path2.unshift(graph[cur].parent); + fn = link(conversions$1[graph[cur].parent][cur], fn); + cur = graph[cur].parent; + } + fn.conversion = path2; + return fn; +} +var route$1 = function(fromModel) { + const graph = deriveBFS(fromModel); + const conversion = {}; + const models2 = Object.keys(graph); + for (let len = models2.length, i = 0; i < len; i++) { + const toModel = models2[i]; + const node = graph[toModel]; + if (node.parent === null) { + continue; + } + conversion[toModel] = wrapConversion(toModel, graph); + } + return conversion; +}; +const conversions = conversions$2; +const route = route$1; +const convert$1 = {}; +const models = Object.keys(conversions); +function wrapRaw(fn) { + const wrappedFn = function(...args) { + const arg0 = args[0]; + if (arg0 === void 0 || arg0 === null) { + return arg0; + } + if (arg0.length > 1) { + args = arg0; + } + return fn(args); + }; + if ("conversion" in fn) { + wrappedFn.conversion = fn.conversion; + } + return wrappedFn; +} +function wrapRounded(fn) { + const wrappedFn = function(...args) { + const arg0 = args[0]; + if (arg0 === void 0 || arg0 === null) { + return arg0; + } + if (arg0.length > 1) { + args = arg0; + } + const result = fn(args); + if (typeof result === "object") { + for (let len = result.length, i = 0; i < len; i++) { + result[i] = Math.round(result[i]); + } + } + return result; + }; + if ("conversion" in fn) { + wrappedFn.conversion = fn.conversion; + } + return wrappedFn; +} +models.forEach((fromModel) => { + convert$1[fromModel] = {}; + Object.defineProperty(convert$1[fromModel], "channels", { value: conversions[fromModel].channels }); + Object.defineProperty(convert$1[fromModel], "labels", { value: conversions[fromModel].labels }); + const routes = route(fromModel); + const routeModels = Object.keys(routes); + routeModels.forEach((toModel) => { + const fn = routes[toModel]; + convert$1[fromModel][toModel] = wrapRounded(fn); + convert$1[fromModel][toModel].raw = wrapRaw(fn); + }); +}); +var colorConvert = convert$1; +const colorString = colorStringExports; +const convert = colorConvert; +const skippedModels = [ + // To be honest, I don't really feel like keyword belongs in color convert, but eh. + "keyword", + // Gray conflicts with some method names, and has its own method defined. + "gray", + // Shouldn't really be in color-convert either... + "hex" +]; +const hashedModelKeys = {}; +for (const model of Object.keys(convert)) { + hashedModelKeys[[...convert[model].labels].sort().join("")] = model; +} +const limiters = {}; +function Color(object, model) { + if (!(this instanceof Color)) { + return new Color(object, model); + } + if (model && model in skippedModels) { + model = null; + } + if (model && !(model in convert)) { + throw new Error("Unknown model: " + model); + } + let i; + let channels; + if (object == null) { + this.model = "rgb"; + this.color = [0, 0, 0]; + this.valpha = 1; + } else if (object instanceof Color) { + this.model = object.model; + this.color = [...object.color]; + this.valpha = object.valpha; + } else if (typeof object === "string") { + const result = colorString.get(object); + if (result === null) { + throw new Error("Unable to parse color from string: " + object); + } + this.model = result.model; + channels = convert[this.model].channels; + this.color = result.value.slice(0, channels); + this.valpha = typeof result.value[channels] === "number" ? result.value[channels] : 1; + } else if (object.length > 0) { + this.model = model || "rgb"; + channels = convert[this.model].channels; + const newArray = Array.prototype.slice.call(object, 0, channels); + this.color = zeroArray(newArray, channels); + this.valpha = typeof object[channels] === "number" ? object[channels] : 1; + } else if (typeof object === "number") { + this.model = "rgb"; + this.color = [ + object >> 16 & 255, + object >> 8 & 255, + object & 255 + ]; + this.valpha = 1; + } else { + this.valpha = 1; + const keys2 = Object.keys(object); + if ("alpha" in object) { + keys2.splice(keys2.indexOf("alpha"), 1); + this.valpha = typeof object.alpha === "number" ? object.alpha : 0; + } + const hashedKeys = keys2.sort().join(""); + if (!(hashedKeys in hashedModelKeys)) { + throw new Error("Unable to parse color from object: " + JSON.stringify(object)); + } + this.model = hashedModelKeys[hashedKeys]; + const { labels } = convert[this.model]; + const color2 = []; + for (i = 0; i < labels.length; i++) { + color2.push(object[labels[i]]); + } + this.color = zeroArray(color2); + } + if (limiters[this.model]) { + channels = convert[this.model].channels; + for (i = 0; i < channels; i++) { + const limit = limiters[this.model][i]; + if (limit) { + this.color[i] = limit(this.color[i]); + } + } + } + this.valpha = Math.max(0, Math.min(1, this.valpha)); + if (Object.freeze) { + Object.freeze(this); + } +} +Color.prototype = { + toString() { + return this.string(); + }, + toJSON() { + return this[this.model](); + }, + string(places) { + let self = this.model in colorString.to ? this : this.rgb(); + self = self.round(typeof places === "number" ? places : 1); + const args = self.valpha === 1 ? self.color : [...self.color, this.valpha]; + return colorString.to[self.model](args); + }, + percentString(places) { + const self = this.rgb().round(typeof places === "number" ? places : 1); + const args = self.valpha === 1 ? self.color : [...self.color, this.valpha]; + return colorString.to.rgb.percent(args); + }, + array() { + return this.valpha === 1 ? [...this.color] : [...this.color, this.valpha]; + }, + object() { + const result = {}; + const { channels } = convert[this.model]; + const { labels } = convert[this.model]; + for (let i = 0; i < channels; i++) { + result[labels[i]] = this.color[i]; + } + if (this.valpha !== 1) { + result.alpha = this.valpha; + } + return result; + }, + unitArray() { + const rgb = this.rgb().color; + rgb[0] /= 255; + rgb[1] /= 255; + rgb[2] /= 255; + if (this.valpha !== 1) { + rgb.push(this.valpha); + } + return rgb; + }, + unitObject() { + const rgb = this.rgb().object(); + rgb.r /= 255; + rgb.g /= 255; + rgb.b /= 255; + if (this.valpha !== 1) { + rgb.alpha = this.valpha; + } + return rgb; + }, + round(places) { + places = Math.max(places || 0, 0); + return new Color([...this.color.map(roundToPlace(places)), this.valpha], this.model); + }, + alpha(value) { + if (value !== void 0) { + return new Color([...this.color, Math.max(0, Math.min(1, value))], this.model); + } + return this.valpha; + }, + // Rgb + red: getset("rgb", 0, maxfn(255)), + green: getset("rgb", 1, maxfn(255)), + blue: getset("rgb", 2, maxfn(255)), + hue: getset(["hsl", "hsv", "hsl", "hwb", "hcg"], 0, (value) => (value % 360 + 360) % 360), + saturationl: getset("hsl", 1, maxfn(100)), + lightness: getset("hsl", 2, maxfn(100)), + saturationv: getset("hsv", 1, maxfn(100)), + value: getset("hsv", 2, maxfn(100)), + chroma: getset("hcg", 1, maxfn(100)), + gray: getset("hcg", 2, maxfn(100)), + white: getset("hwb", 1, maxfn(100)), + wblack: getset("hwb", 2, maxfn(100)), + cyan: getset("cmyk", 0, maxfn(100)), + magenta: getset("cmyk", 1, maxfn(100)), + yellow: getset("cmyk", 2, maxfn(100)), + black: getset("cmyk", 3, maxfn(100)), + x: getset("xyz", 0, maxfn(95.047)), + y: getset("xyz", 1, maxfn(100)), + z: getset("xyz", 2, maxfn(108.833)), + l: getset("lab", 0, maxfn(100)), + a: getset("lab", 1), + b: getset("lab", 2), + keyword(value) { + if (value !== void 0) { + return new Color(value); + } + return convert[this.model].keyword(this.color); + }, + hex(value) { + if (value !== void 0) { + return new Color(value); + } + return colorString.to.hex(this.rgb().round().color); + }, + hexa(value) { + if (value !== void 0) { + return new Color(value); + } + const rgbArray = this.rgb().round().color; + let alphaHex = Math.round(this.valpha * 255).toString(16).toUpperCase(); + if (alphaHex.length === 1) { + alphaHex = "0" + alphaHex; + } + return colorString.to.hex(rgbArray) + alphaHex; + }, + rgbNumber() { + const rgb = this.rgb().color; + return (rgb[0] & 255) << 16 | (rgb[1] & 255) << 8 | rgb[2] & 255; + }, + luminosity() { + const rgb = this.rgb().color; + const lum = []; + for (const [i, element] of rgb.entries()) { + const chan = element / 255; + lum[i] = chan <= 0.04045 ? chan / 12.92 : ((chan + 0.055) / 1.055) ** 2.4; + } + return 0.2126 * lum[0] + 0.7152 * lum[1] + 0.0722 * lum[2]; + }, + contrast(color2) { + const lum1 = this.luminosity(); + const lum2 = color2.luminosity(); + if (lum1 > lum2) { + return (lum1 + 0.05) / (lum2 + 0.05); + } + return (lum2 + 0.05) / (lum1 + 0.05); + }, + level(color2) { + const contrastRatio = this.contrast(color2); + if (contrastRatio >= 7) { + return "AAA"; + } + return contrastRatio >= 4.5 ? "AA" : ""; + }, + isDark() { + const rgb = this.rgb().color; + const yiq = (rgb[0] * 2126 + rgb[1] * 7152 + rgb[2] * 722) / 1e4; + return yiq < 128; + }, + isLight() { + return !this.isDark(); + }, + negate() { + const rgb = this.rgb(); + for (let i = 0; i < 3; i++) { + rgb.color[i] = 255 - rgb.color[i]; + } + return rgb; + }, + lighten(ratio) { + const hsl = this.hsl(); + hsl.color[2] += hsl.color[2] * ratio; + return hsl; + }, + darken(ratio) { + const hsl = this.hsl(); + hsl.color[2] -= hsl.color[2] * ratio; + return hsl; + }, + saturate(ratio) { + const hsl = this.hsl(); + hsl.color[1] += hsl.color[1] * ratio; + return hsl; + }, + desaturate(ratio) { + const hsl = this.hsl(); + hsl.color[1] -= hsl.color[1] * ratio; + return hsl; + }, + whiten(ratio) { + const hwb = this.hwb(); + hwb.color[1] += hwb.color[1] * ratio; + return hwb; + }, + blacken(ratio) { + const hwb = this.hwb(); + hwb.color[2] += hwb.color[2] * ratio; + return hwb; + }, + grayscale() { + const rgb = this.rgb().color; + const value = rgb[0] * 0.3 + rgb[1] * 0.59 + rgb[2] * 0.11; + return Color.rgb(value, value, value); + }, + fade(ratio) { + return this.alpha(this.valpha - this.valpha * ratio); + }, + opaquer(ratio) { + return this.alpha(this.valpha + this.valpha * ratio); + }, + rotate(degrees) { + const hsl = this.hsl(); + let hue = hsl.color[0]; + hue = (hue + degrees) % 360; + hue = hue < 0 ? 360 + hue : hue; + hsl.color[0] = hue; + return hsl; + }, + mix(mixinColor, weight) { + if (!mixinColor || !mixinColor.rgb) { + throw new Error('Argument to "mix" was not a Color instance, but rather an instance of ' + typeof mixinColor); + } + const color1 = mixinColor.rgb(); + const color2 = this.rgb(); + const p = weight === void 0 ? 0.5 : weight; + const w = 2 * p - 1; + const a = color1.alpha() - color2.alpha(); + const w1 = ((w * a === -1 ? w : (w + a) / (1 + w * a)) + 1) / 2; + const w2 = 1 - w1; + return Color.rgb( + w1 * color1.red() + w2 * color2.red(), + w1 * color1.green() + w2 * color2.green(), + w1 * color1.blue() + w2 * color2.blue(), + color1.alpha() * p + color2.alpha() * (1 - p) + ); + } +}; +for (const model of Object.keys(convert)) { + if (skippedModels.includes(model)) { + continue; + } + const { channels } = convert[model]; + Color.prototype[model] = function(...args) { + if (this.model === model) { + return new Color(this); + } + if (args.length > 0) { + return new Color(args, model); + } + return new Color([...assertArray(convert[this.model][model].raw(this.color)), this.valpha], model); + }; + Color[model] = function(...args) { + let color2 = args[0]; + if (typeof color2 === "number") { + color2 = zeroArray(args, channels); + } + return new Color(color2, model); + }; +} +function roundTo(number, places) { + return Number(number.toFixed(places)); +} +function roundToPlace(places) { + return function(number) { + return roundTo(number, places); + }; +} +function getset(model, channel, modifier) { + model = Array.isArray(model) ? model : [model]; + for (const m of model) { + (limiters[m] || (limiters[m] = []))[channel] = modifier; + } + model = model[0]; + return function(value) { + let result; + if (value !== void 0) { + if (modifier) { + value = modifier(value); + } + result = this[model](); + result.color[channel] = value; + return result; + } + result = this[model]().color[channel]; + if (modifier) { + result = modifier(result); + } + return result; + }; +} +function maxfn(max) { + return function(v) { + return Math.max(0, Math.min(max, v)); + }; +} +function assertArray(value) { + return Array.isArray(value) ? value : [value]; +} +function zeroArray(array, length) { + for (let i = 0; i < length; i++) { + if (typeof array[i] !== "number") { + array[i] = 0; + } + } + return array; +} +var color = Color; +const Color2 = /* @__PURE__ */ getDefaultExportFromCjs(color); +var macros = { + cref: { signature: "s m" }, + Cref: { signature: "s m" }, + crefrange: { signature: "s m m" }, + Crefrange: { signature: "s m m" }, + cpageref: { signature: "s m" }, + Cpageref: { signature: "s m" }, + ref: { signature: "m" }, + pageref: { signature: "m" }, + namecref: { signature: "m" }, + nameCref: { signature: "m" }, + lcnamecref: { signature: "m" }, + namecrefs: { signature: "m" }, + nameCrefs: { signature: "m" }, + lcnamecrefs: { signature: "m" }, + labelcref: { signature: "m" }, + labelcpageref: { signature: "m" }, + crefalias: { signature: "m m" }, + crefname: { signature: "m m m" }, + // XXX there are many more obscure commands to add here + // https://ctan.org/pkg/cleveref + crefdefaultlabelformat: { signature: "m" }, + crefrangeconjunction: { signature: "m" } +}; +var environments = {}; +function cleanEnumerateBody(ast, itemName = "item") { + let { segments, macros: macros17 } = splitOnMacro(ast, itemName); + for (let i = 0; i < segments.length; i++) { + const segment = segments[i]; + if (i === 0) { + trimEnd(segment); + } else { + trim$1(segment); + } + if (segment.length > 0 && i > 0) { + segment.unshift({ type: "whitespace" }); + } + } + let insertParbreakBefore = /* @__PURE__ */ new WeakSet(); + let body = macros17.flatMap((node, i) => { + var _a; + const segment = segments[i + 1]; + const trailingComments = popTrailingComments(segment); + node.args = node.args || []; + node.args.push(arg(segment, { openMark: "", closeMark: "" })); + updateRenderInfo(node, { inParMode: true }); + if (i > 0 || ((_a = segments[0]) == null ? void 0 : _a.length) > 0) { + insertParbreakBefore.add(node); + } + return [node, ...trailingComments]; + }); + body = body.flatMap( + (node) => insertParbreakBefore.has(node) ? [{ type: "parbreak" }, node] : node + ); + body.unshift(...segments[0]); + for (let i = 0; i < body.length - 1; i++) { + const node = body[i]; + const nextNode = body[i + 1]; + if (!match.parbreak(nextNode)) { + continue; + } + if (match.comment(node)) { + node.suffixParbreak = true; + } + if (match.macro(node) && node.args && node.args[node.args.length - 1].closeMark === "") { + const args = node.args[node.args.length - 1].content; + const lastArg = args[args.length - 1]; + if (match.comment(lastArg)) { + lastArg.suffixParbreak = true; + } + } + } + return body; +} +function popTrailingComments(nodes) { + let lastNodeIndex = lastSignificantNodeIndex(nodes, true); + if (lastNodeIndex === nodes.length - 1 || lastNodeIndex == null && nodes.length === 0) { + return []; + } + if (lastNodeIndex == null) { + lastNodeIndex = -1; + } + return nodes.splice(lastNodeIndex + 1); +} +var macros2 = { + answerline: { signature: "o" }, + fillin: { signature: "o o" }, + fullwidth: { signature: "m" }, + fillwidthlines: { signature: "m" }, + fillwidthdottedlines: { signature: "m" }, + fillwidthgrid: { signature: "m" }, + makeemptybox: { signature: "m" }, + CorrectChoiceEmphasis: { + signature: "m", + renderInfo: { breakAround: true } + }, + SolutionEmphasis: { signature: "m", renderInfo: { breakAround: true } }, + uplevel: { signature: "m", renderInfo: { breakAround: true } }, + checkboxchar: { signature: "m", renderInfo: { breakAround: true } }, + checkedchar: { signature: "m", renderInfo: { breakAround: true } }, + pointname: { signature: "m", renderInfo: { breakAround: true } }, + marginpointname: { signature: "m", renderInfo: { breakAround: true } }, + extrawidth: { signature: "m", renderInfo: { breakAround: true } }, + pointformat: { signature: "m", renderInfo: { breakAround: true } }, + bonuspointformat: { signature: "m", renderInfo: { breakAround: true } }, + totalformat: { signature: "m", renderInfo: { breakAround: true } }, + qformat: { signature: "m", renderInfo: { breakAround: true } }, + titledquestion: { signature: "m o", renderInfo: { breakAround: true } }, + pointpoints: { signature: "m m", renderInfo: { breakAround: true } }, + bonuspointpoints: { signature: "m m", renderInfo: { breakAround: true } } +}; +var environments2 = { + choices: { + signature: "o", + processContent: (nodes) => cleanEnumerateBody(nodes, "choice") + }, + checkboxes: { + signature: "o", + processContent: (nodes) => cleanEnumerateBody(nodes, "choice") + }, + oneparchoices: { + signature: "o", + processContent: (nodes) => cleanEnumerateBody(nodes, "choice") + }, + oneparcheckboxes: { + signature: "o", + processContent: (nodes) => cleanEnumerateBody(nodes, "choice") + }, + parts: { + signature: "o", + processContent: (nodes) => cleanEnumerateBody(nodes, "part") + }, + subparts: { + signature: "o", + processContent: (nodes) => cleanEnumerateBody(nodes, "subpart") + }, + subsubparts: { + signature: "o", + processContent: (nodes) => cleanEnumerateBody(nodes, "subsubpart") + }, + questions: { + signature: "o", + processContent: (nodes) => cleanEnumerateBody(nodes, "question") + } +}; +var macros3 = { + geometry: { + signature: "m", + renderInfo: { breakAround: true, pgfkeysArgs: true } + } +}; +var environments3 = {}; +var macros4 = { + hypersetup: { + signature: "m", + renderInfo: { breakAround: true, pgfkeysArgs: true } + }, + href: { signature: "o m m" }, + url: { signature: "m" }, + nolinkurl: { signature: "m" }, + hyperbaseurl: { signature: "m" }, + hyperimage: { signature: "m m" }, + hyperdef: { signature: "m m m" }, + hyperref: { signature: "o m" }, + hyperlink: { signature: "m m" }, + hypertarget: { signature: "m m" }, + autoref: { signature: "s m" }, + pageref: { signature: "s m" }, + autopageref: { signature: "s m" }, + pdfstringdef: { signature: "m m" }, + pdfbookmark: { signature: "o m m" }, + currentpdfbookmark: { signature: "m m" }, + subpdfbookmark: { signature: "m m" }, + belowpdfbookmark: { signature: "m m" }, + texorpdfstring: { signature: "m m" }, + thispdfpagelabel: { signature: "m" }, + hypercalcbp: { signature: "m" } +}; +var environments4 = {}; +var macros5 = { + // Special + "\\": { signature: "!s !o" }, + _: { signature: "m", escapeToken: "" }, + "^": { signature: "m", escapeToken: "" }, + // \newcommand arg signature from https://www.texdev.net/2020/08/19/the-good-the-bad-and-the-ugly-creating-document-commands + // List can be found in latex2e.pdf "An unofficial reference manual" + newcommand: { + signature: "s +m o +o +m", + renderInfo: { + breakAround: true, + namedArguments: ["starred", "name", "numArgs", "default", "body"] + } + }, + renewcommand: { + signature: "s +m o +o +m", + renderInfo: { + breakAround: true, + namedArguments: ["starred", "name", "numArgs", "default", "body"] + } + }, + providecommand: { + signature: "s +m o +o +m", + renderInfo: { breakAround: true } + }, + // Counters + newcounter: { + signature: "m o", + renderInfo: { breakAround: true } + }, + usecounter: { + signature: "m" + }, + setcounter: { + signature: "m m", + renderInfo: { breakAround: true } + }, + addtocounter: { + signature: "m m", + renderInfo: { breakAround: true } + }, + stepcounter: { + signature: "m", + renderInfo: { breakAround: true } + }, + refstepcounter: { + signature: "m", + renderInfo: { breakAround: true } + }, + // Lengths + newlength: { + signature: "m", + renderInfo: { breakAround: true } + }, + addtolength: { + signature: "m m", + renderInfo: { breakAround: true } + }, + settodepth: { + signature: "m m", + renderInfo: { breakAround: true } + }, + settoheight: { + signature: "m m", + renderInfo: { breakAround: true } + }, + settowidth: { + signature: "m m", + renderInfo: { breakAround: true } + }, + // Spaces + stretch: { signature: "m" }, + hspace: { signature: "s m" }, + vspace: { signature: "s m", renderInfo: { breakAround: true } }, + vfill: { renderInfo: { breakAround: true } }, + indent: { renderInfo: { breakAround: true } }, + phantom: { signature: "m" }, + vphantom: { signature: "m" }, + hphantom: { signature: "m" }, + noindent: { renderInfo: { breakAround: true } }, + smallskip: { renderInfo: { breakAround: true } }, + medskip: { renderInfo: { breakAround: true } }, + bigskip: { renderInfo: { breakAround: true } }, + smallbreak: { renderInfo: { breakAround: true } }, + medbreak: { renderInfo: { breakAround: true } }, + bigbreak: { renderInfo: { breakAround: true } }, + newline: { renderInfo: { breakAround: true } }, + linebreak: { signature: "o", renderInfo: { breakAround: true } }, + nolinebreak: { signature: "o", renderInfo: { breakAround: true } }, + clearpage: { renderInfo: { breakAround: true } }, + cleardoublepage: { renderInfo: { breakAround: true } }, + newpage: { renderInfo: { breakAround: true } }, + enlargethispage: { signature: "s", renderInfo: { breakAround: true } }, + pagebreak: { signature: "o", renderInfo: { breakAround: true } }, + nopagebreak: { signature: "o", renderInfo: { breakAround: true } }, + // Boxes + newsavebox: { + signature: "m", + renderInfo: { breakAround: true } + }, + sbox: { + signature: "m m", + renderInfo: { breakAround: true } + }, + savebox: { + signature: "m o o m", + renderInfo: { breakAround: true } + }, + mbox: { signature: "m" }, + makebox: { signature: "d() o o m", renderInfo: { breakAround: true } }, + fbox: { signature: "m" }, + framebox: { signature: "o o m", renderInfo: { breakAround: true } }, + frame: { signature: "m", renderInfo: { breakAround: true } }, + parbox: { signature: "o o o m m", renderInfo: { breakAround: true } }, + raisebox: { signature: "m o o m" }, + marginpar: { signature: "o m", renderInfo: { breakAround: true } }, + colorbox: { signature: "o m m", renderInfo: { breakAround: true } }, + fcolorbox: { signature: "o m m", renderInfo: { breakAround: true } }, + rotatebox: { signature: "o m m" }, + scalebox: { signature: "m o m" }, + reflectbox: { signature: "m" }, + resizebox: { signature: "s m m m" }, + // Define environments + newenvironment: { + signature: "s m o o m m", + renderInfo: { breakAround: true } + }, + renewenvironment: { + signature: "s m o o m m", + renderInfo: { breakAround: true } + }, + newtheorem: { + signature: "s m o m o", + renderInfo: { breakAround: true } + }, + newfont: { + signature: "m m", + renderInfo: { breakAround: true } + }, + // Counters + alph: { signature: "m" }, + Alph: { signature: "m" }, + arabic: { signature: "m" }, + roman: { signature: "m" }, + Roman: { signature: "m" }, + fnsymbol: { signature: "m" }, + // Other + documentclass: { + signature: "o m", + renderInfo: { breakAround: true, pgfkeysArgs: true } + }, + usepackage: { + signature: "o m", + renderInfo: { breakAround: true, pgfkeysArgs: true } + }, + item: { + signature: "o", + renderInfo: { hangingIndent: true, namedArguments: ["label"] } + }, + value: { signature: "m" }, + centering: { renderInfo: { breakAround: true } }, + input: { signature: "m", renderInfo: { breakAround: true } }, + include: { signature: "m", renderInfo: { breakAround: true } }, + includeonly: { + signature: "m", + renderInfo: { breakAround: true, pgfkeysArgs: true } + }, + discretionary: { signature: "m m m" }, + hyphenation: { signature: "m m m" }, + footnote: { signature: "o m", renderInfo: { inParMode: true } }, + footnotemark: { signature: "o" }, + footnotetext: { signature: "o m", renderInfo: { inParMode: true } }, + caption: { + signature: "o m", + renderInfo: { inParMode: true, breakAround: true } + }, + // Math Commands + sqrt: { signature: "o m", renderInfo: { inMathMode: true } }, + frac: { signature: "m m", renderInfo: { inMathMode: true } }, + stackrel: { signature: "m m" }, + ensuremath: { signature: "m", renderInfo: { inMathMode: true } }, + // Layout commands + abstract: { + signature: "m", + renderInfo: { breakAround: true, inParMode: true } + }, + maketitle: { renderInfo: { breakAround: true } }, + doublespacing: { renderInfo: { breakAround: true } }, + singlespacing: { renderInfo: { breakAround: true } }, + author: { + signature: "m", + renderInfo: { breakAround: true, inParMode: true } + }, + date: { signature: "o m", renderInfo: { breakAround: true } }, + thanks: { + signature: "m", + renderInfo: { breakAround: true, inParMode: true } + }, + // amsart document class adds an optional argument + title: { + signature: "o m", + renderInfo: { breakAround: true, inParMode: true } + }, + pagenumbering: { signature: "m", renderInfo: { breakAround: true } }, + pagestyle: { signature: "m", renderInfo: { breakAround: true } }, + thispagestyle: { signature: "m", renderInfo: { breakAround: true } }, + // Colors + definecolor: { signature: "m m m", renderInfo: { breakAround: true } }, + pagecolor: { signature: "o m", renderInfo: { breakAround: true } }, + nopagecolor: { renderInfo: { breakAround: true } }, + multicolumn: { signature: "m m m" }, + // Graphics + includegraphics: { + signature: "s o o m", + renderInfo: { breakAround: true, pgfkeysArgs: true } + }, + rule: { signature: "o m m" }, + // Sectioning + part: { + signature: "s o m", + renderInfo: { + breakAround: true, + inParMode: true, + namedArguments: ["starred", "tocTitle", "title"] + } + }, + chapter: { + signature: "s o m", + renderInfo: { + breakAround: true, + inParMode: true, + namedArguments: ["starred", "tocTitle", "title"] + } + }, + section: { + signature: "s o m", + renderInfo: { + breakAround: true, + inParMode: true, + namedArguments: ["starred", "tocTitle", "title"] + } + }, + subsection: { + signature: "s o m", + renderInfo: { + breakAround: true, + inParMode: true, + namedArguments: ["starred", "tocTitle", "title"] + } + }, + subsubsection: { + signature: "s o m", + renderInfo: { + breakAround: true, + inParMode: true, + namedArguments: ["starred", "tocTitle", "title"] + } + }, + paragraph: { + signature: "s o m", + renderInfo: { + breakAround: true, + inParMode: true, + namedArguments: ["starred", "tocTitle", "title"] + } + }, + subparagraph: { + signature: "s o m", + renderInfo: { + breakAround: true, + inParMode: true, + namedArguments: ["starred", "tocTitle", "title"] + } + }, + appendix: { renderInfo: { breakAround: true, inParMode: true } }, + frontmatter: { renderInfo: { breakAround: true, inParMode: true } }, + mainmatter: { renderInfo: { breakAround: true, inParMode: true } }, + backmatter: { renderInfo: { breakAround: true, inParMode: true } }, + // Citing and references + bibitem: { signature: "o m", renderInfo: { hangingIndent: true } }, + cite: { signature: "o m" }, + // Fonts + textrm: { signature: "m", renderInfo: { inParMode: true } }, + textit: { signature: "m", renderInfo: { inParMode: true } }, + textmd: { signature: "m", renderInfo: { inParMode: true } }, + textbf: { signature: "m", renderInfo: { inParMode: true } }, + textup: { signature: "m", renderInfo: { inParMode: true } }, + textsl: { signature: "m", renderInfo: { inParMode: true } }, + textsf: { signature: "m", renderInfo: { inParMode: true } }, + textsc: { signature: "m", renderInfo: { inParMode: true } }, + texttt: { signature: "m", renderInfo: { inParMode: true } }, + emph: { signature: "m", renderInfo: { inParMode: true } }, + textnormal: { signature: "m", renderInfo: { inParMode: true } }, + uppercase: { signature: "m", renderInfo: { inParMode: true } }, + mathbf: { signature: "m" }, + mathsf: { signature: "m" }, + mathtt: { signature: "m" }, + mathit: { signature: "m" }, + mathnormal: { signature: "m" }, + mathcal: { signature: "m" }, + mathrm: { signature: "m" }, + // Other + setlength: { signature: "m m", renderInfo: { breakAround: true } }, + ref: { signature: "s m" }, + label: { signature: "o m" }, + // cleveref changes \label to have this signature + printbibliography: { renderInfo: { breakAround: true } }, + addtocontents: { signature: "m m", renderInfo: { breakAround: true } }, + addcontentsline: { signature: "m m m", renderInfo: { breakAround: true } }, + contentsline: { signature: "m m m", renderInfo: { breakAround: true } }, + bibliography: { signature: "m", renderInfo: { breakAround: true } }, + bibliographystyle: { signature: "m", renderInfo: { breakAround: true } } +}; +var environments5 = { + document: { + processContent: (nodes) => { + trim$1(nodes); + return nodes; + } + }, + array: { signature: "o m", renderInfo: { alignContent: true } }, + description: { signature: "o", processContent: cleanEnumerateBody }, + enumerate: { + signature: "o", + processContent: cleanEnumerateBody, + renderInfo: { pgfkeysArgs: true } + }, + itemize: { signature: "o", processContent: cleanEnumerateBody }, + trivlist: { signature: "o", processContent: cleanEnumerateBody }, + list: { signature: "m m", processContent: cleanEnumerateBody }, + figure: { signature: "o" }, + "figure*": { signature: "o" }, + filecontents: { signature: "o m" }, + "filecontents*": { signature: "o m" }, + minipage: { signature: "o o o m" }, + picture: { signature: "r() d()" }, + tabbing: { renderInfo: { alignContent: true } }, + table: { signature: "o" }, + tabular: { signature: "o m", renderInfo: { alignContent: true } }, + "tabular*": { signature: "m o m", renderInfo: { alignContent: true } }, + thebibliography: { + signature: "m", + processContent: (nodes) => cleanEnumerateBody(nodes, "bibitem") + }, + // Math + math: { renderInfo: { inMathMode: true } } +}; +var argSpecM = parse$2("m")[0]; +var argSpecO = parse$2("o")[0]; +var argSpecRDelim = {}; +var argumentParser = (nodes, startPos) => { + const { argument: optionalArg, nodesRemoved: optionalArgNodesRemoved } = gobbleSingleArgument(nodes, argSpecO, startPos); + let codeArg = null; + let codeArgNodesRemoved = 0; + const nextNode = nodes[startPos]; + if (match.group(nextNode)) { + const mandatoryArg = gobbleSingleArgument(nodes, argSpecM, startPos); + codeArg = mandatoryArg.argument; + codeArgNodesRemoved = mandatoryArg.nodesRemoved; + } else if (match.string(nextNode) && nextNode.content.length === 1) { + const delim = nextNode.content; + argSpecRDelim[delim] = argSpecRDelim[delim] || parse$2(`r${delim}${delim}`)[0]; + const delimArg = gobbleSingleArgument( + nodes, + argSpecRDelim[delim], + startPos + ); + codeArg = delimArg.argument; + codeArgNodesRemoved = delimArg.nodesRemoved; + } + return { + args: [optionalArg || arg(null), codeArg || arg(null)], + nodesRemoved: optionalArgNodesRemoved + codeArgNodesRemoved + }; +}; +var macros6 = { + lstset: { signature: "m" }, + lstinline: { argumentParser }, + lstinputlisting: { signature: "o m" }, + lstdefinestyle: { signature: "m m" }, + lstnewenvironment: { signature: "m o o m m" }, + lstMakeShortInline: { signature: "o m" }, + lstDeleteShortInline: { signature: "m" }, + lstdefineformat: { signature: "m m" }, + lstdefinelanguage: { signature: "o m o m o" }, + lstalias: { signature: "o m o m" }, + lstloadlanguages: { signature: "m" } +}; +var environments6 = {}; +var macros7 = { + see: { signature: "m m" }, + seealso: { signature: "m m" }, + seename: { signature: "m" }, + alsoname: { signature: "m" }, + index: { signature: "m" } +}; +var environments7 = {}; +var macros8 = { + mathtoolsset: { + signature: "m", + renderInfo: { breakAround: true, pgfkeysArgs: true } + }, + mathllap: { + signature: "o m" + }, + mathrlap: { + signature: "o m" + }, + mathclap: { + signature: "o m" + }, + clap: { + signature: "m" + }, + mathmbox: { + signature: "m" + }, + mathmakebox: { + signature: "o o m" + }, + cramped: { + signature: "o m" + }, + crampedllap: { + signature: "o m" + }, + crampedrlap: { + signature: "o m" + }, + crampedclap: { + signature: "o m" + }, + crampedsubstack: { + signature: "o m" + }, + smashoperator: { + signature: "o m" + }, + newtagform: { + signature: "m o m m" + }, + renewtagform: { + signature: "m o m m" + }, + usetagform: { + signature: "m" + }, + xleftrightarrow: { signature: "o m" }, + xLeftarrow: { signature: "o m" }, + xhookleftarrow: { signature: "o m" }, + xmapsto: { signature: "o m" }, + xRightarrow: { signature: "o m" }, + xLeftrightarrow: { signature: "o m" }, + xhookrightarrow: { signature: "o m" }, + underbracket: { signature: "o o m" }, + overbracket: { signature: "o o m" }, + underbrace: { signature: "m" }, + overbrace: { signature: "m" }, + shoveleft: { signature: "o m" }, + shoveright: { signature: "o m" }, + ArrowBetweenLines: { signature: "s o" }, + vdotswithin: { signature: "m" }, + shortdotswithin: { signature: "s m" }, + DeclarePairedDelimiter: { + signature: "m m m", + renderInfo: { breakAround: true } + }, + DeclarePairedDelimiterX: { + signature: "m o m m m", + renderInfo: { breakAround: true } + }, + DeclarePairedDelimiterXPP: { + signature: "m o m m m m m", + renderInfo: { breakAround: true } + }, + prescript: { signature: "m m m" }, + DeclareMathSizes: { signature: "m m m m" }, + newgathered: { signature: "m m m m" }, + renewgathered: { signature: "m m m m" }, + splitfrac: { signature: "m m" }, + splitdfrac: { signature: "m m" }, + xmathstrut: { signature: "o m" }, + // amsthm + newtheorem: { signature: "s m o m o", renderInfo: { breakAround: true } }, + theoremstyle: { signature: "m", renderInfo: { breakAround: true } }, + newtheoremstyle: { + signature: "m m m m m m m m m", + renderInfo: { breakAround: true } + }, + // amsmath + text: { signature: "m", renderInfo: { inMathMode: false } }, + // amsfonts + mathbb: { signature: "m" }, + mathscr: { signature: "m" }, + mathfrak: { signature: "m" }, + frak: { signature: "m" }, + Bdd: { signature: "m" }, + bold: { signature: "m" }, + // amsopn + operatorname: { signature: "s m" }, + DeclareMathOperator: { + signature: "s m m", + renderInfo: { breakAround: true } + } +}; +var environments8 = { + crampedsubarray: { + signature: "m", + renderInfo: { alignContent: true, inMathMode: true } + }, + matrix: { renderInfo: { alignContent: true, inMathMode: true } }, + bmatrix: { renderInfo: { alignContent: true, inMathMode: true } }, + pmatrix: { renderInfo: { alignContent: true, inMathMode: true } }, + vmatrix: { renderInfo: { alignContent: true, inMathMode: true } }, + Bmatrix: { renderInfo: { alignContent: true, inMathMode: true } }, + Vmatrix: { renderInfo: { alignContent: true, inMathMode: true } }, + smallmatrix: { renderInfo: { alignContent: true, inMathMode: true } }, + psmallmatrix: { renderInfo: { alignContent: true, inMathMode: true } }, + vsmallmatrix: { renderInfo: { alignContent: true, inMathMode: true } }, + bsmallmatrix: { renderInfo: { alignContent: true, inMathMode: true } }, + Bsmallmatrix: { renderInfo: { alignContent: true, inMathMode: true } }, + Vsmallmatrix: { renderInfo: { alignContent: true, inMathMode: true } }, + "matrix*": { + signature: "o", + renderInfo: { alignContent: true, inMathMode: true } + }, + "bmatrix*": { + signature: "o", + renderInfo: { alignContent: true, inMathMode: true } + }, + "pmatrix*": { + signature: "o", + renderInfo: { alignContent: true, inMathMode: true } + }, + "vmatrix*": { + signature: "o", + renderInfo: { alignContent: true, inMathMode: true } + }, + "Bmatrix*": { + signature: "o", + renderInfo: { alignContent: true, inMathMode: true } + }, + "Vmatrix*": { + signature: "o", + renderInfo: { alignContent: true, inMathMode: true } + }, + "smallmatrix*": { + signature: "o", + renderInfo: { alignContent: true, inMathMode: true } + }, + "psmallmatrix*": { + signature: "o", + renderInfo: { alignContent: true, inMathMode: true } + }, + "bsmallmatrix*": { + signature: "o", + renderInfo: { alignContent: true, inMathMode: true } + }, + "vsmallmatrix*": { + signature: "o", + renderInfo: { alignContent: true, inMathMode: true } + }, + "Bsmallmatrix*": { + signature: "o", + renderInfo: { alignContent: true, inMathMode: true } + }, + "Vsmallmatrix*": { + signature: "o", + renderInfo: { alignContent: true, inMathMode: true } + }, + multilined: { signature: "o o", renderInfo: { inMathMode: true } }, + cases: { renderInfo: { alignContent: true, inMathMode: true } }, + "cases*": { renderInfo: { alignContent: true, inMathMode: true } }, + dcases: { renderInfo: { alignContent: true, inMathMode: true } }, + "dcases*": { renderInfo: { alignContent: true, inMathMode: true } }, + rcases: { renderInfo: { alignContent: true, inMathMode: true } }, + "rcases*": { renderInfo: { alignContent: true, inMathMode: true } }, + drcases: { renderInfo: { alignContent: true, inMathMode: true } }, + "drcases*": { renderInfo: { alignContent: true, inMathMode: true } }, + spreadlines: { signature: "m", renderInfo: { inMathMode: true } }, + lgathered: { signature: "o", renderInfo: { inMathMode: true } }, + rgathered: { signature: "o", renderInfo: { inMathMode: true } }, + // amsmath + "align*": { renderInfo: { inMathMode: true, alignContent: true } }, + align: { renderInfo: { inMathMode: true, alignContent: true } }, + aligned: { renderInfo: { inMathMode: true, alignContent: true } }, + "alignat*": { renderInfo: { inMathMode: true, alignContent: true } }, + alignat: { renderInfo: { inMathMode: true, alignContent: true } }, + "equation*": { renderInfo: { inMathMode: true } }, + equation: { renderInfo: { inMathMode: true } }, + "gather*": { renderInfo: { inMathMode: true } }, + gather: { renderInfo: { inMathMode: true } }, + "multline*": { renderInfo: { inMathMode: true } }, + multline: { renderInfo: { inMathMode: true } }, + "flalign*": { renderInfo: { inMathMode: true, alignContent: true } }, + flalign: { renderInfo: { inMathMode: true, alignContent: true } }, + split: { renderInfo: { inMathMode: true } }, + // Math environments + displaymath: { renderInfo: { inMathMode: true } }, + // Typical amsthm environments + theorem: { signature: "o" }, + lemma: { signature: "o" }, + definition: { signature: "o" }, + proposition: { signature: "o" }, + corollary: { signature: "o" }, + remark: { signature: "!o" }, + example: { signature: "!o" }, + proof: { signature: "o" } +}; +var argSpecM2 = parse$2("m")[0]; +var argSpecO2 = parse$2("o")[0]; +var argSpecRDelim2 = {}; +var argumentParser2 = (nodes, startPos) => { + const { argument: optionalArg, nodesRemoved: optionalArgNodesRemoved } = gobbleSingleArgument(nodes, argSpecO2, startPos); + const { argument: languageArg, nodesRemoved: languageArgNodesRemoved } = gobbleSingleArgument(nodes, argSpecM2, startPos); + let codeArg = null; + let codeArgNodesRemoved = 0; + const nextNode = nodes[startPos]; + if (match.group(nextNode)) { + const mandatoryArg = gobbleSingleArgument(nodes, argSpecM2, startPos); + codeArg = mandatoryArg.argument; + codeArgNodesRemoved = mandatoryArg.nodesRemoved; + } else if (match.string(nextNode) && nextNode.content.length === 1) { + const delim = nextNode.content; + argSpecRDelim2[delim] = argSpecRDelim2[delim] || parse$2(`r${delim}${delim}`)[0]; + const delimArg = gobbleSingleArgument( + nodes, + argSpecRDelim2[delim], + startPos + ); + codeArg = delimArg.argument; + codeArgNodesRemoved = delimArg.nodesRemoved; + } + return { + args: [ + optionalArg || arg(null), + languageArg || arg(null), + codeArg || arg(null) + ], + nodesRemoved: optionalArgNodesRemoved + languageArgNodesRemoved + codeArgNodesRemoved + }; +}; +var macros9 = { + mint: { argumentParser: argumentParser2 }, + mintinline: { argumentParser: argumentParser2 }, + inputminted: { argumentParser: argumentParser2 }, + usemintedstyle: { signature: "m" }, + setminted: { signature: "o m" }, + setmintedinline: { signature: "o m" }, + newmint: { signature: "o m m" }, + newminted: { signature: "o m m" }, + newmintinline: { signature: "o m m" }, + newmintedfile: { signature: "o m m" } +}; +var environments9 = {}; +var macros10 = { + NiceMatrixOptions: { + signature: "m", + renderInfo: { pgfkeysArgs: true, breakAround: true } + } +}; +var environments10 = { + NiceTabular: { + signature: "o m !o", + renderInfo: { pgfkeysArgs: true, alignContent: true } + }, + NiceMatrixBlock: { + signature: "!o", + renderInfo: { pgfkeysArgs: true, alignContent: true } + }, + NiceArrayWithDelims: { + signature: "m m o m !o", + renderInfo: { pgfkeysArgs: true, alignContent: true } + }, + NiceArray: { + signature: "o m !o", + renderInfo: { pgfkeysArgs: true, alignContent: true } + }, + pNiceArray: { + signature: "o m !o", + renderInfo: { pgfkeysArgs: true, alignContent: true } + }, + bNiceArray: { + signature: "o m !o", + renderInfo: { pgfkeysArgs: true, alignContent: true } + }, + BNiceArray: { + signature: "o m !o", + renderInfo: { pgfkeysArgs: true, alignContent: true } + }, + vNiceArray: { + signature: "o m !o", + renderInfo: { pgfkeysArgs: true, alignContent: true } + }, + VNiceArray: { + signature: "o m !o", + renderInfo: { pgfkeysArgs: true, alignContent: true } + }, + NiceMatrix: { + signature: "!o", + renderInfo: { pgfkeysArgs: true, alignContent: true } + }, + pNiceMatrix: { + signature: "!o", + renderInfo: { pgfkeysArgs: true, alignContent: true } + }, + bNiceMatrix: { + signature: "!o", + renderInfo: { pgfkeysArgs: true, alignContent: true } + }, + BNiceMatrix: { + signature: "!o", + renderInfo: { pgfkeysArgs: true, alignContent: true } + }, + vNiceMatrix: { + signature: "!o", + renderInfo: { pgfkeysArgs: true, alignContent: true } + }, + VNiceMatrix: { + signature: "!o", + renderInfo: { pgfkeysArgs: true, alignContent: true } + } +}; +var macros11 = { + systeme: { + signature: "s o o m", + renderInfo: { inMathMode: true } + }, + sysdelim: { + signature: "m m" + }, + syseqsep: { signature: "m" }, + sysalign: { signature: "m" }, + syssignspace: { signature: "m" }, + syseqspace: { signature: "m" }, + syslineskipcoeff: { signature: "m" }, + syseqivsign: { signature: "m" }, + sysaddeqsign: { signature: "m" }, + sysremoveeqsign: { signature: "m" }, + sysextracolonsign: { signature: "m" }, + syscodeextracol: { signature: "m" }, + sysautonum: { signature: "m" }, + syssubstitute: { signature: "m" } +}; +var environments11 = {}; +(function() { + if (typeof globalThis === "object") + return; + Object.defineProperty(Object.prototype, "__magic__", { + get: function() { + return this; + }, + configurable: true + // This makes it possible to `delete` the getter later. + }); + __magic__.globalThis = __magic__; + delete Object.prototype.__magic__; +})(); +var OPTIONAL_ARGUMENT_ARG_SPEC = parse$2("o")[0]; +function blankArg() { + return arg([], { openMark: "", closeMark: "" }); +} +var tikzCommandArgumentParser = (nodes, startPos) => { + const origStartPos = startPos; + let pos = startPos; + let nodesRemoved = 0; + const cursorPosAfterAnimations = eatAllAnimationSpecs(nodes, pos); + let animationArg = blankArg(); + if (cursorPosAfterAnimations !== pos) { + const argContent = nodes.splice(pos, cursorPosAfterAnimations - pos); + trim$1(argContent); + animationArg = arg(argContent, { + openMark: " ", + closeMark: " " + }); + } + nodesRemoved += cursorPosAfterAnimations - pos; + const { + argument: _optionalArgument, + nodesRemoved: optionalArgumentNodesRemoved + } = gobbleSingleArgument(nodes, OPTIONAL_ARGUMENT_ARG_SPEC, pos); + nodesRemoved += optionalArgumentNodesRemoved; + const optionalArg = _optionalArgument || blankArg(); + while (match.whitespace(nodes[pos])) { + pos++; + } + const firstNode = nodes[pos]; + if (!firstNode) { + return { + args: [animationArg, optionalArg, blankArg()], + nodesRemoved: 0 + }; + } + if (match.group(firstNode)) { + const args = [animationArg, optionalArg, arg(firstNode.content)]; + nodes.splice(origStartPos, pos - origStartPos + 1); + return { args, nodesRemoved: pos - origStartPos + 1 + nodesRemoved }; + } + const semicolonPosition = scan(nodes, ";", { startIndex: pos }); + if (semicolonPosition != null) { + const argNodes = nodes.splice( + origStartPos, + semicolonPosition - origStartPos + 1 + ); + trim$1(argNodes); + const args = [animationArg, optionalArg, arg(argNodes)]; + return { + args, + nodesRemoved: origStartPos - semicolonPosition + 1 + nodesRemoved + }; + } + return { + args: [animationArg, optionalArg, blankArg()], + nodesRemoved: 0 + }; +}; +function eatAllAnimationSpecs(nodes, startPos) { + const colonPos = scan(nodes, ":", { + startIndex: startPos, + allowSubstringMatches: true, + onlySkipWhitespaceAndComments: true + }); + if (!colonPos) { + return startPos; + } + let lastMatchPos = startPos; + let i = colonPos + 1; + for (; i < nodes.length; i++) { + const node = nodes[i]; + if (match.string(node, "[")) { + break; + } + if (match.string(node, "=")) { + i++; + while (match.whitespace(nodes[i]) || match.comment(nodes[i])) { + i++; + } + if (!match.group(nodes[i])) { + break; + } + lastMatchPos = i + 1; + const colonPos2 = scan(nodes, ":", { + startIndex: lastMatchPos, + allowSubstringMatches: true, + onlySkipWhitespaceAndComments: true + }); + if (colonPos2 == null) { + break; + } + i = colonPos2 + 1; + } + } + return lastMatchPos; +} +var macros12 = { + pgfkeys: { + signature: "m", + renderInfo: { breakAround: true, pgfkeysArgs: true } + }, + tikzoption: { + signature: "m", + renderInfo: { breakAround: true, pgfkeysArgs: true } + }, + tikzstyle: { + signature: "m", + renderInfo: { breakAround: true, pgfkeysArgs: true } + }, + usetikzlibrary: { + signature: "m", + renderInfo: { breakAround: true, pgfkeysArgs: true } + }, + usepgfmodule: { signature: "m", renderInfo: { pgfkeysArgs: true } }, + usepgflibrary: { signature: "m", renderInfo: { pgfkeysArgs: true } }, + pgfplotsset: { + signature: "m", + renderInfo: { breakAround: true, pgfkeysArgs: true } + }, + pgfplotstabletypeset: { + signature: "o m", + renderInfo: { breakAround: true, pgfkeysArgs: true } + }, + tikz: { + signature: "o o m", + argumentParser: tikzCommandArgumentParser, + renderInfo: { namedArguments: ["animation", "options", "command"] } + } +}; +var environments12 = { + tikzpicture: { + signature: "o", + renderInfo: { pgfkeysArgs: true, tikzEnvironment: true }, + processContent: processTikzEnvironmentContent + }, + axis: { + signature: "o", + renderInfo: { pgfkeysArgs: true, tikzEnvironment: true }, + processContent: processTikzEnvironmentContent + }, + scope: { + signature: "o", + renderInfo: { pgfkeysArgs: true, tikzEnvironment: true }, + processContent: processTikzEnvironmentContent + }, + pgfonlayer: { + signature: "m", + renderInfo: { tikzEnvironment: true }, + processContent: processTikzEnvironmentContent + }, + pgflowlevelscope: { + signature: "m", + renderInfo: { tikzEnvironment: true }, + processContent: processTikzEnvironmentContent + }, + pgfviewboxscope: { + signature: "m m m m m", + renderInfo: { tikzEnvironment: true }, + processContent: processTikzEnvironmentContent + }, + pgftransparencygroup: { + signature: "o", + renderInfo: { pgfkeysArgs: true, tikzEnvironment: true }, + processContent: processTikzEnvironmentContent + }, + behindforegroundpath: { + signature: "m", + processContent: processTikzEnvironmentContent + }, + pgfmetadecoration: { + signature: "m", + processContent: processTikzEnvironmentContent + }, + colormixin: { signature: "m", renderInfo: { pgfkeysArgs: true } } +}; +function processTikzEnvironmentContent(nodes) { + attachMacroArgsInArray(nodes, conditionalMacros); + return nodes; +} +var conditionalMacros = { + pgfextra: { signature: "m" }, + beginpgfgraphicnamed: { signature: "m" }, + pgfrealjobname: { signature: "m" }, + pgfplotstreampoint: { signature: "m" }, + pgfplotstreampointoutlier: { signature: "m" }, + pgfplotstreamspecial: { signature: "m" }, + pgfplotxyfile: { signature: "m" }, + pgfplotxyzfile: { signature: "m" }, + pgfplotfunction: { signature: "mmm" }, + pgfplotgnuplot: { signature: "o m" }, + pgfplothandlerrecord: { signature: "m" }, + pgfdeclareplothandler: { signature: "m m m" }, + pgfdeclarelayer: { signature: "m" }, + pgfsetlayers: { signature: "m", renderInfo: { pgfkeysArgs: true } }, + pgfonlayer: { signature: "m" }, + startpgfonlayer: { signature: "m" }, + pgfdeclarehorizontalshading: { signature: "o m m m " }, + pgfdeclareradialshading: { signature: "o m m m" }, + pgfdeclarefunctionalshading: { signature: "o m m m m m" }, + pgfshadecolortorgb: { signature: "m m" }, + pgfshadecolortocmyk: { signature: "m m" }, + pgfshadecolortogray: { signature: "m m" }, + pgfuseshading: { signature: "m" }, + pgfshadepath: { signature: "m m" }, + pgfsetadditionalshadetransform: { signature: "m" }, + pgfsetstrokeopacity: { signature: "m" }, + pgfsetfillopacity: { signature: "m" }, + pgfsetblendmode: { signature: "m" }, + pgfdeclarefading: { signature: "m m" }, + pgfsetfading: { signature: "m m" }, + pgfsetfadingforcurrentpath: { signature: "m m" }, + pgfsetfadingforcurrentpathstroked: { signature: "m m" }, + pgfanimateattribute: { signature: "m m" }, + pgfsnapshot: { signature: "m" }, + pgfqpoint: { signature: "m m" }, + pgfqpointxy: { signature: "m m" }, + pgfqpointxyz: { signature: "m m m" }, + pgfqpointscale: { signature: "m m" }, + pgfpathqmoveto: { signature: "m m" }, + pgfpathqlineto: { signature: "m m" }, + pgfpathqcurveto: { signature: "m m m m m m" }, + pgfpathqcircle: { signature: "m" }, + pgfqbox: { signature: "m" }, + pgfqboxsynced: { signature: "m" }, + pgfaliasimage: { signature: "m m" }, + pgfuseimage: { signature: "m" }, + pgfimage: { signature: "o m", renderInfo: { pgfkeysArgs: true } }, + pgfdeclaremask: { signature: "o m m", renderInfo: { pgfkeysArgs: true } }, + pgfdeclarepatternformonly: { signature: "o m m m m m" }, + pgfdeclarepatterninherentlycolored: { signature: "o m m m m m" }, + pgfsetfillpattern: { signature: "m m" }, + // Coordinate canvas and nonlinear transformations + pgftransformshift: { signature: "m" }, + pgftransformxshift: { signature: "m" }, + pgftransformyshift: { signature: "m" }, + pgftransformscale: { signature: "m" }, + pgftransformxscale: { signature: "m" }, + pgftransformyscale: { signature: "m" }, + pgftransformxslant: { signature: "m" }, + pgftransformyslant: { signature: "m" }, + pgftransformrotate: { signature: "m" }, + pgftransformtriangle: { signature: "m m m" }, + pgftransformcm: { signature: "m m m m m" }, + pgftransformarrow: { signature: "m m" }, + pgftransformlineattime: { signature: "m m m" }, + pgftransformcurveattime: { signature: "m m m m m" }, + pgftransformarcaxesattime: { signature: "m m m m m m" }, + pgfgettransform: { signature: "m" }, + pgfsettransform: { signature: "m" }, + pgfgettransformentries: { signature: "m m m m m m" }, + pgfsettransformentries: { signature: "m m m m m m" }, + pgfpointtransformed: { signature: "m" }, + pgflowlevel: { signature: "m" }, + pgflowlevelobj: { signature: "m m" }, + pgflowlevelscope: { signature: "m" }, + startpgflowlevelscope: { signature: "m" }, + pgfviewboxscope: { signature: "m m m m m" }, + startpgfviewboxscope: { signature: "m m m m m" }, + pgftransformnonlinear: { signature: "m" }, + pgfpointtransformednonlinear: { signature: "m" }, + pgfsetcurvilinearbeziercurve: { signature: "m m m m" }, + pgfcurvilineardistancetotime: { signature: "m" }, + pgfpointcurvilinearbezierorthogonal: { signature: "m m" }, + pgfpointcurvilinearbezierpolar: { signature: "m m" }, + // Matrices + pgfmatrix: { signature: "m m m m m m m" }, + pgfsetmatrixcolumnsep: { signature: "m" }, + pgfmatrixnextcell: { signature: "o" }, + pgfsetmatrixrowsep: { signature: "m" }, + pgfmatrixendrow: { signature: "o" }, + // Nodes and shapes + pgfnode: { signature: "m m m m m" }, + pgfmultipartnode: { signature: "m m m m" }, + pgfcoordinate: { signature: "m m" }, + pgfnodealias: { signature: "m m" }, + pgfnoderename: { signature: "m m" }, + pgfpositionnodelater: { signature: "m" }, + pgfpositionnodenow: { signature: "m" }, + pgfnodepostsetupcode: { signature: "m m" }, + pgfpointanchor: { signature: "m m" }, + pgfpointshapeborder: { signature: "m m" }, + pgfdeclareshape: { signature: "m m" }, + saveddimen: { signature: "m m" }, + savedmacro: { signature: " m" }, + anchor: { signature: "m m" }, + deferredanchor: { signature: "m m" }, + anchorborder: { signature: "m" }, + backgroundpath: { signature: "m" }, + foregroundpath: { signature: "m" }, + behindbackgroundpath: { signature: "m" }, + beforebackgroundpath: { signature: "m" }, + beforeforegroundpath: { signature: "m" }, + behindforegroundpath: { signature: "m" }, + // Arrows + pgfdeclarearrow: { signature: "m" }, + pgfarrowssettipend: { signature: "m" }, + pgfarrowssetbackend: { signature: "m" }, + pgfarrowssetlineend: { signature: "m" }, + pgfarrowssetvisualbackend: { signature: "m" }, + pgfarrowssetvisualtipend: { signature: "m" }, + pgfarrowshullpoint: { signature: "m m" }, + pgfarrowsupperhullpoint: { signature: "m m" }, + pgfarrowssave: { signature: "m" }, + pgfarrowssavethe: { signature: "m" }, + pgfarrowsaddtooptions: { signature: "m" }, + pgfarrowsaddtolateoptions: { signature: "m" }, + pgfarrowsaddtolengthscalelist: { signature: "m" }, + pgfarrowsaddtowidthscalelist: { signature: "m" }, + pgfarrowsthreeparameters: { signature: "m" }, + pgfarrowslinewidthdependent: { signature: "m m m" }, + pgfarrowslengthdependent: { signature: "m" }, + // Path + pgfusepath: { signature: "m" }, + pgfsetlinewidth: { signature: "m" }, + pgfsetmiterlimit: { signature: "m" }, + pgfsetdash: { signature: "m m" }, + pgfsetstrokecolor: { signature: "m" }, + pgfsetcolor: { signature: "m" }, + pgfsetinnerlinewidth: { signature: "m" }, + pgfsetinnerstrokecolor: { signature: "m" }, + pgfsetarrowsstart: { signature: "m" }, + pgfsetarrowsend: { signature: "m" }, + pgfsetarrows: { signature: "m" }, + pgfsetshortenstart: { signature: "m" }, + pgfsetshortenend: { signature: "m" }, + pgfsetfillcolor: { signature: "m" }, + // Decorations + pgfdeclaredecoration: { signature: "m m m" }, + state: { signature: "m o m" }, + pgfdecoratepath: { signature: "m m" }, + startpgfdecoration: { signature: "m" }, + pgfdecoration: { signature: "m" }, + pgfdecoratecurrentpath: { signature: "m" }, + pgfsetdecorationsegmenttransformation: { signature: "m" }, + pgfdeclaremetadecorate: { signature: "m m m" }, + pgfmetadecoration: { signature: "m" }, + startpgfmetadecoration: { signature: "m" }, + // Constructing paths + pgfpathmoveto: { signature: "m" }, + pgfpathlineto: { signature: "m" }, + pgfpathcurveto: { signature: "m m m" }, + pgfpathquadraticcurveto: { signature: "m m" }, + pgfpathcurvebetweentime: { signature: "m m m m m m" }, + pgfpathcurvebetweentimecontinue: { signature: "m m m m m m" }, + pgfpatharc: { signature: "m m m" }, + pgfpatharcaxes: { signature: "m m m m" }, + pgfpatharcto: { signature: "m m m m m m" }, + pgfpatharctoprecomputed: { signature: "m m m m m m m m" }, + pgfpathellipse: { signature: "m m m" }, + pgfpathcircle: { signature: "m m" }, + pgfpathrectangle: { signature: "m m" }, + pgfpathrectanglecorners: { signature: "m m" }, + pgfpathgrid: { signature: " o m m" }, + pgfpathparabola: { signature: "m m" }, + pgfpathsine: { signature: "m" }, + pgfpathcosine: { signature: "m" }, + pgfsetcornersarced: { signature: "m" }, + "pgf@protocolsizes": { signature: "m m" }, + // Specifying coordinates + pgfpoint: { signature: "m m" }, + pgfpointpolar: { signature: "m m m" }, + pgfpointxy: { signature: "m m" }, + pgfsetxvec: { signature: "m" }, + pgfsetyvec: { signature: "m" }, + pgfpointpolarxy: { signature: "m m" }, + pgfpointxyz: { signature: "m m m" }, + pgfsetzvec: { signature: "m" }, + pgfpointcylindrical: { signature: "m m m" }, + pgfpointspherical: { signature: "m m m" }, + pgfpointadd: { signature: "m m" }, + pgfpointscale: { signature: "m m" }, + pgfpointdiff: { signature: "m m" }, + pgfpointnormalised: { signature: "m" }, + pgfpointlineattime: { signature: "m m m" }, + pgfpointlineatdistance: { signature: "m m m" }, + pgfpointarcaxesattime: { signature: "m m m m m m" }, + pgfpointcurveattime: { signature: "m m m m m" }, + pgfpointborderrectangle: { signature: "m m" }, + pgfpointborderellipse: { signature: "m m" }, + pgfpointintersectionoflines: { signature: "m m m m" }, + pgfpointintersectionofcircles: { signature: "m m m m m" }, + pgfintersectionofpaths: { signature: "m m" }, + pgfpointintersectionsolution: { signature: "m" }, + pgfextractx: { signature: "m m" }, + pgfextracty: { signature: "m m" }, + pgfgetlastxy: { signature: "m m" }, + "pgf@process": { signature: "m" }, + // Heirarchical structres ... + pgfsetbaseline: { signature: "m" }, + pgfsetbaselinepointnow: { signature: "m" }, + pgfsetbaselinepointlater: { signature: "m" }, + pgftext: { signature: "o m", renderInfo: { pgfkeysArgs: true } }, + pgfuseid: { signature: "m" }, + pgfusetype: { signature: "m" }, + pgfidrefnextuse: { signature: "m m" }, + pgfidrefprevuse: { signature: "m m" }, + pgfaliasid: { signature: "m m" }, + pgfgaliasid: { signature: "m m" }, + pgfifidreferenced: { signature: "m m m" }, + pgfrdfabout: { signature: "m" }, + pgfrdfcontent: { signature: "m" }, + pgfrdfdatatype: { signature: "m" }, + pgfrdfhref: { signature: "m" }, + pgfrdfprefix: { signature: "m" }, + pgfrdfproperty: { signature: "m" }, + pgfrdfrel: { signature: "m" }, + pgfrdfresource: { signature: "m" }, + pgfrdfrev: { signature: "m" }, + pgfrdfsrc: { signature: "m" }, + pgfrdftypeof: { signature: "m" }, + pgfrdfvocab: { signature: "m" }, + pgferror: { signature: "m" }, + pgfwarning: { signature: "m" }, + path: { + signature: "u;", + renderInfo: { breakAround: true, tikzPathCommand: true } + }, + draw: { + signature: "u;", + renderInfo: { breakAround: true, tikzPathCommand: true } + }, + fill: { + signature: "u;", + renderInfo: { breakAround: true, tikzPathCommand: true } + }, + filldraw: { + signature: "u;", + renderInfo: { breakAround: true, tikzPathCommand: true } + }, + pattern: { + signature: "u;", + renderInfo: { breakAround: true, tikzPathCommand: true } + }, + shade: { + signature: "u;", + renderInfo: { breakAround: true, tikzPathCommand: true } + }, + clip: { + signature: "u;", + renderInfo: { breakAround: true, tikzPathCommand: true } + }, + useasboundingbox: { + signature: "u;", + renderInfo: { breakAround: true, tikzPathCommand: true } + }, + node: { + signature: "u;", + renderInfo: { breakAround: true, tikzPathCommand: true } + }, + coordinate: { + signature: "u;", + renderInfo: { breakAround: true, tikzPathCommand: true } + }, + graph: { + signature: "u;", + renderInfo: { breakAround: true, tikzPathCommand: true } + }, + scoped: { + signature: "o o m", + argumentParser: tikzCommandArgumentParser, + renderInfo: { + namedArguments: ["animation", "options", "command"], + breakAround: true + } + } +}; +var macros13 = { + substitutecolormodel: { + signature: "m m", + renderInfo: { breakAround: true } + }, + selectcolormodel: { + signature: "m", + renderInfo: { breakAround: true } + }, + definecolor: { + signature: "o m m m", + renderInfo: { breakAround: true } + }, + providecolor: { + signature: "o m m m", + renderInfo: { breakAround: true } + }, + colorlet: { + signature: "o m o m", + renderInfo: { breakAround: true } + }, + definecolorset: { + signature: "o m m m", + renderInfo: { breakAround: true } + }, + providecolorset: { + signature: "o m m m m", + renderInfo: { breakAround: true } + }, + preparecolor: { + signature: "o m m m", + renderInfo: { breakAround: true } + }, + preparecolorset: { + signature: "o m m m m", + renderInfo: { breakAround: true } + }, + DefineNamedColor: { + signature: "m m m m", + renderInfo: { breakAround: true } + }, + definecolors: { + signature: "m", + renderInfo: { breakAround: true } + }, + providecolors: { + signature: "m", + renderInfo: { breakAround: true } + }, + color: { signature: "o m", renderInfo: { breakAround: true } }, + textcolor: { signature: "o m m", renderInfo: { inParMode: true } }, + pagecolor: { signature: "o m" }, + colorbox: { signature: "o m m" }, + fcolorbox: { signature: "o m o m m" }, + boxframe: { signature: "o m" }, + testcolor: { signature: "o m" }, + blendcolors: { signature: "s m" }, + maskcolors: { signature: "o m" }, + definecolorseries: { + signature: "m m m o m o m", + renderInfo: { breakAround: true } + }, + resetcolorseries: { + signature: "o m", + renderInfo: { breakAround: true } + }, + rowcolors: { signature: "s o m m m" }, + extractcolorspec: { signature: "m m" }, + extractcolorspecs: { signature: "m m m" }, + convertcolorspec: { signature: "m m m m" } +}; +var environments13 = { + testcolors: { signature: "o", renderInfo: { pgfkeysArgs: true } } +}; +var fromRgb = ([r, g, b]) => Color2([r * 255, g * 255, b * 255], "rgb"); +var DVI_PS_NAMES = { + Apricot: Color2("#FBB982"), + Aquamarine: Color2("#00B5BE"), + Bittersweet: Color2("#C04F17"), + Black: Color2("#221E1F"), + Blue: Color2("#2D2F92"), + BlueGreen: Color2("#00B3B8"), + BlueViolet: Color2("#473992"), + BrickRed: Color2("#B6321C"), + Brown: Color2("#792500"), + BurntOrange: Color2("#F7921D"), + CadetBlue: Color2("#74729A"), + CarnationPink: Color2("#F282B4"), + Cerulean: Color2("#00A2E3"), + CornflowerBlue: Color2("#41B0E4"), + Cyan: Color2("#00AEEF"), + Dandelion: Color2("#FDBC42"), + DarkOrchid: Color2("#A4538A"), + Emerald: Color2("#00A99D"), + ForestGreen: Color2("#009B55"), + Fuchsia: Color2("#8C368C"), + Goldenrod: Color2("#FFDF42"), + Gray: Color2("#949698"), + Green: Color2("#00A64F"), + GreenYellow: Color2("#DFE674"), + JungleGreen: Color2("#00A99A"), + Lavender: Color2("#F49EC4"), + LimeGreen: Color2("#8DC73E"), + Magenta: Color2("#EC008C"), + Mahogany: Color2("#A9341F"), + Maroon: Color2("#AF3235"), + Melon: Color2("#F89E7B"), + MidnightBlue: Color2("#006795"), + Mulberry: Color2("#A93C93"), + NavyBlue: Color2("#006EB8"), + OliveGreen: Color2("#3C8031"), + Orange: Color2("#F58137"), + OrangeRed: Color2("#ED135A"), + Orchid: Color2("#AF72B0"), + Peach: Color2("#F7965A"), + Periwinkle: Color2("#7977B8"), + PineGreen: Color2("#008B72"), + Plum: Color2("#92268F"), + ProcessBlue: Color2("#00B0F0"), + Purple: Color2("#99479B"), + RawSienna: Color2("#974006"), + Red: Color2("#ED1B23"), + RedOrange: Color2("#F26035"), + RedViolet: Color2("#A1246B"), + Rhodamine: Color2("#EF559F"), + RoyalBlue: Color2("#0071BC"), + RoyalPurple: Color2("#613F99"), + RubineRed: Color2("#ED017D"), + Salmon: Color2("#F69289"), + SeaGreen: Color2("#3FBC9D"), + Sepia: Color2("#671800"), + SkyBlue: Color2("#46C5DD"), + SpringGreen: Color2("#C6DC67"), + Tan: Color2("#DA9D76"), + TealBlue: Color2("#00AEB3"), + Thistle: Color2("#D883B7"), + Turquoise: Color2("#00B4CE"), + Violet: Color2("#58429B"), + VioletRed: Color2("#EF58A0"), + White: Color2("#FFFFFF"), + WildStrawberry: Color2("#EE2967"), + Yellow: Color2("#FFF200"), + YellowGreen: Color2("#98CC70"), + YellowOrange: Color2("#FAA21A") +}; +var SVG_NAMES = { + AliceBlue: fromRgb([0.94, 0.972, 1]), + AntiqueWhite: fromRgb([0.98, 0.92, 0.844]), + Aqua: fromRgb([0, 1, 1]), + Aquamarine: fromRgb([0.498, 1, 0.83]), + Azure: fromRgb([0.94, 1, 1]), + Beige: fromRgb([0.96, 0.96, 0.864]), + Bisque: fromRgb([1, 0.894, 0.77]), + Black: fromRgb([0, 0, 0]), + BlanchedAlmond: fromRgb([1, 0.92, 0.804]), + Blue: fromRgb([0, 0, 1]), + BlueViolet: fromRgb([0.54, 0.17, 0.888]), + Brown: fromRgb([0.648, 0.165, 0.165]), + BurlyWood: fromRgb([0.87, 0.72, 0.53]), + CadetBlue: fromRgb([0.372, 0.62, 0.628]), + Chartreuse: fromRgb([0.498, 1, 0]), + Chocolate: fromRgb([0.824, 0.41, 0.116]), + Coral: fromRgb([1, 0.498, 0.312]), + CornflowerBlue: fromRgb([0.392, 0.585, 0.93]), + Cornsilk: fromRgb([1, 0.972, 0.864]), + Crimson: fromRgb([0.864, 0.08, 0.235]), + Cyan: fromRgb([0, 1, 1]), + DarkBlue: fromRgb([0, 0, 0.545]), + DarkCyan: fromRgb([0, 0.545, 0.545]), + DarkGoldenrod: fromRgb([0.72, 0.525, 0.044]), + DarkGray: fromRgb([0.664, 0.664, 0.664]), + DarkGreen: fromRgb([0, 0.392, 0]), + DarkGrey: fromRgb([0.664, 0.664, 0.664]), + DarkKhaki: fromRgb([0.74, 0.716, 0.42]), + DarkMagenta: fromRgb([0.545, 0, 0.545]), + DarkOliveGreen: fromRgb([0.332, 0.42, 0.185]), + DarkOrange: fromRgb([1, 0.55, 0]), + DarkOrchid: fromRgb([0.6, 0.196, 0.8]), + DarkRed: fromRgb([0.545, 0, 0]), + DarkSalmon: fromRgb([0.912, 0.59, 0.48]), + DarkSeaGreen: fromRgb([0.56, 0.736, 0.56]), + DarkSlateBlue: fromRgb([0.284, 0.24, 0.545]), + DarkSlateGray: fromRgb([0.185, 0.31, 0.31]), + DarkSlateGrey: fromRgb([0.185, 0.31, 0.31]), + DarkTurquoise: fromRgb([0, 0.808, 0.82]), + DarkViolet: fromRgb([0.58, 0, 0.828]), + DeepPink: fromRgb([1, 0.08, 0.576]), + DeepSkyBlue: fromRgb([0, 0.75, 1]), + DimGray: fromRgb([0.41, 0.41, 0.41]), + DimGrey: fromRgb([0.41, 0.41, 0.41]), + DodgerBlue: fromRgb([0.116, 0.565, 1]), + FireBrick: fromRgb([0.698, 0.132, 0.132]), + FloralWhite: fromRgb([1, 0.98, 0.94]), + ForestGreen: fromRgb([0.132, 0.545, 0.132]), + Fuchsia: fromRgb([1, 0, 1]), + Gainsboro: fromRgb([0.864, 0.864, 0.864]), + GhostWhite: fromRgb([0.972, 0.972, 1]), + Gold: fromRgb([1, 0.844, 0]), + Goldenrod: fromRgb([0.855, 0.648, 0.125]), + Gray: fromRgb([0.5, 0.5, 0.5]), + Green: fromRgb([0, 0.5, 0]), + GreenYellow: fromRgb([0.68, 1, 0.185]), + Grey: fromRgb([0.5, 0.5, 0.5]), + Honeydew: fromRgb([0.94, 1, 0.94]), + HotPink: fromRgb([1, 0.41, 0.705]), + IndianRed: fromRgb([0.804, 0.36, 0.36]), + Indigo: fromRgb([0.294, 0, 0.51]), + Ivory: fromRgb([1, 1, 0.94]), + Khaki: fromRgb([0.94, 0.9, 0.55]), + Lavender: fromRgb([0.9, 0.9, 0.98]), + LavenderBlush: fromRgb([1, 0.94, 0.96]), + LawnGreen: fromRgb([0.488, 0.99, 0]), + LemonChiffon: fromRgb([1, 0.98, 0.804]), + LightBlue: fromRgb([0.68, 0.848, 0.9]), + LightCoral: fromRgb([0.94, 0.5, 0.5]), + LightCyan: fromRgb([0.88, 1, 1]), + LightGoldenrod: fromRgb([0.933, 0.867, 0.51]), + LightGoldenrodYellow: fromRgb([0.98, 0.98, 0.824]), + LightGray: fromRgb([0.828, 0.828, 0.828]), + LightGreen: fromRgb([0.565, 0.932, 0.565]), + LightGrey: fromRgb([0.828, 0.828, 0.828]), + LightPink: fromRgb([1, 0.712, 0.756]), + LightSalmon: fromRgb([1, 0.628, 0.48]), + LightSeaGreen: fromRgb([0.125, 0.698, 0.668]), + LightSkyBlue: fromRgb([0.53, 0.808, 0.98]), + LightSlateBlue: fromRgb([0.518, 0.44, 1]), + LightSlateGray: fromRgb([0.468, 0.532, 0.6]), + LightSlateGrey: fromRgb([0.468, 0.532, 0.6]), + LightSteelBlue: fromRgb([0.69, 0.77, 0.87]), + LightYellow: fromRgb([1, 1, 0.88]), + Lime: fromRgb([0, 1, 0]), + LimeGreen: fromRgb([0.196, 0.804, 0.196]), + Linen: fromRgb([0.98, 0.94, 0.9]), + Magenta: fromRgb([1, 0, 1]), + Maroon: fromRgb([0.5, 0, 0]), + MediumAquamarine: fromRgb([0.4, 0.804, 0.668]), + MediumBlue: fromRgb([0, 0, 0.804]), + MediumOrchid: fromRgb([0.73, 0.332, 0.828]), + MediumPurple: fromRgb([0.576, 0.44, 0.86]), + MediumSeaGreen: fromRgb([0.235, 0.7, 0.444]), + MediumSlateBlue: fromRgb([0.484, 0.408, 0.932]), + MediumSpringGreen: fromRgb([0, 0.98, 0.604]), + MediumTurquoise: fromRgb([0.284, 0.82, 0.8]), + MediumVioletRed: fromRgb([0.78, 0.084, 0.52]), + MidnightBlue: fromRgb([0.098, 0.098, 0.44]), + MintCream: fromRgb([0.96, 1, 0.98]), + MistyRose: fromRgb([1, 0.894, 0.884]), + Moccasin: fromRgb([1, 0.894, 0.71]), + NavajoWhite: fromRgb([1, 0.87, 0.68]), + Navy: fromRgb([0, 0, 0.5]), + NavyBlue: fromRgb([0, 0, 0.5]), + OldLace: fromRgb([0.992, 0.96, 0.9]), + Olive: fromRgb([0.5, 0.5, 0]), + OliveDrab: fromRgb([0.42, 0.556, 0.136]), + Orange: fromRgb([1, 0.648, 0]), + OrangeRed: fromRgb([1, 0.27, 0]), + Orchid: fromRgb([0.855, 0.44, 0.84]), + PaleGoldenrod: fromRgb([0.932, 0.91, 0.668]), + PaleGreen: fromRgb([0.596, 0.985, 0.596]), + PaleTurquoise: fromRgb([0.688, 0.932, 0.932]), + PaleVioletRed: fromRgb([0.86, 0.44, 0.576]), + PapayaWhip: fromRgb([1, 0.936, 0.835]), + PeachPuff: fromRgb([1, 0.855, 0.725]), + Peru: fromRgb([0.804, 0.52, 0.248]), + Pink: fromRgb([1, 0.752, 0.796]), + Plum: fromRgb([0.868, 0.628, 0.868]), + PowderBlue: fromRgb([0.69, 0.88, 0.9]), + Purple: fromRgb([0.5, 0, 0.5]), + Red: fromRgb([1, 0, 0]), + RosyBrown: fromRgb([0.736, 0.56, 0.56]), + RoyalBlue: fromRgb([0.255, 0.41, 0.884]), + SaddleBrown: fromRgb([0.545, 0.27, 0.075]), + Salmon: fromRgb([0.98, 0.5, 0.448]), + SandyBrown: fromRgb([0.956, 0.644, 0.376]), + SeaGreen: fromRgb([0.18, 0.545, 0.34]), + Seashell: fromRgb([1, 0.96, 0.932]), + Sienna: fromRgb([0.628, 0.32, 0.176]), + Silver: fromRgb([0.752, 0.752, 0.752]), + SkyBlue: fromRgb([0.53, 0.808, 0.92]), + SlateBlue: fromRgb([0.415, 0.352, 0.804]), + SlateGray: fromRgb([0.44, 0.5, 0.565]), + SlateGrey: fromRgb([0.44, 0.5, 0.565]), + Snow: fromRgb([1, 0.98, 0.98]), + SpringGreen: fromRgb([0, 1, 0.498]), + SteelBlue: fromRgb([0.275, 0.51, 0.705]), + Tan: fromRgb([0.824, 0.705, 0.55]), + Teal: fromRgb([0, 0.5, 0.5]), + Thistle: fromRgb([0.848, 0.75, 0.848]), + Tomato: fromRgb([1, 0.39, 0.28]), + Turquoise: fromRgb([0.25, 0.88, 0.815]), + Violet: fromRgb([0.932, 0.51, 0.932]), + VioletRed: fromRgb([0.816, 0.125, 0.565]), + Wheat: fromRgb([0.96, 0.87, 0.7]), + White: fromRgb([1, 1, 1]), + WhiteSmoke: fromRgb([0.96, 0.96, 0.96]), + Yellow: fromRgb([1, 1, 0]), + YellowGreen: fromRgb([0.604, 0.804, 0.196]) +}; +var X11_NAMES = { + AntiqueWhite1: fromRgb([1, 0.936, 0.86]), + AntiqueWhite2: fromRgb([0.932, 0.875, 0.8]), + AntiqueWhite3: fromRgb([0.804, 0.752, 0.69]), + AntiqueWhite4: fromRgb([0.545, 0.512, 0.47]), + Aquamarine1: fromRgb([0.498, 1, 0.83]), + Aquamarine2: fromRgb([0.464, 0.932, 0.776]), + Aquamarine3: fromRgb([0.4, 0.804, 0.668]), + Aquamarine4: fromRgb([0.27, 0.545, 0.455]), + Azure1: fromRgb([0.94, 1, 1]), + Azure2: fromRgb([0.88, 0.932, 0.932]), + Azure3: fromRgb([0.756, 0.804, 0.804]), + Azure4: fromRgb([0.512, 0.545, 0.545]), + Bisque1: fromRgb([1, 0.894, 0.77]), + Bisque2: fromRgb([0.932, 0.835, 0.716]), + Bisque3: fromRgb([0.804, 0.716, 0.62]), + Bisque4: fromRgb([0.545, 0.49, 0.42]), + Blue1: fromRgb([0, 0, 1]), + Blue2: fromRgb([0, 0, 0.932]), + Blue3: fromRgb([0, 0, 0.804]), + Blue4: fromRgb([0, 0, 0.545]), + Brown1: fromRgb([1, 0.25, 0.25]), + Brown2: fromRgb([0.932, 0.23, 0.23]), + Brown3: fromRgb([0.804, 0.2, 0.2]), + Brown4: fromRgb([0.545, 0.136, 0.136]), + Burlywood1: fromRgb([1, 0.828, 0.608]), + Burlywood2: fromRgb([0.932, 0.772, 0.57]), + Burlywood3: fromRgb([0.804, 0.668, 0.49]), + Burlywood4: fromRgb([0.545, 0.45, 0.332]), + CadetBlue1: fromRgb([0.596, 0.96, 1]), + CadetBlue2: fromRgb([0.556, 0.898, 0.932]), + CadetBlue3: fromRgb([0.48, 0.772, 0.804]), + CadetBlue4: fromRgb([0.325, 0.525, 0.545]), + Chartreuse1: fromRgb([0.498, 1, 0]), + Chartreuse2: fromRgb([0.464, 0.932, 0]), + Chartreuse3: fromRgb([0.4, 0.804, 0]), + Chartreuse4: fromRgb([0.27, 0.545, 0]), + Chocolate1: fromRgb([1, 0.498, 0.14]), + Chocolate2: fromRgb([0.932, 0.464, 0.13]), + Chocolate3: fromRgb([0.804, 0.4, 0.112]), + Chocolate4: fromRgb([0.545, 0.27, 0.075]), + Coral1: fromRgb([1, 0.448, 0.336]), + Coral2: fromRgb([0.932, 0.415, 0.312]), + Coral3: fromRgb([0.804, 0.356, 0.27]), + Coral4: fromRgb([0.545, 0.244, 0.185]), + Cornsilk1: fromRgb([1, 0.972, 0.864]), + Cornsilk2: fromRgb([0.932, 0.91, 0.804]), + Cornsilk3: fromRgb([0.804, 0.785, 0.694]), + Cornsilk4: fromRgb([0.545, 0.532, 0.47]), + Cyan1: fromRgb([0, 1, 1]), + Cyan2: fromRgb([0, 0.932, 0.932]), + Cyan3: fromRgb([0, 0.804, 0.804]), + Cyan4: fromRgb([0, 0.545, 0.545]), + DarkGoldenrod1: fromRgb([1, 0.725, 0.06]), + DarkGoldenrod2: fromRgb([0.932, 0.68, 0.055]), + DarkGoldenrod3: fromRgb([0.804, 0.585, 0.048]), + DarkGoldenrod4: fromRgb([0.545, 0.396, 0.03]), + DarkOliveGreen1: fromRgb([0.792, 1, 0.44]), + DarkOliveGreen2: fromRgb([0.736, 0.932, 0.408]), + DarkOliveGreen3: fromRgb([0.635, 0.804, 0.352]), + DarkOliveGreen4: fromRgb([0.43, 0.545, 0.24]), + DarkOrange1: fromRgb([1, 0.498, 0]), + DarkOrange2: fromRgb([0.932, 0.464, 0]), + DarkOrange3: fromRgb([0.804, 0.4, 0]), + DarkOrange4: fromRgb([0.545, 0.27, 0]), + DarkOrchid1: fromRgb([0.75, 0.244, 1]), + DarkOrchid2: fromRgb([0.698, 0.228, 0.932]), + DarkOrchid3: fromRgb([0.604, 0.196, 0.804]), + DarkOrchid4: fromRgb([0.408, 0.132, 0.545]), + DarkSeaGreen1: fromRgb([0.756, 1, 0.756]), + DarkSeaGreen2: fromRgb([0.705, 0.932, 0.705]), + DarkSeaGreen3: fromRgb([0.608, 0.804, 0.608]), + DarkSeaGreen4: fromRgb([0.41, 0.545, 0.41]), + DarkSlateGray1: fromRgb([0.592, 1, 1]), + DarkSlateGray2: fromRgb([0.552, 0.932, 0.932]), + DarkSlateGray3: fromRgb([0.475, 0.804, 0.804]), + DarkSlateGray4: fromRgb([0.32, 0.545, 0.545]), + DeepPink1: fromRgb([1, 0.08, 0.576]), + DeepPink2: fromRgb([0.932, 0.07, 0.536]), + DeepPink3: fromRgb([0.804, 0.064, 0.464]), + DeepPink4: fromRgb([0.545, 0.04, 0.312]), + DeepSkyBlue1: fromRgb([0, 0.75, 1]), + DeepSkyBlue2: fromRgb([0, 0.698, 0.932]), + DeepSkyBlue3: fromRgb([0, 0.604, 0.804]), + DeepSkyBlue4: fromRgb([0, 0.408, 0.545]), + DodgerBlue1: fromRgb([0.116, 0.565, 1]), + DodgerBlue2: fromRgb([0.11, 0.525, 0.932]), + DodgerBlue3: fromRgb([0.094, 0.455, 0.804]), + DodgerBlue4: fromRgb([0.064, 0.305, 0.545]), + Firebrick1: fromRgb([1, 0.19, 0.19]), + Firebrick2: fromRgb([0.932, 0.172, 0.172]), + Firebrick3: fromRgb([0.804, 0.15, 0.15]), + Firebrick4: fromRgb([0.545, 0.1, 0.1]), + Gold1: fromRgb([1, 0.844, 0]), + Gold2: fromRgb([0.932, 0.79, 0]), + Gold3: fromRgb([0.804, 0.68, 0]), + Gold4: fromRgb([0.545, 0.46, 0]), + Goldenrod1: fromRgb([1, 0.756, 0.145]), + Goldenrod2: fromRgb([0.932, 0.705, 0.132]), + Goldenrod3: fromRgb([0.804, 0.608, 0.112]), + Goldenrod4: fromRgb([0.545, 0.41, 0.08]), + Green1: fromRgb([0, 1, 0]), + Green2: fromRgb([0, 0.932, 0]), + Green3: fromRgb([0, 0.804, 0]), + Green4: fromRgb([0, 0.545, 0]), + Honeydew1: fromRgb([0.94, 1, 0.94]), + Honeydew2: fromRgb([0.88, 0.932, 0.88]), + Honeydew3: fromRgb([0.756, 0.804, 0.756]), + Honeydew4: fromRgb([0.512, 0.545, 0.512]), + HotPink1: fromRgb([1, 0.43, 0.705]), + HotPink2: fromRgb([0.932, 0.415, 0.655]), + HotPink3: fromRgb([0.804, 0.376, 0.565]), + HotPink4: fromRgb([0.545, 0.228, 0.385]), + IndianRed1: fromRgb([1, 0.415, 0.415]), + IndianRed2: fromRgb([0.932, 0.39, 0.39]), + IndianRed3: fromRgb([0.804, 0.332, 0.332]), + IndianRed4: fromRgb([0.545, 0.228, 0.228]), + Ivory1: fromRgb([1, 1, 0.94]), + Ivory2: fromRgb([0.932, 0.932, 0.88]), + Ivory3: fromRgb([0.804, 0.804, 0.756]), + Ivory4: fromRgb([0.545, 0.545, 0.512]), + Khaki1: fromRgb([1, 0.965, 0.56]), + Khaki2: fromRgb([0.932, 0.9, 0.52]), + Khaki3: fromRgb([0.804, 0.776, 0.45]), + Khaki4: fromRgb([0.545, 0.525, 0.305]), + LavenderBlush1: fromRgb([1, 0.94, 0.96]), + LavenderBlush2: fromRgb([0.932, 0.88, 0.898]), + LavenderBlush3: fromRgb([0.804, 0.756, 0.772]), + LavenderBlush4: fromRgb([0.545, 0.512, 0.525]), + LemonChiffon1: fromRgb([1, 0.98, 0.804]), + LemonChiffon2: fromRgb([0.932, 0.912, 0.75]), + LemonChiffon3: fromRgb([0.804, 0.79, 0.648]), + LemonChiffon4: fromRgb([0.545, 0.536, 0.44]), + LightBlue1: fromRgb([0.75, 0.936, 1]), + LightBlue2: fromRgb([0.698, 0.875, 0.932]), + LightBlue3: fromRgb([0.604, 0.752, 0.804]), + LightBlue4: fromRgb([0.408, 0.512, 0.545]), + LightCyan1: fromRgb([0.88, 1, 1]), + LightCyan2: fromRgb([0.82, 0.932, 0.932]), + LightCyan3: fromRgb([0.705, 0.804, 0.804]), + LightCyan4: fromRgb([0.48, 0.545, 0.545]), + LightGoldenrod1: fromRgb([1, 0.925, 0.545]), + LightGoldenrod2: fromRgb([0.932, 0.864, 0.51]), + LightGoldenrod3: fromRgb([0.804, 0.745, 0.44]), + LightGoldenrod4: fromRgb([0.545, 0.505, 0.298]), + LightPink1: fromRgb([1, 0.684, 0.725]), + LightPink2: fromRgb([0.932, 0.635, 0.68]), + LightPink3: fromRgb([0.804, 0.55, 0.585]), + LightPink4: fromRgb([0.545, 0.372, 0.396]), + LightSalmon1: fromRgb([1, 0.628, 0.48]), + LightSalmon2: fromRgb([0.932, 0.585, 0.448]), + LightSalmon3: fromRgb([0.804, 0.505, 0.385]), + LightSalmon4: fromRgb([0.545, 0.34, 0.26]), + LightSkyBlue1: fromRgb([0.69, 0.888, 1]), + LightSkyBlue2: fromRgb([0.644, 0.828, 0.932]), + LightSkyBlue3: fromRgb([0.552, 0.712, 0.804]), + LightSkyBlue4: fromRgb([0.376, 0.484, 0.545]), + LightSteelBlue1: fromRgb([0.792, 0.884, 1]), + LightSteelBlue2: fromRgb([0.736, 0.824, 0.932]), + LightSteelBlue3: fromRgb([0.635, 0.71, 0.804]), + LightSteelBlue4: fromRgb([0.43, 0.484, 0.545]), + LightYellow1: fromRgb([1, 1, 0.88]), + LightYellow2: fromRgb([0.932, 0.932, 0.82]), + LightYellow3: fromRgb([0.804, 0.804, 0.705]), + LightYellow4: fromRgb([0.545, 0.545, 0.48]), + Magenta1: fromRgb([1, 0, 1]), + Magenta2: fromRgb([0.932, 0, 0.932]), + Magenta3: fromRgb([0.804, 0, 0.804]), + Magenta4: fromRgb([0.545, 0, 0.545]), + Maroon1: fromRgb([1, 0.204, 0.7]), + Maroon2: fromRgb([0.932, 0.19, 0.655]), + Maroon3: fromRgb([0.804, 0.16, 0.565]), + Maroon4: fromRgb([0.545, 0.11, 0.385]), + MediumOrchid1: fromRgb([0.88, 0.4, 1]), + MediumOrchid2: fromRgb([0.82, 0.372, 0.932]), + MediumOrchid3: fromRgb([0.705, 0.32, 0.804]), + MediumOrchid4: fromRgb([0.48, 0.215, 0.545]), + MediumPurple1: fromRgb([0.67, 0.51, 1]), + MediumPurple2: fromRgb([0.624, 0.475, 0.932]), + MediumPurple3: fromRgb([0.536, 0.408, 0.804]), + MediumPurple4: fromRgb([0.365, 0.28, 0.545]), + MistyRose1: fromRgb([1, 0.894, 0.884]), + MistyRose2: fromRgb([0.932, 0.835, 0.824]), + MistyRose3: fromRgb([0.804, 0.716, 0.71]), + MistyRose4: fromRgb([0.545, 0.49, 0.484]), + NavajoWhite1: fromRgb([1, 0.87, 0.68]), + NavajoWhite2: fromRgb([0.932, 0.81, 0.63]), + NavajoWhite3: fromRgb([0.804, 0.7, 0.545]), + NavajoWhite4: fromRgb([0.545, 0.475, 0.37]), + OliveDrab1: fromRgb([0.752, 1, 0.244]), + OliveDrab2: fromRgb([0.7, 0.932, 0.228]), + OliveDrab3: fromRgb([0.604, 0.804, 0.196]), + OliveDrab4: fromRgb([0.41, 0.545, 0.132]), + Orange1: fromRgb([1, 0.648, 0]), + Orange2: fromRgb([0.932, 0.604, 0]), + Orange3: fromRgb([0.804, 0.52, 0]), + Orange4: fromRgb([0.545, 0.352, 0]), + OrangeRed1: fromRgb([1, 0.27, 0]), + OrangeRed2: fromRgb([0.932, 0.25, 0]), + OrangeRed3: fromRgb([0.804, 0.215, 0]), + OrangeRed4: fromRgb([0.545, 0.145, 0]), + Orchid1: fromRgb([1, 0.512, 0.98]), + Orchid2: fromRgb([0.932, 0.48, 0.912]), + Orchid3: fromRgb([0.804, 0.41, 0.79]), + Orchid4: fromRgb([0.545, 0.28, 0.536]), + PaleGreen1: fromRgb([0.604, 1, 0.604]), + PaleGreen2: fromRgb([0.565, 0.932, 0.565]), + PaleGreen3: fromRgb([0.488, 0.804, 0.488]), + PaleGreen4: fromRgb([0.33, 0.545, 0.33]), + PaleTurquoise1: fromRgb([0.732, 1, 1]), + PaleTurquoise2: fromRgb([0.684, 0.932, 0.932]), + PaleTurquoise3: fromRgb([0.59, 0.804, 0.804]), + PaleTurquoise4: fromRgb([0.4, 0.545, 0.545]), + PaleVioletRed1: fromRgb([1, 0.51, 0.67]), + PaleVioletRed2: fromRgb([0.932, 0.475, 0.624]), + PaleVioletRed3: fromRgb([0.804, 0.408, 0.536]), + PaleVioletRed4: fromRgb([0.545, 0.28, 0.365]), + PeachPuff1: fromRgb([1, 0.855, 0.725]), + PeachPuff2: fromRgb([0.932, 0.796, 0.68]), + PeachPuff3: fromRgb([0.804, 0.688, 0.585]), + PeachPuff4: fromRgb([0.545, 0.468, 0.396]), + Pink1: fromRgb([1, 0.71, 0.772]), + Pink2: fromRgb([0.932, 0.664, 0.72]), + Pink3: fromRgb([0.804, 0.57, 0.62]), + Pink4: fromRgb([0.545, 0.39, 0.424]), + Plum1: fromRgb([1, 0.732, 1]), + Plum2: fromRgb([0.932, 0.684, 0.932]), + Plum3: fromRgb([0.804, 0.59, 0.804]), + Plum4: fromRgb([0.545, 0.4, 0.545]), + Purple1: fromRgb([0.608, 0.19, 1]), + Purple2: fromRgb([0.57, 0.172, 0.932]), + Purple3: fromRgb([0.49, 0.15, 0.804]), + Purple4: fromRgb([0.332, 0.1, 0.545]), + Red1: fromRgb([1, 0, 0]), + Red2: fromRgb([0.932, 0, 0]), + Red3: fromRgb([0.804, 0, 0]), + Red4: fromRgb([0.545, 0, 0]), + RosyBrown1: fromRgb([1, 0.756, 0.756]), + RosyBrown2: fromRgb([0.932, 0.705, 0.705]), + RosyBrown3: fromRgb([0.804, 0.608, 0.608]), + RosyBrown4: fromRgb([0.545, 0.41, 0.41]), + RoyalBlue1: fromRgb([0.284, 0.464, 1]), + RoyalBlue2: fromRgb([0.264, 0.43, 0.932]), + RoyalBlue3: fromRgb([0.228, 0.372, 0.804]), + RoyalBlue4: fromRgb([0.152, 0.25, 0.545]), + Salmon1: fromRgb([1, 0.55, 0.41]), + Salmon2: fromRgb([0.932, 0.51, 0.385]), + Salmon3: fromRgb([0.804, 0.44, 0.33]), + Salmon4: fromRgb([0.545, 0.298, 0.224]), + SeaGreen1: fromRgb([0.33, 1, 0.624]), + SeaGreen2: fromRgb([0.305, 0.932, 0.58]), + SeaGreen3: fromRgb([0.264, 0.804, 0.5]), + SeaGreen4: fromRgb([0.18, 0.545, 0.34]), + Seashell1: fromRgb([1, 0.96, 0.932]), + Seashell2: fromRgb([0.932, 0.898, 0.87]), + Seashell3: fromRgb([0.804, 0.772, 0.75]), + Seashell4: fromRgb([0.545, 0.525, 0.51]), + Sienna1: fromRgb([1, 0.51, 0.28]), + Sienna2: fromRgb([0.932, 0.475, 0.26]), + Sienna3: fromRgb([0.804, 0.408, 0.224]), + Sienna4: fromRgb([0.545, 0.28, 0.15]), + SkyBlue1: fromRgb([0.53, 0.808, 1]), + SkyBlue2: fromRgb([0.494, 0.752, 0.932]), + SkyBlue3: fromRgb([0.424, 0.65, 0.804]), + SkyBlue4: fromRgb([0.29, 0.44, 0.545]), + SlateBlue1: fromRgb([0.512, 0.435, 1]), + SlateBlue2: fromRgb([0.48, 0.404, 0.932]), + SlateBlue3: fromRgb([0.41, 0.35, 0.804]), + SlateBlue4: fromRgb([0.28, 0.235, 0.545]), + SlateGray1: fromRgb([0.776, 0.888, 1]), + SlateGray2: fromRgb([0.725, 0.828, 0.932]), + SlateGray3: fromRgb([0.624, 0.712, 0.804]), + SlateGray4: fromRgb([0.424, 0.484, 0.545]), + Snow1: fromRgb([1, 0.98, 0.98]), + Snow2: fromRgb([0.932, 0.912, 0.912]), + Snow3: fromRgb([0.804, 0.79, 0.79]), + Snow4: fromRgb([0.545, 0.536, 0.536]), + SpringGreen1: fromRgb([0, 1, 0.498]), + SpringGreen2: fromRgb([0, 0.932, 0.464]), + SpringGreen3: fromRgb([0, 0.804, 0.4]), + SpringGreen4: fromRgb([0, 0.545, 0.27]), + SteelBlue1: fromRgb([0.39, 0.72, 1]), + SteelBlue2: fromRgb([0.36, 0.675, 0.932]), + SteelBlue3: fromRgb([0.31, 0.58, 0.804]), + SteelBlue4: fromRgb([0.21, 0.392, 0.545]), + Tan1: fromRgb([1, 0.648, 0.31]), + Tan2: fromRgb([0.932, 0.604, 0.288]), + Tan3: fromRgb([0.804, 0.52, 0.248]), + Tan4: fromRgb([0.545, 0.352, 0.17]), + Thistle1: fromRgb([1, 0.884, 1]), + Thistle2: fromRgb([0.932, 0.824, 0.932]), + Thistle3: fromRgb([0.804, 0.71, 0.804]), + Thistle4: fromRgb([0.545, 0.484, 0.545]), + Tomato1: fromRgb([1, 0.39, 0.28]), + Tomato2: fromRgb([0.932, 0.36, 0.26]), + Tomato3: fromRgb([0.804, 0.31, 0.224]), + Tomato4: fromRgb([0.545, 0.21, 0.15]), + Turquoise1: fromRgb([0, 0.96, 1]), + Turquoise2: fromRgb([0, 0.898, 0.932]), + Turquoise3: fromRgb([0, 0.772, 0.804]), + Turquoise4: fromRgb([0, 0.525, 0.545]), + VioletRed1: fromRgb([1, 0.244, 0.59]), + VioletRed2: fromRgb([0.932, 0.228, 0.55]), + VioletRed3: fromRgb([0.804, 0.196, 0.47]), + VioletRed4: fromRgb([0.545, 0.132, 0.32]), + Wheat1: fromRgb([1, 0.905, 0.73]), + Wheat2: fromRgb([0.932, 0.848, 0.684]), + Wheat3: fromRgb([0.804, 0.73, 0.59]), + Wheat4: fromRgb([0.545, 0.494, 0.4]), + Yellow1: fromRgb([1, 1, 0]), + Yellow2: fromRgb([0.932, 0.932, 0]), + Yellow3: fromRgb([0.804, 0.804, 0]), + Yellow4: fromRgb([0.545, 0.545, 0]), + Gray0: fromRgb([0.745, 0.745, 0.745]), + Green0: fromRgb([0, 1, 0]), + Grey0: fromRgb([0.745, 0.745, 0.745]), + Maroon0: fromRgb([0.69, 0.19, 0.376]), + Purple0: fromRgb([0.628, 0.125, 0.94]) +}; +var XColorCoreModelToColor = { + rgb: ([r, g, b]) => Color2([r * 255, g * 255, b * 255], "rgb"), + cmy: ([c, m, y]) => XColorCoreModelToColor.rgb([1 - c, 1 - m, 1 - y]), + cmyk: ([c, m, y, k]) => Color2([c * 255, m * 255, y * 255, k * 100], "cmyk"), + hsb: ([h, s2, b]) => Color2([h * 360, s2 * 100, b * 100], "hsv"), + gray: ([v]) => Color2([v * 255, v * 255, v * 255], "rgb") +}; +({ + // Core colors + red: XColorCoreModelToColor.rgb([1, 0, 0]), + green: XColorCoreModelToColor.rgb([0, 1, 0]), + blue: XColorCoreModelToColor.rgb([0, 0, 1]), + brown: XColorCoreModelToColor.rgb([0.75, 0.5, 0.25]), + lime: XColorCoreModelToColor.rgb([0.75, 1, 0]), + orange: XColorCoreModelToColor.rgb([1, 0.5, 0]), + pink: XColorCoreModelToColor.rgb([1, 0.75, 0.75]), + purple: XColorCoreModelToColor.rgb([0.75, 0, 0.25]), + teal: XColorCoreModelToColor.rgb([0, 0.5, 0.5]), + violet: XColorCoreModelToColor.rgb([0.5, 0, 0.5]), + cyan: XColorCoreModelToColor.rgb([0, 1, 1]), + magenta: XColorCoreModelToColor.rgb([1, 0, 1]), + yellow: XColorCoreModelToColor.rgb([1, 1, 0]), + olive: XColorCoreModelToColor.rgb([0.5, 0.5, 0]), + black: XColorCoreModelToColor.rgb([0, 0, 0]), + darkgray: XColorCoreModelToColor.rgb([0.25, 0.25, 0.25]), + gray: XColorCoreModelToColor.rgb([0.5, 0.5, 0.5]), + lightgray: XColorCoreModelToColor.rgb([0.75, 0.75, 0.75]), + white: XColorCoreModelToColor.rgb([1, 1, 1]), + ...DVI_PS_NAMES, + ...SVG_NAMES, + ...X11_NAMES +}); +var macros14 = { + NewDocumentCommand: { + signature: "m m m", + renderInfo: { breakAround: true } + }, + RenewDocumentCommand: { + signature: "m m m", + renderInfo: { breakAround: true } + }, + ProvideDocumentCommand: { + signature: "m m m", + renderInfo: { breakAround: true } + }, + DeclareDocumentCommand: { + signature: "m m m", + renderInfo: { breakAround: true } + }, + NewDocumentEnvironment: { + signature: "m m m m", + renderInfo: { breakAround: true } + }, + RenewDocumentEnvironment: { + signature: "m m m m", + renderInfo: { breakAround: true } + }, + ProvideDocumentEnvironment: { + signature: "m m m m", + renderInfo: { breakAround: true } + }, + DeclareDocumentEnvironment: { + signature: "m m m m", + renderInfo: { breakAround: true } + }, + NewExpandableDocumentCommand: { + signature: "m m m", + renderInfo: { breakAround: true } + }, + RenewExpandableDocumentCommand: { + signature: "m m m", + renderInfo: { breakAround: true } + }, + ProvideExpandableDocumentCommand: { + signature: "m m m", + renderInfo: { breakAround: true } + }, + DeclareExpandableDocumentCommand: { + signature: "m m m", + renderInfo: { breakAround: true } + }, + RequirePackage: { + signature: "o m", + renderInfo: { pgfkeysArgs: true, breakAround: true } + }, + DeclareOption: { signature: "m m", renderInfo: { breakAround: true } } +}; +var environments14 = {}; +var macros15 = { + mode: { signature: "s d<> d{}", renderInfo: { breakAround: true } }, + insertnavigation: { signature: "m", renderInfo: { breakAround: true } }, + insertsectionnavigation: { + signature: "m", + renderInfo: { breakAround: true } + }, + insertsectionnavigationhorizontal: { + signature: "m m m", + renderInfo: { breakAround: true } + }, + insertauthor: { signature: "o", renderInfo: { breakAround: true } }, + insertshortauthor: { signature: "o", renderInfo: { breakAround: true } }, + insertshortdate: { signature: "o", renderInfo: { breakAround: true } }, + insertshortinstitute: { signature: "o", renderInfo: { breakAround: true } }, + insertshortpart: { signature: "o", renderInfo: { breakAround: true } }, + insertshorttitle: { signature: "o", renderInfo: { breakAround: true } }, + insertsubsectionnavigation: { + signature: "m", + renderInfo: { breakAround: true } + }, + insertsubsectionnavigationhorizontal: { + signature: "m m m", + renderInfo: { breakAround: true } + }, + insertverticalnavigation: { + signature: "m", + renderInfo: { breakAround: true } + }, + usebeamercolor: { signature: "s m", renderInfo: { breakAround: true } }, + usebeamertemplate: { signature: "s m", renderInfo: { breakAround: true } }, + setbeamercolor: { + signature: "m m", + renderInfo: { breakAround: true, pgfkeysArgs: true } + }, + setbeamersize: { + signature: "m o o", + renderInfo: { breakAround: true, pgfkeysArgs: true } + }, + setbeamertemplate: { + signature: "m o o d{}", + renderInfo: { breakAround: true, pgfkeysArgs: true } + }, + newcommand: { + signature: "s d<> +m o +o +m", + renderInfo: { + breakAround: true, + namedArguments: [ + "starred", + null, + "name", + "numArgs", + "default", + "body" + ] + } + }, + renewcommand: { + signature: "s d<> +m o +o +m", + renderInfo: { + breakAround: true, + namedArguments: [ + "starred", + null, + "name", + "numArgs", + "default", + "body" + ] + } + }, + newenvironment: { + signature: "s d<> m o o m m", + renderInfo: { breakAround: true } + }, + renewenvironment: { + signature: "s d<> m o o m m", + renderInfo: { breakAround: true } + }, + resetcounteronoverlays: { + signature: "m", + renderInfo: { breakAround: true } + }, + resetcountonoverlays: { signature: "m", renderInfo: { breakAround: true } }, + logo: { signature: "m", renderInfo: { breakAround: true } }, + frametitle: { signature: "d<> o m", renderInfo: { breakAround: true } }, + framesubtitle: { signature: "d<> m", renderInfo: { breakAround: true } }, + pause: { signature: "o" }, + onslide: { signature: "t+ t* d<> d{}" }, + only: { signature: "d<> m d<>" }, + uncover: { signature: "d<> m" }, + visible: { signature: "d<> m" }, + invisible: { signature: "d<> m" }, + alt: { signature: "d<> m m d<>" }, + temporal: { signature: "r<> m m m" }, + item: { + signature: "d<> o d<>", + renderInfo: { + hangingIndent: true, + namedArguments: [null, "label", null] + } + }, + label: { signature: "d<> o m" }, + // cleveref adds an optional argument to label; this gives maximum compatibility. + action: { signature: "d<> m" }, + beamerdefaultoverlayspecification: { signature: "m" }, + titlegraphic: { signature: "m", renderInfo: { breakAround: true } }, + subject: { signature: "m", renderInfo: { breakAround: true } }, + keywords: { signature: "m", renderInfo: { breakAround: true } }, + lecture: { signature: "o m m", renderInfo: { breakAround: true } }, + partpage: { renderInfo: { breakAround: true } }, + sectionpage: { renderInfo: { breakAround: true } }, + subsectionpage: { renderInfo: { breakAround: true } }, + AtBeginLecture: { signature: "m", renderInfo: { breakAround: true } }, + AtBeginPart: { signature: "m", renderInfo: { breakAround: true } }, + tableofcontents: { + signature: "o", + renderInfo: { breakAround: true, pgfkeysArgs: true } + }, + againframe: { signature: "d<> o o m", renderInfo: { breakAround: true } }, + framezoom: { + signature: "r<> r<> o r() r()", + renderInfo: { breakAround: true } + }, + column: { signature: "d<> o m", renderInfo: { breakAround: true } }, + animate: { signature: "r<>", renderInfo: { breakAround: true } }, + animatevalue: { signature: "r<> m m m", renderInfo: { breakAround: true } }, + sound: { + signature: "o m m", + renderInfo: { breakAround: true, pgfkeysArgs: true } + }, + hyperlinksound: { + signature: "o m m", + renderInfo: { breakAround: true, pgfkeysArgs: true } + }, + hyperlinkmute: { signature: "m", renderInfo: { breakAround: true } }, + // These signatures conflict with the default signatures. + // Care must be taken when processing an AST. + section: { + signature: "s d<> o m", + renderInfo: { + breakAround: true, + namedArguments: ["starred", null, "tocTitle", "title"] + } + }, + subsection: { + signature: "s d<> o m", + renderInfo: { + breakAround: true, + namedArguments: ["starred", null, "tocTitle", "title"] + } + }, + subsubsection: { + signature: "s d<> o m", + renderInfo: { + breakAround: true, + namedArguments: ["starred", null, "tocTitle", "title"] + } + }, + part: { + signature: "s d<> o m", + renderInfo: { + breakAround: true, + namedArguments: ["starred", null, "tocTitle", "title"] + } + }, + bibitem: { + signature: "s d<> o m", + renderInfo: { + hangingIndent: true, + namedArguments: ["starred", null, "tocTitle", "title"] + } + } +}; +var environments15 = { + frame: { + signature: "!d<> !o !o !d{} !d{}" + }, + block: { + signature: "!d<> !d{} !d<>" + }, + alertblock: { + signature: "!d<> !d{} !d<>" + }, + exampleblock: { + signature: "!d<> !d{} !d<>" + }, + onlyenv: { + signature: "!d<>" + }, + altenv: { + signature: "!d<> m m m m !d<>" + }, + overlayarea: { signature: "m m" }, + overprint: { signature: "o" }, + actionenv: { signature: "!d<>" }, + columns: { signature: "d<> o" }, + column: { signature: "d<> o m" } +}; +var macros16 = { + columnbreak: { renderInfo: { breakAround: true } } +}; +var environments16 = { + multicols: { + signature: "m o o" + }, + "multicols*": { + signature: "m o o" + } +}; +var macroInfo = { + cleveref: macros, + exam: macros2, + geometry: macros3, + hyperref: macros4, + latex2e: macros5, + listings: macros6, + makeidx: macros7, + mathtools: macros8, + minted: macros9, + nicematrix: macros10, + systeme: macros11, + tikz: macros12, + xcolor: macros13, + xparse: macros14, + beamer: macros15, + multicol: macros16 +}; +var environmentInfo = { + cleveref: environments, + exam: environments2, + geometry: environments3, + hyperref: environments4, + latex2e: environments5, + listings: environments6, + makeidx: environments7, + mathtools: environments8, + minted: environments9, + nicematrix: environments10, + systeme: environments11, + tikz: environments12, + xcolor: environments13, + xparse: environments14, + beamer: environments15, + multicol: environments16 +}; +function processEnvironment(envNode, envInfo) { + if (envInfo.signature && envNode.args == null) { + const { args } = gobbleArguments(envNode.content, envInfo.signature); + envNode.args = args; + } + updateRenderInfo(envNode, envInfo.renderInfo); + if (typeof envInfo.processContent === "function") { + envNode.content = envInfo.processContent(envNode.content); + } +} +function findRegionInArray(tree, start, end) { + const ret = []; + let currRegion = { start: void 0, end: tree.length }; + for (let i = 0; i < tree.length; i++) { + const node = tree[i]; + if (start(node)) { + currRegion.start = i; + } + if (end(node)) { + currRegion.end = i + 1; + ret.push(currRegion); + currRegion = { start: void 0, end: tree.length }; + } + } + if (currRegion.start != null) { + ret.push(currRegion); + } + return ret; +} +function refineRegions(regions) { + const _regions = [...regions]; + _regions.sort((a, b) => a.start - b.start); + const cutPointsSet = new Set(_regions.flatMap((r) => [r.start, r.end])); + const cutPoints = Array.from(cutPointsSet); + cutPoints.sort((a, b) => a - b); + const retRegions = []; + const retRegionsContainedIn = []; + let seekIndex = 0; + for (let i = 0; i < cutPoints.length - 1; i++) { + const start = cutPoints[i]; + const end = cutPoints[i + 1]; + const region = { start, end }; + const regionContainedIn = /* @__PURE__ */ new Set(); + let encounteredEndPastStart = false; + for (let j = seekIndex; j < _regions.length; j++) { + const superRegion = _regions[j]; + if (superRegion.end >= region.start) { + encounteredEndPastStart = true; + } + if (!encounteredEndPastStart && superRegion.end < region.start) { + seekIndex = j + 1; + continue; + } + if (superRegion.start > end) { + break; + } + if (superRegion.start <= region.start && superRegion.end >= region.end) { + encounteredEndPastStart = true; + regionContainedIn.add(superRegion); + } + } + if (regionContainedIn.size > 0) { + retRegions.push(region); + retRegionsContainedIn.push(regionContainedIn); + } + } + return { regions: retRegions, regionsContainedIn: retRegionsContainedIn }; +} +function splitByRegions(array, regionsRecord) { + const ret = []; + const indices = [0, array.length]; + const reverseMap = {}; + for (const [key, records] of Object.entries(regionsRecord)) { + indices.push( + ...records.flatMap((r) => { + reverseMap["" + [r.start, r.end]] = key; + return [r.start, r.end]; + }) + ); + } + indices.sort((a, b) => a - b); + for (let i = 0; i < indices.length - 1; i++) { + const start = indices[i]; + const end = indices[i + 1]; + if (start === end) { + continue; + } + const regionKey = reverseMap["" + [start, end]]; + ret.push([regionKey || null, array.slice(start, end)]); + } + return ret; +} +function escapeRegExp(str) { + return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"); +} +function buildWordRegex(allowedSet) { + const regexpStr = `^(${["\\p{L}"].concat(Array.from(allowedSet).map(escapeRegExp)).join("|")})*`; + return new RegExp(regexpStr, "u"); +} +function hasReparsableMacroNamesInArray(tree, allowedTokens) { + for (let i = 0; i < tree.length; i++) { + const macro = tree[i]; + const string = tree[i + 1]; + if (match.anyMacro(macro) && match.anyString(string)) { + if (allowedTokens.has( + macro.content.charAt(macro.content.length - 1) + ) || allowedTokens.has(string.content.charAt(0))) { + return true; + } + } + } + return false; +} +function hasReparsableMacroNames(tree, allowedTokens) { + if (typeof allowedTokens === "string") { + allowedTokens = new Set(allowedTokens.split("")); + } + const _allowedTokens = allowedTokens; + for (const v of _allowedTokens) { + if (v.length > 1) { + throw new Error( + `Only single characters are allowed as \`allowedTokens\` when reparsing macro names, not \`${v}\`.` + ); + } + } + let ret = false; + visit( + tree, + (nodes) => { + if (hasReparsableMacroNamesInArray(nodes, _allowedTokens)) { + ret = true; + return EXIT; + } + }, + { includeArrays: true, test: Array.isArray } + ); + return ret; +} +function reparseMacroNamesInArray(tree, allowedTokens) { + var _a, _b, _c; + const regex = buildWordRegex(allowedTokens); + let i = 0; + while (i < tree.length) { + const macro = tree[i]; + const string = tree[i + 1]; + if (match.anyMacro(macro) && // The _^ macros in math mode should not be extended no-matter what; + // So we check to make sure that the macro we're dealing with has the default escape token. + (macro.escapeToken == null || macro.escapeToken === "\\") && match.anyString(string) && // There are two options. Either the macro ends with the special character, + // e.g. `\@foo` or the special character starts the next string, e.g. `\foo@`. + (allowedTokens.has( + macro.content.charAt(macro.content.length - 1) + ) || allowedTokens.has(string.content.charAt(0)))) { + const match3 = string.content.match(regex); + const takeable = match3 ? match3[0] : ""; + if (takeable.length > 0) { + if (takeable.length === string.content.length) { + macro.content += string.content; + tree.splice(i + 1, 1); + if (macro.position && ((_a = string.position) == null ? void 0 : _a.end)) { + macro.position.end = string.position.end; + } + } else { + macro.content += takeable; + string.content = string.content.slice(takeable.length); + if ((_b = macro.position) == null ? void 0 : _b.end) { + macro.position.end.offset += takeable.length; + macro.position.end.column += takeable.length; + } + if ((_c = string.position) == null ? void 0 : _c.start) { + string.position.start.offset += takeable.length; + string.position.start.column += takeable.length; + } + } + } else { + i++; + } + } else { + ++i; + } + } +} +function reparseMacroNames(tree, allowedTokens) { + if (typeof allowedTokens === "string") { + allowedTokens = new Set(allowedTokens.split("")); + } + const _allowedTokens = allowedTokens; + for (const v of _allowedTokens) { + if (v.length > 1) { + throw new Error( + `Only single characters are allowed as \`allowedTokens\` when reparsing macro names, not \`${v}\`.` + ); + } + } + visit( + tree, + (nodes) => { + reparseMacroNamesInArray(nodes, _allowedTokens); + }, + { includeArrays: true, test: Array.isArray } + ); +} +var expl3Find = { + start: match.createMacroMatcher(["ExplSyntaxOn"]), + end: match.createMacroMatcher(["ExplSyntaxOff"]) +}; +var atLetterFind = { + start: match.createMacroMatcher(["makeatletter"]), + end: match.createMacroMatcher(["makeatother"]) +}; +function findExpl3AndAtLetterRegionsInArray(tree) { + const expl3 = findRegionInArray(tree, expl3Find.start, expl3Find.end); + const atLetter = findRegionInArray( + tree, + atLetterFind.start, + atLetterFind.end + ); + const regionMap = new Map([ + ...expl3.map((x) => [x, "expl"]), + ...atLetter.map((x) => [x, "atLetter"]) + ]); + const all = refineRegions([...expl3, ...atLetter]); + const ret = { + explOnly: [], + atLetterOnly: [], + both: [] + }; + for (let i = 0; i < all.regions.length; i++) { + const region = all.regions[i]; + const containedIn = all.regionsContainedIn[i]; + if (containedIn.size === 2) { + ret.both.push(region); + continue; + } + for (const v of containedIn.values()) { + if (regionMap.get(v) === "expl") { + ret.explOnly.push(region); + } + if (regionMap.get(v) === "atLetter") { + ret.atLetterOnly.push(region); + } + } + } + ret.explOnly = ret.explOnly.filter((r) => r.end - r.start > 1); + ret.atLetterOnly = ret.atLetterOnly.filter((r) => r.end - r.start > 1); + ret.both = ret.both.filter((r) => r.end - r.start > 1); + return ret; +} +var atLetterSet = /* @__PURE__ */ new Set(["@"]); +var explSet = /* @__PURE__ */ new Set(["_", ":"]); +var bothSet = /* @__PURE__ */ new Set(["_", ":", "@"]); +function reparseExpl3AndAtLetterRegions(tree) { + visit( + tree, + { + leave: (nodes) => { + const regions = findExpl3AndAtLetterRegionsInArray(nodes); + const totalNumRegions = regions.both.length + regions.atLetterOnly.length + regions.explOnly.length; + if (totalNumRegions === 0) { + return; + } + const splits = splitByRegions(nodes, regions); + const processed = []; + for (const [key, slice2] of splits) { + switch (key) { + case null: + processed.push(...slice2); + continue; + case "atLetterOnly": + reparseMacroNames(slice2, atLetterSet); + processed.push(...slice2); + continue; + case "explOnly": + reparseMacroNames(slice2, explSet); + processed.push(...slice2); + continue; + case "both": + reparseMacroNames(slice2, bothSet); + processed.push(...slice2); + continue; + default: + throw new Error( + `Unexpected case when splitting ${key}` + ); + } + } + nodes.length = 0; + nodes.push(...processed); + return SKIP; + } + }, + { includeArrays: true, test: Array.isArray } + ); +} +var unifiedLatexAstComplier = function unifiedLatexAstComplier2() { + Object.assign(this, { Compiler: (x) => x }); +}; +function parseMinimal(str) { + return LatexPegParser.parse(str); +} +function parseMathMinimal(str) { + return LatexPegParser.parse(str, { startRule: "math" }); +} +var unifiedLatexFromStringMinimal = function unifiedLatexFromStringMinimal2(options2) { + const parser2 = (str) => { + if ((options2 == null ? void 0 : options2.mode) === "math") { + return { + type: "root", + content: parseMathMinimal(str), + _renderInfo: { inMathMode: true } + }; + } + return parseMinimal(str); + }; + Object.assign(this, { Parser: parser2 }); +}; +function unifiedLatexReparseMathConstructPlugin({ + mathEnvs, + mathMacros +}) { + const isMathEnvironment = match.createEnvironmentMatcher(mathEnvs); + const isMathMacro = match.createMacroMatcher(mathMacros); + return (tree) => { + visit( + tree, + (node) => { + if (match.anyMacro(node)) { + for (const arg2 of node.args || []) { + if (arg2.content.length > 0 && !wasParsedInMathMode(arg2.content)) { + arg2.content = parseMathMinimal( + printRaw(arg2.content) + ); + } + } + } + if (match.anyEnvironment(node)) { + if (!wasParsedInMathMode(node.content)) { + node.content = parseMathMinimal(printRaw(node.content)); + } + } + }, + { + test: (node) => isMathEnvironment(node) || isMathMacro(node) + } + ); + }; +} +function wasParsedInMathMode(nodes) { + return !nodes.some( + (node) => ( + // If there are multi-char strings or ^ and _ have been parsed as strings, we know + // that we were not parsed in math mode. + match.anyString(node) && node.content.length > 1 || match.string(node, "^") || match.string(node, "_") + ) + ); +} +var unifiedLatexProcessMacrosAndEnvironmentsWithMathReparse = function unifiedLatexProcessMacrosAndEnvironmentsWithMathReparse2(options2) { + const { environments: environments17 = {}, macros: macros17 = {} } = options2 || {}; + const mathMacros = Object.fromEntries( + Object.entries(macros17).filter( + ([_, info]) => { + var _a; + return ((_a = info.renderInfo) == null ? void 0 : _a.inMathMode) === true; + } + ) + ); + const mathEnvs = Object.fromEntries( + Object.entries(environments17).filter( + ([_, info]) => { + var _a; + return ((_a = info.renderInfo) == null ? void 0 : _a.inMathMode) === true; + } + ) + ); + const mathReparser = unifiedLatexReparseMathConstructPlugin({ + mathEnvs: Object.keys(mathEnvs), + mathMacros: Object.keys(mathMacros) + }); + const isRelevantEnvironment = match.createEnvironmentMatcher(environments17); + const isRelevantMathEnvironment = match.createEnvironmentMatcher(mathEnvs); + return (tree) => { + visit( + tree, + { + enter: (nodes) => { + if (!Array.isArray(nodes)) { + return; + } + attachMacroArgsInArray(nodes, mathMacros); + }, + leave: (node) => { + if (!isRelevantMathEnvironment(node)) { + return; + } + const envName = printRaw(node.env); + const envInfo = environments17[envName]; + if (!envInfo) { + throw new Error( + `Could not find environment info for environment "${envName}"` + ); + } + processEnvironment(node, envInfo); + } + }, + { includeArrays: true } + ); + mathReparser(tree); + visit( + tree, + { + enter: (nodes) => { + if (!Array.isArray(nodes)) { + return; + } + attachMacroArgsInArray(nodes, macros17); + }, + leave: (node) => { + if (!isRelevantEnvironment(node)) { + return; + } + const envName = printRaw(node.env); + const envInfo = environments17[envName]; + if (!envInfo) { + throw new Error( + `Could not find environment info for environment "${envName}"` + ); + } + processEnvironment(node, envInfo); + } + }, + { includeArrays: true } + ); + }; +}; +var unifiedLatexProcessAtLetterAndExplMacros = function unifiedLatexProcessAtLetterAndExplMacros2(options2) { + let { + atLetter = false, + expl3 = false, + autodetectExpl3AndAtLetter = false + } = options2 || {}; + return (tree) => { + reparseExpl3AndAtLetterRegions(tree); + if (atLetter || expl3) { + autodetectExpl3AndAtLetter = false; + } + if (autodetectExpl3AndAtLetter) { + atLetter = hasReparsableMacroNames(tree, "@"); + expl3 = hasReparsableMacroNames(tree, "_"); + } + const charSet = /* @__PURE__ */ new Set(); + if (atLetter) { + charSet.add("@"); + } + if (expl3) { + charSet.add(":"); + charSet.add("_"); + } + if (charSet.size > 0) { + reparseMacroNames(tree, charSet); + } + }; +}; +var unifiedLatexFromString = function unifiedLatexFromString2(options2) { + const { + mode = "regular", + macros: macros17 = {}, + environments: environments17 = {}, + flags: { + atLetter = false, + expl3 = false, + autodetectExpl3AndAtLetter = false + } = {} + } = options2 || {}; + const allMacroInfo = Object.assign( + {}, + ...Object.values(macroInfo), + macros17 + ); + const allEnvInfo = Object.assign( + {}, + ...Object.values(environmentInfo), + environments17 + ); + const fullParser = unified().use(unifiedLatexFromStringMinimal, { mode }).use(unifiedLatexProcessAtLetterAndExplMacros, { + atLetter, + expl3, + autodetectExpl3AndAtLetter + }).use(unifiedLatexProcessMacrosAndEnvironmentsWithMathReparse, { + macros: allMacroInfo, + environments: allEnvInfo + }).use(unifiedLatexTrimEnvironmentContents).use(unifiedLatexTrimRoot).use(unifiedLatexAstComplier); + const parser2 = (str) => { + const file = fullParser.processSync({ value: str }); + return file.result; + }; + Object.assign(this, { Parser: parser2 }); +}; +var parser = unified().use(unifiedLatexFromString).freeze(); +function parse(str) { + return parser.parse(str); +} +var __accessCheck = (obj, member, msg) => { + if (!member.has(obj)) + throw TypeError("Cannot " + msg); +}; +var __privateGet = (obj, member, getter) => { + __accessCheck(obj, member, "read from private field"); + return getter ? getter.call(obj) : member.get(obj); +}; +var __privateAdd = (obj, member, value) => { + if (member.has(obj)) + throw TypeError("Cannot add the same private member more than once"); + member instanceof WeakSet ? member.add(obj) : member.set(obj, value); +}; +var __privateSet = (obj, member, value, setter) => { + __accessCheck(obj, member, "write to private field"); + setter ? setter.call(obj, value) : member.set(obj, value); + return value; +}; +var __defProp2 = Object.defineProperty; +var __export = (target, all) => { + for (var name in all) + __defProp2(target, name, { get: all[name], enumerable: true }); +}; +var public_exports = {}; +__export(public_exports, { + builders: () => builders, + printer: () => printer, + utils: () => utils +}); +var DOC_TYPE_STRING = "string"; +var DOC_TYPE_ARRAY = "array"; +var DOC_TYPE_CURSOR = "cursor"; +var DOC_TYPE_INDENT = "indent"; +var DOC_TYPE_ALIGN = "align"; +var DOC_TYPE_TRIM = "trim"; +var DOC_TYPE_GROUP = "group"; +var DOC_TYPE_FILL = "fill"; +var DOC_TYPE_IF_BREAK = "if-break"; +var DOC_TYPE_INDENT_IF_BREAK = "indent-if-break"; +var DOC_TYPE_LINE_SUFFIX = "line-suffix"; +var DOC_TYPE_LINE_SUFFIX_BOUNDARY = "line-suffix-boundary"; +var DOC_TYPE_LINE = "line"; +var DOC_TYPE_LABEL = "label"; +var DOC_TYPE_BREAK_PARENT = "break-parent"; +var VALID_OBJECT_DOC_TYPES = /* @__PURE__ */ new Set([ + DOC_TYPE_CURSOR, + DOC_TYPE_INDENT, + DOC_TYPE_ALIGN, + DOC_TYPE_TRIM, + DOC_TYPE_GROUP, + DOC_TYPE_FILL, + DOC_TYPE_IF_BREAK, + DOC_TYPE_INDENT_IF_BREAK, + DOC_TYPE_LINE_SUFFIX, + DOC_TYPE_LINE_SUFFIX_BOUNDARY, + DOC_TYPE_LINE, + DOC_TYPE_LABEL, + DOC_TYPE_BREAK_PARENT +]); +function getDocType(doc) { + if (typeof doc === "string") { + return DOC_TYPE_STRING; + } + if (Array.isArray(doc)) { + return DOC_TYPE_ARRAY; + } + if (!doc) { + return; + } + const { type } = doc; + if (VALID_OBJECT_DOC_TYPES.has(type)) { + return type; + } +} +var get_doc_type_default = getDocType; +var disjunctionListFormat = (list) => new Intl.ListFormat("en-US", { type: "disjunction" }).format(list); +function getDocErrorMessage(doc) { + const type = doc === null ? "null" : typeof doc; + if (type !== "string" && type !== "object") { + return `Unexpected doc '${type}', +Expected it to be 'string' or 'object'.`; + } + if (get_doc_type_default(doc)) { + throw new Error("doc is valid."); + } + const objectType = Object.prototype.toString.call(doc); + if (objectType !== "[object Object]") { + return `Unexpected doc '${objectType}'.`; + } + const EXPECTED_TYPE_VALUES = disjunctionListFormat( + [...VALID_OBJECT_DOC_TYPES].map((type2) => `'${type2}'`) + ); + return `Unexpected doc.type '${doc.type}'. +Expected it to be ${EXPECTED_TYPE_VALUES}.`; +} +var InvalidDocError = class extends Error { + constructor(doc) { + super(getDocErrorMessage(doc)); + __publicField(this, "name", "InvalidDocError"); + this.doc = doc; + } +}; +var invalid_doc_error_default = InvalidDocError; +var traverseDocOnExitStackMarker = {}; +function traverseDoc(doc, onEnter, onExit, shouldTraverseConditionalGroups) { + const docsStack = [doc]; + while (docsStack.length > 0) { + const doc2 = docsStack.pop(); + if (doc2 === traverseDocOnExitStackMarker) { + onExit(docsStack.pop()); + continue; + } + if (onExit) { + docsStack.push(doc2, traverseDocOnExitStackMarker); + } + const docType = get_doc_type_default(doc2); + if (!docType) { + throw new invalid_doc_error_default(doc2); + } + if ((onEnter == null ? void 0 : onEnter(doc2)) === false) { + continue; + } + switch (docType) { + case DOC_TYPE_ARRAY: + case DOC_TYPE_FILL: { + const parts = docType === DOC_TYPE_ARRAY ? doc2 : doc2.parts; + for (let ic = parts.length, i = ic - 1; i >= 0; --i) { + docsStack.push(parts[i]); + } + break; + } + case DOC_TYPE_IF_BREAK: + docsStack.push(doc2.flatContents, doc2.breakContents); + break; + case DOC_TYPE_GROUP: + if (shouldTraverseConditionalGroups && doc2.expandedStates) { + for (let ic = doc2.expandedStates.length, i = ic - 1; i >= 0; --i) { + docsStack.push(doc2.expandedStates[i]); + } + } else { + docsStack.push(doc2.contents); + } + break; + case DOC_TYPE_ALIGN: + case DOC_TYPE_INDENT: + case DOC_TYPE_INDENT_IF_BREAK: + case DOC_TYPE_LABEL: + case DOC_TYPE_LINE_SUFFIX: + docsStack.push(doc2.contents); + break; + case DOC_TYPE_STRING: + case DOC_TYPE_CURSOR: + case DOC_TYPE_TRIM: + case DOC_TYPE_LINE_SUFFIX_BOUNDARY: + case DOC_TYPE_LINE: + case DOC_TYPE_BREAK_PARENT: + break; + default: + throw new invalid_doc_error_default(doc2); + } + } +} +var traverse_doc_default = traverseDoc; +var noop = () => { +}; +var assertDocArray = noop; +function indent(contents) { + return { type: DOC_TYPE_INDENT, contents }; +} +function align(widthOrString, contents) { + return { type: DOC_TYPE_ALIGN, contents, n: widthOrString }; +} +function group(contents, opts = {}) { + assertDocArray( + opts.expandedStates + ); + return { + type: DOC_TYPE_GROUP, + id: opts.id, + contents, + break: Boolean(opts.shouldBreak), + expandedStates: opts.expandedStates + }; +} +function dedentToRoot(contents) { + return align(Number.NEGATIVE_INFINITY, contents); +} +function markAsRoot(contents) { + return align({ type: "root" }, contents); +} +function dedent(contents) { + return align(-1, contents); +} +function conditionalGroup(states, opts) { + return group(states[0], { ...opts, expandedStates: states }); +} +function fill(parts) { + return { type: DOC_TYPE_FILL, parts }; +} +function ifBreak(breakContents, flatContents = "", opts = {}) { + return { + type: DOC_TYPE_IF_BREAK, + breakContents, + flatContents, + groupId: opts.groupId + }; +} +function indentIfBreak(contents, opts) { + return { + type: DOC_TYPE_INDENT_IF_BREAK, + contents, + groupId: opts.groupId, + negate: opts.negate + }; +} +function lineSuffix(contents) { + return { type: DOC_TYPE_LINE_SUFFIX, contents }; +} +var lineSuffixBoundary = { type: DOC_TYPE_LINE_SUFFIX_BOUNDARY }; +var breakParent = { type: DOC_TYPE_BREAK_PARENT }; +var trim = { type: DOC_TYPE_TRIM }; +var hardlineWithoutBreakParent = { type: DOC_TYPE_LINE, hard: true }; +var literallineWithoutBreakParent = { + type: DOC_TYPE_LINE, + hard: true, + literal: true +}; +var line = { type: DOC_TYPE_LINE }; +var softline = { type: DOC_TYPE_LINE, soft: true }; +var hardline = [hardlineWithoutBreakParent, breakParent]; +var literalline = [literallineWithoutBreakParent, breakParent]; +var cursor = { type: DOC_TYPE_CURSOR }; +function join(separator, docs) { + const parts = []; + for (let i = 0; i < docs.length; i++) { + if (i !== 0) { + parts.push(separator); + } + parts.push(docs[i]); + } + return parts; +} +function addAlignmentToDoc(doc, size, tabWidth) { + let aligned = doc; + if (size > 0) { + for (let i = 0; i < Math.floor(size / tabWidth); ++i) { + aligned = indent(aligned); + } + aligned = align(size % tabWidth, aligned); + aligned = align(Number.NEGATIVE_INFINITY, aligned); + } + return aligned; +} +function label(label2, contents) { + return label2 ? { type: DOC_TYPE_LABEL, label: label2, contents } : contents; +} +var at = (isOptionalObject, object, index2) => { + if (isOptionalObject && (object === void 0 || object === null)) { + return; + } + if (Array.isArray(object) || typeof object === "string") { + return object[index2 < 0 ? object.length + index2 : index2]; + } + return object.at(index2); +}; +var at_default = at; +var stringReplaceAll = (isOptionalObject, original, pattern, replacement) => { + if (isOptionalObject && (original === void 0 || original === null)) { + return; + } + if (original.replaceAll) { + return original.replaceAll(pattern, replacement); + } + if (pattern.global) { + return original.replace(pattern, replacement); + } + return original.split(pattern).join(replacement); +}; +var string_replace_all_default = stringReplaceAll; +function convertEndOfLineToChars(value) { + switch (value) { + case "cr": + return "\r"; + case "crlf": + return "\r\n"; + default: + return "\n"; + } +} +var emoji_regex_default = () => { + return /[#*0-9]\uFE0F?\u20E3|[\xA9\xAE\u203C\u2049\u2122\u2139\u2194-\u2199\u21A9\u21AA\u231A\u231B\u2328\u23CF\u23ED-\u23EF\u23F1\u23F2\u23F8-\u23FA\u24C2\u25AA\u25AB\u25B6\u25C0\u25FB\u25FC\u25FE\u2600-\u2604\u260E\u2611\u2614\u2615\u2618\u2620\u2622\u2623\u2626\u262A\u262E\u262F\u2638-\u263A\u2640\u2642\u2648-\u2653\u265F\u2660\u2663\u2665\u2666\u2668\u267B\u267E\u267F\u2692\u2694-\u2697\u2699\u269B\u269C\u26A0\u26A7\u26AA\u26B0\u26B1\u26BD\u26BE\u26C4\u26C8\u26CF\u26D1\u26D3\u26E9\u26F0-\u26F5\u26F7\u26F8\u26FA\u2702\u2708\u2709\u270F\u2712\u2714\u2716\u271D\u2721\u2733\u2734\u2744\u2747\u2757\u2763\u27A1\u2934\u2935\u2B05-\u2B07\u2B1B\u2B1C\u2B55\u3030\u303D\u3297\u3299]\uFE0F?|[\u261D\u270C\u270D](?:\uFE0F|\uD83C[\uDFFB-\uDFFF])?|[\u270A\u270B](?:\uD83C[\uDFFB-\uDFFF])?|[\u23E9-\u23EC\u23F0\u23F3\u25FD\u2693\u26A1\u26AB\u26C5\u26CE\u26D4\u26EA\u26FD\u2705\u2728\u274C\u274E\u2753-\u2755\u2795-\u2797\u27B0\u27BF\u2B50]|\u26F9(?:\uFE0F|\uD83C[\uDFFB-\uDFFF])?(?:\u200D[\u2640\u2642]\uFE0F?)?|\u2764\uFE0F?(?:\u200D(?:\uD83D\uDD25|\uD83E\uDE79))?|\uD83C(?:[\uDC04\uDD70\uDD71\uDD7E\uDD7F\uDE02\uDE37\uDF21\uDF24-\uDF2C\uDF36\uDF7D\uDF96\uDF97\uDF99-\uDF9B\uDF9E\uDF9F\uDFCD\uDFCE\uDFD4-\uDFDF\uDFF5\uDFF7]\uFE0F?|[\uDF85\uDFC2\uDFC7](?:\uD83C[\uDFFB-\uDFFF])?|[\uDFC3\uDFC4\uDFCA](?:\uD83C[\uDFFB-\uDFFF])?(?:\u200D[\u2640\u2642]\uFE0F?)?|[\uDFCB\uDFCC](?:\uFE0F|\uD83C[\uDFFB-\uDFFF])?(?:\u200D[\u2640\u2642]\uFE0F?)?|[\uDCCF\uDD8E\uDD91-\uDD9A\uDE01\uDE1A\uDE2F\uDE32-\uDE36\uDE38-\uDE3A\uDE50\uDE51\uDF00-\uDF20\uDF2D-\uDF35\uDF37-\uDF7C\uDF7E-\uDF84\uDF86-\uDF93\uDFA0-\uDFC1\uDFC5\uDFC6\uDFC8\uDFC9\uDFCF-\uDFD3\uDFE0-\uDFF0\uDFF8-\uDFFF]|\uDDE6\uD83C[\uDDE8-\uDDEC\uDDEE\uDDF1\uDDF2\uDDF4\uDDF6-\uDDFA\uDDFC\uDDFD\uDDFF]|\uDDE7\uD83C[\uDDE6\uDDE7\uDDE9-\uDDEF\uDDF1-\uDDF4\uDDF6-\uDDF9\uDDFB\uDDFC\uDDFE\uDDFF]|\uDDE8\uD83C[\uDDE6\uDDE8\uDDE9\uDDEB-\uDDEE\uDDF0-\uDDF5\uDDF7\uDDFA-\uDDFF]|\uDDE9\uD83C[\uDDEA\uDDEC\uDDEF\uDDF0\uDDF2\uDDF4\uDDFF]|\uDDEA\uD83C[\uDDE6\uDDE8\uDDEA\uDDEC\uDDED\uDDF7-\uDDFA]|\uDDEB\uD83C[\uDDEE-\uDDF0\uDDF2\uDDF4\uDDF7]|\uDDEC\uD83C[\uDDE6\uDDE7\uDDE9-\uDDEE\uDDF1-\uDDF3\uDDF5-\uDDFA\uDDFC\uDDFE]|\uDDED\uD83C[\uDDF0\uDDF2\uDDF3\uDDF7\uDDF9\uDDFA]|\uDDEE\uD83C[\uDDE8-\uDDEA\uDDF1-\uDDF4\uDDF6-\uDDF9]|\uDDEF\uD83C[\uDDEA\uDDF2\uDDF4\uDDF5]|\uDDF0\uD83C[\uDDEA\uDDEC-\uDDEE\uDDF2\uDDF3\uDDF5\uDDF7\uDDFC\uDDFE\uDDFF]|\uDDF1\uD83C[\uDDE6-\uDDE8\uDDEE\uDDF0\uDDF7-\uDDFB\uDDFE]|\uDDF2\uD83C[\uDDE6\uDDE8-\uDDED\uDDF0-\uDDFF]|\uDDF3\uD83C[\uDDE6\uDDE8\uDDEA-\uDDEC\uDDEE\uDDF1\uDDF4\uDDF5\uDDF7\uDDFA\uDDFF]|\uDDF4\uD83C\uDDF2|\uDDF5\uD83C[\uDDE6\uDDEA-\uDDED\uDDF0-\uDDF3\uDDF7-\uDDF9\uDDFC\uDDFE]|\uDDF6\uD83C\uDDE6|\uDDF7\uD83C[\uDDEA\uDDF4\uDDF8\uDDFA\uDDFC]|\uDDF8\uD83C[\uDDE6-\uDDEA\uDDEC-\uDDF4\uDDF7-\uDDF9\uDDFB\uDDFD-\uDDFF]|\uDDF9\uD83C[\uDDE6\uDDE8\uDDE9\uDDEB-\uDDED\uDDEF-\uDDF4\uDDF7\uDDF9\uDDFB\uDDFC\uDDFF]|\uDDFA\uD83C[\uDDE6\uDDEC\uDDF2\uDDF3\uDDF8\uDDFE\uDDFF]|\uDDFB\uD83C[\uDDE6\uDDE8\uDDEA\uDDEC\uDDEE\uDDF3\uDDFA]|\uDDFC\uD83C[\uDDEB\uDDF8]|\uDDFD\uD83C\uDDF0|\uDDFE\uD83C[\uDDEA\uDDF9]|\uDDFF\uD83C[\uDDE6\uDDF2\uDDFC]|\uDFF3\uFE0F?(?:\u200D(?:\u26A7\uFE0F?|\uD83C\uDF08))?|\uDFF4(?:\u200D\u2620\uFE0F?|\uDB40\uDC67\uDB40\uDC62\uDB40(?:\uDC65\uDB40\uDC6E\uDB40\uDC67|\uDC73\uDB40\uDC63\uDB40\uDC74|\uDC77\uDB40\uDC6C\uDB40\uDC73)\uDB40\uDC7F)?)|\uD83D(?:[\uDC08\uDC26](?:\u200D\u2B1B)?|[\uDC3F\uDCFD\uDD49\uDD4A\uDD6F\uDD70\uDD73\uDD76-\uDD79\uDD87\uDD8A-\uDD8D\uDDA5\uDDA8\uDDB1\uDDB2\uDDBC\uDDC2-\uDDC4\uDDD1-\uDDD3\uDDDC-\uDDDE\uDDE1\uDDE3\uDDE8\uDDEF\uDDF3\uDDFA\uDECB\uDECD-\uDECF\uDEE0-\uDEE5\uDEE9\uDEF0\uDEF3]\uFE0F?|[\uDC42\uDC43\uDC46-\uDC50\uDC66\uDC67\uDC6B-\uDC6D\uDC72\uDC74-\uDC76\uDC78\uDC7C\uDC83\uDC85\uDC8F\uDC91\uDCAA\uDD7A\uDD95\uDD96\uDE4C\uDE4F\uDEC0\uDECC](?:\uD83C[\uDFFB-\uDFFF])?|[\uDC6E\uDC70\uDC71\uDC73\uDC77\uDC81\uDC82\uDC86\uDC87\uDE45-\uDE47\uDE4B\uDE4D\uDE4E\uDEA3\uDEB4-\uDEB6](?:\uD83C[\uDFFB-\uDFFF])?(?:\u200D[\u2640\u2642]\uFE0F?)?|[\uDD74\uDD90](?:\uFE0F|\uD83C[\uDFFB-\uDFFF])?|[\uDC00-\uDC07\uDC09-\uDC14\uDC16-\uDC25\uDC27-\uDC3A\uDC3C-\uDC3E\uDC40\uDC44\uDC45\uDC51-\uDC65\uDC6A\uDC79-\uDC7B\uDC7D-\uDC80\uDC84\uDC88-\uDC8E\uDC90\uDC92-\uDCA9\uDCAB-\uDCFC\uDCFF-\uDD3D\uDD4B-\uDD4E\uDD50-\uDD67\uDDA4\uDDFB-\uDE2D\uDE2F-\uDE34\uDE37-\uDE44\uDE48-\uDE4A\uDE80-\uDEA2\uDEA4-\uDEB3\uDEB7-\uDEBF\uDEC1-\uDEC5\uDED0-\uDED2\uDED5-\uDED7\uDEDC-\uDEDF\uDEEB\uDEEC\uDEF4-\uDEFC\uDFE0-\uDFEB\uDFF0]|\uDC15(?:\u200D\uD83E\uDDBA)?|\uDC3B(?:\u200D\u2744\uFE0F?)?|\uDC41\uFE0F?(?:\u200D\uD83D\uDDE8\uFE0F?)?|\uDC68(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:\uDC8B\u200D\uD83D)?\uDC68|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D(?:[\uDC68\uDC69]\u200D\uD83D(?:\uDC66(?:\u200D\uD83D\uDC66)?|\uDC67(?:\u200D\uD83D[\uDC66\uDC67])?)|[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uDC66(?:\u200D\uD83D\uDC66)?|\uDC67(?:\u200D\uD83D[\uDC66\uDC67])?)|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\uD83C(?:\uDFFB(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:\uDC8B\u200D\uD83D)?\uDC68\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF-\uDDB3\uDDBC\uDDBD]|\uDD1D\u200D\uD83D\uDC68\uD83C[\uDFFC-\uDFFF])))?|\uDFFC(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:\uDC8B\u200D\uD83D)?\uDC68\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF-\uDDB3\uDDBC\uDDBD]|\uDD1D\u200D\uD83D\uDC68\uD83C[\uDFFB\uDFFD-\uDFFF])))?|\uDFFD(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:\uDC8B\u200D\uD83D)?\uDC68\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF-\uDDB3\uDDBC\uDDBD]|\uDD1D\u200D\uD83D\uDC68\uD83C[\uDFFB\uDFFC\uDFFE\uDFFF])))?|\uDFFE(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:\uDC8B\u200D\uD83D)?\uDC68\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF-\uDDB3\uDDBC\uDDBD]|\uDD1D\u200D\uD83D\uDC68\uD83C[\uDFFB-\uDFFD\uDFFF])))?|\uDFFF(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:\uDC8B\u200D\uD83D)?\uDC68\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF-\uDDB3\uDDBC\uDDBD]|\uDD1D\u200D\uD83D\uDC68\uD83C[\uDFFB-\uDFFE])))?))?|\uDC69(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:\uDC8B\u200D\uD83D)?[\uDC68\uDC69]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D(?:[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uDC66(?:\u200D\uD83D\uDC66)?|\uDC67(?:\u200D\uD83D[\uDC66\uDC67])?|\uDC69\u200D\uD83D(?:\uDC66(?:\u200D\uD83D\uDC66)?|\uDC67(?:\u200D\uD83D[\uDC66\uDC67])?))|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\uD83C(?:\uDFFB(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:[\uDC68\uDC69]|\uDC8B\u200D\uD83D[\uDC68\uDC69])\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF-\uDDB3\uDDBC\uDDBD]|\uDD1D\u200D\uD83D[\uDC68\uDC69]\uD83C[\uDFFC-\uDFFF])))?|\uDFFC(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:[\uDC68\uDC69]|\uDC8B\u200D\uD83D[\uDC68\uDC69])\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF-\uDDB3\uDDBC\uDDBD]|\uDD1D\u200D\uD83D[\uDC68\uDC69]\uD83C[\uDFFB\uDFFD-\uDFFF])))?|\uDFFD(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:[\uDC68\uDC69]|\uDC8B\u200D\uD83D[\uDC68\uDC69])\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF-\uDDB3\uDDBC\uDDBD]|\uDD1D\u200D\uD83D[\uDC68\uDC69]\uD83C[\uDFFB\uDFFC\uDFFE\uDFFF])))?|\uDFFE(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:[\uDC68\uDC69]|\uDC8B\u200D\uD83D[\uDC68\uDC69])\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF-\uDDB3\uDDBC\uDDBD]|\uDD1D\u200D\uD83D[\uDC68\uDC69]\uD83C[\uDFFB-\uDFFD\uDFFF])))?|\uDFFF(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:[\uDC68\uDC69]|\uDC8B\u200D\uD83D[\uDC68\uDC69])\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF-\uDDB3\uDDBC\uDDBD]|\uDD1D\u200D\uD83D[\uDC68\uDC69]\uD83C[\uDFFB-\uDFFE])))?))?|\uDC6F(?:\u200D[\u2640\u2642]\uFE0F?)?|\uDD75(?:\uFE0F|\uD83C[\uDFFB-\uDFFF])?(?:\u200D[\u2640\u2642]\uFE0F?)?|\uDE2E(?:\u200D\uD83D\uDCA8)?|\uDE35(?:\u200D\uD83D\uDCAB)?|\uDE36(?:\u200D\uD83C\uDF2B\uFE0F?)?)|\uD83E(?:[\uDD0C\uDD0F\uDD18-\uDD1F\uDD30-\uDD34\uDD36\uDD77\uDDB5\uDDB6\uDDBB\uDDD2\uDDD3\uDDD5\uDEC3-\uDEC5\uDEF0\uDEF2-\uDEF8](?:\uD83C[\uDFFB-\uDFFF])?|[\uDD26\uDD35\uDD37-\uDD39\uDD3D\uDD3E\uDDB8\uDDB9\uDDCD-\uDDCF\uDDD4\uDDD6-\uDDDD](?:\uD83C[\uDFFB-\uDFFF])?(?:\u200D[\u2640\u2642]\uFE0F?)?|[\uDDDE\uDDDF](?:\u200D[\u2640\u2642]\uFE0F?)?|[\uDD0D\uDD0E\uDD10-\uDD17\uDD20-\uDD25\uDD27-\uDD2F\uDD3A\uDD3F-\uDD45\uDD47-\uDD76\uDD78-\uDDB4\uDDB7\uDDBA\uDDBC-\uDDCC\uDDD0\uDDE0-\uDDFF\uDE70-\uDE7C\uDE80-\uDE88\uDE90-\uDEBD\uDEBF-\uDEC2\uDECE-\uDEDB\uDEE0-\uDEE8]|\uDD3C(?:\u200D[\u2640\u2642]\uFE0F?|\uD83C[\uDFFB-\uDFFF])?|\uDDD1(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\uD83C[\uDF3E\uDF73\uDF7C\uDF84\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF-\uDDB3\uDDBC\uDDBD]|\uDD1D\u200D\uD83E\uDDD1))|\uD83C(?:\uDFFB(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D(?:\uD83D\uDC8B\u200D)?\uD83E\uDDD1\uD83C[\uDFFC-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF84\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF-\uDDB3\uDDBC\uDDBD]|\uDD1D\u200D\uD83E\uDDD1\uD83C[\uDFFB-\uDFFF])))?|\uDFFC(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D(?:\uD83D\uDC8B\u200D)?\uD83E\uDDD1\uD83C[\uDFFB\uDFFD-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF84\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF-\uDDB3\uDDBC\uDDBD]|\uDD1D\u200D\uD83E\uDDD1\uD83C[\uDFFB-\uDFFF])))?|\uDFFD(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D(?:\uD83D\uDC8B\u200D)?\uD83E\uDDD1\uD83C[\uDFFB\uDFFC\uDFFE\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF84\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF-\uDDB3\uDDBC\uDDBD]|\uDD1D\u200D\uD83E\uDDD1\uD83C[\uDFFB-\uDFFF])))?|\uDFFE(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D(?:\uD83D\uDC8B\u200D)?\uD83E\uDDD1\uD83C[\uDFFB-\uDFFD\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF84\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF-\uDDB3\uDDBC\uDDBD]|\uDD1D\u200D\uD83E\uDDD1\uD83C[\uDFFB-\uDFFF])))?|\uDFFF(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D(?:\uD83D\uDC8B\u200D)?\uD83E\uDDD1\uD83C[\uDFFB-\uDFFE]|\uD83C[\uDF3E\uDF73\uDF7C\uDF84\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF-\uDDB3\uDDBC\uDDBD]|\uDD1D\u200D\uD83E\uDDD1\uD83C[\uDFFB-\uDFFF])))?))?|\uDEF1(?:\uD83C(?:\uDFFB(?:\u200D\uD83E\uDEF2\uD83C[\uDFFC-\uDFFF])?|\uDFFC(?:\u200D\uD83E\uDEF2\uD83C[\uDFFB\uDFFD-\uDFFF])?|\uDFFD(?:\u200D\uD83E\uDEF2\uD83C[\uDFFB\uDFFC\uDFFE\uDFFF])?|\uDFFE(?:\u200D\uD83E\uDEF2\uD83C[\uDFFB-\uDFFD\uDFFF])?|\uDFFF(?:\u200D\uD83E\uDEF2\uD83C[\uDFFB-\uDFFE])?))?)/g; +}; +var eastasianwidth_default = { + eastAsianWidth(character) { + var x = character.charCodeAt(0); + var y = character.length == 2 ? character.charCodeAt(1) : 0; + var codePoint = x; + if (55296 <= x && x <= 56319 && 56320 <= y && y <= 57343) { + x &= 1023; + y &= 1023; + codePoint = x << 10 | y; + codePoint += 65536; + } + if (12288 == codePoint || 65281 <= codePoint && codePoint <= 65376 || 65504 <= codePoint && codePoint <= 65510) { + return "F"; + } + if (4352 <= codePoint && codePoint <= 4447 || 4515 <= codePoint && codePoint <= 4519 || 4602 <= codePoint && codePoint <= 4607 || 9001 <= codePoint && codePoint <= 9002 || 11904 <= codePoint && codePoint <= 11929 || 11931 <= codePoint && codePoint <= 12019 || 12032 <= codePoint && codePoint <= 12245 || 12272 <= codePoint && codePoint <= 12283 || 12289 <= codePoint && codePoint <= 12350 || 12353 <= codePoint && codePoint <= 12438 || 12441 <= codePoint && codePoint <= 12543 || 12549 <= codePoint && codePoint <= 12589 || 12593 <= codePoint && codePoint <= 12686 || 12688 <= codePoint && codePoint <= 12730 || 12736 <= codePoint && codePoint <= 12771 || 12784 <= codePoint && codePoint <= 12830 || 12832 <= codePoint && codePoint <= 12871 || 12880 <= codePoint && codePoint <= 13054 || 13056 <= codePoint && codePoint <= 19903 || 19968 <= codePoint && codePoint <= 42124 || 42128 <= codePoint && codePoint <= 42182 || 43360 <= codePoint && codePoint <= 43388 || 44032 <= codePoint && codePoint <= 55203 || 55216 <= codePoint && codePoint <= 55238 || 55243 <= codePoint && codePoint <= 55291 || 63744 <= codePoint && codePoint <= 64255 || 65040 <= codePoint && codePoint <= 65049 || 65072 <= codePoint && codePoint <= 65106 || 65108 <= codePoint && codePoint <= 65126 || 65128 <= codePoint && codePoint <= 65131 || 110592 <= codePoint && codePoint <= 110593 || 127488 <= codePoint && codePoint <= 127490 || 127504 <= codePoint && codePoint <= 127546 || 127552 <= codePoint && codePoint <= 127560 || 127568 <= codePoint && codePoint <= 127569 || 131072 <= codePoint && codePoint <= 194367 || 177984 <= codePoint && codePoint <= 196605 || 196608 <= codePoint && codePoint <= 262141) { + return "W"; + } + return "N"; + } +}; +var notAsciiRegex = /[^\x20-\x7F]/; +function getStringWidth(text) { + if (!text) { + return 0; + } + if (!notAsciiRegex.test(text)) { + return text.length; + } + text = text.replace(emoji_regex_default(), " "); + let width = 0; + for (const character of text) { + const codePoint = character.codePointAt(0); + if (codePoint <= 31 || codePoint >= 127 && codePoint <= 159) { + continue; + } + if (codePoint >= 768 && codePoint <= 879) { + continue; + } + const code = eastasianwidth_default.eastAsianWidth(character); + width += code === "F" || code === "W" ? 2 : 1; + } + return width; +} +var get_string_width_default = getStringWidth; +var getDocParts = (doc) => { + if (Array.isArray(doc)) { + return doc; + } + if (doc.type !== DOC_TYPE_FILL) { + throw new Error(`Expect doc to be 'array' or '${DOC_TYPE_FILL}'.`); + } + return doc.parts; +}; +function mapDoc(doc, cb) { + if (typeof doc === "string") { + return cb(doc); + } + const mapped = /* @__PURE__ */ new Map(); + return rec(doc); + function rec(doc2) { + if (mapped.has(doc2)) { + return mapped.get(doc2); + } + const result = process2(doc2); + mapped.set(doc2, result); + return result; + } + function process2(doc2) { + switch (get_doc_type_default(doc2)) { + case DOC_TYPE_ARRAY: + return cb(doc2.map(rec)); + case DOC_TYPE_FILL: + return cb({ + ...doc2, + parts: doc2.parts.map(rec) + }); + case DOC_TYPE_IF_BREAK: + return cb({ + ...doc2, + breakContents: rec(doc2.breakContents), + flatContents: rec(doc2.flatContents) + }); + case DOC_TYPE_GROUP: { + let { + expandedStates, + contents + } = doc2; + if (expandedStates) { + expandedStates = expandedStates.map(rec); + contents = expandedStates[0]; + } else { + contents = rec(contents); + } + return cb({ + ...doc2, + contents, + expandedStates + }); + } + case DOC_TYPE_ALIGN: + case DOC_TYPE_INDENT: + case DOC_TYPE_INDENT_IF_BREAK: + case DOC_TYPE_LABEL: + case DOC_TYPE_LINE_SUFFIX: + return cb({ + ...doc2, + contents: rec(doc2.contents) + }); + case DOC_TYPE_STRING: + case DOC_TYPE_CURSOR: + case DOC_TYPE_TRIM: + case DOC_TYPE_LINE_SUFFIX_BOUNDARY: + case DOC_TYPE_LINE: + case DOC_TYPE_BREAK_PARENT: + return cb(doc2); + default: + throw new invalid_doc_error_default(doc2); + } + } +} +function findInDoc(doc, fn, defaultValue) { + let result = defaultValue; + let shouldSkipFurtherProcessing = false; + function findInDocOnEnterFn(doc2) { + if (shouldSkipFurtherProcessing) { + return false; + } + const maybeResult = fn(doc2); + if (maybeResult !== void 0) { + shouldSkipFurtherProcessing = true; + result = maybeResult; + } + } + traverse_doc_default(doc, findInDocOnEnterFn); + return result; +} +function willBreakFn(doc) { + if (doc.type === DOC_TYPE_GROUP && doc.break) { + return true; + } + if (doc.type === DOC_TYPE_LINE && doc.hard) { + return true; + } + if (doc.type === DOC_TYPE_BREAK_PARENT) { + return true; + } +} +function willBreak(doc) { + return findInDoc(doc, willBreakFn, false); +} +function breakParentGroup(groupStack) { + if (groupStack.length > 0) { + const parentGroup = at_default( + /* isOptionalObject*/ + false, + groupStack, + -1 + ); + if (!parentGroup.expandedStates && !parentGroup.break) { + parentGroup.break = "propagated"; + } + } + return null; +} +function propagateBreaks(doc) { + const alreadyVisitedSet = /* @__PURE__ */ new Set(); + const groupStack = []; + function propagateBreaksOnEnterFn(doc2) { + if (doc2.type === DOC_TYPE_BREAK_PARENT) { + breakParentGroup(groupStack); + } + if (doc2.type === DOC_TYPE_GROUP) { + groupStack.push(doc2); + if (alreadyVisitedSet.has(doc2)) { + return false; + } + alreadyVisitedSet.add(doc2); + } + } + function propagateBreaksOnExitFn(doc2) { + if (doc2.type === DOC_TYPE_GROUP) { + const group22 = groupStack.pop(); + if (group22.break) { + breakParentGroup(groupStack); + } + } + } + traverse_doc_default( + doc, + propagateBreaksOnEnterFn, + propagateBreaksOnExitFn, + /* shouldTraverseConditionalGroups */ + true + ); +} +function removeLinesFn(doc) { + if (doc.type === DOC_TYPE_LINE && !doc.hard) { + return doc.soft ? "" : " "; + } + if (doc.type === DOC_TYPE_IF_BREAK) { + return doc.flatContents; + } + return doc; +} +function removeLines(doc) { + return mapDoc(doc, removeLinesFn); +} +function stripTrailingHardlineFromParts(parts) { + parts = [...parts]; + while (parts.length >= 2 && at_default( + /* isOptionalObject*/ + false, + parts, + -2 + ).type === DOC_TYPE_LINE && at_default( + /* isOptionalObject*/ + false, + parts, + -1 + ).type === DOC_TYPE_BREAK_PARENT) { + parts.length -= 2; + } + if (parts.length > 0) { + const lastPart = stripTrailingHardlineFromDoc(at_default( + /* isOptionalObject*/ + false, + parts, + -1 + )); + parts[parts.length - 1] = lastPart; + } + return parts; +} +function stripTrailingHardlineFromDoc(doc) { + switch (get_doc_type_default(doc)) { + case DOC_TYPE_ALIGN: + case DOC_TYPE_INDENT: + case DOC_TYPE_INDENT_IF_BREAK: + case DOC_TYPE_GROUP: + case DOC_TYPE_LINE_SUFFIX: + case DOC_TYPE_LABEL: { + const contents = stripTrailingHardlineFromDoc(doc.contents); + return { + ...doc, + contents + }; + } + case DOC_TYPE_IF_BREAK: + return { + ...doc, + breakContents: stripTrailingHardlineFromDoc(doc.breakContents), + flatContents: stripTrailingHardlineFromDoc(doc.flatContents) + }; + case DOC_TYPE_FILL: + return { + ...doc, + parts: stripTrailingHardlineFromParts(doc.parts) + }; + case DOC_TYPE_ARRAY: + return stripTrailingHardlineFromParts(doc); + case DOC_TYPE_STRING: + return doc.replace(/[\n\r]*$/, ""); + case DOC_TYPE_CURSOR: + case DOC_TYPE_TRIM: + case DOC_TYPE_LINE_SUFFIX_BOUNDARY: + case DOC_TYPE_LINE: + case DOC_TYPE_BREAK_PARENT: + break; + default: + throw new invalid_doc_error_default(doc); + } + return doc; +} +function stripTrailingHardline(doc) { + return stripTrailingHardlineFromDoc(cleanDoc(doc)); +} +function cleanDocFn(doc) { + switch (get_doc_type_default(doc)) { + case DOC_TYPE_FILL: + if (doc.parts.every((part) => part === "")) { + return ""; + } + break; + case DOC_TYPE_GROUP: + if (!doc.contents && !doc.id && !doc.break && !doc.expandedStates) { + return ""; + } + if (doc.contents.type === DOC_TYPE_GROUP && doc.contents.id === doc.id && doc.contents.break === doc.break && doc.contents.expandedStates === doc.expandedStates) { + return doc.contents; + } + break; + case DOC_TYPE_ALIGN: + case DOC_TYPE_INDENT: + case DOC_TYPE_INDENT_IF_BREAK: + case DOC_TYPE_LINE_SUFFIX: + if (!doc.contents) { + return ""; + } + break; + case DOC_TYPE_IF_BREAK: + if (!doc.flatContents && !doc.breakContents) { + return ""; + } + break; + case DOC_TYPE_ARRAY: { + const parts = []; + for (const part of doc) { + if (!part) { + continue; + } + const [currentPart, ...restParts] = Array.isArray(part) ? part : [part]; + if (typeof currentPart === "string" && typeof at_default( + /* isOptionalObject*/ + false, + parts, + -1 + ) === "string") { + parts[parts.length - 1] += currentPart; + } else { + parts.push(currentPart); + } + parts.push(...restParts); + } + if (parts.length === 0) { + return ""; + } + if (parts.length === 1) { + return parts[0]; + } + return parts; + } + case DOC_TYPE_STRING: + case DOC_TYPE_CURSOR: + case DOC_TYPE_TRIM: + case DOC_TYPE_LINE_SUFFIX_BOUNDARY: + case DOC_TYPE_LINE: + case DOC_TYPE_LABEL: + case DOC_TYPE_BREAK_PARENT: + break; + default: + throw new invalid_doc_error_default(doc); + } + return doc; +} +function cleanDoc(doc) { + return mapDoc(doc, (currentDoc) => cleanDocFn(currentDoc)); +} +function replaceEndOfLine(doc, replacement = literalline) { + return mapDoc(doc, (currentDoc) => typeof currentDoc === "string" ? join(replacement, currentDoc.split("\n")) : currentDoc); +} +function canBreakFn(doc) { + if (doc.type === DOC_TYPE_LINE) { + return true; + } +} +function canBreak(doc) { + return findInDoc(doc, canBreakFn, false); +} +var MODE_BREAK = Symbol("MODE_BREAK"); +var MODE_FLAT = Symbol("MODE_FLAT"); +var CURSOR_PLACEHOLDER = Symbol("cursor"); +function rootIndent() { + return { + value: "", + length: 0, + queue: [] + }; +} +function makeIndent(ind, options2) { + return generateInd(ind, { + type: "indent" + }, options2); +} +function makeAlign(indent22, widthOrDoc, options2) { + if (widthOrDoc === Number.NEGATIVE_INFINITY) { + return indent22.root || rootIndent(); + } + if (widthOrDoc < 0) { + return generateInd(indent22, { + type: "dedent" + }, options2); + } + if (!widthOrDoc) { + return indent22; + } + if (widthOrDoc.type === "root") { + return { + ...indent22, + root: indent22 + }; + } + const alignType = typeof widthOrDoc === "string" ? "stringAlign" : "numberAlign"; + return generateInd(indent22, { + type: alignType, + n: widthOrDoc + }, options2); +} +function generateInd(ind, newPart, options2) { + const queue = newPart.type === "dedent" ? ind.queue.slice(0, -1) : [...ind.queue, newPart]; + let value = ""; + let length = 0; + let lastTabs = 0; + let lastSpaces = 0; + for (const part of queue) { + switch (part.type) { + case "indent": + flush(); + if (options2.useTabs) { + addTabs(1); + } else { + addSpaces(options2.tabWidth); + } + break; + case "stringAlign": + flush(); + value += part.n; + length += part.n.length; + break; + case "numberAlign": + lastTabs += 1; + lastSpaces += part.n; + break; + default: + throw new Error(`Unexpected type '${part.type}'`); + } + } + flushSpaces(); + return { + ...ind, + value, + length, + queue + }; + function addTabs(count) { + value += " ".repeat(count); + length += options2.tabWidth * count; + } + function addSpaces(count) { + value += " ".repeat(count); + length += count; + } + function flush() { + if (options2.useTabs) { + flushTabs(); + } else { + flushSpaces(); + } + } + function flushTabs() { + if (lastTabs > 0) { + addTabs(lastTabs); + } + resetLast(); + } + function flushSpaces() { + if (lastSpaces > 0) { + addSpaces(lastSpaces); + } + resetLast(); + } + function resetLast() { + lastTabs = 0; + lastSpaces = 0; + } +} +function trim2(out) { + let trimCount = 0; + let cursorCount = 0; + let outIndex = out.length; + outer: + while (outIndex--) { + const last = out[outIndex]; + if (last === CURSOR_PLACEHOLDER) { + cursorCount++; + continue; + } + for (let charIndex = last.length - 1; charIndex >= 0; charIndex--) { + const char = last[charIndex]; + if (char === " " || char === " ") { + trimCount++; + } else { + out[outIndex] = last.slice(0, charIndex + 1); + break outer; + } + } + } + if (trimCount > 0 || cursorCount > 0) { + out.length = outIndex + 1; + while (cursorCount-- > 0) { + out.push(CURSOR_PLACEHOLDER); + } + } + return trimCount; +} +function fits(next, restCommands, width, hasLineSuffix, groupModeMap, mustBeFlat) { + if (width === Number.POSITIVE_INFINITY) { + return true; + } + let restIdx = restCommands.length; + const cmds = [next]; + const out = []; + while (width >= 0) { + if (cmds.length === 0) { + if (restIdx === 0) { + return true; + } + cmds.push(restCommands[--restIdx]); + continue; + } + const { + mode, + doc + } = cmds.pop(); + switch (get_doc_type_default(doc)) { + case DOC_TYPE_STRING: + out.push(doc); + width -= get_string_width_default(doc); + break; + case DOC_TYPE_ARRAY: + case DOC_TYPE_FILL: { + const parts = getDocParts(doc); + for (let i = parts.length - 1; i >= 0; i--) { + cmds.push({ + mode, + doc: parts[i] + }); + } + break; + } + case DOC_TYPE_INDENT: + case DOC_TYPE_ALIGN: + case DOC_TYPE_INDENT_IF_BREAK: + case DOC_TYPE_LABEL: + cmds.push({ + mode, + doc: doc.contents + }); + break; + case DOC_TYPE_TRIM: + width += trim2(out); + break; + case DOC_TYPE_GROUP: { + if (mustBeFlat && doc.break) { + return false; + } + const groupMode = doc.break ? MODE_BREAK : mode; + const contents = doc.expandedStates && groupMode === MODE_BREAK ? at_default( + /* isOptionalObject*/ + false, + doc.expandedStates, + -1 + ) : doc.contents; + cmds.push({ + mode: groupMode, + doc: contents + }); + break; + } + case DOC_TYPE_IF_BREAK: { + const groupMode = doc.groupId ? groupModeMap[doc.groupId] || MODE_FLAT : mode; + const contents = groupMode === MODE_BREAK ? doc.breakContents : doc.flatContents; + if (contents) { + cmds.push({ + mode, + doc: contents + }); + } + break; + } + case DOC_TYPE_LINE: + if (mode === MODE_BREAK || doc.hard) { + return true; + } + if (!doc.soft) { + out.push(" "); + width--; + } + break; + case DOC_TYPE_LINE_SUFFIX: + hasLineSuffix = true; + break; + case DOC_TYPE_LINE_SUFFIX_BOUNDARY: + if (hasLineSuffix) { + return false; + } + break; + } + } + return false; +} +function printDocToString(doc, options2) { + const groupModeMap = {}; + const width = options2.printWidth; + const newLine = convertEndOfLineToChars(options2.endOfLine); + let pos = 0; + const cmds = [{ + ind: rootIndent(), + mode: MODE_BREAK, + doc + }]; + const out = []; + let shouldRemeasure = false; + const lineSuffix22 = []; + let printedCursorCount = 0; + propagateBreaks(doc); + while (cmds.length > 0) { + const { + ind, + mode, + doc: doc2 + } = cmds.pop(); + switch (get_doc_type_default(doc2)) { + case DOC_TYPE_STRING: { + const formatted = newLine !== "\n" ? string_replace_all_default( + /* isOptionalObject*/ + false, + doc2, + "\n", + newLine + ) : doc2; + out.push(formatted); + if (cmds.length > 0) { + pos += get_string_width_default(formatted); + } + break; + } + case DOC_TYPE_ARRAY: + for (let i = doc2.length - 1; i >= 0; i--) { + cmds.push({ + ind, + mode, + doc: doc2[i] + }); + } + break; + case DOC_TYPE_CURSOR: + if (printedCursorCount >= 2) { + throw new Error("There are too many 'cursor' in doc."); + } + out.push(CURSOR_PLACEHOLDER); + printedCursorCount++; + break; + case DOC_TYPE_INDENT: + cmds.push({ + ind: makeIndent(ind, options2), + mode, + doc: doc2.contents + }); + break; + case DOC_TYPE_ALIGN: + cmds.push({ + ind: makeAlign(ind, doc2.n, options2), + mode, + doc: doc2.contents + }); + break; + case DOC_TYPE_TRIM: + pos -= trim2(out); + break; + case DOC_TYPE_GROUP: + switch (mode) { + case MODE_FLAT: + if (!shouldRemeasure) { + cmds.push({ + ind, + mode: doc2.break ? MODE_BREAK : MODE_FLAT, + doc: doc2.contents + }); + break; + } + case MODE_BREAK: { + shouldRemeasure = false; + const next = { + ind, + mode: MODE_FLAT, + doc: doc2.contents + }; + const rem = width - pos; + const hasLineSuffix = lineSuffix22.length > 0; + if (!doc2.break && fits(next, cmds, rem, hasLineSuffix, groupModeMap)) { + cmds.push(next); + } else { + if (doc2.expandedStates) { + const mostExpanded = at_default( + /* isOptionalObject*/ + false, + doc2.expandedStates, + -1 + ); + if (doc2.break) { + cmds.push({ + ind, + mode: MODE_BREAK, + doc: mostExpanded + }); + break; + } else { + for (let i = 1; i < doc2.expandedStates.length + 1; i++) { + if (i >= doc2.expandedStates.length) { + cmds.push({ + ind, + mode: MODE_BREAK, + doc: mostExpanded + }); + break; + } else { + const state = doc2.expandedStates[i]; + const cmd = { + ind, + mode: MODE_FLAT, + doc: state + }; + if (fits(cmd, cmds, rem, hasLineSuffix, groupModeMap)) { + cmds.push(cmd); + break; + } + } + } + } + } else { + cmds.push({ + ind, + mode: MODE_BREAK, + doc: doc2.contents + }); + } + } + break; + } + } + if (doc2.id) { + groupModeMap[doc2.id] = at_default( + /* isOptionalObject*/ + false, + cmds, + -1 + ).mode; + } + break; + case DOC_TYPE_FILL: { + const rem = width - pos; + const { + parts + } = doc2; + if (parts.length === 0) { + break; + } + const [content, whitespace] = parts; + const contentFlatCmd = { + ind, + mode: MODE_FLAT, + doc: content + }; + const contentBreakCmd = { + ind, + mode: MODE_BREAK, + doc: content + }; + const contentFits = fits(contentFlatCmd, [], rem, lineSuffix22.length > 0, groupModeMap, true); + if (parts.length === 1) { + if (contentFits) { + cmds.push(contentFlatCmd); + } else { + cmds.push(contentBreakCmd); + } + break; + } + const whitespaceFlatCmd = { + ind, + mode: MODE_FLAT, + doc: whitespace + }; + const whitespaceBreakCmd = { + ind, + mode: MODE_BREAK, + doc: whitespace + }; + if (parts.length === 2) { + if (contentFits) { + cmds.push(whitespaceFlatCmd, contentFlatCmd); + } else { + cmds.push(whitespaceBreakCmd, contentBreakCmd); + } + break; + } + parts.splice(0, 2); + const remainingCmd = { + ind, + mode, + doc: fill(parts) + }; + const secondContent = parts[0]; + const firstAndSecondContentFlatCmd = { + ind, + mode: MODE_FLAT, + doc: [content, whitespace, secondContent] + }; + const firstAndSecondContentFits = fits(firstAndSecondContentFlatCmd, [], rem, lineSuffix22.length > 0, groupModeMap, true); + if (firstAndSecondContentFits) { + cmds.push(remainingCmd, whitespaceFlatCmd, contentFlatCmd); + } else if (contentFits) { + cmds.push(remainingCmd, whitespaceBreakCmd, contentFlatCmd); + } else { + cmds.push(remainingCmd, whitespaceBreakCmd, contentBreakCmd); + } + break; + } + case DOC_TYPE_IF_BREAK: + case DOC_TYPE_INDENT_IF_BREAK: { + const groupMode = doc2.groupId ? groupModeMap[doc2.groupId] : mode; + if (groupMode === MODE_BREAK) { + const breakContents = doc2.type === DOC_TYPE_IF_BREAK ? doc2.breakContents : doc2.negate ? doc2.contents : indent(doc2.contents); + if (breakContents) { + cmds.push({ + ind, + mode, + doc: breakContents + }); + } + } + if (groupMode === MODE_FLAT) { + const flatContents = doc2.type === DOC_TYPE_IF_BREAK ? doc2.flatContents : doc2.negate ? indent(doc2.contents) : doc2.contents; + if (flatContents) { + cmds.push({ + ind, + mode, + doc: flatContents + }); + } + } + break; + } + case DOC_TYPE_LINE_SUFFIX: + lineSuffix22.push({ + ind, + mode, + doc: doc2.contents + }); + break; + case DOC_TYPE_LINE_SUFFIX_BOUNDARY: + if (lineSuffix22.length > 0) { + cmds.push({ + ind, + mode, + doc: hardlineWithoutBreakParent + }); + } + break; + case DOC_TYPE_LINE: + switch (mode) { + case MODE_FLAT: + if (!doc2.hard) { + if (!doc2.soft) { + out.push(" "); + pos += 1; + } + break; + } else { + shouldRemeasure = true; + } + case MODE_BREAK: + if (lineSuffix22.length > 0) { + cmds.push({ + ind, + mode, + doc: doc2 + }, ...lineSuffix22.reverse()); + lineSuffix22.length = 0; + break; + } + if (doc2.literal) { + if (ind.root) { + out.push(newLine, ind.root.value); + pos = ind.root.length; + } else { + out.push(newLine); + pos = 0; + } + } else { + pos -= trim2(out); + out.push(newLine + ind.value); + pos = ind.length; + } + break; + } + break; + case DOC_TYPE_LABEL: + cmds.push({ + ind, + mode, + doc: doc2.contents + }); + break; + case DOC_TYPE_BREAK_PARENT: + break; + default: + throw new invalid_doc_error_default(doc2); + } + if (cmds.length === 0 && lineSuffix22.length > 0) { + cmds.push(...lineSuffix22.reverse()); + lineSuffix22.length = 0; + } + } + const cursorPlaceholderIndex = out.indexOf(CURSOR_PLACEHOLDER); + if (cursorPlaceholderIndex !== -1) { + const otherCursorPlaceholderIndex = out.indexOf(CURSOR_PLACEHOLDER, cursorPlaceholderIndex + 1); + const beforeCursor = out.slice(0, cursorPlaceholderIndex).join(""); + const aroundCursor = out.slice(cursorPlaceholderIndex + 1, otherCursorPlaceholderIndex).join(""); + const afterCursor = out.slice(otherCursorPlaceholderIndex + 1).join(""); + return { + formatted: beforeCursor + aroundCursor + afterCursor, + cursorNodeStart: beforeCursor.length, + cursorNodeText: aroundCursor + }; + } + return { + formatted: out.join("") + }; +} +var builders = { + join, + line, + softline, + hardline, + literalline, + group, + conditionalGroup, + fill, + lineSuffix, + lineSuffixBoundary, + cursor, + breakParent, + ifBreak, + trim, + indent, + indentIfBreak, + align, + addAlignmentToDoc, + markAsRoot, + dedentToRoot, + dedent, + hardlineWithoutBreakParent, + literallineWithoutBreakParent, + label, + // TODO: Remove this in v4 + concat: (parts) => parts +}; +var printer = { printDocToString }; +var utils = { + willBreak, + traverseDoc: traverse_doc_default, + findInDoc, + mapDoc, + removeLines, + stripTrailingHardline, + replaceEndOfLine, + canBreak +}; +function formatEnvSurround(node) { + const env = printRaw(node.env); + return { + envName: env, + start: ESCAPE + "begin{" + env + "}", + end: ESCAPE + "end{" + env + "}" + }; +} +function isLineType(elm) { + if (elm == null || typeof elm === "string") { + return false; + } + if (Array.isArray(elm)) { + return isLineType(elm[0]); + } + if (elm.type === "concat") { + return isLineType(elm.parts); + } + return elm.type === "line"; +} +function joinWithSoftline(arr) { + if (arr.length === 0 || arr.length === 1) { + return arr; + } + const ret = [arr[0]]; + for (let i = 1; i < arr.length; i++) { + const prevNode = arr[i - 1]; + const nextNode = arr[i]; + if (!isLineType(prevNode) && !isLineType(nextNode)) { + ret.push(softline2); + } + ret.push(nextNode); + } + return ret; +} +function getNodeInfo(node, options2) { + if (!node) { + return { renderInfo: {} }; + } + const renderInfo = node._renderInfo || {}; + const previousNode = options2.referenceMap && options2.referenceMap.getPreviousNode(node); + const nextNode = options2.referenceMap && options2.referenceMap.getNextNode(node); + const renderCache = options2.referenceMap && options2.referenceMap.getRenderCache(node); + return { + renderInfo, + renderCache, + previousNode, + nextNode, + referenceMap: options2.referenceMap + }; +} +var ESCAPE = "\\"; +var { + group: group2, + fill: fill2, + ifBreak: ifBreak2, + line: line2, + softline: softline2, + hardline: hardline2, + lineSuffix: lineSuffix2, + lineSuffixBoundary: lineSuffixBoundary2, + breakParent: breakParent2, + indent: indent2, + markAsRoot: markAsRoot2, + join: join2 +} = builders; +function formatDocArray(nodes, docArray, options2) { + const ret = []; + for (let i = 0; i < nodes.length; i++) { + const rawNode = nodes[i]; + const printedNode = docArray[i]; + const { renderInfo, referenceMap, previousNode, nextNode } = getNodeInfo(rawNode, options2); + const renderCache = referenceMap && referenceMap.getRenderCache(rawNode); + switch (rawNode.type) { + case "comment": + if (!rawNode.sameline && previousNode && !match.comment(previousNode) && !match.parbreak(previousNode)) { + ret.push(hardline2); + } + ret.push(printedNode); + if (nextNode && !rawNode.suffixParbreak) { + ret.push(hardline2); + } + break; + case "environment": + case "displaymath": + case "mathenv": + if (previousNode && (previousNode == null ? void 0 : previousNode.type) !== "parbreak") { + if (ret[ret.length - 1] === line2) { + ret.pop(); + } + if (ret[ret.length - 1] !== hardline2) { + ret.push(hardline2); + } + } + ret.push(printedNode); + if ((nextNode == null ? void 0 : nextNode.type) === "whitespace") { + ret.push(hardline2); + i++; + } + break; + case "macro": + if (renderInfo.breakBefore || renderInfo.breakAround) { + if (previousNode) { + if (ret[ret.length - 1] === line2 || ret[ret.length - 1] === hardline2) { + ret.pop(); + ret.push(hardline2); + } else if (!match.comment(previousNode) && !match.parbreak(previousNode)) { + ret.push(hardline2); + } + } + } + if (renderInfo.inParMode && !renderInfo.hangingIndent && renderCache) { + ret.push( + renderCache.content, + ...renderCache.rawArgs || [] + ); + } else { + ret.push(printedNode); + } + if (renderInfo.breakAfter || renderInfo.breakAround) { + if (nextNode) { + if (match.whitespace(nextNode)) { + ret.push(hardline2); + i++; + } else if (match.parbreak(nextNode)) + ; + else if (!match.comment(nextNode)) { + ret.push(hardline2); + } + } + } + break; + case "parbreak": + ret.push(hardline2, hardline2); + break; + default: + ret.push(printedNode); + break; + } + } + return ret; +} +function zip(array1, array2) { + const ret = []; + const len = Math.min(array1.length, array2.length); + for (let i = 0; i < len; i++) { + ret.push([array1[i], array2[i]]); + } + return ret; +} +function printMacro(path2, print, options2) { + const node = path2.getNode(); + const { renderInfo, previousNode, nextNode, referenceMap } = getNodeInfo( + node, + options2 + ); + const content = (node.escapeToken != null ? node.escapeToken : ESCAPE) + node.content; + const args = node.args ? path2.map(print, "args") : []; + const rawArgs = []; + for (const [arg2, printedArg] of zip(node.args || [], args)) { + const renderCache = referenceMap && referenceMap.getRenderCache(arg2); + if (renderInfo.inParMode && renderCache) { + rawArgs.push(...renderCache); + } else { + rawArgs.push(printedArg); + } + } + if (referenceMap) { + referenceMap.setRenderCache(node, { rawArgs, content }); + } + if (renderInfo.hangingIndent) { + return indent2(fill2([content, ...rawArgs])); + } + return group2([content, ...rawArgs]); +} +function printArgumentPgfkeys(nodes, options2) { + const { allowParenGroups = false } = options2; + const parsed = parsePgfkeys(nodes, { allowParenGroups }); + const content = []; + for (const part of parsed) { + const isLastItem = part === parsed[parsed.length - 1]; + if (part.itemParts) { + const parts = part.itemParts.map( + (node) => printRaw(node, { asArray: true }).map( + (token) => token === linebreak ? hardline2 : token + ) + ); + const row = join2("=", parts); + content.push(row); + if (part.trailingComma) { + content.push(","); + } + } + if (part.trailingComment) { + const leadingContent = part.itemParts ? [" "] : []; + if (part.leadingParbreak) { + leadingContent.push(hardline2); + } + content.push( + ...leadingContent, + // We're carefully and manually controlling the newlines, + // so print the comment directly without any newlines + "%", + part.trailingComment.content, + breakParent2 + ); + } + if (!isLastItem) { + content.push(line2); + } + } + let leadingComment = [""]; + if (options2.leadingComment) { + if (options2.leadingComment.leadingWhitespace) { + leadingComment.push(" "); + } + leadingComment.push("%" + options2.leadingComment.content, breakParent2); + } + return group2([ + options2.openMark, + ...leadingComment, + // If there is no content, we don't want to push an extra `softline`. + // This matters because the braces group could still be broken by `leadingComment` + content.length > 0 ? indent2([softline2, ...content]) : "", + softline2, + options2.closeMark + ]); +} +function printTikzArgument(path2, print, options2) { + const node = path2.getNode(); + getNodeInfo( + node, + options2 + ); + const content = []; + const nodes = [...node.content]; + trim$1(nodes); + try { + const tikzAst = parse$1(nodes); + if (tikzAst.content.length === 0) { + content.push(";"); + return content; + } + const printer2 = new TikzArgumentPrinter(tikzAst, path2, print); + return printer2.toDoc(); + } catch (e) { + console.warn("Encountered error when trying to parse tikz argument", e); + } + content.push(";"); + return content; +} +function printFragment(fragment, path2, print) { + const tmpKey = Symbol(); + const currNode = path2.getNode(); + if (!currNode) { + throw new Error( + "tried to print a fragment, but the current node is `null`" + ); + } + currNode[tmpKey] = fragment; + const ret = print(tmpKey); + delete currNode[tmpKey]; + return ret; +} +function printTikzPathSpecNode(node, path2, print) { + switch (node.type) { + case "comment": + return printFragment(node, path2, print); + case "unknown": + return printFragment(node.content, path2, print); + case "coordinate": + return [printRaw(node.prefix), "(", printRaw(node.content), ")"]; + case "line_to": + return node.command; + case "square_brace_group": + return printOptionalArgs(node.content); + case "operation": + return node.content.content; + case "svg_operation": { + const comments = node.comments.map( + (n) => printTikzPathSpecNode(n, path2, print) + ); + const options2 = node.options ? printOptionalArgs(node.options) : []; + const rest = node.options ? [group2(indent2([line2, printRaw(node.content)]))] : [" ", printRaw(node.content)]; + return [...comments, "svg", options2, ...rest]; + } + case "curve_to": { + const comments = node.comments.map( + (n) => printTikzPathSpecNode(n, path2, print) + ); + const printedControls = node.controls.length > 1 ? [ + printTikzPathSpecNode(node.controls[0], path2, print), + " ", + "and", + line2, + printTikzPathSpecNode(node.controls[1], path2, print) + ] : [printTikzPathSpecNode(node.controls[0], path2, print)]; + return [ + ...comments, + "..", + " ", + group2( + indent2(["controls", line2, ...printedControls, " ", ".."]) + ) + ]; + } + case "animation": { + const comments = node.comments.map( + (n) => printTikzPathSpecNode(n, path2, print) + ); + return [ + ...comments, + ":", + node.attribute, + " ", + "=", + " ", + group2( + indent2([ + printArgumentPgfkeys(node.content, { + openMark: "{", + closeMark: "}" + }) + ]) + ) + ]; + } + case "foreach": { + const comments = node.comments.map( + (n) => printTikzPathSpecNode(n, path2, print) + ); + const variables = [...node.variables]; + trim$1(variables); + const list = node.list.type === "macro" ? printFragment(node.list, path2, print) : printArgumentPgfkeys(node.list.content, { + openMark: "{", + closeMark: "}", + allowParenGroups: true + }); + const doc = [ + ...comments, + printRaw(node.start), + " ", + printRaw(variables) + ]; + if (node.options) { + doc.push(" ", indent2(printOptionalArgs(node.options))); + } + doc.push(" ", "in", " ", group2(indent2(list))); + const commandType = node.command.type; + switch (commandType) { + case "foreach": + doc.push( + indent2([ + line2, + printTikzPathSpecNode(node.command, path2, print) + ]) + ); + break; + case "macro": + doc.push( + indent2([line2, printFragment(node.command, path2, print)]) + ); + break; + case "group": { + const groupContent = [...node.command.content]; + trim$1(groupContent); + doc.push( + " ", + indent2( + group2([ + "{", + indent2([ + softline2, + ...groupContent.map( + (n) => printFragment(n, path2, print) + ) + ]), + softline2, + "}" + ]) + ) + ); + break; + } + default: + const invalidType = commandType; + console.warn( + `Unhandled command type when printing "foreach": ${invalidType}` + ); + } + return indent2(doc); + } + } + console.warn( + `Encountered unknown type when trying to print tikz PathSpec: "${node.type}"` + ); + return []; +} +function printOptionalArgs(nodes) { + return printArgumentPgfkeys(nodes, { + openMark: "[", + closeMark: "]" + }); +} +var _path, _print; +var TikzArgumentPrinter = class { + constructor(spec, path2, print) { + __privateAdd(this, _path, void 0); + __privateAdd(this, _print, void 0); + __privateSet(this, _path, path2); + __privateSet(this, _print, print); + this.nodes = [...spec.content]; + } + nodeToDoc(node) { + return printTikzPathSpecNode(node, __privateGet(this, _path), __privateGet(this, _print)); + } + toDoc() { + const doc = []; + const startArg = this.eatOptionalArg(); + if (startArg.optionalArg) { + doc.push( + ...startArg.comments.map( + (c) => printFragment(c, __privateGet(this, _path), __privateGet(this, _print)) + ) + ); + doc.push(printOptionalArgs(startArg.optionalArg.content)); + } + const innerDoc = []; + doc.push(group2([indent2(innerDoc), ";"])); + let cycle = -1; + while (this.nodes.length > 0) { + cycle++; + const firstSep = cycle === 0 && !startArg.optionalArg ? " " : line2; + const comingUp = this.peek(); + switch (comingUp) { + case "short_path": { + const [n0, n1, n2] = this.nodes.splice(0, 3); + innerDoc.push( + firstSep, + this.nodeToDoc(n0), + " ", + this.nodeToDoc(n1), + " ", + this.nodeToDoc(n2) + ); + continue; + } + case "long_path": { + const [n0, n1] = this.nodes.splice(0, 2); + if (n1.type === "operation") { + this.nodes.unshift(n1); + innerDoc.push( + firstSep, + this.nodeToDoc(n0), + " ", + this.eatOperation() + ); + } else { + innerDoc.push( + firstSep, + this.nodeToDoc(n0), + " ", + this.nodeToDoc(n1) + ); + } + continue; + } + case "node": + { + const eatenNode = this.eatNode(); + if (eatenNode) { + innerDoc.push(line2, ...eatenNode); + continue; + } + console.warn( + "Expected to print a tikz `node` PathSpec but couldn't find the text `node`" + ); + } + continue; + case "operation": + innerDoc.push(firstSep, this.eatOperation()); + continue; + case "unknown": { + const node = this.nodes.shift(); + innerDoc.push(firstSep, this.nodeToDoc(node)); + continue; + } + } + this.nodes.shift(); + } + return doc; + } + /** + * Look at the current node and the nodes that follow. Return what + * "type" is recognized. + */ + peek() { + const [n0, n1, n2, n3] = [ + this.nodes[0], + this.nodes[1], + this.nodes[2], + this.nodes[3] + ]; + if ((n0 == null ? void 0 : n0.type) === "coordinate" && isPathJoinOperation(n1)) { + if ((n2 == null ? void 0 : n2.type) === "coordinate" && !((n3 == null ? void 0 : n3.type) === "coordinate" || isPathJoinOperation(n3))) { + return "short_path"; + } + return "long_path"; + } + if ((n0 == null ? void 0 : n0.type) === "operation") { + if (n0.content.content === "node") { + return "node"; + } + return "operation"; + } + return "unknown"; + } + /** + * Eat comments and an optional arg if present. If no optional + * arg is present, do nothing. + */ + eatOptionalArg() { + let i = 0; + const comments = []; + let optionalArg = null; + for (; i < this.nodes.length; i++) { + const node = this.nodes[i]; + if (node.type === "square_brace_group") { + optionalArg = node; + i++; + break; + } + if (node.type === "comment") { + comments.push(node); + continue; + } + break; + } + if (optionalArg) { + this.nodes.splice(0, i); + } + return { optionalArg, comments }; + } + /** + * Eat a `type === "operation"` node whose contents is `"node"`. I.e., + * the type of thing that shows up in `\path node at (1,1) {foo};` + */ + eatNode() { + const firstNode = this.nodes[0]; + if ((firstNode == null ? void 0 : firstNode.type) === "operation" && firstNode.content.content === "node") { + this.nodes.shift(); + } else { + return null; + } + const innerDoc = []; + const commentBlock = []; + const doc = [commentBlock, "node", group2(indent2(innerDoc))]; + let hasNodeArgument = false; + let shouldBail = false; + let i = 0; + const comments = []; + const options2 = []; + const name = []; + const atLocations = []; + const animations = []; + let content = []; + for (; i < this.nodes.length && !shouldBail; i++) { + const node = this.nodes[i]; + switch (node.type) { + case "animation": + animations.push(this.nodeToDoc(node)); + continue; + case "comment": { + const comment = { + ...node, + leadingWhitespace: false + }; + comments.push(this.nodeToDoc(comment)); + continue; + } + case "square_brace_group": + options2.push(printOptionalArgs(node.content)); + continue; + case "coordinate": + name.push(this.nodeToDoc(node)); + continue; + case "operation": { + if (node.content.content === "at") { + const nextNode = this.nodes[i + 1]; + if (!nextNode || !(nextNode.type === "coordinate" || nextNode.type === "unknown" && match.anyMacro(nextNode.content))) { + shouldBail = true; + continue; + } + atLocations.push(["at", " ", this.nodeToDoc(nextNode)]); + i++; + continue; + } + shouldBail = true; + continue; + } + case "unknown": { + if (match.group(node.content)) { + hasNodeArgument = true; + content = this.nodeToDoc(node); + } + } + } + break; + } + if (!hasNodeArgument) { + return innerDoc; + } + this.nodes.splice(0, i + 1); + let isFirstElement = true; + let isNamed = !(Array.isArray(name) && name.length === 0); + for (const comment of comments) { + commentBlock.push(comment, hardline2); + } + if (options2.length > 0) { + innerDoc.push(join2(" ", options2)); + isFirstElement = false; + } + if (animations.length > 0) { + innerDoc.push(isFirstElement ? " " : line2); + innerDoc.push(join2(line2, animations)); + isFirstElement = false; + } + if (isNamed) { + innerDoc.push(isFirstElement ? " " : line2); + innerDoc.push(name); + isFirstElement = false; + } + if (atLocations.length > 0) { + innerDoc.push(isFirstElement || isNamed ? " " : line2); + innerDoc.push(join2(line2, atLocations)); + isFirstElement = false; + } + innerDoc.push(line2, content); + return doc; + } + /** + * Eat a `type === "operation"` node, including its optional arguments. + */ + eatOperation() { + const node = this.nodes[0]; + if ((node == null ? void 0 : node.type) === "operation") { + this.nodes.shift(); + } else { + return []; + } + const doc = []; + if ((node == null ? void 0 : node.type) !== "operation") { + throw new Error("Expecting `operation` node."); + } + const options2 = this.eatOptionalArg(); + doc.push( + ...options2.comments.map( + (c) => printFragment(c, __privateGet(this, _path), __privateGet(this, _print)) + ), + node.content.content + ); + if (options2.optionalArg) { + doc.push(indent2(printOptionalArgs(options2.optionalArg.content))); + } + return doc; + } +}; +_path = /* @__PURE__ */ new WeakMap(); +_print = /* @__PURE__ */ new WeakMap(); +var PATH_JOIN_OPERATIONS = /* @__PURE__ */ new Set(["rectangle", "grid", "sin", "cos", "to"]); +function isPathJoinOperation(node) { + if (!node) { + return false; + } + switch (node.type) { + case "line_to": + case "curve_to": + return true; + case "operation": + return PATH_JOIN_OPERATIONS.has(node.content.content); + } + return false; +} +function printArgument(path2, print, options2) { + const node = path2.getNode(); + const { renderInfo, previousNode, nextNode, referenceMap } = getNodeInfo( + node, + options2 + ); + if (node.openMark === "" && node.closeMark === "" && node.content.length === 0) { + return []; + } + const parentNode = path2.getParentNode(); + const { renderInfo: parentRenderInfo } = getNodeInfo(parentNode, options2); + if (parentRenderInfo.pgfkeysArgs) { + const leadingComment = node.content.length > 0 && match.comment(node.content[0]) && node.content[0].sameline ? node.content[0] : null; + const content2 = leadingComment ? node.content.slice(1) : node.content; + trim$1(content2); + return printArgumentPgfkeys(content2, { + openMark: node.openMark, + closeMark: node.closeMark, + leadingComment + }); + } + if (parentRenderInfo.tikzPathCommand) { + return printTikzArgument(path2, print, options2); + } + const openMark = node.openMark; + const closeMark = node.closeMark; + let content = path2.map(print, "content"); + content = formatDocArray(node.content, content, options2); + if (match.comment(node.content[node.content.length - 1])) { + content.push(hardline2); + } + let rawRet = [openMark, fill2(content), closeMark]; + if (renderInfo.inParMode) { + rawRet = [openMark, ...content, closeMark]; + } + if (referenceMap) { + referenceMap.setRenderCache(node, rawRet); + } + return rawRet; +} +function hasPreambleCode(nodes) { + return nodes.some((node) => match.macro(node, "documentclass")); +} +function printRoot(path2, print, options2) { + const node = path2.getNode(); + getNodeInfo( + node, + options2 + ); + const content = path2.map(print, "content"); + const rawContent = formatDocArray(node.content, content, options2); + const concatFunction = hasPreambleCode(node.content) ? (x) => x : fill2; + return concatFunction(rawContent); +} +function printComment(path2, _print2, _options) { + const node = path2.getNode(); + let leadingWhitespace = ""; + if (node.leadingWhitespace && node.sameline) { + leadingWhitespace = " "; + } + const content = [leadingWhitespace, "%" + printRaw(node.content)]; + return content; +} +function printInlineMath(path2, print, options2) { + const node = path2.getNode(); + if (node.content.length === 0) { + return ["$", " ", "$"]; + } + let content = path2.map(print, "content"); + content = formatDocArray(node.content, content, options2); + content = joinWithSoftline(content); + if (node.content[node.content.length - 1].type === "comment") { + content.push(hardline2); + } + return fill2(["$", ...content, "$"]); +} +function printDisplayMath(path2, print, options2) { + const node = path2.getNode(); + let content = path2.map(print, "content"); + content = formatDocArray(node.content, content, options2); + content = joinWithSoftline(content); + const bodyStartToken = [hardline2]; + if (node.content.length === 0 || node.content[0].type === "comment" && node.content[0].sameline) { + bodyStartToken.pop(); + } + return [ + ESCAPE + "[", + indent2(fill2(bodyStartToken.concat(content))), + hardline2, + ESCAPE + "]" + ]; +} +function printVerbatimEnvironment(path2, print, options2) { + const node = path2.getNode(); + const env = formatEnvSurround(node); + return [env.start, node.content, env.end]; +} +function printEnvironment(path2, print, options2) { + const node = path2.getNode(); + const { renderInfo, previousNode, nextNode, referenceMap } = getNodeInfo( + node, + options2 + ); + const args = node.args ? path2.map(print, "args") : []; + const env = formatEnvSurround(node); + let content = path2.map(print, "content"); + content = formatDocArray(node.content, content, options2); + if (renderInfo.inMathMode) { + content = joinWithSoftline(content); + } + let bodyStartToken = [hardline2]; + if (node.content.length === 0 || node.content[0].type === "comment" && node.content[0].sameline) { + bodyStartToken.pop(); + } + return [ + env.start, + ...args, + indent2(fill2(bodyStartToken.concat(content))), + hardline2, + env.end + ]; +} +function printAlignedEnvironment(path2, print, options2) { + const node = path2.getNode(); + getNodeInfo( + node, + options2 + ); + const args = node.args ? path2.map(print, "args") : []; + const env = formatEnvSurround(node); + const leadingComment = node.content[0] && node.content[0].type === "comment" && node.content[0].sameline ? node.content[0] : null; + const { rows, rowSeps, trailingComments } = formatAlignedContent( + leadingComment ? node.content.slice(1) : node.content + ); + const content = []; + for (let i = 0; i < rows.length; i++) { + const row = rows[i]; + const rowSep = rowSeps[i]; + const trailingComment = trailingComments[i]; + content.push(row); + if (rowSep) { + content.push(printRaw(rowSep)); + } + if (rowSep && trailingComment) { + content.push(" "); + } + if (trailingComment) { + content.push(["%", printRaw(trailingComment.content)]); + } + if (rowSep || trailingComment) { + content.push(hardline2); + } + } + if (content[content.length - 1] === hardline2) { + content.pop(); + } + if (leadingComment) { + content.unshift( + leadingComment.leadingWhitespace ? " " : "", + "%" + printRaw(leadingComment.content), + hardline2 + ); + return [env.start, ...args, indent2(content), hardline2, env.end]; + } + return [ + env.start, + ...args, + indent2([hardline2, ...content]), + hardline2, + env.end + ]; +} +function formatAlignedContent(nodes) { + function getSpace(len = 1) { + return " ".repeat(len); + } + const rows = parseAlignEnvironment(nodes); + const numCols = Math.max(...rows.map((r) => r.cells.length)); + const rowSeps = rows.map(({ rowSep }) => printRaw(rowSep || [])); + const trailingComments = rows.map(({ trailingComment }) => trailingComment); + const renderedRows = rows.map(({ cells, colSeps }) => ({ + cells: cells.map((nodes2) => { + trim$1(nodes2); + return printRaw(nodes2); + }), + seps: colSeps.map((nodes2) => printRaw(nodes2)) + })); + const colWidths = []; + for (let i = 0; i < numCols; i++) { + colWidths.push( + Math.max( + ...renderedRows.map( + ({ cells, seps }) => ((cells[i] || "") + (seps[i] || "")).length + ) + ) + ); + } + const joinedRows = renderedRows.map(({ cells, seps }) => { + if (cells.length === 1 && cells[0] === "") { + return ""; + } + let ret = ""; + for (let i = 0; i < cells.length; i++) { + const width = colWidths[i] - (seps[i] || "").length; + ret += (i === 0 ? "" : " ") + cells[i] + getSpace(width - cells[i].length + 1) + (seps[i] || ""); + } + return ret; + }); + return { rows: joinedRows, rowSeps, trailingComments }; +} +var ReferenceMap = class { + constructor(ast) { + this.ast = ast; + this.map = /* @__PURE__ */ new Map(); + visit( + this.ast, + (nodeList) => { + for (let i = 0; i < nodeList.length; i++) { + this.map.set(nodeList[i], { + previous: nodeList[i - 1], + next: nodeList[i + 1] + }); + } + }, + { includeArrays: true, test: Array.isArray } + ); + } + /** + * Associate render-specific data with this node. This data + * will be overwritten if `setRenderCache` is called twice. + * + * @param {Ast.Ast} node + * @param {*} data + * @memberof ReferenceMap + */ + setRenderCache(node, data) { + const currData = this.map.get(node) || {}; + this.map.set(node, { ...currData, renderCache: data }); + } + /** + * Retrieve data associated with `node` via `setRenderCache` + * + * @param {Ast.Ast} node + * @returns {(object | undefined)} + * @memberof ReferenceMap + */ + getRenderCache(node) { + var _a; + return (_a = this.map.get(node)) == null ? void 0 : _a.renderCache; + } + getPreviousNode(node) { + return (this.map.get(node) || {}).previous; + } + getNextNode(node) { + return (this.map.get(node) || {}).next; + } +}; +function printLatexAst(path2, options2, print) { + const node = path2.getValue(); + const { renderInfo } = getNodeInfo(node, options2); + if (node == null) { + return node; + } + if (typeof node === "string") { + return node; + } + switch (node.type) { + case "root": + if (options2.referenceMap) { + console.warn( + "Processing root node, but ReferenceMap already exists. Are there multiple nodes of type 'root'?" + ); + } + options2.referenceMap = new ReferenceMap(node); + return printRoot(path2, print, options2); + case "argument": + return printArgument(path2, print, options2); + case "comment": + return printComment(path2); + case "environment": + case "mathenv": + if (renderInfo.alignContent) { + return printAlignedEnvironment(path2, print, options2); + } + return printEnvironment(path2, print, options2); + case "displaymath": + return printDisplayMath(path2, print, options2); + case "group": + const content = printRaw(node.content, { + asArray: true + }).map((token) => token === linebreak ? hardline2 : token); + return ["{", ...content, "}"]; + case "inlinemath": + return printInlineMath(path2, print, options2); + case "macro": + return printMacro(path2, print, options2); + case "parbreak": + return [hardline2, hardline2]; + case "string": + return node.content; + case "verb": + return [ + ESCAPE, + node.env, + node.escape, + printRaw(node.content), + node.escape + ]; + case "verbatim": + return printVerbatimEnvironment(path2); + case "whitespace": + return line2; + default: + console.warn("Printing unknown type", node); + return printRaw(node); + } +} +var languages$1 = [ + { + name: "latex", + extensions: [".tex"], + parsers: ["latex-parser"] + } +]; +var parsers$1 = { + "latex-parser": { + parse, + astFormat: "latex-ast", + locStart: (node) => node.position ? node.position.start.offset : 0, + locEnd: (node) => node.position ? node.position.end.offset : 1 + } +}; +var printers$1 = { + "latex-ast": { + print: printLatexAst + } +}; +var prettierPluginLatex$1 = { languages: languages$1, parsers: parsers$1, printers: printers$1 }; +const options = {}; +const defaultOptions = { + useTabs: true +}; +const languages = prettierPluginLatex$1.languages; +const parsers = prettierPluginLatex$1.parsers; +const printers = prettierPluginLatex$1.printers; +const prettierPluginLatex = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({ + __proto__: null, + defaultOptions, + languages, + options, + parsers, + printers +}, Symbol.toStringTag, { value: "Module" })); +export { + parsers as a, + printers as b, + defaultOptions as d, + languages as l, + options as o, + prettierPluginLatex as p +}; +//# sourceMappingURL=prettier-plugin-latex-9db821d0.mjs.map diff --git a/node_modules/prettier-plugin-latex/dist/prettier-plugin-latex-f9d12326.js b/node_modules/prettier-plugin-latex/dist/prettier-plugin-latex-f9d12326.js new file mode 100644 index 0000000..219ffea --- /dev/null +++ b/node_modules/prettier-plugin-latex/dist/prettier-plugin-latex-f9d12326.js @@ -0,0 +1,24908 @@ +"use strict"; +var __defProp = Object.defineProperty; +var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value; +var __publicField = (obj, key, value) => { + __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value); + return value; +}; +var linebreak = Symbol("linebreak"); +var ESCAPE$1 = "\\"; +function _printRaw(node) { + if (typeof node === "string") { + return [node]; + } + if (Array.isArray(node)) { + return [].concat( + ...node.map((n) => _printRaw(n)) + ); + } + let argsString, escape; + switch (node.type) { + case "root": + return _printRaw(node.content); + case "argument": + return [node.openMark, ..._printRaw(node.content), node.closeMark]; + case "comment": + var suffix = node.suffixParbreak ? "" : linebreak; + var leadingWhitespace = ""; + if (node.sameline && node.leadingWhitespace) { + leadingWhitespace = " "; + } + if (node.sameline) { + return [ + leadingWhitespace, + "%", + ..._printRaw(node.content), + suffix + ]; + } + return [linebreak, "%", ..._printRaw(node.content), suffix]; + case "environment": + case "mathenv": + case "verbatim": + var env = _printRaw(node.env); + var envStart = [ESCAPE$1 + "begin{", ...env, "}"]; + var envEnd = [ESCAPE$1 + "end{", ...env, "}"]; + argsString = node.args == null ? [] : _printRaw(node.args); + return [ + ...envStart, + ...argsString, + ..._printRaw(node.content), + ...envEnd + ]; + case "displaymath": + return [ESCAPE$1 + "[", ..._printRaw(node.content), ESCAPE$1 + "]"]; + case "group": + return ["{", ..._printRaw(node.content), "}"]; + case "inlinemath": + return ["$", ..._printRaw(node.content), "$"]; + case "macro": + argsString = node.args == null ? [] : _printRaw(node.args); + escape = node.escapeToken == null ? ESCAPE$1 : node.escapeToken; + return [escape, ..._printRaw(node.content), ...argsString]; + case "parbreak": + return [linebreak, linebreak]; + case "string": + return [node.content]; + case "verb": + return [ + ESCAPE$1, + node.env, + node.escape, + ..._printRaw(node.content), + node.escape + ]; + case "whitespace": + return [" "]; + default: + console.warn( + "Cannot find render for node ", + node, + `(of type ${typeof node})` + ); + return ["" + node]; + } +} +function printRaw(node, options2) { + const asArray = options2 != null ? options2.asArray : false; + const printedTokens = _printRaw(node); + if (asArray) { + return printedTokens; + } + return printedTokens.map((x) => x === linebreak ? "\n" : x).join(""); +} +function createMacroMatcher(macros17) { + const macrosHash = Array.isArray(macros17) ? macros17.length > 0 ? typeof macros17[0] === "string" ? Object.fromEntries( + macros17.map((macro2) => { + if (typeof macro2 !== "string") { + throw new Error("Wrong branch of map function"); + } + return [macro2, {}]; + }) + ) : Object.fromEntries( + macros17.map((macro2) => { + if (typeof macro2 === "string") { + throw new Error("Wrong branch of map function"); + } + if (macro2.escapeToken != null) { + return [ + macro2.content, + { escapeToken: macro2.escapeToken } + ]; + } + return [macro2.content, {}]; + }) + ) : {} : macros17; + return function matchAgainstMacros(node) { + if (node == null || node.type !== "macro") { + return false; + } + const spec = macrosHash[node.content]; + if (!spec) { + return false; + } + if (typeof spec === "object" && "escapeToken" in spec) { + return spec.escapeToken == null || spec.escapeToken === node.escapeToken; + } + return true; + }; +} +function createEnvironmentMatcher(macros17) { + const environmentsHash = Array.isArray(macros17) ? Object.fromEntries( + macros17.map((str) => { + return [str, {}]; + }) + ) : macros17; + return function matchAgainstEnvironments(node) { + if (!match.anyEnvironment(node)) { + return false; + } + const envName = printRaw(node.env); + const spec = environmentsHash[envName]; + if (!spec) { + return false; + } + return true; + }; +} +var match = { + macro(node, macroName) { + if (node == null) { + return false; + } + return node.type === "macro" && (macroName == null || node.content === macroName); + }, + anyMacro(node) { + return match.macro(node); + }, + environment(node, envName) { + if (node == null) { + return false; + } + return (node.type === "environment" || node.type === "mathenv") && (envName == null || printRaw(node.env) === envName); + }, + anyEnvironment(node) { + return match.environment(node); + }, + comment(node) { + if (node == null) { + return false; + } + return node.type === "comment"; + }, + parbreak(node) { + if (node == null) { + return false; + } + return node.type === "parbreak"; + }, + whitespace(node) { + if (node == null) { + return false; + } + return node.type === "whitespace"; + }, + /** + * Matches whitespace or a comment with leading whitespace. + */ + whitespaceLike(node) { + if (node == null) { + return false; + } + return node.type === "whitespace" || node.type === "whitespace" && node.leadingWhitespace === true; + }, + string(node, value) { + if (node == null) { + return false; + } + return node.type === "string" && (value == null || node.content === value); + }, + anyString(node) { + return match.string(node); + }, + group(node) { + if (node == null) { + return false; + } + return node.type === "group"; + }, + argument(node) { + if (node == null) { + return false; + } + return node.type === "argument"; + }, + blankArgument(node) { + if (!match.argument(node)) { + return false; + } + return node.openMark === "" && node.closeMark === "" && node.content.length === 0; + }, + math(node) { + if (node == null) { + return false; + } + return node.type === "displaymath" || node.type === "inlinemath"; + }, + createMacroMatcher, + createEnvironmentMatcher +}; +function listMathChildren(node) { + const NULL_RETURN = { enter: [], leave: [] }; + if (Array.isArray(node)) { + return NULL_RETURN; + } + if (match.math(node)) { + return { enter: ["content"], leave: [] }; + } + const renderInfo = node._renderInfo || {}; + if (renderInfo.inMathMode == null) { + return NULL_RETURN; + } + if (match.macro(node)) { + if (renderInfo.inMathMode === true) { + return { enter: ["args"], leave: [] }; + } else if (renderInfo.inMathMode === false) { + return { enter: [], leave: ["args"] }; + } + } + if (match.environment(node)) { + if (renderInfo.inMathMode === true) { + return { enter: ["content"], leave: [] }; + } else { + return { enter: [], leave: ["content"] }; + } + } + return NULL_RETURN; +} +var CONTINUE = Symbol("continue"); +var SKIP = Symbol("skip"); +var EXIT = Symbol("exit"); +var DEFAULT_CONTEXT = { + inMathMode: false, + hasMathModeAncestor: false +}; +function visit(tree, visitor, options2) { + const { + startingContext = DEFAULT_CONTEXT, + test = () => true, + includeArrays = false + } = options2 || {}; + let enter; + let leave; + if (typeof visitor === "function") { + enter = visitor; + } else if (visitor && typeof visitor === "object") { + enter = visitor.enter; + leave = visitor.leave; + } + walk(tree, { + key: void 0, + index: void 0, + parents: [], + containingArray: void 0, + context: { ...startingContext } + }); + function walk(node, { key, index: index2, parents, context, containingArray }) { + const nodePassesTest = includeArrays ? test(node, { key, index: index2, parents, context, containingArray }) : !Array.isArray(node) && test(node, { key, index: index2, parents, context, containingArray }); + const result = enter && nodePassesTest ? toResult( + enter(node, { + key, + index: index2, + parents, + context, + containingArray + }) + ) : [CONTINUE]; + if (result[0] === EXIT) { + return result; + } + if (result[0] === SKIP) { + return leave && nodePassesTest ? toResult( + leave(node, { + key, + index: index2, + parents, + context, + containingArray + }) + ) : result; + } + if (Array.isArray(node)) { + for (let index22 = 0; index22 > -1 && index22 < node.length; index22++) { + const item = node[index22]; + const result2 = walk(item, { + key, + index: index22, + parents, + context, + containingArray: node + }); + if (result2[0] === EXIT) { + return result2; + } + if (typeof result2[1] === "number") { + index22 = result2[1] - 1; + } + } + } else { + let childProps = ["content", "args"]; + switch (node.type) { + case "macro": + childProps = ["args"]; + break; + case "comment": + case "string": + case "verb": + case "verbatim": + childProps = []; + break; + } + const mathModeProps = listMathChildren(node); + for (const key2 of childProps) { + const value = node[key2]; + const grandparents = [node].concat(parents); + if (value == null) { + continue; + } + const newContext = { ...context }; + if (mathModeProps.enter.includes(key2)) { + newContext.inMathMode = true; + newContext.hasMathModeAncestor = true; + } else if (mathModeProps.leave.includes(key2)) { + newContext.inMathMode = false; + } + const result2 = walk(value, { + key: key2, + index: void 0, + parents: grandparents, + context: newContext, + containingArray: void 0 + }); + if (result2[0] === EXIT) { + return result2; + } + } + } + return leave && nodePassesTest ? toResult( + leave(node, { + key, + index: index2, + parents, + context, + containingArray + }) + ) : result; + } +} +function toResult(value) { + if (value == null) { + return [CONTINUE]; + } + if (Array.isArray(value)) { + return value; + } + if (typeof value === "number") { + return [CONTINUE, value]; + } + return [value]; +} +function trim$1(nodes) { + if (!Array.isArray(nodes)) { + console.warn("Trying to trim a non-array ast", nodes); + return nodes; + } + const { trimmedStart } = trimStart(nodes); + const { trimmedEnd } = trimEnd(nodes); + return { trimmedStart, trimmedEnd }; +} +function trimStart(nodes) { + const { start } = amountOfLeadingAndTrailingWhitespace(nodes); + nodes.splice(0, start); + for (const leadingToken of nodes) { + if (!match.comment(leadingToken)) { + break; + } + if (leadingToken.leadingWhitespace || leadingToken.sameline) { + leadingToken.leadingWhitespace = false; + delete leadingToken.position; + } + if (start > 0 && leadingToken.sameline) { + leadingToken.sameline = false; + delete leadingToken.position; + } + } + return { trimmedStart: start }; +} +function trimEnd(nodes) { + const { end } = amountOfLeadingAndTrailingWhitespace(nodes); + nodes.splice(nodes.length - end, end); + for (let i = nodes.length - 1; i >= 0; i--) { + const trailingToken = nodes[i]; + if (!match.comment(trailingToken)) { + break; + } + delete trailingToken.suffixParbreak; + if (match.comment(trailingToken) && trailingToken.leadingWhitespace && !trailingToken.sameline) { + trailingToken.leadingWhitespace = false; + delete trailingToken.position; + } + } + return { trimmedEnd: end }; +} +function amountOfLeadingAndTrailingWhitespace(ast) { + let start = 0; + let end = 0; + for (const node of ast) { + if (match.whitespace(node) || match.parbreak(node)) { + start++; + } else { + break; + } + } + if (start === ast.length) { + return { start, end: 0 }; + } + for (let i = ast.length - 1; i >= 0; i--) { + const node = ast[i]; + if (match.whitespace(node) || match.parbreak(node)) { + end++; + } else { + break; + } + } + return { start, end }; +} +var unifiedLatexTrimEnvironmentContents = function unifiedLatexTrimEnvironmentContents2() { + return (tree) => { + visit(tree, (node) => { + if (!(match.math(node) || match.anyEnvironment(node))) { + return; + } + let firstNode = node.content[0]; + if (match.comment(firstNode) && firstNode.sameline) { + firstNode.suffixParbreak = false; + trimEnd(node.content); + const { trimmedStart } = trimStart(node.content.slice(1)); + node.content.splice(1, trimmedStart); + } else { + trim$1(node.content); + } + }); + }; +}; +var unifiedLatexTrimRoot = function unifiedLatexTrimRoot2() { + return (tree) => { + trim$1(tree.content); + }; +}; +function decorateArrayForPegjs(array) { + array.charAt = function(i) { + return this[i]; + }; + array.charCodeAt = () => 0; + array.substring = function(i, j) { + return this.slice(i, j); + }; + array.replace = function(a, b) { + const ret = JSON.stringify(this); + return ret.replace(a, b); + }; + return array; +} +var latex_default = ( + // Generated by Peggy 2.0.1. + // + // https://peggyjs.org/ + function() { + function peg$subclass(child, parent) { + function C() { + this.constructor = child; + } + C.prototype = parent.prototype; + child.prototype = new C(); + } + function peg$SyntaxError(message, expected, found, location) { + var self = Error.call(this, message); + if (Object.setPrototypeOf) { + Object.setPrototypeOf(self, peg$SyntaxError.prototype); + } + self.expected = expected; + self.found = found; + self.location = location; + self.name = "SyntaxError"; + return self; + } + peg$subclass(peg$SyntaxError, Error); + function peg$padEnd(str, targetLength, padString) { + padString = padString || " "; + if (str.length > targetLength) { + return str; + } + targetLength -= str.length; + padString += padString.repeat(targetLength); + return str + padString.slice(0, targetLength); + } + peg$SyntaxError.prototype.format = function(sources) { + var str = "Error: " + this.message; + if (this.location) { + var src = null; + var k; + for (k = 0; k < sources.length; k++) { + if (sources[k].source === this.location.source) { + src = sources[k].text.split(/\r\n|\n|\r/g); + break; + } + } + var s2 = this.location.start; + var loc = this.location.source + ":" + s2.line + ":" + s2.column; + if (src) { + var e = this.location.end; + var filler = peg$padEnd("", s2.line.toString().length, " "); + var line3 = src[s2.line - 1]; + var last = s2.line === e.line ? e.column : line3.length + 1; + var hatLen = last - s2.column || 1; + str += "\n --> " + loc + "\n" + filler + " |\n" + s2.line + " | " + line3 + "\n" + filler + " | " + peg$padEnd("", s2.column - 1, " ") + peg$padEnd("", hatLen, "^"); + } else { + str += "\n at " + loc; + } + } + return str; + }; + peg$SyntaxError.buildMessage = function(expected, found) { + var DESCRIBE_EXPECTATION_FNS = { + literal: function(expectation) { + return '"' + literalEscape(expectation.text) + '"'; + }, + class: function(expectation) { + var escapedParts = expectation.parts.map(function(part) { + return Array.isArray(part) ? classEscape(part[0]) + "-" + classEscape(part[1]) : classEscape(part); + }); + return "[" + (expectation.inverted ? "^" : "") + escapedParts.join("") + "]"; + }, + any: function() { + return "any character"; + }, + end: function() { + return "end of input"; + }, + other: function(expectation) { + return expectation.description; + } + }; + function hex(ch) { + return ch.charCodeAt(0).toString(16).toUpperCase(); + } + function literalEscape(s2) { + return s2.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\0/g, "\\0").replace(/\t/g, "\\t").replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/[\x00-\x0F]/g, function(ch) { + return "\\x0" + hex(ch); + }).replace(/[\x10-\x1F\x7F-\x9F]/g, function(ch) { + return "\\x" + hex(ch); + }); + } + function classEscape(s2) { + return s2.replace(/\\/g, "\\\\").replace(/\]/g, "\\]").replace(/\^/g, "\\^").replace(/-/g, "\\-").replace(/\0/g, "\\0").replace(/\t/g, "\\t").replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/[\x00-\x0F]/g, function(ch) { + return "\\x0" + hex(ch); + }).replace(/[\x10-\x1F\x7F-\x9F]/g, function(ch) { + return "\\x" + hex(ch); + }); + } + function describeExpectation(expectation) { + return DESCRIBE_EXPECTATION_FNS[expectation.type](expectation); + } + function describeExpected(expected2) { + var descriptions = expected2.map(describeExpectation); + var i, j; + descriptions.sort(); + if (descriptions.length > 0) { + for (i = 1, j = 1; i < descriptions.length; i++) { + if (descriptions[i - 1] !== descriptions[i]) { + descriptions[j] = descriptions[i]; + j++; + } + } + descriptions.length = j; + } + switch (descriptions.length) { + case 1: + return descriptions[0]; + case 2: + return descriptions[0] + " or " + descriptions[1]; + default: + return descriptions.slice(0, -1).join(", ") + ", or " + descriptions[descriptions.length - 1]; + } + } + function describeFound(found2) { + return found2 ? '"' + literalEscape(found2) + '"' : "end of input"; + } + return "Expected " + describeExpected(expected) + " but " + describeFound(found) + " found."; + }; + function peg$parse(input, options2) { + options2 = options2 !== void 0 ? options2 : {}; + var peg$FAILED = {}; + var peg$source = options2.grammarSource; + var peg$startRuleFunctions = { document: peg$parsedocument, math: peg$parsemath }; + var peg$startRuleFunction = peg$parsedocument; + var peg$c0 = "%"; + var peg$c1 = "."; + var peg$c2 = "verb*"; + var peg$c3 = "verb"; + var peg$c4 = "["; + var peg$c5 = "]"; + var peg$c6 = "lstinline"; + var peg$c7 = "mintinline"; + var peg$c8 = "mint"; + var peg$c10 = "verbatim*"; + var peg$c11 = "verbatim"; + var peg$c12 = "filecontents*"; + var peg$c13 = "filecontents"; + var peg$c14 = "comment"; + var peg$c15 = "lstlisting"; + var peg$c16 = "("; + var peg$c17 = ")"; + var peg$c18 = "begin"; + var peg$c19 = "end"; + var peg$c20 = "equation*"; + var peg$c21 = "equation"; + var peg$c22 = "align*"; + var peg$c23 = "align"; + var peg$c24 = "alignat*"; + var peg$c25 = "alignat"; + var peg$c26 = "gather*"; + var peg$c27 = "gather"; + var peg$c28 = "multline*"; + var peg$c29 = "multline"; + var peg$c30 = "flalign*"; + var peg$c31 = "flalign"; + var peg$c32 = "split"; + var peg$c33 = "math"; + var peg$c34 = "displaymath"; + var peg$c35 = "\\"; + var peg$c36 = "{"; + var peg$c37 = "}"; + var peg$c38 = "$"; + var peg$c39 = "&"; + var peg$c40 = "\r"; + var peg$c41 = "\n"; + var peg$c42 = "\r\n"; + var peg$c43 = "#"; + var peg$c44 = "^"; + var peg$c45 = "_"; + var peg$c46 = "\0"; + var peg$r0 = /^[^ \t\n\r]/; + var peg$r1 = /^[ \t]/; + var peg$r2 = /^[a-zA-Z]/; + var peg$r3 = /^[0-9]/; + var peg$r4 = /^[.,;:\-*\/()!?=+<>[\]`'"~]/; + var peg$e0 = peg$otherExpectation("document"); + var peg$e1 = peg$otherExpectation("math"); + var peg$e2 = peg$otherExpectation("token"); + var peg$e3 = peg$anyExpectation(); + var peg$e4 = peg$otherExpectation("parbreak"); + var peg$e5 = peg$otherExpectation("math token"); + var peg$e6 = peg$otherExpectation("nonchar token"); + var peg$e7 = peg$literalExpectation("%", false); + var peg$e8 = peg$otherExpectation("whitespace"); + var peg$e9 = peg$otherExpectation("number"); + var peg$e10 = peg$literalExpectation(".", false); + var peg$e11 = peg$otherExpectation("special macro"); + var peg$e12 = peg$literalExpectation("verb*", false); + var peg$e13 = peg$literalExpectation("verb", false); + var peg$e14 = peg$literalExpectation("[", false); + var peg$e15 = peg$literalExpectation("]", false); + var peg$e16 = peg$classExpectation([" ", " ", "\n", "\r"], true, false); + var peg$e17 = peg$otherExpectation("verbatim listings"); + var peg$e18 = peg$literalExpectation("lstinline", false); + var peg$e19 = peg$otherExpectation("verbatim minted"); + var peg$e20 = peg$literalExpectation("mintinline", false); + var peg$e21 = peg$literalExpectation("mint", false); + var peg$e24 = peg$otherExpectation("verbatim environment"); + var peg$e25 = peg$literalExpectation("verbatim*", false); + var peg$e26 = peg$literalExpectation("verbatim", false); + var peg$e27 = peg$literalExpectation("filecontents*", false); + var peg$e28 = peg$literalExpectation("filecontents", false); + var peg$e29 = peg$literalExpectation("comment", false); + var peg$e30 = peg$literalExpectation("lstlisting", false); + var peg$e31 = peg$otherExpectation("macro"); + var peg$e32 = peg$otherExpectation("group"); + var peg$e33 = peg$otherExpectation("environment"); + var peg$e34 = peg$otherExpectation("math environment"); + var peg$e36 = peg$literalExpectation("(", false); + var peg$e37 = peg$literalExpectation(")", false); + var peg$e38 = peg$literalExpectation("begin", false); + var peg$e39 = peg$literalExpectation("end", false); + var peg$e40 = peg$literalExpectation("equation*", false); + var peg$e41 = peg$literalExpectation("equation", false); + var peg$e42 = peg$literalExpectation("align*", false); + var peg$e43 = peg$literalExpectation("align", false); + var peg$e44 = peg$literalExpectation("alignat*", false); + var peg$e45 = peg$literalExpectation("alignat", false); + var peg$e46 = peg$literalExpectation("gather*", false); + var peg$e47 = peg$literalExpectation("gather", false); + var peg$e48 = peg$literalExpectation("multline*", false); + var peg$e49 = peg$literalExpectation("multline", false); + var peg$e50 = peg$literalExpectation("flalign*", false); + var peg$e51 = peg$literalExpectation("flalign", false); + var peg$e52 = peg$literalExpectation("split", false); + var peg$e53 = peg$literalExpectation("math", false); + var peg$e54 = peg$literalExpectation("displaymath", false); + var peg$e55 = peg$otherExpectation("escape"); + var peg$e56 = peg$literalExpectation("\\", false); + var peg$e57 = peg$literalExpectation("{", false); + var peg$e58 = peg$literalExpectation("}", false); + var peg$e59 = peg$literalExpectation("$", false); + var peg$e60 = peg$literalExpectation("&", false); + var peg$e61 = peg$otherExpectation("newline"); + var peg$e62 = peg$literalExpectation("\r", false); + var peg$e63 = peg$literalExpectation("\n", false); + var peg$e64 = peg$literalExpectation("\r\n", false); + var peg$e65 = peg$literalExpectation("#", false); + var peg$e66 = peg$literalExpectation("^", false); + var peg$e67 = peg$literalExpectation("_", false); + var peg$e68 = peg$literalExpectation("\0", false); + var peg$e69 = peg$classExpectation([" ", " "], false, false); + var peg$e70 = peg$otherExpectation("letter"); + var peg$e71 = peg$classExpectation([["a", "z"], ["A", "Z"]], false, false); + var peg$e72 = peg$otherExpectation("digit"); + var peg$e73 = peg$classExpectation([["0", "9"]], false, false); + var peg$e74 = peg$otherExpectation("punctuation"); + var peg$e75 = peg$classExpectation([".", ",", ";", ":", "-", "*", "/", "(", ")", "!", "?", "=", "+", "<", ">", "[", "]", "`", "'", '"', "~"], false, false); + var peg$e76 = peg$otherExpectation("full comment"); + var peg$e77 = peg$otherExpectation("comment"); + var peg$f0 = function(content) { + return createNode("root", { content: content.flatMap((x) => x) }); + }; + var peg$f1 = function(t) { + return t; + }; + var peg$f2 = function(eq) { + return createNode("inlinemath", { content: eq.flatMap((x) => x) }); + }; + var peg$f3 = function(s2) { + return createNode("string", { content: s2 }); + }; + var peg$f4 = function(s2) { + return createNode("string", { content: s2 }); + }; + var peg$f5 = function() { + return createNode("parbreak"); + }; + var peg$f6 = function(x) { + return x; + }; + var peg$f7 = function(x) { + return x; + }; + var peg$f8 = function() { + return createNode("macro", { content: "^", escapeToken: "" }); + }; + var peg$f9 = function() { + return createNode("macro", { content: "_", escapeToken: "" }); + }; + var peg$f10 = function(s2) { + return createNode("string", { content: s2 }); + }; + var peg$f11 = function() { + return createNode("whitespace"); + }; + var peg$f12 = function(a, b) { + return a.join("") + "." + b.join(""); + }; + var peg$f13 = function(b) { + return "." + b.join(""); + }; + var peg$f14 = function(a) { + return a.join("") + "."; + }; + var peg$f15 = function(s2) { + return createNode("string", { content: s2 }); + }; + var peg$f16 = function(env, e, end) { + return end == e; + }; + var peg$f17 = function(env, e, x) { + return x; + }; + var peg$f18 = function(env, e, x, end) { + return end == e; + }; + var peg$f19 = function(env, e, x) { + return createNode("verb", { + env, + escape: e, + content: x.join("") + }); + }; + var peg$f20 = function(x) { + return x; + }; + var peg$f21 = function(x) { + return createNode("displaymath", { content: x.flatMap((x2) => x2) }); + }; + var peg$f22 = function(x) { + return x; + }; + var peg$f23 = function(x) { + return createNode("inlinemath", { content: x.flatMap((x2) => x2) }); + }; + var peg$f24 = function(x) { + return x; + }; + var peg$f25 = function(x) { + return createNode("displaymath", { content: x.flatMap((x2) => x2) }); + }; + var peg$f26 = function(end) { + return end.type === "string" && end.content === "]"; + }; + var peg$f27 = function(x) { + return x; + }; + var peg$f28 = function(o) { + return [ + createNode("string", { content: "[" }), + ...o, + createNode("string", { content: "]" }) + ]; + }; + var peg$f29 = function(x) { + return x; + }; + var peg$f30 = function(v) { + return createNode("group", { + content: createNode("string", { content: v.join("") }) + }); + }; + var peg$f31 = function(d, end) { + return end == d; + }; + var peg$f32 = function(d, x) { + return x; + }; + var peg$f33 = function(d, v, end) { + return end == d; + }; + var peg$f34 = function(d, v) { + return [ + createNode("string", { content: d }), + createNode("string", { content: v.join("") }), + createNode("string", { content: d }) + ]; + }; + var peg$f35 = function(macro, option, verbatim) { + return [ + createNode("macro", { content: macro }), + ...option || [], + ...[].concat(verbatim) + ]; + }; + var peg$f36 = function(macro, option, language, verbatim) { + return [ + createNode("macro", { content: macro }), + ...option || [], + language, + ...[].concat(verbatim) + ]; + }; + var peg$f40 = function(env, end_env) { + return compare_env({ content: [env] }, end_env); + }; + var peg$f41 = function(env, x) { + return x; + }; + var peg$f42 = function(env, body) { + return createNode("verbatim", { + env, + content: body.join("") + }); + }; + var peg$f43 = function(n) { + return n.join(""); + }; + var peg$f44 = function(n) { + return n; + }; + var peg$f45 = function(m) { + return createNode("macro", { content: m }); + }; + var peg$f46 = function(c) { + return c; + }; + var peg$f47 = function(x) { + return createNode("group", { content: x.flatMap((x2) => x2) }); + }; + var peg$f48 = function(g) { + return text().slice(1, -1); + }; + var peg$f49 = function(env, env_comment, end_env) { + return compare_env(env, end_env); + }; + var peg$f50 = function(env, env_comment, x) { + return x; + }; + var peg$f51 = function(env, env_comment, body) { + body = body.flatMap((x) => x); + return createNode("environment", { + env, + content: env_comment ? [env_comment, ...body] : body + }); + }; + var peg$f52 = function(env, env_comment, end_env) { + return compare_env({ content: [env] }, end_env); + }; + var peg$f53 = function(env, env_comment, x) { + return x; + }; + var peg$f54 = function(env, env_comment, body) { + body = body.flatMap((x) => x); + return createNode("mathenv", { + env, + content: env_comment ? [env_comment, ...body] : body + }); + }; + var peg$f57 = function(e) { + return createNode("string", { content: e }); + }; + var peg$f58 = function() { + return createNode("string", { content: "\\" }); + }; + var peg$f59 = function(s2) { + return createNode("string", { content: s2 }); + }; + var peg$f60 = function(s2) { + return createNode("string", { content: s2 }); + }; + var peg$f61 = function(s2) { + return createNode("string", { content: s2 }); + }; + var peg$f62 = function(s2) { + return createNode("string", { content: s2 }); + }; + var peg$f63 = function(s2) { + return createNode("string", { content: s2 }); + }; + var peg$f64 = function(s2) { + return createNode("string", { content: s2 }); + }; + var peg$f65 = function(s2) { + return createNode("string", { content: s2 }); + }; + var peg$f66 = function() { + return " "; + }; + var peg$f67 = function(p) { + return createNode("string", { content: p }); + }; + var peg$f68 = function(leading_sp, comment) { + return createNode("comment", { + ...comment, + sameline: false, + leadingWhitespace: leading_sp.length > 0 + }); + }; + var peg$f69 = function(spaces, x) { + return createNode("comment", { + ...x, + sameline: true, + leadingWhitespace: spaces.length > 0 + }); + }; + var peg$f70 = function(c) { + return c; + }; + var peg$f71 = function(c) { + return { content: c.join(""), suffixParbreak: true }; + }; + var peg$f72 = function(c) { + return c; + }; + var peg$f73 = function(c) { + return { content: c.join("") }; + }; + var peg$f74 = function() { + var loc = location(); + return loc.start.column === 1; + }; + var peg$currPos = 0; + var peg$savedPos = 0; + var peg$posDetailsCache = [{ line: 1, column: 1 }]; + var peg$maxFailPos = 0; + var peg$maxFailExpected = []; + var peg$silentFails = 0; + var peg$result; + if ("startRule" in options2) { + if (!(options2.startRule in peg$startRuleFunctions)) { + throw new Error(`Can't start parsing from rule "` + options2.startRule + '".'); + } + peg$startRuleFunction = peg$startRuleFunctions[options2.startRule]; + } + function text() { + return input.substring(peg$savedPos, peg$currPos); + } + function location() { + return peg$computeLocation(peg$savedPos, peg$currPos); + } + function peg$literalExpectation(text2, ignoreCase) { + return { type: "literal", text: text2, ignoreCase }; + } + function peg$classExpectation(parts, inverted, ignoreCase) { + return { type: "class", parts, inverted, ignoreCase }; + } + function peg$anyExpectation() { + return { type: "any" }; + } + function peg$endExpectation() { + return { type: "end" }; + } + function peg$otherExpectation(description) { + return { type: "other", description }; + } + function peg$computePosDetails(pos) { + var details = peg$posDetailsCache[pos]; + var p; + if (details) { + return details; + } else { + p = pos - 1; + while (!peg$posDetailsCache[p]) { + p--; + } + details = peg$posDetailsCache[p]; + details = { + line: details.line, + column: details.column + }; + while (p < pos) { + if (input.charCodeAt(p) === 10) { + details.line++; + details.column = 1; + } else { + details.column++; + } + p++; + } + peg$posDetailsCache[pos] = details; + return details; + } + } + function peg$computeLocation(startPos, endPos) { + var startPosDetails = peg$computePosDetails(startPos); + var endPosDetails = peg$computePosDetails(endPos); + return { + source: peg$source, + start: { + offset: startPos, + line: startPosDetails.line, + column: startPosDetails.column + }, + end: { + offset: endPos, + line: endPosDetails.line, + column: endPosDetails.column + } + }; + } + function peg$fail(expected2) { + if (peg$currPos < peg$maxFailPos) { + return; + } + if (peg$currPos > peg$maxFailPos) { + peg$maxFailPos = peg$currPos; + peg$maxFailExpected = []; + } + peg$maxFailExpected.push(expected2); + } + function peg$buildStructuredError(expected2, found, location2) { + return new peg$SyntaxError( + peg$SyntaxError.buildMessage(expected2, found), + expected2, + found, + location2 + ); + } + function peg$parsedocument() { + var s0, s1, s2; + peg$silentFails++; + s0 = peg$currPos; + s1 = []; + s2 = peg$parsetoken(); + while (s2 !== peg$FAILED) { + s1.push(s2); + s2 = peg$parsetoken(); + } + peg$savedPos = s0; + s1 = peg$f0(s1); + s0 = s1; + peg$silentFails--; + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + return s0; + } + function peg$parsemath() { + var s0, s1; + peg$silentFails++; + s0 = []; + s1 = peg$parsemath_token(); + while (s1 !== peg$FAILED) { + s0.push(s1); + s1 = peg$parsemath_token(); + } + peg$silentFails--; + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e1); + } + return s0; + } + function peg$parsetoken() { + var s0, s1, s2, s3, s4, s5; + peg$silentFails++; + s0 = peg$parsespecial_macro(); + if (s0 === peg$FAILED) { + s0 = peg$parsemacro(); + if (s0 === peg$FAILED) { + s0 = peg$parsefull_comment(); + if (s0 === peg$FAILED) { + s0 = peg$parsegroup(); + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$parsemath_shift(); + if (s1 !== peg$FAILED) { + s2 = []; + s3 = peg$currPos; + s4 = peg$currPos; + peg$silentFails++; + s5 = peg$parsemath_shift(); + peg$silentFails--; + if (s5 === peg$FAILED) { + s4 = void 0; + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + if (s4 !== peg$FAILED) { + s5 = peg$parsemath_token(); + if (s5 !== peg$FAILED) { + peg$savedPos = s3; + s3 = peg$f1(s5); + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + if (s3 !== peg$FAILED) { + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$currPos; + s4 = peg$currPos; + peg$silentFails++; + s5 = peg$parsemath_shift(); + peg$silentFails--; + if (s5 === peg$FAILED) { + s4 = void 0; + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + if (s4 !== peg$FAILED) { + s5 = peg$parsemath_token(); + if (s5 !== peg$FAILED) { + peg$savedPos = s3; + s3 = peg$f1(s5); + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s3 = peg$parsemath_shift(); + if (s3 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f2(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$parsealignment_tab(); + if (s0 === peg$FAILED) { + s0 = peg$parseparbreak(); + if (s0 === peg$FAILED) { + s0 = peg$parsemacro_parameter(); + if (s0 === peg$FAILED) { + s0 = peg$parseignore(); + if (s0 === peg$FAILED) { + s0 = peg$parsenumber(); + if (s0 === peg$FAILED) { + s0 = peg$parsewhitespace(); + if (s0 === peg$FAILED) { + s0 = peg$parsepunctuation(); + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$currPos; + s2 = []; + s3 = peg$currPos; + s4 = peg$currPos; + peg$silentFails++; + s5 = peg$parsenonchar_token(); + peg$silentFails--; + if (s5 === peg$FAILED) { + s4 = void 0; + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + if (s4 !== peg$FAILED) { + if (input.length > peg$currPos) { + s5 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s5 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s5 !== peg$FAILED) { + s4 = [s4, s5]; + s3 = s4; + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + if (s3 !== peg$FAILED) { + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$currPos; + s4 = peg$currPos; + peg$silentFails++; + s5 = peg$parsenonchar_token(); + peg$silentFails--; + if (s5 === peg$FAILED) { + s4 = void 0; + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + if (s4 !== peg$FAILED) { + if (input.length > peg$currPos) { + s5 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s5 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s5 !== peg$FAILED) { + s4 = [s4, s5]; + s3 = s4; + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s1 = input.substring(s1, peg$currPos); + } else { + s1 = s2; + } + if (s1 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$f3(s1); + } + s0 = s1; + if (s0 === peg$FAILED) { + s0 = peg$parsebegin_group(); + if (s0 === peg$FAILED) { + s0 = peg$parseend_group(); + if (s0 === peg$FAILED) { + s0 = peg$parsemath_shift(); + if (s0 === peg$FAILED) { + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s1 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$f4(s1); + } + s0 = s1; + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e2); + } + } + return s0; + } + function peg$parseparbreak() { + var s0, s1, s2, s3, s4, s5, s6, s7; + peg$silentFails++; + s0 = peg$currPos; + s1 = peg$currPos; + s2 = []; + s3 = peg$parsesp(); + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$parsesp(); + } + s3 = peg$parsenl(); + if (s3 !== peg$FAILED) { + s4 = []; + s5 = peg$currPos; + s6 = []; + s7 = peg$parsesp(); + while (s7 !== peg$FAILED) { + s6.push(s7); + s7 = peg$parsesp(); + } + s7 = peg$parsenl(); + if (s7 !== peg$FAILED) { + s6 = [s6, s7]; + s5 = s6; + } else { + peg$currPos = s5; + s5 = peg$FAILED; + } + if (s5 !== peg$FAILED) { + while (s5 !== peg$FAILED) { + s4.push(s5); + s5 = peg$currPos; + s6 = []; + s7 = peg$parsesp(); + while (s7 !== peg$FAILED) { + s6.push(s7); + s7 = peg$parsesp(); + } + s7 = peg$parsenl(); + if (s7 !== peg$FAILED) { + s6 = [s6, s7]; + s5 = s6; + } else { + peg$currPos = s5; + s5 = peg$FAILED; + } + } + } else { + s4 = peg$FAILED; + } + if (s4 !== peg$FAILED) { + s5 = []; + s6 = peg$parsesp(); + while (s6 !== peg$FAILED) { + s5.push(s6); + s6 = peg$parsesp(); + } + s6 = peg$currPos; + peg$silentFails++; + s7 = peg$parsecomment_start(); + peg$silentFails--; + if (s7 === peg$FAILED) { + s6 = void 0; + } else { + peg$currPos = s6; + s6 = peg$FAILED; + } + if (s6 !== peg$FAILED) { + s2 = [s2, s3, s4, s5, s6]; + s1 = s2; + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + if (s1 === peg$FAILED) { + s1 = peg$currPos; + s2 = []; + s3 = peg$parsesp(); + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$parsesp(); + } + s3 = peg$parsenl(); + if (s3 !== peg$FAILED) { + s4 = []; + s5 = peg$currPos; + s6 = []; + s7 = peg$parsesp(); + while (s7 !== peg$FAILED) { + s6.push(s7); + s7 = peg$parsesp(); + } + s7 = peg$parsenl(); + if (s7 !== peg$FAILED) { + s6 = [s6, s7]; + s5 = s6; + } else { + peg$currPos = s5; + s5 = peg$FAILED; + } + if (s5 !== peg$FAILED) { + while (s5 !== peg$FAILED) { + s4.push(s5); + s5 = peg$currPos; + s6 = []; + s7 = peg$parsesp(); + while (s7 !== peg$FAILED) { + s6.push(s7); + s7 = peg$parsesp(); + } + s7 = peg$parsenl(); + if (s7 !== peg$FAILED) { + s6 = [s6, s7]; + s5 = s6; + } else { + peg$currPos = s5; + s5 = peg$FAILED; + } + } + } else { + s4 = peg$FAILED; + } + if (s4 !== peg$FAILED) { + s2 = [s2, s3, s4]; + s1 = s2; + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + } + if (s1 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$f5(); + } + s0 = s1; + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e4); + } + } + return s0; + } + function peg$parsemath_token() { + var s0, s1, s2, s3, s4; + peg$silentFails++; + s0 = peg$parsespecial_macro(); + if (s0 === peg$FAILED) { + s0 = peg$parsemacro(); + if (s0 === peg$FAILED) { + s0 = peg$parsefull_comment(); + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = []; + s2 = peg$parsewhitespace(); + while (s2 !== peg$FAILED) { + s1.push(s2); + s2 = peg$parsewhitespace(); + } + s2 = peg$parsegroup(); + if (s2 !== peg$FAILED) { + s3 = []; + s4 = peg$parsewhitespace(); + while (s4 !== peg$FAILED) { + s3.push(s4); + s4 = peg$parsewhitespace(); + } + peg$savedPos = s0; + s0 = peg$f6(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = []; + s2 = peg$parsewhitespace(); + while (s2 !== peg$FAILED) { + s1.push(s2); + s2 = peg$parsewhitespace(); + } + s2 = peg$parsealignment_tab(); + if (s2 !== peg$FAILED) { + s3 = []; + s4 = peg$parsewhitespace(); + while (s4 !== peg$FAILED) { + s3.push(s4); + s4 = peg$parsewhitespace(); + } + peg$savedPos = s0; + s0 = peg$f7(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$parsemacro_parameter(); + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = []; + s2 = peg$parsewhitespace(); + while (s2 !== peg$FAILED) { + s1.push(s2); + s2 = peg$parsewhitespace(); + } + s2 = peg$parsesuperscript(); + if (s2 !== peg$FAILED) { + s3 = []; + s4 = peg$parsewhitespace(); + while (s4 !== peg$FAILED) { + s3.push(s4); + s4 = peg$parsewhitespace(); + } + peg$savedPos = s0; + s0 = peg$f8(); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = []; + s2 = peg$parsewhitespace(); + while (s2 !== peg$FAILED) { + s1.push(s2); + s2 = peg$parsewhitespace(); + } + s2 = peg$parsesubscript(); + if (s2 !== peg$FAILED) { + s3 = []; + s4 = peg$parsewhitespace(); + while (s4 !== peg$FAILED) { + s3.push(s4); + s4 = peg$parsewhitespace(); + } + peg$savedPos = s0; + s0 = peg$f9(); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$parseignore(); + if (s0 === peg$FAILED) { + s0 = peg$parsewhitespace(); + if (s0 === peg$FAILED) { + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s1 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$f10(s1); + } + s0 = s1; + } + } + } + } + } + } + } + } + } + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e5); + } + } + return s0; + } + function peg$parsenonchar_token() { + var s0; + peg$silentFails++; + s0 = peg$parseescape(); + if (s0 === peg$FAILED) { + if (input.charCodeAt(peg$currPos) === 37) { + s0 = peg$c0; + peg$currPos++; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e7); + } + } + if (s0 === peg$FAILED) { + s0 = peg$parsebegin_group(); + if (s0 === peg$FAILED) { + s0 = peg$parseend_group(); + if (s0 === peg$FAILED) { + s0 = peg$parsemath_shift(); + if (s0 === peg$FAILED) { + s0 = peg$parsealignment_tab(); + if (s0 === peg$FAILED) { + s0 = peg$parsenl(); + if (s0 === peg$FAILED) { + s0 = peg$parsemacro_parameter(); + if (s0 === peg$FAILED) { + s0 = peg$parseignore(); + if (s0 === peg$FAILED) { + s0 = peg$parsesp(); + if (s0 === peg$FAILED) { + s0 = peg$parsepunctuation(); + if (s0 === peg$FAILED) { + s0 = peg$parseEOF(); + } + } + } + } + } + } + } + } + } + } + } + peg$silentFails--; + if (s0 === peg$FAILED) { + if (peg$silentFails === 0) { + peg$fail(peg$e6); + } + } + return s0; + } + function peg$parsewhitespace() { + var s0, s1, s2, s3, s4, s5, s6, s7; + peg$silentFails++; + s0 = peg$currPos; + s1 = peg$currPos; + s2 = peg$parsenl(); + if (s2 !== peg$FAILED) { + s3 = []; + s4 = peg$parsesp(); + while (s4 !== peg$FAILED) { + s3.push(s4); + s4 = peg$parsesp(); + } + s2 = [s2, s3]; + s1 = s2; + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + if (s1 === peg$FAILED) { + s1 = peg$currPos; + s2 = []; + s3 = peg$parsesp(); + if (s3 !== peg$FAILED) { + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$parsesp(); + } + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s3 = peg$parsenl(); + if (s3 !== peg$FAILED) { + s4 = peg$currPos; + peg$silentFails++; + s5 = peg$parsecomment_start(); + peg$silentFails--; + if (s5 === peg$FAILED) { + s4 = void 0; + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + if (s4 !== peg$FAILED) { + s5 = []; + s6 = peg$parsesp(); + while (s6 !== peg$FAILED) { + s5.push(s6); + s6 = peg$parsesp(); + } + s6 = peg$currPos; + peg$silentFails++; + s7 = peg$parsenl(); + peg$silentFails--; + if (s7 === peg$FAILED) { + s6 = void 0; + } else { + peg$currPos = s6; + s6 = peg$FAILED; + } + if (s6 !== peg$FAILED) { + s2 = [s2, s3, s4, s5, s6]; + s1 = s2; + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + if (s1 === peg$FAILED) { + s1 = []; + s2 = peg$parsesp(); + if (s2 !== peg$FAILED) { + while (s2 !== peg$FAILED) { + s1.push(s2); + s2 = peg$parsesp(); + } + } else { + s1 = peg$FAILED; + } + } + } + if (s1 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$f11(); + } + s0 = s1; + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e8); + } + } + return s0; + } + function peg$parsenumber() { + var s0, s1, s2, s3, s4, s5; + peg$silentFails++; + s0 = peg$currPos; + s1 = peg$currPos; + s2 = []; + s3 = peg$parsenum(); + if (s3 !== peg$FAILED) { + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$parsenum(); + } + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + if (input.charCodeAt(peg$currPos) === 46) { + s3 = peg$c1; + peg$currPos++; + } else { + s3 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e10); + } + } + if (s3 !== peg$FAILED) { + s4 = []; + s5 = peg$parsenum(); + if (s5 !== peg$FAILED) { + while (s5 !== peg$FAILED) { + s4.push(s5); + s5 = peg$parsenum(); + } + } else { + s4 = peg$FAILED; + } + if (s4 !== peg$FAILED) { + peg$savedPos = s1; + s1 = peg$f12(s2, s4); + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + if (s1 === peg$FAILED) { + s1 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 46) { + s2 = peg$c1; + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e10); + } + } + if (s2 !== peg$FAILED) { + s3 = []; + s4 = peg$parsenum(); + if (s4 !== peg$FAILED) { + while (s4 !== peg$FAILED) { + s3.push(s4); + s4 = peg$parsenum(); + } + } else { + s3 = peg$FAILED; + } + if (s3 !== peg$FAILED) { + peg$savedPos = s1; + s1 = peg$f13(s3); + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + if (s1 === peg$FAILED) { + s1 = peg$currPos; + s2 = []; + s3 = peg$parsenum(); + if (s3 !== peg$FAILED) { + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$parsenum(); + } + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + if (input.charCodeAt(peg$currPos) === 46) { + s3 = peg$c1; + peg$currPos++; + } else { + s3 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e10); + } + } + if (s3 !== peg$FAILED) { + peg$savedPos = s1; + s1 = peg$f14(s2); + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + } + } + if (s1 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$f15(s1); + } + s0 = s1; + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e9); + } + } + return s0; + } + function peg$parsespecial_macro() { + var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9; + peg$silentFails++; + s0 = peg$currPos; + s1 = peg$parseescape(); + if (s1 !== peg$FAILED) { + if (input.substr(peg$currPos, 5) === peg$c2) { + s2 = peg$c2; + peg$currPos += 5; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e12); + } + } + if (s2 === peg$FAILED) { + if (input.substr(peg$currPos, 4) === peg$c3) { + s2 = peg$c3; + peg$currPos += 4; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e13); + } + } + } + if (s2 !== peg$FAILED) { + if (input.length > peg$currPos) { + s3 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s3 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s3 !== peg$FAILED) { + s4 = []; + s5 = peg$currPos; + s6 = peg$currPos; + peg$silentFails++; + s7 = peg$currPos; + if (input.length > peg$currPos) { + s8 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s8 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s8 !== peg$FAILED) { + peg$savedPos = peg$currPos; + s9 = peg$f16(s2, s3, s8); + if (s9) { + s9 = void 0; + } else { + s9 = peg$FAILED; + } + if (s9 !== peg$FAILED) { + s8 = [s8, s9]; + s7 = s8; + } else { + peg$currPos = s7; + s7 = peg$FAILED; + } + } else { + peg$currPos = s7; + s7 = peg$FAILED; + } + peg$silentFails--; + if (s7 === peg$FAILED) { + s6 = void 0; + } else { + peg$currPos = s6; + s6 = peg$FAILED; + } + if (s6 !== peg$FAILED) { + if (input.length > peg$currPos) { + s7 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s7 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s7 !== peg$FAILED) { + peg$savedPos = s5; + s5 = peg$f17(s2, s3, s7); + } else { + peg$currPos = s5; + s5 = peg$FAILED; + } + } else { + peg$currPos = s5; + s5 = peg$FAILED; + } + while (s5 !== peg$FAILED) { + s4.push(s5); + s5 = peg$currPos; + s6 = peg$currPos; + peg$silentFails++; + s7 = peg$currPos; + if (input.length > peg$currPos) { + s8 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s8 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s8 !== peg$FAILED) { + peg$savedPos = peg$currPos; + s9 = peg$f16(s2, s3, s8); + if (s9) { + s9 = void 0; + } else { + s9 = peg$FAILED; + } + if (s9 !== peg$FAILED) { + s8 = [s8, s9]; + s7 = s8; + } else { + peg$currPos = s7; + s7 = peg$FAILED; + } + } else { + peg$currPos = s7; + s7 = peg$FAILED; + } + peg$silentFails--; + if (s7 === peg$FAILED) { + s6 = void 0; + } else { + peg$currPos = s6; + s6 = peg$FAILED; + } + if (s6 !== peg$FAILED) { + if (input.length > peg$currPos) { + s7 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s7 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s7 !== peg$FAILED) { + peg$savedPos = s5; + s5 = peg$f17(s2, s3, s7); + } else { + peg$currPos = s5; + s5 = peg$FAILED; + } + } else { + peg$currPos = s5; + s5 = peg$FAILED; + } + } + s5 = peg$currPos; + if (input.length > peg$currPos) { + s6 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s6 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s6 !== peg$FAILED) { + peg$savedPos = peg$currPos; + s7 = peg$f18(s2, s3, s4, s6); + if (s7) { + s7 = void 0; + } else { + s7 = peg$FAILED; + } + if (s7 !== peg$FAILED) { + s6 = [s6, s7]; + s5 = s6; + } else { + peg$currPos = s5; + s5 = peg$FAILED; + } + } else { + peg$currPos = s5; + s5 = peg$FAILED; + } + if (s5 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f19(s2, s3, s4); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$parseverbatim_listings(); + if (s0 === peg$FAILED) { + s0 = peg$parseverbatim_minted(); + if (s0 === peg$FAILED) { + s0 = peg$parseverbatim_environment(); + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$parsebegin_display_math(); + if (s1 !== peg$FAILED) { + s2 = []; + s3 = peg$currPos; + s4 = peg$currPos; + peg$silentFails++; + s5 = peg$parseend_display_math(); + peg$silentFails--; + if (s5 === peg$FAILED) { + s4 = void 0; + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + if (s4 !== peg$FAILED) { + s5 = peg$parsemath_token(); + if (s5 !== peg$FAILED) { + peg$savedPos = s3; + s3 = peg$f20(s5); + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$currPos; + s4 = peg$currPos; + peg$silentFails++; + s5 = peg$parseend_display_math(); + peg$silentFails--; + if (s5 === peg$FAILED) { + s4 = void 0; + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + if (s4 !== peg$FAILED) { + s5 = peg$parsemath_token(); + if (s5 !== peg$FAILED) { + peg$savedPos = s3; + s3 = peg$f20(s5); + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } + s3 = peg$parseend_display_math(); + if (s3 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f21(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$parsebegin_inline_math(); + if (s1 !== peg$FAILED) { + s2 = []; + s3 = peg$currPos; + s4 = peg$currPos; + peg$silentFails++; + s5 = peg$parseend_inline_math(); + peg$silentFails--; + if (s5 === peg$FAILED) { + s4 = void 0; + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + if (s4 !== peg$FAILED) { + s5 = peg$parsemath_token(); + if (s5 !== peg$FAILED) { + peg$savedPos = s3; + s3 = peg$f22(s5); + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$currPos; + s4 = peg$currPos; + peg$silentFails++; + s5 = peg$parseend_inline_math(); + peg$silentFails--; + if (s5 === peg$FAILED) { + s4 = void 0; + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + if (s4 !== peg$FAILED) { + s5 = peg$parsemath_token(); + if (s5 !== peg$FAILED) { + peg$savedPos = s3; + s3 = peg$f22(s5); + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } + s3 = peg$parseend_inline_math(); + if (s3 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f23(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$parsemath_shift(); + if (s1 !== peg$FAILED) { + s2 = peg$parsemath_shift(); + if (s2 !== peg$FAILED) { + s3 = []; + s4 = peg$currPos; + s5 = peg$currPos; + peg$silentFails++; + s6 = peg$currPos; + s7 = peg$parsemath_shift(); + if (s7 !== peg$FAILED) { + s8 = peg$parsemath_shift(); + if (s8 !== peg$FAILED) { + s7 = [s7, s8]; + s6 = s7; + } else { + peg$currPos = s6; + s6 = peg$FAILED; + } + } else { + peg$currPos = s6; + s6 = peg$FAILED; + } + peg$silentFails--; + if (s6 === peg$FAILED) { + s5 = void 0; + } else { + peg$currPos = s5; + s5 = peg$FAILED; + } + if (s5 !== peg$FAILED) { + s6 = peg$parsemath_token(); + if (s6 !== peg$FAILED) { + peg$savedPos = s4; + s4 = peg$f24(s6); + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + while (s4 !== peg$FAILED) { + s3.push(s4); + s4 = peg$currPos; + s5 = peg$currPos; + peg$silentFails++; + s6 = peg$currPos; + s7 = peg$parsemath_shift(); + if (s7 !== peg$FAILED) { + s8 = peg$parsemath_shift(); + if (s8 !== peg$FAILED) { + s7 = [s7, s8]; + s6 = s7; + } else { + peg$currPos = s6; + s6 = peg$FAILED; + } + } else { + peg$currPos = s6; + s6 = peg$FAILED; + } + peg$silentFails--; + if (s6 === peg$FAILED) { + s5 = void 0; + } else { + peg$currPos = s5; + s5 = peg$FAILED; + } + if (s5 !== peg$FAILED) { + s6 = peg$parsemath_token(); + if (s6 !== peg$FAILED) { + peg$savedPos = s4; + s4 = peg$f24(s6); + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + } + s4 = peg$parsemath_shift(); + if (s4 !== peg$FAILED) { + s5 = peg$parsemath_shift(); + if (s5 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f25(s3); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$parsemath_environment(); + if (s0 === peg$FAILED) { + s0 = peg$parseenvironment(); + } + } + } + } + } + } + } + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e11); + } + } + return s0; + } + function peg$parsesquare_bracket_argument() { + var s0, s1, s2, s3, s4, s5, s6, s7; + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 91) { + s1 = peg$c4; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e14); + } + } + if (s1 !== peg$FAILED) { + s2 = []; + s3 = peg$currPos; + s4 = peg$currPos; + peg$silentFails++; + s5 = peg$currPos; + s6 = peg$parsetoken(); + if (s6 !== peg$FAILED) { + peg$savedPos = peg$currPos; + s7 = peg$f26(s6); + if (s7) { + s7 = void 0; + } else { + s7 = peg$FAILED; + } + if (s7 !== peg$FAILED) { + s6 = [s6, s7]; + s5 = s6; + } else { + peg$currPos = s5; + s5 = peg$FAILED; + } + } else { + peg$currPos = s5; + s5 = peg$FAILED; + } + peg$silentFails--; + if (s5 === peg$FAILED) { + s4 = void 0; + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + if (s4 !== peg$FAILED) { + s5 = peg$parsetoken(); + if (s5 !== peg$FAILED) { + peg$savedPos = s3; + s3 = peg$f27(s5); + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$currPos; + s4 = peg$currPos; + peg$silentFails++; + s5 = peg$currPos; + s6 = peg$parsetoken(); + if (s6 !== peg$FAILED) { + peg$savedPos = peg$currPos; + s7 = peg$f26(s6); + if (s7) { + s7 = void 0; + } else { + s7 = peg$FAILED; + } + if (s7 !== peg$FAILED) { + s6 = [s6, s7]; + s5 = s6; + } else { + peg$currPos = s5; + s5 = peg$FAILED; + } + } else { + peg$currPos = s5; + s5 = peg$FAILED; + } + peg$silentFails--; + if (s5 === peg$FAILED) { + s4 = void 0; + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + if (s4 !== peg$FAILED) { + s5 = peg$parsetoken(); + if (s5 !== peg$FAILED) { + peg$savedPos = s3; + s3 = peg$f27(s5); + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } + if (input.charCodeAt(peg$currPos) === 93) { + s3 = peg$c5; + peg$currPos++; + } else { + s3 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e15); + } + } + if (s3 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f28(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parseverbatim_group() { + var s0, s1, s2, s3, s4, s5; + s0 = peg$currPos; + s1 = peg$parsebegin_group(); + if (s1 !== peg$FAILED) { + s2 = []; + s3 = peg$currPos; + s4 = peg$currPos; + peg$silentFails++; + s5 = peg$parseend_group(); + peg$silentFails--; + if (s5 === peg$FAILED) { + s4 = void 0; + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + if (s4 !== peg$FAILED) { + if (input.length > peg$currPos) { + s5 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s5 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s5 !== peg$FAILED) { + peg$savedPos = s3; + s3 = peg$f29(s5); + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$currPos; + s4 = peg$currPos; + peg$silentFails++; + s5 = peg$parseend_group(); + peg$silentFails--; + if (s5 === peg$FAILED) { + s4 = void 0; + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + if (s4 !== peg$FAILED) { + if (input.length > peg$currPos) { + s5 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s5 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s5 !== peg$FAILED) { + peg$savedPos = s3; + s3 = peg$f29(s5); + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } + s3 = peg$parseend_group(); + if (s3 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f30(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parseverbatim_delimited_by_char() { + var s0, s1, s2, s3, s4, s5, s6, s7; + s0 = peg$currPos; + if (peg$r0.test(input.charAt(peg$currPos))) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e16); + } + } + if (s1 !== peg$FAILED) { + s2 = []; + s3 = peg$currPos; + s4 = peg$currPos; + peg$silentFails++; + s5 = peg$currPos; + if (input.length > peg$currPos) { + s6 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s6 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s6 !== peg$FAILED) { + peg$savedPos = peg$currPos; + s7 = peg$f31(s1, s6); + if (s7) { + s7 = void 0; + } else { + s7 = peg$FAILED; + } + if (s7 !== peg$FAILED) { + s6 = [s6, s7]; + s5 = s6; + } else { + peg$currPos = s5; + s5 = peg$FAILED; + } + } else { + peg$currPos = s5; + s5 = peg$FAILED; + } + peg$silentFails--; + if (s5 === peg$FAILED) { + s4 = void 0; + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + if (s4 !== peg$FAILED) { + if (input.length > peg$currPos) { + s5 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s5 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s5 !== peg$FAILED) { + peg$savedPos = s3; + s3 = peg$f32(s1, s5); + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$currPos; + s4 = peg$currPos; + peg$silentFails++; + s5 = peg$currPos; + if (input.length > peg$currPos) { + s6 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s6 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s6 !== peg$FAILED) { + peg$savedPos = peg$currPos; + s7 = peg$f31(s1, s6); + if (s7) { + s7 = void 0; + } else { + s7 = peg$FAILED; + } + if (s7 !== peg$FAILED) { + s6 = [s6, s7]; + s5 = s6; + } else { + peg$currPos = s5; + s5 = peg$FAILED; + } + } else { + peg$currPos = s5; + s5 = peg$FAILED; + } + peg$silentFails--; + if (s5 === peg$FAILED) { + s4 = void 0; + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + if (s4 !== peg$FAILED) { + if (input.length > peg$currPos) { + s5 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s5 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s5 !== peg$FAILED) { + peg$savedPos = s3; + s3 = peg$f32(s1, s5); + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } + s3 = peg$currPos; + if (input.length > peg$currPos) { + s4 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s4 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s4 !== peg$FAILED) { + peg$savedPos = peg$currPos; + s5 = peg$f33(s1, s2, s4); + if (s5) { + s5 = void 0; + } else { + s5 = peg$FAILED; + } + if (s5 !== peg$FAILED) { + s4 = [s4, s5]; + s3 = s4; + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + if (s3 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f34(s1, s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parseverbatim_listings() { + var s0, s1, s2, s3, s4; + peg$silentFails++; + s0 = peg$currPos; + s1 = peg$parseescape(); + if (s1 !== peg$FAILED) { + if (input.substr(peg$currPos, 9) === peg$c6) { + s2 = peg$c6; + peg$currPos += 9; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e18); + } + } + if (s2 !== peg$FAILED) { + s3 = peg$parsesquare_bracket_argument(); + if (s3 === peg$FAILED) { + s3 = null; + } + s4 = peg$parseverbatim_group(); + if (s4 === peg$FAILED) { + s4 = peg$parseverbatim_delimited_by_char(); + } + if (s4 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f35(s2, s3, s4); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e17); + } + } + return s0; + } + function peg$parseverbatim_minted() { + var s0, s1, s2, s3, s4, s5; + peg$silentFails++; + s0 = peg$currPos; + s1 = peg$parseescape(); + if (s1 !== peg$FAILED) { + if (input.substr(peg$currPos, 10) === peg$c7) { + s2 = peg$c7; + peg$currPos += 10; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e20); + } + } + if (s2 === peg$FAILED) { + if (input.substr(peg$currPos, 4) === peg$c8) { + s2 = peg$c8; + peg$currPos += 4; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e21); + } + } + } + if (s2 !== peg$FAILED) { + s3 = peg$parsesquare_bracket_argument(); + if (s3 === peg$FAILED) { + s3 = null; + } + s4 = peg$parsegroup(); + if (s4 !== peg$FAILED) { + s5 = peg$parseverbatim_group(); + if (s5 === peg$FAILED) { + s5 = peg$parseverbatim_delimited_by_char(); + } + if (s5 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f36(s2, s3, s4, s5); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e19); + } + } + return s0; + } + function peg$parseverbatim_environment() { + var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11; + peg$silentFails++; + s0 = peg$currPos; + s1 = peg$parsebegin_env(); + if (s1 !== peg$FAILED) { + s2 = peg$parsebegin_group(); + if (s2 !== peg$FAILED) { + s3 = peg$parseverbatim_env_name(); + if (s3 !== peg$FAILED) { + s4 = peg$parseend_group(); + if (s4 !== peg$FAILED) { + s5 = []; + s6 = peg$currPos; + s7 = peg$currPos; + peg$silentFails++; + s8 = peg$currPos; + s9 = peg$parseend_env(); + if (s9 !== peg$FAILED) { + s10 = peg$parsegroup(); + if (s10 !== peg$FAILED) { + peg$savedPos = peg$currPos; + s11 = peg$f40(s3, s10); + if (s11) { + s11 = void 0; + } else { + s11 = peg$FAILED; + } + if (s11 !== peg$FAILED) { + s9 = [s9, s10, s11]; + s8 = s9; + } else { + peg$currPos = s8; + s8 = peg$FAILED; + } + } else { + peg$currPos = s8; + s8 = peg$FAILED; + } + } else { + peg$currPos = s8; + s8 = peg$FAILED; + } + peg$silentFails--; + if (s8 === peg$FAILED) { + s7 = void 0; + } else { + peg$currPos = s7; + s7 = peg$FAILED; + } + if (s7 !== peg$FAILED) { + if (input.length > peg$currPos) { + s8 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s8 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s8 !== peg$FAILED) { + peg$savedPos = s6; + s6 = peg$f41(s3, s8); + } else { + peg$currPos = s6; + s6 = peg$FAILED; + } + } else { + peg$currPos = s6; + s6 = peg$FAILED; + } + while (s6 !== peg$FAILED) { + s5.push(s6); + s6 = peg$currPos; + s7 = peg$currPos; + peg$silentFails++; + s8 = peg$currPos; + s9 = peg$parseend_env(); + if (s9 !== peg$FAILED) { + s10 = peg$parsegroup(); + if (s10 !== peg$FAILED) { + peg$savedPos = peg$currPos; + s11 = peg$f40(s3, s10); + if (s11) { + s11 = void 0; + } else { + s11 = peg$FAILED; + } + if (s11 !== peg$FAILED) { + s9 = [s9, s10, s11]; + s8 = s9; + } else { + peg$currPos = s8; + s8 = peg$FAILED; + } + } else { + peg$currPos = s8; + s8 = peg$FAILED; + } + } else { + peg$currPos = s8; + s8 = peg$FAILED; + } + peg$silentFails--; + if (s8 === peg$FAILED) { + s7 = void 0; + } else { + peg$currPos = s7; + s7 = peg$FAILED; + } + if (s7 !== peg$FAILED) { + if (input.length > peg$currPos) { + s8 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s8 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s8 !== peg$FAILED) { + peg$savedPos = s6; + s6 = peg$f41(s3, s8); + } else { + peg$currPos = s6; + s6 = peg$FAILED; + } + } else { + peg$currPos = s6; + s6 = peg$FAILED; + } + } + s6 = peg$parseend_env(); + if (s6 !== peg$FAILED) { + s7 = peg$parsebegin_group(); + if (s7 !== peg$FAILED) { + s8 = peg$parseverbatim_env_name(); + if (s8 !== peg$FAILED) { + s9 = peg$parseend_group(); + if (s9 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f42(s3, s5); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e24); + } + } + return s0; + } + function peg$parseverbatim_env_name() { + var s0; + if (input.substr(peg$currPos, 9) === peg$c10) { + s0 = peg$c10; + peg$currPos += 9; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e25); + } + } + if (s0 === peg$FAILED) { + if (input.substr(peg$currPos, 8) === peg$c11) { + s0 = peg$c11; + peg$currPos += 8; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e26); + } + } + if (s0 === peg$FAILED) { + if (input.substr(peg$currPos, 13) === peg$c12) { + s0 = peg$c12; + peg$currPos += 13; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e27); + } + } + if (s0 === peg$FAILED) { + if (input.substr(peg$currPos, 12) === peg$c13) { + s0 = peg$c13; + peg$currPos += 12; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e28); + } + } + if (s0 === peg$FAILED) { + if (input.substr(peg$currPos, 7) === peg$c14) { + s0 = peg$c14; + peg$currPos += 7; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e29); + } + } + if (s0 === peg$FAILED) { + if (input.substr(peg$currPos, 10) === peg$c15) { + s0 = peg$c15; + peg$currPos += 10; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e30); + } + } + } + } + } + } + } + return s0; + } + function peg$parsemacro() { + var s0, s1, s2, s3, s4; + peg$silentFails++; + s0 = peg$currPos; + s1 = peg$currPos; + s2 = peg$parseescape(); + if (s2 !== peg$FAILED) { + s3 = []; + s4 = peg$parsechar(); + if (s4 !== peg$FAILED) { + while (s4 !== peg$FAILED) { + s3.push(s4); + s4 = peg$parsechar(); + } + } else { + s3 = peg$FAILED; + } + if (s3 !== peg$FAILED) { + peg$savedPos = s1; + s1 = peg$f43(s3); + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + if (s1 === peg$FAILED) { + s1 = peg$currPos; + s2 = peg$parseescape(); + if (s2 !== peg$FAILED) { + if (input.length > peg$currPos) { + s3 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s3 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s3 !== peg$FAILED) { + peg$savedPos = s1; + s1 = peg$f44(s3); + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + } + if (s1 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$f45(s1); + } + s0 = s1; + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e31); + } + } + return s0; + } + function peg$parsegroup() { + var s0, s1, s2, s3, s4, s5; + peg$silentFails++; + s0 = peg$currPos; + s1 = peg$parsebegin_group(); + if (s1 !== peg$FAILED) { + s2 = []; + s3 = peg$currPos; + s4 = peg$currPos; + peg$silentFails++; + s5 = peg$parseend_group(); + peg$silentFails--; + if (s5 === peg$FAILED) { + s4 = void 0; + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + if (s4 !== peg$FAILED) { + s5 = peg$parsetoken(); + if (s5 !== peg$FAILED) { + peg$savedPos = s3; + s3 = peg$f46(s5); + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$currPos; + s4 = peg$currPos; + peg$silentFails++; + s5 = peg$parseend_group(); + peg$silentFails--; + if (s5 === peg$FAILED) { + s4 = void 0; + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + if (s4 !== peg$FAILED) { + s5 = peg$parsetoken(); + if (s5 !== peg$FAILED) { + peg$savedPos = s3; + s3 = peg$f46(s5); + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } + s3 = peg$parseend_group(); + if (s3 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f47(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e32); + } + } + return s0; + } + function peg$parsegroup_contents_as_string() { + var s0, s1; + s0 = peg$currPos; + s1 = peg$parsegroup(); + if (s1 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$f48(); + } + s0 = s1; + return s0; + } + function peg$parseenvironment() { + var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10; + peg$silentFails++; + s0 = peg$currPos; + s1 = peg$parsebegin_env(); + if (s1 !== peg$FAILED) { + s2 = peg$parsegroup_contents_as_string(); + if (s2 !== peg$FAILED) { + s3 = peg$parsesameline_comment(); + if (s3 === peg$FAILED) { + s3 = null; + } + s4 = []; + s5 = peg$currPos; + s6 = peg$currPos; + peg$silentFails++; + s7 = peg$currPos; + s8 = peg$parseend_env(); + if (s8 !== peg$FAILED) { + s9 = peg$parsegroup_contents_as_string(); + if (s9 !== peg$FAILED) { + peg$savedPos = peg$currPos; + s10 = peg$f49(s2, s3, s9); + if (s10) { + s10 = void 0; + } else { + s10 = peg$FAILED; + } + if (s10 !== peg$FAILED) { + s8 = [s8, s9, s10]; + s7 = s8; + } else { + peg$currPos = s7; + s7 = peg$FAILED; + } + } else { + peg$currPos = s7; + s7 = peg$FAILED; + } + } else { + peg$currPos = s7; + s7 = peg$FAILED; + } + peg$silentFails--; + if (s7 === peg$FAILED) { + s6 = void 0; + } else { + peg$currPos = s6; + s6 = peg$FAILED; + } + if (s6 !== peg$FAILED) { + s7 = peg$parsetoken(); + if (s7 !== peg$FAILED) { + peg$savedPos = s5; + s5 = peg$f50(s2, s3, s7); + } else { + peg$currPos = s5; + s5 = peg$FAILED; + } + } else { + peg$currPos = s5; + s5 = peg$FAILED; + } + while (s5 !== peg$FAILED) { + s4.push(s5); + s5 = peg$currPos; + s6 = peg$currPos; + peg$silentFails++; + s7 = peg$currPos; + s8 = peg$parseend_env(); + if (s8 !== peg$FAILED) { + s9 = peg$parsegroup_contents_as_string(); + if (s9 !== peg$FAILED) { + peg$savedPos = peg$currPos; + s10 = peg$f49(s2, s3, s9); + if (s10) { + s10 = void 0; + } else { + s10 = peg$FAILED; + } + if (s10 !== peg$FAILED) { + s8 = [s8, s9, s10]; + s7 = s8; + } else { + peg$currPos = s7; + s7 = peg$FAILED; + } + } else { + peg$currPos = s7; + s7 = peg$FAILED; + } + } else { + peg$currPos = s7; + s7 = peg$FAILED; + } + peg$silentFails--; + if (s7 === peg$FAILED) { + s6 = void 0; + } else { + peg$currPos = s6; + s6 = peg$FAILED; + } + if (s6 !== peg$FAILED) { + s7 = peg$parsetoken(); + if (s7 !== peg$FAILED) { + peg$savedPos = s5; + s5 = peg$f50(s2, s3, s7); + } else { + peg$currPos = s5; + s5 = peg$FAILED; + } + } else { + peg$currPos = s5; + s5 = peg$FAILED; + } + } + s5 = peg$parseend_env(); + if (s5 !== peg$FAILED) { + s6 = peg$parsegroup_contents_as_string(); + if (s6 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f51(s2, s3, s4); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e33); + } + } + return s0; + } + function peg$parsemath_environment() { + var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12; + peg$silentFails++; + s0 = peg$currPos; + s1 = peg$parsebegin_env(); + if (s1 !== peg$FAILED) { + s2 = peg$parsebegin_group(); + if (s2 !== peg$FAILED) { + s3 = peg$parsemath_env_name(); + if (s3 !== peg$FAILED) { + s4 = peg$parseend_group(); + if (s4 !== peg$FAILED) { + s5 = peg$parsesameline_comment(); + if (s5 === peg$FAILED) { + s5 = null; + } + s6 = []; + s7 = peg$currPos; + s8 = peg$currPos; + peg$silentFails++; + s9 = peg$currPos; + s10 = peg$parseend_env(); + if (s10 !== peg$FAILED) { + s11 = peg$parsegroup(); + if (s11 !== peg$FAILED) { + peg$savedPos = peg$currPos; + s12 = peg$f52(s3, s5, s11); + if (s12) { + s12 = void 0; + } else { + s12 = peg$FAILED; + } + if (s12 !== peg$FAILED) { + s10 = [s10, s11, s12]; + s9 = s10; + } else { + peg$currPos = s9; + s9 = peg$FAILED; + } + } else { + peg$currPos = s9; + s9 = peg$FAILED; + } + } else { + peg$currPos = s9; + s9 = peg$FAILED; + } + peg$silentFails--; + if (s9 === peg$FAILED) { + s8 = void 0; + } else { + peg$currPos = s8; + s8 = peg$FAILED; + } + if (s8 !== peg$FAILED) { + s9 = peg$parsemath_token(); + if (s9 !== peg$FAILED) { + peg$savedPos = s7; + s7 = peg$f53(s3, s5, s9); + } else { + peg$currPos = s7; + s7 = peg$FAILED; + } + } else { + peg$currPos = s7; + s7 = peg$FAILED; + } + while (s7 !== peg$FAILED) { + s6.push(s7); + s7 = peg$currPos; + s8 = peg$currPos; + peg$silentFails++; + s9 = peg$currPos; + s10 = peg$parseend_env(); + if (s10 !== peg$FAILED) { + s11 = peg$parsegroup(); + if (s11 !== peg$FAILED) { + peg$savedPos = peg$currPos; + s12 = peg$f52(s3, s5, s11); + if (s12) { + s12 = void 0; + } else { + s12 = peg$FAILED; + } + if (s12 !== peg$FAILED) { + s10 = [s10, s11, s12]; + s9 = s10; + } else { + peg$currPos = s9; + s9 = peg$FAILED; + } + } else { + peg$currPos = s9; + s9 = peg$FAILED; + } + } else { + peg$currPos = s9; + s9 = peg$FAILED; + } + peg$silentFails--; + if (s9 === peg$FAILED) { + s8 = void 0; + } else { + peg$currPos = s8; + s8 = peg$FAILED; + } + if (s8 !== peg$FAILED) { + s9 = peg$parsemath_token(); + if (s9 !== peg$FAILED) { + peg$savedPos = s7; + s7 = peg$f53(s3, s5, s9); + } else { + peg$currPos = s7; + s7 = peg$FAILED; + } + } else { + peg$currPos = s7; + s7 = peg$FAILED; + } + } + s7 = peg$parseend_env(); + if (s7 !== peg$FAILED) { + s8 = peg$parsebegin_group(); + if (s8 !== peg$FAILED) { + s9 = peg$parsemath_env_name(); + if (s9 !== peg$FAILED) { + s10 = peg$parseend_group(); + if (s10 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f54(s3, s5, s6); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e34); + } + } + return s0; + } + function peg$parsebegin_display_math() { + var s0, s1, s2; + s0 = peg$currPos; + s1 = peg$parseescape(); + if (s1 !== peg$FAILED) { + if (input.charCodeAt(peg$currPos) === 91) { + s2 = peg$c4; + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e14); + } + } + if (s2 !== peg$FAILED) { + s1 = [s1, s2]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parseend_display_math() { + var s0, s1, s2; + s0 = peg$currPos; + s1 = peg$parseescape(); + if (s1 !== peg$FAILED) { + if (input.charCodeAt(peg$currPos) === 93) { + s2 = peg$c5; + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e15); + } + } + if (s2 !== peg$FAILED) { + s1 = [s1, s2]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsebegin_inline_math() { + var s0, s1, s2; + s0 = peg$currPos; + s1 = peg$parseescape(); + if (s1 !== peg$FAILED) { + if (input.charCodeAt(peg$currPos) === 40) { + s2 = peg$c16; + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e36); + } + } + if (s2 !== peg$FAILED) { + s1 = [s1, s2]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parseend_inline_math() { + var s0, s1, s2; + s0 = peg$currPos; + s1 = peg$parseescape(); + if (s1 !== peg$FAILED) { + if (input.charCodeAt(peg$currPos) === 41) { + s2 = peg$c17; + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e37); + } + } + if (s2 !== peg$FAILED) { + s1 = [s1, s2]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsebegin_env() { + var s0, s1, s2; + s0 = peg$currPos; + s1 = peg$parseescape(); + if (s1 !== peg$FAILED) { + if (input.substr(peg$currPos, 5) === peg$c18) { + s2 = peg$c18; + peg$currPos += 5; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e38); + } + } + if (s2 !== peg$FAILED) { + s1 = [s1, s2]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parseend_env() { + var s0, s1, s2; + s0 = peg$currPos; + s1 = peg$parseescape(); + if (s1 !== peg$FAILED) { + if (input.substr(peg$currPos, 3) === peg$c19) { + s2 = peg$c19; + peg$currPos += 3; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e39); + } + } + if (s2 !== peg$FAILED) { + s1 = [s1, s2]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsemath_env_name() { + var s0, s1; + s0 = peg$currPos; + if (input.substr(peg$currPos, 9) === peg$c20) { + s1 = peg$c20; + peg$currPos += 9; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e40); + } + } + if (s1 === peg$FAILED) { + if (input.substr(peg$currPos, 8) === peg$c21) { + s1 = peg$c21; + peg$currPos += 8; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e41); + } + } + if (s1 === peg$FAILED) { + if (input.substr(peg$currPos, 6) === peg$c22) { + s1 = peg$c22; + peg$currPos += 6; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e42); + } + } + if (s1 === peg$FAILED) { + if (input.substr(peg$currPos, 5) === peg$c23) { + s1 = peg$c23; + peg$currPos += 5; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e43); + } + } + if (s1 === peg$FAILED) { + if (input.substr(peg$currPos, 8) === peg$c24) { + s1 = peg$c24; + peg$currPos += 8; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e44); + } + } + if (s1 === peg$FAILED) { + if (input.substr(peg$currPos, 7) === peg$c25) { + s1 = peg$c25; + peg$currPos += 7; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e45); + } + } + if (s1 === peg$FAILED) { + if (input.substr(peg$currPos, 7) === peg$c26) { + s1 = peg$c26; + peg$currPos += 7; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e46); + } + } + if (s1 === peg$FAILED) { + if (input.substr(peg$currPos, 6) === peg$c27) { + s1 = peg$c27; + peg$currPos += 6; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e47); + } + } + if (s1 === peg$FAILED) { + if (input.substr(peg$currPos, 9) === peg$c28) { + s1 = peg$c28; + peg$currPos += 9; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e48); + } + } + if (s1 === peg$FAILED) { + if (input.substr(peg$currPos, 8) === peg$c29) { + s1 = peg$c29; + peg$currPos += 8; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e49); + } + } + if (s1 === peg$FAILED) { + if (input.substr(peg$currPos, 8) === peg$c30) { + s1 = peg$c30; + peg$currPos += 8; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e50); + } + } + if (s1 === peg$FAILED) { + if (input.substr(peg$currPos, 7) === peg$c31) { + s1 = peg$c31; + peg$currPos += 7; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e51); + } + } + if (s1 === peg$FAILED) { + if (input.substr(peg$currPos, 5) === peg$c32) { + s1 = peg$c32; + peg$currPos += 5; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e52); + } + } + if (s1 === peg$FAILED) { + if (input.substr(peg$currPos, 4) === peg$c33) { + s1 = peg$c33; + peg$currPos += 4; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e53); + } + } + if (s1 === peg$FAILED) { + if (input.substr(peg$currPos, 11) === peg$c34) { + s1 = peg$c34; + peg$currPos += 11; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e54); + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + if (s1 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$f57(s1); + } + s0 = s1; + return s0; + } + function peg$parseescape() { + var s0, s1; + peg$silentFails++; + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 92) { + s1 = peg$c35; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e56); + } + } + if (s1 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$f58(); + } + s0 = s1; + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e55); + } + } + return s0; + } + function peg$parsebegin_group() { + var s0, s1; + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 123) { + s1 = peg$c36; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e57); + } + } + if (s1 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$f59(s1); + } + s0 = s1; + return s0; + } + function peg$parseend_group() { + var s0, s1; + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 125) { + s1 = peg$c37; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e58); + } + } + if (s1 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$f60(s1); + } + s0 = s1; + return s0; + } + function peg$parsemath_shift() { + var s0, s1; + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 36) { + s1 = peg$c38; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e59); + } + } + if (s1 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$f61(s1); + } + s0 = s1; + return s0; + } + function peg$parsealignment_tab() { + var s0, s1; + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 38) { + s1 = peg$c39; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e60); + } + } + if (s1 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$f62(s1); + } + s0 = s1; + return s0; + } + function peg$parsenl() { + var s0, s1, s2; + peg$silentFails++; + s0 = peg$currPos; + s1 = peg$currPos; + peg$silentFails++; + if (input.charCodeAt(peg$currPos) === 13) { + s2 = peg$c40; + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e62); + } + } + peg$silentFails--; + if (s2 === peg$FAILED) { + s1 = void 0; + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + if (s1 !== peg$FAILED) { + if (input.charCodeAt(peg$currPos) === 10) { + s2 = peg$c41; + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e63); + } + } + if (s2 !== peg$FAILED) { + s1 = [s1, s2]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + if (input.charCodeAt(peg$currPos) === 13) { + s0 = peg$c40; + peg$currPos++; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e62); + } + } + if (s0 === peg$FAILED) { + if (input.substr(peg$currPos, 2) === peg$c42) { + s0 = peg$c42; + peg$currPos += 2; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e64); + } + } + } + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e61); + } + } + return s0; + } + function peg$parsemacro_parameter() { + var s0, s1; + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 35) { + s1 = peg$c43; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e65); + } + } + if (s1 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$f63(s1); + } + s0 = s1; + return s0; + } + function peg$parsesuperscript() { + var s0, s1; + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 94) { + s1 = peg$c44; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e66); + } + } + if (s1 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$f64(s1); + } + s0 = s1; + return s0; + } + function peg$parsesubscript() { + var s0, s1; + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 95) { + s1 = peg$c45; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e67); + } + } + if (s1 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$f65(s1); + } + s0 = s1; + return s0; + } + function peg$parseignore() { + var s0; + if (input.charCodeAt(peg$currPos) === 0) { + s0 = peg$c46; + peg$currPos++; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e68); + } + } + return s0; + } + function peg$parsesp() { + var s0, s1, s2; + peg$silentFails++; + s0 = peg$currPos; + s1 = []; + if (peg$r1.test(input.charAt(peg$currPos))) { + s2 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e69); + } + } + if (s2 !== peg$FAILED) { + while (s2 !== peg$FAILED) { + s1.push(s2); + if (peg$r1.test(input.charAt(peg$currPos))) { + s2 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e69); + } + } + } + } else { + s1 = peg$FAILED; + } + if (s1 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$f66(); + } + s0 = s1; + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e8); + } + } + return s0; + } + function peg$parsechar() { + var s0; + peg$silentFails++; + if (peg$r2.test(input.charAt(peg$currPos))) { + s0 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e71); + } + } + peg$silentFails--; + if (s0 === peg$FAILED) { + if (peg$silentFails === 0) { + peg$fail(peg$e70); + } + } + return s0; + } + function peg$parsenum() { + var s0; + peg$silentFails++; + if (peg$r3.test(input.charAt(peg$currPos))) { + s0 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e73); + } + } + peg$silentFails--; + if (s0 === peg$FAILED) { + if (peg$silentFails === 0) { + peg$fail(peg$e72); + } + } + return s0; + } + function peg$parsepunctuation() { + var s0, s1; + peg$silentFails++; + s0 = peg$currPos; + if (peg$r4.test(input.charAt(peg$currPos))) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e75); + } + } + if (s1 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$f67(s1); + } + s0 = s1; + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e74); + } + } + return s0; + } + function peg$parsecomment_start() { + var s0; + if (input.charCodeAt(peg$currPos) === 37) { + s0 = peg$c0; + peg$currPos++; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e7); + } + } + return s0; + } + function peg$parsefull_comment() { + var s0; + peg$silentFails++; + s0 = peg$parseownline_comment(); + if (s0 === peg$FAILED) { + s0 = peg$parsesameline_comment(); + } + peg$silentFails--; + if (s0 === peg$FAILED) { + if (peg$silentFails === 0) { + peg$fail(peg$e76); + } + } + return s0; + } + function peg$parseownline_comment() { + var s0, s1, s2, s3; + s0 = peg$currPos; + s1 = peg$currPos; + s2 = []; + s3 = peg$parsesp(); + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$parsesp(); + } + s3 = peg$parsenl(); + if (s3 !== peg$FAILED) { + s2 = [s2, s3]; + s1 = s2; + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + if (s1 === peg$FAILED) { + s1 = null; + } + s2 = peg$parseleading_sp(); + if (s2 !== peg$FAILED) { + s3 = peg$parsecomment(); + if (s3 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f68(s2, s3); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsesameline_comment() { + var s0, s1, s2; + s0 = peg$currPos; + s1 = []; + s2 = peg$parsesp(); + while (s2 !== peg$FAILED) { + s1.push(s2); + s2 = peg$parsesp(); + } + s2 = peg$parsecomment(); + if (s2 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f69(s1, s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsecomment() { + var s0, s1, s2, s3, s4, s5, s6, s7; + peg$silentFails++; + s0 = peg$currPos; + s1 = peg$parsecomment_start(); + if (s1 !== peg$FAILED) { + s2 = []; + s3 = peg$currPos; + s4 = peg$currPos; + peg$silentFails++; + s5 = peg$parsenl(); + peg$silentFails--; + if (s5 === peg$FAILED) { + s4 = void 0; + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + if (s4 !== peg$FAILED) { + if (input.length > peg$currPos) { + s5 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s5 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s5 !== peg$FAILED) { + peg$savedPos = s3; + s3 = peg$f70(s5); + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$currPos; + s4 = peg$currPos; + peg$silentFails++; + s5 = peg$parsenl(); + peg$silentFails--; + if (s5 === peg$FAILED) { + s4 = void 0; + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + if (s4 !== peg$FAILED) { + if (input.length > peg$currPos) { + s5 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s5 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s5 !== peg$FAILED) { + peg$savedPos = s3; + s3 = peg$f70(s5); + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } + s3 = peg$currPos; + peg$silentFails++; + s4 = peg$parseparbreak(); + peg$silentFails--; + if (s4 !== peg$FAILED) { + peg$currPos = s3; + s3 = void 0; + } else { + s3 = peg$FAILED; + } + if (s3 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f71(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$parsecomment_start(); + if (s1 !== peg$FAILED) { + s2 = []; + s3 = peg$currPos; + s4 = peg$currPos; + peg$silentFails++; + s5 = peg$parsenl(); + peg$silentFails--; + if (s5 === peg$FAILED) { + s4 = void 0; + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + if (s4 !== peg$FAILED) { + if (input.length > peg$currPos) { + s5 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s5 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s5 !== peg$FAILED) { + peg$savedPos = s3; + s3 = peg$f72(s5); + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$currPos; + s4 = peg$currPos; + peg$silentFails++; + s5 = peg$parsenl(); + peg$silentFails--; + if (s5 === peg$FAILED) { + s4 = void 0; + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + if (s4 !== peg$FAILED) { + if (input.length > peg$currPos) { + s5 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s5 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s5 !== peg$FAILED) { + peg$savedPos = s3; + s3 = peg$f72(s5); + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } + s3 = peg$currPos; + s4 = peg$parsenl(); + if (s4 !== peg$FAILED) { + s5 = []; + s6 = peg$parsesp(); + while (s6 !== peg$FAILED) { + s5.push(s6); + s6 = peg$parsesp(); + } + s6 = peg$currPos; + peg$silentFails++; + s7 = peg$parsecomment_start(); + peg$silentFails--; + if (s7 === peg$FAILED) { + s6 = void 0; + } else { + peg$currPos = s6; + s6 = peg$FAILED; + } + if (s6 !== peg$FAILED) { + s4 = [s4, s5, s6]; + s3 = s4; + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + if (s3 === peg$FAILED) { + s3 = peg$parsenl(); + if (s3 === peg$FAILED) { + s3 = peg$parseEOF(); + } + } + if (s3 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f73(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e77); + } + } + return s0; + } + function peg$parseleading_sp() { + var s0, s1, s2, s3, s4; + s0 = peg$currPos; + s1 = peg$currPos; + s2 = peg$parsestart_of_line(); + if (s2 !== peg$FAILED) { + s3 = []; + s4 = peg$parsesp(); + while (s4 !== peg$FAILED) { + s3.push(s4); + s4 = peg$parsesp(); + } + s2 = [s2, s3]; + s1 = s2; + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + if (s1 !== peg$FAILED) { + s0 = input.substring(s0, peg$currPos); + } else { + s0 = s1; + } + return s0; + } + function peg$parsestart_of_line() { + var s0; + peg$savedPos = peg$currPos; + s0 = peg$f74(); + if (s0) { + s0 = void 0; + } else { + s0 = peg$FAILED; + } + return s0; + } + function peg$parseEOF() { + var s0, s1; + s0 = peg$currPos; + peg$silentFails++; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + peg$silentFails--; + if (s1 === peg$FAILED) { + s0 = void 0; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function toString(e) { + if (typeof e === "string") { + return e; + } + if (typeof e.content === "string") { + return e.content; + } + if (e && e.type === "whitespace") { + return " "; + } + return e; + } + function compare_env(g1, g2) { + const g1Name = typeof g1 === "string" ? g1 : g1.content.map(toString).join(""); + const g2Name = typeof g2 === "string" ? g2 : g2.content.map(toString).join(""); + return g1Name === g2Name; + } + function createNode(type, extra = {}) { + return { type, ...extra, position: location() }; + } + peg$result = peg$startRuleFunction(); + if (peg$result !== peg$FAILED && peg$currPos === input.length) { + return peg$result; + } else { + if (peg$result !== peg$FAILED && peg$currPos < input.length) { + peg$fail(peg$endExpectation()); + } + throw peg$buildStructuredError( + peg$maxFailExpected, + peg$maxFailPos < input.length ? input.charAt(peg$maxFailPos) : null, + peg$maxFailPos < input.length ? peg$computeLocation(peg$maxFailPos, peg$maxFailPos + 1) : peg$computeLocation(peg$maxFailPos, peg$maxFailPos) + ); + } + } + return { + SyntaxError: peg$SyntaxError, + parse: peg$parse + }; + }() +); +var align_environment_default = ( + // Generated by Peggy 2.0.1. + // + // https://peggyjs.org/ + function() { + function peg$subclass(child, parent) { + function C() { + this.constructor = child; + } + C.prototype = parent.prototype; + child.prototype = new C(); + } + function peg$SyntaxError(message, expected, found, location) { + var self = Error.call(this, message); + if (Object.setPrototypeOf) { + Object.setPrototypeOf(self, peg$SyntaxError.prototype); + } + self.expected = expected; + self.found = found; + self.location = location; + self.name = "SyntaxError"; + return self; + } + peg$subclass(peg$SyntaxError, Error); + function peg$padEnd(str, targetLength, padString) { + padString = padString || " "; + if (str.length > targetLength) { + return str; + } + targetLength -= str.length; + padString += padString.repeat(targetLength); + return str + padString.slice(0, targetLength); + } + peg$SyntaxError.prototype.format = function(sources) { + var str = "Error: " + this.message; + if (this.location) { + var src = null; + var k; + for (k = 0; k < sources.length; k++) { + if (sources[k].source === this.location.source) { + src = sources[k].text.split(/\r\n|\n|\r/g); + break; + } + } + var s2 = this.location.start; + var loc = this.location.source + ":" + s2.line + ":" + s2.column; + if (src) { + var e = this.location.end; + var filler = peg$padEnd("", s2.line.toString().length, " "); + var line3 = src[s2.line - 1]; + var last = s2.line === e.line ? e.column : line3.length + 1; + var hatLen = last - s2.column || 1; + str += "\n --> " + loc + "\n" + filler + " |\n" + s2.line + " | " + line3 + "\n" + filler + " | " + peg$padEnd("", s2.column - 1, " ") + peg$padEnd("", hatLen, "^"); + } else { + str += "\n at " + loc; + } + } + return str; + }; + peg$SyntaxError.buildMessage = function(expected, found) { + var DESCRIBE_EXPECTATION_FNS = { + literal: function(expectation) { + return '"' + literalEscape(expectation.text) + '"'; + }, + class: function(expectation) { + var escapedParts = expectation.parts.map(function(part) { + return Array.isArray(part) ? classEscape(part[0]) + "-" + classEscape(part[1]) : classEscape(part); + }); + return "[" + (expectation.inverted ? "^" : "") + escapedParts.join("") + "]"; + }, + any: function() { + return "any character"; + }, + end: function() { + return "end of input"; + }, + other: function(expectation) { + return expectation.description; + } + }; + function hex(ch) { + return ch.charCodeAt(0).toString(16).toUpperCase(); + } + function literalEscape(s2) { + return s2.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\0/g, "\\0").replace(/\t/g, "\\t").replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/[\x00-\x0F]/g, function(ch) { + return "\\x0" + hex(ch); + }).replace(/[\x10-\x1F\x7F-\x9F]/g, function(ch) { + return "\\x" + hex(ch); + }); + } + function classEscape(s2) { + return s2.replace(/\\/g, "\\\\").replace(/\]/g, "\\]").replace(/\^/g, "\\^").replace(/-/g, "\\-").replace(/\0/g, "\\0").replace(/\t/g, "\\t").replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/[\x00-\x0F]/g, function(ch) { + return "\\x0" + hex(ch); + }).replace(/[\x10-\x1F\x7F-\x9F]/g, function(ch) { + return "\\x" + hex(ch); + }); + } + function describeExpectation(expectation) { + return DESCRIBE_EXPECTATION_FNS[expectation.type](expectation); + } + function describeExpected(expected2) { + var descriptions = expected2.map(describeExpectation); + var i, j; + descriptions.sort(); + if (descriptions.length > 0) { + for (i = 1, j = 1; i < descriptions.length; i++) { + if (descriptions[i - 1] !== descriptions[i]) { + descriptions[j] = descriptions[i]; + j++; + } + } + descriptions.length = j; + } + switch (descriptions.length) { + case 1: + return descriptions[0]; + case 2: + return descriptions[0] + " or " + descriptions[1]; + default: + return descriptions.slice(0, -1).join(", ") + ", or " + descriptions[descriptions.length - 1]; + } + } + function describeFound(found2) { + return found2 ? '"' + literalEscape(found2) + '"' : "end of input"; + } + return "Expected " + describeExpected(expected) + " but " + describeFound(found) + " found."; + }; + function peg$parse(input, options2) { + options2 = options2 !== void 0 ? options2 : {}; + var peg$FAILED = {}; + var peg$source = options2.grammarSource; + var peg$startRuleFunctions = { body: peg$parsebody }; + var peg$startRuleFunction = peg$parsebody; + var peg$e0 = peg$anyExpectation(); + var peg$f0 = function() { + return []; + }; + var peg$f1 = function(x) { + return { cells: [], colSeps: [], ...x }; + }; + var peg$f2 = function(rowItems, rowSep, trailingComment) { + return { ...rowItems, rowSep, trailingComment }; + }; + var peg$f3 = function(rowItems, trailingComment) { + return { ...rowItems, rowSep: null, trailingComment }; + }; + var peg$f4 = function(x) { + return x; + }; + var peg$f5 = function(x) { + return { + cells: [], + colSeps: [], + rowSep: null, + trailingComment: x + }; + }; + var peg$f6 = function(x) { + return x; + }; + var peg$f7 = function(colSep, cell) { + return { colSep, cell }; + }; + var peg$f8 = function(colSep) { + return { colSep }; + }; + var peg$f9 = function(a, b) { + return processRow(a, b); + }; + var peg$f10 = function(b) { + return processRow(null, b); + }; + var peg$f11 = function(tok) { + return options2.isSameLineComment(tok); + }; + var peg$f12 = function(tok) { + return tok; + }; + var peg$f13 = function(tok) { + return options2.isOwnLineComment(tok); + }; + var peg$f14 = function(tok) { + return tok; + }; + var peg$f15 = function(tok) { + return options2.isWhitespace(tok); + }; + var peg$f16 = function(tok) { + return tok; + }; + var peg$f17 = function(tok) { + return options2.isRowSep(tok); + }; + var peg$f18 = function(tok) { + return tok; + }; + var peg$f19 = function(tok) { + return options2.isColSep(tok); + }; + var peg$f20 = function(tok) { + return tok; + }; + var peg$currPos = 0; + var peg$posDetailsCache = [{ line: 1, column: 1 }]; + var peg$maxFailPos = 0; + var peg$maxFailExpected = []; + var peg$silentFails = 0; + var peg$result; + if ("startRule" in options2) { + if (!(options2.startRule in peg$startRuleFunctions)) { + throw new Error(`Can't start parsing from rule "` + options2.startRule + '".'); + } + peg$startRuleFunction = peg$startRuleFunctions[options2.startRule]; + } + function peg$anyExpectation() { + return { type: "any" }; + } + function peg$endExpectation() { + return { type: "end" }; + } + function peg$computePosDetails(pos) { + var details = peg$posDetailsCache[pos]; + var p; + if (details) { + return details; + } else { + p = pos - 1; + while (!peg$posDetailsCache[p]) { + p--; + } + details = peg$posDetailsCache[p]; + details = { + line: details.line, + column: details.column + }; + while (p < pos) { + if (input.charCodeAt(p) === 10) { + details.line++; + details.column = 1; + } else { + details.column++; + } + p++; + } + peg$posDetailsCache[pos] = details; + return details; + } + } + function peg$computeLocation(startPos, endPos) { + var startPosDetails = peg$computePosDetails(startPos); + var endPosDetails = peg$computePosDetails(endPos); + return { + source: peg$source, + start: { + offset: startPos, + line: startPosDetails.line, + column: startPosDetails.column + }, + end: { + offset: endPos, + line: endPosDetails.line, + column: endPosDetails.column + } + }; + } + function peg$fail(expected2) { + if (peg$currPos < peg$maxFailPos) { + return; + } + if (peg$currPos > peg$maxFailPos) { + peg$maxFailPos = peg$currPos; + peg$maxFailExpected = []; + } + peg$maxFailExpected.push(expected2); + } + function peg$buildStructuredError(expected2, found, location2) { + return new peg$SyntaxError( + peg$SyntaxError.buildMessage(expected2, found), + expected2, + found, + location2 + ); + } + function peg$parsebody() { + var s0, s1; + s0 = []; + s1 = peg$parsecomment_only_line(); + if (s1 === peg$FAILED) { + s1 = peg$parserow_with_end(); + if (s1 === peg$FAILED) { + s1 = peg$parserow_without_end(); + } + } + if (s1 !== peg$FAILED) { + while (s1 !== peg$FAILED) { + s0.push(s1); + s1 = peg$parsecomment_only_line(); + if (s1 === peg$FAILED) { + s1 = peg$parserow_with_end(); + if (s1 === peg$FAILED) { + s1 = peg$parserow_without_end(); + } + } + } + } else { + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$parseEOL(); + if (s1 !== peg$FAILED) { + s1 = peg$f0(); + } + s0 = s1; + } + return s0; + } + function peg$parserow_with_end() { + var s0, s1, s2, s3; + s0 = peg$currPos; + s1 = peg$currPos; + s2 = peg$parserow_items(); + if (s2 === peg$FAILED) { + s2 = null; + } + s2 = peg$f1(s2); + s1 = s2; + s2 = peg$parserow_sep(); + if (s2 !== peg$FAILED) { + s3 = peg$parsetrailing_comment(); + if (s3 === peg$FAILED) { + s3 = null; + } + s0 = peg$f2(s1, s2, s3); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parserow_without_end() { + var s0, s1, s2; + s0 = peg$currPos; + s1 = peg$parserow_items(); + if (s1 !== peg$FAILED) { + s2 = peg$parsetrailing_comment(); + if (s2 === peg$FAILED) { + s2 = null; + } + s0 = peg$f3(s1, s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsetrailing_comment() { + var s0, s1, s2; + s0 = peg$currPos; + s1 = []; + s2 = peg$parsewhitespace(); + while (s2 !== peg$FAILED) { + s1.push(s2); + s2 = peg$parsewhitespace(); + } + s2 = peg$parsesame_line_comment(); + if (s2 !== peg$FAILED) { + s0 = peg$f4(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsecomment_only_line() { + var s0, s1, s2; + s0 = peg$currPos; + s1 = []; + s2 = peg$parsewhitespace(); + while (s2 !== peg$FAILED) { + s1.push(s2); + s2 = peg$parsewhitespace(); + } + s2 = peg$parseown_line_comment(); + if (s2 !== peg$FAILED) { + s0 = peg$f5(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsetoken() { + var s0, s1, s2; + s0 = peg$currPos; + s1 = peg$currPos; + peg$silentFails++; + s2 = peg$parserow_sep(); + if (s2 === peg$FAILED) { + s2 = peg$parsecol_sep(); + if (s2 === peg$FAILED) { + s2 = peg$parsetrailing_comment(); + if (s2 === peg$FAILED) { + s2 = peg$parseown_line_comment(); + } + } + } + peg$silentFails--; + if (s2 === peg$FAILED) { + s1 = void 0; + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + if (s1 !== peg$FAILED) { + if (input.length > peg$currPos) { + s2 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s2 !== peg$FAILED) { + s0 = peg$f6(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsecell() { + var s0, s1, s2; + s0 = peg$currPos; + s1 = []; + s2 = peg$parsetoken(); + if (s2 !== peg$FAILED) { + while (s2 !== peg$FAILED) { + s1.push(s2); + s2 = peg$parsetoken(); + } + } else { + s1 = peg$FAILED; + } + if (s1 !== peg$FAILED) { + s0 = input.substring(s0, peg$currPos); + } else { + s0 = s1; + } + return s0; + } + function peg$parseseparated_cell() { + var s0, s1, s2; + s0 = peg$currPos; + s1 = peg$parsecol_sep(); + if (s1 !== peg$FAILED) { + s2 = peg$parsecell(); + if (s2 !== peg$FAILED) { + s0 = peg$f7(s1, s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$parsecol_sep(); + if (s1 !== peg$FAILED) { + s1 = peg$f8(s1); + } + s0 = s1; + } + return s0; + } + function peg$parserow_items() { + var s0, s1, s2, s3; + s0 = peg$currPos; + s1 = peg$parsecell(); + if (s1 !== peg$FAILED) { + s2 = []; + s3 = peg$parseseparated_cell(); + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$parseseparated_cell(); + } + s0 = peg$f9(s1, s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = []; + s2 = peg$parseseparated_cell(); + if (s2 !== peg$FAILED) { + while (s2 !== peg$FAILED) { + s1.push(s2); + s2 = peg$parseseparated_cell(); + } + } else { + s1 = peg$FAILED; + } + if (s1 !== peg$FAILED) { + s1 = peg$f10(s1); + } + s0 = s1; + } + return s0; + } + function peg$parsesame_line_comment() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f11(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s0 = peg$f12(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parseown_line_comment() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f13(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s0 = peg$f14(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsewhitespace() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f15(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s0 = peg$f16(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parserow_sep() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f17(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s0 = peg$f18(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsecol_sep() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f19(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s0 = peg$f20(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parseEOL() { + var s0, s1; + s0 = peg$currPos; + peg$silentFails++; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + peg$silentFails--; + if (s1 === peg$FAILED) { + s0 = void 0; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function processRow(leadCell, otherCells) { + const cells = [leadCell || []]; + const seps = []; + for (const x of otherCells) { + cells.push(x.cell || []); + seps.push(x.colSep); + } + return { cells, colSeps: seps }; + } + if (!options2.isWhitespace) { + try { + Object.assign( + options2, + createMatchers(["\\", "hline", "cr"], ["&"]) + ); + } catch (e) { + console.warn("Error when initializing parser", e); + } + } + peg$result = peg$startRuleFunction(); + if (peg$result !== peg$FAILED && peg$currPos === input.length) { + return peg$result; + } else { + if (peg$result !== peg$FAILED && peg$currPos < input.length) { + peg$fail(peg$endExpectation()); + } + throw peg$buildStructuredError( + peg$maxFailExpected, + peg$maxFailPos < input.length ? input.charAt(peg$maxFailPos) : null, + peg$maxFailPos < input.length ? peg$computeLocation(peg$maxFailPos, peg$maxFailPos + 1) : peg$computeLocation(peg$maxFailPos, peg$maxFailPos) + ); + } + } + return { + SyntaxError: peg$SyntaxError, + parse: peg$parse + }; + }() +); +var xparse_argspec_default = ( + // Generated by Peggy 2.0.1. + // + // https://peggyjs.org/ + function() { + function peg$subclass(child, parent) { + function C() { + this.constructor = child; + } + C.prototype = parent.prototype; + child.prototype = new C(); + } + function peg$SyntaxError(message, expected, found, location) { + var self = Error.call(this, message); + if (Object.setPrototypeOf) { + Object.setPrototypeOf(self, peg$SyntaxError.prototype); + } + self.expected = expected; + self.found = found; + self.location = location; + self.name = "SyntaxError"; + return self; + } + peg$subclass(peg$SyntaxError, Error); + function peg$padEnd(str, targetLength, padString) { + padString = padString || " "; + if (str.length > targetLength) { + return str; + } + targetLength -= str.length; + padString += padString.repeat(targetLength); + return str + padString.slice(0, targetLength); + } + peg$SyntaxError.prototype.format = function(sources) { + var str = "Error: " + this.message; + if (this.location) { + var src = null; + var k; + for (k = 0; k < sources.length; k++) { + if (sources[k].source === this.location.source) { + src = sources[k].text.split(/\r\n|\n|\r/g); + break; + } + } + var s2 = this.location.start; + var loc = this.location.source + ":" + s2.line + ":" + s2.column; + if (src) { + var e = this.location.end; + var filler = peg$padEnd("", s2.line.toString().length, " "); + var line3 = src[s2.line - 1]; + var last = s2.line === e.line ? e.column : line3.length + 1; + var hatLen = last - s2.column || 1; + str += "\n --> " + loc + "\n" + filler + " |\n" + s2.line + " | " + line3 + "\n" + filler + " | " + peg$padEnd("", s2.column - 1, " ") + peg$padEnd("", hatLen, "^"); + } else { + str += "\n at " + loc; + } + } + return str; + }; + peg$SyntaxError.buildMessage = function(expected, found) { + var DESCRIBE_EXPECTATION_FNS = { + literal: function(expectation) { + return '"' + literalEscape(expectation.text) + '"'; + }, + class: function(expectation) { + var escapedParts = expectation.parts.map(function(part) { + return Array.isArray(part) ? classEscape(part[0]) + "-" + classEscape(part[1]) : classEscape(part); + }); + return "[" + (expectation.inverted ? "^" : "") + escapedParts.join("") + "]"; + }, + any: function() { + return "any character"; + }, + end: function() { + return "end of input"; + }, + other: function(expectation) { + return expectation.description; + } + }; + function hex(ch) { + return ch.charCodeAt(0).toString(16).toUpperCase(); + } + function literalEscape(s2) { + return s2.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\0/g, "\\0").replace(/\t/g, "\\t").replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/[\x00-\x0F]/g, function(ch) { + return "\\x0" + hex(ch); + }).replace(/[\x10-\x1F\x7F-\x9F]/g, function(ch) { + return "\\x" + hex(ch); + }); + } + function classEscape(s2) { + return s2.replace(/\\/g, "\\\\").replace(/\]/g, "\\]").replace(/\^/g, "\\^").replace(/-/g, "\\-").replace(/\0/g, "\\0").replace(/\t/g, "\\t").replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/[\x00-\x0F]/g, function(ch) { + return "\\x0" + hex(ch); + }).replace(/[\x10-\x1F\x7F-\x9F]/g, function(ch) { + return "\\x" + hex(ch); + }); + } + function describeExpectation(expectation) { + return DESCRIBE_EXPECTATION_FNS[expectation.type](expectation); + } + function describeExpected(expected2) { + var descriptions = expected2.map(describeExpectation); + var i, j; + descriptions.sort(); + if (descriptions.length > 0) { + for (i = 1, j = 1; i < descriptions.length; i++) { + if (descriptions[i - 1] !== descriptions[i]) { + descriptions[j] = descriptions[i]; + j++; + } + } + descriptions.length = j; + } + switch (descriptions.length) { + case 1: + return descriptions[0]; + case 2: + return descriptions[0] + " or " + descriptions[1]; + default: + return descriptions.slice(0, -1).join(", ") + ", or " + descriptions[descriptions.length - 1]; + } + } + function describeFound(found2) { + return found2 ? '"' + literalEscape(found2) + '"' : "end of input"; + } + return "Expected " + describeExpected(expected) + " but " + describeFound(found) + " found."; + }; + function peg$parse(input, options2) { + options2 = options2 !== void 0 ? options2 : {}; + var peg$FAILED = {}; + var peg$source = options2.grammarSource; + var peg$startRuleFunctions = { args_spec_list: peg$parseargs_spec_list }; + var peg$startRuleFunction = peg$parseargs_spec_list; + var peg$c1 = "v"; + var peg$c2 = "b"; + var peg$c3 = "!"; + var peg$c4 = "D"; + var peg$c5 = "d"; + var peg$c6 = "s"; + var peg$c7 = "O"; + var peg$c8 = "o"; + var peg$c9 = "e"; + var peg$c10 = "E"; + var peg$c11 = "t"; + var peg$c12 = "R"; + var peg$c13 = "r"; + var peg$c14 = "u"; + var peg$c15 = "m"; + var peg$c16 = "{"; + var peg$c17 = "}"; + var peg$c18 = " "; + var peg$c19 = "\n"; + var peg$c20 = "\r"; + var peg$r0 = /^[{ ]/; + var peg$e0 = peg$literalExpectation("+", false); + var peg$e1 = peg$literalExpectation("v", false); + var peg$e2 = peg$anyExpectation(); + var peg$e3 = peg$literalExpectation("b", false); + var peg$e4 = peg$literalExpectation("!", false); + var peg$e5 = peg$literalExpectation("D", false); + var peg$e6 = peg$literalExpectation("d", false); + var peg$e7 = peg$literalExpectation("s", false); + var peg$e8 = peg$literalExpectation("O", false); + var peg$e9 = peg$literalExpectation("o", false); + var peg$e10 = peg$literalExpectation("e", false); + var peg$e11 = peg$literalExpectation("E", false); + var peg$e12 = peg$literalExpectation("t", false); + var peg$e13 = peg$literalExpectation("R", false); + var peg$e14 = peg$literalExpectation("r", false); + var peg$e15 = peg$literalExpectation("u", false); + var peg$e16 = peg$classExpectation(["{", " "], false, false); + var peg$e17 = peg$literalExpectation("m", false); + var peg$e18 = peg$literalExpectation("{", false); + var peg$e19 = peg$literalExpectation("}", false); + var peg$e20 = peg$literalExpectation(" ", false); + var peg$e21 = peg$literalExpectation("\n", false); + var peg$e22 = peg$literalExpectation("\r", false); + var peg$f0 = function(x) { + return x; + }; + var peg$f1 = function(spec) { + return spec; + }; + var peg$f2 = function(spec) { + return spec; + }; + var peg$f3 = function(openBrace) { + return createNode("verbatim", { openBrace, closeBrace: openBrace }); + }; + var peg$f4 = function() { + return createNode("body"); + }; + var peg$f5 = function(leading_bang, spec) { + return leading_bang ? { ...spec, noLeadingWhitespace: true } : spec; + }; + var peg$f6 = function(braceSpec, defaultArg) { + return createNode("optional", { ...braceSpec, defaultArg }); + }; + var peg$f7 = function(braceSpec) { + return createNode("optional", braceSpec); + }; + var peg$f8 = function() { + return createNode("optionalStar"); + }; + var peg$f9 = function(g) { + return createNode("optional", { defaultArg: g }); + }; + var peg$f10 = function() { + return createNode("optional"); + }; + var peg$f11 = function(args) { + return createNode("embellishment", { + embellishmentTokens: args.content + }); + }; + var peg$f12 = function(args, g) { + return createNode("embellishment", { + embellishmentTokens: args.content, + defaultArg: g + }); + }; + var peg$f13 = function(tok) { + return createNode("optionalToken", { token: tok }); + }; + var peg$f14 = function(braceSpec, defaultArg) { + return createNode("mandatory", { ...braceSpec, defaultArg }); + }; + var peg$f15 = function(braceSpec) { + return createNode("mandatory", braceSpec); + }; + var peg$f16 = function(stopTokens) { + return createNode("until", { stopTokens }); + }; + var peg$f17 = function(x) { + return [x]; + }; + var peg$f18 = function(g) { + return g.content; + }; + var peg$f19 = function() { + return createNode("mandatory"); + }; + var peg$f20 = function(openBrace, closeBrace) { + return { openBrace, closeBrace }; + }; + var peg$f21 = function(content) { + return { type: "group", content }; + }; + var peg$f22 = function() { + return ""; + }; + var peg$currPos = 0; + var peg$posDetailsCache = [{ line: 1, column: 1 }]; + var peg$maxFailPos = 0; + var peg$maxFailExpected = []; + var peg$silentFails = 0; + var peg$result; + if ("startRule" in options2) { + if (!(options2.startRule in peg$startRuleFunctions)) { + throw new Error(`Can't start parsing from rule "` + options2.startRule + '".'); + } + peg$startRuleFunction = peg$startRuleFunctions[options2.startRule]; + } + function peg$literalExpectation(text2, ignoreCase) { + return { type: "literal", text: text2, ignoreCase }; + } + function peg$classExpectation(parts, inverted, ignoreCase) { + return { type: "class", parts, inverted, ignoreCase }; + } + function peg$anyExpectation() { + return { type: "any" }; + } + function peg$endExpectation() { + return { type: "end" }; + } + function peg$computePosDetails(pos) { + var details = peg$posDetailsCache[pos]; + var p; + if (details) { + return details; + } else { + p = pos - 1; + while (!peg$posDetailsCache[p]) { + p--; + } + details = peg$posDetailsCache[p]; + details = { + line: details.line, + column: details.column + }; + while (p < pos) { + if (input.charCodeAt(p) === 10) { + details.line++; + details.column = 1; + } else { + details.column++; + } + p++; + } + peg$posDetailsCache[pos] = details; + return details; + } + } + function peg$computeLocation(startPos, endPos) { + var startPosDetails = peg$computePosDetails(startPos); + var endPosDetails = peg$computePosDetails(endPos); + return { + source: peg$source, + start: { + offset: startPos, + line: startPosDetails.line, + column: startPosDetails.column + }, + end: { + offset: endPos, + line: endPosDetails.line, + column: endPosDetails.column + } + }; + } + function peg$fail(expected2) { + if (peg$currPos < peg$maxFailPos) { + return; + } + if (peg$currPos > peg$maxFailPos) { + peg$maxFailPos = peg$currPos; + peg$maxFailExpected = []; + } + peg$maxFailExpected.push(expected2); + } + function peg$buildStructuredError(expected2, found, location2) { + return new peg$SyntaxError( + peg$SyntaxError.buildMessage(expected2, found), + expected2, + found, + location2 + ); + } + function peg$parseargs_spec_list() { + var s0, s1, s2, s4; + s0 = peg$currPos; + s1 = []; + s2 = peg$currPos; + peg$parsewhitespace(); + s4 = peg$parsearg_spec(); + if (s4 !== peg$FAILED) { + s2 = peg$f0(s4); + } else { + peg$currPos = s2; + s2 = peg$FAILED; + } + while (s2 !== peg$FAILED) { + s1.push(s2); + s2 = peg$currPos; + peg$parsewhitespace(); + s4 = peg$parsearg_spec(); + if (s4 !== peg$FAILED) { + s2 = peg$f0(s4); + } else { + peg$currPos = s2; + s2 = peg$FAILED; + } + } + s2 = peg$parsewhitespace(); + s0 = peg$f1(s1); + return s0; + } + function peg$parsearg_spec() { + var s0, s2; + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 43) { + peg$currPos++; + } else { + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + s2 = peg$parseoptional(); + if (s2 === peg$FAILED) { + s2 = peg$parsemandatory(); + if (s2 === peg$FAILED) { + s2 = peg$parseverbatim(); + if (s2 === peg$FAILED) { + s2 = peg$parserequired(); + if (s2 === peg$FAILED) { + s2 = peg$parsebody(); + if (s2 === peg$FAILED) { + s2 = peg$parseuntil(); + } + } + } + } + } + if (s2 !== peg$FAILED) { + s0 = peg$f2(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parseverbatim() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 118) { + s1 = peg$c1; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e1); + } + } + if (s1 !== peg$FAILED) { + if (input.length > peg$currPos) { + s2 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e2); + } + } + if (s2 !== peg$FAILED) { + s0 = peg$f3(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsebody() { + var s0, s1; + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 98) { + s1 = peg$c2; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s1 !== peg$FAILED) { + s1 = peg$f4(); + } + s0 = s1; + return s0; + } + function peg$parseoptional() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 33) { + s1 = peg$c3; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e4); + } + } + if (s1 === peg$FAILED) { + s1 = null; + } + s2 = peg$parseoptional_star(); + if (s2 === peg$FAILED) { + s2 = peg$parseoptional_standard(); + if (s2 === peg$FAILED) { + s2 = peg$parseoptional_delimited(); + if (s2 === peg$FAILED) { + s2 = peg$parseoptional_embellishment(); + if (s2 === peg$FAILED) { + s2 = peg$parseoptional_token(); + } + } + } + } + if (s2 !== peg$FAILED) { + s0 = peg$f5(s1, s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parseoptional_delimited() { + var s0, s1, s2, s3; + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 68) { + s1 = peg$c4; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e5); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$parsebrace_spec(); + s3 = peg$parsebraced_group(); + if (s3 !== peg$FAILED) { + s0 = peg$f6(s2, s3); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 100) { + s1 = peg$c5; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e6); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$parsebrace_spec(); + s0 = peg$f7(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } + return s0; + } + function peg$parseoptional_star() { + var s0, s1; + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 115) { + s1 = peg$c6; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e7); + } + } + if (s1 !== peg$FAILED) { + s1 = peg$f8(); + } + s0 = s1; + return s0; + } + function peg$parseoptional_standard() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 79) { + s1 = peg$c7; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e8); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$parsebraced_group(); + if (s2 !== peg$FAILED) { + s0 = peg$f9(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 111) { + s1 = peg$c8; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e9); + } + } + if (s1 !== peg$FAILED) { + s1 = peg$f10(); + } + s0 = s1; + } + return s0; + } + function peg$parseoptional_embellishment() { + var s0, s1, s2, s3; + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 101) { + s1 = peg$c9; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e10); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$parsebraced_group(); + if (s2 !== peg$FAILED) { + s0 = peg$f11(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 69) { + s1 = peg$c10; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e11); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$parsebraced_group(); + if (s2 !== peg$FAILED) { + s3 = peg$parsebraced_group(); + if (s3 !== peg$FAILED) { + s0 = peg$f12(s2, s3); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } + return s0; + } + function peg$parseoptional_token() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 116) { + s1 = peg$c11; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e12); + } + } + if (s1 !== peg$FAILED) { + if (input.length > peg$currPos) { + s2 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e2); + } + } + if (s2 !== peg$FAILED) { + s0 = peg$f13(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parserequired() { + var s0, s1, s2, s3; + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 82) { + s1 = peg$c12; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e13); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$parsebrace_spec(); + s3 = peg$parsebraced_group(); + if (s3 !== peg$FAILED) { + s0 = peg$f14(s2, s3); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 114) { + s1 = peg$c13; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e14); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$parsebrace_spec(); + s0 = peg$f15(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } + return s0; + } + function peg$parseuntil() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 117) { + s1 = peg$c14; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e15); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$parseuntil_stop_token(); + if (s2 !== peg$FAILED) { + s0 = peg$f16(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parseuntil_stop_token() { + var s0, s1, s2; + s0 = peg$currPos; + s1 = peg$currPos; + peg$silentFails++; + if (peg$r0.test(input.charAt(peg$currPos))) { + s2 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e16); + } + } + peg$silentFails--; + if (s2 === peg$FAILED) { + s1 = void 0; + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + if (s1 !== peg$FAILED) { + if (input.length > peg$currPos) { + s2 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e2); + } + } + if (s2 !== peg$FAILED) { + s0 = peg$f17(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$parsebraced_group(); + if (s1 !== peg$FAILED) { + s1 = peg$f18(s1); + } + s0 = s1; + } + return s0; + } + function peg$parsemandatory() { + var s0, s1; + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 109) { + s1 = peg$c15; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e17); + } + } + if (s1 !== peg$FAILED) { + s1 = peg$f19(); + } + s0 = s1; + return s0; + } + function peg$parsebrace_spec() { + var s0, s1, s2, s3, s4, s5; + s0 = peg$currPos; + s1 = peg$currPos; + s2 = peg$currPos; + s3 = peg$currPos; + peg$silentFails++; + s4 = peg$parsewhitespace_token(); + peg$silentFails--; + if (s4 === peg$FAILED) { + s3 = void 0; + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + if (s3 !== peg$FAILED) { + if (input.length > peg$currPos) { + s4 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s4 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e2); + } + } + if (s4 !== peg$FAILED) { + s3 = [s3, s4]; + s2 = s3; + } else { + peg$currPos = s2; + s2 = peg$FAILED; + } + } else { + peg$currPos = s2; + s2 = peg$FAILED; + } + if (s2 === peg$FAILED) { + s2 = null; + } + s1 = input.substring(s1, peg$currPos); + s2 = peg$currPos; + s3 = peg$currPos; + s4 = peg$currPos; + peg$silentFails++; + s5 = peg$parsewhitespace_token(); + peg$silentFails--; + if (s5 === peg$FAILED) { + s4 = void 0; + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + if (s4 !== peg$FAILED) { + if (input.length > peg$currPos) { + s5 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s5 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e2); + } + } + if (s5 !== peg$FAILED) { + s4 = [s4, s5]; + s3 = s4; + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + if (s3 === peg$FAILED) { + s3 = null; + } + s2 = input.substring(s2, peg$currPos); + s0 = peg$f20(s1, s2); + return s0; + } + function peg$parsebraced_group() { + var s0, s1, s2, s3, s4, s5, s6, s7; + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 123) { + s1 = peg$c16; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e18); + } + } + if (s1 !== peg$FAILED) { + s2 = []; + s3 = peg$currPos; + s4 = peg$currPos; + s5 = peg$currPos; + peg$silentFails++; + if (input.charCodeAt(peg$currPos) === 125) { + s6 = peg$c17; + peg$currPos++; + } else { + s6 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e19); + } + } + peg$silentFails--; + if (s6 === peg$FAILED) { + s5 = void 0; + } else { + peg$currPos = s5; + s5 = peg$FAILED; + } + if (s5 !== peg$FAILED) { + s6 = peg$currPos; + peg$silentFails++; + s7 = peg$parsebraced_group(); + peg$silentFails--; + if (s7 === peg$FAILED) { + s6 = void 0; + } else { + peg$currPos = s6; + s6 = peg$FAILED; + } + if (s6 !== peg$FAILED) { + if (input.length > peg$currPos) { + s7 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s7 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e2); + } + } + if (s7 !== peg$FAILED) { + s5 = [s5, s6, s7]; + s4 = s5; + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + if (s4 !== peg$FAILED) { + s3 = input.substring(s3, peg$currPos); + } else { + s3 = s4; + } + if (s3 === peg$FAILED) { + s3 = peg$parsebraced_group(); + } + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$currPos; + s4 = peg$currPos; + s5 = peg$currPos; + peg$silentFails++; + if (input.charCodeAt(peg$currPos) === 125) { + s6 = peg$c17; + peg$currPos++; + } else { + s6 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e19); + } + } + peg$silentFails--; + if (s6 === peg$FAILED) { + s5 = void 0; + } else { + peg$currPos = s5; + s5 = peg$FAILED; + } + if (s5 !== peg$FAILED) { + s6 = peg$currPos; + peg$silentFails++; + s7 = peg$parsebraced_group(); + peg$silentFails--; + if (s7 === peg$FAILED) { + s6 = void 0; + } else { + peg$currPos = s6; + s6 = peg$FAILED; + } + if (s6 !== peg$FAILED) { + if (input.length > peg$currPos) { + s7 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s7 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e2); + } + } + if (s7 !== peg$FAILED) { + s5 = [s5, s6, s7]; + s4 = s5; + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + if (s4 !== peg$FAILED) { + s3 = input.substring(s3, peg$currPos); + } else { + s3 = s4; + } + if (s3 === peg$FAILED) { + s3 = peg$parsebraced_group(); + } + } + if (input.charCodeAt(peg$currPos) === 125) { + s3 = peg$c17; + peg$currPos++; + } else { + s3 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e19); + } + } + if (s3 !== peg$FAILED) { + s0 = peg$f21(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsewhitespace() { + var s0, s1, s2; + s0 = peg$currPos; + s1 = []; + s2 = peg$parsewhitespace_token(); + while (s2 !== peg$FAILED) { + s1.push(s2); + s2 = peg$parsewhitespace_token(); + } + s1 = peg$f22(); + s0 = s1; + return s0; + } + function peg$parsewhitespace_token() { + var s0; + if (input.charCodeAt(peg$currPos) === 32) { + s0 = peg$c18; + peg$currPos++; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e20); + } + } + if (s0 === peg$FAILED) { + if (input.charCodeAt(peg$currPos) === 10) { + s0 = peg$c19; + peg$currPos++; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e21); + } + } + if (s0 === peg$FAILED) { + if (input.charCodeAt(peg$currPos) === 13) { + s0 = peg$c20; + peg$currPos++; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e22); + } + } + } + } + return s0; + } + const DEFAULT_OPTIONS = { + optional: { openBrace: "[", closeBrace: "]" }, + mandatory: { openBrace: "{", closeBrace: "}" } + }; + function createNode(type, options22) { + const computedOptions = DEFAULT_OPTIONS[type] || {}; + return { type, ...computedOptions, ...options22 }; + } + peg$result = peg$startRuleFunction(); + if (peg$result !== peg$FAILED && peg$currPos === input.length) { + return peg$result; + } else { + if (peg$result !== peg$FAILED && peg$currPos < input.length) { + peg$fail(peg$endExpectation()); + } + throw peg$buildStructuredError( + peg$maxFailExpected, + peg$maxFailPos < input.length ? input.charAt(peg$maxFailPos) : null, + peg$maxFailPos < input.length ? peg$computeLocation(peg$maxFailPos, peg$maxFailPos + 1) : peg$computeLocation(peg$maxFailPos, peg$maxFailPos) + ); + } + } + return { + SyntaxError: peg$SyntaxError, + parse: peg$parse + }; + }() +); +var pgfkeys_default = ( + // Generated by Peggy 2.0.1. + // + // https://peggyjs.org/ + function() { + function peg$subclass(child, parent) { + function C() { + this.constructor = child; + } + C.prototype = parent.prototype; + child.prototype = new C(); + } + function peg$SyntaxError(message, expected, found, location) { + var self = Error.call(this, message); + if (Object.setPrototypeOf) { + Object.setPrototypeOf(self, peg$SyntaxError.prototype); + } + self.expected = expected; + self.found = found; + self.location = location; + self.name = "SyntaxError"; + return self; + } + peg$subclass(peg$SyntaxError, Error); + function peg$padEnd(str, targetLength, padString) { + padString = padString || " "; + if (str.length > targetLength) { + return str; + } + targetLength -= str.length; + padString += padString.repeat(targetLength); + return str + padString.slice(0, targetLength); + } + peg$SyntaxError.prototype.format = function(sources) { + var str = "Error: " + this.message; + if (this.location) { + var src = null; + var k; + for (k = 0; k < sources.length; k++) { + if (sources[k].source === this.location.source) { + src = sources[k].text.split(/\r\n|\n|\r/g); + break; + } + } + var s2 = this.location.start; + var loc = this.location.source + ":" + s2.line + ":" + s2.column; + if (src) { + var e = this.location.end; + var filler = peg$padEnd("", s2.line.toString().length, " "); + var line3 = src[s2.line - 1]; + var last = s2.line === e.line ? e.column : line3.length + 1; + var hatLen = last - s2.column || 1; + str += "\n --> " + loc + "\n" + filler + " |\n" + s2.line + " | " + line3 + "\n" + filler + " | " + peg$padEnd("", s2.column - 1, " ") + peg$padEnd("", hatLen, "^"); + } else { + str += "\n at " + loc; + } + } + return str; + }; + peg$SyntaxError.buildMessage = function(expected, found) { + var DESCRIBE_EXPECTATION_FNS = { + literal: function(expectation) { + return '"' + literalEscape(expectation.text) + '"'; + }, + class: function(expectation) { + var escapedParts = expectation.parts.map(function(part) { + return Array.isArray(part) ? classEscape(part[0]) + "-" + classEscape(part[1]) : classEscape(part); + }); + return "[" + (expectation.inverted ? "^" : "") + escapedParts.join("") + "]"; + }, + any: function() { + return "any character"; + }, + end: function() { + return "end of input"; + }, + other: function(expectation) { + return expectation.description; + } + }; + function hex(ch) { + return ch.charCodeAt(0).toString(16).toUpperCase(); + } + function literalEscape(s2) { + return s2.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\0/g, "\\0").replace(/\t/g, "\\t").replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/[\x00-\x0F]/g, function(ch) { + return "\\x0" + hex(ch); + }).replace(/[\x10-\x1F\x7F-\x9F]/g, function(ch) { + return "\\x" + hex(ch); + }); + } + function classEscape(s2) { + return s2.replace(/\\/g, "\\\\").replace(/\]/g, "\\]").replace(/\^/g, "\\^").replace(/-/g, "\\-").replace(/\0/g, "\\0").replace(/\t/g, "\\t").replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/[\x00-\x0F]/g, function(ch) { + return "\\x0" + hex(ch); + }).replace(/[\x10-\x1F\x7F-\x9F]/g, function(ch) { + return "\\x" + hex(ch); + }); + } + function describeExpectation(expectation) { + return DESCRIBE_EXPECTATION_FNS[expectation.type](expectation); + } + function describeExpected(expected2) { + var descriptions = expected2.map(describeExpectation); + var i, j; + descriptions.sort(); + if (descriptions.length > 0) { + for (i = 1, j = 1; i < descriptions.length; i++) { + if (descriptions[i - 1] !== descriptions[i]) { + descriptions[j] = descriptions[i]; + j++; + } + } + descriptions.length = j; + } + switch (descriptions.length) { + case 1: + return descriptions[0]; + case 2: + return descriptions[0] + " or " + descriptions[1]; + default: + return descriptions.slice(0, -1).join(", ") + ", or " + descriptions[descriptions.length - 1]; + } + } + function describeFound(found2) { + return found2 ? '"' + literalEscape(found2) + '"' : "end of input"; + } + return "Expected " + describeExpected(expected) + " but " + describeFound(found) + " found."; + }; + function peg$parse(input, options2) { + options2 = options2 !== void 0 ? options2 : {}; + var peg$FAILED = {}; + var peg$source = options2.grammarSource; + var peg$startRuleFunctions = { body: peg$parsebody }; + var peg$startRuleFunction = peg$parsebody; + var peg$e0 = peg$anyExpectation(); + var peg$f0 = function() { + return []; + }; + var peg$f1 = function(rowItems, trailingComment) { + return { + itemParts: [], + ...rowItems, + trailingComment, + trailingComma: true + }; + }; + var peg$f2 = function(rowItems, trailingComment) { + return { ...rowItems, trailingComment }; + }; + var peg$f3 = function(a, b) { + return processItem(a, b); + }; + var peg$f4 = function(b) { + return processItem(null, b); + }; + var peg$f5 = function(cell) { + return { cell }; + }; + var peg$f6 = function() { + return {}; + }; + var peg$f7 = function(part) { + return part; + }; + var peg$f8 = function(x) { + return x; + }; + var peg$f9 = function(space, x) { + return { + trailingComment: x, + leadingParbreak: space.parbreak > 0 + }; + }; + var peg$f10 = function(list) { + return { + whitespace: list.filter((x) => options2.isWhitespace(x)).length, + parbreak: list.filter((x) => options2.isParbreak(x)).length + }; + }; + var peg$f11 = function() { + return !options2.allowParenGroups; + }; + var peg$f12 = function(tok) { + return options2.isSameLineComment(tok); + }; + var peg$f13 = function(tok) { + return tok; + }; + var peg$f14 = function(tok) { + return options2.isOwnLineComment(tok); + }; + var peg$f15 = function(tok) { + return tok; + }; + var peg$f16 = function(tok) { + return options2.isWhitespace(tok); + }; + var peg$f17 = function(tok) { + return tok; + }; + var peg$f18 = function(tok) { + return options2.isParbreak(tok); + }; + var peg$f19 = function(tok) { + return tok; + }; + var peg$f20 = function(tok) { + return options2.isComma(tok); + }; + var peg$f21 = function(tok) { + return tok; + }; + var peg$f22 = function(tok) { + return options2.isEquals(tok); + }; + var peg$f23 = function(tok) { + return tok; + }; + var peg$f24 = function(tok) { + return options2.isChar(tok, "("); + }; + var peg$f25 = function(tok) { + return tok; + }; + var peg$f26 = function(tok) { + return options2.isChar(tok, ")"); + }; + var peg$f27 = function(tok) { + return tok; + }; + var peg$currPos = 0; + var peg$posDetailsCache = [{ line: 1, column: 1 }]; + var peg$maxFailPos = 0; + var peg$maxFailExpected = []; + var peg$silentFails = 0; + var peg$result; + if ("startRule" in options2) { + if (!(options2.startRule in peg$startRuleFunctions)) { + throw new Error(`Can't start parsing from rule "` + options2.startRule + '".'); + } + peg$startRuleFunction = peg$startRuleFunctions[options2.startRule]; + } + function peg$anyExpectation() { + return { type: "any" }; + } + function peg$endExpectation() { + return { type: "end" }; + } + function peg$computePosDetails(pos) { + var details = peg$posDetailsCache[pos]; + var p; + if (details) { + return details; + } else { + p = pos - 1; + while (!peg$posDetailsCache[p]) { + p--; + } + details = peg$posDetailsCache[p]; + details = { + line: details.line, + column: details.column + }; + while (p < pos) { + if (input.charCodeAt(p) === 10) { + details.line++; + details.column = 1; + } else { + details.column++; + } + p++; + } + peg$posDetailsCache[pos] = details; + return details; + } + } + function peg$computeLocation(startPos, endPos) { + var startPosDetails = peg$computePosDetails(startPos); + var endPosDetails = peg$computePosDetails(endPos); + return { + source: peg$source, + start: { + offset: startPos, + line: startPosDetails.line, + column: startPosDetails.column + }, + end: { + offset: endPos, + line: endPosDetails.line, + column: endPosDetails.column + } + }; + } + function peg$fail(expected2) { + if (peg$currPos < peg$maxFailPos) { + return; + } + if (peg$currPos > peg$maxFailPos) { + peg$maxFailPos = peg$currPos; + peg$maxFailExpected = []; + } + peg$maxFailExpected.push(expected2); + } + function peg$buildStructuredError(expected2, found, location2) { + return new peg$SyntaxError( + peg$SyntaxError.buildMessage(expected2, found), + expected2, + found, + location2 + ); + } + function peg$parsebody() { + var s0, s1, s2; + s0 = []; + s1 = peg$parsecomment_only_line(); + if (s1 === peg$FAILED) { + s1 = peg$parseitem_with_end(); + if (s1 === peg$FAILED) { + s1 = peg$parseitem_without_end(); + } + } + if (s1 !== peg$FAILED) { + while (s1 !== peg$FAILED) { + s0.push(s1); + s1 = peg$parsecomment_only_line(); + if (s1 === peg$FAILED) { + s1 = peg$parseitem_with_end(); + if (s1 === peg$FAILED) { + s1 = peg$parseitem_without_end(); + } + } + } + } else { + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = []; + s2 = peg$parsewhitespace(); + while (s2 !== peg$FAILED) { + s1.push(s2); + s2 = peg$parsewhitespace(); + } + s2 = peg$parseEOL(); + if (s2 !== peg$FAILED) { + s0 = peg$f0(); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } + return s0; + } + function peg$parseitem_with_end() { + var s0, s2, s4, s5, s6, s7, s8; + s0 = peg$currPos; + peg$parsewhitespace_or_parbreaks(); + s2 = peg$parserow_items(); + if (s2 === peg$FAILED) { + s2 = null; + } + peg$parsewhitespace_or_parbreaks(); + s4 = peg$parseitem_sep(); + if (s4 !== peg$FAILED) { + s5 = []; + s6 = peg$parsewhitespace(); + while (s6 !== peg$FAILED) { + s5.push(s6); + s6 = peg$parsewhitespace(); + } + s6 = peg$parsetrailing_comment(); + if (s6 === peg$FAILED) { + s6 = null; + } + s7 = []; + s8 = peg$parsewhitespace(); + while (s8 !== peg$FAILED) { + s7.push(s8); + s8 = peg$parsewhitespace(); + } + s0 = peg$f1(s2, s6); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parseitem_without_end() { + var s0, s2, s3; + s0 = peg$currPos; + peg$parsewhitespace_or_parbreaks(); + s2 = peg$parserow_items(); + if (s2 !== peg$FAILED) { + s3 = peg$parsetrailing_comment(); + if (s3 === peg$FAILED) { + s3 = null; + } + s0 = peg$f2(s2, s3); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parserow_items() { + var s0, s1, s2, s3; + s0 = peg$currPos; + s1 = peg$parseitem_part(); + if (s1 !== peg$FAILED) { + s2 = []; + s3 = peg$parseseparated_part(); + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$parseseparated_part(); + } + s0 = peg$f3(s1, s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = []; + s2 = peg$parseseparated_part(); + if (s2 !== peg$FAILED) { + while (s2 !== peg$FAILED) { + s1.push(s2); + s2 = peg$parseseparated_part(); + } + } else { + s1 = peg$FAILED; + } + if (s1 !== peg$FAILED) { + s1 = peg$f4(s1); + } + s0 = s1; + } + return s0; + } + function peg$parseseparated_part() { + var s0, s1, s2, s3, s4; + s0 = peg$currPos; + s1 = []; + s2 = peg$parseparbreak(); + while (s2 !== peg$FAILED) { + s1.push(s2); + s2 = peg$parseparbreak(); + } + s2 = peg$parseequals(); + if (s2 !== peg$FAILED) { + s3 = []; + s4 = peg$parseparbreak(); + while (s4 !== peg$FAILED) { + s3.push(s4); + s4 = peg$parseparbreak(); + } + s4 = peg$parseitem_part(); + if (s4 !== peg$FAILED) { + s0 = peg$f5(s4); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = []; + s2 = peg$parseparbreak(); + while (s2 !== peg$FAILED) { + s1.push(s2); + s2 = peg$parseparbreak(); + } + s2 = peg$parseequals(); + if (s2 !== peg$FAILED) { + s0 = peg$f6(); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } + return s0; + } + function peg$parseitem_part() { + var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9; + s0 = peg$currPos; + s1 = []; + s2 = peg$parsewhitespace(); + while (s2 !== peg$FAILED) { + s1.push(s2); + s2 = peg$parsewhitespace(); + } + s2 = peg$currPos; + s3 = []; + s4 = peg$parsenon_whitespace_non_parbreak_token(); + if (s4 === peg$FAILED) { + s4 = peg$currPos; + s5 = peg$parsewhitespace(); + if (s5 === peg$FAILED) { + s5 = peg$parseparbreak(); + } + if (s5 !== peg$FAILED) { + s6 = peg$currPos; + peg$silentFails++; + s7 = peg$currPos; + s8 = []; + s9 = peg$parsewhitespace(); + if (s9 === peg$FAILED) { + s9 = peg$parseparbreak(); + } + while (s9 !== peg$FAILED) { + s8.push(s9); + s9 = peg$parsewhitespace(); + if (s9 === peg$FAILED) { + s9 = peg$parseparbreak(); + } + } + s9 = peg$parsenon_whitespace_non_parbreak_token(); + if (s9 !== peg$FAILED) { + s8 = [s8, s9]; + s7 = s8; + } else { + peg$currPos = s7; + s7 = peg$FAILED; + } + peg$silentFails--; + if (s7 !== peg$FAILED) { + peg$currPos = s6; + s6 = void 0; + } else { + s6 = peg$FAILED; + } + if (s6 !== peg$FAILED) { + s5 = [s5, s6]; + s4 = s5; + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + } + if (s4 !== peg$FAILED) { + while (s4 !== peg$FAILED) { + s3.push(s4); + s4 = peg$parsenon_whitespace_non_parbreak_token(); + if (s4 === peg$FAILED) { + s4 = peg$currPos; + s5 = peg$parsewhitespace(); + if (s5 === peg$FAILED) { + s5 = peg$parseparbreak(); + } + if (s5 !== peg$FAILED) { + s6 = peg$currPos; + peg$silentFails++; + s7 = peg$currPos; + s8 = []; + s9 = peg$parsewhitespace(); + if (s9 === peg$FAILED) { + s9 = peg$parseparbreak(); + } + while (s9 !== peg$FAILED) { + s8.push(s9); + s9 = peg$parsewhitespace(); + if (s9 === peg$FAILED) { + s9 = peg$parseparbreak(); + } + } + s9 = peg$parsenon_whitespace_non_parbreak_token(); + if (s9 !== peg$FAILED) { + s8 = [s8, s9]; + s7 = s8; + } else { + peg$currPos = s7; + s7 = peg$FAILED; + } + peg$silentFails--; + if (s7 !== peg$FAILED) { + peg$currPos = s6; + s6 = void 0; + } else { + s6 = peg$FAILED; + } + if (s6 !== peg$FAILED) { + s5 = [s5, s6]; + s4 = s5; + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + } + } + } else { + s3 = peg$FAILED; + } + if (s3 !== peg$FAILED) { + s2 = input.substring(s2, peg$currPos); + } else { + s2 = s3; + } + if (s2 !== peg$FAILED) { + s3 = []; + s4 = peg$parsewhitespace(); + while (s4 !== peg$FAILED) { + s3.push(s4); + s4 = peg$parsewhitespace(); + } + s0 = peg$f7(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsetrailing_comment() { + var s0, s1, s2; + s0 = peg$currPos; + s1 = []; + s2 = peg$parsewhitespace(); + while (s2 !== peg$FAILED) { + s1.push(s2); + s2 = peg$parsewhitespace(); + } + s2 = peg$parsesame_line_comment(); + if (s2 !== peg$FAILED) { + s0 = peg$f8(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsecomment_only_line() { + var s0, s1, s2; + s0 = peg$currPos; + s1 = peg$parsewhitespace_or_parbreaks(); + s2 = peg$parseown_line_comment(); + if (s2 !== peg$FAILED) { + s0 = peg$f9(s1, s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsetoken() { + var s0, s1, s2, s3; + s0 = peg$currPos; + s1 = peg$currPos; + s2 = peg$currPos; + peg$silentFails++; + s3 = peg$parsenon_token(); + peg$silentFails--; + if (s3 === peg$FAILED) { + s2 = void 0; + } else { + peg$currPos = s2; + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + if (input.length > peg$currPos) { + s3 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s3 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s3 !== peg$FAILED) { + s2 = [s2, s3]; + s1 = s2; + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + if (s1 !== peg$FAILED) { + s0 = input.substring(s0, peg$currPos); + } else { + s0 = s1; + } + return s0; + } + function peg$parsenon_whitespace_non_parbreak_token() { + var s0, s1, s2, s3; + s0 = peg$currPos; + s1 = peg$currPos; + s2 = peg$currPos; + peg$silentFails++; + s3 = peg$parsewhitespace(); + if (s3 === peg$FAILED) { + s3 = peg$parseparbreak(); + } + peg$silentFails--; + if (s3 === peg$FAILED) { + s2 = void 0; + } else { + peg$currPos = s2; + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s3 = peg$parseparen_block(); + if (s3 === peg$FAILED) { + s3 = peg$parsetoken(); + } + if (s3 !== peg$FAILED) { + s2 = [s2, s3]; + s1 = s2; + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + if (s1 !== peg$FAILED) { + s0 = input.substring(s0, peg$currPos); + } else { + s0 = s1; + } + return s0; + } + function peg$parsenon_token() { + var s0; + s0 = peg$parseitem_sep(); + if (s0 === peg$FAILED) { + s0 = peg$parseequals(); + if (s0 === peg$FAILED) { + s0 = peg$parsetrailing_comment(); + if (s0 === peg$FAILED) { + s0 = peg$parseown_line_comment(); + } + } + } + return s0; + } + function peg$parsewhitespace_or_parbreaks() { + var s0, s1, s2; + s0 = peg$currPos; + s1 = []; + s2 = peg$parsewhitespace(); + if (s2 === peg$FAILED) { + s2 = peg$parseparbreak(); + } + while (s2 !== peg$FAILED) { + s1.push(s2); + s2 = peg$parsewhitespace(); + if (s2 === peg$FAILED) { + s2 = peg$parseparbreak(); + } + } + s1 = peg$f10(s1); + s0 = s1; + return s0; + } + function peg$parseparen_block() { + var s0, s1, s2, s3, s4, s5, s6, s7, s8; + s0 = peg$currPos; + s1 = peg$f11(); + if (s1) { + s1 = peg$FAILED; + } else { + s1 = void 0; + } + if (s1 !== peg$FAILED) { + s2 = peg$currPos; + s3 = peg$currPos; + s4 = peg$parseopen_paren(); + if (s4 !== peg$FAILED) { + s5 = []; + s6 = peg$currPos; + s7 = peg$currPos; + peg$silentFails++; + s8 = peg$parseclose_paren(); + peg$silentFails--; + if (s8 === peg$FAILED) { + s7 = void 0; + } else { + peg$currPos = s7; + s7 = peg$FAILED; + } + if (s7 !== peg$FAILED) { + if (input.length > peg$currPos) { + s8 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s8 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s8 !== peg$FAILED) { + s7 = [s7, s8]; + s6 = s7; + } else { + peg$currPos = s6; + s6 = peg$FAILED; + } + } else { + peg$currPos = s6; + s6 = peg$FAILED; + } + while (s6 !== peg$FAILED) { + s5.push(s6); + s6 = peg$currPos; + s7 = peg$currPos; + peg$silentFails++; + s8 = peg$parseclose_paren(); + peg$silentFails--; + if (s8 === peg$FAILED) { + s7 = void 0; + } else { + peg$currPos = s7; + s7 = peg$FAILED; + } + if (s7 !== peg$FAILED) { + if (input.length > peg$currPos) { + s8 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s8 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s8 !== peg$FAILED) { + s7 = [s7, s8]; + s6 = s7; + } else { + peg$currPos = s6; + s6 = peg$FAILED; + } + } else { + peg$currPos = s6; + s6 = peg$FAILED; + } + } + s6 = peg$parseclose_paren(); + if (s6 !== peg$FAILED) { + s4 = [s4, s5, s6]; + s3 = s4; + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + if (s3 !== peg$FAILED) { + s2 = input.substring(s2, peg$currPos); + } else { + s2 = s3; + } + if (s2 !== peg$FAILED) { + s1 = [s1, s2]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsesame_line_comment() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f12(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s0 = peg$f13(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parseown_line_comment() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f14(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s0 = peg$f15(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsewhitespace() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f16(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s0 = peg$f17(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parseparbreak() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f18(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s0 = peg$f19(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parseitem_sep() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f20(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s0 = peg$f21(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parseequals() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f22(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s0 = peg$f23(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parseopen_paren() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f24(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s0 = peg$f25(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parseclose_paren() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f26(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s0 = peg$f27(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parseEOL() { + var s0, s1; + s0 = peg$currPos; + peg$silentFails++; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + peg$silentFails--; + if (s1 === peg$FAILED) { + s0 = void 0; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function processItem(leadCell, otherCells) { + const cells = [leadCell || []]; + for (const x of otherCells) { + cells.push(x.cell || []); + } + return { itemParts: cells }; + } + if (!options2.isWhitespace) { + try { + Object.assign(options2, { + isChar: (node, char) => node.type === "string" && node.content === char, + isComma(node) { + return node.type === "string" && node.content === ","; + }, + isEquals(node) { + return node.type === "string" && node.content === "="; + }, + isParbreak(node) { + return node.type === "parbreak"; + }, + isWhitespace(node) { + return node.type === "whitespace"; + }, + isSameLineComment: (node) => node.type === "comment" && node.sameline, + isOwnLineComment: (node) => node.type === "comment" && !node.sameline, + isComment: (node) => node.type === "comment", + allowParenGroups: true + }); + } catch (e) { + console.warn("Error when initializing parser", e); + } + } + peg$result = peg$startRuleFunction(); + if (peg$result !== peg$FAILED && peg$currPos === input.length) { + return peg$result; + } else { + if (peg$result !== peg$FAILED && peg$currPos < input.length) { + peg$fail(peg$endExpectation()); + } + throw peg$buildStructuredError( + peg$maxFailExpected, + peg$maxFailPos < input.length ? input.charAt(peg$maxFailPos) : null, + peg$maxFailPos < input.length ? peg$computeLocation(peg$maxFailPos, peg$maxFailPos + 1) : peg$computeLocation(peg$maxFailPos, peg$maxFailPos) + ); + } + } + return { + SyntaxError: peg$SyntaxError, + parse: peg$parse + }; + }() +); +// Generated by Peggy 2.0.1. +// +// https://peggyjs.org/ +(function() { + function peg$subclass(child, parent) { + function C() { + this.constructor = child; + } + C.prototype = parent.prototype; + child.prototype = new C(); + } + function peg$SyntaxError(message, expected, found, location) { + var self = Error.call(this, message); + if (Object.setPrototypeOf) { + Object.setPrototypeOf(self, peg$SyntaxError.prototype); + } + self.expected = expected; + self.found = found; + self.location = location; + self.name = "SyntaxError"; + return self; + } + peg$subclass(peg$SyntaxError, Error); + function peg$padEnd(str, targetLength, padString) { + padString = padString || " "; + if (str.length > targetLength) { + return str; + } + targetLength -= str.length; + padString += padString.repeat(targetLength); + return str + padString.slice(0, targetLength); + } + peg$SyntaxError.prototype.format = function(sources) { + var str = "Error: " + this.message; + if (this.location) { + var src = null; + var k; + for (k = 0; k < sources.length; k++) { + if (sources[k].source === this.location.source) { + src = sources[k].text.split(/\r\n|\n|\r/g); + break; + } + } + var s2 = this.location.start; + var loc = this.location.source + ":" + s2.line + ":" + s2.column; + if (src) { + var e = this.location.end; + var filler = peg$padEnd("", s2.line.toString().length, " "); + var line3 = src[s2.line - 1]; + var last = s2.line === e.line ? e.column : line3.length + 1; + var hatLen = last - s2.column || 1; + str += "\n --> " + loc + "\n" + filler + " |\n" + s2.line + " | " + line3 + "\n" + filler + " | " + peg$padEnd("", s2.column - 1, " ") + peg$padEnd("", hatLen, "^"); + } else { + str += "\n at " + loc; + } + } + return str; + }; + peg$SyntaxError.buildMessage = function(expected, found) { + var DESCRIBE_EXPECTATION_FNS = { + literal: function(expectation) { + return '"' + literalEscape(expectation.text) + '"'; + }, + class: function(expectation) { + var escapedParts = expectation.parts.map(function(part) { + return Array.isArray(part) ? classEscape(part[0]) + "-" + classEscape(part[1]) : classEscape(part); + }); + return "[" + (expectation.inverted ? "^" : "") + escapedParts.join("") + "]"; + }, + any: function() { + return "any character"; + }, + end: function() { + return "end of input"; + }, + other: function(expectation) { + return expectation.description; + } + }; + function hex(ch) { + return ch.charCodeAt(0).toString(16).toUpperCase(); + } + function literalEscape(s2) { + return s2.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\0/g, "\\0").replace(/\t/g, "\\t").replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/[\x00-\x0F]/g, function(ch) { + return "\\x0" + hex(ch); + }).replace(/[\x10-\x1F\x7F-\x9F]/g, function(ch) { + return "\\x" + hex(ch); + }); + } + function classEscape(s2) { + return s2.replace(/\\/g, "\\\\").replace(/\]/g, "\\]").replace(/\^/g, "\\^").replace(/-/g, "\\-").replace(/\0/g, "\\0").replace(/\t/g, "\\t").replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/[\x00-\x0F]/g, function(ch) { + return "\\x0" + hex(ch); + }).replace(/[\x10-\x1F\x7F-\x9F]/g, function(ch) { + return "\\x" + hex(ch); + }); + } + function describeExpectation(expectation) { + return DESCRIBE_EXPECTATION_FNS[expectation.type](expectation); + } + function describeExpected(expected2) { + var descriptions = expected2.map(describeExpectation); + var i, j; + descriptions.sort(); + if (descriptions.length > 0) { + for (i = 1, j = 1; i < descriptions.length; i++) { + if (descriptions[i - 1] !== descriptions[i]) { + descriptions[j] = descriptions[i]; + j++; + } + } + descriptions.length = j; + } + switch (descriptions.length) { + case 1: + return descriptions[0]; + case 2: + return descriptions[0] + " or " + descriptions[1]; + default: + return descriptions.slice(0, -1).join(", ") + ", or " + descriptions[descriptions.length - 1]; + } + } + function describeFound(found2) { + return found2 ? '"' + literalEscape(found2) + '"' : "end of input"; + } + return "Expected " + describeExpected(expected) + " but " + describeFound(found) + " found."; + }; + function peg$parse(input, options2) { + options2 = options2 !== void 0 ? options2 : {}; + var peg$FAILED = {}; + var peg$source = options2.grammarSource; + var peg$startRuleFunctions = { body: peg$parsebody }; + var peg$startRuleFunction = peg$parsebody; + var peg$e0 = peg$anyExpectation(); + var peg$f0 = function(e) { + return [].concat(...e).filter((n) => !!n); + }; + var peg$f1 = function() { + return []; + }; + var peg$f2 = function(tok) { + return options2.isHash(tok); + }; + var peg$f3 = function(tok) { + return tok; + }; + var peg$f4 = function(tok) { + return options2.isNumber(tok); + }; + var peg$f5 = function(tok) { + return tok; + }; + var peg$f6 = function() { + return { type: "string", content: "#" }; + }; + var peg$f7 = function(num) { + const split = options2.splitNumber(num); + return [{ type: "hash_number", number: split.number }, split.rest]; + }; + var peg$currPos = 0; + var peg$posDetailsCache = [{ line: 1, column: 1 }]; + var peg$maxFailPos = 0; + var peg$maxFailExpected = []; + var peg$silentFails = 0; + var peg$result; + if ("startRule" in options2) { + if (!(options2.startRule in peg$startRuleFunctions)) { + throw new Error(`Can't start parsing from rule "` + options2.startRule + '".'); + } + peg$startRuleFunction = peg$startRuleFunctions[options2.startRule]; + } + function peg$anyExpectation() { + return { type: "any" }; + } + function peg$endExpectation() { + return { type: "end" }; + } + function peg$computePosDetails(pos) { + var details = peg$posDetailsCache[pos]; + var p; + if (details) { + return details; + } else { + p = pos - 1; + while (!peg$posDetailsCache[p]) { + p--; + } + details = peg$posDetailsCache[p]; + details = { + line: details.line, + column: details.column + }; + while (p < pos) { + if (input.charCodeAt(p) === 10) { + details.line++; + details.column = 1; + } else { + details.column++; + } + p++; + } + peg$posDetailsCache[pos] = details; + return details; + } + } + function peg$computeLocation(startPos, endPos) { + var startPosDetails = peg$computePosDetails(startPos); + var endPosDetails = peg$computePosDetails(endPos); + return { + source: peg$source, + start: { + offset: startPos, + line: startPosDetails.line, + column: startPosDetails.column + }, + end: { + offset: endPos, + line: endPosDetails.line, + column: endPosDetails.column + } + }; + } + function peg$fail(expected2) { + if (peg$currPos < peg$maxFailPos) { + return; + } + if (peg$currPos > peg$maxFailPos) { + peg$maxFailPos = peg$currPos; + peg$maxFailExpected = []; + } + peg$maxFailExpected.push(expected2); + } + function peg$buildStructuredError(expected2, found, location2) { + return new peg$SyntaxError( + peg$SyntaxError.buildMessage(expected2, found), + expected2, + found, + location2 + ); + } + function peg$parsebody() { + var s0, s1, s2; + s0 = peg$currPos; + s1 = []; + s2 = peg$parsedouble_hash(); + if (s2 === peg$FAILED) { + s2 = peg$parsehash_number(); + if (s2 === peg$FAILED) { + if (input.length > peg$currPos) { + s2 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + } + } + if (s2 !== peg$FAILED) { + while (s2 !== peg$FAILED) { + s1.push(s2); + s2 = peg$parsedouble_hash(); + if (s2 === peg$FAILED) { + s2 = peg$parsehash_number(); + if (s2 === peg$FAILED) { + if (input.length > peg$currPos) { + s2 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + } + } + } + } else { + s1 = peg$FAILED; + } + if (s1 !== peg$FAILED) { + s1 = peg$f0(s1); + } + s0 = s1; + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$parseEOL(); + if (s1 !== peg$FAILED) { + s1 = peg$f1(); + } + s0 = s1; + } + return s0; + } + function peg$parsehash() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f2(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s0 = peg$f3(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsenumber() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f4(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s0 = peg$f5(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsedouble_hash() { + var s0, s1, s2; + s0 = peg$currPos; + s1 = peg$parsehash(); + if (s1 !== peg$FAILED) { + s2 = peg$parsehash(); + if (s2 !== peg$FAILED) { + s0 = peg$f6(); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsehash_number() { + var s0, s1, s2; + s0 = peg$currPos; + s1 = peg$parsehash(); + if (s1 !== peg$FAILED) { + s2 = peg$parsenumber(); + if (s2 !== peg$FAILED) { + s0 = peg$f7(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parseEOL() { + var s0, s1; + s0 = peg$currPos; + peg$silentFails++; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + peg$silentFails--; + if (s1 === peg$FAILED) { + s0 = void 0; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + if (!options2.isHash) { + try { + Object.assign(options2, { + isHash: (node) => node.type === "string" && node.content === "#", + isNumber: (node) => node.type === "string" && 0 < +node.content.charAt(0), + splitNumber: (node) => { + const number = +node.content.charAt(0); + if (node.content.length > 1) { + return { + number, + rest: { + type: "string", + content: node.content.slice(1) + } + }; + } + return { number }; + } + }); + } catch (e) { + console.warn("Error when initializing parser", e); + } + } + peg$result = peg$startRuleFunction(); + if (peg$result !== peg$FAILED && peg$currPos === input.length) { + return peg$result; + } else { + if (peg$result !== peg$FAILED && peg$currPos < input.length) { + peg$fail(peg$endExpectation()); + } + throw peg$buildStructuredError( + peg$maxFailExpected, + peg$maxFailPos < input.length ? input.charAt(peg$maxFailPos) : null, + peg$maxFailPos < input.length ? peg$computeLocation(peg$maxFailPos, peg$maxFailPos + 1) : peg$computeLocation(peg$maxFailPos, peg$maxFailPos) + ); + } + } + return { + SyntaxError: peg$SyntaxError, + parse: peg$parse + }; +})(); +// Generated by Peggy 2.0.1. +// +// https://peggyjs.org/ +(function() { + function peg$subclass(child, parent) { + function C() { + this.constructor = child; + } + C.prototype = parent.prototype; + child.prototype = new C(); + } + function peg$SyntaxError(message, expected, found, location) { + var self = Error.call(this, message); + if (Object.setPrototypeOf) { + Object.setPrototypeOf(self, peg$SyntaxError.prototype); + } + self.expected = expected; + self.found = found; + self.location = location; + self.name = "SyntaxError"; + return self; + } + peg$subclass(peg$SyntaxError, Error); + function peg$padEnd(str, targetLength, padString) { + padString = padString || " "; + if (str.length > targetLength) { + return str; + } + targetLength -= str.length; + padString += padString.repeat(targetLength); + return str + padString.slice(0, targetLength); + } + peg$SyntaxError.prototype.format = function(sources) { + var str = "Error: " + this.message; + if (this.location) { + var src = null; + var k; + for (k = 0; k < sources.length; k++) { + if (sources[k].source === this.location.source) { + src = sources[k].text.split(/\r\n|\n|\r/g); + break; + } + } + var s2 = this.location.start; + var loc = this.location.source + ":" + s2.line + ":" + s2.column; + if (src) { + var e = this.location.end; + var filler = peg$padEnd("", s2.line.toString().length, " "); + var line3 = src[s2.line - 1]; + var last = s2.line === e.line ? e.column : line3.length + 1; + var hatLen = last - s2.column || 1; + str += "\n --> " + loc + "\n" + filler + " |\n" + s2.line + " | " + line3 + "\n" + filler + " | " + peg$padEnd("", s2.column - 1, " ") + peg$padEnd("", hatLen, "^"); + } else { + str += "\n at " + loc; + } + } + return str; + }; + peg$SyntaxError.buildMessage = function(expected, found) { + var DESCRIBE_EXPECTATION_FNS = { + literal: function(expectation) { + return '"' + literalEscape(expectation.text) + '"'; + }, + class: function(expectation) { + var escapedParts = expectation.parts.map(function(part) { + return Array.isArray(part) ? classEscape(part[0]) + "-" + classEscape(part[1]) : classEscape(part); + }); + return "[" + (expectation.inverted ? "^" : "") + escapedParts.join("") + "]"; + }, + any: function() { + return "any character"; + }, + end: function() { + return "end of input"; + }, + other: function(expectation) { + return expectation.description; + } + }; + function hex(ch) { + return ch.charCodeAt(0).toString(16).toUpperCase(); + } + function literalEscape(s2) { + return s2.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\0/g, "\\0").replace(/\t/g, "\\t").replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/[\x00-\x0F]/g, function(ch) { + return "\\x0" + hex(ch); + }).replace(/[\x10-\x1F\x7F-\x9F]/g, function(ch) { + return "\\x" + hex(ch); + }); + } + function classEscape(s2) { + return s2.replace(/\\/g, "\\\\").replace(/\]/g, "\\]").replace(/\^/g, "\\^").replace(/-/g, "\\-").replace(/\0/g, "\\0").replace(/\t/g, "\\t").replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/[\x00-\x0F]/g, function(ch) { + return "\\x0" + hex(ch); + }).replace(/[\x10-\x1F\x7F-\x9F]/g, function(ch) { + return "\\x" + hex(ch); + }); + } + function describeExpectation(expectation) { + return DESCRIBE_EXPECTATION_FNS[expectation.type](expectation); + } + function describeExpected(expected2) { + var descriptions = expected2.map(describeExpectation); + var i, j; + descriptions.sort(); + if (descriptions.length > 0) { + for (i = 1, j = 1; i < descriptions.length; i++) { + if (descriptions[i - 1] !== descriptions[i]) { + descriptions[j] = descriptions[i]; + j++; + } + } + descriptions.length = j; + } + switch (descriptions.length) { + case 1: + return descriptions[0]; + case 2: + return descriptions[0] + " or " + descriptions[1]; + default: + return descriptions.slice(0, -1).join(", ") + ", or " + descriptions[descriptions.length - 1]; + } + } + function describeFound(found2) { + return found2 ? '"' + literalEscape(found2) + '"' : "end of input"; + } + return "Expected " + describeExpected(expected) + " but " + describeFound(found) + " found."; + }; + function peg$parse(input, options2) { + options2 = options2 !== void 0 ? options2 : {}; + var peg$FAILED = {}; + var peg$source = options2.grammarSource; + var peg$startRuleFunctions = { body: peg$parsebody }; + var peg$startRuleFunction = peg$parsebody; + var peg$e0 = peg$anyExpectation(); + var peg$f0 = function(e) { + return [].concat(...e).filter((n) => !!n); + }; + var peg$f1 = function() { + return []; + }; + var peg$f2 = function(toks) { + return options2.isRecognized(toks); + }; + var peg$f3 = function(toks) { + return options2.isRecognized(toks); + }; + var peg$f4 = function(tok1, tok2) { + const split = options2.split(tok2); + return options2.isRecognized([tok1, split[0]]); + }; + var peg$f5 = function(tok1, tok2) { + const split = options2.split(tok2); + return [options2.isRecognized([tok1, split[0]]), split[1]]; + }; + var peg$f6 = function(tok1, tok2) { + return options2.isRecognized([tok1, tok2]); + }; + var peg$f7 = function(tok1, tok2) { + return options2.isRecognized([tok1, tok2]); + }; + var peg$f8 = function(toks) { + return options2.isRecognized(toks); + }; + var peg$f9 = function(toks) { + return options2.isRecognized(toks); + }; + var peg$f10 = function(tok) { + return options2.isRecognized([tok]); + }; + var peg$f11 = function(tok) { + return options2.isRecognized([tok]); + }; + var peg$f12 = function(tok) { + return options2.isMacro(tok); + }; + var peg$f13 = function(tok) { + return tok; + }; + var peg$f14 = function(tok) { + return options2.isWhitespace(tok); + }; + var peg$f15 = function(tok) { + return tok; + }; + var peg$f16 = function(tok) { + return options2.isSplitable(tok); + }; + var peg$f17 = function(tok) { + return tok; + }; + var peg$currPos = 0; + var peg$posDetailsCache = [{ line: 1, column: 1 }]; + var peg$maxFailPos = 0; + var peg$maxFailExpected = []; + var peg$silentFails = 0; + var peg$result; + if ("startRule" in options2) { + if (!(options2.startRule in peg$startRuleFunctions)) { + throw new Error(`Can't start parsing from rule "` + options2.startRule + '".'); + } + peg$startRuleFunction = peg$startRuleFunctions[options2.startRule]; + } + function peg$anyExpectation() { + return { type: "any" }; + } + function peg$endExpectation() { + return { type: "end" }; + } + function peg$computePosDetails(pos) { + var details = peg$posDetailsCache[pos]; + var p; + if (details) { + return details; + } else { + p = pos - 1; + while (!peg$posDetailsCache[p]) { + p--; + } + details = peg$posDetailsCache[p]; + details = { + line: details.line, + column: details.column + }; + while (p < pos) { + if (input.charCodeAt(p) === 10) { + details.line++; + details.column = 1; + } else { + details.column++; + } + p++; + } + peg$posDetailsCache[pos] = details; + return details; + } + } + function peg$computeLocation(startPos, endPos) { + var startPosDetails = peg$computePosDetails(startPos); + var endPosDetails = peg$computePosDetails(endPos); + return { + source: peg$source, + start: { + offset: startPos, + line: startPosDetails.line, + column: startPosDetails.column + }, + end: { + offset: endPos, + line: endPosDetails.line, + column: endPosDetails.column + } + }; + } + function peg$fail(expected2) { + if (peg$currPos < peg$maxFailPos) { + return; + } + if (peg$currPos > peg$maxFailPos) { + peg$maxFailPos = peg$currPos; + peg$maxFailExpected = []; + } + peg$maxFailExpected.push(expected2); + } + function peg$buildStructuredError(expected2, found, location2) { + return new peg$SyntaxError( + peg$SyntaxError.buildMessage(expected2, found), + expected2, + found, + location2 + ); + } + function peg$parsebody() { + var s0, s1, s2; + s0 = peg$currPos; + s1 = []; + s2 = peg$parsetriple_ligature(); + if (s2 === peg$FAILED) { + s2 = peg$parsedouble_ligature(); + if (s2 === peg$FAILED) { + s2 = peg$parsemono_ligature(); + if (s2 === peg$FAILED) { + if (input.length > peg$currPos) { + s2 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + } + } + } + if (s2 !== peg$FAILED) { + while (s2 !== peg$FAILED) { + s1.push(s2); + s2 = peg$parsetriple_ligature(); + if (s2 === peg$FAILED) { + s2 = peg$parsedouble_ligature(); + if (s2 === peg$FAILED) { + s2 = peg$parsemono_ligature(); + if (s2 === peg$FAILED) { + if (input.length > peg$currPos) { + s2 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + } + } + } + } + } else { + s1 = peg$FAILED; + } + if (s1 !== peg$FAILED) { + s1 = peg$f0(s1); + } + s0 = s1; + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$parseEOL(); + if (s1 !== peg$FAILED) { + s1 = peg$f1(); + } + s0 = s1; + } + return s0; + } + function peg$parsetriple_ligature() { + var s0, s1, s2, s3, s4; + s0 = peg$currPos; + s1 = peg$currPos; + if (input.length > peg$currPos) { + s2 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s2 !== peg$FAILED) { + if (input.length > peg$currPos) { + s3 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s3 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s3 !== peg$FAILED) { + if (input.length > peg$currPos) { + s4 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s4 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s4 !== peg$FAILED) { + s2 = [s2, s3, s4]; + s1 = s2; + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + if (s1 !== peg$FAILED) { + s2 = peg$f2(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s0 = peg$f3(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsedouble_ligature() { + var s0; + s0 = peg$parsedouble_macro_ligature(); + if (s0 === peg$FAILED) { + s0 = peg$parsedouble_macro_ligature_extracted(); + if (s0 === peg$FAILED) { + s0 = peg$parsedouble_char_ligature(); + } + } + return s0; + } + function peg$parsedouble_macro_ligature_extracted() { + var s0, s1, s2, s3, s4; + s0 = peg$currPos; + s1 = peg$parsemacro(); + if (s1 !== peg$FAILED) { + s2 = []; + s3 = peg$parsewhitespace(); + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$parsewhitespace(); + } + s3 = peg$parsesplitable(); + if (s3 !== peg$FAILED) { + s4 = peg$f4(s1, s3); + if (s4) { + s4 = void 0; + } else { + s4 = peg$FAILED; + } + if (s4 !== peg$FAILED) { + s0 = peg$f5(s1, s3); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsedouble_macro_ligature() { + var s0, s1, s2, s3, s4; + s0 = peg$currPos; + s1 = peg$parsemacro(); + if (s1 !== peg$FAILED) { + s2 = []; + s3 = peg$parsewhitespace(); + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$parsewhitespace(); + } + if (input.length > peg$currPos) { + s3 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s3 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s3 !== peg$FAILED) { + s4 = peg$f6(s1, s3); + if (s4) { + s4 = void 0; + } else { + s4 = peg$FAILED; + } + if (s4 !== peg$FAILED) { + s0 = peg$f7(s1, s3); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsedouble_char_ligature() { + var s0, s1, s2, s3; + s0 = peg$currPos; + s1 = peg$currPos; + if (input.length > peg$currPos) { + s2 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s2 !== peg$FAILED) { + if (input.length > peg$currPos) { + s3 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s3 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s3 !== peg$FAILED) { + s2 = [s2, s3]; + s1 = s2; + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + if (s1 !== peg$FAILED) { + s2 = peg$f8(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s0 = peg$f9(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsemono_ligature() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f10(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s0 = peg$f11(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsemacro() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f12(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s0 = peg$f13(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsewhitespace() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f14(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s0 = peg$f15(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsesplitable() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f16(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s0 = peg$f17(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parseEOL() { + var s0, s1; + s0 = peg$currPos; + peg$silentFails++; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + peg$silentFails--; + if (s1 === peg$FAILED) { + s0 = void 0; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + if (!options2.isWhitespace) { + try { + Object.assign(options2, { + isMacro: (node) => node.type === "macro", + isWhitespace: (node) => node.type === "whitespace", + isRecognized: (nodes) => { + if (nodes.length == 2 && nodes[0].content === "^" && nodes[1].content === "o") { + return { type: "string", content: "ô" }; + } + return null; + }, + isSplitable: (node) => node.type === "string" && node.content.length > 1, + split: (node) => [ + { type: "string", content: node.content.charAt(0) }, + { type: "string", content: node.content.slice(1) } + ] + }); + } catch (e) { + console.warn("Error when initializing parser", e); + } + } + peg$result = peg$startRuleFunction(); + if (peg$result !== peg$FAILED && peg$currPos === input.length) { + return peg$result; + } else { + if (peg$result !== peg$FAILED && peg$currPos < input.length) { + peg$fail(peg$endExpectation()); + } + throw peg$buildStructuredError( + peg$maxFailExpected, + peg$maxFailPos < input.length ? input.charAt(peg$maxFailPos) : null, + peg$maxFailPos < input.length ? peg$computeLocation(peg$maxFailPos, peg$maxFailPos + 1) : peg$computeLocation(peg$maxFailPos, peg$maxFailPos) + ); + } + } + return { + SyntaxError: peg$SyntaxError, + parse: peg$parse + }; +})(); +// Generated by Peggy 2.0.1. +// +// https://peggyjs.org/ +(function() { + function peg$subclass(child, parent) { + function C() { + this.constructor = child; + } + C.prototype = parent.prototype; + child.prototype = new C(); + } + function peg$SyntaxError(message, expected, found, location) { + var self = Error.call(this, message); + if (Object.setPrototypeOf) { + Object.setPrototypeOf(self, peg$SyntaxError.prototype); + } + self.expected = expected; + self.found = found; + self.location = location; + self.name = "SyntaxError"; + return self; + } + peg$subclass(peg$SyntaxError, Error); + function peg$padEnd(str, targetLength, padString) { + padString = padString || " "; + if (str.length > targetLength) { + return str; + } + targetLength -= str.length; + padString += padString.repeat(targetLength); + return str + padString.slice(0, targetLength); + } + peg$SyntaxError.prototype.format = function(sources) { + var str = "Error: " + this.message; + if (this.location) { + var src = null; + var k; + for (k = 0; k < sources.length; k++) { + if (sources[k].source === this.location.source) { + src = sources[k].text.split(/\r\n|\n|\r/g); + break; + } + } + var s2 = this.location.start; + var loc = this.location.source + ":" + s2.line + ":" + s2.column; + if (src) { + var e = this.location.end; + var filler = peg$padEnd("", s2.line.toString().length, " "); + var line3 = src[s2.line - 1]; + var last = s2.line === e.line ? e.column : line3.length + 1; + var hatLen = last - s2.column || 1; + str += "\n --> " + loc + "\n" + filler + " |\n" + s2.line + " | " + line3 + "\n" + filler + " | " + peg$padEnd("", s2.column - 1, " ") + peg$padEnd("", hatLen, "^"); + } else { + str += "\n at " + loc; + } + } + return str; + }; + peg$SyntaxError.buildMessage = function(expected, found) { + var DESCRIBE_EXPECTATION_FNS = { + literal: function(expectation) { + return '"' + literalEscape(expectation.text) + '"'; + }, + class: function(expectation) { + var escapedParts = expectation.parts.map(function(part) { + return Array.isArray(part) ? classEscape(part[0]) + "-" + classEscape(part[1]) : classEscape(part); + }); + return "[" + (expectation.inverted ? "^" : "") + escapedParts.join("") + "]"; + }, + any: function() { + return "any character"; + }, + end: function() { + return "end of input"; + }, + other: function(expectation) { + return expectation.description; + } + }; + function hex(ch) { + return ch.charCodeAt(0).toString(16).toUpperCase(); + } + function literalEscape(s2) { + return s2.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\0/g, "\\0").replace(/\t/g, "\\t").replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/[\x00-\x0F]/g, function(ch) { + return "\\x0" + hex(ch); + }).replace(/[\x10-\x1F\x7F-\x9F]/g, function(ch) { + return "\\x" + hex(ch); + }); + } + function classEscape(s2) { + return s2.replace(/\\/g, "\\\\").replace(/\]/g, "\\]").replace(/\^/g, "\\^").replace(/-/g, "\\-").replace(/\0/g, "\\0").replace(/\t/g, "\\t").replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/[\x00-\x0F]/g, function(ch) { + return "\\x0" + hex(ch); + }).replace(/[\x10-\x1F\x7F-\x9F]/g, function(ch) { + return "\\x" + hex(ch); + }); + } + function describeExpectation(expectation) { + return DESCRIBE_EXPECTATION_FNS[expectation.type](expectation); + } + function describeExpected(expected2) { + var descriptions = expected2.map(describeExpectation); + var i, j; + descriptions.sort(); + if (descriptions.length > 0) { + for (i = 1, j = 1; i < descriptions.length; i++) { + if (descriptions[i - 1] !== descriptions[i]) { + descriptions[j] = descriptions[i]; + j++; + } + } + descriptions.length = j; + } + switch (descriptions.length) { + case 1: + return descriptions[0]; + case 2: + return descriptions[0] + " or " + descriptions[1]; + default: + return descriptions.slice(0, -1).join(", ") + ", or " + descriptions[descriptions.length - 1]; + } + } + function describeFound(found2) { + return found2 ? '"' + literalEscape(found2) + '"' : "end of input"; + } + return "Expected " + describeExpected(expected) + " but " + describeFound(found) + " found."; + }; + function peg$parse(input, options2) { + options2 = options2 !== void 0 ? options2 : {}; + var peg$FAILED = {}; + var peg$source = options2.grammarSource; + var peg$startRuleFunctions = { start: peg$parsestart }; + var peg$startRuleFunction = peg$parsestart; + var peg$c0 = ";"; + var peg$c1 = ","; + var peg$c2 = ":"; + var peg$c3 = "/"; + var peg$c4 = ">"; + var peg$c5 = "!"; + var peg$c6 = "."; + var peg$c7 = "!!["; + var peg$c8 = "]"; + var peg$c9 = "!!"; + var peg$c10 = "+"; + var peg$c11 = "-"; + var peg$r0 = /^[a-zA-Z0-9]/; + var peg$r1 = /^[0-9]/; + var peg$r2 = /^[ \t\n\r]/; + var peg$r3 = /^[0-9a-fA-F]/; + var peg$e0 = peg$anyExpectation(); + var peg$e1 = peg$literalExpectation(";", false); + var peg$e2 = peg$literalExpectation(",", false); + var peg$e3 = peg$otherExpectation("model list"); + var peg$e4 = peg$literalExpectation(":", false); + var peg$e5 = peg$literalExpectation("/", false); + var peg$e6 = peg$otherExpectation("model"); + var peg$e7 = peg$otherExpectation("color spec list"); + var peg$e8 = peg$otherExpectation("color spec"); + var peg$e9 = peg$otherExpectation("color"); + var peg$e10 = peg$otherExpectation("function expression"); + var peg$e11 = peg$literalExpectation(">", false); + var peg$e12 = peg$otherExpectation("function"); + var peg$e13 = peg$otherExpectation("extended expression"); + var peg$e14 = peg$otherExpectation("core model"); + var peg$e15 = peg$otherExpectation("expr"); + var peg$e16 = peg$literalExpectation("!", false); + var peg$e17 = peg$otherExpectation("mix expr"); + var peg$e18 = peg$otherExpectation("name"); + var peg$e19 = peg$literalExpectation(".", false); + var peg$e20 = peg$classExpectation([["a", "z"], ["A", "Z"], ["0", "9"]], false, false); + var peg$e21 = peg$otherExpectation("postfix"); + var peg$e22 = peg$literalExpectation("!![", false); + var peg$e23 = peg$literalExpectation("]", false); + var peg$e24 = peg$literalExpectation("!!", false); + var peg$e25 = peg$otherExpectation("prefix"); + var peg$e26 = peg$otherExpectation("plus"); + var peg$e27 = peg$literalExpectation("+", false); + var peg$e28 = peg$otherExpectation("minus"); + var peg$e29 = peg$literalExpectation("-", false); + var peg$e30 = peg$otherExpectation("num"); + var peg$e31 = peg$classExpectation([["0", "9"]], false, false); + var peg$e32 = peg$otherExpectation("positive float"); + var peg$e33 = peg$otherExpectation("divisor"); + var peg$e34 = peg$otherExpectation("int"); + var peg$e36 = peg$classExpectation([" ", " ", "\n", "\r"], false, false); + var peg$e37 = peg$classExpectation([["0", "9"], ["a", "f"], ["A", "F"]], false, false); + var peg$f0 = function(m) { + return m; + }; + var peg$f1 = function(m) { + return m; + }; + var peg$f2 = function(m) { + return m; + }; + var peg$f3 = function(m) { + return m; + }; + var peg$f4 = function(m) { + return m; + }; + var peg$f5 = function(a) { + return { type: "invalid_spec", content: a }; + }; + var peg$f6 = function(f, c) { + return c; + }; + var peg$f7 = function(f, r) { + return { type: "color_set", content: [f].concat(r) }; + }; + var peg$f8 = function(n, s2) { + return { type: "color_set_item", name: n, spec_list: s2 }; + }; + var peg$f9 = function(c, m) { + return { type: "model_list", contents: m, core_model: c }; + }; + var peg$f10 = function(m) { + return { type: "model_list", contents: m, core_model: null }; + }; + var peg$f11 = function(m, a) { + return a; + }; + var peg$f12 = function(m, r) { + return [m].concat(r); + }; + var peg$f13 = function(s2, a) { + return a; + }; + var peg$f14 = function(s2, r) { + return { type: "spec_list", content: [s2].concat(r) }; + }; + var peg$f15 = function(c) { + return { type: "hex_spec", content: [c] }; + }; + var peg$f16 = function(c, d) { + return d; + }; + var peg$f17 = function(c, d) { + return d; + }; + var peg$f18 = function(c, r) { + return { type: "num_spec", content: r ? [c].concat(r) : [c] }; + }; + var peg$f19 = function(c, fs) { + return { type: "color", color: c, functions: fs }; + }; + var peg$f20 = function(f, n) { + return n; + }; + var peg$f21 = function(f, args) { + return { type: "function", name: f, args }; + }; + var peg$f22 = function(core, d, e, es) { + return { + type: "extended_expr", + core_model: core, + div: d, + expressions: [e].concat(es) + }; + }; + var peg$f23 = function(core, e, es) { + return { + type: "extended_expr", + core_model: core, + div: null, + expressions: [e].concat(es) + }; + }; + var peg$f24 = function(e, d) { + return { type: "weighted_expr", color: e, weight: d }; + }; + var peg$f25 = function(e) { + return e; + }; + var peg$f26 = function(p, n, e, po) { + return { + type: "expr", + prefix: p, + name: n, + mix_expr: e, + postfix: po + }; + }; + var peg$f27 = function(p, n) { + return { type: "complete_mix", mix_percent: p, name: n }; + }; + var peg$f28 = function(p) { + return { type: "partial_mix", mix_percent: p }; + }; + var peg$f29 = function(c, p) { + return c.concat(p || []); + }; + var peg$f30 = function(n) { + return { type: "postfix", num: n }; + }; + var peg$f31 = function(p) { + return { type: "postfix", plusses: p }; + }; + var peg$f32 = function(n) { + return parseInt(n, 10); + }; + var peg$f33 = function(n) { + return parseFloat(n); + }; + var peg$f34 = function(n) { + return n; + }; + var peg$f35 = function(n) { + return -n; + }; + var peg$f36 = function(m, n) { + return m ? -n : n; + }; + var peg$f37 = function(h) { + return h.toUpperCase(); + }; + var peg$currPos = 0; + var peg$posDetailsCache = [{ line: 1, column: 1 }]; + var peg$maxFailPos = 0; + var peg$maxFailExpected = []; + var peg$silentFails = 0; + var peg$result; + if ("startRule" in options2) { + if (!(options2.startRule in peg$startRuleFunctions)) { + throw new Error(`Can't start parsing from rule "` + options2.startRule + '".'); + } + peg$startRuleFunction = peg$startRuleFunctions[options2.startRule]; + } + function peg$literalExpectation(text2, ignoreCase) { + return { type: "literal", text: text2, ignoreCase }; + } + function peg$classExpectation(parts, inverted, ignoreCase) { + return { type: "class", parts, inverted, ignoreCase }; + } + function peg$anyExpectation() { + return { type: "any" }; + } + function peg$endExpectation() { + return { type: "end" }; + } + function peg$otherExpectation(description) { + return { type: "other", description }; + } + function peg$computePosDetails(pos) { + var details = peg$posDetailsCache[pos]; + var p; + if (details) { + return details; + } else { + p = pos - 1; + while (!peg$posDetailsCache[p]) { + p--; + } + details = peg$posDetailsCache[p]; + details = { + line: details.line, + column: details.column + }; + while (p < pos) { + if (input.charCodeAt(p) === 10) { + details.line++; + details.column = 1; + } else { + details.column++; + } + p++; + } + peg$posDetailsCache[pos] = details; + return details; + } + } + function peg$computeLocation(startPos, endPos) { + var startPosDetails = peg$computePosDetails(startPos); + var endPosDetails = peg$computePosDetails(endPos); + return { + source: peg$source, + start: { + offset: startPos, + line: startPosDetails.line, + column: startPosDetails.column + }, + end: { + offset: endPos, + line: endPosDetails.line, + column: endPosDetails.column + } + }; + } + function peg$fail(expected2) { + if (peg$currPos < peg$maxFailPos) { + return; + } + if (peg$currPos > peg$maxFailPos) { + peg$maxFailPos = peg$currPos; + peg$maxFailExpected = []; + } + peg$maxFailExpected.push(expected2); + } + function peg$buildStructuredError(expected2, found, location2) { + return new peg$SyntaxError( + peg$SyntaxError.buildMessage(expected2, found), + expected2, + found, + location2 + ); + } + function peg$parsestart() { + var s0, s1, s2, s3; + s0 = peg$currPos; + s1 = peg$parsespec(); + if (s1 !== peg$FAILED) { + s2 = peg$parseEOL(); + if (s2 !== peg$FAILED) { + s0 = peg$f0(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$parsespec_list(); + if (s1 !== peg$FAILED) { + s2 = peg$parseEOL(); + if (s2 !== peg$FAILED) { + s0 = peg$f1(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$parsecolor(); + if (s1 !== peg$FAILED) { + s2 = peg$parseEOL(); + if (s2 !== peg$FAILED) { + s0 = peg$f2(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$parsemodel_list(); + if (s1 !== peg$FAILED) { + s2 = peg$parseEOL(); + if (s2 !== peg$FAILED) { + s0 = peg$f3(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$parsecolor_set_spec(); + if (s1 !== peg$FAILED) { + s2 = peg$parseEOL(); + if (s2 !== peg$FAILED) { + s0 = peg$f4(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$currPos; + s2 = []; + if (input.length > peg$currPos) { + s3 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s3 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + while (s3 !== peg$FAILED) { + s2.push(s3); + if (input.length > peg$currPos) { + s3 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s3 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + } + s1 = input.substring(s1, peg$currPos); + s1 = peg$f5(s1); + s0 = s1; + } + } + } + } + } + return s0; + } + function peg$parsecolor_set_spec() { + var s0, s1, s2, s3, s4, s5; + s0 = peg$currPos; + s1 = peg$parsecolor_set_item(); + if (s1 !== peg$FAILED) { + s2 = []; + s3 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 59) { + s4 = peg$c0; + peg$currPos++; + } else { + s4 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e1); + } + } + if (s4 !== peg$FAILED) { + s5 = peg$parsecolor_set_item(); + if (s5 !== peg$FAILED) { + s3 = peg$f6(s1, s5); + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 59) { + s4 = peg$c0; + peg$currPos++; + } else { + s4 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e1); + } + } + if (s4 !== peg$FAILED) { + s5 = peg$parsecolor_set_item(); + if (s5 !== peg$FAILED) { + s3 = peg$f6(s1, s5); + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } + s0 = peg$f7(s1, s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsecolor_set_item() { + var s0, s1, s2, s3; + s0 = peg$currPos; + s1 = peg$parsename(); + if (s1 !== peg$FAILED) { + if (input.charCodeAt(peg$currPos) === 44) { + s2 = peg$c1; + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e2); + } + } + if (s2 !== peg$FAILED) { + s3 = peg$parsespec_list(); + if (s3 !== peg$FAILED) { + s0 = peg$f8(s1, s3); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsemodel_list() { + var s0, s1, s2, s3; + peg$silentFails++; + s0 = peg$currPos; + s1 = peg$parsecore_model(); + if (s1 !== peg$FAILED) { + if (input.charCodeAt(peg$currPos) === 58) { + s2 = peg$c2; + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e4); + } + } + if (s2 !== peg$FAILED) { + s3 = peg$parsemodel_list_tail(); + if (s3 !== peg$FAILED) { + s0 = peg$f9(s1, s3); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$parsemodel_list_tail(); + if (s1 !== peg$FAILED) { + s1 = peg$f10(s1); + } + s0 = s1; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + return s0; + } + function peg$parsemodel_list_tail() { + var s0, s1, s2, s3, s4, s5; + s0 = peg$currPos; + s1 = peg$parsemodel(); + if (s1 !== peg$FAILED) { + s2 = []; + s3 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 47) { + s4 = peg$c3; + peg$currPos++; + } else { + s4 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e5); + } + } + if (s4 !== peg$FAILED) { + s5 = peg$parsemodel(); + if (s5 !== peg$FAILED) { + s3 = peg$f11(s1, s5); + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 47) { + s4 = peg$c3; + peg$currPos++; + } else { + s4 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e5); + } + } + if (s4 !== peg$FAILED) { + s5 = peg$parsemodel(); + if (s5 !== peg$FAILED) { + s3 = peg$f11(s1, s5); + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } + s0 = peg$f12(s1, s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsemodel() { + var s0; + peg$silentFails++; + s0 = peg$parsecore_model(); + peg$silentFails--; + if (s0 === peg$FAILED) { + if (peg$silentFails === 0) { + peg$fail(peg$e6); + } + } + return s0; + } + function peg$parsespec_list() { + var s0, s1, s2, s3, s4, s5; + peg$silentFails++; + s0 = peg$currPos; + s1 = peg$parsespec(); + if (s1 !== peg$FAILED) { + s2 = []; + s3 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 47) { + s4 = peg$c3; + peg$currPos++; + } else { + s4 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e5); + } + } + if (s4 !== peg$FAILED) { + s5 = peg$parsespec(); + if (s5 !== peg$FAILED) { + s3 = peg$f13(s1, s5); + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 47) { + s4 = peg$c3; + peg$currPos++; + } else { + s4 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e5); + } + } + if (s4 !== peg$FAILED) { + s5 = peg$parsespec(); + if (s5 !== peg$FAILED) { + s3 = peg$f13(s1, s5); + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } + s0 = peg$f14(s1, s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e7); + } + } + return s0; + } + function peg$parsespec() { + var s0, s1, s2, s3, s4, s5, s6, s7, s8; + peg$silentFails++; + s0 = peg$currPos; + s1 = peg$currPos; + s2 = peg$currPos; + s3 = peg$parsehex(); + if (s3 !== peg$FAILED) { + s4 = peg$parsehex(); + if (s4 !== peg$FAILED) { + s5 = peg$parsehex(); + if (s5 !== peg$FAILED) { + s6 = peg$parsehex(); + if (s6 !== peg$FAILED) { + s7 = peg$parsehex(); + if (s7 !== peg$FAILED) { + s8 = peg$parsehex(); + if (s8 !== peg$FAILED) { + s3 = [s3, s4, s5, s6, s7, s8]; + s2 = s3; + } else { + peg$currPos = s2; + s2 = peg$FAILED; + } + } else { + peg$currPos = s2; + s2 = peg$FAILED; + } + } else { + peg$currPos = s2; + s2 = peg$FAILED; + } + } else { + peg$currPos = s2; + s2 = peg$FAILED; + } + } else { + peg$currPos = s2; + s2 = peg$FAILED; + } + } else { + peg$currPos = s2; + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s1 = input.substring(s1, peg$currPos); + } else { + s1 = s2; + } + if (s1 !== peg$FAILED) { + s1 = peg$f15(s1); + } + s0 = s1; + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$parsedec(); + if (s1 !== peg$FAILED) { + s2 = []; + s3 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 44) { + s4 = peg$c1; + peg$currPos++; + } else { + s4 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e2); + } + } + if (s4 !== peg$FAILED) { + s5 = peg$parsedec(); + if (s5 !== peg$FAILED) { + s3 = peg$f16(s1, s5); + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + if (s3 !== peg$FAILED) { + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 44) { + s4 = peg$c1; + peg$currPos++; + } else { + s4 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e2); + } + } + if (s4 !== peg$FAILED) { + s5 = peg$parsedec(); + if (s5 !== peg$FAILED) { + s3 = peg$f16(s1, s5); + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } + } else { + s2 = peg$FAILED; + } + if (s2 === peg$FAILED) { + s2 = []; + s3 = peg$currPos; + s4 = peg$parsesp(); + if (s4 !== peg$FAILED) { + s5 = peg$parsedec(); + if (s5 !== peg$FAILED) { + s3 = peg$f17(s1, s5); + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + if (s3 !== peg$FAILED) { + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$currPos; + s4 = peg$parsesp(); + if (s4 !== peg$FAILED) { + s5 = peg$parsedec(); + if (s5 !== peg$FAILED) { + s3 = peg$f17(s1, s5); + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } + } else { + s2 = peg$FAILED; + } + } + if (s2 === peg$FAILED) { + s2 = null; + } + s0 = peg$f18(s1, s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e8); + } + } + return s0; + } + function peg$parsecolor() { + var s0, s1, s2, s3; + peg$silentFails++; + s0 = peg$currPos; + s1 = peg$parsecolor_expr(); + if (s1 !== peg$FAILED) { + s2 = []; + s3 = peg$parsefunc_expr(); + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$parsefunc_expr(); + } + s0 = peg$f19(s1, s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e9); + } + } + return s0; + } + function peg$parsecolor_expr() { + var s0; + s0 = peg$parseext_expr(); + if (s0 === peg$FAILED) { + s0 = peg$parseexpr(); + if (s0 === peg$FAILED) { + s0 = peg$parsename(); + } + } + return s0; + } + function peg$parsefunc_expr() { + var s0, s1, s2, s3, s4, s5, s6; + peg$silentFails++; + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 62) { + s1 = peg$c4; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e11); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$parsefunction(); + if (s2 !== peg$FAILED) { + s3 = []; + s4 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 44) { + s5 = peg$c1; + peg$currPos++; + } else { + s5 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e2); + } + } + if (s5 !== peg$FAILED) { + s6 = peg$parseint(); + if (s6 !== peg$FAILED) { + s4 = peg$f20(s2, s6); + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + while (s4 !== peg$FAILED) { + s3.push(s4); + s4 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 44) { + s5 = peg$c1; + peg$currPos++; + } else { + s5 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e2); + } + } + if (s5 !== peg$FAILED) { + s6 = peg$parseint(); + if (s6 !== peg$FAILED) { + s4 = peg$f20(s2, s6); + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + } + s0 = peg$f21(s2, s3); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e10); + } + } + return s0; + } + function peg$parsefunction() { + var s0; + peg$silentFails++; + s0 = peg$parsename(); + peg$silentFails--; + if (s0 === peg$FAILED) { + if (peg$silentFails === 0) { + peg$fail(peg$e12); + } + } + return s0; + } + function peg$parseext_expr() { + var s0, s1, s2, s3, s4, s5, s6, s7; + peg$silentFails++; + s0 = peg$currPos; + s1 = peg$parsecore_model(); + if (s1 !== peg$FAILED) { + if (input.charCodeAt(peg$currPos) === 44) { + s2 = peg$c1; + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e2); + } + } + if (s2 !== peg$FAILED) { + s3 = peg$parsediv(); + if (s3 !== peg$FAILED) { + if (input.charCodeAt(peg$currPos) === 58) { + s4 = peg$c2; + peg$currPos++; + } else { + s4 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e4); + } + } + if (s4 !== peg$FAILED) { + s5 = peg$parseweighted_expr(); + if (s5 !== peg$FAILED) { + s6 = []; + s7 = peg$parseadditional_weighted_expr(); + while (s7 !== peg$FAILED) { + s6.push(s7); + s7 = peg$parseadditional_weighted_expr(); + } + s0 = peg$f22(s1, s3, s5, s6); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$parsecore_model(); + if (s1 !== peg$FAILED) { + if (input.charCodeAt(peg$currPos) === 58) { + s2 = peg$c2; + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e4); + } + } + if (s2 !== peg$FAILED) { + s3 = peg$parseweighted_expr(); + if (s3 !== peg$FAILED) { + s4 = []; + s5 = peg$parseadditional_weighted_expr(); + while (s5 !== peg$FAILED) { + s4.push(s5); + s5 = peg$parseadditional_weighted_expr(); + } + s0 = peg$f23(s1, s3, s4); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e13); + } + } + return s0; + } + function peg$parseweighted_expr() { + var s0, s1, s2, s3; + s0 = peg$currPos; + s1 = peg$parseexpr(); + if (s1 !== peg$FAILED) { + if (input.charCodeAt(peg$currPos) === 44) { + s2 = peg$c1; + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e2); + } + } + if (s2 !== peg$FAILED) { + s3 = peg$parsedec(); + if (s3 !== peg$FAILED) { + s0 = peg$f24(s1, s3); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parseadditional_weighted_expr() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 59) { + s1 = peg$c0; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e1); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$parseweighted_expr(); + if (s2 !== peg$FAILED) { + s0 = peg$f25(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsecore_model() { + var s0; + peg$silentFails++; + s0 = peg$parsename(); + peg$silentFails--; + if (s0 === peg$FAILED) { + if (peg$silentFails === 0) { + peg$fail(peg$e14); + } + } + return s0; + } + function peg$parseexpr() { + var s0, s1, s2, s3, s4; + peg$silentFails++; + s0 = peg$currPos; + s1 = peg$parseprefix(); + s2 = peg$parsename(); + if (s2 !== peg$FAILED) { + s3 = peg$parsemix_expr(); + s4 = peg$parsepostfix(); + if (s4 === peg$FAILED) { + s4 = null; + } + s0 = peg$f26(s1, s2, s3, s4); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e15); + } + } + return s0; + } + function peg$parsecomplete_mix() { + var s0, s1, s2, s3, s4; + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 33) { + s1 = peg$c5; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e16); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$parsepct(); + if (s2 !== peg$FAILED) { + if (input.charCodeAt(peg$currPos) === 33) { + s3 = peg$c5; + peg$currPos++; + } else { + s3 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e16); + } + } + if (s3 !== peg$FAILED) { + s4 = peg$parsename(); + if (s4 !== peg$FAILED) { + s0 = peg$f27(s2, s4); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsepartial_mix() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 33) { + s1 = peg$c5; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e16); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$parsepct(); + if (s2 !== peg$FAILED) { + s0 = peg$f28(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsemix_expr() { + var s0, s1, s2; + peg$silentFails++; + s0 = peg$currPos; + s1 = []; + s2 = peg$parsecomplete_mix(); + while (s2 !== peg$FAILED) { + s1.push(s2); + s2 = peg$parsecomplete_mix(); + } + s2 = peg$parsepartial_mix(); + if (s2 === peg$FAILED) { + s2 = null; + } + s0 = peg$f29(s1, s2); + peg$silentFails--; + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e17); + } + return s0; + } + function peg$parsename() { + var s0, s1, s2; + peg$silentFails++; + if (input.charCodeAt(peg$currPos) === 46) { + s0 = peg$c6; + peg$currPos++; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e19); + } + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = []; + if (peg$r0.test(input.charAt(peg$currPos))) { + s2 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e20); + } + } + if (s2 !== peg$FAILED) { + while (s2 !== peg$FAILED) { + s1.push(s2); + if (peg$r0.test(input.charAt(peg$currPos))) { + s2 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e20); + } + } + } + } else { + s1 = peg$FAILED; + } + if (s1 !== peg$FAILED) { + s0 = input.substring(s0, peg$currPos); + } else { + s0 = s1; + } + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e18); + } + } + return s0; + } + function peg$parsepostfix() { + var s0, s1, s2, s3, s4; + peg$silentFails++; + s0 = peg$currPos; + if (input.substr(peg$currPos, 3) === peg$c7) { + s1 = peg$c7; + peg$currPos += 3; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e22); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$parsenum(); + if (s2 !== peg$FAILED) { + if (input.charCodeAt(peg$currPos) === 93) { + s3 = peg$c8; + peg$currPos++; + } else { + s3 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e23); + } + } + if (s3 !== peg$FAILED) { + s0 = peg$f30(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + if (input.substr(peg$currPos, 2) === peg$c9) { + s1 = peg$c9; + peg$currPos += 2; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e24); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$currPos; + s3 = []; + s4 = peg$parseplus(); + if (s4 !== peg$FAILED) { + while (s4 !== peg$FAILED) { + s3.push(s4); + s4 = peg$parseplus(); + } + } else { + s3 = peg$FAILED; + } + if (s3 !== peg$FAILED) { + s2 = input.substring(s2, peg$currPos); + } else { + s2 = s3; + } + if (s2 !== peg$FAILED) { + s0 = peg$f31(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e21); + } + } + return s0; + } + function peg$parseprefix() { + var s0; + peg$silentFails++; + s0 = peg$parseminus(); + if (s0 === peg$FAILED) { + s0 = null; + } + peg$silentFails--; + if (peg$silentFails === 0) { + peg$fail(peg$e25); + } + return s0; + } + function peg$parseplus() { + var s0, s1, s2; + peg$silentFails++; + s0 = peg$currPos; + s1 = []; + if (input.charCodeAt(peg$currPos) === 43) { + s2 = peg$c10; + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e27); + } + } + if (s2 !== peg$FAILED) { + while (s2 !== peg$FAILED) { + s1.push(s2); + if (input.charCodeAt(peg$currPos) === 43) { + s2 = peg$c10; + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e27); + } + } + } + } else { + s1 = peg$FAILED; + } + if (s1 !== peg$FAILED) { + s0 = input.substring(s0, peg$currPos); + } else { + s0 = s1; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e26); + } + } + return s0; + } + function peg$parseminus() { + var s0, s1, s2; + peg$silentFails++; + s0 = peg$currPos; + s1 = []; + if (input.charCodeAt(peg$currPos) === 45) { + s2 = peg$c11; + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e29); + } + } + if (s2 !== peg$FAILED) { + while (s2 !== peg$FAILED) { + s1.push(s2); + if (input.charCodeAt(peg$currPos) === 45) { + s2 = peg$c11; + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e29); + } + } + } + } else { + s1 = peg$FAILED; + } + if (s1 !== peg$FAILED) { + s0 = input.substring(s0, peg$currPos); + } else { + s0 = s1; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e28); + } + } + return s0; + } + function peg$parsenum() { + var s0, s1, s2, s3; + peg$silentFails++; + s0 = peg$currPos; + s1 = peg$currPos; + s2 = []; + if (peg$r1.test(input.charAt(peg$currPos))) { + s3 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s3 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e31); + } + } + if (s3 !== peg$FAILED) { + while (s3 !== peg$FAILED) { + s2.push(s3); + if (peg$r1.test(input.charAt(peg$currPos))) { + s3 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s3 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e31); + } + } + } + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s1 = input.substring(s1, peg$currPos); + } else { + s1 = s2; + } + if (s1 !== peg$FAILED) { + s1 = peg$f32(s1); + } + s0 = s1; + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e30); + } + } + return s0; + } + function peg$parsepct() { + var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9; + peg$silentFails++; + s0 = peg$currPos; + s1 = peg$currPos; + s2 = peg$currPos; + s3 = peg$currPos; + s4 = []; + if (peg$r1.test(input.charAt(peg$currPos))) { + s5 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s5 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e31); + } + } + if (s5 !== peg$FAILED) { + while (s5 !== peg$FAILED) { + s4.push(s5); + if (peg$r1.test(input.charAt(peg$currPos))) { + s5 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s5 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e31); + } + } + } + } else { + s4 = peg$FAILED; + } + if (s4 !== peg$FAILED) { + s3 = input.substring(s3, peg$currPos); + } else { + s3 = s4; + } + if (s3 !== peg$FAILED) { + s4 = peg$currPos; + s5 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 46) { + s6 = peg$c6; + peg$currPos++; + } else { + s6 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e19); + } + } + if (s6 !== peg$FAILED) { + s7 = peg$currPos; + s8 = []; + if (peg$r1.test(input.charAt(peg$currPos))) { + s9 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s9 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e31); + } + } + while (s9 !== peg$FAILED) { + s8.push(s9); + if (peg$r1.test(input.charAt(peg$currPos))) { + s9 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s9 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e31); + } + } + } + s7 = input.substring(s7, peg$currPos); + s6 = [s6, s7]; + s5 = s6; + } else { + peg$currPos = s5; + s5 = peg$FAILED; + } + if (s5 === peg$FAILED) { + s5 = null; + } + s4 = input.substring(s4, peg$currPos); + s3 = [s3, s4]; + s2 = s3; + } else { + peg$currPos = s2; + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s1 = input.substring(s1, peg$currPos); + } else { + s1 = s2; + } + if (s1 === peg$FAILED) { + s1 = peg$currPos; + s2 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 46) { + s3 = peg$c6; + peg$currPos++; + } else { + s3 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e19); + } + } + if (s3 !== peg$FAILED) { + s4 = peg$currPos; + s5 = []; + if (peg$r1.test(input.charAt(peg$currPos))) { + s6 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s6 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e31); + } + } + if (s6 !== peg$FAILED) { + while (s6 !== peg$FAILED) { + s5.push(s6); + if (peg$r1.test(input.charAt(peg$currPos))) { + s6 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s6 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e31); + } + } + } + } else { + s5 = peg$FAILED; + } + if (s5 !== peg$FAILED) { + s4 = input.substring(s4, peg$currPos); + } else { + s4 = s5; + } + if (s4 !== peg$FAILED) { + s3 = [s3, s4]; + s2 = s3; + } else { + peg$currPos = s2; + s2 = peg$FAILED; + } + } else { + peg$currPos = s2; + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s1 = input.substring(s1, peg$currPos); + } else { + s1 = s2; + } + } + if (s1 !== peg$FAILED) { + s1 = peg$f33(s1); + } + s0 = s1; + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e32); + } + } + return s0; + } + function peg$parsediv() { + var s0; + peg$silentFails++; + s0 = peg$parsepct(); + peg$silentFails--; + if (s0 === peg$FAILED) { + if (peg$silentFails === 0) { + peg$fail(peg$e33); + } + } + return s0; + } + function peg$parsedec() { + var s0, s1, s2; + s0 = peg$parsepct(); + if (s0 === peg$FAILED) { + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 43) { + s1 = peg$c10; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e27); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$parsepct(); + if (s2 !== peg$FAILED) { + s0 = peg$f34(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 45) { + s1 = peg$c11; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e29); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$parsepct(); + if (s2 !== peg$FAILED) { + s0 = peg$f35(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } + } + return s0; + } + function peg$parseint() { + var s0, s1, s2; + peg$silentFails++; + s0 = peg$currPos; + s1 = peg$parseminus(); + if (s1 === peg$FAILED) { + s1 = null; + } + s2 = peg$parsenum(); + if (s2 !== peg$FAILED) { + s0 = peg$f36(s1, s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e34); + } + } + return s0; + } + function peg$parsesp() { + var s0, s1; + s0 = []; + if (peg$r2.test(input.charAt(peg$currPos))) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e36); + } + } + if (s1 !== peg$FAILED) { + while (s1 !== peg$FAILED) { + s0.push(s1); + if (peg$r2.test(input.charAt(peg$currPos))) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e36); + } + } + } + } else { + s0 = peg$FAILED; + } + return s0; + } + function peg$parsehex() { + var s0, s1; + s0 = peg$currPos; + if (peg$r3.test(input.charAt(peg$currPos))) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e37); + } + } + if (s1 !== peg$FAILED) { + s1 = peg$f37(s1); + } + s0 = s1; + return s0; + } + function peg$parseEOL() { + var s0, s1; + s0 = peg$currPos; + peg$silentFails++; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + peg$silentFails--; + if (s1 === peg$FAILED) { + s0 = void 0; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + peg$result = peg$startRuleFunction(); + if (peg$result !== peg$FAILED && peg$currPos === input.length) { + return peg$result; + } else { + if (peg$result !== peg$FAILED && peg$currPos < input.length) { + peg$fail(peg$endExpectation()); + } + throw peg$buildStructuredError( + peg$maxFailExpected, + peg$maxFailPos < input.length ? input.charAt(peg$maxFailPos) : null, + peg$maxFailPos < input.length ? peg$computeLocation(peg$maxFailPos, peg$maxFailPos + 1) : peg$computeLocation(peg$maxFailPos, peg$maxFailPos) + ); + } + } + return { + SyntaxError: peg$SyntaxError, + parse: peg$parse + }; +})(); +// Generated by Peggy 2.0.1. +// +// https://peggyjs.org/ +(function() { + function peg$subclass(child, parent) { + function C() { + this.constructor = child; + } + C.prototype = parent.prototype; + child.prototype = new C(); + } + function peg$SyntaxError(message, expected, found, location) { + var self = Error.call(this, message); + if (Object.setPrototypeOf) { + Object.setPrototypeOf(self, peg$SyntaxError.prototype); + } + self.expected = expected; + self.found = found; + self.location = location; + self.name = "SyntaxError"; + return self; + } + peg$subclass(peg$SyntaxError, Error); + function peg$padEnd(str, targetLength, padString) { + padString = padString || " "; + if (str.length > targetLength) { + return str; + } + targetLength -= str.length; + padString += padString.repeat(targetLength); + return str + padString.slice(0, targetLength); + } + peg$SyntaxError.prototype.format = function(sources) { + var str = "Error: " + this.message; + if (this.location) { + var src = null; + var k; + for (k = 0; k < sources.length; k++) { + if (sources[k].source === this.location.source) { + src = sources[k].text.split(/\r\n|\n|\r/g); + break; + } + } + var s2 = this.location.start; + var loc = this.location.source + ":" + s2.line + ":" + s2.column; + if (src) { + var e = this.location.end; + var filler = peg$padEnd("", s2.line.toString().length, " "); + var line3 = src[s2.line - 1]; + var last = s2.line === e.line ? e.column : line3.length + 1; + var hatLen = last - s2.column || 1; + str += "\n --> " + loc + "\n" + filler + " |\n" + s2.line + " | " + line3 + "\n" + filler + " | " + peg$padEnd("", s2.column - 1, " ") + peg$padEnd("", hatLen, "^"); + } else { + str += "\n at " + loc; + } + } + return str; + }; + peg$SyntaxError.buildMessage = function(expected, found) { + var DESCRIBE_EXPECTATION_FNS = { + literal: function(expectation) { + return '"' + literalEscape(expectation.text) + '"'; + }, + class: function(expectation) { + var escapedParts = expectation.parts.map(function(part) { + return Array.isArray(part) ? classEscape(part[0]) + "-" + classEscape(part[1]) : classEscape(part); + }); + return "[" + (expectation.inverted ? "^" : "") + escapedParts.join("") + "]"; + }, + any: function() { + return "any character"; + }, + end: function() { + return "end of input"; + }, + other: function(expectation) { + return expectation.description; + } + }; + function hex(ch) { + return ch.charCodeAt(0).toString(16).toUpperCase(); + } + function literalEscape(s2) { + return s2.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\0/g, "\\0").replace(/\t/g, "\\t").replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/[\x00-\x0F]/g, function(ch) { + return "\\x0" + hex(ch); + }).replace(/[\x10-\x1F\x7F-\x9F]/g, function(ch) { + return "\\x" + hex(ch); + }); + } + function classEscape(s2) { + return s2.replace(/\\/g, "\\\\").replace(/\]/g, "\\]").replace(/\^/g, "\\^").replace(/-/g, "\\-").replace(/\0/g, "\\0").replace(/\t/g, "\\t").replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/[\x00-\x0F]/g, function(ch) { + return "\\x0" + hex(ch); + }).replace(/[\x10-\x1F\x7F-\x9F]/g, function(ch) { + return "\\x" + hex(ch); + }); + } + function describeExpectation(expectation) { + return DESCRIBE_EXPECTATION_FNS[expectation.type](expectation); + } + function describeExpected(expected2) { + var descriptions = expected2.map(describeExpectation); + var i, j; + descriptions.sort(); + if (descriptions.length > 0) { + for (i = 1, j = 1; i < descriptions.length; i++) { + if (descriptions[i - 1] !== descriptions[i]) { + descriptions[j] = descriptions[i]; + j++; + } + } + descriptions.length = j; + } + switch (descriptions.length) { + case 1: + return descriptions[0]; + case 2: + return descriptions[0] + " or " + descriptions[1]; + default: + return descriptions.slice(0, -1).join(", ") + ", or " + descriptions[descriptions.length - 1]; + } + } + function describeFound(found2) { + return found2 ? '"' + literalEscape(found2) + '"' : "end of input"; + } + return "Expected " + describeExpected(expected) + " but " + describeFound(found) + " found."; + }; + function peg$parse(input, options2) { + options2 = options2 !== void 0 ? options2 : {}; + var peg$FAILED = {}; + var peg$source = options2.grammarSource; + var peg$startRuleFunctions = { body: peg$parsebody }; + var peg$startRuleFunction = peg$parsebody; + var peg$e0 = peg$otherExpectation("decl_start"); + var peg$e1 = peg$otherExpectation("decl_end"); + var peg$e2 = peg$otherExpectation("vert"); + var peg$e3 = peg$anyExpectation(); + var peg$e4 = peg$otherExpectation("l"); + var peg$e5 = peg$otherExpectation("r"); + var peg$e6 = peg$otherExpectation("c"); + var peg$e7 = peg$otherExpectation("p"); + var peg$e8 = peg$otherExpectation("m"); + var peg$e9 = peg$otherExpectation("b"); + var peg$e10 = peg$otherExpectation("w"); + var peg$e11 = peg$otherExpectation("W"); + var peg$e12 = peg$otherExpectation("X"); + var peg$e13 = peg$otherExpectation("!"); + var peg$e14 = peg$otherExpectation("@"); + var peg$e15 = peg$otherExpectation("<"); + var peg$e16 = peg$otherExpectation(">"); + var peg$e17 = peg$otherExpectation("group"); + var peg$e18 = peg$otherExpectation("whitespace"); + var peg$f0 = function(c) { + return c; + }; + var peg$f1 = function(cols) { + return cols; + }; + var peg$f2 = function() { + return []; + }; + var peg$f3 = function(divs1, start, a, end, divs2) { + return { + type: "column", + pre_dividers: divs1, + post_dividers: divs2, + before_start_code: start, + before_end_code: end, + alignment: a + }; + }; + var peg$f4 = function() { + return { + type: "vert_divider" + }; + }; + var peg$f5 = function(b, g) { + return { + type: "bang_divider", + content: g[0].content + }; + }; + var peg$f6 = function(g) { + return { + type: "at_divider", + content: g[0].content + }; + }; + var peg$f7 = function(div) { + return div; + }; + var peg$f8 = function(g) { + return { type: "decl_code", code: g[0].content }; + }; + var peg$f9 = function(g) { + return { type: "decl_code", code: g[0].content }; + }; + var peg$f10 = function() { + return { type: "alignment", alignment: "left" }; + }; + var peg$f11 = function() { + return { type: "alignment", alignment: "center" }; + }; + var peg$f12 = function() { + return { type: "alignment", alignment: "right" }; + }; + var peg$f13 = function() { + return { type: "alignment", alignment: "X" }; + }; + var peg$f14 = function() { + return "top"; + }; + var peg$f15 = function() { + return "default"; + }; + var peg$f16 = function() { + return "bottom"; + }; + var peg$f17 = function(a, g) { + return { + type: "alignment", + alignment: "parbox", + baseline: a, + size: g[0].content + }; + }; + var peg$f18 = function(g1, g2) { + return { + type: "alignment", + alignment: "parbox", + baseline: g1[0].content, + size: g2[0].content + }; + }; + var peg$f19 = function(tok) { + return options2.matchChar(tok, "|"); + }; + var peg$f20 = function(tok) { + return options2.matchChar(tok, "l"); + }; + var peg$f21 = function(tok) { + return options2.matchChar(tok, "r"); + }; + var peg$f22 = function(tok) { + return options2.matchChar(tok, "c"); + }; + var peg$f23 = function(tok) { + return options2.matchChar(tok, "p"); + }; + var peg$f24 = function(tok) { + return options2.matchChar(tok, "m"); + }; + var peg$f25 = function(tok) { + return options2.matchChar(tok, "b"); + }; + var peg$f26 = function(tok) { + return options2.matchChar(tok, "w"); + }; + var peg$f27 = function(tok) { + return options2.matchChar(tok, "W"); + }; + var peg$f28 = function(tok) { + return options2.matchChar(tok, "X"); + }; + var peg$f29 = function(tok) { + return options2.matchChar(tok, "!"); + }; + var peg$f30 = function(tok) { + return options2.matchChar(tok, "@"); + }; + var peg$f31 = function(tok) { + return options2.matchChar(tok, "<"); + }; + var peg$f32 = function(tok) { + return options2.matchChar(tok, ">"); + }; + var peg$f33 = function(tok) { + return options2.isGroup(tok); + }; + var peg$f34 = function(tok) { + return options2.isWhitespace(tok); + }; + var peg$currPos = 0; + var peg$posDetailsCache = [{ line: 1, column: 1 }]; + var peg$maxFailPos = 0; + var peg$maxFailExpected = []; + var peg$silentFails = 0; + var peg$result; + if ("startRule" in options2) { + if (!(options2.startRule in peg$startRuleFunctions)) { + throw new Error(`Can't start parsing from rule "` + options2.startRule + '".'); + } + peg$startRuleFunction = peg$startRuleFunctions[options2.startRule]; + } + function peg$anyExpectation() { + return { type: "any" }; + } + function peg$endExpectation() { + return { type: "end" }; + } + function peg$otherExpectation(description) { + return { type: "other", description }; + } + function peg$computePosDetails(pos) { + var details = peg$posDetailsCache[pos]; + var p; + if (details) { + return details; + } else { + p = pos - 1; + while (!peg$posDetailsCache[p]) { + p--; + } + details = peg$posDetailsCache[p]; + details = { + line: details.line, + column: details.column + }; + while (p < pos) { + if (input.charCodeAt(p) === 10) { + details.line++; + details.column = 1; + } else { + details.column++; + } + p++; + } + peg$posDetailsCache[pos] = details; + return details; + } + } + function peg$computeLocation(startPos, endPos) { + var startPosDetails = peg$computePosDetails(startPos); + var endPosDetails = peg$computePosDetails(endPos); + return { + source: peg$source, + start: { + offset: startPos, + line: startPosDetails.line, + column: startPosDetails.column + }, + end: { + offset: endPos, + line: endPosDetails.line, + column: endPosDetails.column + } + }; + } + function peg$fail(expected2) { + if (peg$currPos < peg$maxFailPos) { + return; + } + if (peg$currPos > peg$maxFailPos) { + peg$maxFailPos = peg$currPos; + peg$maxFailExpected = []; + } + peg$maxFailExpected.push(expected2); + } + function peg$buildStructuredError(expected2, found, location2) { + return new peg$SyntaxError( + peg$SyntaxError.buildMessage(expected2, found), + expected2, + found, + location2 + ); + } + function peg$parsebody() { + var s0, s1, s2, s3, s4, s5; + s0 = peg$currPos; + s1 = []; + s2 = peg$currPos; + s3 = peg$parsecolumn(); + if (s3 !== peg$FAILED) { + s4 = []; + s5 = peg$parse_(); + while (s5 !== peg$FAILED) { + s4.push(s5); + s5 = peg$parse_(); + } + s2 = peg$f0(s3); + } else { + peg$currPos = s2; + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + while (s2 !== peg$FAILED) { + s1.push(s2); + s2 = peg$currPos; + s3 = peg$parsecolumn(); + if (s3 !== peg$FAILED) { + s4 = []; + s5 = peg$parse_(); + while (s5 !== peg$FAILED) { + s4.push(s5); + s5 = peg$parse_(); + } + s2 = peg$f0(s3); + } else { + peg$currPos = s2; + s2 = peg$FAILED; + } + } + } else { + s1 = peg$FAILED; + } + if (s1 !== peg$FAILED) { + s1 = peg$f1(s1); + } + s0 = s1; + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$parseEOL(); + if (s1 !== peg$FAILED) { + s1 = peg$f2(); + } + s0 = s1; + } + return s0; + } + function peg$parsecolumn() { + var s0, s1, s2, s3, s4, s5, s6; + s0 = peg$currPos; + s1 = []; + s2 = peg$parsecolumn_divider(); + while (s2 !== peg$FAILED) { + s1.push(s2); + s2 = peg$parsecolumn_divider(); + } + s2 = peg$parsedecl_start(); + if (s2 === peg$FAILED) { + s2 = null; + } + s3 = peg$parsealignment(); + if (s3 !== peg$FAILED) { + s4 = peg$parsedecl_end(); + if (s4 === peg$FAILED) { + s4 = null; + } + s5 = []; + s6 = peg$parsecolumn_divider(); + while (s6 !== peg$FAILED) { + s5.push(s6); + s6 = peg$parsecolumn_divider(); + } + s0 = peg$f3(s1, s2, s3, s4, s5); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsecolumn_divider() { + var s0, s1, s2, s3, s4; + s0 = peg$currPos; + s1 = []; + s2 = peg$parse_(); + while (s2 !== peg$FAILED) { + s1.push(s2); + s2 = peg$parse_(); + } + s2 = peg$currPos; + s3 = peg$parsevert(); + if (s3 !== peg$FAILED) { + s3 = peg$f4(); + } + s2 = s3; + if (s2 === peg$FAILED) { + s2 = peg$currPos; + s3 = peg$parsebang(); + if (s3 !== peg$FAILED) { + s4 = peg$parsegroup(); + if (s4 !== peg$FAILED) { + s2 = peg$f5(s3, s4); + } else { + peg$currPos = s2; + s2 = peg$FAILED; + } + } else { + peg$currPos = s2; + s2 = peg$FAILED; + } + if (s2 === peg$FAILED) { + s2 = peg$currPos; + s3 = peg$parseat(); + if (s3 !== peg$FAILED) { + s4 = peg$parsegroup(); + if (s4 !== peg$FAILED) { + s2 = peg$f6(s4); + } else { + peg$currPos = s2; + s2 = peg$FAILED; + } + } else { + peg$currPos = s2; + s2 = peg$FAILED; + } + } + } + if (s2 !== peg$FAILED) { + s3 = []; + s4 = peg$parse_(); + while (s4 !== peg$FAILED) { + s3.push(s4); + s4 = peg$parse_(); + } + s0 = peg$f7(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsedecl_start() { + var s0, s1, s2; + peg$silentFails++; + s0 = peg$currPos; + s1 = peg$parsegreater(); + if (s1 !== peg$FAILED) { + s2 = peg$parsegroup(); + if (s2 !== peg$FAILED) { + s0 = peg$f8(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + return s0; + } + function peg$parsedecl_end() { + var s0, s1, s2; + peg$silentFails++; + s0 = peg$currPos; + s1 = peg$parseless(); + if (s1 !== peg$FAILED) { + s2 = peg$parsegroup(); + if (s2 !== peg$FAILED) { + s0 = peg$f9(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e1); + } + } + return s0; + } + function peg$parsealignment() { + var s0, s1, s2, s3, s4, s5; + s0 = peg$currPos; + s1 = peg$parsel(); + if (s1 !== peg$FAILED) { + s1 = peg$f10(); + } + s0 = s1; + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$parsec(); + if (s1 !== peg$FAILED) { + s1 = peg$f11(); + } + s0 = s1; + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$parser(); + if (s1 !== peg$FAILED) { + s1 = peg$f12(); + } + s0 = s1; + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$parseX(); + if (s1 !== peg$FAILED) { + s1 = peg$f13(); + } + s0 = s1; + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$currPos; + s2 = peg$parsep(); + if (s2 !== peg$FAILED) { + s2 = peg$f14(); + } + s1 = s2; + if (s1 === peg$FAILED) { + s1 = peg$currPos; + s2 = peg$parsem(); + if (s2 !== peg$FAILED) { + s2 = peg$f15(); + } + s1 = s2; + if (s1 === peg$FAILED) { + s1 = peg$currPos; + s2 = peg$parseb(); + if (s2 !== peg$FAILED) { + s2 = peg$f16(); + } + s1 = s2; + } + } + if (s1 !== peg$FAILED) { + s2 = []; + s3 = peg$parse_(); + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$parse_(); + } + s3 = peg$parsegroup(); + if (s3 !== peg$FAILED) { + s0 = peg$f17(s1, s3); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$parsew(); + if (s1 === peg$FAILED) { + s1 = peg$parseW(); + } + if (s1 !== peg$FAILED) { + s2 = []; + s3 = peg$parse_(); + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$parse_(); + } + s3 = peg$parsegroup(); + if (s3 !== peg$FAILED) { + s4 = []; + s5 = peg$parse_(); + while (s5 !== peg$FAILED) { + s4.push(s5); + s5 = peg$parse_(); + } + s5 = peg$parsegroup(); + if (s5 !== peg$FAILED) { + s0 = peg$f18(s3, s5); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } + } + } + } + } + return s0; + } + function peg$parsevert() { + var s0, s1, s2; + peg$silentFails++; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f19(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s1 = [s1, s2]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e2); + } + } + return s0; + } + function peg$parsel() { + var s0, s1, s2; + peg$silentFails++; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f20(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s1 = [s1, s2]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e4); + } + } + return s0; + } + function peg$parser() { + var s0, s1, s2; + peg$silentFails++; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f21(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s1 = [s1, s2]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e5); + } + } + return s0; + } + function peg$parsec() { + var s0, s1, s2; + peg$silentFails++; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f22(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s1 = [s1, s2]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e6); + } + } + return s0; + } + function peg$parsep() { + var s0, s1, s2; + peg$silentFails++; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f23(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s1 = [s1, s2]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e7); + } + } + return s0; + } + function peg$parsem() { + var s0, s1, s2; + peg$silentFails++; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f24(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s1 = [s1, s2]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e8); + } + } + return s0; + } + function peg$parseb() { + var s0, s1, s2; + peg$silentFails++; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f25(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s1 = [s1, s2]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e9); + } + } + return s0; + } + function peg$parsew() { + var s0, s1, s2; + peg$silentFails++; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f26(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s1 = [s1, s2]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e10); + } + } + return s0; + } + function peg$parseW() { + var s0, s1, s2; + peg$silentFails++; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f27(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s1 = [s1, s2]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e11); + } + } + return s0; + } + function peg$parseX() { + var s0, s1, s2; + peg$silentFails++; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f28(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s1 = [s1, s2]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e12); + } + } + return s0; + } + function peg$parsebang() { + var s0, s1, s2; + peg$silentFails++; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f29(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s1 = [s1, s2]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e13); + } + } + return s0; + } + function peg$parseat() { + var s0, s1, s2; + peg$silentFails++; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f30(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s1 = [s1, s2]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e14); + } + } + return s0; + } + function peg$parseless() { + var s0, s1, s2; + peg$silentFails++; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f31(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s1 = [s1, s2]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e15); + } + } + return s0; + } + function peg$parsegreater() { + var s0, s1, s2; + peg$silentFails++; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f32(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s1 = [s1, s2]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e16); + } + } + return s0; + } + function peg$parsegroup() { + var s0, s1, s2; + peg$silentFails++; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f33(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s1 = [s1, s2]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e17); + } + } + return s0; + } + function peg$parse_() { + var s0, s1, s2; + peg$silentFails++; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f34(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s1 = [s1, s2]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e18); + } + } + return s0; + } + function peg$parseEOL() { + var s0, s1; + s0 = peg$currPos; + peg$silentFails++; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + peg$silentFails--; + if (s1 === peg$FAILED) { + s0 = void 0; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + if (!options2.isHash) { + try { + Object.assign(options2, { + matchChar: (node, char) => node.type === "string" && node.content === char, + isGroup: (node) => node.type === "group", + isWhitespace: (node) => node.type === "whitespace" + }); + } catch (e) { + console.warn("Error when initializing parser", e); + } + } + peg$result = peg$startRuleFunction(); + if (peg$result !== peg$FAILED && peg$currPos === input.length) { + return peg$result; + } else { + if (peg$result !== peg$FAILED && peg$currPos < input.length) { + peg$fail(peg$endExpectation()); + } + throw peg$buildStructuredError( + peg$maxFailExpected, + peg$maxFailPos < input.length ? input.charAt(peg$maxFailPos) : null, + peg$maxFailPos < input.length ? peg$computeLocation(peg$maxFailPos, peg$maxFailPos + 1) : peg$computeLocation(peg$maxFailPos, peg$maxFailPos) + ); + } + } + return { + SyntaxError: peg$SyntaxError, + parse: peg$parse + }; +})(); +// Generated by Peggy 2.0.1. +// +// https://peggyjs.org/ +(function() { + function peg$subclass(child, parent) { + function C() { + this.constructor = child; + } + C.prototype = parent.prototype; + child.prototype = new C(); + } + function peg$SyntaxError(message, expected, found, location) { + var self = Error.call(this, message); + if (Object.setPrototypeOf) { + Object.setPrototypeOf(self, peg$SyntaxError.prototype); + } + self.expected = expected; + self.found = found; + self.location = location; + self.name = "SyntaxError"; + return self; + } + peg$subclass(peg$SyntaxError, Error); + function peg$padEnd(str, targetLength, padString) { + padString = padString || " "; + if (str.length > targetLength) { + return str; + } + targetLength -= str.length; + padString += padString.repeat(targetLength); + return str + padString.slice(0, targetLength); + } + peg$SyntaxError.prototype.format = function(sources) { + var str = "Error: " + this.message; + if (this.location) { + var src = null; + var k; + for (k = 0; k < sources.length; k++) { + if (sources[k].source === this.location.source) { + src = sources[k].text.split(/\r\n|\n|\r/g); + break; + } + } + var s2 = this.location.start; + var loc = this.location.source + ":" + s2.line + ":" + s2.column; + if (src) { + var e = this.location.end; + var filler = peg$padEnd("", s2.line.toString().length, " "); + var line3 = src[s2.line - 1]; + var last = s2.line === e.line ? e.column : line3.length + 1; + var hatLen = last - s2.column || 1; + str += "\n --> " + loc + "\n" + filler + " |\n" + s2.line + " | " + line3 + "\n" + filler + " | " + peg$padEnd("", s2.column - 1, " ") + peg$padEnd("", hatLen, "^"); + } else { + str += "\n at " + loc; + } + } + return str; + }; + peg$SyntaxError.buildMessage = function(expected, found) { + var DESCRIBE_EXPECTATION_FNS = { + literal: function(expectation) { + return '"' + literalEscape(expectation.text) + '"'; + }, + class: function(expectation) { + var escapedParts = expectation.parts.map(function(part) { + return Array.isArray(part) ? classEscape(part[0]) + "-" + classEscape(part[1]) : classEscape(part); + }); + return "[" + (expectation.inverted ? "^" : "") + escapedParts.join("") + "]"; + }, + any: function() { + return "any character"; + }, + end: function() { + return "end of input"; + }, + other: function(expectation) { + return expectation.description; + } + }; + function hex(ch) { + return ch.charCodeAt(0).toString(16).toUpperCase(); + } + function literalEscape(s2) { + return s2.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\0/g, "\\0").replace(/\t/g, "\\t").replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/[\x00-\x0F]/g, function(ch) { + return "\\x0" + hex(ch); + }).replace(/[\x10-\x1F\x7F-\x9F]/g, function(ch) { + return "\\x" + hex(ch); + }); + } + function classEscape(s2) { + return s2.replace(/\\/g, "\\\\").replace(/\]/g, "\\]").replace(/\^/g, "\\^").replace(/-/g, "\\-").replace(/\0/g, "\\0").replace(/\t/g, "\\t").replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/[\x00-\x0F]/g, function(ch) { + return "\\x0" + hex(ch); + }).replace(/[\x10-\x1F\x7F-\x9F]/g, function(ch) { + return "\\x" + hex(ch); + }); + } + function describeExpectation(expectation) { + return DESCRIBE_EXPECTATION_FNS[expectation.type](expectation); + } + function describeExpected(expected2) { + var descriptions = expected2.map(describeExpectation); + var i, j; + descriptions.sort(); + if (descriptions.length > 0) { + for (i = 1, j = 1; i < descriptions.length; i++) { + if (descriptions[i - 1] !== descriptions[i]) { + descriptions[j] = descriptions[i]; + j++; + } + } + descriptions.length = j; + } + switch (descriptions.length) { + case 1: + return descriptions[0]; + case 2: + return descriptions[0] + " or " + descriptions[1]; + default: + return descriptions.slice(0, -1).join(", ") + ", or " + descriptions[descriptions.length - 1]; + } + } + function describeFound(found2) { + return found2 ? '"' + literalEscape(found2) + '"' : "end of input"; + } + return "Expected " + describeExpected(expected) + " but " + describeFound(found) + " found."; + }; + function peg$parse(input, options2) { + options2 = options2 !== void 0 ? options2 : {}; + var peg$FAILED = {}; + var peg$source = options2.grammarSource; + var peg$startRuleFunctions = { body: peg$parsebody }; + var peg$startRuleFunction = peg$parsebody; + var peg$e1 = peg$otherExpectation("item"); + var peg$e2 = peg$anyExpectation(); + var peg$e3 = peg$otherExpectation("equation"); + var peg$e4 = peg$otherExpectation("trailing comment"); + var peg$e5 = peg$otherExpectation("comment only line"); + var peg$e6 = peg$otherExpectation("non-var token"); + var peg$e7 = peg$otherExpectation("token"); + var peg$e8 = peg$otherExpectation("same line comment"); + var peg$e9 = peg$otherExpectation("own line comment"); + var peg$e10 = peg$otherExpectation(","); + var peg$e11 = peg$otherExpectation("@"); + var peg$e12 = peg$otherExpectation("variable token"); + var peg$e13 = peg$otherExpectation("+/-"); + var peg$e14 = peg$otherExpectation("="); + var peg$f0 = function(a, b) { + return a.concat(b ? b : []); + }; + var peg$f1 = function() { + return []; + }; + var peg$f3 = function(op, a, b, c) { + return { type: "item", op, variable: b, content: a.concat(b, c) }; + }; + var peg$f4 = function(op, a) { + return { type: "item", op, variable: null, content: a }; + }; + var peg$f5 = function(line3, sep, comment) { + return { ...line3, sep: [].concat(sep), trailingComment: comment }; + }; + var peg$f6 = function(line3, comment) { + return { ...line3, trailingComment: comment }; + }; + var peg$f7 = function(eq, ann) { + return { + type: "line", + equation: eq, + annotation: ann, + sep: null + }; + }; + var peg$f8 = function(at2, ann) { + return at2 ? { type: "annotation", marker: at2, content: ann } : null; + }; + var peg$f9 = function(left, eq, right) { + return { type: "equation", left, right, equals: eq }; + }; + var peg$f10 = function(x) { + return x; + }; + var peg$f11 = function(x) { + return { + type: "line", + trailingComment: x + }; + }; + var peg$f12 = function(v, s2) { + return [v].concat(s2 ? s2 : []); + }; + var peg$f13 = function(t) { + return t; + }; + var peg$f14 = function(x) { + return x; + }; + var peg$f15 = function(x) { + return x; + }; + var peg$f16 = function(tok) { + return options2.isSameLineComment(tok); + }; + var peg$f17 = function(tok) { + return tok; + }; + var peg$f18 = function(tok) { + return options2.isOwnLineComment(tok); + }; + var peg$f19 = function(tok) { + return tok; + }; + var peg$f20 = function(tok) { + return options2.isWhitespace(tok); + }; + var peg$f21 = function(tok) { + return tok; + }; + var peg$f22 = function(tok) { + return options2.isSep(tok); + }; + var peg$f23 = function(tok) { + return tok; + }; + var peg$f24 = function(tok) { + return options2.isAt(tok); + }; + var peg$f25 = function(tok) { + return tok; + }; + var peg$f26 = function(tok) { + return options2.isVar(tok); + }; + var peg$f27 = function(tok) { + return tok; + }; + var peg$f28 = function(tok) { + return options2.isOperation(tok); + }; + var peg$f29 = function(tok) { + return tok; + }; + var peg$f30 = function(tok) { + return options2.isEquals(tok); + }; + var peg$f31 = function(tok) { + return tok; + }; + var peg$f32 = function(tok) { + return options2.isSubscript(tok); + }; + var peg$f33 = function(tok) { + return tok; + }; + var peg$currPos = 0; + var peg$posDetailsCache = [{ line: 1, column: 1 }]; + var peg$maxFailPos = 0; + var peg$maxFailExpected = []; + var peg$silentFails = 0; + var peg$result; + if ("startRule" in options2) { + if (!(options2.startRule in peg$startRuleFunctions)) { + throw new Error(`Can't start parsing from rule "` + options2.startRule + '".'); + } + peg$startRuleFunction = peg$startRuleFunctions[options2.startRule]; + } + function peg$anyExpectation() { + return { type: "any" }; + } + function peg$endExpectation() { + return { type: "end" }; + } + function peg$otherExpectation(description) { + return { type: "other", description }; + } + function peg$computePosDetails(pos) { + var details = peg$posDetailsCache[pos]; + var p; + if (details) { + return details; + } else { + p = pos - 1; + while (!peg$posDetailsCache[p]) { + p--; + } + details = peg$posDetailsCache[p]; + details = { + line: details.line, + column: details.column + }; + while (p < pos) { + if (input.charCodeAt(p) === 10) { + details.line++; + details.column = 1; + } else { + details.column++; + } + p++; + } + peg$posDetailsCache[pos] = details; + return details; + } + } + function peg$computeLocation(startPos, endPos) { + var startPosDetails = peg$computePosDetails(startPos); + var endPosDetails = peg$computePosDetails(endPos); + return { + source: peg$source, + start: { + offset: startPos, + line: startPosDetails.line, + column: startPosDetails.column + }, + end: { + offset: endPos, + line: endPosDetails.line, + column: endPosDetails.column + } + }; + } + function peg$fail(expected2) { + if (peg$currPos < peg$maxFailPos) { + return; + } + if (peg$currPos > peg$maxFailPos) { + peg$maxFailPos = peg$currPos; + peg$maxFailExpected = []; + } + peg$maxFailExpected.push(expected2); + } + function peg$buildStructuredError(expected2, found, location2) { + return new peg$SyntaxError( + peg$SyntaxError.buildMessage(expected2, found), + expected2, + found, + location2 + ); + } + function peg$parsebody() { + var s0, s1, s2; + s0 = peg$currPos; + s1 = []; + s2 = peg$parsecomment_only_line(); + if (s2 === peg$FAILED) { + s2 = peg$parseline_with_sep(); + if (s2 === peg$FAILED) { + s2 = peg$parsepartial_line_with_comment(); + } + } + while (s2 !== peg$FAILED) { + s1.push(s2); + s2 = peg$parsecomment_only_line(); + if (s2 === peg$FAILED) { + s2 = peg$parseline_with_sep(); + if (s2 === peg$FAILED) { + s2 = peg$parsepartial_line_with_comment(); + } + } + } + s2 = peg$parseline_without_sep(); + if (s2 === peg$FAILED) { + s2 = peg$parseEOL(); + } + if (s2 !== peg$FAILED) { + s0 = peg$f0(s1, s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$parseEOL(); + if (s1 !== peg$FAILED) { + s1 = peg$f1(); + } + s0 = s1; + } + return s0; + } + function peg$parseitem() { + var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9; + peg$silentFails++; + s0 = peg$currPos; + s1 = peg$parseoperation(); + if (s1 === peg$FAILED) { + s1 = null; + } + s2 = []; + s3 = peg$parse_(); + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$parse_(); + } + s3 = []; + s4 = peg$parsenon_var_token(); + while (s4 !== peg$FAILED) { + s3.push(s4); + s4 = peg$parsenon_var_token(); + } + s4 = []; + s5 = peg$parse_(); + while (s5 !== peg$FAILED) { + s4.push(s5); + s5 = peg$parse_(); + } + s5 = peg$parsevar(); + if (s5 !== peg$FAILED) { + s6 = []; + s7 = peg$parse_(); + while (s7 !== peg$FAILED) { + s6.push(s7); + s7 = peg$parse_(); + } + s7 = []; + s8 = peg$parsetoken(); + while (s8 !== peg$FAILED) { + s7.push(s8); + s8 = peg$parsetoken(); + } + s8 = []; + s9 = peg$parse_(); + while (s9 !== peg$FAILED) { + s8.push(s9); + s9 = peg$parse_(); + } + s0 = peg$f3(s1, s3, s5, s7); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$parseoperation(); + if (s1 === peg$FAILED) { + s1 = null; + } + s2 = []; + s3 = peg$parse_(); + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$parse_(); + } + s3 = []; + s4 = peg$parsenon_var_token(); + if (s4 !== peg$FAILED) { + while (s4 !== peg$FAILED) { + s3.push(s4); + s4 = peg$parsenon_var_token(); + } + } else { + s3 = peg$FAILED; + } + if (s3 !== peg$FAILED) { + s4 = []; + s5 = peg$parse_(); + while (s5 !== peg$FAILED) { + s4.push(s5); + s5 = peg$parse_(); + } + s0 = peg$f4(s1, s3); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e1); + } + } + return s0; + } + function peg$parseline_with_sep() { + var s0, s1, s2, s3; + s0 = peg$currPos; + s1 = peg$parseline_without_sep(); + if (s1 !== peg$FAILED) { + s2 = peg$parsesep(); + if (s2 !== peg$FAILED) { + s3 = peg$parsetrailing_comment(); + if (s3 === peg$FAILED) { + s3 = null; + } + s0 = peg$f5(s1, s2, s3); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsepartial_line_with_comment() { + var s0, s1, s2; + s0 = peg$currPos; + s1 = peg$parseline_without_sep(); + if (s1 !== peg$FAILED) { + s2 = peg$parsetrailing_comment(); + if (s2 !== peg$FAILED) { + s0 = peg$f6(s1, s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parseline_without_sep() { + var s0, s1, s2, s3; + s0 = peg$currPos; + s1 = peg$currPos; + peg$silentFails++; + if (input.length > peg$currPos) { + s2 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e2); + } + } + peg$silentFails--; + if (s2 !== peg$FAILED) { + peg$currPos = s1; + s1 = void 0; + } else { + s1 = peg$FAILED; + } + if (s1 !== peg$FAILED) { + s2 = peg$parseequation(); + s3 = peg$parseannotation(); + if (s3 === peg$FAILED) { + s3 = null; + } + s0 = peg$f7(s2, s3); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parseannotation() { + var s0, s1, s2, s3; + s0 = peg$currPos; + s1 = peg$parseat(); + if (s1 !== peg$FAILED) { + s2 = []; + s3 = peg$parsenon_sep_token(); + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$parsenon_sep_token(); + } + s0 = peg$f8(s1, s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parseequation() { + var s0, s1, s2, s3, s4; + peg$silentFails++; + s0 = peg$currPos; + s1 = []; + s2 = peg$parseitem(); + while (s2 !== peg$FAILED) { + s1.push(s2); + s2 = peg$parseitem(); + } + s2 = peg$parseequals(); + if (s2 === peg$FAILED) { + s2 = null; + } + s3 = []; + s4 = peg$parsetoken(); + if (s4 === peg$FAILED) { + s4 = peg$parseoperation(); + } + while (s4 !== peg$FAILED) { + s3.push(s4); + s4 = peg$parsetoken(); + if (s4 === peg$FAILED) { + s4 = peg$parseoperation(); + } + } + s0 = peg$f9(s1, s2, s3); + peg$silentFails--; + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + return s0; + } + function peg$parsetrailing_comment() { + var s0, s1, s2; + peg$silentFails++; + s0 = peg$currPos; + s1 = []; + s2 = peg$parse_(); + while (s2 !== peg$FAILED) { + s1.push(s2); + s2 = peg$parse_(); + } + s2 = peg$parsesame_line_comment(); + if (s2 !== peg$FAILED) { + s0 = peg$f10(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e4); + } + } + return s0; + } + function peg$parsecomment_only_line() { + var s0, s1, s2; + peg$silentFails++; + s0 = peg$currPos; + s1 = []; + s2 = peg$parse_(); + while (s2 !== peg$FAILED) { + s1.push(s2); + s2 = peg$parse_(); + } + s2 = peg$parseown_line_comment(); + if (s2 !== peg$FAILED) { + s0 = peg$f11(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e5); + } + } + return s0; + } + function peg$parsevar() { + var s0, s1, s2, s3; + s0 = peg$currPos; + s1 = peg$parsevar_token(); + if (s1 !== peg$FAILED) { + s2 = []; + s3 = peg$parse_(); + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$parse_(); + } + s3 = peg$parsesubscript(); + if (s3 === peg$FAILED) { + s3 = null; + } + s0 = peg$f12(s1, s3); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsenon_var_token() { + var s0, s1, s2; + peg$silentFails++; + s0 = peg$currPos; + s1 = peg$currPos; + peg$silentFails++; + s2 = peg$parsevar(); + peg$silentFails--; + if (s2 === peg$FAILED) { + s1 = void 0; + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + if (s1 !== peg$FAILED) { + s2 = peg$parsetoken(); + if (s2 !== peg$FAILED) { + s0 = peg$f13(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e6); + } + } + return s0; + } + function peg$parsenon_sep_token() { + var s0, s1, s2; + s0 = peg$currPos; + s1 = peg$currPos; + peg$silentFails++; + s2 = peg$parsesep(); + if (s2 === peg$FAILED) { + s2 = peg$parsetrailing_comment(); + if (s2 === peg$FAILED) { + s2 = peg$parseown_line_comment(); + } + } + peg$silentFails--; + if (s2 === peg$FAILED) { + s1 = void 0; + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + if (s1 !== peg$FAILED) { + if (input.length > peg$currPos) { + s2 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e2); + } + } + if (s2 !== peg$FAILED) { + s0 = peg$f14(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsetoken() { + var s0, s1, s2; + peg$silentFails++; + s0 = peg$currPos; + s1 = peg$currPos; + peg$silentFails++; + s2 = peg$parsesep(); + if (s2 === peg$FAILED) { + s2 = peg$parseat(); + if (s2 === peg$FAILED) { + s2 = peg$parseoperation(); + if (s2 === peg$FAILED) { + s2 = peg$parseequals(); + if (s2 === peg$FAILED) { + s2 = peg$parsetrailing_comment(); + if (s2 === peg$FAILED) { + s2 = peg$parseown_line_comment(); + } + } + } + } + } + peg$silentFails--; + if (s2 === peg$FAILED) { + s1 = void 0; + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + if (s1 !== peg$FAILED) { + if (input.length > peg$currPos) { + s2 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e2); + } + } + if (s2 !== peg$FAILED) { + s0 = peg$f15(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e7); + } + } + return s0; + } + function peg$parsesame_line_comment() { + var s0, s1, s2; + peg$silentFails++; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e2); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f16(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s0 = peg$f17(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e8); + } + } + return s0; + } + function peg$parseown_line_comment() { + var s0, s1, s2; + peg$silentFails++; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e2); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f18(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s0 = peg$f19(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e9); + } + } + return s0; + } + function peg$parse_() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e2); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f20(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s0 = peg$f21(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsesep() { + var s0, s1, s2; + peg$silentFails++; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e2); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f22(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s0 = peg$f23(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e10); + } + } + return s0; + } + function peg$parseat() { + var s0, s1, s2; + peg$silentFails++; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e2); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f24(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s0 = peg$f25(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e11); + } + } + return s0; + } + function peg$parsevar_token() { + var s0, s1, s2; + peg$silentFails++; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e2); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f26(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s0 = peg$f27(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e12); + } + } + return s0; + } + function peg$parseoperation() { + var s0, s1, s2, s3, s4; + peg$silentFails++; + s0 = peg$currPos; + s1 = []; + s2 = peg$parse_(); + while (s2 !== peg$FAILED) { + s1.push(s2); + s2 = peg$parse_(); + } + if (input.length > peg$currPos) { + s2 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e2); + } + } + if (s2 !== peg$FAILED) { + s3 = []; + s4 = peg$parse_(); + while (s4 !== peg$FAILED) { + s3.push(s4); + s4 = peg$parse_(); + } + s4 = peg$f28(s2); + if (s4) { + s4 = void 0; + } else { + s4 = peg$FAILED; + } + if (s4 !== peg$FAILED) { + s0 = peg$f29(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e13); + } + } + return s0; + } + function peg$parseequals() { + var s0, s1, s2; + peg$silentFails++; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e2); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f30(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s0 = peg$f31(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e14); + } + } + return s0; + } + function peg$parsesubscript() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e2); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f32(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s0 = peg$f33(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parseEOL() { + var s0, s1; + s0 = peg$currPos; + peg$silentFails++; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e2); + } + } + peg$silentFails--; + if (s1 === peg$FAILED) { + s0 = void 0; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + if (!options2.isWhitespace) { + try { + Object.assign(options2, { + isSep: (node) => node.type === "string" && node.content === ",", + isVar: (node) => node.type === "string" && node.content.match(/[a-zA-Z]/), + isOperation: (node) => node.type === "string" && node.content.match(/[+-]/), + isEquals: (node) => node.type === "string" && node.content === "=", + isAt: (node) => node.type === "string" && node.content === "@", + isSubscript: (node) => node.content === "_", + isWhitespace: (node) => node.type === "whitespace", + isSameLineComment: (node) => node.type === "comment" && node.sameline, + isOwnLineComment: (node) => node.type === "comment" && !node.sameline + }); + } catch (e) { + console.warn("Error when initializing parser", e); + } + } + peg$result = peg$startRuleFunction(); + if (peg$result !== peg$FAILED && peg$currPos === input.length) { + return peg$result; + } else { + if (peg$result !== peg$FAILED && peg$currPos < input.length) { + peg$fail(peg$endExpectation()); + } + throw peg$buildStructuredError( + peg$maxFailExpected, + peg$maxFailPos < input.length ? input.charAt(peg$maxFailPos) : null, + peg$maxFailPos < input.length ? peg$computeLocation(peg$maxFailPos, peg$maxFailPos + 1) : peg$computeLocation(peg$maxFailPos, peg$maxFailPos) + ); + } + } + return { + SyntaxError: peg$SyntaxError, + parse: peg$parse + }; +})(); +// Generated by Peggy 2.0.1. +// +// https://peggyjs.org/ +(function() { + function peg$subclass(child, parent) { + function C() { + this.constructor = child; + } + C.prototype = parent.prototype; + child.prototype = new C(); + } + function peg$SyntaxError(message, expected, found, location) { + var self = Error.call(this, message); + if (Object.setPrototypeOf) { + Object.setPrototypeOf(self, peg$SyntaxError.prototype); + } + self.expected = expected; + self.found = found; + self.location = location; + self.name = "SyntaxError"; + return self; + } + peg$subclass(peg$SyntaxError, Error); + function peg$padEnd(str, targetLength, padString) { + padString = padString || " "; + if (str.length > targetLength) { + return str; + } + targetLength -= str.length; + padString += padString.repeat(targetLength); + return str + padString.slice(0, targetLength); + } + peg$SyntaxError.prototype.format = function(sources) { + var str = "Error: " + this.message; + if (this.location) { + var src = null; + var k; + for (k = 0; k < sources.length; k++) { + if (sources[k].source === this.location.source) { + src = sources[k].text.split(/\r\n|\n|\r/g); + break; + } + } + var s2 = this.location.start; + var loc = this.location.source + ":" + s2.line + ":" + s2.column; + if (src) { + var e = this.location.end; + var filler = peg$padEnd("", s2.line.toString().length, " "); + var line3 = src[s2.line - 1]; + var last = s2.line === e.line ? e.column : line3.length + 1; + var hatLen = last - s2.column || 1; + str += "\n --> " + loc + "\n" + filler + " |\n" + s2.line + " | " + line3 + "\n" + filler + " | " + peg$padEnd("", s2.column - 1, " ") + peg$padEnd("", hatLen, "^"); + } else { + str += "\n at " + loc; + } + } + return str; + }; + peg$SyntaxError.buildMessage = function(expected, found) { + var DESCRIBE_EXPECTATION_FNS = { + literal: function(expectation) { + return '"' + literalEscape(expectation.text) + '"'; + }, + class: function(expectation) { + var escapedParts = expectation.parts.map(function(part) { + return Array.isArray(part) ? classEscape(part[0]) + "-" + classEscape(part[1]) : classEscape(part); + }); + return "[" + (expectation.inverted ? "^" : "") + escapedParts.join("") + "]"; + }, + any: function() { + return "any character"; + }, + end: function() { + return "end of input"; + }, + other: function(expectation) { + return expectation.description; + } + }; + function hex(ch) { + return ch.charCodeAt(0).toString(16).toUpperCase(); + } + function literalEscape(s2) { + return s2.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\0/g, "\\0").replace(/\t/g, "\\t").replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/[\x00-\x0F]/g, function(ch) { + return "\\x0" + hex(ch); + }).replace(/[\x10-\x1F\x7F-\x9F]/g, function(ch) { + return "\\x" + hex(ch); + }); + } + function classEscape(s2) { + return s2.replace(/\\/g, "\\\\").replace(/\]/g, "\\]").replace(/\^/g, "\\^").replace(/-/g, "\\-").replace(/\0/g, "\\0").replace(/\t/g, "\\t").replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/[\x00-\x0F]/g, function(ch) { + return "\\x0" + hex(ch); + }).replace(/[\x10-\x1F\x7F-\x9F]/g, function(ch) { + return "\\x" + hex(ch); + }); + } + function describeExpectation(expectation) { + return DESCRIBE_EXPECTATION_FNS[expectation.type](expectation); + } + function describeExpected(expected2) { + var descriptions = expected2.map(describeExpectation); + var i, j; + descriptions.sort(); + if (descriptions.length > 0) { + for (i = 1, j = 1; i < descriptions.length; i++) { + if (descriptions[i - 1] !== descriptions[i]) { + descriptions[j] = descriptions[i]; + j++; + } + } + descriptions.length = j; + } + switch (descriptions.length) { + case 1: + return descriptions[0]; + case 2: + return descriptions[0] + " or " + descriptions[1]; + default: + return descriptions.slice(0, -1).join(", ") + ", or " + descriptions[descriptions.length - 1]; + } + } + function describeFound(found2) { + return found2 ? '"' + literalEscape(found2) + '"' : "end of input"; + } + return "Expected " + describeExpected(expected) + " but " + describeFound(found) + " found."; + }; + function peg$parse(input, options2) { + options2 = options2 !== void 0 ? options2 : {}; + var peg$FAILED = {}; + var peg$source = options2.grammarSource; + var peg$startRuleFunctions = { root: peg$parseroot }; + var peg$startRuleFunction = peg$parseroot; + var peg$c0 = "plus"; + var peg$c1 = "minus"; + var peg$c2 = "pt"; + var peg$c3 = "mm"; + var peg$c4 = "cm"; + var peg$c5 = "in"; + var peg$c6 = "ex"; + var peg$c7 = "em"; + var peg$c8 = "bp"; + var peg$c9 = "pc"; + var peg$c10 = "dd"; + var peg$c11 = "cc"; + var peg$c12 = "nd"; + var peg$c13 = "nc"; + var peg$c14 = "sp"; + var peg$c15 = "filll"; + var peg$c16 = "fill"; + var peg$c17 = "fil"; + var peg$c18 = "."; + var peg$c19 = "+"; + var peg$c20 = "-"; + var peg$r0 = /^[0-9]/; + var peg$e0 = peg$anyExpectation(); + var peg$e1 = peg$literalExpectation("plus", false); + var peg$e2 = peg$literalExpectation("minus", false); + var peg$e3 = peg$literalExpectation("pt", false); + var peg$e4 = peg$literalExpectation("mm", false); + var peg$e5 = peg$literalExpectation("cm", false); + var peg$e6 = peg$literalExpectation("in", false); + var peg$e7 = peg$literalExpectation("ex", false); + var peg$e8 = peg$literalExpectation("em", false); + var peg$e9 = peg$literalExpectation("bp", false); + var peg$e10 = peg$literalExpectation("pc", false); + var peg$e11 = peg$literalExpectation("dd", false); + var peg$e12 = peg$literalExpectation("cc", false); + var peg$e13 = peg$literalExpectation("nd", false); + var peg$e14 = peg$literalExpectation("nc", false); + var peg$e15 = peg$literalExpectation("sp", false); + var peg$e16 = peg$literalExpectation("filll", false); + var peg$e17 = peg$literalExpectation("fill", false); + var peg$e18 = peg$literalExpectation("fil", false); + var peg$e19 = peg$otherExpectation("number"); + var peg$e20 = peg$classExpectation([["0", "9"]], false, false); + var peg$e21 = peg$literalExpectation(".", false); + var peg$e22 = peg$literalExpectation("+", false); + var peg$e23 = peg$literalExpectation("-", false); + var peg$f0 = function(b, st, sh) { + return { + type: "glue", + fixed: b, + stretchable: st, + shrinkable: sh, + position: location() + }; + }; + var peg$f1 = function(glue) { + return glue; + }; + var peg$f2 = function(n, u) { + return { type: "dim", value: n, unit: u }; + }; + var peg$f3 = function(n, u) { + return { type: "dim", value: n, unit: u }; + }; + var peg$f4 = function(n, u) { + return { type: "dim", value: n, unit: u }; + }; + var peg$f5 = function(n) { + return parseFloat(n); + }; + var peg$currPos = 0; + var peg$savedPos = 0; + var peg$posDetailsCache = [{ line: 1, column: 1 }]; + var peg$maxFailPos = 0; + var peg$maxFailExpected = []; + var peg$silentFails = 0; + var peg$result; + if ("startRule" in options2) { + if (!(options2.startRule in peg$startRuleFunctions)) { + throw new Error(`Can't start parsing from rule "` + options2.startRule + '".'); + } + peg$startRuleFunction = peg$startRuleFunctions[options2.startRule]; + } + function location() { + return peg$computeLocation(peg$savedPos, peg$currPos); + } + function peg$literalExpectation(text2, ignoreCase) { + return { type: "literal", text: text2, ignoreCase }; + } + function peg$classExpectation(parts, inverted, ignoreCase) { + return { type: "class", parts, inverted, ignoreCase }; + } + function peg$anyExpectation() { + return { type: "any" }; + } + function peg$endExpectation() { + return { type: "end" }; + } + function peg$otherExpectation(description) { + return { type: "other", description }; + } + function peg$computePosDetails(pos) { + var details = peg$posDetailsCache[pos]; + var p; + if (details) { + return details; + } else { + p = pos - 1; + while (!peg$posDetailsCache[p]) { + p--; + } + details = peg$posDetailsCache[p]; + details = { + line: details.line, + column: details.column + }; + while (p < pos) { + if (input.charCodeAt(p) === 10) { + details.line++; + details.column = 1; + } else { + details.column++; + } + p++; + } + peg$posDetailsCache[pos] = details; + return details; + } + } + function peg$computeLocation(startPos, endPos) { + var startPosDetails = peg$computePosDetails(startPos); + var endPosDetails = peg$computePosDetails(endPos); + return { + source: peg$source, + start: { + offset: startPos, + line: startPosDetails.line, + column: startPosDetails.column + }, + end: { + offset: endPos, + line: endPosDetails.line, + column: endPosDetails.column + } + }; + } + function peg$fail(expected2) { + if (peg$currPos < peg$maxFailPos) { + return; + } + if (peg$currPos > peg$maxFailPos) { + peg$maxFailPos = peg$currPos; + peg$maxFailExpected = []; + } + peg$maxFailExpected.push(expected2); + } + function peg$buildStructuredError(expected2, found, location2) { + return new peg$SyntaxError( + peg$SyntaxError.buildMessage(expected2, found), + expected2, + found, + location2 + ); + } + function peg$parseroot() { + var s0, s1, s2, s3, s4; + s0 = peg$currPos; + s1 = peg$currPos; + s2 = peg$parsebase(); + if (s2 !== peg$FAILED) { + s3 = peg$parsestretchable(); + if (s3 === peg$FAILED) { + s3 = null; + } + s4 = peg$parseshrinkable(); + if (s4 === peg$FAILED) { + s4 = null; + } + peg$savedPos = s1; + s1 = peg$f0(s2, s3, s4); + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + if (s1 !== peg$FAILED) { + s2 = []; + if (input.length > peg$currPos) { + s3 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s3 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + while (s3 !== peg$FAILED) { + s2.push(s3); + if (input.length > peg$currPos) { + s3 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s3 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + } + peg$savedPos = s0; + s0 = peg$f1(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsebase() { + var s0, s1, s2; + s0 = peg$currPos; + s1 = peg$parsenumber(); + if (s1 !== peg$FAILED) { + s2 = peg$parseunit(); + if (s2 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f2(s1, s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsestretchable() { + var s0, s1, s2, s3; + s0 = peg$currPos; + if (input.substr(peg$currPos, 4) === peg$c0) { + s1 = peg$c0; + peg$currPos += 4; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e1); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$parsenumber(); + if (s2 !== peg$FAILED) { + s3 = peg$parserubber_unit(); + if (s3 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f3(s2, s3); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parseshrinkable() { + var s0, s1, s2, s3; + s0 = peg$currPos; + if (input.substr(peg$currPos, 5) === peg$c1) { + s1 = peg$c1; + peg$currPos += 5; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e2); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$parsenumber(); + if (s2 !== peg$FAILED) { + s3 = peg$parserubber_unit(); + if (s3 !== peg$FAILED) { + peg$savedPos = s0; + s0 = peg$f4(s2, s3); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parseunit() { + var s0; + if (input.substr(peg$currPos, 2) === peg$c2) { + s0 = peg$c2; + peg$currPos += 2; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + if (s0 === peg$FAILED) { + if (input.substr(peg$currPos, 2) === peg$c3) { + s0 = peg$c3; + peg$currPos += 2; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e4); + } + } + if (s0 === peg$FAILED) { + if (input.substr(peg$currPos, 2) === peg$c4) { + s0 = peg$c4; + peg$currPos += 2; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e5); + } + } + if (s0 === peg$FAILED) { + if (input.substr(peg$currPos, 2) === peg$c5) { + s0 = peg$c5; + peg$currPos += 2; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e6); + } + } + if (s0 === peg$FAILED) { + if (input.substr(peg$currPos, 2) === peg$c6) { + s0 = peg$c6; + peg$currPos += 2; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e7); + } + } + if (s0 === peg$FAILED) { + if (input.substr(peg$currPos, 2) === peg$c7) { + s0 = peg$c7; + peg$currPos += 2; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e8); + } + } + if (s0 === peg$FAILED) { + if (input.substr(peg$currPos, 2) === peg$c8) { + s0 = peg$c8; + peg$currPos += 2; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e9); + } + } + if (s0 === peg$FAILED) { + if (input.substr(peg$currPos, 2) === peg$c9) { + s0 = peg$c9; + peg$currPos += 2; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e10); + } + } + if (s0 === peg$FAILED) { + if (input.substr(peg$currPos, 2) === peg$c10) { + s0 = peg$c10; + peg$currPos += 2; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e11); + } + } + if (s0 === peg$FAILED) { + if (input.substr(peg$currPos, 2) === peg$c11) { + s0 = peg$c11; + peg$currPos += 2; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e12); + } + } + if (s0 === peg$FAILED) { + if (input.substr(peg$currPos, 2) === peg$c12) { + s0 = peg$c12; + peg$currPos += 2; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e13); + } + } + if (s0 === peg$FAILED) { + if (input.substr(peg$currPos, 2) === peg$c13) { + s0 = peg$c13; + peg$currPos += 2; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e14); + } + } + if (s0 === peg$FAILED) { + if (input.substr(peg$currPos, 2) === peg$c14) { + s0 = peg$c14; + peg$currPos += 2; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e15); + } + } + } + } + } + } + } + } + } + } + } + } + } + } + return s0; + } + function peg$parserubber_unit() { + var s0; + s0 = peg$parseunit(); + if (s0 === peg$FAILED) { + if (input.substr(peg$currPos, 5) === peg$c15) { + s0 = peg$c15; + peg$currPos += 5; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e16); + } + } + if (s0 === peg$FAILED) { + if (input.substr(peg$currPos, 4) === peg$c16) { + s0 = peg$c16; + peg$currPos += 4; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e17); + } + } + if (s0 === peg$FAILED) { + if (input.substr(peg$currPos, 3) === peg$c17) { + s0 = peg$c17; + peg$currPos += 3; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e18); + } + } + } + } + } + return s0; + } + function peg$parsenumber() { + var s0, s1, s2, s3, s4, s5, s6, s7, s8; + peg$silentFails++; + s0 = peg$currPos; + s1 = peg$currPos; + s2 = peg$currPos; + s3 = peg$parsesign(); + if (s3 === peg$FAILED) { + s3 = null; + } + s4 = peg$currPos; + s5 = []; + if (peg$r0.test(input.charAt(peg$currPos))) { + s6 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s6 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e20); + } + } + while (s6 !== peg$FAILED) { + s5.push(s6); + if (peg$r0.test(input.charAt(peg$currPos))) { + s6 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s6 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e20); + } + } + } + if (input.charCodeAt(peg$currPos) === 46) { + s6 = peg$c18; + peg$currPos++; + } else { + s6 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e21); + } + } + if (s6 !== peg$FAILED) { + s7 = []; + if (peg$r0.test(input.charAt(peg$currPos))) { + s8 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s8 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e20); + } + } + if (s8 !== peg$FAILED) { + while (s8 !== peg$FAILED) { + s7.push(s8); + if (peg$r0.test(input.charAt(peg$currPos))) { + s8 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s8 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e20); + } + } + } + } else { + s7 = peg$FAILED; + } + if (s7 !== peg$FAILED) { + s5 = [s5, s6, s7]; + s4 = s5; + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + if (s4 === peg$FAILED) { + s4 = []; + if (peg$r0.test(input.charAt(peg$currPos))) { + s5 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s5 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e20); + } + } + if (s5 !== peg$FAILED) { + while (s5 !== peg$FAILED) { + s4.push(s5); + if (peg$r0.test(input.charAt(peg$currPos))) { + s5 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s5 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e20); + } + } + } + } else { + s4 = peg$FAILED; + } + } + if (s4 !== peg$FAILED) { + s3 = [s3, s4]; + s2 = s3; + } else { + peg$currPos = s2; + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s1 = input.substring(s1, peg$currPos); + } else { + s1 = s2; + } + if (s1 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$f5(s1); + } + s0 = s1; + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e19); + } + } + return s0; + } + function peg$parsesign() { + var s0; + if (input.charCodeAt(peg$currPos) === 43) { + s0 = peg$c19; + peg$currPos++; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e22); + } + } + if (s0 === peg$FAILED) { + if (input.charCodeAt(peg$currPos) === 45) { + s0 = peg$c20; + peg$currPos++; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e23); + } + } + } + return s0; + } + peg$result = peg$startRuleFunction(); + if (peg$result !== peg$FAILED && peg$currPos === input.length) { + return peg$result; + } else { + if (peg$result !== peg$FAILED && peg$currPos < input.length) { + peg$fail(peg$endExpectation()); + } + throw peg$buildStructuredError( + peg$maxFailExpected, + peg$maxFailPos < input.length ? input.charAt(peg$maxFailPos) : null, + peg$maxFailPos < input.length ? peg$computeLocation(peg$maxFailPos, peg$maxFailPos + 1) : peg$computeLocation(peg$maxFailPos, peg$maxFailPos) + ); + } + } + return { + SyntaxError: peg$SyntaxError, + parse: peg$parse + }; +})(); +var tikz_default = ( + // Generated by Peggy 2.0.1. + // + // https://peggyjs.org/ + function() { + function peg$subclass(child, parent) { + function C() { + this.constructor = child; + } + C.prototype = parent.prototype; + child.prototype = new C(); + } + function peg$SyntaxError(message, expected, found, location) { + var self = Error.call(this, message); + if (Object.setPrototypeOf) { + Object.setPrototypeOf(self, peg$SyntaxError.prototype); + } + self.expected = expected; + self.found = found; + self.location = location; + self.name = "SyntaxError"; + return self; + } + peg$subclass(peg$SyntaxError, Error); + function peg$padEnd(str, targetLength, padString) { + padString = padString || " "; + if (str.length > targetLength) { + return str; + } + targetLength -= str.length; + padString += padString.repeat(targetLength); + return str + padString.slice(0, targetLength); + } + peg$SyntaxError.prototype.format = function(sources) { + var str = "Error: " + this.message; + if (this.location) { + var src = null; + var k; + for (k = 0; k < sources.length; k++) { + if (sources[k].source === this.location.source) { + src = sources[k].text.split(/\r\n|\n|\r/g); + break; + } + } + var s2 = this.location.start; + var loc = this.location.source + ":" + s2.line + ":" + s2.column; + if (src) { + var e = this.location.end; + var filler = peg$padEnd("", s2.line.toString().length, " "); + var line3 = src[s2.line - 1]; + var last = s2.line === e.line ? e.column : line3.length + 1; + var hatLen = last - s2.column || 1; + str += "\n --> " + loc + "\n" + filler + " |\n" + s2.line + " | " + line3 + "\n" + filler + " | " + peg$padEnd("", s2.column - 1, " ") + peg$padEnd("", hatLen, "^"); + } else { + str += "\n at " + loc; + } + } + return str; + }; + peg$SyntaxError.buildMessage = function(expected, found) { + var DESCRIBE_EXPECTATION_FNS = { + literal: function(expectation) { + return '"' + literalEscape(expectation.text) + '"'; + }, + class: function(expectation) { + var escapedParts = expectation.parts.map(function(part) { + return Array.isArray(part) ? classEscape(part[0]) + "-" + classEscape(part[1]) : classEscape(part); + }); + return "[" + (expectation.inverted ? "^" : "") + escapedParts.join("") + "]"; + }, + any: function() { + return "any character"; + }, + end: function() { + return "end of input"; + }, + other: function(expectation) { + return expectation.description; + } + }; + function hex(ch) { + return ch.charCodeAt(0).toString(16).toUpperCase(); + } + function literalEscape(s2) { + return s2.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\0/g, "\\0").replace(/\t/g, "\\t").replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/[\x00-\x0F]/g, function(ch) { + return "\\x0" + hex(ch); + }).replace(/[\x10-\x1F\x7F-\x9F]/g, function(ch) { + return "\\x" + hex(ch); + }); + } + function classEscape(s2) { + return s2.replace(/\\/g, "\\\\").replace(/\]/g, "\\]").replace(/\^/g, "\\^").replace(/-/g, "\\-").replace(/\0/g, "\\0").replace(/\t/g, "\\t").replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/[\x00-\x0F]/g, function(ch) { + return "\\x0" + hex(ch); + }).replace(/[\x10-\x1F\x7F-\x9F]/g, function(ch) { + return "\\x" + hex(ch); + }); + } + function describeExpectation(expectation) { + return DESCRIBE_EXPECTATION_FNS[expectation.type](expectation); + } + function describeExpected(expected2) { + var descriptions = expected2.map(describeExpectation); + var i, j; + descriptions.sort(); + if (descriptions.length > 0) { + for (i = 1, j = 1; i < descriptions.length; i++) { + if (descriptions[i - 1] !== descriptions[i]) { + descriptions[j] = descriptions[i]; + j++; + } + } + descriptions.length = j; + } + switch (descriptions.length) { + case 1: + return descriptions[0]; + case 2: + return descriptions[0] + " or " + descriptions[1]; + default: + return descriptions.slice(0, -1).join(", ") + ", or " + descriptions[descriptions.length - 1]; + } + } + function describeFound(found2) { + return found2 ? '"' + literalEscape(found2) + '"' : "end of input"; + } + return "Expected " + describeExpected(expected) + " but " + describeFound(found) + " found."; + }; + function peg$parse(input, options2) { + options2 = options2 !== void 0 ? options2 : {}; + var peg$FAILED = {}; + var peg$source = options2.grammarSource; + var peg$startRuleFunctions = { path_spec: peg$parsepath_spec, foreach_body: peg$parseforeach_body }; + var peg$startRuleFunction = peg$parsepath_spec; + var peg$e0 = peg$anyExpectation(); + var peg$e3 = peg$otherExpectation("comment"); + var peg$e4 = peg$otherExpectation("floating comment"); + var peg$e5 = peg$otherExpectation("operation"); + var peg$e6 = peg$otherExpectation("="); + var peg$f0 = function(v) { + return v; + }; + var peg$f1 = function(ops) { + return { type: "path_spec", content: ops }; + }; + var peg$f2 = function(c1, op, comment) { + return { op, comment }; + }; + var peg$f3 = function(c1, ops, c2, body) { + const comments = [c1, ...ops.map((x) => x.comment), c2].filter( + (x) => x + ); + const attribute = ops.map((x) => x.op.content.content).join(" "); + return { + type: "animation", + comments, + attribute, + content: body.content + }; + }; + var peg$f4 = function(start, b) { + return { ...b, start, type: "foreach" }; + }; + var peg$f5 = function(c1, variables, options22, c2, c3, list, c4, command) { + const comments = [c1, c2, c3, c4].filter((x) => x); + return { + type: "foreach_body", + variables, + options: options22 && options22.content, + list, + command, + comments + }; + }; + var peg$f6 = function(c1, options22, c2, body) { + const comments = [c1, c2].filter((x) => x); + return { + type: "svg_operation", + options: options22 && options22.content, + content: body, + comments + }; + }; + var peg$f7 = function(c1, c2, coord, c3, c4, x) { + return { coord: x, comment: c4 }; + }; + var peg$f8 = function(c1, c2, coord, c3, a, c5) { + const comments = [c1, c2, c3, a && a.comment, c5].filter((x) => x); + return { + type: "curve_to", + controls: a ? [coord, a.coord] : [coord], + comments + }; + }; + var peg$f9 = function() { + return { type: "line_to", command: "|-" }; + }; + var peg$f10 = function() { + return { type: "line_to", command: "-|" }; + }; + var peg$f11 = function() { + return { type: "line_to", command: "--" }; + }; + var peg$f12 = function(prefix, content) { + return { type: "coordinate", content, prefix }; + }; + var peg$f13 = function(content) { + return { type: "square_brace_group", content }; + }; + var peg$f14 = function(v) { + return { type: "unknown", content: v }; + }; + var peg$f19 = function(tok) { + return options2.isComment(tok); + }; + var peg$f20 = function(tok) { + return tok; + }; + var peg$f21 = function(tok) { + return options2.isWhitespace(tok); + }; + var peg$f22 = function(tok) { + return tok; + }; + var peg$f23 = function(c) { + return c; + }; + var peg$f24 = function(tok) { + return options2.isOperation(tok); + }; + var peg$f25 = function(tok) { + return { type: "operation", content: tok }; + }; + var peg$f26 = function(tok) { + return options2.isChar(tok, "="); + }; + var peg$f27 = function(tok) { + return tok; + }; + var peg$f28 = function(tok) { + return options2.isChar(tok, "["); + }; + var peg$f29 = function(tok) { + return tok; + }; + var peg$f30 = function(tok) { + return options2.isChar(tok, "]"); + }; + var peg$f31 = function(tok) { + return tok; + }; + var peg$f32 = function(tok) { + return options2.isChar(tok, "("); + }; + var peg$f33 = function(tok) { + return tok; + }; + var peg$f34 = function(tok) { + return options2.isChar(tok, ")"); + }; + var peg$f35 = function(tok) { + return tok; + }; + var peg$f36 = function(tok) { + return options2.isChar(tok, "+"); + }; + var peg$f37 = function(tok) { + return tok; + }; + var peg$f38 = function(tok) { + return options2.isChar(tok, "-"); + }; + var peg$f39 = function(tok) { + return tok; + }; + var peg$f40 = function(tok) { + return options2.isChar(tok, "|"); + }; + var peg$f41 = function(tok) { + return tok; + }; + var peg$f42 = function(tok) { + return options2.isChar(tok, "."); + }; + var peg$f43 = function(tok) { + return tok; + }; + var peg$f44 = function(tok) { + return options2.isChar(tok, "controls"); + }; + var peg$f45 = function(tok) { + return tok; + }; + var peg$f46 = function(tok) { + return options2.isChar(tok, "and"); + }; + var peg$f47 = function(tok) { + return tok; + }; + var peg$f48 = function(tok) { + return options2.isChar(tok, "svg"); + }; + var peg$f49 = function(tok) { + return tok; + }; + var peg$f50 = function(tok) { + return options2.isGroup(tok); + }; + var peg$f51 = function(tok) { + return tok; + }; + var peg$f52 = function(tok) { + return options2.isAnyMacro(tok); + }; + var peg$f53 = function(tok) { + return tok; + }; + var peg$f54 = function(tok) { + return options2.isChar(tok, "foreach"); + }; + var peg$f55 = function(tok) { + return tok; + }; + var peg$f56 = function(tok) { + return options2.isMacro(tok, "foreach"); + }; + var peg$f57 = function(tok) { + return tok; + }; + var peg$f58 = function(tok) { + return options2.isChar(tok, "in"); + }; + var peg$f59 = function(tok) { + return tok; + }; + var peg$f60 = function(tok) { + return options2.isChar(tok, ":"); + }; + var peg$f61 = function(tok) { + return tok; + }; + var peg$currPos = 0; + var peg$posDetailsCache = [{ line: 1, column: 1 }]; + var peg$maxFailPos = 0; + var peg$maxFailExpected = []; + var peg$silentFails = 0; + var peg$result; + if ("startRule" in options2) { + if (!(options2.startRule in peg$startRuleFunctions)) { + throw new Error(`Can't start parsing from rule "` + options2.startRule + '".'); + } + peg$startRuleFunction = peg$startRuleFunctions[options2.startRule]; + } + function peg$anyExpectation() { + return { type: "any" }; + } + function peg$endExpectation() { + return { type: "end" }; + } + function peg$otherExpectation(description) { + return { type: "other", description }; + } + function peg$computePosDetails(pos) { + var details = peg$posDetailsCache[pos]; + var p; + if (details) { + return details; + } else { + p = pos - 1; + while (!peg$posDetailsCache[p]) { + p--; + } + details = peg$posDetailsCache[p]; + details = { + line: details.line, + column: details.column + }; + while (p < pos) { + if (input.charCodeAt(p) === 10) { + details.line++; + details.column = 1; + } else { + details.column++; + } + p++; + } + peg$posDetailsCache[pos] = details; + return details; + } + } + function peg$computeLocation(startPos, endPos) { + var startPosDetails = peg$computePosDetails(startPos); + var endPosDetails = peg$computePosDetails(endPos); + return { + source: peg$source, + start: { + offset: startPos, + line: startPosDetails.line, + column: startPosDetails.column + }, + end: { + offset: endPos, + line: endPosDetails.line, + column: endPosDetails.column + } + }; + } + function peg$fail(expected2) { + if (peg$currPos < peg$maxFailPos) { + return; + } + if (peg$currPos > peg$maxFailPos) { + peg$maxFailPos = peg$currPos; + peg$maxFailExpected = []; + } + peg$maxFailExpected.push(expected2); + } + function peg$buildStructuredError(expected2, found, location2) { + return new peg$SyntaxError( + peg$SyntaxError.buildMessage(expected2, found), + expected2, + found, + location2 + ); + } + function peg$parsepath_spec() { + var s0, s1, s2, s3, s4, s5; + s0 = peg$currPos; + s1 = []; + s2 = peg$currPos; + s3 = peg$parsesquare_brace_group(); + if (s3 === peg$FAILED) { + s3 = peg$parsecoordinate(); + if (s3 === peg$FAILED) { + s3 = peg$parsecurve_to(); + if (s3 === peg$FAILED) { + s3 = peg$parseline_to(); + if (s3 === peg$FAILED) { + s3 = peg$parsesvg(); + if (s3 === peg$FAILED) { + s3 = peg$parseforeach(); + if (s3 === peg$FAILED) { + s3 = peg$parseoperation(); + if (s3 === peg$FAILED) { + s3 = peg$parsecomment(); + if (s3 === peg$FAILED) { + s3 = peg$parseanimation(); + if (s3 === peg$FAILED) { + s3 = peg$parseunknown(); + } + } + } + } + } + } + } + } + } + if (s3 !== peg$FAILED) { + s4 = []; + s5 = peg$parse_(); + while (s5 !== peg$FAILED) { + s4.push(s5); + s5 = peg$parse_(); + } + s2 = peg$f0(s3); + } else { + peg$currPos = s2; + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + while (s2 !== peg$FAILED) { + s1.push(s2); + s2 = peg$currPos; + s3 = peg$parsesquare_brace_group(); + if (s3 === peg$FAILED) { + s3 = peg$parsecoordinate(); + if (s3 === peg$FAILED) { + s3 = peg$parsecurve_to(); + if (s3 === peg$FAILED) { + s3 = peg$parseline_to(); + if (s3 === peg$FAILED) { + s3 = peg$parsesvg(); + if (s3 === peg$FAILED) { + s3 = peg$parseforeach(); + if (s3 === peg$FAILED) { + s3 = peg$parseoperation(); + if (s3 === peg$FAILED) { + s3 = peg$parsecomment(); + if (s3 === peg$FAILED) { + s3 = peg$parseanimation(); + if (s3 === peg$FAILED) { + s3 = peg$parseunknown(); + } + } + } + } + } + } + } + } + } + if (s3 !== peg$FAILED) { + s4 = []; + s5 = peg$parse_(); + while (s5 !== peg$FAILED) { + s4.push(s5); + s5 = peg$parse_(); + } + s2 = peg$f0(s3); + } else { + peg$currPos = s2; + s2 = peg$FAILED; + } + } + } else { + s1 = peg$FAILED; + } + if (s1 !== peg$FAILED) { + s1 = peg$f1(s1); + } + s0 = s1; + return s0; + } + function peg$parseanimation() { + var s0, s1, s2, s3, s4, s5, s6; + s0 = peg$currPos; + s1 = peg$parsecolon(); + if (s1 !== peg$FAILED) { + s2 = peg$parse_comment_(); + s3 = []; + s4 = peg$currPos; + s5 = peg$parseoperation(); + if (s5 !== peg$FAILED) { + s6 = peg$parse_comment_(); + s4 = peg$f2(s2, s5, s6); + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + if (s4 !== peg$FAILED) { + while (s4 !== peg$FAILED) { + s3.push(s4); + s4 = peg$currPos; + s5 = peg$parseoperation(); + if (s5 !== peg$FAILED) { + s6 = peg$parse_comment_(); + s4 = peg$f2(s2, s5, s6); + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + } + } else { + s3 = peg$FAILED; + } + if (s3 !== peg$FAILED) { + s4 = peg$parseequals(); + if (s4 !== peg$FAILED) { + s5 = peg$parse_comment_(); + s6 = peg$parsegroup(); + if (s6 !== peg$FAILED) { + s0 = peg$f3(s2, s3, s5, s6); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parseforeach() { + var s0, s1, s2; + s0 = peg$currPos; + s1 = peg$parseforeach_keyword(); + if (s1 === peg$FAILED) { + s1 = peg$parseforeach_macro(); + } + if (s1 !== peg$FAILED) { + s2 = peg$parseforeach_body(); + if (s2 !== peg$FAILED) { + s0 = peg$f4(s1, s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parseforeach_body() { + var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9; + s0 = peg$currPos; + s1 = peg$parse_comment_(); + s2 = peg$currPos; + s3 = []; + s4 = peg$currPos; + s5 = peg$currPos; + peg$silentFails++; + s6 = peg$parsein_keyword(); + if (s6 === peg$FAILED) { + s6 = peg$parsesquare_brace_group(); + } + peg$silentFails--; + if (s6 === peg$FAILED) { + s5 = void 0; + } else { + peg$currPos = s5; + s5 = peg$FAILED; + } + if (s5 !== peg$FAILED) { + if (input.length > peg$currPos) { + s6 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s6 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s6 !== peg$FAILED) { + s5 = [s5, s6]; + s4 = s5; + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + while (s4 !== peg$FAILED) { + s3.push(s4); + s4 = peg$currPos; + s5 = peg$currPos; + peg$silentFails++; + s6 = peg$parsein_keyword(); + if (s6 === peg$FAILED) { + s6 = peg$parsesquare_brace_group(); + } + peg$silentFails--; + if (s6 === peg$FAILED) { + s5 = void 0; + } else { + peg$currPos = s5; + s5 = peg$FAILED; + } + if (s5 !== peg$FAILED) { + if (input.length > peg$currPos) { + s6 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s6 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s6 !== peg$FAILED) { + s5 = [s5, s6]; + s4 = s5; + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + } + s2 = input.substring(s2, peg$currPos); + s3 = peg$parsesquare_brace_group(); + if (s3 === peg$FAILED) { + s3 = null; + } + s4 = peg$parse_comment_(); + s5 = peg$parsein_keyword(); + if (s5 !== peg$FAILED) { + s6 = peg$parse_comment_(); + s7 = peg$parsegroup(); + if (s7 === peg$FAILED) { + s7 = peg$parsemacro(); + } + if (s7 !== peg$FAILED) { + s8 = peg$parse_comment_(); + s9 = peg$parseforeach(); + if (s9 === peg$FAILED) { + s9 = peg$parsegroup(); + if (s9 === peg$FAILED) { + s9 = peg$parsemacro(); + } + } + if (s9 !== peg$FAILED) { + s0 = peg$f5(s1, s2, s3, s4, s6, s7, s8, s9); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsesvg() { + var s0, s1, s2, s3, s4, s5; + s0 = peg$currPos; + s1 = peg$parsesvg_keyword(); + if (s1 !== peg$FAILED) { + s2 = peg$parse_comment_(); + s3 = peg$parsesquare_brace_group(); + if (s3 === peg$FAILED) { + s3 = null; + } + s4 = peg$parse_comment_(); + s5 = peg$parsegroup(); + if (s5 !== peg$FAILED) { + s0 = peg$f6(s2, s3, s4, s5); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsecurve_to() { + var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10; + s0 = peg$currPos; + s1 = peg$parsedotdot(); + if (s1 !== peg$FAILED) { + s2 = peg$parse_comment_(); + s3 = peg$parsecontrols_keyword(); + if (s3 !== peg$FAILED) { + s4 = peg$parse_comment_(); + s5 = peg$parsecoordinate(); + if (s5 !== peg$FAILED) { + s6 = peg$parse_comment_(); + s7 = peg$currPos; + s8 = peg$parseand_keyword(); + if (s8 !== peg$FAILED) { + s9 = peg$parse_comment_(); + s10 = peg$parsecoordinate(); + if (s10 !== peg$FAILED) { + s7 = peg$f7(s2, s4, s5, s6, s9, s10); + } else { + peg$currPos = s7; + s7 = peg$FAILED; + } + } else { + peg$currPos = s7; + s7 = peg$FAILED; + } + if (s7 === peg$FAILED) { + s7 = null; + } + s8 = peg$parse_comment_(); + s9 = peg$parsedotdot(); + if (s9 !== peg$FAILED) { + s0 = peg$f8(s2, s4, s5, s6, s7, s8); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parseline_to() { + var s0, s1, s2; + s0 = peg$currPos; + s1 = peg$parsepipe(); + if (s1 !== peg$FAILED) { + s2 = peg$parseminus(); + if (s2 !== peg$FAILED) { + s0 = peg$f9(); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$parseminus(); + if (s1 !== peg$FAILED) { + s2 = peg$parsepipe(); + if (s2 !== peg$FAILED) { + s0 = peg$f10(); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$parseminus(); + if (s1 !== peg$FAILED) { + s2 = peg$parseminus(); + if (s2 !== peg$FAILED) { + s0 = peg$f11(); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } + } + return s0; + } + function peg$parsecoordinate() { + var s0, s1, s2, s3, s4, s5, s6, s7; + s0 = peg$currPos; + s1 = peg$currPos; + s2 = peg$currPos; + s3 = peg$parseplus(); + if (s3 !== peg$FAILED) { + s4 = peg$parseplus(); + if (s4 === peg$FAILED) { + s4 = null; + } + s3 = [s3, s4]; + s2 = s3; + } else { + peg$currPos = s2; + s2 = peg$FAILED; + } + if (s2 === peg$FAILED) { + s2 = null; + } + s1 = input.substring(s1, peg$currPos); + s2 = peg$parseopen_paren(); + if (s2 !== peg$FAILED) { + s3 = peg$currPos; + s4 = []; + s5 = peg$currPos; + s6 = peg$currPos; + peg$silentFails++; + s7 = peg$parseclose_paren(); + peg$silentFails--; + if (s7 === peg$FAILED) { + s6 = void 0; + } else { + peg$currPos = s6; + s6 = peg$FAILED; + } + if (s6 !== peg$FAILED) { + if (input.length > peg$currPos) { + s7 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s7 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s7 !== peg$FAILED) { + s6 = [s6, s7]; + s5 = s6; + } else { + peg$currPos = s5; + s5 = peg$FAILED; + } + } else { + peg$currPos = s5; + s5 = peg$FAILED; + } + while (s5 !== peg$FAILED) { + s4.push(s5); + s5 = peg$currPos; + s6 = peg$currPos; + peg$silentFails++; + s7 = peg$parseclose_paren(); + peg$silentFails--; + if (s7 === peg$FAILED) { + s6 = void 0; + } else { + peg$currPos = s6; + s6 = peg$FAILED; + } + if (s6 !== peg$FAILED) { + if (input.length > peg$currPos) { + s7 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s7 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s7 !== peg$FAILED) { + s6 = [s6, s7]; + s5 = s6; + } else { + peg$currPos = s5; + s5 = peg$FAILED; + } + } else { + peg$currPos = s5; + s5 = peg$FAILED; + } + } + s3 = input.substring(s3, peg$currPos); + s4 = peg$parseclose_paren(); + if (s4 !== peg$FAILED) { + s0 = peg$f12(s1, s3); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsesquare_brace_group() { + var s0, s1, s2, s3, s4, s5, s6; + s0 = peg$currPos; + s1 = peg$parseopen_square_brace(); + if (s1 !== peg$FAILED) { + s2 = peg$currPos; + s3 = []; + s4 = peg$currPos; + s5 = peg$currPos; + peg$silentFails++; + s6 = peg$parseclose_square_brace(); + peg$silentFails--; + if (s6 === peg$FAILED) { + s5 = void 0; + } else { + peg$currPos = s5; + s5 = peg$FAILED; + } + if (s5 !== peg$FAILED) { + if (input.length > peg$currPos) { + s6 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s6 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s6 !== peg$FAILED) { + s5 = [s5, s6]; + s4 = s5; + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + while (s4 !== peg$FAILED) { + s3.push(s4); + s4 = peg$currPos; + s5 = peg$currPos; + peg$silentFails++; + s6 = peg$parseclose_square_brace(); + peg$silentFails--; + if (s6 === peg$FAILED) { + s5 = void 0; + } else { + peg$currPos = s5; + s5 = peg$FAILED; + } + if (s5 !== peg$FAILED) { + if (input.length > peg$currPos) { + s6 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s6 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s6 !== peg$FAILED) { + s5 = [s5, s6]; + s4 = s5; + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + } + s2 = input.substring(s2, peg$currPos); + s3 = peg$parseclose_square_brace(); + if (s3 !== peg$FAILED) { + s0 = peg$f13(s2); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsedotdot() { + var s0, s1, s2; + s0 = peg$currPos; + s1 = peg$parsedot(); + if (s1 !== peg$FAILED) { + s2 = peg$parsedot(); + if (s2 !== peg$FAILED) { + s1 = [s1, s2]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parseunknown() { + var s0, s1; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + s1 = peg$f14(s1); + } + s0 = s1; + return s0; + } + function peg$parsecomment() { + var s0, s1, s2; + peg$silentFails++; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f19(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s0 = peg$f20(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e3); + } + } + return s0; + } + function peg$parse_() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f21(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s0 = peg$f22(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parse_comment_() { + var s0, s1, s2, s3, s4; + peg$silentFails++; + s0 = peg$currPos; + s1 = []; + s2 = peg$parse_(); + while (s2 !== peg$FAILED) { + s1.push(s2); + s2 = peg$parse_(); + } + s2 = peg$parsecomment(); + if (s2 === peg$FAILED) { + s2 = null; + } + s3 = []; + s4 = peg$parse_(); + while (s4 !== peg$FAILED) { + s3.push(s4); + s4 = peg$parse_(); + } + s0 = peg$f23(s2); + peg$silentFails--; + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e4); + } + return s0; + } + function peg$parseoperation() { + var s0, s1, s2; + peg$silentFails++; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f24(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s0 = peg$f25(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e5); + } + } + return s0; + } + function peg$parseequals() { + var s0, s1, s2; + peg$silentFails++; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f26(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s0 = peg$f27(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e6); + } + } + return s0; + } + function peg$parseopen_square_brace() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f28(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s0 = peg$f29(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parseclose_square_brace() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f30(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s0 = peg$f31(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parseopen_paren() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f32(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s0 = peg$f33(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parseclose_paren() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f34(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s0 = peg$f35(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parseplus() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f36(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s0 = peg$f37(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parseminus() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f38(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s0 = peg$f39(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsepipe() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f40(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s0 = peg$f41(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsedot() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f42(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s0 = peg$f43(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsecontrols_keyword() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f44(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s0 = peg$f45(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parseand_keyword() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f46(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s0 = peg$f47(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsesvg_keyword() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f48(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s0 = peg$f49(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsegroup() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f50(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s0 = peg$f51(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsemacro() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f52(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s0 = peg$f53(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parseforeach_keyword() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f54(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s0 = peg$f55(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parseforeach_macro() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f56(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s0 = peg$f57(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsein_keyword() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f58(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s0 = peg$f59(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + function peg$parsecolon() { + var s0, s1, s2; + s0 = peg$currPos; + if (input.length > peg$currPos) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { + peg$fail(peg$e0); + } + } + if (s1 !== peg$FAILED) { + s2 = peg$f60(s1); + if (s2) { + s2 = void 0; + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s0 = peg$f61(s1); + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + return s0; + } + if (!options2.isWhitespace) { + try { + Object.assign(options2, { + isChar: (node, char) => node.type === "string" && node.content === char, + isOperation: (node) => node.type === "string" && node.content.match(/[a-zA-Z]/), + isWhitespace: (node) => node.type === "whitespace" || node.type === "parbreak", + isSameLineComment: (node) => node.type === "comment" && node.sameline, + isOwnLineComment: (node) => node.type === "comment" && !node.sameline, + isComment: (node) => node.type === "comment", + isGroup: (node) => node.type === "group", + isMacro: (node, name) => node.type === "macro" && node.content === name, + isAnyMacro: (node) => node.type === "macro" + }); + } catch (e) { + console.warn("Error when initializing parser", e); + } + } + peg$result = peg$startRuleFunction(); + if (peg$result !== peg$FAILED && peg$currPos === input.length) { + return peg$result; + } else { + if (peg$result !== peg$FAILED && peg$currPos < input.length) { + peg$fail(peg$endExpectation()); + } + throw peg$buildStructuredError( + peg$maxFailExpected, + peg$maxFailPos < input.length ? input.charAt(peg$maxFailPos) : null, + peg$maxFailPos < input.length ? peg$computeLocation(peg$maxFailPos, peg$maxFailPos + 1) : peg$computeLocation(peg$maxFailPos, peg$maxFailPos) + ); + } + } + return { + SyntaxError: peg$SyntaxError, + parse: peg$parse + }; + }() +); +var LatexPegParser = latex_default; +var AlignEnvironmentPegParser = align_environment_default; +var ArgSpecPegParser = xparse_argspec_default; +var PgfkeysPegParser = pgfkeys_default; +var TikzPegParser = tikz_default; +var parseCache = {}; +function parse$2(str = "") { + parseCache[str] = parseCache[str] || ArgSpecPegParser.parse(str); + return parseCache[str]; +} +var BRACES_MAP = { + "*": { openMark: "", closeMark: "" }, + "{": { openMark: "{", closeMark: "}" }, + "[": { openMark: "[", closeMark: "]" }, + "(": { openMark: "(", closeMark: ")" }, + "<": { openMark: "<", closeMark: ">" } +}; +var CLOSE_BRACES = new Set( + Object.values(BRACES_MAP).map((x) => x.closeMark).filter((x) => x) +); +function bracesToOpenAndCloseMarks(braces) { + const ret = []; + for (const char of braces.split("")) { + if (CLOSE_BRACES.has(char)) { + continue; + } + const braces2 = BRACES_MAP[char]; + if (braces2 == null) { + throw new Error(`Unknown open/close mark type "${char}"`); + } + ret.push(braces2); + } + return ret; +} +function arg(args2, special) { + if (args2 == null) { + return { type: "argument", content: [], openMark: "", closeMark: "" }; + } + if (typeof args2 === "string") { + args2 = s(args2); + } + if (!Array.isArray(args2) && args2.type === "argument") { + return args2; + } + let openMark = (special == null ? void 0 : special.openMark) ?? "{"; + let closeMark = (special == null ? void 0 : special.closeMark) ?? "}"; + if (special == null ? void 0 : special.braces) { + const braces = bracesToOpenAndCloseMarks(special.braces); + if (braces[0]) { + openMark = braces[0].openMark; + closeMark = braces[0].closeMark; + } + } + if (!Array.isArray(args2)) { + args2 = [args2]; + } + return { type: "argument", content: args2, openMark, closeMark }; +} +function s(value) { + if (typeof value === "string") { + return { type: "string", content: value }; + } + return value; +} +function getDefaultExportFromCjs(x) { + return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, "default") ? x["default"] : x; +} +var dist = { exports: {} }; +var create = { exports: {} }; +var append = { exports: {} }; +var config = { exports: {} }; +(function(module2, exports2) { + Object.defineProperty(exports2, "__esModule", { + value: true + }); + exports2.default = { + END_WORD: "$", + END_WORD_REPLACER: "9a219a89-91cd-42e2-abd5-eb113af08ca8", + PERMS_MIN_LEN: 2 + }; + module2.exports = exports2["default"]; +})(config, config.exports); +var configExports = config.exports; +(function(module2, exports2) { + Object.defineProperty(exports2, "__esModule", { + value: true + }); + exports2.default = append2; + var _config = configExports; + var _config2 = _interopRequireDefault(_config); + function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : { default: obj }; + } + function append2(trie, letter, index2, array) { + var isEndWordLetter = letter === _config2.default.END_WORD; + var isLastLetter = index2 === array.length - 1; + if (isEndWordLetter && !isLastLetter) { + trie[_config2.default.END_WORD] = 1; + trie[_config2.default.END_WORD_REPLACER] = {}; + trie = trie[_config2.default.END_WORD_REPLACER]; + } else { + trie[letter] = trie[letter] || {}; + trie = trie[letter]; + } + if (isLastLetter) { + trie[_config2.default.END_WORD] = 1; + } + return trie; + } + module2.exports = exports2["default"]; +})(append, append.exports); +var appendExports = append.exports; +(function(module2, exports2) { + Object.defineProperty(exports2, "__esModule", { + value: true + }); + var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function(obj) { + return typeof obj; + } : function(obj) { + return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; + }; + exports2.default = create2; + var _append = appendExports; + var _append2 = _interopRequireDefault(_append); + function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : { default: obj }; + } + function create2(input) { + if (!Array.isArray(input)) { + throw "Expected parameter Array, received " + (typeof input === "undefined" ? "undefined" : _typeof(input)); + } + var trie = input.reduce(function(accumulator, item) { + item.toLowerCase().split("").reduce(_append2.default, accumulator); + return accumulator; + }, {}); + return trie; + } + module2.exports = exports2["default"]; +})(create, create.exports); +var createExports = create.exports; +var checkPrefix = { exports: {} }; +var utils$1 = { exports: {} }; +(function(module2, exports2) { + Object.defineProperty(exports2, "__esModule", { + value: true + }); + exports2.default = { + objectCopy: function objectCopy(obj) { + if (typeof obj === "undefined") { + return {}; + } + return JSON.parse(JSON.stringify(obj)); + }, + stringify: function stringify(obj) { + var spacer = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : 2; + if (typeof obj === "undefined") { + return ""; + } + return JSON.stringify(obj, null, spacer); + } + }; + module2.exports = exports2["default"]; +})(utils$1, utils$1.exports); +var utilsExports = utils$1.exports; +(function(module2, exports2) { + Object.defineProperty(exports2, "__esModule", { + value: true + }); + exports2.default = checkPrefix2; + var _utils = utilsExports; + _interopRequireDefault(_utils); + function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : { default: obj }; + } + function checkPrefix2(prefixNode, prefix) { + var input = prefix.toLowerCase().split(""); + var prefixFound = input.every(function(letter, index2) { + if (!prefixNode[letter]) { + return false; + } + return prefixNode = prefixNode[letter]; + }); + return { + prefixFound, + prefixNode + }; + } + module2.exports = exports2["default"]; +})(checkPrefix, checkPrefix.exports); +var checkPrefixExports = checkPrefix.exports; +var recursePrefix = { exports: {} }; +(function(module2, exports2) { + Object.defineProperty(exports2, "__esModule", { + value: true + }); + exports2.default = recursePrefix2; + var _config = configExports; + var _config2 = _interopRequireDefault(_config); + function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : { default: obj }; + } + var pushInOrder = function pushInOrder2(word, prefixes) { + var i = 0; + while (i < prefixes.length) { + if (word < prefixes[i]) { + break; + } + i += 1; + } + prefixes.splice(i, 0, word); + return prefixes; + }; + function recursePrefix2(node, prefix, sorted) { + var prefixes = arguments.length > 3 && arguments[3] !== void 0 ? arguments[3] : []; + var word = prefix; + for (var branch in node) { + var currentLetter = branch; + if (branch === _config2.default.END_WORD && typeof node[branch] === "number") { + if (sorted) { + pushInOrder(word, prefixes); + } else { + prefixes.push(word); + } + word = ""; + } else if (branch === _config2.default.END_WORD_REPLACER) { + currentLetter = _config2.default.END_WORD; + } + recursePrefix2(node[branch], prefix + currentLetter, sorted, prefixes); + } + return prefixes; + } + module2.exports = exports2["default"]; +})(recursePrefix, recursePrefix.exports); +var recursePrefixExports = recursePrefix.exports; +var recurseRandomWord = { exports: {} }; +(function(module2, exports2) { + Object.defineProperty(exports2, "__esModule", { + value: true + }); + exports2.default = recurseRandomWord2; + var _config = configExports; + var _config2 = _interopRequireDefault(_config); + function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : { default: obj }; + } + function recurseRandomWord2(node, prefix) { + var word = prefix; + var branches = Object.keys(node); + var branch = branches[Math.floor(Math.random() * branches.length)]; + if (branch === _config2.default.END_WORD) { + return word; + } + return recurseRandomWord2(node[branch], prefix + branch); + } + module2.exports = exports2["default"]; +})(recurseRandomWord, recurseRandomWord.exports); +var recurseRandomWordExports = recurseRandomWord.exports; +var permutations = { exports: {} }; +(function(module2, exports2) { + Object.defineProperty(exports2, "__esModule", { + value: true + }); + var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function(obj) { + return typeof obj; + } : function(obj) { + return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; + }; + exports2.default = permutations2; + var _config = configExports; + var _config2 = _interopRequireDefault(_config); + function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : { default: obj }; + } + function permutations2(letters, trie) { + var opts = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : { + type: "anagram" + }; + if (typeof letters !== "string") { + throw "Permutations expects string letters, received " + (typeof letters === "undefined" ? "undefined" : _typeof(letters)); + } + var words = []; + var permute = function permute2(word, node) { + var prefix = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : ""; + var wordIsEmpty = word.length === 0; + var wordFound = words.indexOf(prefix) !== -1; + var endWordFound = node[_config2.default.END_WORD] === 1; + if (wordIsEmpty && endWordFound && !wordFound) { + words.push(prefix); + } + for (var i = 0, len = word.length; i < len; i++) { + var letter = word[i]; + if (opts.type === "sub-anagram") { + if (endWordFound && !(words.indexOf(prefix) !== -1)) { + words.push(prefix); + } + } + if (node[letter]) { + var remaining = word.substring(0, i) + word.substring(i + 1, len); + permute2(remaining, node[letter], prefix + letter, words); + } + } + return words.sort(); + }; + return permute(letters, trie); + } + module2.exports = exports2["default"]; +})(permutations, permutations.exports); +var permutationsExports = permutations.exports; +(function(module2, exports2) { + Object.defineProperty(exports2, "__esModule", { + value: true + }); + var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function(obj) { + return typeof obj; + } : function(obj) { + return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; + }; + exports2.default = function(input) { + if (!Array.isArray(input)) { + throw "Expected parameter Array, received " + (typeof input === "undefined" ? "undefined" : _typeof(input)); + } + var trie = (0, _create2.default)([].concat(_toConsumableArray(input))); + return { + /** + * Get the generated raw trie object + */ + tree: function tree() { + return trie; + }, + /** + * Get a string representation of the trie + */ + dump: function dump() { + var spacer = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : 0; + return _utils2.default.stringify(trie, spacer); + }, + /** + * Add a new word to the trie + */ + addWord: function addWord(word) { + if (typeof word !== "string" || word === "") { + throw "Expected parameter string, received " + (typeof word === "undefined" ? "undefined" : _typeof(word)); + } + var reducer = function reducer2() { + return _append2.default.apply(void 0, arguments); + }; + var input2 = word.toLowerCase().split(""); + input2.reduce(reducer, trie); + return this; + }, + /** + * Remove an existing word from the trie + */ + removeWord: function removeWord(word) { + if (typeof word !== "string" || word === "") { + throw "Expected parameter string, received " + (typeof word === "undefined" ? "undefined" : _typeof(word)); + } + var _checkPrefix = (0, _checkPrefix6.default)(trie, word), prefixFound = _checkPrefix.prefixFound, prefixNode = _checkPrefix.prefixNode; + if (prefixFound) { + delete prefixNode[_config2.default.END_WORD]; + } + return this; + }, + /** + * Check a prefix is valid + * @returns Boolean + */ + isPrefix: function isPrefix(prefix) { + if (typeof prefix !== "string") { + throw "Expected string prefix, received " + (typeof prefix === "undefined" ? "undefined" : _typeof(prefix)); + } + var _checkPrefix2 = (0, _checkPrefix6.default)(trie, prefix), prefixFound = _checkPrefix2.prefixFound; + return prefixFound; + }, + /** + * Get a list of all words in the trie with the given prefix + * @returns Array + */ + getPrefix: function getPrefix(strPrefix) { + var sorted = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : true; + if (typeof strPrefix !== "string") { + throw "Expected string prefix, received " + (typeof strPrefix === "undefined" ? "undefined" : _typeof(strPrefix)); + } + if (typeof sorted !== "boolean") { + throw "Expected sort parameter as boolean, received " + (typeof sorted === "undefined" ? "undefined" : _typeof(sorted)); + } + if (!this.isPrefix(strPrefix)) { + return []; + } + var prefixNode = strPrefix.length ? (0, _checkPrefix6.default)(trie, strPrefix).prefixNode : trie; + return (0, _recursePrefix2.default)(prefixNode, strPrefix, sorted); + }, + /** + * Get a random word in the trie with the given prefix + * @returns Array + */ + getRandomWordWithPrefix: function getRandomWordWithPrefix(strPrefix) { + if (typeof strPrefix !== "string") { + throw "Expected string prefix, received " + (typeof strPrefix === "undefined" ? "undefined" : _typeof(strPrefix)); + } + if (!this.isPrefix(strPrefix)) { + return ""; + } + var _checkPrefix3 = (0, _checkPrefix6.default)(trie, strPrefix), prefixNode = _checkPrefix3.prefixNode; + return (0, _recurseRandomWord2.default)(prefixNode, strPrefix); + }, + /** + * Count the number of words with the given prefixSearch + * @returns Number + */ + countPrefix: function countPrefix(strPrefix) { + var prefixes = this.getPrefix(strPrefix); + return prefixes.length; + }, + /** + * Get all words in the trie + * @returns Array + */ + getWords: function getWords() { + var sorted = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : true; + return this.getPrefix("", sorted); + }, + /** + * Check the existence of a word in the trie + * @returns Boolean + */ + hasWord: function hasWord(word) { + if (typeof word !== "string") { + throw "Expected string word, received " + (typeof word === "undefined" ? "undefined" : _typeof(word)); + } + var _checkPrefix4 = (0, _checkPrefix6.default)(trie, word), prefixFound = _checkPrefix4.prefixFound, prefixNode = _checkPrefix4.prefixNode; + if (prefixFound) { + return prefixNode[_config2.default.END_WORD] === 1; + } + return false; + }, + /** + * Get a list of valid anagrams that can be made from the given letters + * @returns Array + */ + getAnagrams: function getAnagrams(letters) { + if (typeof letters !== "string") { + throw "Anagrams expected string letters, received " + (typeof letters === "undefined" ? "undefined" : _typeof(letters)); + } + if (letters.length < PERMS_MIN_LEN) { + throw "getAnagrams expects at least " + PERMS_MIN_LEN + " letters"; + } + return (0, _permutations2.default)(letters, trie, { + type: "anagram" + }); + }, + /** + * Get a list of all sub-anagrams that can be made from the given letters + * @returns Array + */ + getSubAnagrams: function getSubAnagrams(letters) { + if (typeof letters !== "string") { + throw "Expected string letters, received " + (typeof letters === "undefined" ? "undefined" : _typeof(letters)); + } + if (letters.length < PERMS_MIN_LEN) { + throw "getSubAnagrams expects at least " + PERMS_MIN_LEN + " letters"; + } + return (0, _permutations2.default)(letters, trie, { + type: "sub-anagram" + }); + } + }; + }; + var _create = createExports; + var _create2 = _interopRequireDefault(_create); + var _append = appendExports; + var _append2 = _interopRequireDefault(_append); + var _checkPrefix5 = checkPrefixExports; + var _checkPrefix6 = _interopRequireDefault(_checkPrefix5); + var _recursePrefix = recursePrefixExports; + var _recursePrefix2 = _interopRequireDefault(_recursePrefix); + var _recurseRandomWord = recurseRandomWordExports; + var _recurseRandomWord2 = _interopRequireDefault(_recurseRandomWord); + var _utils = utilsExports; + var _utils2 = _interopRequireDefault(_utils); + var _config = configExports; + var _config2 = _interopRequireDefault(_config); + var _permutations = permutationsExports; + var _permutations2 = _interopRequireDefault(_permutations); + function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : { default: obj }; + } + function _toConsumableArray(arr) { + if (Array.isArray(arr)) { + for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { + arr2[i] = arr[i]; + } + return arr2; + } else { + return Array.from(arr); + } + } + var PERMS_MIN_LEN = _config2.default.PERMS_MIN_LEN; + module2.exports = exports2["default"]; +})(dist, dist.exports); +function scan(nodes, token, options2) { + const { startIndex, onlySkipWhitespaceAndComments, allowSubstringMatches } = options2 || {}; + if (typeof token === "string") { + token = { type: "string", content: token }; + } + for (let i = startIndex || 0; i < nodes.length; i++) { + const node = nodes[i]; + if (node.type === token.type) { + switch (node.type) { + case "comment": + case "displaymath": + case "inlinemath": + case "root": + case "parbreak": + case "whitespace": + case "verb": + case "verbatim": + case "group": + return i; + case "macro": + if (node.content === token.content) { + return i; + } + break; + case "environment": + case "mathenv": + if (printRaw(node.env) === printRaw(token.env)) { + return i; + } + break; + case "string": + if (node.content === token.content) { + return i; + } + if (allowSubstringMatches && node.content.indexOf(token.content) >= 0) { + return i; + } + break; + } + } + if (onlySkipWhitespaceAndComments && !match.whitespace(node) && !match.comment(node)) { + return null; + } + } + return null; +} +function updateRenderInfo(node, renderInfo) { + if (renderInfo != null) { + node._renderInfo = { ...node._renderInfo || {}, ...renderInfo }; + } + return node; +} +function gobbleSingleArgument(nodes, argSpec, startPos = 0) { + if (typeof argSpec === "string" || !argSpec.type) { + throw new Error( + `argSpec must be an already-parsed argument specification, not "${JSON.stringify( + argSpec + )}"` + ); + } + let argument = null; + let currPos = startPos; + const gobbleWhitespace = argSpec.noLeadingWhitespace ? () => { + } : () => { + while (currPos < nodes.length) { + if (!match.whitespace(nodes[currPos])) { + break; + } + currPos++; + } + }; + const openMark = argSpec.openBrace || ""; + const closeMark = argSpec.closeBrace || ""; + const acceptGroup = (argSpec.type === "mandatory" || argSpec.type === "optional") && openMark === "{" && closeMark === "}"; + function findBracePositions() { + let openMarkPos = null; + if (openMark) { + openMarkPos = nodes.findIndex( + (node, i) => i >= currPos && match.string(node, openMark) + ); + if (openMarkPos < currPos) { + openMarkPos = null; + } + } + let closeMarkPos = null; + if (openMarkPos != null) { + closeMarkPos = nodes.findIndex( + (node, i) => i >= openMarkPos + 1 && match.string(node, closeMark) + ); + if (closeMarkPos < openMarkPos + 1) { + closeMarkPos = null; + } + } + return [openMarkPos, closeMarkPos]; + } + gobbleWhitespace(); + const currNode = nodes[currPos]; + if (currNode == null || match.comment(currNode) || match.parbreak(currNode)) { + return { argument, nodesRemoved: 0 }; + } + switch (argSpec.type) { + case "mandatory": + if (acceptGroup) { + let content = [currNode]; + if (match.group(currNode)) { + content = currNode.content; + } + argument = arg(content, { + openMark, + closeMark + }); + currPos++; + break; + } + case "optional": + if (acceptGroup && match.group(currNode)) { + argument = arg(currNode.content, { + openMark, + closeMark + }); + currPos++; + break; + } + if (match.string(currNode, openMark)) { + const [openMarkPos, closeMarkPos] = findBracePositions(); + if (openMarkPos != null && closeMarkPos != null) { + argument = arg(nodes.slice(openMarkPos + 1, closeMarkPos), { + openMark, + closeMark + }); + currPos = closeMarkPos + 1; + break; + } + } + break; + case "optionalStar": + case "optionalToken": + if (match.string( + currNode, + argSpec.type === "optionalStar" ? "*" : argSpec.token + )) { + argument = arg([currNode], { openMark: "", closeMark: "" }); + currPos++; + break; + } + break; + case "until": { + if (argSpec.stopTokens.length > 1) { + console.warn( + `"until" matches with multi-token stop conditions are not yet implemented` + ); + break; + } + const rawToken = argSpec.stopTokens[0]; + const stopToken = rawToken === " " ? { type: "whitespace" } : { type: "string", content: argSpec.stopTokens[0] }; + let matchPos = scan(nodes, stopToken, { + startIndex: startPos, + allowSubstringMatches: true + }); + if (matchPos != null && partialStringMatch(nodes[matchPos], stopToken)) { + console.warn( + `"until" arguments that stop at non-punctuation symbols is not yet implemented` + ); + break; + } + if (matchPos == null) { + break; + } + argument = arg(nodes.slice(startPos, matchPos), { + openMark: "", + closeMark: rawToken + }); + currPos = matchPos; + if (currPos < nodes.length) { + currPos++; + } + break; + } + default: + console.warn( + `Don't know how to find an argument of argspec type "${argSpec.type}"` + ); + } + const nodesRemoved = argument ? currPos - startPos : 0; + nodes.splice(startPos, nodesRemoved); + return { argument, nodesRemoved }; +} +function partialStringMatch(node, token) { + return match.anyString(node) && match.anyString(token) && node.content.length > token.content.length; +} +function gobbleArguments(nodes, argSpec, startPos = 0) { + if (typeof argSpec === "function") { + return argSpec(nodes, startPos); + } + if (typeof argSpec === "string") { + argSpec = parse$2(argSpec); + } + const args = []; + let nodesRemoved = 0; + for (const spec of argSpec) { + const { argument, nodesRemoved: removed } = gobbleSingleArgument( + nodes, + spec, + startPos + ); + if (argument) { + args.push(argument); + nodesRemoved += removed; + } else { + args.push(arg([], { openMark: "", closeMark: "" })); + } + } + return { args, nodesRemoved }; +} +function attachMacroArgsInArray(nodes, macros17) { + let currIndex; + const isRelevantMacro = match.createMacroMatcher(macros17); + function gobbleUntilMacro() { + while (currIndex >= 0 && !isRelevantMacro(nodes[currIndex])) { + currIndex--; + } + } + currIndex = nodes.length - 1; + while (currIndex >= 0) { + gobbleUntilMacro(); + if (currIndex < 0) { + return; + } + const macroIndex = currIndex; + const macro = nodes[macroIndex]; + const macroName = macro.content; + const macroInfo2 = macros17[macroName]; + updateRenderInfo(macro, macroInfo2.renderInfo); + const signatureOrParser = macroInfo2.argumentParser || macroInfo2.signature; + if (signatureOrParser == null) { + currIndex--; + continue; + } + if (macro.args != null) { + currIndex = macroIndex - 1; + continue; + } + currIndex++; + const { args } = gobbleArguments(nodes, signatureOrParser, currIndex); + macro.args = args; + currIndex = macroIndex - 1; + } +} +parse$2("o")[0]; +function createMatchers$3() { + return { + isChar: match.string, + isTerminal: (node) => match.string(node, ";"), + isOperation: (node) => match.anyString(node) && node.content.match(/[a-zA-Z]/), + isWhitespace: (node) => match.whitespace(node) || match.parbreak(node), + isComment: match.comment, + isGroup: match.group, + isMacro: match.macro, + isAnyMacro: match.anyMacro + }; +} +var matchers = createMatchers$3(); +function parse$1(ast, options2) { + const { startRule = "path_spec" } = options2 || {}; + if (!Array.isArray(ast)) { + throw new Error("You must pass an array of nodes"); + } + ast = decorateArrayForPegjs([...ast]); + return TikzPegParser.parse(ast, { + ...matchers, + startRule + }); +} +function createMatchers$2() { + return { + isChar: (node, char) => match.string(node, char), + isComma: (node) => match.string(node, ","), + isEquals: (node) => match.string(node, "="), + isWhitespace: (node) => match.whitespace(node), + isParbreak: (node) => match.parbreak(node), + isSameLineComment: (node) => match.comment(node) && node.sameline, + isOwnLineComment: (node) => match.comment(node) && !node.sameline + }; +} +function parsePgfkeys(ast, options2) { + if (!Array.isArray(ast)) { + throw new Error("You must pass an array of nodes"); + } + const { allowParenGroups = false } = options2 || {}; + ast = decorateArrayForPegjs([...ast]); + return PgfkeysPegParser.parse(ast, { + ...createMatchers$2(), + allowParenGroups + }); +} +function createMatchers$1(rowSepMacros, colSep) { + const isRowSep = match.createMacroMatcher(rowSepMacros); + return { + isRowSep, + isColSep: (node) => colSep.some((sep) => match.string(node, sep)), + isWhitespace: (node) => match.whitespace(node), + isSameLineComment: (node) => match.comment(node) && node.sameline, + isOwnLineComment: (node) => match.comment(node) && !node.sameline + }; +} +function parseAlignEnvironment(ast, colSep = ["&"], rowSepMacros = ["\\", "hline", "cr"]) { + if (!Array.isArray(ast)) { + throw new Error("You must pass an array of nodes"); + } + ast = decorateArrayForPegjs([...ast]); + return AlignEnvironmentPegParser.parse( + ast, + createMatchers$1(rowSepMacros, colSep) + ); +} +function bail(error) { + if (error) { + throw error; + } +} +/*! + * Determine if an object is a Buffer + * + * @author Feross Aboukhadijeh + * @license MIT + */ +var isBuffer = function isBuffer2(obj) { + return obj != null && obj.constructor != null && typeof obj.constructor.isBuffer === "function" && obj.constructor.isBuffer(obj); +}; +const isBuffer$1 = /* @__PURE__ */ getDefaultExportFromCjs(isBuffer); +var hasOwn = Object.prototype.hasOwnProperty; +var toStr = Object.prototype.toString; +var defineProperty = Object.defineProperty; +var gOPD = Object.getOwnPropertyDescriptor; +var isArray = function isArray2(arr) { + if (typeof Array.isArray === "function") { + return Array.isArray(arr); + } + return toStr.call(arr) === "[object Array]"; +}; +var isPlainObject$1 = function isPlainObject(obj) { + if (!obj || toStr.call(obj) !== "[object Object]") { + return false; + } + var hasOwnConstructor = hasOwn.call(obj, "constructor"); + var hasIsPrototypeOf = obj.constructor && obj.constructor.prototype && hasOwn.call(obj.constructor.prototype, "isPrototypeOf"); + if (obj.constructor && !hasOwnConstructor && !hasIsPrototypeOf) { + return false; + } + var key; + for (key in obj) { + } + return typeof key === "undefined" || hasOwn.call(obj, key); +}; +var setProperty = function setProperty2(target, options2) { + if (defineProperty && options2.name === "__proto__") { + defineProperty(target, options2.name, { + enumerable: true, + configurable: true, + value: options2.newValue, + writable: true + }); + } else { + target[options2.name] = options2.newValue; + } +}; +var getProperty = function getProperty2(obj, name) { + if (name === "__proto__") { + if (!hasOwn.call(obj, name)) { + return void 0; + } else if (gOPD) { + return gOPD(obj, name).value; + } + } + return obj[name]; +}; +var extend = function extend2() { + var options2, name, src, copy, copyIsArray, clone; + var target = arguments[0]; + var i = 1; + var length = arguments.length; + var deep = false; + if (typeof target === "boolean") { + deep = target; + target = arguments[1] || {}; + i = 2; + } + if (target == null || typeof target !== "object" && typeof target !== "function") { + target = {}; + } + for (; i < length; ++i) { + options2 = arguments[i]; + if (options2 != null) { + for (name in options2) { + src = getProperty(target, name); + copy = getProperty(options2, name); + if (target !== copy) { + if (deep && copy && (isPlainObject$1(copy) || (copyIsArray = isArray(copy)))) { + if (copyIsArray) { + copyIsArray = false; + clone = src && isArray(src) ? src : []; + } else { + clone = src && isPlainObject$1(src) ? src : {}; + } + setProperty(target, { name, newValue: extend2(deep, clone, copy) }); + } else if (typeof copy !== "undefined") { + setProperty(target, { name, newValue: copy }); + } + } + } + } + } + return target; +}; +const extend$1 = /* @__PURE__ */ getDefaultExportFromCjs(extend); +function isPlainObject2(value) { + if (typeof value !== "object" || value === null) { + return false; + } + const prototype = Object.getPrototypeOf(value); + return (prototype === null || prototype === Object.prototype || Object.getPrototypeOf(prototype) === null) && !(Symbol.toStringTag in value) && !(Symbol.iterator in value); +} +function trough() { + const fns = []; + const pipeline = { run, use }; + return pipeline; + function run(...values) { + let middlewareIndex = -1; + const callback = values.pop(); + if (typeof callback !== "function") { + throw new TypeError("Expected function as last argument, not " + callback); + } + next(null, ...values); + function next(error, ...output) { + const fn = fns[++middlewareIndex]; + let index2 = -1; + if (error) { + callback(error); + return; + } + while (++index2 < values.length) { + if (output[index2] === null || output[index2] === void 0) { + output[index2] = values[index2]; + } + } + values = output; + if (fn) { + wrap(fn, next)(...output); + } else { + callback(null, ...output); + } + } + } + function use(middelware) { + if (typeof middelware !== "function") { + throw new TypeError( + "Expected `middelware` to be a function, not " + middelware + ); + } + fns.push(middelware); + return pipeline; + } +} +function wrap(middleware, callback) { + let called; + return wrapped; + function wrapped(...parameters) { + const fnExpectsCallback = middleware.length > parameters.length; + let result; + if (fnExpectsCallback) { + parameters.push(done); + } + try { + result = middleware.apply(this, parameters); + } catch (error) { + const exception = ( + /** @type {Error} */ + error + ); + if (fnExpectsCallback && called) { + throw exception; + } + return done(exception); + } + if (!fnExpectsCallback) { + if (result instanceof Promise) { + result.then(then, done); + } else if (result instanceof Error) { + done(result); + } else { + then(result); + } + } + } + function done(error, ...output) { + if (!called) { + called = true; + callback(error, ...output); + } + } + function then(value) { + done(null, value); + } +} +function stringifyPosition(value) { + if (!value || typeof value !== "object") { + return ""; + } + if ("position" in value || "type" in value) { + return position(value.position); + } + if ("start" in value || "end" in value) { + return position(value); + } + if ("line" in value || "column" in value) { + return point(value); + } + return ""; +} +function point(point2) { + return index(point2 && point2.line) + ":" + index(point2 && point2.column); +} +function position(pos) { + return point(pos && pos.start) + "-" + point(pos && pos.end); +} +function index(value) { + return value && typeof value === "number" ? value : 1; +} +class VFileMessage extends Error { + /** + * Create a message for `reason` at `place` from `origin`. + * + * When an error is passed in as `reason`, the `stack` is copied. + * + * @param {string | Error | VFileMessage} reason + * Reason for message, uses the stack and message of the error if given. + * + * > 👉 **Note**: you should use markdown. + * @param {Node | NodeLike | Position | Point | null | undefined} [place] + * Place in file where the message occurred. + * @param {string | null | undefined} [origin] + * Place in code where the message originates (example: + * `'my-package:my-rule'` or `'my-rule'`). + * @returns + * Instance of `VFileMessage`. + */ + // To do: next major: expose `undefined` everywhere instead of `null`. + constructor(reason, place, origin) { + const parts = [null, null]; + let position2 = { + // @ts-expect-error: we always follows the structure of `position`. + start: { line: null, column: null }, + // @ts-expect-error: " + end: { line: null, column: null } + }; + super(); + if (typeof place === "string") { + origin = place; + place = void 0; + } + if (typeof origin === "string") { + const index2 = origin.indexOf(":"); + if (index2 === -1) { + parts[1] = origin; + } else { + parts[0] = origin.slice(0, index2); + parts[1] = origin.slice(index2 + 1); + } + } + if (place) { + if ("type" in place || "position" in place) { + if (place.position) { + position2 = place.position; + } + } else if ("start" in place || "end" in place) { + position2 = place; + } else if ("line" in place || "column" in place) { + position2.start = place; + } + } + this.name = stringifyPosition(place) || "1:1"; + this.message = typeof reason === "object" ? reason.message : reason; + this.stack = ""; + if (typeof reason === "object" && reason.stack) { + this.stack = reason.stack; + } + this.reason = this.message; + this.fatal; + this.line = position2.start.line; + this.column = position2.start.column; + this.position = position2; + this.source = parts[0]; + this.ruleId = parts[1]; + this.file; + this.actual; + this.expected; + this.url; + this.note; + } +} +VFileMessage.prototype.file = ""; +VFileMessage.prototype.name = ""; +VFileMessage.prototype.reason = ""; +VFileMessage.prototype.message = ""; +VFileMessage.prototype.stack = ""; +VFileMessage.prototype.fatal = null; +VFileMessage.prototype.column = null; +VFileMessage.prototype.line = null; +VFileMessage.prototype.source = null; +VFileMessage.prototype.ruleId = null; +VFileMessage.prototype.position = null; +const path = { basename, dirname, extname, join: join$1, sep: "/" }; +function basename(path2, ext) { + if (ext !== void 0 && typeof ext !== "string") { + throw new TypeError('"ext" argument must be a string'); + } + assertPath$1(path2); + let start = 0; + let end = -1; + let index2 = path2.length; + let seenNonSlash; + if (ext === void 0 || ext.length === 0 || ext.length > path2.length) { + while (index2--) { + if (path2.charCodeAt(index2) === 47) { + if (seenNonSlash) { + start = index2 + 1; + break; + } + } else if (end < 0) { + seenNonSlash = true; + end = index2 + 1; + } + } + return end < 0 ? "" : path2.slice(start, end); + } + if (ext === path2) { + return ""; + } + let firstNonSlashEnd = -1; + let extIndex = ext.length - 1; + while (index2--) { + if (path2.charCodeAt(index2) === 47) { + if (seenNonSlash) { + start = index2 + 1; + break; + } + } else { + if (firstNonSlashEnd < 0) { + seenNonSlash = true; + firstNonSlashEnd = index2 + 1; + } + if (extIndex > -1) { + if (path2.charCodeAt(index2) === ext.charCodeAt(extIndex--)) { + if (extIndex < 0) { + end = index2; + } + } else { + extIndex = -1; + end = firstNonSlashEnd; + } + } + } + } + if (start === end) { + end = firstNonSlashEnd; + } else if (end < 0) { + end = path2.length; + } + return path2.slice(start, end); +} +function dirname(path2) { + assertPath$1(path2); + if (path2.length === 0) { + return "."; + } + let end = -1; + let index2 = path2.length; + let unmatchedSlash; + while (--index2) { + if (path2.charCodeAt(index2) === 47) { + if (unmatchedSlash) { + end = index2; + break; + } + } else if (!unmatchedSlash) { + unmatchedSlash = true; + } + } + return end < 0 ? path2.charCodeAt(0) === 47 ? "/" : "." : end === 1 && path2.charCodeAt(0) === 47 ? "//" : path2.slice(0, end); +} +function extname(path2) { + assertPath$1(path2); + let index2 = path2.length; + let end = -1; + let startPart = 0; + let startDot = -1; + let preDotState = 0; + let unmatchedSlash; + while (index2--) { + const code = path2.charCodeAt(index2); + if (code === 47) { + if (unmatchedSlash) { + startPart = index2 + 1; + break; + } + continue; + } + if (end < 0) { + unmatchedSlash = true; + end = index2 + 1; + } + if (code === 46) { + if (startDot < 0) { + startDot = index2; + } else if (preDotState !== 1) { + preDotState = 1; + } + } else if (startDot > -1) { + preDotState = -1; + } + } + if (startDot < 0 || end < 0 || // We saw a non-dot character immediately before the dot. + preDotState === 0 || // The (right-most) trimmed path component is exactly `..`. + preDotState === 1 && startDot === end - 1 && startDot === startPart + 1) { + return ""; + } + return path2.slice(startDot, end); +} +function join$1(...segments) { + let index2 = -1; + let joined; + while (++index2 < segments.length) { + assertPath$1(segments[index2]); + if (segments[index2]) { + joined = joined === void 0 ? segments[index2] : joined + "/" + segments[index2]; + } + } + return joined === void 0 ? "." : normalize(joined); +} +function normalize(path2) { + assertPath$1(path2); + const absolute = path2.charCodeAt(0) === 47; + let value = normalizeString(path2, !absolute); + if (value.length === 0 && !absolute) { + value = "."; + } + if (value.length > 0 && path2.charCodeAt(path2.length - 1) === 47) { + value += "/"; + } + return absolute ? "/" + value : value; +} +function normalizeString(path2, allowAboveRoot) { + let result = ""; + let lastSegmentLength = 0; + let lastSlash = -1; + let dots = 0; + let index2 = -1; + let code; + let lastSlashIndex; + while (++index2 <= path2.length) { + if (index2 < path2.length) { + code = path2.charCodeAt(index2); + } else if (code === 47) { + break; + } else { + code = 47; + } + if (code === 47) { + if (lastSlash === index2 - 1 || dots === 1) + ; + else if (lastSlash !== index2 - 1 && dots === 2) { + if (result.length < 2 || lastSegmentLength !== 2 || result.charCodeAt(result.length - 1) !== 46 || result.charCodeAt(result.length - 2) !== 46) { + if (result.length > 2) { + lastSlashIndex = result.lastIndexOf("/"); + if (lastSlashIndex !== result.length - 1) { + if (lastSlashIndex < 0) { + result = ""; + lastSegmentLength = 0; + } else { + result = result.slice(0, lastSlashIndex); + lastSegmentLength = result.length - 1 - result.lastIndexOf("/"); + } + lastSlash = index2; + dots = 0; + continue; + } + } else if (result.length > 0) { + result = ""; + lastSegmentLength = 0; + lastSlash = index2; + dots = 0; + continue; + } + } + if (allowAboveRoot) { + result = result.length > 0 ? result + "/.." : ".."; + lastSegmentLength = 2; + } + } else { + if (result.length > 0) { + result += "/" + path2.slice(lastSlash + 1, index2); + } else { + result = path2.slice(lastSlash + 1, index2); + } + lastSegmentLength = index2 - lastSlash - 1; + } + lastSlash = index2; + dots = 0; + } else if (code === 46 && dots > -1) { + dots++; + } else { + dots = -1; + } + } + return result; +} +function assertPath$1(path2) { + if (typeof path2 !== "string") { + throw new TypeError( + "Path must be a string. Received " + JSON.stringify(path2) + ); + } +} +const proc = { cwd }; +function cwd() { + return "/"; +} +function isUrl(fileUrlOrPath) { + return fileUrlOrPath !== null && typeof fileUrlOrPath === "object" && // @ts-expect-error: indexable. + fileUrlOrPath.href && // @ts-expect-error: indexable. + fileUrlOrPath.origin; +} +function urlToPath(path2) { + if (typeof path2 === "string") { + path2 = new URL(path2); + } else if (!isUrl(path2)) { + const error = new TypeError( + 'The "path" argument must be of type string or an instance of URL. Received `' + path2 + "`" + ); + error.code = "ERR_INVALID_ARG_TYPE"; + throw error; + } + if (path2.protocol !== "file:") { + const error = new TypeError("The URL must be of scheme file"); + error.code = "ERR_INVALID_URL_SCHEME"; + throw error; + } + return getPathFromURLPosix(path2); +} +function getPathFromURLPosix(url) { + if (url.hostname !== "") { + const error = new TypeError( + 'File URL host must be "localhost" or empty on darwin' + ); + error.code = "ERR_INVALID_FILE_URL_HOST"; + throw error; + } + const pathname = url.pathname; + let index2 = -1; + while (++index2 < pathname.length) { + if (pathname.charCodeAt(index2) === 37 && pathname.charCodeAt(index2 + 1) === 50) { + const third = pathname.charCodeAt(index2 + 2); + if (third === 70 || third === 102) { + const error = new TypeError( + "File URL path must not include encoded / characters" + ); + error.code = "ERR_INVALID_FILE_URL_PATH"; + throw error; + } + } + } + return decodeURIComponent(pathname); +} +const order = ["history", "path", "basename", "stem", "extname", "dirname"]; +class VFile { + /** + * Create a new virtual file. + * + * `options` is treated as: + * + * * `string` or `Buffer` — `{value: options}` + * * `URL` — `{path: options}` + * * `VFile` — shallow copies its data over to the new file + * * `object` — all fields are shallow copied over to the new file + * + * Path related fields are set in the following order (least specific to + * most specific): `history`, `path`, `basename`, `stem`, `extname`, + * `dirname`. + * + * You cannot set `dirname` or `extname` without setting either `history`, + * `path`, `basename`, or `stem` too. + * + * @param {Compatible | null | undefined} [value] + * File value. + * @returns + * New instance. + */ + constructor(value) { + let options2; + if (!value) { + options2 = {}; + } else if (typeof value === "string" || buffer(value)) { + options2 = { value }; + } else if (isUrl(value)) { + options2 = { path: value }; + } else { + options2 = value; + } + this.data = {}; + this.messages = []; + this.history = []; + this.cwd = proc.cwd(); + this.value; + this.stored; + this.result; + this.map; + let index2 = -1; + while (++index2 < order.length) { + const prop2 = order[index2]; + if (prop2 in options2 && options2[prop2] !== void 0 && options2[prop2] !== null) { + this[prop2] = prop2 === "history" ? [...options2[prop2]] : options2[prop2]; + } + } + let prop; + for (prop in options2) { + if (!order.includes(prop)) { + this[prop] = options2[prop]; + } + } + } + /** + * Get the full path (example: `'~/index.min.js'`). + * + * @returns {string} + */ + get path() { + return this.history[this.history.length - 1]; + } + /** + * Set the full path (example: `'~/index.min.js'`). + * + * Cannot be nullified. + * You can set a file URL (a `URL` object with a `file:` protocol) which will + * be turned into a path with `url.fileURLToPath`. + * + * @param {string | URL} path + */ + set path(path2) { + if (isUrl(path2)) { + path2 = urlToPath(path2); + } + assertNonEmpty(path2, "path"); + if (this.path !== path2) { + this.history.push(path2); + } + } + /** + * Get the parent path (example: `'~'`). + */ + get dirname() { + return typeof this.path === "string" ? path.dirname(this.path) : void 0; + } + /** + * Set the parent path (example: `'~'`). + * + * Cannot be set if there’s no `path` yet. + */ + set dirname(dirname2) { + assertPath(this.basename, "dirname"); + this.path = path.join(dirname2 || "", this.basename); + } + /** + * Get the basename (including extname) (example: `'index.min.js'`). + */ + get basename() { + return typeof this.path === "string" ? path.basename(this.path) : void 0; + } + /** + * Set basename (including extname) (`'index.min.js'`). + * + * Cannot contain path separators (`'/'` on unix, macOS, and browsers, `'\'` + * on windows). + * Cannot be nullified (use `file.path = file.dirname` instead). + */ + set basename(basename2) { + assertNonEmpty(basename2, "basename"); + assertPart(basename2, "basename"); + this.path = path.join(this.dirname || "", basename2); + } + /** + * Get the extname (including dot) (example: `'.js'`). + */ + get extname() { + return typeof this.path === "string" ? path.extname(this.path) : void 0; + } + /** + * Set the extname (including dot) (example: `'.js'`). + * + * Cannot contain path separators (`'/'` on unix, macOS, and browsers, `'\'` + * on windows). + * Cannot be set if there’s no `path` yet. + */ + set extname(extname2) { + assertPart(extname2, "extname"); + assertPath(this.dirname, "extname"); + if (extname2) { + if (extname2.charCodeAt(0) !== 46) { + throw new Error("`extname` must start with `.`"); + } + if (extname2.includes(".", 1)) { + throw new Error("`extname` cannot contain multiple dots"); + } + } + this.path = path.join(this.dirname, this.stem + (extname2 || "")); + } + /** + * Get the stem (basename w/o extname) (example: `'index.min'`). + */ + get stem() { + return typeof this.path === "string" ? path.basename(this.path, this.extname) : void 0; + } + /** + * Set the stem (basename w/o extname) (example: `'index.min'`). + * + * Cannot contain path separators (`'/'` on unix, macOS, and browsers, `'\'` + * on windows). + * Cannot be nullified (use `file.path = file.dirname` instead). + */ + set stem(stem) { + assertNonEmpty(stem, "stem"); + assertPart(stem, "stem"); + this.path = path.join(this.dirname || "", stem + (this.extname || "")); + } + /** + * Serialize the file. + * + * @param {BufferEncoding | null | undefined} [encoding='utf8'] + * Character encoding to understand `value` as when it’s a `Buffer` + * (default: `'utf8'`). + * @returns {string} + * Serialized file. + */ + toString(encoding) { + return (this.value || "").toString(encoding || void 0); + } + /** + * Create a warning message associated with the file. + * + * Its `fatal` is set to `false` and `file` is set to the current file path. + * Its added to `file.messages`. + * + * @param {string | Error | VFileMessage} reason + * Reason for message, uses the stack and message of the error if given. + * @param {Node | NodeLike | Position | Point | null | undefined} [place] + * Place in file where the message occurred. + * @param {string | null | undefined} [origin] + * Place in code where the message originates (example: + * `'my-package:my-rule'` or `'my-rule'`). + * @returns {VFileMessage} + * Message. + */ + message(reason, place, origin) { + const message = new VFileMessage(reason, place, origin); + if (this.path) { + message.name = this.path + ":" + message.name; + message.file = this.path; + } + message.fatal = false; + this.messages.push(message); + return message; + } + /** + * Create an info message associated with the file. + * + * Its `fatal` is set to `null` and `file` is set to the current file path. + * Its added to `file.messages`. + * + * @param {string | Error | VFileMessage} reason + * Reason for message, uses the stack and message of the error if given. + * @param {Node | NodeLike | Position | Point | null | undefined} [place] + * Place in file where the message occurred. + * @param {string | null | undefined} [origin] + * Place in code where the message originates (example: + * `'my-package:my-rule'` or `'my-rule'`). + * @returns {VFileMessage} + * Message. + */ + info(reason, place, origin) { + const message = this.message(reason, place, origin); + message.fatal = null; + return message; + } + /** + * Create a fatal error associated with the file. + * + * Its `fatal` is set to `true` and `file` is set to the current file path. + * Its added to `file.messages`. + * + * > 👉 **Note**: a fatal error means that a file is no longer processable. + * + * @param {string | Error | VFileMessage} reason + * Reason for message, uses the stack and message of the error if given. + * @param {Node | NodeLike | Position | Point | null | undefined} [place] + * Place in file where the message occurred. + * @param {string | null | undefined} [origin] + * Place in code where the message originates (example: + * `'my-package:my-rule'` or `'my-rule'`). + * @returns {never} + * Message. + * @throws {VFileMessage} + * Message. + */ + fail(reason, place, origin) { + const message = this.message(reason, place, origin); + message.fatal = true; + throw message; + } +} +function assertPart(part, name) { + if (part && part.includes(path.sep)) { + throw new Error( + "`" + name + "` cannot be a path: did not expect `" + path.sep + "`" + ); + } +} +function assertNonEmpty(part, name) { + if (!part) { + throw new Error("`" + name + "` cannot be empty"); + } +} +function assertPath(path2, name) { + if (!path2) { + throw new Error("Setting `" + name + "` requires `path` to be set too"); + } +} +function buffer(value) { + return isBuffer$1(value); +} +const unified = base().freeze(); +const own = {}.hasOwnProperty; +function base() { + const transformers = trough(); + const attachers = []; + let namespace = {}; + let frozen; + let freezeIndex = -1; + processor.data = data; + processor.Parser = void 0; + processor.Compiler = void 0; + processor.freeze = freeze; + processor.attachers = attachers; + processor.use = use; + processor.parse = parse2; + processor.stringify = stringify; + processor.run = run; + processor.runSync = runSync; + processor.process = process; + processor.processSync = processSync; + return processor; + function processor() { + const destination = base(); + let index2 = -1; + while (++index2 < attachers.length) { + destination.use(...attachers[index2]); + } + destination.data(extend$1(true, {}, namespace)); + return destination; + } + function data(key, value) { + if (typeof key === "string") { + if (arguments.length === 2) { + assertUnfrozen("data", frozen); + namespace[key] = value; + return processor; + } + return own.call(namespace, key) && namespace[key] || null; + } + if (key) { + assertUnfrozen("data", frozen); + namespace = key; + return processor; + } + return namespace; + } + function freeze() { + if (frozen) { + return processor; + } + while (++freezeIndex < attachers.length) { + const [attacher, ...options2] = attachers[freezeIndex]; + if (options2[0] === false) { + continue; + } + if (options2[0] === true) { + options2[0] = void 0; + } + const transformer = attacher.call(processor, ...options2); + if (typeof transformer === "function") { + transformers.use(transformer); + } + } + frozen = true; + freezeIndex = Number.POSITIVE_INFINITY; + return processor; + } + function use(value, ...options2) { + let settings; + assertUnfrozen("use", frozen); + if (value === null || value === void 0) + ; + else if (typeof value === "function") { + addPlugin(value, ...options2); + } else if (typeof value === "object") { + if (Array.isArray(value)) { + addList(value); + } else { + addPreset(value); + } + } else { + throw new TypeError("Expected usable value, not `" + value + "`"); + } + if (settings) { + namespace.settings = Object.assign(namespace.settings || {}, settings); + } + return processor; + function add(value2) { + if (typeof value2 === "function") { + addPlugin(value2); + } else if (typeof value2 === "object") { + if (Array.isArray(value2)) { + const [plugin, ...options3] = value2; + addPlugin(plugin, ...options3); + } else { + addPreset(value2); + } + } else { + throw new TypeError("Expected usable value, not `" + value2 + "`"); + } + } + function addPreset(result) { + addList(result.plugins); + if (result.settings) { + settings = Object.assign(settings || {}, result.settings); + } + } + function addList(plugins) { + let index2 = -1; + if (plugins === null || plugins === void 0) + ; + else if (Array.isArray(plugins)) { + while (++index2 < plugins.length) { + const thing = plugins[index2]; + add(thing); + } + } else { + throw new TypeError("Expected a list of plugins, not `" + plugins + "`"); + } + } + function addPlugin(plugin, value2) { + let index2 = -1; + let entry; + while (++index2 < attachers.length) { + if (attachers[index2][0] === plugin) { + entry = attachers[index2]; + break; + } + } + if (entry) { + if (isPlainObject2(entry[1]) && isPlainObject2(value2)) { + value2 = extend$1(true, entry[1], value2); + } + entry[1] = value2; + } else { + attachers.push([...arguments]); + } + } + } + function parse2(doc) { + processor.freeze(); + const file = vfile(doc); + const Parser = processor.Parser; + assertParser("parse", Parser); + if (newable(Parser, "parse")) { + return new Parser(String(file), file).parse(); + } + return Parser(String(file), file); + } + function stringify(node, doc) { + processor.freeze(); + const file = vfile(doc); + const Compiler = processor.Compiler; + assertCompiler("stringify", Compiler); + assertNode(node); + if (newable(Compiler, "compile")) { + return new Compiler(node, file).compile(); + } + return Compiler(node, file); + } + function run(node, doc, callback) { + assertNode(node); + processor.freeze(); + if (!callback && typeof doc === "function") { + callback = doc; + doc = void 0; + } + if (!callback) { + return new Promise(executor); + } + executor(null, callback); + function executor(resolve, reject) { + transformers.run(node, vfile(doc), done); + function done(error, tree, file) { + tree = tree || node; + if (error) { + reject(error); + } else if (resolve) { + resolve(tree); + } else { + callback(null, tree, file); + } + } + } + } + function runSync(node, file) { + let result; + let complete; + processor.run(node, file, done); + assertDone("runSync", "run", complete); + return result; + function done(error, tree) { + bail(error); + result = tree; + complete = true; + } + } + function process(doc, callback) { + processor.freeze(); + assertParser("process", processor.Parser); + assertCompiler("process", processor.Compiler); + if (!callback) { + return new Promise(executor); + } + executor(null, callback); + function executor(resolve, reject) { + const file = vfile(doc); + processor.run(processor.parse(file), file, (error, tree, file2) => { + if (error || !tree || !file2) { + done(error); + } else { + const result = processor.stringify(tree, file2); + if (result === void 0 || result === null) + ; + else if (looksLikeAVFileValue(result)) { + file2.value = result; + } else { + file2.result = result; + } + done(error, file2); + } + }); + function done(error, file2) { + if (error || !file2) { + reject(error); + } else if (resolve) { + resolve(file2); + } else { + callback(null, file2); + } + } + } + } + function processSync(doc) { + let complete; + processor.freeze(); + assertParser("processSync", processor.Parser); + assertCompiler("processSync", processor.Compiler); + const file = vfile(doc); + processor.process(file, done); + assertDone("processSync", "process", complete); + return file; + function done(error) { + complete = true; + bail(error); + } + } +} +function newable(value, name) { + return typeof value === "function" && // Prototypes do exist. + // type-coverage:ignore-next-line + value.prototype && // A function with keys in its prototype is probably a constructor. + // Classes’ prototype methods are not enumerable, so we check if some value + // exists in the prototype. + // type-coverage:ignore-next-line + (keys(value.prototype) || name in value.prototype); +} +function keys(value) { + let key; + for (key in value) { + if (own.call(value, key)) { + return true; + } + } + return false; +} +function assertParser(name, value) { + if (typeof value !== "function") { + throw new TypeError("Cannot `" + name + "` without `Parser`"); + } +} +function assertCompiler(name, value) { + if (typeof value !== "function") { + throw new TypeError("Cannot `" + name + "` without `Compiler`"); + } +} +function assertUnfrozen(name, frozen) { + if (frozen) { + throw new Error( + "Cannot call `" + name + "` on a frozen processor.\nCreate a new processor first, by calling it: use `processor()` instead of `processor`." + ); + } +} +function assertNode(node) { + if (!isPlainObject2(node) || typeof node.type !== "string") { + throw new TypeError("Expected node, got `" + node + "`"); + } +} +function assertDone(name, asyncName, complete) { + if (!complete) { + throw new Error( + "`" + name + "` finished async. Use `" + asyncName + "` instead" + ); + } +} +function vfile(value) { + return looksLikeAVFile(value) ? value : new VFile(value); +} +function looksLikeAVFile(value) { + return Boolean( + value && typeof value === "object" && "message" in value && "messages" in value + ); +} +function looksLikeAVFileValue(value) { + return typeof value === "string" || isBuffer$1(value); +} +function splitOnCondition(nodes, splitFunc = () => false, options2) { + if (!Array.isArray(nodes)) { + throw new Error(`Can only split an Array, not ${nodes}`); + } + const { onlySplitOnFirstOccurrence = false } = options2 || {}; + const splitIndices = []; + for (let i = 0; i < nodes.length; i++) { + if (splitFunc(nodes[i])) { + splitIndices.push(i); + if (onlySplitOnFirstOccurrence) { + break; + } + } + } + if (splitIndices.length === 0) { + return { segments: [nodes], separators: [] }; + } + let separators = splitIndices.map((i) => nodes[i]); + let segments = splitIndices.map((splitEnd, i) => { + const splitStart = i === 0 ? 0 : splitIndices[i - 1] + 1; + return nodes.slice(splitStart, splitEnd); + }); + segments.push( + nodes.slice(splitIndices[splitIndices.length - 1] + 1, nodes.length) + ); + return { segments, separators }; +} +function splitOnMacro(ast, macroName) { + if (typeof macroName === "string") { + macroName = [macroName]; + } + if (!Array.isArray(macroName)) { + throw new Error("Type coercion failed"); + } + const isSeparator = match.createMacroMatcher(macroName); + const { segments, separators } = splitOnCondition(ast, isSeparator); + return { segments, macros: separators }; +} +function lastSignificantNodeIndex(nodes, parbreaksAreInsignificant) { + for (let i = nodes.length - 1; i >= 0; i--) { + const node = nodes[i]; + if (match.whitespace(node) || match.comment(node) || parbreaksAreInsignificant && match.parbreak(node)) { + continue; + } + return i; + } + return void 0; +} +var colorString$1 = { exports: {} }; +var colorName = { + "aliceblue": [240, 248, 255], + "antiquewhite": [250, 235, 215], + "aqua": [0, 255, 255], + "aquamarine": [127, 255, 212], + "azure": [240, 255, 255], + "beige": [245, 245, 220], + "bisque": [255, 228, 196], + "black": [0, 0, 0], + "blanchedalmond": [255, 235, 205], + "blue": [0, 0, 255], + "blueviolet": [138, 43, 226], + "brown": [165, 42, 42], + "burlywood": [222, 184, 135], + "cadetblue": [95, 158, 160], + "chartreuse": [127, 255, 0], + "chocolate": [210, 105, 30], + "coral": [255, 127, 80], + "cornflowerblue": [100, 149, 237], + "cornsilk": [255, 248, 220], + "crimson": [220, 20, 60], + "cyan": [0, 255, 255], + "darkblue": [0, 0, 139], + "darkcyan": [0, 139, 139], + "darkgoldenrod": [184, 134, 11], + "darkgray": [169, 169, 169], + "darkgreen": [0, 100, 0], + "darkgrey": [169, 169, 169], + "darkkhaki": [189, 183, 107], + "darkmagenta": [139, 0, 139], + "darkolivegreen": [85, 107, 47], + "darkorange": [255, 140, 0], + "darkorchid": [153, 50, 204], + "darkred": [139, 0, 0], + "darksalmon": [233, 150, 122], + "darkseagreen": [143, 188, 143], + "darkslateblue": [72, 61, 139], + "darkslategray": [47, 79, 79], + "darkslategrey": [47, 79, 79], + "darkturquoise": [0, 206, 209], + "darkviolet": [148, 0, 211], + "deeppink": [255, 20, 147], + "deepskyblue": [0, 191, 255], + "dimgray": [105, 105, 105], + "dimgrey": [105, 105, 105], + "dodgerblue": [30, 144, 255], + "firebrick": [178, 34, 34], + "floralwhite": [255, 250, 240], + "forestgreen": [34, 139, 34], + "fuchsia": [255, 0, 255], + "gainsboro": [220, 220, 220], + "ghostwhite": [248, 248, 255], + "gold": [255, 215, 0], + "goldenrod": [218, 165, 32], + "gray": [128, 128, 128], + "green": [0, 128, 0], + "greenyellow": [173, 255, 47], + "grey": [128, 128, 128], + "honeydew": [240, 255, 240], + "hotpink": [255, 105, 180], + "indianred": [205, 92, 92], + "indigo": [75, 0, 130], + "ivory": [255, 255, 240], + "khaki": [240, 230, 140], + "lavender": [230, 230, 250], + "lavenderblush": [255, 240, 245], + "lawngreen": [124, 252, 0], + "lemonchiffon": [255, 250, 205], + "lightblue": [173, 216, 230], + "lightcoral": [240, 128, 128], + "lightcyan": [224, 255, 255], + "lightgoldenrodyellow": [250, 250, 210], + "lightgray": [211, 211, 211], + "lightgreen": [144, 238, 144], + "lightgrey": [211, 211, 211], + "lightpink": [255, 182, 193], + "lightsalmon": [255, 160, 122], + "lightseagreen": [32, 178, 170], + "lightskyblue": [135, 206, 250], + "lightslategray": [119, 136, 153], + "lightslategrey": [119, 136, 153], + "lightsteelblue": [176, 196, 222], + "lightyellow": [255, 255, 224], + "lime": [0, 255, 0], + "limegreen": [50, 205, 50], + "linen": [250, 240, 230], + "magenta": [255, 0, 255], + "maroon": [128, 0, 0], + "mediumaquamarine": [102, 205, 170], + "mediumblue": [0, 0, 205], + "mediumorchid": [186, 85, 211], + "mediumpurple": [147, 112, 219], + "mediumseagreen": [60, 179, 113], + "mediumslateblue": [123, 104, 238], + "mediumspringgreen": [0, 250, 154], + "mediumturquoise": [72, 209, 204], + "mediumvioletred": [199, 21, 133], + "midnightblue": [25, 25, 112], + "mintcream": [245, 255, 250], + "mistyrose": [255, 228, 225], + "moccasin": [255, 228, 181], + "navajowhite": [255, 222, 173], + "navy": [0, 0, 128], + "oldlace": [253, 245, 230], + "olive": [128, 128, 0], + "olivedrab": [107, 142, 35], + "orange": [255, 165, 0], + "orangered": [255, 69, 0], + "orchid": [218, 112, 214], + "palegoldenrod": [238, 232, 170], + "palegreen": [152, 251, 152], + "paleturquoise": [175, 238, 238], + "palevioletred": [219, 112, 147], + "papayawhip": [255, 239, 213], + "peachpuff": [255, 218, 185], + "peru": [205, 133, 63], + "pink": [255, 192, 203], + "plum": [221, 160, 221], + "powderblue": [176, 224, 230], + "purple": [128, 0, 128], + "rebeccapurple": [102, 51, 153], + "red": [255, 0, 0], + "rosybrown": [188, 143, 143], + "royalblue": [65, 105, 225], + "saddlebrown": [139, 69, 19], + "salmon": [250, 128, 114], + "sandybrown": [244, 164, 96], + "seagreen": [46, 139, 87], + "seashell": [255, 245, 238], + "sienna": [160, 82, 45], + "silver": [192, 192, 192], + "skyblue": [135, 206, 235], + "slateblue": [106, 90, 205], + "slategray": [112, 128, 144], + "slategrey": [112, 128, 144], + "snow": [255, 250, 250], + "springgreen": [0, 255, 127], + "steelblue": [70, 130, 180], + "tan": [210, 180, 140], + "teal": [0, 128, 128], + "thistle": [216, 191, 216], + "tomato": [255, 99, 71], + "turquoise": [64, 224, 208], + "violet": [238, 130, 238], + "wheat": [245, 222, 179], + "white": [255, 255, 255], + "whitesmoke": [245, 245, 245], + "yellow": [255, 255, 0], + "yellowgreen": [154, 205, 50] +}; +var simpleSwizzle = { exports: {} }; +var isArrayish$1 = function isArrayish(obj) { + if (!obj || typeof obj === "string") { + return false; + } + return obj instanceof Array || Array.isArray(obj) || obj.length >= 0 && (obj.splice instanceof Function || Object.getOwnPropertyDescriptor(obj, obj.length - 1) && obj.constructor.name !== "String"); +}; +var isArrayish2 = isArrayish$1; +var concat = Array.prototype.concat; +var slice = Array.prototype.slice; +var swizzle$1 = simpleSwizzle.exports = function swizzle(args) { + var results = []; + for (var i = 0, len = args.length; i < len; i++) { + var arg2 = args[i]; + if (isArrayish2(arg2)) { + results = concat.call(results, slice.call(arg2)); + } else { + results.push(arg2); + } + } + return results; +}; +swizzle$1.wrap = function(fn) { + return function() { + return fn(swizzle$1(arguments)); + }; +}; +var simpleSwizzleExports = simpleSwizzle.exports; +var colorNames = colorName; +var swizzle2 = simpleSwizzleExports; +var hasOwnProperty = Object.hasOwnProperty; +var reverseNames = /* @__PURE__ */ Object.create(null); +for (var name in colorNames) { + if (hasOwnProperty.call(colorNames, name)) { + reverseNames[colorNames[name]] = name; + } +} +var cs = colorString$1.exports = { + to: {}, + get: {} +}; +cs.get = function(string) { + var prefix = string.substring(0, 3).toLowerCase(); + var val; + var model; + switch (prefix) { + case "hsl": + val = cs.get.hsl(string); + model = "hsl"; + break; + case "hwb": + val = cs.get.hwb(string); + model = "hwb"; + break; + default: + val = cs.get.rgb(string); + model = "rgb"; + break; + } + if (!val) { + return null; + } + return { model, value: val }; +}; +cs.get.rgb = function(string) { + if (!string) { + return null; + } + var abbr = /^#([a-f0-9]{3,4})$/i; + var hex = /^#([a-f0-9]{6})([a-f0-9]{2})?$/i; + var rgba = /^rgba?\(\s*([+-]?\d+)(?=[\s,])\s*(?:,\s*)?([+-]?\d+)(?=[\s,])\s*(?:,\s*)?([+-]?\d+)\s*(?:[,|\/]\s*([+-]?[\d\.]+)(%?)\s*)?\)$/; + var per = /^rgba?\(\s*([+-]?[\d\.]+)\%\s*,?\s*([+-]?[\d\.]+)\%\s*,?\s*([+-]?[\d\.]+)\%\s*(?:[,|\/]\s*([+-]?[\d\.]+)(%?)\s*)?\)$/; + var keyword = /^(\w+)$/; + var rgb = [0, 0, 0, 1]; + var match2; + var i; + var hexAlpha; + if (match2 = string.match(hex)) { + hexAlpha = match2[2]; + match2 = match2[1]; + for (i = 0; i < 3; i++) { + var i2 = i * 2; + rgb[i] = parseInt(match2.slice(i2, i2 + 2), 16); + } + if (hexAlpha) { + rgb[3] = parseInt(hexAlpha, 16) / 255; + } + } else if (match2 = string.match(abbr)) { + match2 = match2[1]; + hexAlpha = match2[3]; + for (i = 0; i < 3; i++) { + rgb[i] = parseInt(match2[i] + match2[i], 16); + } + if (hexAlpha) { + rgb[3] = parseInt(hexAlpha + hexAlpha, 16) / 255; + } + } else if (match2 = string.match(rgba)) { + for (i = 0; i < 3; i++) { + rgb[i] = parseInt(match2[i + 1], 0); + } + if (match2[4]) { + if (match2[5]) { + rgb[3] = parseFloat(match2[4]) * 0.01; + } else { + rgb[3] = parseFloat(match2[4]); + } + } + } else if (match2 = string.match(per)) { + for (i = 0; i < 3; i++) { + rgb[i] = Math.round(parseFloat(match2[i + 1]) * 2.55); + } + if (match2[4]) { + if (match2[5]) { + rgb[3] = parseFloat(match2[4]) * 0.01; + } else { + rgb[3] = parseFloat(match2[4]); + } + } + } else if (match2 = string.match(keyword)) { + if (match2[1] === "transparent") { + return [0, 0, 0, 0]; + } + if (!hasOwnProperty.call(colorNames, match2[1])) { + return null; + } + rgb = colorNames[match2[1]]; + rgb[3] = 1; + return rgb; + } else { + return null; + } + for (i = 0; i < 3; i++) { + rgb[i] = clamp(rgb[i], 0, 255); + } + rgb[3] = clamp(rgb[3], 0, 1); + return rgb; +}; +cs.get.hsl = function(string) { + if (!string) { + return null; + } + var hsl = /^hsla?\(\s*([+-]?(?:\d{0,3}\.)?\d+)(?:deg)?\s*,?\s*([+-]?[\d\.]+)%\s*,?\s*([+-]?[\d\.]+)%\s*(?:[,|\/]\s*([+-]?(?=\.\d|\d)(?:0|[1-9]\d*)?(?:\.\d*)?(?:[eE][+-]?\d+)?)\s*)?\)$/; + var match2 = string.match(hsl); + if (match2) { + var alpha = parseFloat(match2[4]); + var h = (parseFloat(match2[1]) % 360 + 360) % 360; + var s2 = clamp(parseFloat(match2[2]), 0, 100); + var l = clamp(parseFloat(match2[3]), 0, 100); + var a = clamp(isNaN(alpha) ? 1 : alpha, 0, 1); + return [h, s2, l, a]; + } + return null; +}; +cs.get.hwb = function(string) { + if (!string) { + return null; + } + var hwb = /^hwb\(\s*([+-]?\d{0,3}(?:\.\d+)?)(?:deg)?\s*,\s*([+-]?[\d\.]+)%\s*,\s*([+-]?[\d\.]+)%\s*(?:,\s*([+-]?(?=\.\d|\d)(?:0|[1-9]\d*)?(?:\.\d*)?(?:[eE][+-]?\d+)?)\s*)?\)$/; + var match2 = string.match(hwb); + if (match2) { + var alpha = parseFloat(match2[4]); + var h = (parseFloat(match2[1]) % 360 + 360) % 360; + var w = clamp(parseFloat(match2[2]), 0, 100); + var b = clamp(parseFloat(match2[3]), 0, 100); + var a = clamp(isNaN(alpha) ? 1 : alpha, 0, 1); + return [h, w, b, a]; + } + return null; +}; +cs.to.hex = function() { + var rgba = swizzle2(arguments); + return "#" + hexDouble(rgba[0]) + hexDouble(rgba[1]) + hexDouble(rgba[2]) + (rgba[3] < 1 ? hexDouble(Math.round(rgba[3] * 255)) : ""); +}; +cs.to.rgb = function() { + var rgba = swizzle2(arguments); + return rgba.length < 4 || rgba[3] === 1 ? "rgb(" + Math.round(rgba[0]) + ", " + Math.round(rgba[1]) + ", " + Math.round(rgba[2]) + ")" : "rgba(" + Math.round(rgba[0]) + ", " + Math.round(rgba[1]) + ", " + Math.round(rgba[2]) + ", " + rgba[3] + ")"; +}; +cs.to.rgb.percent = function() { + var rgba = swizzle2(arguments); + var r = Math.round(rgba[0] / 255 * 100); + var g = Math.round(rgba[1] / 255 * 100); + var b = Math.round(rgba[2] / 255 * 100); + return rgba.length < 4 || rgba[3] === 1 ? "rgb(" + r + "%, " + g + "%, " + b + "%)" : "rgba(" + r + "%, " + g + "%, " + b + "%, " + rgba[3] + ")"; +}; +cs.to.hsl = function() { + var hsla = swizzle2(arguments); + return hsla.length < 4 || hsla[3] === 1 ? "hsl(" + hsla[0] + ", " + hsla[1] + "%, " + hsla[2] + "%)" : "hsla(" + hsla[0] + ", " + hsla[1] + "%, " + hsla[2] + "%, " + hsla[3] + ")"; +}; +cs.to.hwb = function() { + var hwba = swizzle2(arguments); + var a = ""; + if (hwba.length >= 4 && hwba[3] !== 1) { + a = ", " + hwba[3]; + } + return "hwb(" + hwba[0] + ", " + hwba[1] + "%, " + hwba[2] + "%" + a + ")"; +}; +cs.to.keyword = function(rgb) { + return reverseNames[rgb.slice(0, 3)]; +}; +function clamp(num, min, max) { + return Math.min(Math.max(min, num), max); +} +function hexDouble(num) { + var str = Math.round(num).toString(16).toUpperCase(); + return str.length < 2 ? "0" + str : str; +} +var colorStringExports = colorString$1.exports; +const cssKeywords = colorName; +const reverseKeywords = {}; +for (const key of Object.keys(cssKeywords)) { + reverseKeywords[cssKeywords[key]] = key; +} +const convert$2 = { + rgb: { channels: 3, labels: "rgb" }, + hsl: { channels: 3, labels: "hsl" }, + hsv: { channels: 3, labels: "hsv" }, + hwb: { channels: 3, labels: "hwb" }, + cmyk: { channels: 4, labels: "cmyk" }, + xyz: { channels: 3, labels: "xyz" }, + lab: { channels: 3, labels: "lab" }, + lch: { channels: 3, labels: "lch" }, + hex: { channels: 1, labels: ["hex"] }, + keyword: { channels: 1, labels: ["keyword"] }, + ansi16: { channels: 1, labels: ["ansi16"] }, + ansi256: { channels: 1, labels: ["ansi256"] }, + hcg: { channels: 3, labels: ["h", "c", "g"] }, + apple: { channels: 3, labels: ["r16", "g16", "b16"] }, + gray: { channels: 1, labels: ["gray"] } +}; +var conversions$2 = convert$2; +for (const model of Object.keys(convert$2)) { + if (!("channels" in convert$2[model])) { + throw new Error("missing channels property: " + model); + } + if (!("labels" in convert$2[model])) { + throw new Error("missing channel labels property: " + model); + } + if (convert$2[model].labels.length !== convert$2[model].channels) { + throw new Error("channel and label counts mismatch: " + model); + } + const { channels, labels } = convert$2[model]; + delete convert$2[model].channels; + delete convert$2[model].labels; + Object.defineProperty(convert$2[model], "channels", { value: channels }); + Object.defineProperty(convert$2[model], "labels", { value: labels }); +} +convert$2.rgb.hsl = function(rgb) { + const r = rgb[0] / 255; + const g = rgb[1] / 255; + const b = rgb[2] / 255; + const min = Math.min(r, g, b); + const max = Math.max(r, g, b); + const delta = max - min; + let h; + let s2; + if (max === min) { + h = 0; + } else if (r === max) { + h = (g - b) / delta; + } else if (g === max) { + h = 2 + (b - r) / delta; + } else if (b === max) { + h = 4 + (r - g) / delta; + } + h = Math.min(h * 60, 360); + if (h < 0) { + h += 360; + } + const l = (min + max) / 2; + if (max === min) { + s2 = 0; + } else if (l <= 0.5) { + s2 = delta / (max + min); + } else { + s2 = delta / (2 - max - min); + } + return [h, s2 * 100, l * 100]; +}; +convert$2.rgb.hsv = function(rgb) { + let rdif; + let gdif; + let bdif; + let h; + let s2; + const r = rgb[0] / 255; + const g = rgb[1] / 255; + const b = rgb[2] / 255; + const v = Math.max(r, g, b); + const diff = v - Math.min(r, g, b); + const diffc = function(c) { + return (v - c) / 6 / diff + 1 / 2; + }; + if (diff === 0) { + h = 0; + s2 = 0; + } else { + s2 = diff / v; + rdif = diffc(r); + gdif = diffc(g); + bdif = diffc(b); + if (r === v) { + h = bdif - gdif; + } else if (g === v) { + h = 1 / 3 + rdif - bdif; + } else if (b === v) { + h = 2 / 3 + gdif - rdif; + } + if (h < 0) { + h += 1; + } else if (h > 1) { + h -= 1; + } + } + return [ + h * 360, + s2 * 100, + v * 100 + ]; +}; +convert$2.rgb.hwb = function(rgb) { + const r = rgb[0]; + const g = rgb[1]; + let b = rgb[2]; + const h = convert$2.rgb.hsl(rgb)[0]; + const w = 1 / 255 * Math.min(r, Math.min(g, b)); + b = 1 - 1 / 255 * Math.max(r, Math.max(g, b)); + return [h, w * 100, b * 100]; +}; +convert$2.rgb.cmyk = function(rgb) { + const r = rgb[0] / 255; + const g = rgb[1] / 255; + const b = rgb[2] / 255; + const k = Math.min(1 - r, 1 - g, 1 - b); + const c = (1 - r - k) / (1 - k) || 0; + const m = (1 - g - k) / (1 - k) || 0; + const y = (1 - b - k) / (1 - k) || 0; + return [c * 100, m * 100, y * 100, k * 100]; +}; +function comparativeDistance(x, y) { + return (x[0] - y[0]) ** 2 + (x[1] - y[1]) ** 2 + (x[2] - y[2]) ** 2; +} +convert$2.rgb.keyword = function(rgb) { + const reversed = reverseKeywords[rgb]; + if (reversed) { + return reversed; + } + let currentClosestDistance = Infinity; + let currentClosestKeyword; + for (const keyword of Object.keys(cssKeywords)) { + const value = cssKeywords[keyword]; + const distance = comparativeDistance(rgb, value); + if (distance < currentClosestDistance) { + currentClosestDistance = distance; + currentClosestKeyword = keyword; + } + } + return currentClosestKeyword; +}; +convert$2.keyword.rgb = function(keyword) { + return cssKeywords[keyword]; +}; +convert$2.rgb.xyz = function(rgb) { + let r = rgb[0] / 255; + let g = rgb[1] / 255; + let b = rgb[2] / 255; + r = r > 0.04045 ? ((r + 0.055) / 1.055) ** 2.4 : r / 12.92; + g = g > 0.04045 ? ((g + 0.055) / 1.055) ** 2.4 : g / 12.92; + b = b > 0.04045 ? ((b + 0.055) / 1.055) ** 2.4 : b / 12.92; + const x = r * 0.4124 + g * 0.3576 + b * 0.1805; + const y = r * 0.2126 + g * 0.7152 + b * 0.0722; + const z = r * 0.0193 + g * 0.1192 + b * 0.9505; + return [x * 100, y * 100, z * 100]; +}; +convert$2.rgb.lab = function(rgb) { + const xyz = convert$2.rgb.xyz(rgb); + let x = xyz[0]; + let y = xyz[1]; + let z = xyz[2]; + x /= 95.047; + y /= 100; + z /= 108.883; + x = x > 8856e-6 ? x ** (1 / 3) : 7.787 * x + 16 / 116; + y = y > 8856e-6 ? y ** (1 / 3) : 7.787 * y + 16 / 116; + z = z > 8856e-6 ? z ** (1 / 3) : 7.787 * z + 16 / 116; + const l = 116 * y - 16; + const a = 500 * (x - y); + const b = 200 * (y - z); + return [l, a, b]; +}; +convert$2.hsl.rgb = function(hsl) { + const h = hsl[0] / 360; + const s2 = hsl[1] / 100; + const l = hsl[2] / 100; + let t2; + let t3; + let val; + if (s2 === 0) { + val = l * 255; + return [val, val, val]; + } + if (l < 0.5) { + t2 = l * (1 + s2); + } else { + t2 = l + s2 - l * s2; + } + const t1 = 2 * l - t2; + const rgb = [0, 0, 0]; + for (let i = 0; i < 3; i++) { + t3 = h + 1 / 3 * -(i - 1); + if (t3 < 0) { + t3++; + } + if (t3 > 1) { + t3--; + } + if (6 * t3 < 1) { + val = t1 + (t2 - t1) * 6 * t3; + } else if (2 * t3 < 1) { + val = t2; + } else if (3 * t3 < 2) { + val = t1 + (t2 - t1) * (2 / 3 - t3) * 6; + } else { + val = t1; + } + rgb[i] = val * 255; + } + return rgb; +}; +convert$2.hsl.hsv = function(hsl) { + const h = hsl[0]; + let s2 = hsl[1] / 100; + let l = hsl[2] / 100; + let smin = s2; + const lmin = Math.max(l, 0.01); + l *= 2; + s2 *= l <= 1 ? l : 2 - l; + smin *= lmin <= 1 ? lmin : 2 - lmin; + const v = (l + s2) / 2; + const sv = l === 0 ? 2 * smin / (lmin + smin) : 2 * s2 / (l + s2); + return [h, sv * 100, v * 100]; +}; +convert$2.hsv.rgb = function(hsv) { + const h = hsv[0] / 60; + const s2 = hsv[1] / 100; + let v = hsv[2] / 100; + const hi = Math.floor(h) % 6; + const f = h - Math.floor(h); + const p = 255 * v * (1 - s2); + const q = 255 * v * (1 - s2 * f); + const t = 255 * v * (1 - s2 * (1 - f)); + v *= 255; + switch (hi) { + case 0: + return [v, t, p]; + case 1: + return [q, v, p]; + case 2: + return [p, v, t]; + case 3: + return [p, q, v]; + case 4: + return [t, p, v]; + case 5: + return [v, p, q]; + } +}; +convert$2.hsv.hsl = function(hsv) { + const h = hsv[0]; + const s2 = hsv[1] / 100; + const v = hsv[2] / 100; + const vmin = Math.max(v, 0.01); + let sl; + let l; + l = (2 - s2) * v; + const lmin = (2 - s2) * vmin; + sl = s2 * vmin; + sl /= lmin <= 1 ? lmin : 2 - lmin; + sl = sl || 0; + l /= 2; + return [h, sl * 100, l * 100]; +}; +convert$2.hwb.rgb = function(hwb) { + const h = hwb[0] / 360; + let wh = hwb[1] / 100; + let bl = hwb[2] / 100; + const ratio = wh + bl; + let f; + if (ratio > 1) { + wh /= ratio; + bl /= ratio; + } + const i = Math.floor(6 * h); + const v = 1 - bl; + f = 6 * h - i; + if ((i & 1) !== 0) { + f = 1 - f; + } + const n = wh + f * (v - wh); + let r; + let g; + let b; + switch (i) { + default: + case 6: + case 0: + r = v; + g = n; + b = wh; + break; + case 1: + r = n; + g = v; + b = wh; + break; + case 2: + r = wh; + g = v; + b = n; + break; + case 3: + r = wh; + g = n; + b = v; + break; + case 4: + r = n; + g = wh; + b = v; + break; + case 5: + r = v; + g = wh; + b = n; + break; + } + return [r * 255, g * 255, b * 255]; +}; +convert$2.cmyk.rgb = function(cmyk) { + const c = cmyk[0] / 100; + const m = cmyk[1] / 100; + const y = cmyk[2] / 100; + const k = cmyk[3] / 100; + const r = 1 - Math.min(1, c * (1 - k) + k); + const g = 1 - Math.min(1, m * (1 - k) + k); + const b = 1 - Math.min(1, y * (1 - k) + k); + return [r * 255, g * 255, b * 255]; +}; +convert$2.xyz.rgb = function(xyz) { + const x = xyz[0] / 100; + const y = xyz[1] / 100; + const z = xyz[2] / 100; + let r; + let g; + let b; + r = x * 3.2406 + y * -1.5372 + z * -0.4986; + g = x * -0.9689 + y * 1.8758 + z * 0.0415; + b = x * 0.0557 + y * -0.204 + z * 1.057; + r = r > 31308e-7 ? 1.055 * r ** (1 / 2.4) - 0.055 : r * 12.92; + g = g > 31308e-7 ? 1.055 * g ** (1 / 2.4) - 0.055 : g * 12.92; + b = b > 31308e-7 ? 1.055 * b ** (1 / 2.4) - 0.055 : b * 12.92; + r = Math.min(Math.max(0, r), 1); + g = Math.min(Math.max(0, g), 1); + b = Math.min(Math.max(0, b), 1); + return [r * 255, g * 255, b * 255]; +}; +convert$2.xyz.lab = function(xyz) { + let x = xyz[0]; + let y = xyz[1]; + let z = xyz[2]; + x /= 95.047; + y /= 100; + z /= 108.883; + x = x > 8856e-6 ? x ** (1 / 3) : 7.787 * x + 16 / 116; + y = y > 8856e-6 ? y ** (1 / 3) : 7.787 * y + 16 / 116; + z = z > 8856e-6 ? z ** (1 / 3) : 7.787 * z + 16 / 116; + const l = 116 * y - 16; + const a = 500 * (x - y); + const b = 200 * (y - z); + return [l, a, b]; +}; +convert$2.lab.xyz = function(lab) { + const l = lab[0]; + const a = lab[1]; + const b = lab[2]; + let x; + let y; + let z; + y = (l + 16) / 116; + x = a / 500 + y; + z = y - b / 200; + const y2 = y ** 3; + const x2 = x ** 3; + const z2 = z ** 3; + y = y2 > 8856e-6 ? y2 : (y - 16 / 116) / 7.787; + x = x2 > 8856e-6 ? x2 : (x - 16 / 116) / 7.787; + z = z2 > 8856e-6 ? z2 : (z - 16 / 116) / 7.787; + x *= 95.047; + y *= 100; + z *= 108.883; + return [x, y, z]; +}; +convert$2.lab.lch = function(lab) { + const l = lab[0]; + const a = lab[1]; + const b = lab[2]; + let h; + const hr = Math.atan2(b, a); + h = hr * 360 / 2 / Math.PI; + if (h < 0) { + h += 360; + } + const c = Math.sqrt(a * a + b * b); + return [l, c, h]; +}; +convert$2.lch.lab = function(lch) { + const l = lch[0]; + const c = lch[1]; + const h = lch[2]; + const hr = h / 360 * 2 * Math.PI; + const a = c * Math.cos(hr); + const b = c * Math.sin(hr); + return [l, a, b]; +}; +convert$2.rgb.ansi16 = function(args, saturation = null) { + const [r, g, b] = args; + let value = saturation === null ? convert$2.rgb.hsv(args)[2] : saturation; + value = Math.round(value / 50); + if (value === 0) { + return 30; + } + let ansi = 30 + (Math.round(b / 255) << 2 | Math.round(g / 255) << 1 | Math.round(r / 255)); + if (value === 2) { + ansi += 60; + } + return ansi; +}; +convert$2.hsv.ansi16 = function(args) { + return convert$2.rgb.ansi16(convert$2.hsv.rgb(args), args[2]); +}; +convert$2.rgb.ansi256 = function(args) { + const r = args[0]; + const g = args[1]; + const b = args[2]; + if (r === g && g === b) { + if (r < 8) { + return 16; + } + if (r > 248) { + return 231; + } + return Math.round((r - 8) / 247 * 24) + 232; + } + const ansi = 16 + 36 * Math.round(r / 255 * 5) + 6 * Math.round(g / 255 * 5) + Math.round(b / 255 * 5); + return ansi; +}; +convert$2.ansi16.rgb = function(args) { + let color2 = args % 10; + if (color2 === 0 || color2 === 7) { + if (args > 50) { + color2 += 3.5; + } + color2 = color2 / 10.5 * 255; + return [color2, color2, color2]; + } + const mult = (~~(args > 50) + 1) * 0.5; + const r = (color2 & 1) * mult * 255; + const g = (color2 >> 1 & 1) * mult * 255; + const b = (color2 >> 2 & 1) * mult * 255; + return [r, g, b]; +}; +convert$2.ansi256.rgb = function(args) { + if (args >= 232) { + const c = (args - 232) * 10 + 8; + return [c, c, c]; + } + args -= 16; + let rem; + const r = Math.floor(args / 36) / 5 * 255; + const g = Math.floor((rem = args % 36) / 6) / 5 * 255; + const b = rem % 6 / 5 * 255; + return [r, g, b]; +}; +convert$2.rgb.hex = function(args) { + const integer = ((Math.round(args[0]) & 255) << 16) + ((Math.round(args[1]) & 255) << 8) + (Math.round(args[2]) & 255); + const string = integer.toString(16).toUpperCase(); + return "000000".substring(string.length) + string; +}; +convert$2.hex.rgb = function(args) { + const match2 = args.toString(16).match(/[a-f0-9]{6}|[a-f0-9]{3}/i); + if (!match2) { + return [0, 0, 0]; + } + let colorString2 = match2[0]; + if (match2[0].length === 3) { + colorString2 = colorString2.split("").map((char) => { + return char + char; + }).join(""); + } + const integer = parseInt(colorString2, 16); + const r = integer >> 16 & 255; + const g = integer >> 8 & 255; + const b = integer & 255; + return [r, g, b]; +}; +convert$2.rgb.hcg = function(rgb) { + const r = rgb[0] / 255; + const g = rgb[1] / 255; + const b = rgb[2] / 255; + const max = Math.max(Math.max(r, g), b); + const min = Math.min(Math.min(r, g), b); + const chroma = max - min; + let grayscale; + let hue; + if (chroma < 1) { + grayscale = min / (1 - chroma); + } else { + grayscale = 0; + } + if (chroma <= 0) { + hue = 0; + } else if (max === r) { + hue = (g - b) / chroma % 6; + } else if (max === g) { + hue = 2 + (b - r) / chroma; + } else { + hue = 4 + (r - g) / chroma; + } + hue /= 6; + hue %= 1; + return [hue * 360, chroma * 100, grayscale * 100]; +}; +convert$2.hsl.hcg = function(hsl) { + const s2 = hsl[1] / 100; + const l = hsl[2] / 100; + const c = l < 0.5 ? 2 * s2 * l : 2 * s2 * (1 - l); + let f = 0; + if (c < 1) { + f = (l - 0.5 * c) / (1 - c); + } + return [hsl[0], c * 100, f * 100]; +}; +convert$2.hsv.hcg = function(hsv) { + const s2 = hsv[1] / 100; + const v = hsv[2] / 100; + const c = s2 * v; + let f = 0; + if (c < 1) { + f = (v - c) / (1 - c); + } + return [hsv[0], c * 100, f * 100]; +}; +convert$2.hcg.rgb = function(hcg) { + const h = hcg[0] / 360; + const c = hcg[1] / 100; + const g = hcg[2] / 100; + if (c === 0) { + return [g * 255, g * 255, g * 255]; + } + const pure = [0, 0, 0]; + const hi = h % 1 * 6; + const v = hi % 1; + const w = 1 - v; + let mg = 0; + switch (Math.floor(hi)) { + case 0: + pure[0] = 1; + pure[1] = v; + pure[2] = 0; + break; + case 1: + pure[0] = w; + pure[1] = 1; + pure[2] = 0; + break; + case 2: + pure[0] = 0; + pure[1] = 1; + pure[2] = v; + break; + case 3: + pure[0] = 0; + pure[1] = w; + pure[2] = 1; + break; + case 4: + pure[0] = v; + pure[1] = 0; + pure[2] = 1; + break; + default: + pure[0] = 1; + pure[1] = 0; + pure[2] = w; + } + mg = (1 - c) * g; + return [ + (c * pure[0] + mg) * 255, + (c * pure[1] + mg) * 255, + (c * pure[2] + mg) * 255 + ]; +}; +convert$2.hcg.hsv = function(hcg) { + const c = hcg[1] / 100; + const g = hcg[2] / 100; + const v = c + g * (1 - c); + let f = 0; + if (v > 0) { + f = c / v; + } + return [hcg[0], f * 100, v * 100]; +}; +convert$2.hcg.hsl = function(hcg) { + const c = hcg[1] / 100; + const g = hcg[2] / 100; + const l = g * (1 - c) + 0.5 * c; + let s2 = 0; + if (l > 0 && l < 0.5) { + s2 = c / (2 * l); + } else if (l >= 0.5 && l < 1) { + s2 = c / (2 * (1 - l)); + } + return [hcg[0], s2 * 100, l * 100]; +}; +convert$2.hcg.hwb = function(hcg) { + const c = hcg[1] / 100; + const g = hcg[2] / 100; + const v = c + g * (1 - c); + return [hcg[0], (v - c) * 100, (1 - v) * 100]; +}; +convert$2.hwb.hcg = function(hwb) { + const w = hwb[1] / 100; + const b = hwb[2] / 100; + const v = 1 - b; + const c = v - w; + let g = 0; + if (c < 1) { + g = (v - c) / (1 - c); + } + return [hwb[0], c * 100, g * 100]; +}; +convert$2.apple.rgb = function(apple) { + return [apple[0] / 65535 * 255, apple[1] / 65535 * 255, apple[2] / 65535 * 255]; +}; +convert$2.rgb.apple = function(rgb) { + return [rgb[0] / 255 * 65535, rgb[1] / 255 * 65535, rgb[2] / 255 * 65535]; +}; +convert$2.gray.rgb = function(args) { + return [args[0] / 100 * 255, args[0] / 100 * 255, args[0] / 100 * 255]; +}; +convert$2.gray.hsl = function(args) { + return [0, 0, args[0]]; +}; +convert$2.gray.hsv = convert$2.gray.hsl; +convert$2.gray.hwb = function(gray) { + return [0, 100, gray[0]]; +}; +convert$2.gray.cmyk = function(gray) { + return [0, 0, 0, gray[0]]; +}; +convert$2.gray.lab = function(gray) { + return [gray[0], 0, 0]; +}; +convert$2.gray.hex = function(gray) { + const val = Math.round(gray[0] / 100 * 255) & 255; + const integer = (val << 16) + (val << 8) + val; + const string = integer.toString(16).toUpperCase(); + return "000000".substring(string.length) + string; +}; +convert$2.rgb.gray = function(rgb) { + const val = (rgb[0] + rgb[1] + rgb[2]) / 3; + return [val / 255 * 100]; +}; +const conversions$1 = conversions$2; +function buildGraph() { + const graph = {}; + const models2 = Object.keys(conversions$1); + for (let len = models2.length, i = 0; i < len; i++) { + graph[models2[i]] = { + // http://jsperf.com/1-vs-infinity + // micro-opt, but this is simple. + distance: -1, + parent: null + }; + } + return graph; +} +function deriveBFS(fromModel) { + const graph = buildGraph(); + const queue = [fromModel]; + graph[fromModel].distance = 0; + while (queue.length) { + const current = queue.pop(); + const adjacents = Object.keys(conversions$1[current]); + for (let len = adjacents.length, i = 0; i < len; i++) { + const adjacent = adjacents[i]; + const node = graph[adjacent]; + if (node.distance === -1) { + node.distance = graph[current].distance + 1; + node.parent = current; + queue.unshift(adjacent); + } + } + } + return graph; +} +function link(from, to) { + return function(args) { + return to(from(args)); + }; +} +function wrapConversion(toModel, graph) { + const path2 = [graph[toModel].parent, toModel]; + let fn = conversions$1[graph[toModel].parent][toModel]; + let cur = graph[toModel].parent; + while (graph[cur].parent) { + path2.unshift(graph[cur].parent); + fn = link(conversions$1[graph[cur].parent][cur], fn); + cur = graph[cur].parent; + } + fn.conversion = path2; + return fn; +} +var route$1 = function(fromModel) { + const graph = deriveBFS(fromModel); + const conversion = {}; + const models2 = Object.keys(graph); + for (let len = models2.length, i = 0; i < len; i++) { + const toModel = models2[i]; + const node = graph[toModel]; + if (node.parent === null) { + continue; + } + conversion[toModel] = wrapConversion(toModel, graph); + } + return conversion; +}; +const conversions = conversions$2; +const route = route$1; +const convert$1 = {}; +const models = Object.keys(conversions); +function wrapRaw(fn) { + const wrappedFn = function(...args) { + const arg0 = args[0]; + if (arg0 === void 0 || arg0 === null) { + return arg0; + } + if (arg0.length > 1) { + args = arg0; + } + return fn(args); + }; + if ("conversion" in fn) { + wrappedFn.conversion = fn.conversion; + } + return wrappedFn; +} +function wrapRounded(fn) { + const wrappedFn = function(...args) { + const arg0 = args[0]; + if (arg0 === void 0 || arg0 === null) { + return arg0; + } + if (arg0.length > 1) { + args = arg0; + } + const result = fn(args); + if (typeof result === "object") { + for (let len = result.length, i = 0; i < len; i++) { + result[i] = Math.round(result[i]); + } + } + return result; + }; + if ("conversion" in fn) { + wrappedFn.conversion = fn.conversion; + } + return wrappedFn; +} +models.forEach((fromModel) => { + convert$1[fromModel] = {}; + Object.defineProperty(convert$1[fromModel], "channels", { value: conversions[fromModel].channels }); + Object.defineProperty(convert$1[fromModel], "labels", { value: conversions[fromModel].labels }); + const routes = route(fromModel); + const routeModels = Object.keys(routes); + routeModels.forEach((toModel) => { + const fn = routes[toModel]; + convert$1[fromModel][toModel] = wrapRounded(fn); + convert$1[fromModel][toModel].raw = wrapRaw(fn); + }); +}); +var colorConvert = convert$1; +const colorString = colorStringExports; +const convert = colorConvert; +const skippedModels = [ + // To be honest, I don't really feel like keyword belongs in color convert, but eh. + "keyword", + // Gray conflicts with some method names, and has its own method defined. + "gray", + // Shouldn't really be in color-convert either... + "hex" +]; +const hashedModelKeys = {}; +for (const model of Object.keys(convert)) { + hashedModelKeys[[...convert[model].labels].sort().join("")] = model; +} +const limiters = {}; +function Color(object, model) { + if (!(this instanceof Color)) { + return new Color(object, model); + } + if (model && model in skippedModels) { + model = null; + } + if (model && !(model in convert)) { + throw new Error("Unknown model: " + model); + } + let i; + let channels; + if (object == null) { + this.model = "rgb"; + this.color = [0, 0, 0]; + this.valpha = 1; + } else if (object instanceof Color) { + this.model = object.model; + this.color = [...object.color]; + this.valpha = object.valpha; + } else if (typeof object === "string") { + const result = colorString.get(object); + if (result === null) { + throw new Error("Unable to parse color from string: " + object); + } + this.model = result.model; + channels = convert[this.model].channels; + this.color = result.value.slice(0, channels); + this.valpha = typeof result.value[channels] === "number" ? result.value[channels] : 1; + } else if (object.length > 0) { + this.model = model || "rgb"; + channels = convert[this.model].channels; + const newArray = Array.prototype.slice.call(object, 0, channels); + this.color = zeroArray(newArray, channels); + this.valpha = typeof object[channels] === "number" ? object[channels] : 1; + } else if (typeof object === "number") { + this.model = "rgb"; + this.color = [ + object >> 16 & 255, + object >> 8 & 255, + object & 255 + ]; + this.valpha = 1; + } else { + this.valpha = 1; + const keys2 = Object.keys(object); + if ("alpha" in object) { + keys2.splice(keys2.indexOf("alpha"), 1); + this.valpha = typeof object.alpha === "number" ? object.alpha : 0; + } + const hashedKeys = keys2.sort().join(""); + if (!(hashedKeys in hashedModelKeys)) { + throw new Error("Unable to parse color from object: " + JSON.stringify(object)); + } + this.model = hashedModelKeys[hashedKeys]; + const { labels } = convert[this.model]; + const color2 = []; + for (i = 0; i < labels.length; i++) { + color2.push(object[labels[i]]); + } + this.color = zeroArray(color2); + } + if (limiters[this.model]) { + channels = convert[this.model].channels; + for (i = 0; i < channels; i++) { + const limit = limiters[this.model][i]; + if (limit) { + this.color[i] = limit(this.color[i]); + } + } + } + this.valpha = Math.max(0, Math.min(1, this.valpha)); + if (Object.freeze) { + Object.freeze(this); + } +} +Color.prototype = { + toString() { + return this.string(); + }, + toJSON() { + return this[this.model](); + }, + string(places) { + let self = this.model in colorString.to ? this : this.rgb(); + self = self.round(typeof places === "number" ? places : 1); + const args = self.valpha === 1 ? self.color : [...self.color, this.valpha]; + return colorString.to[self.model](args); + }, + percentString(places) { + const self = this.rgb().round(typeof places === "number" ? places : 1); + const args = self.valpha === 1 ? self.color : [...self.color, this.valpha]; + return colorString.to.rgb.percent(args); + }, + array() { + return this.valpha === 1 ? [...this.color] : [...this.color, this.valpha]; + }, + object() { + const result = {}; + const { channels } = convert[this.model]; + const { labels } = convert[this.model]; + for (let i = 0; i < channels; i++) { + result[labels[i]] = this.color[i]; + } + if (this.valpha !== 1) { + result.alpha = this.valpha; + } + return result; + }, + unitArray() { + const rgb = this.rgb().color; + rgb[0] /= 255; + rgb[1] /= 255; + rgb[2] /= 255; + if (this.valpha !== 1) { + rgb.push(this.valpha); + } + return rgb; + }, + unitObject() { + const rgb = this.rgb().object(); + rgb.r /= 255; + rgb.g /= 255; + rgb.b /= 255; + if (this.valpha !== 1) { + rgb.alpha = this.valpha; + } + return rgb; + }, + round(places) { + places = Math.max(places || 0, 0); + return new Color([...this.color.map(roundToPlace(places)), this.valpha], this.model); + }, + alpha(value) { + if (value !== void 0) { + return new Color([...this.color, Math.max(0, Math.min(1, value))], this.model); + } + return this.valpha; + }, + // Rgb + red: getset("rgb", 0, maxfn(255)), + green: getset("rgb", 1, maxfn(255)), + blue: getset("rgb", 2, maxfn(255)), + hue: getset(["hsl", "hsv", "hsl", "hwb", "hcg"], 0, (value) => (value % 360 + 360) % 360), + saturationl: getset("hsl", 1, maxfn(100)), + lightness: getset("hsl", 2, maxfn(100)), + saturationv: getset("hsv", 1, maxfn(100)), + value: getset("hsv", 2, maxfn(100)), + chroma: getset("hcg", 1, maxfn(100)), + gray: getset("hcg", 2, maxfn(100)), + white: getset("hwb", 1, maxfn(100)), + wblack: getset("hwb", 2, maxfn(100)), + cyan: getset("cmyk", 0, maxfn(100)), + magenta: getset("cmyk", 1, maxfn(100)), + yellow: getset("cmyk", 2, maxfn(100)), + black: getset("cmyk", 3, maxfn(100)), + x: getset("xyz", 0, maxfn(95.047)), + y: getset("xyz", 1, maxfn(100)), + z: getset("xyz", 2, maxfn(108.833)), + l: getset("lab", 0, maxfn(100)), + a: getset("lab", 1), + b: getset("lab", 2), + keyword(value) { + if (value !== void 0) { + return new Color(value); + } + return convert[this.model].keyword(this.color); + }, + hex(value) { + if (value !== void 0) { + return new Color(value); + } + return colorString.to.hex(this.rgb().round().color); + }, + hexa(value) { + if (value !== void 0) { + return new Color(value); + } + const rgbArray = this.rgb().round().color; + let alphaHex = Math.round(this.valpha * 255).toString(16).toUpperCase(); + if (alphaHex.length === 1) { + alphaHex = "0" + alphaHex; + } + return colorString.to.hex(rgbArray) + alphaHex; + }, + rgbNumber() { + const rgb = this.rgb().color; + return (rgb[0] & 255) << 16 | (rgb[1] & 255) << 8 | rgb[2] & 255; + }, + luminosity() { + const rgb = this.rgb().color; + const lum = []; + for (const [i, element] of rgb.entries()) { + const chan = element / 255; + lum[i] = chan <= 0.04045 ? chan / 12.92 : ((chan + 0.055) / 1.055) ** 2.4; + } + return 0.2126 * lum[0] + 0.7152 * lum[1] + 0.0722 * lum[2]; + }, + contrast(color2) { + const lum1 = this.luminosity(); + const lum2 = color2.luminosity(); + if (lum1 > lum2) { + return (lum1 + 0.05) / (lum2 + 0.05); + } + return (lum2 + 0.05) / (lum1 + 0.05); + }, + level(color2) { + const contrastRatio = this.contrast(color2); + if (contrastRatio >= 7) { + return "AAA"; + } + return contrastRatio >= 4.5 ? "AA" : ""; + }, + isDark() { + const rgb = this.rgb().color; + const yiq = (rgb[0] * 2126 + rgb[1] * 7152 + rgb[2] * 722) / 1e4; + return yiq < 128; + }, + isLight() { + return !this.isDark(); + }, + negate() { + const rgb = this.rgb(); + for (let i = 0; i < 3; i++) { + rgb.color[i] = 255 - rgb.color[i]; + } + return rgb; + }, + lighten(ratio) { + const hsl = this.hsl(); + hsl.color[2] += hsl.color[2] * ratio; + return hsl; + }, + darken(ratio) { + const hsl = this.hsl(); + hsl.color[2] -= hsl.color[2] * ratio; + return hsl; + }, + saturate(ratio) { + const hsl = this.hsl(); + hsl.color[1] += hsl.color[1] * ratio; + return hsl; + }, + desaturate(ratio) { + const hsl = this.hsl(); + hsl.color[1] -= hsl.color[1] * ratio; + return hsl; + }, + whiten(ratio) { + const hwb = this.hwb(); + hwb.color[1] += hwb.color[1] * ratio; + return hwb; + }, + blacken(ratio) { + const hwb = this.hwb(); + hwb.color[2] += hwb.color[2] * ratio; + return hwb; + }, + grayscale() { + const rgb = this.rgb().color; + const value = rgb[0] * 0.3 + rgb[1] * 0.59 + rgb[2] * 0.11; + return Color.rgb(value, value, value); + }, + fade(ratio) { + return this.alpha(this.valpha - this.valpha * ratio); + }, + opaquer(ratio) { + return this.alpha(this.valpha + this.valpha * ratio); + }, + rotate(degrees) { + const hsl = this.hsl(); + let hue = hsl.color[0]; + hue = (hue + degrees) % 360; + hue = hue < 0 ? 360 + hue : hue; + hsl.color[0] = hue; + return hsl; + }, + mix(mixinColor, weight) { + if (!mixinColor || !mixinColor.rgb) { + throw new Error('Argument to "mix" was not a Color instance, but rather an instance of ' + typeof mixinColor); + } + const color1 = mixinColor.rgb(); + const color2 = this.rgb(); + const p = weight === void 0 ? 0.5 : weight; + const w = 2 * p - 1; + const a = color1.alpha() - color2.alpha(); + const w1 = ((w * a === -1 ? w : (w + a) / (1 + w * a)) + 1) / 2; + const w2 = 1 - w1; + return Color.rgb( + w1 * color1.red() + w2 * color2.red(), + w1 * color1.green() + w2 * color2.green(), + w1 * color1.blue() + w2 * color2.blue(), + color1.alpha() * p + color2.alpha() * (1 - p) + ); + } +}; +for (const model of Object.keys(convert)) { + if (skippedModels.includes(model)) { + continue; + } + const { channels } = convert[model]; + Color.prototype[model] = function(...args) { + if (this.model === model) { + return new Color(this); + } + if (args.length > 0) { + return new Color(args, model); + } + return new Color([...assertArray(convert[this.model][model].raw(this.color)), this.valpha], model); + }; + Color[model] = function(...args) { + let color2 = args[0]; + if (typeof color2 === "number") { + color2 = zeroArray(args, channels); + } + return new Color(color2, model); + }; +} +function roundTo(number, places) { + return Number(number.toFixed(places)); +} +function roundToPlace(places) { + return function(number) { + return roundTo(number, places); + }; +} +function getset(model, channel, modifier) { + model = Array.isArray(model) ? model : [model]; + for (const m of model) { + (limiters[m] || (limiters[m] = []))[channel] = modifier; + } + model = model[0]; + return function(value) { + let result; + if (value !== void 0) { + if (modifier) { + value = modifier(value); + } + result = this[model](); + result.color[channel] = value; + return result; + } + result = this[model]().color[channel]; + if (modifier) { + result = modifier(result); + } + return result; + }; +} +function maxfn(max) { + return function(v) { + return Math.max(0, Math.min(max, v)); + }; +} +function assertArray(value) { + return Array.isArray(value) ? value : [value]; +} +function zeroArray(array, length) { + for (let i = 0; i < length; i++) { + if (typeof array[i] !== "number") { + array[i] = 0; + } + } + return array; +} +var color = Color; +const Color2 = /* @__PURE__ */ getDefaultExportFromCjs(color); +var macros = { + cref: { signature: "s m" }, + Cref: { signature: "s m" }, + crefrange: { signature: "s m m" }, + Crefrange: { signature: "s m m" }, + cpageref: { signature: "s m" }, + Cpageref: { signature: "s m" }, + ref: { signature: "m" }, + pageref: { signature: "m" }, + namecref: { signature: "m" }, + nameCref: { signature: "m" }, + lcnamecref: { signature: "m" }, + namecrefs: { signature: "m" }, + nameCrefs: { signature: "m" }, + lcnamecrefs: { signature: "m" }, + labelcref: { signature: "m" }, + labelcpageref: { signature: "m" }, + crefalias: { signature: "m m" }, + crefname: { signature: "m m m" }, + // XXX there are many more obscure commands to add here + // https://ctan.org/pkg/cleveref + crefdefaultlabelformat: { signature: "m" }, + crefrangeconjunction: { signature: "m" } +}; +var environments = {}; +function cleanEnumerateBody(ast, itemName = "item") { + let { segments, macros: macros17 } = splitOnMacro(ast, itemName); + for (let i = 0; i < segments.length; i++) { + const segment = segments[i]; + if (i === 0) { + trimEnd(segment); + } else { + trim$1(segment); + } + if (segment.length > 0 && i > 0) { + segment.unshift({ type: "whitespace" }); + } + } + let insertParbreakBefore = /* @__PURE__ */ new WeakSet(); + let body = macros17.flatMap((node, i) => { + var _a; + const segment = segments[i + 1]; + const trailingComments = popTrailingComments(segment); + node.args = node.args || []; + node.args.push(arg(segment, { openMark: "", closeMark: "" })); + updateRenderInfo(node, { inParMode: true }); + if (i > 0 || ((_a = segments[0]) == null ? void 0 : _a.length) > 0) { + insertParbreakBefore.add(node); + } + return [node, ...trailingComments]; + }); + body = body.flatMap( + (node) => insertParbreakBefore.has(node) ? [{ type: "parbreak" }, node] : node + ); + body.unshift(...segments[0]); + for (let i = 0; i < body.length - 1; i++) { + const node = body[i]; + const nextNode = body[i + 1]; + if (!match.parbreak(nextNode)) { + continue; + } + if (match.comment(node)) { + node.suffixParbreak = true; + } + if (match.macro(node) && node.args && node.args[node.args.length - 1].closeMark === "") { + const args = node.args[node.args.length - 1].content; + const lastArg = args[args.length - 1]; + if (match.comment(lastArg)) { + lastArg.suffixParbreak = true; + } + } + } + return body; +} +function popTrailingComments(nodes) { + let lastNodeIndex = lastSignificantNodeIndex(nodes, true); + if (lastNodeIndex === nodes.length - 1 || lastNodeIndex == null && nodes.length === 0) { + return []; + } + if (lastNodeIndex == null) { + lastNodeIndex = -1; + } + return nodes.splice(lastNodeIndex + 1); +} +var macros2 = { + answerline: { signature: "o" }, + fillin: { signature: "o o" }, + fullwidth: { signature: "m" }, + fillwidthlines: { signature: "m" }, + fillwidthdottedlines: { signature: "m" }, + fillwidthgrid: { signature: "m" }, + makeemptybox: { signature: "m" }, + CorrectChoiceEmphasis: { + signature: "m", + renderInfo: { breakAround: true } + }, + SolutionEmphasis: { signature: "m", renderInfo: { breakAround: true } }, + uplevel: { signature: "m", renderInfo: { breakAround: true } }, + checkboxchar: { signature: "m", renderInfo: { breakAround: true } }, + checkedchar: { signature: "m", renderInfo: { breakAround: true } }, + pointname: { signature: "m", renderInfo: { breakAround: true } }, + marginpointname: { signature: "m", renderInfo: { breakAround: true } }, + extrawidth: { signature: "m", renderInfo: { breakAround: true } }, + pointformat: { signature: "m", renderInfo: { breakAround: true } }, + bonuspointformat: { signature: "m", renderInfo: { breakAround: true } }, + totalformat: { signature: "m", renderInfo: { breakAround: true } }, + qformat: { signature: "m", renderInfo: { breakAround: true } }, + titledquestion: { signature: "m o", renderInfo: { breakAround: true } }, + pointpoints: { signature: "m m", renderInfo: { breakAround: true } }, + bonuspointpoints: { signature: "m m", renderInfo: { breakAround: true } } +}; +var environments2 = { + choices: { + signature: "o", + processContent: (nodes) => cleanEnumerateBody(nodes, "choice") + }, + checkboxes: { + signature: "o", + processContent: (nodes) => cleanEnumerateBody(nodes, "choice") + }, + oneparchoices: { + signature: "o", + processContent: (nodes) => cleanEnumerateBody(nodes, "choice") + }, + oneparcheckboxes: { + signature: "o", + processContent: (nodes) => cleanEnumerateBody(nodes, "choice") + }, + parts: { + signature: "o", + processContent: (nodes) => cleanEnumerateBody(nodes, "part") + }, + subparts: { + signature: "o", + processContent: (nodes) => cleanEnumerateBody(nodes, "subpart") + }, + subsubparts: { + signature: "o", + processContent: (nodes) => cleanEnumerateBody(nodes, "subsubpart") + }, + questions: { + signature: "o", + processContent: (nodes) => cleanEnumerateBody(nodes, "question") + } +}; +var macros3 = { + geometry: { + signature: "m", + renderInfo: { breakAround: true, pgfkeysArgs: true } + } +}; +var environments3 = {}; +var macros4 = { + hypersetup: { + signature: "m", + renderInfo: { breakAround: true, pgfkeysArgs: true } + }, + href: { signature: "o m m" }, + url: { signature: "m" }, + nolinkurl: { signature: "m" }, + hyperbaseurl: { signature: "m" }, + hyperimage: { signature: "m m" }, + hyperdef: { signature: "m m m" }, + hyperref: { signature: "o m" }, + hyperlink: { signature: "m m" }, + hypertarget: { signature: "m m" }, + autoref: { signature: "s m" }, + pageref: { signature: "s m" }, + autopageref: { signature: "s m" }, + pdfstringdef: { signature: "m m" }, + pdfbookmark: { signature: "o m m" }, + currentpdfbookmark: { signature: "m m" }, + subpdfbookmark: { signature: "m m" }, + belowpdfbookmark: { signature: "m m" }, + texorpdfstring: { signature: "m m" }, + thispdfpagelabel: { signature: "m" }, + hypercalcbp: { signature: "m" } +}; +var environments4 = {}; +var macros5 = { + // Special + "\\": { signature: "!s !o" }, + _: { signature: "m", escapeToken: "" }, + "^": { signature: "m", escapeToken: "" }, + // \newcommand arg signature from https://www.texdev.net/2020/08/19/the-good-the-bad-and-the-ugly-creating-document-commands + // List can be found in latex2e.pdf "An unofficial reference manual" + newcommand: { + signature: "s +m o +o +m", + renderInfo: { + breakAround: true, + namedArguments: ["starred", "name", "numArgs", "default", "body"] + } + }, + renewcommand: { + signature: "s +m o +o +m", + renderInfo: { + breakAround: true, + namedArguments: ["starred", "name", "numArgs", "default", "body"] + } + }, + providecommand: { + signature: "s +m o +o +m", + renderInfo: { breakAround: true } + }, + // Counters + newcounter: { + signature: "m o", + renderInfo: { breakAround: true } + }, + usecounter: { + signature: "m" + }, + setcounter: { + signature: "m m", + renderInfo: { breakAround: true } + }, + addtocounter: { + signature: "m m", + renderInfo: { breakAround: true } + }, + stepcounter: { + signature: "m", + renderInfo: { breakAround: true } + }, + refstepcounter: { + signature: "m", + renderInfo: { breakAround: true } + }, + // Lengths + newlength: { + signature: "m", + renderInfo: { breakAround: true } + }, + addtolength: { + signature: "m m", + renderInfo: { breakAround: true } + }, + settodepth: { + signature: "m m", + renderInfo: { breakAround: true } + }, + settoheight: { + signature: "m m", + renderInfo: { breakAround: true } + }, + settowidth: { + signature: "m m", + renderInfo: { breakAround: true } + }, + // Spaces + stretch: { signature: "m" }, + hspace: { signature: "s m" }, + vspace: { signature: "s m", renderInfo: { breakAround: true } }, + vfill: { renderInfo: { breakAround: true } }, + indent: { renderInfo: { breakAround: true } }, + phantom: { signature: "m" }, + vphantom: { signature: "m" }, + hphantom: { signature: "m" }, + noindent: { renderInfo: { breakAround: true } }, + smallskip: { renderInfo: { breakAround: true } }, + medskip: { renderInfo: { breakAround: true } }, + bigskip: { renderInfo: { breakAround: true } }, + smallbreak: { renderInfo: { breakAround: true } }, + medbreak: { renderInfo: { breakAround: true } }, + bigbreak: { renderInfo: { breakAround: true } }, + newline: { renderInfo: { breakAround: true } }, + linebreak: { signature: "o", renderInfo: { breakAround: true } }, + nolinebreak: { signature: "o", renderInfo: { breakAround: true } }, + clearpage: { renderInfo: { breakAround: true } }, + cleardoublepage: { renderInfo: { breakAround: true } }, + newpage: { renderInfo: { breakAround: true } }, + enlargethispage: { signature: "s", renderInfo: { breakAround: true } }, + pagebreak: { signature: "o", renderInfo: { breakAround: true } }, + nopagebreak: { signature: "o", renderInfo: { breakAround: true } }, + // Boxes + newsavebox: { + signature: "m", + renderInfo: { breakAround: true } + }, + sbox: { + signature: "m m", + renderInfo: { breakAround: true } + }, + savebox: { + signature: "m o o m", + renderInfo: { breakAround: true } + }, + mbox: { signature: "m" }, + makebox: { signature: "d() o o m", renderInfo: { breakAround: true } }, + fbox: { signature: "m" }, + framebox: { signature: "o o m", renderInfo: { breakAround: true } }, + frame: { signature: "m", renderInfo: { breakAround: true } }, + parbox: { signature: "o o o m m", renderInfo: { breakAround: true } }, + raisebox: { signature: "m o o m" }, + marginpar: { signature: "o m", renderInfo: { breakAround: true } }, + colorbox: { signature: "o m m", renderInfo: { breakAround: true } }, + fcolorbox: { signature: "o m m", renderInfo: { breakAround: true } }, + rotatebox: { signature: "o m m" }, + scalebox: { signature: "m o m" }, + reflectbox: { signature: "m" }, + resizebox: { signature: "s m m m" }, + // Define environments + newenvironment: { + signature: "s m o o m m", + renderInfo: { breakAround: true } + }, + renewenvironment: { + signature: "s m o o m m", + renderInfo: { breakAround: true } + }, + newtheorem: { + signature: "s m o m o", + renderInfo: { breakAround: true } + }, + newfont: { + signature: "m m", + renderInfo: { breakAround: true } + }, + // Counters + alph: { signature: "m" }, + Alph: { signature: "m" }, + arabic: { signature: "m" }, + roman: { signature: "m" }, + Roman: { signature: "m" }, + fnsymbol: { signature: "m" }, + // Other + documentclass: { + signature: "o m", + renderInfo: { breakAround: true, pgfkeysArgs: true } + }, + usepackage: { + signature: "o m", + renderInfo: { breakAround: true, pgfkeysArgs: true } + }, + item: { + signature: "o", + renderInfo: { hangingIndent: true, namedArguments: ["label"] } + }, + value: { signature: "m" }, + centering: { renderInfo: { breakAround: true } }, + input: { signature: "m", renderInfo: { breakAround: true } }, + include: { signature: "m", renderInfo: { breakAround: true } }, + includeonly: { + signature: "m", + renderInfo: { breakAround: true, pgfkeysArgs: true } + }, + discretionary: { signature: "m m m" }, + hyphenation: { signature: "m m m" }, + footnote: { signature: "o m", renderInfo: { inParMode: true } }, + footnotemark: { signature: "o" }, + footnotetext: { signature: "o m", renderInfo: { inParMode: true } }, + caption: { + signature: "o m", + renderInfo: { inParMode: true, breakAround: true } + }, + // Math Commands + sqrt: { signature: "o m", renderInfo: { inMathMode: true } }, + frac: { signature: "m m", renderInfo: { inMathMode: true } }, + stackrel: { signature: "m m" }, + ensuremath: { signature: "m", renderInfo: { inMathMode: true } }, + // Layout commands + abstract: { + signature: "m", + renderInfo: { breakAround: true, inParMode: true } + }, + maketitle: { renderInfo: { breakAround: true } }, + doublespacing: { renderInfo: { breakAround: true } }, + singlespacing: { renderInfo: { breakAround: true } }, + author: { + signature: "m", + renderInfo: { breakAround: true, inParMode: true } + }, + date: { signature: "o m", renderInfo: { breakAround: true } }, + thanks: { + signature: "m", + renderInfo: { breakAround: true, inParMode: true } + }, + // amsart document class adds an optional argument + title: { + signature: "o m", + renderInfo: { breakAround: true, inParMode: true } + }, + pagenumbering: { signature: "m", renderInfo: { breakAround: true } }, + pagestyle: { signature: "m", renderInfo: { breakAround: true } }, + thispagestyle: { signature: "m", renderInfo: { breakAround: true } }, + // Colors + definecolor: { signature: "m m m", renderInfo: { breakAround: true } }, + pagecolor: { signature: "o m", renderInfo: { breakAround: true } }, + nopagecolor: { renderInfo: { breakAround: true } }, + multicolumn: { signature: "m m m" }, + // Graphics + includegraphics: { + signature: "s o o m", + renderInfo: { breakAround: true, pgfkeysArgs: true } + }, + rule: { signature: "o m m" }, + // Sectioning + part: { + signature: "s o m", + renderInfo: { + breakAround: true, + inParMode: true, + namedArguments: ["starred", "tocTitle", "title"] + } + }, + chapter: { + signature: "s o m", + renderInfo: { + breakAround: true, + inParMode: true, + namedArguments: ["starred", "tocTitle", "title"] + } + }, + section: { + signature: "s o m", + renderInfo: { + breakAround: true, + inParMode: true, + namedArguments: ["starred", "tocTitle", "title"] + } + }, + subsection: { + signature: "s o m", + renderInfo: { + breakAround: true, + inParMode: true, + namedArguments: ["starred", "tocTitle", "title"] + } + }, + subsubsection: { + signature: "s o m", + renderInfo: { + breakAround: true, + inParMode: true, + namedArguments: ["starred", "tocTitle", "title"] + } + }, + paragraph: { + signature: "s o m", + renderInfo: { + breakAround: true, + inParMode: true, + namedArguments: ["starred", "tocTitle", "title"] + } + }, + subparagraph: { + signature: "s o m", + renderInfo: { + breakAround: true, + inParMode: true, + namedArguments: ["starred", "tocTitle", "title"] + } + }, + appendix: { renderInfo: { breakAround: true, inParMode: true } }, + frontmatter: { renderInfo: { breakAround: true, inParMode: true } }, + mainmatter: { renderInfo: { breakAround: true, inParMode: true } }, + backmatter: { renderInfo: { breakAround: true, inParMode: true } }, + // Citing and references + bibitem: { signature: "o m", renderInfo: { hangingIndent: true } }, + cite: { signature: "o m" }, + // Fonts + textrm: { signature: "m", renderInfo: { inParMode: true } }, + textit: { signature: "m", renderInfo: { inParMode: true } }, + textmd: { signature: "m", renderInfo: { inParMode: true } }, + textbf: { signature: "m", renderInfo: { inParMode: true } }, + textup: { signature: "m", renderInfo: { inParMode: true } }, + textsl: { signature: "m", renderInfo: { inParMode: true } }, + textsf: { signature: "m", renderInfo: { inParMode: true } }, + textsc: { signature: "m", renderInfo: { inParMode: true } }, + texttt: { signature: "m", renderInfo: { inParMode: true } }, + emph: { signature: "m", renderInfo: { inParMode: true } }, + textnormal: { signature: "m", renderInfo: { inParMode: true } }, + uppercase: { signature: "m", renderInfo: { inParMode: true } }, + mathbf: { signature: "m" }, + mathsf: { signature: "m" }, + mathtt: { signature: "m" }, + mathit: { signature: "m" }, + mathnormal: { signature: "m" }, + mathcal: { signature: "m" }, + mathrm: { signature: "m" }, + // Other + setlength: { signature: "m m", renderInfo: { breakAround: true } }, + ref: { signature: "s m" }, + label: { signature: "o m" }, + // cleveref changes \label to have this signature + printbibliography: { renderInfo: { breakAround: true } }, + addtocontents: { signature: "m m", renderInfo: { breakAround: true } }, + addcontentsline: { signature: "m m m", renderInfo: { breakAround: true } }, + contentsline: { signature: "m m m", renderInfo: { breakAround: true } }, + bibliography: { signature: "m", renderInfo: { breakAround: true } }, + bibliographystyle: { signature: "m", renderInfo: { breakAround: true } } +}; +var environments5 = { + document: { + processContent: (nodes) => { + trim$1(nodes); + return nodes; + } + }, + array: { signature: "o m", renderInfo: { alignContent: true } }, + description: { signature: "o", processContent: cleanEnumerateBody }, + enumerate: { + signature: "o", + processContent: cleanEnumerateBody, + renderInfo: { pgfkeysArgs: true } + }, + itemize: { signature: "o", processContent: cleanEnumerateBody }, + trivlist: { signature: "o", processContent: cleanEnumerateBody }, + list: { signature: "m m", processContent: cleanEnumerateBody }, + figure: { signature: "o" }, + "figure*": { signature: "o" }, + filecontents: { signature: "o m" }, + "filecontents*": { signature: "o m" }, + minipage: { signature: "o o o m" }, + picture: { signature: "r() d()" }, + tabbing: { renderInfo: { alignContent: true } }, + table: { signature: "o" }, + tabular: { signature: "o m", renderInfo: { alignContent: true } }, + "tabular*": { signature: "m o m", renderInfo: { alignContent: true } }, + thebibliography: { + signature: "m", + processContent: (nodes) => cleanEnumerateBody(nodes, "bibitem") + }, + // Math + math: { renderInfo: { inMathMode: true } } +}; +var argSpecM = parse$2("m")[0]; +var argSpecO = parse$2("o")[0]; +var argSpecRDelim = {}; +var argumentParser = (nodes, startPos) => { + const { argument: optionalArg, nodesRemoved: optionalArgNodesRemoved } = gobbleSingleArgument(nodes, argSpecO, startPos); + let codeArg = null; + let codeArgNodesRemoved = 0; + const nextNode = nodes[startPos]; + if (match.group(nextNode)) { + const mandatoryArg = gobbleSingleArgument(nodes, argSpecM, startPos); + codeArg = mandatoryArg.argument; + codeArgNodesRemoved = mandatoryArg.nodesRemoved; + } else if (match.string(nextNode) && nextNode.content.length === 1) { + const delim = nextNode.content; + argSpecRDelim[delim] = argSpecRDelim[delim] || parse$2(`r${delim}${delim}`)[0]; + const delimArg = gobbleSingleArgument( + nodes, + argSpecRDelim[delim], + startPos + ); + codeArg = delimArg.argument; + codeArgNodesRemoved = delimArg.nodesRemoved; + } + return { + args: [optionalArg || arg(null), codeArg || arg(null)], + nodesRemoved: optionalArgNodesRemoved + codeArgNodesRemoved + }; +}; +var macros6 = { + lstset: { signature: "m" }, + lstinline: { argumentParser }, + lstinputlisting: { signature: "o m" }, + lstdefinestyle: { signature: "m m" }, + lstnewenvironment: { signature: "m o o m m" }, + lstMakeShortInline: { signature: "o m" }, + lstDeleteShortInline: { signature: "m" }, + lstdefineformat: { signature: "m m" }, + lstdefinelanguage: { signature: "o m o m o" }, + lstalias: { signature: "o m o m" }, + lstloadlanguages: { signature: "m" } +}; +var environments6 = {}; +var macros7 = { + see: { signature: "m m" }, + seealso: { signature: "m m" }, + seename: { signature: "m" }, + alsoname: { signature: "m" }, + index: { signature: "m" } +}; +var environments7 = {}; +var macros8 = { + mathtoolsset: { + signature: "m", + renderInfo: { breakAround: true, pgfkeysArgs: true } + }, + mathllap: { + signature: "o m" + }, + mathrlap: { + signature: "o m" + }, + mathclap: { + signature: "o m" + }, + clap: { + signature: "m" + }, + mathmbox: { + signature: "m" + }, + mathmakebox: { + signature: "o o m" + }, + cramped: { + signature: "o m" + }, + crampedllap: { + signature: "o m" + }, + crampedrlap: { + signature: "o m" + }, + crampedclap: { + signature: "o m" + }, + crampedsubstack: { + signature: "o m" + }, + smashoperator: { + signature: "o m" + }, + newtagform: { + signature: "m o m m" + }, + renewtagform: { + signature: "m o m m" + }, + usetagform: { + signature: "m" + }, + xleftrightarrow: { signature: "o m" }, + xLeftarrow: { signature: "o m" }, + xhookleftarrow: { signature: "o m" }, + xmapsto: { signature: "o m" }, + xRightarrow: { signature: "o m" }, + xLeftrightarrow: { signature: "o m" }, + xhookrightarrow: { signature: "o m" }, + underbracket: { signature: "o o m" }, + overbracket: { signature: "o o m" }, + underbrace: { signature: "m" }, + overbrace: { signature: "m" }, + shoveleft: { signature: "o m" }, + shoveright: { signature: "o m" }, + ArrowBetweenLines: { signature: "s o" }, + vdotswithin: { signature: "m" }, + shortdotswithin: { signature: "s m" }, + DeclarePairedDelimiter: { + signature: "m m m", + renderInfo: { breakAround: true } + }, + DeclarePairedDelimiterX: { + signature: "m o m m m", + renderInfo: { breakAround: true } + }, + DeclarePairedDelimiterXPP: { + signature: "m o m m m m m", + renderInfo: { breakAround: true } + }, + prescript: { signature: "m m m" }, + DeclareMathSizes: { signature: "m m m m" }, + newgathered: { signature: "m m m m" }, + renewgathered: { signature: "m m m m" }, + splitfrac: { signature: "m m" }, + splitdfrac: { signature: "m m" }, + xmathstrut: { signature: "o m" }, + // amsthm + newtheorem: { signature: "s m o m o", renderInfo: { breakAround: true } }, + theoremstyle: { signature: "m", renderInfo: { breakAround: true } }, + newtheoremstyle: { + signature: "m m m m m m m m m", + renderInfo: { breakAround: true } + }, + // amsmath + text: { signature: "m", renderInfo: { inMathMode: false } }, + // amsfonts + mathbb: { signature: "m" }, + mathscr: { signature: "m" }, + mathfrak: { signature: "m" }, + frak: { signature: "m" }, + Bdd: { signature: "m" }, + bold: { signature: "m" }, + // amsopn + operatorname: { signature: "s m" }, + DeclareMathOperator: { + signature: "s m m", + renderInfo: { breakAround: true } + } +}; +var environments8 = { + crampedsubarray: { + signature: "m", + renderInfo: { alignContent: true, inMathMode: true } + }, + matrix: { renderInfo: { alignContent: true, inMathMode: true } }, + bmatrix: { renderInfo: { alignContent: true, inMathMode: true } }, + pmatrix: { renderInfo: { alignContent: true, inMathMode: true } }, + vmatrix: { renderInfo: { alignContent: true, inMathMode: true } }, + Bmatrix: { renderInfo: { alignContent: true, inMathMode: true } }, + Vmatrix: { renderInfo: { alignContent: true, inMathMode: true } }, + smallmatrix: { renderInfo: { alignContent: true, inMathMode: true } }, + psmallmatrix: { renderInfo: { alignContent: true, inMathMode: true } }, + vsmallmatrix: { renderInfo: { alignContent: true, inMathMode: true } }, + bsmallmatrix: { renderInfo: { alignContent: true, inMathMode: true } }, + Bsmallmatrix: { renderInfo: { alignContent: true, inMathMode: true } }, + Vsmallmatrix: { renderInfo: { alignContent: true, inMathMode: true } }, + "matrix*": { + signature: "o", + renderInfo: { alignContent: true, inMathMode: true } + }, + "bmatrix*": { + signature: "o", + renderInfo: { alignContent: true, inMathMode: true } + }, + "pmatrix*": { + signature: "o", + renderInfo: { alignContent: true, inMathMode: true } + }, + "vmatrix*": { + signature: "o", + renderInfo: { alignContent: true, inMathMode: true } + }, + "Bmatrix*": { + signature: "o", + renderInfo: { alignContent: true, inMathMode: true } + }, + "Vmatrix*": { + signature: "o", + renderInfo: { alignContent: true, inMathMode: true } + }, + "smallmatrix*": { + signature: "o", + renderInfo: { alignContent: true, inMathMode: true } + }, + "psmallmatrix*": { + signature: "o", + renderInfo: { alignContent: true, inMathMode: true } + }, + "bsmallmatrix*": { + signature: "o", + renderInfo: { alignContent: true, inMathMode: true } + }, + "vsmallmatrix*": { + signature: "o", + renderInfo: { alignContent: true, inMathMode: true } + }, + "Bsmallmatrix*": { + signature: "o", + renderInfo: { alignContent: true, inMathMode: true } + }, + "Vsmallmatrix*": { + signature: "o", + renderInfo: { alignContent: true, inMathMode: true } + }, + multilined: { signature: "o o", renderInfo: { inMathMode: true } }, + cases: { renderInfo: { alignContent: true, inMathMode: true } }, + "cases*": { renderInfo: { alignContent: true, inMathMode: true } }, + dcases: { renderInfo: { alignContent: true, inMathMode: true } }, + "dcases*": { renderInfo: { alignContent: true, inMathMode: true } }, + rcases: { renderInfo: { alignContent: true, inMathMode: true } }, + "rcases*": { renderInfo: { alignContent: true, inMathMode: true } }, + drcases: { renderInfo: { alignContent: true, inMathMode: true } }, + "drcases*": { renderInfo: { alignContent: true, inMathMode: true } }, + spreadlines: { signature: "m", renderInfo: { inMathMode: true } }, + lgathered: { signature: "o", renderInfo: { inMathMode: true } }, + rgathered: { signature: "o", renderInfo: { inMathMode: true } }, + // amsmath + "align*": { renderInfo: { inMathMode: true, alignContent: true } }, + align: { renderInfo: { inMathMode: true, alignContent: true } }, + aligned: { renderInfo: { inMathMode: true, alignContent: true } }, + "alignat*": { renderInfo: { inMathMode: true, alignContent: true } }, + alignat: { renderInfo: { inMathMode: true, alignContent: true } }, + "equation*": { renderInfo: { inMathMode: true } }, + equation: { renderInfo: { inMathMode: true } }, + "gather*": { renderInfo: { inMathMode: true } }, + gather: { renderInfo: { inMathMode: true } }, + "multline*": { renderInfo: { inMathMode: true } }, + multline: { renderInfo: { inMathMode: true } }, + "flalign*": { renderInfo: { inMathMode: true, alignContent: true } }, + flalign: { renderInfo: { inMathMode: true, alignContent: true } }, + split: { renderInfo: { inMathMode: true } }, + // Math environments + displaymath: { renderInfo: { inMathMode: true } }, + // Typical amsthm environments + theorem: { signature: "o" }, + lemma: { signature: "o" }, + definition: { signature: "o" }, + proposition: { signature: "o" }, + corollary: { signature: "o" }, + remark: { signature: "!o" }, + example: { signature: "!o" }, + proof: { signature: "o" } +}; +var argSpecM2 = parse$2("m")[0]; +var argSpecO2 = parse$2("o")[0]; +var argSpecRDelim2 = {}; +var argumentParser2 = (nodes, startPos) => { + const { argument: optionalArg, nodesRemoved: optionalArgNodesRemoved } = gobbleSingleArgument(nodes, argSpecO2, startPos); + const { argument: languageArg, nodesRemoved: languageArgNodesRemoved } = gobbleSingleArgument(nodes, argSpecM2, startPos); + let codeArg = null; + let codeArgNodesRemoved = 0; + const nextNode = nodes[startPos]; + if (match.group(nextNode)) { + const mandatoryArg = gobbleSingleArgument(nodes, argSpecM2, startPos); + codeArg = mandatoryArg.argument; + codeArgNodesRemoved = mandatoryArg.nodesRemoved; + } else if (match.string(nextNode) && nextNode.content.length === 1) { + const delim = nextNode.content; + argSpecRDelim2[delim] = argSpecRDelim2[delim] || parse$2(`r${delim}${delim}`)[0]; + const delimArg = gobbleSingleArgument( + nodes, + argSpecRDelim2[delim], + startPos + ); + codeArg = delimArg.argument; + codeArgNodesRemoved = delimArg.nodesRemoved; + } + return { + args: [ + optionalArg || arg(null), + languageArg || arg(null), + codeArg || arg(null) + ], + nodesRemoved: optionalArgNodesRemoved + languageArgNodesRemoved + codeArgNodesRemoved + }; +}; +var macros9 = { + mint: { argumentParser: argumentParser2 }, + mintinline: { argumentParser: argumentParser2 }, + inputminted: { argumentParser: argumentParser2 }, + usemintedstyle: { signature: "m" }, + setminted: { signature: "o m" }, + setmintedinline: { signature: "o m" }, + newmint: { signature: "o m m" }, + newminted: { signature: "o m m" }, + newmintinline: { signature: "o m m" }, + newmintedfile: { signature: "o m m" } +}; +var environments9 = {}; +var macros10 = { + NiceMatrixOptions: { + signature: "m", + renderInfo: { pgfkeysArgs: true, breakAround: true } + } +}; +var environments10 = { + NiceTabular: { + signature: "o m !o", + renderInfo: { pgfkeysArgs: true, alignContent: true } + }, + NiceMatrixBlock: { + signature: "!o", + renderInfo: { pgfkeysArgs: true, alignContent: true } + }, + NiceArrayWithDelims: { + signature: "m m o m !o", + renderInfo: { pgfkeysArgs: true, alignContent: true } + }, + NiceArray: { + signature: "o m !o", + renderInfo: { pgfkeysArgs: true, alignContent: true } + }, + pNiceArray: { + signature: "o m !o", + renderInfo: { pgfkeysArgs: true, alignContent: true } + }, + bNiceArray: { + signature: "o m !o", + renderInfo: { pgfkeysArgs: true, alignContent: true } + }, + BNiceArray: { + signature: "o m !o", + renderInfo: { pgfkeysArgs: true, alignContent: true } + }, + vNiceArray: { + signature: "o m !o", + renderInfo: { pgfkeysArgs: true, alignContent: true } + }, + VNiceArray: { + signature: "o m !o", + renderInfo: { pgfkeysArgs: true, alignContent: true } + }, + NiceMatrix: { + signature: "!o", + renderInfo: { pgfkeysArgs: true, alignContent: true } + }, + pNiceMatrix: { + signature: "!o", + renderInfo: { pgfkeysArgs: true, alignContent: true } + }, + bNiceMatrix: { + signature: "!o", + renderInfo: { pgfkeysArgs: true, alignContent: true } + }, + BNiceMatrix: { + signature: "!o", + renderInfo: { pgfkeysArgs: true, alignContent: true } + }, + vNiceMatrix: { + signature: "!o", + renderInfo: { pgfkeysArgs: true, alignContent: true } + }, + VNiceMatrix: { + signature: "!o", + renderInfo: { pgfkeysArgs: true, alignContent: true } + } +}; +var macros11 = { + systeme: { + signature: "s o o m", + renderInfo: { inMathMode: true } + }, + sysdelim: { + signature: "m m" + }, + syseqsep: { signature: "m" }, + sysalign: { signature: "m" }, + syssignspace: { signature: "m" }, + syseqspace: { signature: "m" }, + syslineskipcoeff: { signature: "m" }, + syseqivsign: { signature: "m" }, + sysaddeqsign: { signature: "m" }, + sysremoveeqsign: { signature: "m" }, + sysextracolonsign: { signature: "m" }, + syscodeextracol: { signature: "m" }, + sysautonum: { signature: "m" }, + syssubstitute: { signature: "m" } +}; +var environments11 = {}; +(function() { + if (typeof globalThis === "object") + return; + Object.defineProperty(Object.prototype, "__magic__", { + get: function() { + return this; + }, + configurable: true + // This makes it possible to `delete` the getter later. + }); + __magic__.globalThis = __magic__; + delete Object.prototype.__magic__; +})(); +var OPTIONAL_ARGUMENT_ARG_SPEC = parse$2("o")[0]; +function blankArg() { + return arg([], { openMark: "", closeMark: "" }); +} +var tikzCommandArgumentParser = (nodes, startPos) => { + const origStartPos = startPos; + let pos = startPos; + let nodesRemoved = 0; + const cursorPosAfterAnimations = eatAllAnimationSpecs(nodes, pos); + let animationArg = blankArg(); + if (cursorPosAfterAnimations !== pos) { + const argContent = nodes.splice(pos, cursorPosAfterAnimations - pos); + trim$1(argContent); + animationArg = arg(argContent, { + openMark: " ", + closeMark: " " + }); + } + nodesRemoved += cursorPosAfterAnimations - pos; + const { + argument: _optionalArgument, + nodesRemoved: optionalArgumentNodesRemoved + } = gobbleSingleArgument(nodes, OPTIONAL_ARGUMENT_ARG_SPEC, pos); + nodesRemoved += optionalArgumentNodesRemoved; + const optionalArg = _optionalArgument || blankArg(); + while (match.whitespace(nodes[pos])) { + pos++; + } + const firstNode = nodes[pos]; + if (!firstNode) { + return { + args: [animationArg, optionalArg, blankArg()], + nodesRemoved: 0 + }; + } + if (match.group(firstNode)) { + const args = [animationArg, optionalArg, arg(firstNode.content)]; + nodes.splice(origStartPos, pos - origStartPos + 1); + return { args, nodesRemoved: pos - origStartPos + 1 + nodesRemoved }; + } + const semicolonPosition = scan(nodes, ";", { startIndex: pos }); + if (semicolonPosition != null) { + const argNodes = nodes.splice( + origStartPos, + semicolonPosition - origStartPos + 1 + ); + trim$1(argNodes); + const args = [animationArg, optionalArg, arg(argNodes)]; + return { + args, + nodesRemoved: origStartPos - semicolonPosition + 1 + nodesRemoved + }; + } + return { + args: [animationArg, optionalArg, blankArg()], + nodesRemoved: 0 + }; +}; +function eatAllAnimationSpecs(nodes, startPos) { + const colonPos = scan(nodes, ":", { + startIndex: startPos, + allowSubstringMatches: true, + onlySkipWhitespaceAndComments: true + }); + if (!colonPos) { + return startPos; + } + let lastMatchPos = startPos; + let i = colonPos + 1; + for (; i < nodes.length; i++) { + const node = nodes[i]; + if (match.string(node, "[")) { + break; + } + if (match.string(node, "=")) { + i++; + while (match.whitespace(nodes[i]) || match.comment(nodes[i])) { + i++; + } + if (!match.group(nodes[i])) { + break; + } + lastMatchPos = i + 1; + const colonPos2 = scan(nodes, ":", { + startIndex: lastMatchPos, + allowSubstringMatches: true, + onlySkipWhitespaceAndComments: true + }); + if (colonPos2 == null) { + break; + } + i = colonPos2 + 1; + } + } + return lastMatchPos; +} +var macros12 = { + pgfkeys: { + signature: "m", + renderInfo: { breakAround: true, pgfkeysArgs: true } + }, + tikzoption: { + signature: "m", + renderInfo: { breakAround: true, pgfkeysArgs: true } + }, + tikzstyle: { + signature: "m", + renderInfo: { breakAround: true, pgfkeysArgs: true } + }, + usetikzlibrary: { + signature: "m", + renderInfo: { breakAround: true, pgfkeysArgs: true } + }, + usepgfmodule: { signature: "m", renderInfo: { pgfkeysArgs: true } }, + usepgflibrary: { signature: "m", renderInfo: { pgfkeysArgs: true } }, + pgfplotsset: { + signature: "m", + renderInfo: { breakAround: true, pgfkeysArgs: true } + }, + pgfplotstabletypeset: { + signature: "o m", + renderInfo: { breakAround: true, pgfkeysArgs: true } + }, + tikz: { + signature: "o o m", + argumentParser: tikzCommandArgumentParser, + renderInfo: { namedArguments: ["animation", "options", "command"] } + } +}; +var environments12 = { + tikzpicture: { + signature: "o", + renderInfo: { pgfkeysArgs: true, tikzEnvironment: true }, + processContent: processTikzEnvironmentContent + }, + axis: { + signature: "o", + renderInfo: { pgfkeysArgs: true, tikzEnvironment: true }, + processContent: processTikzEnvironmentContent + }, + scope: { + signature: "o", + renderInfo: { pgfkeysArgs: true, tikzEnvironment: true }, + processContent: processTikzEnvironmentContent + }, + pgfonlayer: { + signature: "m", + renderInfo: { tikzEnvironment: true }, + processContent: processTikzEnvironmentContent + }, + pgflowlevelscope: { + signature: "m", + renderInfo: { tikzEnvironment: true }, + processContent: processTikzEnvironmentContent + }, + pgfviewboxscope: { + signature: "m m m m m", + renderInfo: { tikzEnvironment: true }, + processContent: processTikzEnvironmentContent + }, + pgftransparencygroup: { + signature: "o", + renderInfo: { pgfkeysArgs: true, tikzEnvironment: true }, + processContent: processTikzEnvironmentContent + }, + behindforegroundpath: { + signature: "m", + processContent: processTikzEnvironmentContent + }, + pgfmetadecoration: { + signature: "m", + processContent: processTikzEnvironmentContent + }, + colormixin: { signature: "m", renderInfo: { pgfkeysArgs: true } } +}; +function processTikzEnvironmentContent(nodes) { + attachMacroArgsInArray(nodes, conditionalMacros); + return nodes; +} +var conditionalMacros = { + pgfextra: { signature: "m" }, + beginpgfgraphicnamed: { signature: "m" }, + pgfrealjobname: { signature: "m" }, + pgfplotstreampoint: { signature: "m" }, + pgfplotstreampointoutlier: { signature: "m" }, + pgfplotstreamspecial: { signature: "m" }, + pgfplotxyfile: { signature: "m" }, + pgfplotxyzfile: { signature: "m" }, + pgfplotfunction: { signature: "mmm" }, + pgfplotgnuplot: { signature: "o m" }, + pgfplothandlerrecord: { signature: "m" }, + pgfdeclareplothandler: { signature: "m m m" }, + pgfdeclarelayer: { signature: "m" }, + pgfsetlayers: { signature: "m", renderInfo: { pgfkeysArgs: true } }, + pgfonlayer: { signature: "m" }, + startpgfonlayer: { signature: "m" }, + pgfdeclarehorizontalshading: { signature: "o m m m " }, + pgfdeclareradialshading: { signature: "o m m m" }, + pgfdeclarefunctionalshading: { signature: "o m m m m m" }, + pgfshadecolortorgb: { signature: "m m" }, + pgfshadecolortocmyk: { signature: "m m" }, + pgfshadecolortogray: { signature: "m m" }, + pgfuseshading: { signature: "m" }, + pgfshadepath: { signature: "m m" }, + pgfsetadditionalshadetransform: { signature: "m" }, + pgfsetstrokeopacity: { signature: "m" }, + pgfsetfillopacity: { signature: "m" }, + pgfsetblendmode: { signature: "m" }, + pgfdeclarefading: { signature: "m m" }, + pgfsetfading: { signature: "m m" }, + pgfsetfadingforcurrentpath: { signature: "m m" }, + pgfsetfadingforcurrentpathstroked: { signature: "m m" }, + pgfanimateattribute: { signature: "m m" }, + pgfsnapshot: { signature: "m" }, + pgfqpoint: { signature: "m m" }, + pgfqpointxy: { signature: "m m" }, + pgfqpointxyz: { signature: "m m m" }, + pgfqpointscale: { signature: "m m" }, + pgfpathqmoveto: { signature: "m m" }, + pgfpathqlineto: { signature: "m m" }, + pgfpathqcurveto: { signature: "m m m m m m" }, + pgfpathqcircle: { signature: "m" }, + pgfqbox: { signature: "m" }, + pgfqboxsynced: { signature: "m" }, + pgfaliasimage: { signature: "m m" }, + pgfuseimage: { signature: "m" }, + pgfimage: { signature: "o m", renderInfo: { pgfkeysArgs: true } }, + pgfdeclaremask: { signature: "o m m", renderInfo: { pgfkeysArgs: true } }, + pgfdeclarepatternformonly: { signature: "o m m m m m" }, + pgfdeclarepatterninherentlycolored: { signature: "o m m m m m" }, + pgfsetfillpattern: { signature: "m m" }, + // Coordinate canvas and nonlinear transformations + pgftransformshift: { signature: "m" }, + pgftransformxshift: { signature: "m" }, + pgftransformyshift: { signature: "m" }, + pgftransformscale: { signature: "m" }, + pgftransformxscale: { signature: "m" }, + pgftransformyscale: { signature: "m" }, + pgftransformxslant: { signature: "m" }, + pgftransformyslant: { signature: "m" }, + pgftransformrotate: { signature: "m" }, + pgftransformtriangle: { signature: "m m m" }, + pgftransformcm: { signature: "m m m m m" }, + pgftransformarrow: { signature: "m m" }, + pgftransformlineattime: { signature: "m m m" }, + pgftransformcurveattime: { signature: "m m m m m" }, + pgftransformarcaxesattime: { signature: "m m m m m m" }, + pgfgettransform: { signature: "m" }, + pgfsettransform: { signature: "m" }, + pgfgettransformentries: { signature: "m m m m m m" }, + pgfsettransformentries: { signature: "m m m m m m" }, + pgfpointtransformed: { signature: "m" }, + pgflowlevel: { signature: "m" }, + pgflowlevelobj: { signature: "m m" }, + pgflowlevelscope: { signature: "m" }, + startpgflowlevelscope: { signature: "m" }, + pgfviewboxscope: { signature: "m m m m m" }, + startpgfviewboxscope: { signature: "m m m m m" }, + pgftransformnonlinear: { signature: "m" }, + pgfpointtransformednonlinear: { signature: "m" }, + pgfsetcurvilinearbeziercurve: { signature: "m m m m" }, + pgfcurvilineardistancetotime: { signature: "m" }, + pgfpointcurvilinearbezierorthogonal: { signature: "m m" }, + pgfpointcurvilinearbezierpolar: { signature: "m m" }, + // Matrices + pgfmatrix: { signature: "m m m m m m m" }, + pgfsetmatrixcolumnsep: { signature: "m" }, + pgfmatrixnextcell: { signature: "o" }, + pgfsetmatrixrowsep: { signature: "m" }, + pgfmatrixendrow: { signature: "o" }, + // Nodes and shapes + pgfnode: { signature: "m m m m m" }, + pgfmultipartnode: { signature: "m m m m" }, + pgfcoordinate: { signature: "m m" }, + pgfnodealias: { signature: "m m" }, + pgfnoderename: { signature: "m m" }, + pgfpositionnodelater: { signature: "m" }, + pgfpositionnodenow: { signature: "m" }, + pgfnodepostsetupcode: { signature: "m m" }, + pgfpointanchor: { signature: "m m" }, + pgfpointshapeborder: { signature: "m m" }, + pgfdeclareshape: { signature: "m m" }, + saveddimen: { signature: "m m" }, + savedmacro: { signature: " m" }, + anchor: { signature: "m m" }, + deferredanchor: { signature: "m m" }, + anchorborder: { signature: "m" }, + backgroundpath: { signature: "m" }, + foregroundpath: { signature: "m" }, + behindbackgroundpath: { signature: "m" }, + beforebackgroundpath: { signature: "m" }, + beforeforegroundpath: { signature: "m" }, + behindforegroundpath: { signature: "m" }, + // Arrows + pgfdeclarearrow: { signature: "m" }, + pgfarrowssettipend: { signature: "m" }, + pgfarrowssetbackend: { signature: "m" }, + pgfarrowssetlineend: { signature: "m" }, + pgfarrowssetvisualbackend: { signature: "m" }, + pgfarrowssetvisualtipend: { signature: "m" }, + pgfarrowshullpoint: { signature: "m m" }, + pgfarrowsupperhullpoint: { signature: "m m" }, + pgfarrowssave: { signature: "m" }, + pgfarrowssavethe: { signature: "m" }, + pgfarrowsaddtooptions: { signature: "m" }, + pgfarrowsaddtolateoptions: { signature: "m" }, + pgfarrowsaddtolengthscalelist: { signature: "m" }, + pgfarrowsaddtowidthscalelist: { signature: "m" }, + pgfarrowsthreeparameters: { signature: "m" }, + pgfarrowslinewidthdependent: { signature: "m m m" }, + pgfarrowslengthdependent: { signature: "m" }, + // Path + pgfusepath: { signature: "m" }, + pgfsetlinewidth: { signature: "m" }, + pgfsetmiterlimit: { signature: "m" }, + pgfsetdash: { signature: "m m" }, + pgfsetstrokecolor: { signature: "m" }, + pgfsetcolor: { signature: "m" }, + pgfsetinnerlinewidth: { signature: "m" }, + pgfsetinnerstrokecolor: { signature: "m" }, + pgfsetarrowsstart: { signature: "m" }, + pgfsetarrowsend: { signature: "m" }, + pgfsetarrows: { signature: "m" }, + pgfsetshortenstart: { signature: "m" }, + pgfsetshortenend: { signature: "m" }, + pgfsetfillcolor: { signature: "m" }, + // Decorations + pgfdeclaredecoration: { signature: "m m m" }, + state: { signature: "m o m" }, + pgfdecoratepath: { signature: "m m" }, + startpgfdecoration: { signature: "m" }, + pgfdecoration: { signature: "m" }, + pgfdecoratecurrentpath: { signature: "m" }, + pgfsetdecorationsegmenttransformation: { signature: "m" }, + pgfdeclaremetadecorate: { signature: "m m m" }, + pgfmetadecoration: { signature: "m" }, + startpgfmetadecoration: { signature: "m" }, + // Constructing paths + pgfpathmoveto: { signature: "m" }, + pgfpathlineto: { signature: "m" }, + pgfpathcurveto: { signature: "m m m" }, + pgfpathquadraticcurveto: { signature: "m m" }, + pgfpathcurvebetweentime: { signature: "m m m m m m" }, + pgfpathcurvebetweentimecontinue: { signature: "m m m m m m" }, + pgfpatharc: { signature: "m m m" }, + pgfpatharcaxes: { signature: "m m m m" }, + pgfpatharcto: { signature: "m m m m m m" }, + pgfpatharctoprecomputed: { signature: "m m m m m m m m" }, + pgfpathellipse: { signature: "m m m" }, + pgfpathcircle: { signature: "m m" }, + pgfpathrectangle: { signature: "m m" }, + pgfpathrectanglecorners: { signature: "m m" }, + pgfpathgrid: { signature: " o m m" }, + pgfpathparabola: { signature: "m m" }, + pgfpathsine: { signature: "m" }, + pgfpathcosine: { signature: "m" }, + pgfsetcornersarced: { signature: "m" }, + "pgf@protocolsizes": { signature: "m m" }, + // Specifying coordinates + pgfpoint: { signature: "m m" }, + pgfpointpolar: { signature: "m m m" }, + pgfpointxy: { signature: "m m" }, + pgfsetxvec: { signature: "m" }, + pgfsetyvec: { signature: "m" }, + pgfpointpolarxy: { signature: "m m" }, + pgfpointxyz: { signature: "m m m" }, + pgfsetzvec: { signature: "m" }, + pgfpointcylindrical: { signature: "m m m" }, + pgfpointspherical: { signature: "m m m" }, + pgfpointadd: { signature: "m m" }, + pgfpointscale: { signature: "m m" }, + pgfpointdiff: { signature: "m m" }, + pgfpointnormalised: { signature: "m" }, + pgfpointlineattime: { signature: "m m m" }, + pgfpointlineatdistance: { signature: "m m m" }, + pgfpointarcaxesattime: { signature: "m m m m m m" }, + pgfpointcurveattime: { signature: "m m m m m" }, + pgfpointborderrectangle: { signature: "m m" }, + pgfpointborderellipse: { signature: "m m" }, + pgfpointintersectionoflines: { signature: "m m m m" }, + pgfpointintersectionofcircles: { signature: "m m m m m" }, + pgfintersectionofpaths: { signature: "m m" }, + pgfpointintersectionsolution: { signature: "m" }, + pgfextractx: { signature: "m m" }, + pgfextracty: { signature: "m m" }, + pgfgetlastxy: { signature: "m m" }, + "pgf@process": { signature: "m" }, + // Heirarchical structres ... + pgfsetbaseline: { signature: "m" }, + pgfsetbaselinepointnow: { signature: "m" }, + pgfsetbaselinepointlater: { signature: "m" }, + pgftext: { signature: "o m", renderInfo: { pgfkeysArgs: true } }, + pgfuseid: { signature: "m" }, + pgfusetype: { signature: "m" }, + pgfidrefnextuse: { signature: "m m" }, + pgfidrefprevuse: { signature: "m m" }, + pgfaliasid: { signature: "m m" }, + pgfgaliasid: { signature: "m m" }, + pgfifidreferenced: { signature: "m m m" }, + pgfrdfabout: { signature: "m" }, + pgfrdfcontent: { signature: "m" }, + pgfrdfdatatype: { signature: "m" }, + pgfrdfhref: { signature: "m" }, + pgfrdfprefix: { signature: "m" }, + pgfrdfproperty: { signature: "m" }, + pgfrdfrel: { signature: "m" }, + pgfrdfresource: { signature: "m" }, + pgfrdfrev: { signature: "m" }, + pgfrdfsrc: { signature: "m" }, + pgfrdftypeof: { signature: "m" }, + pgfrdfvocab: { signature: "m" }, + pgferror: { signature: "m" }, + pgfwarning: { signature: "m" }, + path: { + signature: "u;", + renderInfo: { breakAround: true, tikzPathCommand: true } + }, + draw: { + signature: "u;", + renderInfo: { breakAround: true, tikzPathCommand: true } + }, + fill: { + signature: "u;", + renderInfo: { breakAround: true, tikzPathCommand: true } + }, + filldraw: { + signature: "u;", + renderInfo: { breakAround: true, tikzPathCommand: true } + }, + pattern: { + signature: "u;", + renderInfo: { breakAround: true, tikzPathCommand: true } + }, + shade: { + signature: "u;", + renderInfo: { breakAround: true, tikzPathCommand: true } + }, + clip: { + signature: "u;", + renderInfo: { breakAround: true, tikzPathCommand: true } + }, + useasboundingbox: { + signature: "u;", + renderInfo: { breakAround: true, tikzPathCommand: true } + }, + node: { + signature: "u;", + renderInfo: { breakAround: true, tikzPathCommand: true } + }, + coordinate: { + signature: "u;", + renderInfo: { breakAround: true, tikzPathCommand: true } + }, + graph: { + signature: "u;", + renderInfo: { breakAround: true, tikzPathCommand: true } + }, + scoped: { + signature: "o o m", + argumentParser: tikzCommandArgumentParser, + renderInfo: { + namedArguments: ["animation", "options", "command"], + breakAround: true + } + } +}; +var macros13 = { + substitutecolormodel: { + signature: "m m", + renderInfo: { breakAround: true } + }, + selectcolormodel: { + signature: "m", + renderInfo: { breakAround: true } + }, + definecolor: { + signature: "o m m m", + renderInfo: { breakAround: true } + }, + providecolor: { + signature: "o m m m", + renderInfo: { breakAround: true } + }, + colorlet: { + signature: "o m o m", + renderInfo: { breakAround: true } + }, + definecolorset: { + signature: "o m m m", + renderInfo: { breakAround: true } + }, + providecolorset: { + signature: "o m m m m", + renderInfo: { breakAround: true } + }, + preparecolor: { + signature: "o m m m", + renderInfo: { breakAround: true } + }, + preparecolorset: { + signature: "o m m m m", + renderInfo: { breakAround: true } + }, + DefineNamedColor: { + signature: "m m m m", + renderInfo: { breakAround: true } + }, + definecolors: { + signature: "m", + renderInfo: { breakAround: true } + }, + providecolors: { + signature: "m", + renderInfo: { breakAround: true } + }, + color: { signature: "o m", renderInfo: { breakAround: true } }, + textcolor: { signature: "o m m", renderInfo: { inParMode: true } }, + pagecolor: { signature: "o m" }, + colorbox: { signature: "o m m" }, + fcolorbox: { signature: "o m o m m" }, + boxframe: { signature: "o m" }, + testcolor: { signature: "o m" }, + blendcolors: { signature: "s m" }, + maskcolors: { signature: "o m" }, + definecolorseries: { + signature: "m m m o m o m", + renderInfo: { breakAround: true } + }, + resetcolorseries: { + signature: "o m", + renderInfo: { breakAround: true } + }, + rowcolors: { signature: "s o m m m" }, + extractcolorspec: { signature: "m m" }, + extractcolorspecs: { signature: "m m m" }, + convertcolorspec: { signature: "m m m m" } +}; +var environments13 = { + testcolors: { signature: "o", renderInfo: { pgfkeysArgs: true } } +}; +var fromRgb = ([r, g, b]) => Color2([r * 255, g * 255, b * 255], "rgb"); +var DVI_PS_NAMES = { + Apricot: Color2("#FBB982"), + Aquamarine: Color2("#00B5BE"), + Bittersweet: Color2("#C04F17"), + Black: Color2("#221E1F"), + Blue: Color2("#2D2F92"), + BlueGreen: Color2("#00B3B8"), + BlueViolet: Color2("#473992"), + BrickRed: Color2("#B6321C"), + Brown: Color2("#792500"), + BurntOrange: Color2("#F7921D"), + CadetBlue: Color2("#74729A"), + CarnationPink: Color2("#F282B4"), + Cerulean: Color2("#00A2E3"), + CornflowerBlue: Color2("#41B0E4"), + Cyan: Color2("#00AEEF"), + Dandelion: Color2("#FDBC42"), + DarkOrchid: Color2("#A4538A"), + Emerald: Color2("#00A99D"), + ForestGreen: Color2("#009B55"), + Fuchsia: Color2("#8C368C"), + Goldenrod: Color2("#FFDF42"), + Gray: Color2("#949698"), + Green: Color2("#00A64F"), + GreenYellow: Color2("#DFE674"), + JungleGreen: Color2("#00A99A"), + Lavender: Color2("#F49EC4"), + LimeGreen: Color2("#8DC73E"), + Magenta: Color2("#EC008C"), + Mahogany: Color2("#A9341F"), + Maroon: Color2("#AF3235"), + Melon: Color2("#F89E7B"), + MidnightBlue: Color2("#006795"), + Mulberry: Color2("#A93C93"), + NavyBlue: Color2("#006EB8"), + OliveGreen: Color2("#3C8031"), + Orange: Color2("#F58137"), + OrangeRed: Color2("#ED135A"), + Orchid: Color2("#AF72B0"), + Peach: Color2("#F7965A"), + Periwinkle: Color2("#7977B8"), + PineGreen: Color2("#008B72"), + Plum: Color2("#92268F"), + ProcessBlue: Color2("#00B0F0"), + Purple: Color2("#99479B"), + RawSienna: Color2("#974006"), + Red: Color2("#ED1B23"), + RedOrange: Color2("#F26035"), + RedViolet: Color2("#A1246B"), + Rhodamine: Color2("#EF559F"), + RoyalBlue: Color2("#0071BC"), + RoyalPurple: Color2("#613F99"), + RubineRed: Color2("#ED017D"), + Salmon: Color2("#F69289"), + SeaGreen: Color2("#3FBC9D"), + Sepia: Color2("#671800"), + SkyBlue: Color2("#46C5DD"), + SpringGreen: Color2("#C6DC67"), + Tan: Color2("#DA9D76"), + TealBlue: Color2("#00AEB3"), + Thistle: Color2("#D883B7"), + Turquoise: Color2("#00B4CE"), + Violet: Color2("#58429B"), + VioletRed: Color2("#EF58A0"), + White: Color2("#FFFFFF"), + WildStrawberry: Color2("#EE2967"), + Yellow: Color2("#FFF200"), + YellowGreen: Color2("#98CC70"), + YellowOrange: Color2("#FAA21A") +}; +var SVG_NAMES = { + AliceBlue: fromRgb([0.94, 0.972, 1]), + AntiqueWhite: fromRgb([0.98, 0.92, 0.844]), + Aqua: fromRgb([0, 1, 1]), + Aquamarine: fromRgb([0.498, 1, 0.83]), + Azure: fromRgb([0.94, 1, 1]), + Beige: fromRgb([0.96, 0.96, 0.864]), + Bisque: fromRgb([1, 0.894, 0.77]), + Black: fromRgb([0, 0, 0]), + BlanchedAlmond: fromRgb([1, 0.92, 0.804]), + Blue: fromRgb([0, 0, 1]), + BlueViolet: fromRgb([0.54, 0.17, 0.888]), + Brown: fromRgb([0.648, 0.165, 0.165]), + BurlyWood: fromRgb([0.87, 0.72, 0.53]), + CadetBlue: fromRgb([0.372, 0.62, 0.628]), + Chartreuse: fromRgb([0.498, 1, 0]), + Chocolate: fromRgb([0.824, 0.41, 0.116]), + Coral: fromRgb([1, 0.498, 0.312]), + CornflowerBlue: fromRgb([0.392, 0.585, 0.93]), + Cornsilk: fromRgb([1, 0.972, 0.864]), + Crimson: fromRgb([0.864, 0.08, 0.235]), + Cyan: fromRgb([0, 1, 1]), + DarkBlue: fromRgb([0, 0, 0.545]), + DarkCyan: fromRgb([0, 0.545, 0.545]), + DarkGoldenrod: fromRgb([0.72, 0.525, 0.044]), + DarkGray: fromRgb([0.664, 0.664, 0.664]), + DarkGreen: fromRgb([0, 0.392, 0]), + DarkGrey: fromRgb([0.664, 0.664, 0.664]), + DarkKhaki: fromRgb([0.74, 0.716, 0.42]), + DarkMagenta: fromRgb([0.545, 0, 0.545]), + DarkOliveGreen: fromRgb([0.332, 0.42, 0.185]), + DarkOrange: fromRgb([1, 0.55, 0]), + DarkOrchid: fromRgb([0.6, 0.196, 0.8]), + DarkRed: fromRgb([0.545, 0, 0]), + DarkSalmon: fromRgb([0.912, 0.59, 0.48]), + DarkSeaGreen: fromRgb([0.56, 0.736, 0.56]), + DarkSlateBlue: fromRgb([0.284, 0.24, 0.545]), + DarkSlateGray: fromRgb([0.185, 0.31, 0.31]), + DarkSlateGrey: fromRgb([0.185, 0.31, 0.31]), + DarkTurquoise: fromRgb([0, 0.808, 0.82]), + DarkViolet: fromRgb([0.58, 0, 0.828]), + DeepPink: fromRgb([1, 0.08, 0.576]), + DeepSkyBlue: fromRgb([0, 0.75, 1]), + DimGray: fromRgb([0.41, 0.41, 0.41]), + DimGrey: fromRgb([0.41, 0.41, 0.41]), + DodgerBlue: fromRgb([0.116, 0.565, 1]), + FireBrick: fromRgb([0.698, 0.132, 0.132]), + FloralWhite: fromRgb([1, 0.98, 0.94]), + ForestGreen: fromRgb([0.132, 0.545, 0.132]), + Fuchsia: fromRgb([1, 0, 1]), + Gainsboro: fromRgb([0.864, 0.864, 0.864]), + GhostWhite: fromRgb([0.972, 0.972, 1]), + Gold: fromRgb([1, 0.844, 0]), + Goldenrod: fromRgb([0.855, 0.648, 0.125]), + Gray: fromRgb([0.5, 0.5, 0.5]), + Green: fromRgb([0, 0.5, 0]), + GreenYellow: fromRgb([0.68, 1, 0.185]), + Grey: fromRgb([0.5, 0.5, 0.5]), + Honeydew: fromRgb([0.94, 1, 0.94]), + HotPink: fromRgb([1, 0.41, 0.705]), + IndianRed: fromRgb([0.804, 0.36, 0.36]), + Indigo: fromRgb([0.294, 0, 0.51]), + Ivory: fromRgb([1, 1, 0.94]), + Khaki: fromRgb([0.94, 0.9, 0.55]), + Lavender: fromRgb([0.9, 0.9, 0.98]), + LavenderBlush: fromRgb([1, 0.94, 0.96]), + LawnGreen: fromRgb([0.488, 0.99, 0]), + LemonChiffon: fromRgb([1, 0.98, 0.804]), + LightBlue: fromRgb([0.68, 0.848, 0.9]), + LightCoral: fromRgb([0.94, 0.5, 0.5]), + LightCyan: fromRgb([0.88, 1, 1]), + LightGoldenrod: fromRgb([0.933, 0.867, 0.51]), + LightGoldenrodYellow: fromRgb([0.98, 0.98, 0.824]), + LightGray: fromRgb([0.828, 0.828, 0.828]), + LightGreen: fromRgb([0.565, 0.932, 0.565]), + LightGrey: fromRgb([0.828, 0.828, 0.828]), + LightPink: fromRgb([1, 0.712, 0.756]), + LightSalmon: fromRgb([1, 0.628, 0.48]), + LightSeaGreen: fromRgb([0.125, 0.698, 0.668]), + LightSkyBlue: fromRgb([0.53, 0.808, 0.98]), + LightSlateBlue: fromRgb([0.518, 0.44, 1]), + LightSlateGray: fromRgb([0.468, 0.532, 0.6]), + LightSlateGrey: fromRgb([0.468, 0.532, 0.6]), + LightSteelBlue: fromRgb([0.69, 0.77, 0.87]), + LightYellow: fromRgb([1, 1, 0.88]), + Lime: fromRgb([0, 1, 0]), + LimeGreen: fromRgb([0.196, 0.804, 0.196]), + Linen: fromRgb([0.98, 0.94, 0.9]), + Magenta: fromRgb([1, 0, 1]), + Maroon: fromRgb([0.5, 0, 0]), + MediumAquamarine: fromRgb([0.4, 0.804, 0.668]), + MediumBlue: fromRgb([0, 0, 0.804]), + MediumOrchid: fromRgb([0.73, 0.332, 0.828]), + MediumPurple: fromRgb([0.576, 0.44, 0.86]), + MediumSeaGreen: fromRgb([0.235, 0.7, 0.444]), + MediumSlateBlue: fromRgb([0.484, 0.408, 0.932]), + MediumSpringGreen: fromRgb([0, 0.98, 0.604]), + MediumTurquoise: fromRgb([0.284, 0.82, 0.8]), + MediumVioletRed: fromRgb([0.78, 0.084, 0.52]), + MidnightBlue: fromRgb([0.098, 0.098, 0.44]), + MintCream: fromRgb([0.96, 1, 0.98]), + MistyRose: fromRgb([1, 0.894, 0.884]), + Moccasin: fromRgb([1, 0.894, 0.71]), + NavajoWhite: fromRgb([1, 0.87, 0.68]), + Navy: fromRgb([0, 0, 0.5]), + NavyBlue: fromRgb([0, 0, 0.5]), + OldLace: fromRgb([0.992, 0.96, 0.9]), + Olive: fromRgb([0.5, 0.5, 0]), + OliveDrab: fromRgb([0.42, 0.556, 0.136]), + Orange: fromRgb([1, 0.648, 0]), + OrangeRed: fromRgb([1, 0.27, 0]), + Orchid: fromRgb([0.855, 0.44, 0.84]), + PaleGoldenrod: fromRgb([0.932, 0.91, 0.668]), + PaleGreen: fromRgb([0.596, 0.985, 0.596]), + PaleTurquoise: fromRgb([0.688, 0.932, 0.932]), + PaleVioletRed: fromRgb([0.86, 0.44, 0.576]), + PapayaWhip: fromRgb([1, 0.936, 0.835]), + PeachPuff: fromRgb([1, 0.855, 0.725]), + Peru: fromRgb([0.804, 0.52, 0.248]), + Pink: fromRgb([1, 0.752, 0.796]), + Plum: fromRgb([0.868, 0.628, 0.868]), + PowderBlue: fromRgb([0.69, 0.88, 0.9]), + Purple: fromRgb([0.5, 0, 0.5]), + Red: fromRgb([1, 0, 0]), + RosyBrown: fromRgb([0.736, 0.56, 0.56]), + RoyalBlue: fromRgb([0.255, 0.41, 0.884]), + SaddleBrown: fromRgb([0.545, 0.27, 0.075]), + Salmon: fromRgb([0.98, 0.5, 0.448]), + SandyBrown: fromRgb([0.956, 0.644, 0.376]), + SeaGreen: fromRgb([0.18, 0.545, 0.34]), + Seashell: fromRgb([1, 0.96, 0.932]), + Sienna: fromRgb([0.628, 0.32, 0.176]), + Silver: fromRgb([0.752, 0.752, 0.752]), + SkyBlue: fromRgb([0.53, 0.808, 0.92]), + SlateBlue: fromRgb([0.415, 0.352, 0.804]), + SlateGray: fromRgb([0.44, 0.5, 0.565]), + SlateGrey: fromRgb([0.44, 0.5, 0.565]), + Snow: fromRgb([1, 0.98, 0.98]), + SpringGreen: fromRgb([0, 1, 0.498]), + SteelBlue: fromRgb([0.275, 0.51, 0.705]), + Tan: fromRgb([0.824, 0.705, 0.55]), + Teal: fromRgb([0, 0.5, 0.5]), + Thistle: fromRgb([0.848, 0.75, 0.848]), + Tomato: fromRgb([1, 0.39, 0.28]), + Turquoise: fromRgb([0.25, 0.88, 0.815]), + Violet: fromRgb([0.932, 0.51, 0.932]), + VioletRed: fromRgb([0.816, 0.125, 0.565]), + Wheat: fromRgb([0.96, 0.87, 0.7]), + White: fromRgb([1, 1, 1]), + WhiteSmoke: fromRgb([0.96, 0.96, 0.96]), + Yellow: fromRgb([1, 1, 0]), + YellowGreen: fromRgb([0.604, 0.804, 0.196]) +}; +var X11_NAMES = { + AntiqueWhite1: fromRgb([1, 0.936, 0.86]), + AntiqueWhite2: fromRgb([0.932, 0.875, 0.8]), + AntiqueWhite3: fromRgb([0.804, 0.752, 0.69]), + AntiqueWhite4: fromRgb([0.545, 0.512, 0.47]), + Aquamarine1: fromRgb([0.498, 1, 0.83]), + Aquamarine2: fromRgb([0.464, 0.932, 0.776]), + Aquamarine3: fromRgb([0.4, 0.804, 0.668]), + Aquamarine4: fromRgb([0.27, 0.545, 0.455]), + Azure1: fromRgb([0.94, 1, 1]), + Azure2: fromRgb([0.88, 0.932, 0.932]), + Azure3: fromRgb([0.756, 0.804, 0.804]), + Azure4: fromRgb([0.512, 0.545, 0.545]), + Bisque1: fromRgb([1, 0.894, 0.77]), + Bisque2: fromRgb([0.932, 0.835, 0.716]), + Bisque3: fromRgb([0.804, 0.716, 0.62]), + Bisque4: fromRgb([0.545, 0.49, 0.42]), + Blue1: fromRgb([0, 0, 1]), + Blue2: fromRgb([0, 0, 0.932]), + Blue3: fromRgb([0, 0, 0.804]), + Blue4: fromRgb([0, 0, 0.545]), + Brown1: fromRgb([1, 0.25, 0.25]), + Brown2: fromRgb([0.932, 0.23, 0.23]), + Brown3: fromRgb([0.804, 0.2, 0.2]), + Brown4: fromRgb([0.545, 0.136, 0.136]), + Burlywood1: fromRgb([1, 0.828, 0.608]), + Burlywood2: fromRgb([0.932, 0.772, 0.57]), + Burlywood3: fromRgb([0.804, 0.668, 0.49]), + Burlywood4: fromRgb([0.545, 0.45, 0.332]), + CadetBlue1: fromRgb([0.596, 0.96, 1]), + CadetBlue2: fromRgb([0.556, 0.898, 0.932]), + CadetBlue3: fromRgb([0.48, 0.772, 0.804]), + CadetBlue4: fromRgb([0.325, 0.525, 0.545]), + Chartreuse1: fromRgb([0.498, 1, 0]), + Chartreuse2: fromRgb([0.464, 0.932, 0]), + Chartreuse3: fromRgb([0.4, 0.804, 0]), + Chartreuse4: fromRgb([0.27, 0.545, 0]), + Chocolate1: fromRgb([1, 0.498, 0.14]), + Chocolate2: fromRgb([0.932, 0.464, 0.13]), + Chocolate3: fromRgb([0.804, 0.4, 0.112]), + Chocolate4: fromRgb([0.545, 0.27, 0.075]), + Coral1: fromRgb([1, 0.448, 0.336]), + Coral2: fromRgb([0.932, 0.415, 0.312]), + Coral3: fromRgb([0.804, 0.356, 0.27]), + Coral4: fromRgb([0.545, 0.244, 0.185]), + Cornsilk1: fromRgb([1, 0.972, 0.864]), + Cornsilk2: fromRgb([0.932, 0.91, 0.804]), + Cornsilk3: fromRgb([0.804, 0.785, 0.694]), + Cornsilk4: fromRgb([0.545, 0.532, 0.47]), + Cyan1: fromRgb([0, 1, 1]), + Cyan2: fromRgb([0, 0.932, 0.932]), + Cyan3: fromRgb([0, 0.804, 0.804]), + Cyan4: fromRgb([0, 0.545, 0.545]), + DarkGoldenrod1: fromRgb([1, 0.725, 0.06]), + DarkGoldenrod2: fromRgb([0.932, 0.68, 0.055]), + DarkGoldenrod3: fromRgb([0.804, 0.585, 0.048]), + DarkGoldenrod4: fromRgb([0.545, 0.396, 0.03]), + DarkOliveGreen1: fromRgb([0.792, 1, 0.44]), + DarkOliveGreen2: fromRgb([0.736, 0.932, 0.408]), + DarkOliveGreen3: fromRgb([0.635, 0.804, 0.352]), + DarkOliveGreen4: fromRgb([0.43, 0.545, 0.24]), + DarkOrange1: fromRgb([1, 0.498, 0]), + DarkOrange2: fromRgb([0.932, 0.464, 0]), + DarkOrange3: fromRgb([0.804, 0.4, 0]), + DarkOrange4: fromRgb([0.545, 0.27, 0]), + DarkOrchid1: fromRgb([0.75, 0.244, 1]), + DarkOrchid2: fromRgb([0.698, 0.228, 0.932]), + DarkOrchid3: fromRgb([0.604, 0.196, 0.804]), + DarkOrchid4: fromRgb([0.408, 0.132, 0.545]), + DarkSeaGreen1: fromRgb([0.756, 1, 0.756]), + DarkSeaGreen2: fromRgb([0.705, 0.932, 0.705]), + DarkSeaGreen3: fromRgb([0.608, 0.804, 0.608]), + DarkSeaGreen4: fromRgb([0.41, 0.545, 0.41]), + DarkSlateGray1: fromRgb([0.592, 1, 1]), + DarkSlateGray2: fromRgb([0.552, 0.932, 0.932]), + DarkSlateGray3: fromRgb([0.475, 0.804, 0.804]), + DarkSlateGray4: fromRgb([0.32, 0.545, 0.545]), + DeepPink1: fromRgb([1, 0.08, 0.576]), + DeepPink2: fromRgb([0.932, 0.07, 0.536]), + DeepPink3: fromRgb([0.804, 0.064, 0.464]), + DeepPink4: fromRgb([0.545, 0.04, 0.312]), + DeepSkyBlue1: fromRgb([0, 0.75, 1]), + DeepSkyBlue2: fromRgb([0, 0.698, 0.932]), + DeepSkyBlue3: fromRgb([0, 0.604, 0.804]), + DeepSkyBlue4: fromRgb([0, 0.408, 0.545]), + DodgerBlue1: fromRgb([0.116, 0.565, 1]), + DodgerBlue2: fromRgb([0.11, 0.525, 0.932]), + DodgerBlue3: fromRgb([0.094, 0.455, 0.804]), + DodgerBlue4: fromRgb([0.064, 0.305, 0.545]), + Firebrick1: fromRgb([1, 0.19, 0.19]), + Firebrick2: fromRgb([0.932, 0.172, 0.172]), + Firebrick3: fromRgb([0.804, 0.15, 0.15]), + Firebrick4: fromRgb([0.545, 0.1, 0.1]), + Gold1: fromRgb([1, 0.844, 0]), + Gold2: fromRgb([0.932, 0.79, 0]), + Gold3: fromRgb([0.804, 0.68, 0]), + Gold4: fromRgb([0.545, 0.46, 0]), + Goldenrod1: fromRgb([1, 0.756, 0.145]), + Goldenrod2: fromRgb([0.932, 0.705, 0.132]), + Goldenrod3: fromRgb([0.804, 0.608, 0.112]), + Goldenrod4: fromRgb([0.545, 0.41, 0.08]), + Green1: fromRgb([0, 1, 0]), + Green2: fromRgb([0, 0.932, 0]), + Green3: fromRgb([0, 0.804, 0]), + Green4: fromRgb([0, 0.545, 0]), + Honeydew1: fromRgb([0.94, 1, 0.94]), + Honeydew2: fromRgb([0.88, 0.932, 0.88]), + Honeydew3: fromRgb([0.756, 0.804, 0.756]), + Honeydew4: fromRgb([0.512, 0.545, 0.512]), + HotPink1: fromRgb([1, 0.43, 0.705]), + HotPink2: fromRgb([0.932, 0.415, 0.655]), + HotPink3: fromRgb([0.804, 0.376, 0.565]), + HotPink4: fromRgb([0.545, 0.228, 0.385]), + IndianRed1: fromRgb([1, 0.415, 0.415]), + IndianRed2: fromRgb([0.932, 0.39, 0.39]), + IndianRed3: fromRgb([0.804, 0.332, 0.332]), + IndianRed4: fromRgb([0.545, 0.228, 0.228]), + Ivory1: fromRgb([1, 1, 0.94]), + Ivory2: fromRgb([0.932, 0.932, 0.88]), + Ivory3: fromRgb([0.804, 0.804, 0.756]), + Ivory4: fromRgb([0.545, 0.545, 0.512]), + Khaki1: fromRgb([1, 0.965, 0.56]), + Khaki2: fromRgb([0.932, 0.9, 0.52]), + Khaki3: fromRgb([0.804, 0.776, 0.45]), + Khaki4: fromRgb([0.545, 0.525, 0.305]), + LavenderBlush1: fromRgb([1, 0.94, 0.96]), + LavenderBlush2: fromRgb([0.932, 0.88, 0.898]), + LavenderBlush3: fromRgb([0.804, 0.756, 0.772]), + LavenderBlush4: fromRgb([0.545, 0.512, 0.525]), + LemonChiffon1: fromRgb([1, 0.98, 0.804]), + LemonChiffon2: fromRgb([0.932, 0.912, 0.75]), + LemonChiffon3: fromRgb([0.804, 0.79, 0.648]), + LemonChiffon4: fromRgb([0.545, 0.536, 0.44]), + LightBlue1: fromRgb([0.75, 0.936, 1]), + LightBlue2: fromRgb([0.698, 0.875, 0.932]), + LightBlue3: fromRgb([0.604, 0.752, 0.804]), + LightBlue4: fromRgb([0.408, 0.512, 0.545]), + LightCyan1: fromRgb([0.88, 1, 1]), + LightCyan2: fromRgb([0.82, 0.932, 0.932]), + LightCyan3: fromRgb([0.705, 0.804, 0.804]), + LightCyan4: fromRgb([0.48, 0.545, 0.545]), + LightGoldenrod1: fromRgb([1, 0.925, 0.545]), + LightGoldenrod2: fromRgb([0.932, 0.864, 0.51]), + LightGoldenrod3: fromRgb([0.804, 0.745, 0.44]), + LightGoldenrod4: fromRgb([0.545, 0.505, 0.298]), + LightPink1: fromRgb([1, 0.684, 0.725]), + LightPink2: fromRgb([0.932, 0.635, 0.68]), + LightPink3: fromRgb([0.804, 0.55, 0.585]), + LightPink4: fromRgb([0.545, 0.372, 0.396]), + LightSalmon1: fromRgb([1, 0.628, 0.48]), + LightSalmon2: fromRgb([0.932, 0.585, 0.448]), + LightSalmon3: fromRgb([0.804, 0.505, 0.385]), + LightSalmon4: fromRgb([0.545, 0.34, 0.26]), + LightSkyBlue1: fromRgb([0.69, 0.888, 1]), + LightSkyBlue2: fromRgb([0.644, 0.828, 0.932]), + LightSkyBlue3: fromRgb([0.552, 0.712, 0.804]), + LightSkyBlue4: fromRgb([0.376, 0.484, 0.545]), + LightSteelBlue1: fromRgb([0.792, 0.884, 1]), + LightSteelBlue2: fromRgb([0.736, 0.824, 0.932]), + LightSteelBlue3: fromRgb([0.635, 0.71, 0.804]), + LightSteelBlue4: fromRgb([0.43, 0.484, 0.545]), + LightYellow1: fromRgb([1, 1, 0.88]), + LightYellow2: fromRgb([0.932, 0.932, 0.82]), + LightYellow3: fromRgb([0.804, 0.804, 0.705]), + LightYellow4: fromRgb([0.545, 0.545, 0.48]), + Magenta1: fromRgb([1, 0, 1]), + Magenta2: fromRgb([0.932, 0, 0.932]), + Magenta3: fromRgb([0.804, 0, 0.804]), + Magenta4: fromRgb([0.545, 0, 0.545]), + Maroon1: fromRgb([1, 0.204, 0.7]), + Maroon2: fromRgb([0.932, 0.19, 0.655]), + Maroon3: fromRgb([0.804, 0.16, 0.565]), + Maroon4: fromRgb([0.545, 0.11, 0.385]), + MediumOrchid1: fromRgb([0.88, 0.4, 1]), + MediumOrchid2: fromRgb([0.82, 0.372, 0.932]), + MediumOrchid3: fromRgb([0.705, 0.32, 0.804]), + MediumOrchid4: fromRgb([0.48, 0.215, 0.545]), + MediumPurple1: fromRgb([0.67, 0.51, 1]), + MediumPurple2: fromRgb([0.624, 0.475, 0.932]), + MediumPurple3: fromRgb([0.536, 0.408, 0.804]), + MediumPurple4: fromRgb([0.365, 0.28, 0.545]), + MistyRose1: fromRgb([1, 0.894, 0.884]), + MistyRose2: fromRgb([0.932, 0.835, 0.824]), + MistyRose3: fromRgb([0.804, 0.716, 0.71]), + MistyRose4: fromRgb([0.545, 0.49, 0.484]), + NavajoWhite1: fromRgb([1, 0.87, 0.68]), + NavajoWhite2: fromRgb([0.932, 0.81, 0.63]), + NavajoWhite3: fromRgb([0.804, 0.7, 0.545]), + NavajoWhite4: fromRgb([0.545, 0.475, 0.37]), + OliveDrab1: fromRgb([0.752, 1, 0.244]), + OliveDrab2: fromRgb([0.7, 0.932, 0.228]), + OliveDrab3: fromRgb([0.604, 0.804, 0.196]), + OliveDrab4: fromRgb([0.41, 0.545, 0.132]), + Orange1: fromRgb([1, 0.648, 0]), + Orange2: fromRgb([0.932, 0.604, 0]), + Orange3: fromRgb([0.804, 0.52, 0]), + Orange4: fromRgb([0.545, 0.352, 0]), + OrangeRed1: fromRgb([1, 0.27, 0]), + OrangeRed2: fromRgb([0.932, 0.25, 0]), + OrangeRed3: fromRgb([0.804, 0.215, 0]), + OrangeRed4: fromRgb([0.545, 0.145, 0]), + Orchid1: fromRgb([1, 0.512, 0.98]), + Orchid2: fromRgb([0.932, 0.48, 0.912]), + Orchid3: fromRgb([0.804, 0.41, 0.79]), + Orchid4: fromRgb([0.545, 0.28, 0.536]), + PaleGreen1: fromRgb([0.604, 1, 0.604]), + PaleGreen2: fromRgb([0.565, 0.932, 0.565]), + PaleGreen3: fromRgb([0.488, 0.804, 0.488]), + PaleGreen4: fromRgb([0.33, 0.545, 0.33]), + PaleTurquoise1: fromRgb([0.732, 1, 1]), + PaleTurquoise2: fromRgb([0.684, 0.932, 0.932]), + PaleTurquoise3: fromRgb([0.59, 0.804, 0.804]), + PaleTurquoise4: fromRgb([0.4, 0.545, 0.545]), + PaleVioletRed1: fromRgb([1, 0.51, 0.67]), + PaleVioletRed2: fromRgb([0.932, 0.475, 0.624]), + PaleVioletRed3: fromRgb([0.804, 0.408, 0.536]), + PaleVioletRed4: fromRgb([0.545, 0.28, 0.365]), + PeachPuff1: fromRgb([1, 0.855, 0.725]), + PeachPuff2: fromRgb([0.932, 0.796, 0.68]), + PeachPuff3: fromRgb([0.804, 0.688, 0.585]), + PeachPuff4: fromRgb([0.545, 0.468, 0.396]), + Pink1: fromRgb([1, 0.71, 0.772]), + Pink2: fromRgb([0.932, 0.664, 0.72]), + Pink3: fromRgb([0.804, 0.57, 0.62]), + Pink4: fromRgb([0.545, 0.39, 0.424]), + Plum1: fromRgb([1, 0.732, 1]), + Plum2: fromRgb([0.932, 0.684, 0.932]), + Plum3: fromRgb([0.804, 0.59, 0.804]), + Plum4: fromRgb([0.545, 0.4, 0.545]), + Purple1: fromRgb([0.608, 0.19, 1]), + Purple2: fromRgb([0.57, 0.172, 0.932]), + Purple3: fromRgb([0.49, 0.15, 0.804]), + Purple4: fromRgb([0.332, 0.1, 0.545]), + Red1: fromRgb([1, 0, 0]), + Red2: fromRgb([0.932, 0, 0]), + Red3: fromRgb([0.804, 0, 0]), + Red4: fromRgb([0.545, 0, 0]), + RosyBrown1: fromRgb([1, 0.756, 0.756]), + RosyBrown2: fromRgb([0.932, 0.705, 0.705]), + RosyBrown3: fromRgb([0.804, 0.608, 0.608]), + RosyBrown4: fromRgb([0.545, 0.41, 0.41]), + RoyalBlue1: fromRgb([0.284, 0.464, 1]), + RoyalBlue2: fromRgb([0.264, 0.43, 0.932]), + RoyalBlue3: fromRgb([0.228, 0.372, 0.804]), + RoyalBlue4: fromRgb([0.152, 0.25, 0.545]), + Salmon1: fromRgb([1, 0.55, 0.41]), + Salmon2: fromRgb([0.932, 0.51, 0.385]), + Salmon3: fromRgb([0.804, 0.44, 0.33]), + Salmon4: fromRgb([0.545, 0.298, 0.224]), + SeaGreen1: fromRgb([0.33, 1, 0.624]), + SeaGreen2: fromRgb([0.305, 0.932, 0.58]), + SeaGreen3: fromRgb([0.264, 0.804, 0.5]), + SeaGreen4: fromRgb([0.18, 0.545, 0.34]), + Seashell1: fromRgb([1, 0.96, 0.932]), + Seashell2: fromRgb([0.932, 0.898, 0.87]), + Seashell3: fromRgb([0.804, 0.772, 0.75]), + Seashell4: fromRgb([0.545, 0.525, 0.51]), + Sienna1: fromRgb([1, 0.51, 0.28]), + Sienna2: fromRgb([0.932, 0.475, 0.26]), + Sienna3: fromRgb([0.804, 0.408, 0.224]), + Sienna4: fromRgb([0.545, 0.28, 0.15]), + SkyBlue1: fromRgb([0.53, 0.808, 1]), + SkyBlue2: fromRgb([0.494, 0.752, 0.932]), + SkyBlue3: fromRgb([0.424, 0.65, 0.804]), + SkyBlue4: fromRgb([0.29, 0.44, 0.545]), + SlateBlue1: fromRgb([0.512, 0.435, 1]), + SlateBlue2: fromRgb([0.48, 0.404, 0.932]), + SlateBlue3: fromRgb([0.41, 0.35, 0.804]), + SlateBlue4: fromRgb([0.28, 0.235, 0.545]), + SlateGray1: fromRgb([0.776, 0.888, 1]), + SlateGray2: fromRgb([0.725, 0.828, 0.932]), + SlateGray3: fromRgb([0.624, 0.712, 0.804]), + SlateGray4: fromRgb([0.424, 0.484, 0.545]), + Snow1: fromRgb([1, 0.98, 0.98]), + Snow2: fromRgb([0.932, 0.912, 0.912]), + Snow3: fromRgb([0.804, 0.79, 0.79]), + Snow4: fromRgb([0.545, 0.536, 0.536]), + SpringGreen1: fromRgb([0, 1, 0.498]), + SpringGreen2: fromRgb([0, 0.932, 0.464]), + SpringGreen3: fromRgb([0, 0.804, 0.4]), + SpringGreen4: fromRgb([0, 0.545, 0.27]), + SteelBlue1: fromRgb([0.39, 0.72, 1]), + SteelBlue2: fromRgb([0.36, 0.675, 0.932]), + SteelBlue3: fromRgb([0.31, 0.58, 0.804]), + SteelBlue4: fromRgb([0.21, 0.392, 0.545]), + Tan1: fromRgb([1, 0.648, 0.31]), + Tan2: fromRgb([0.932, 0.604, 0.288]), + Tan3: fromRgb([0.804, 0.52, 0.248]), + Tan4: fromRgb([0.545, 0.352, 0.17]), + Thistle1: fromRgb([1, 0.884, 1]), + Thistle2: fromRgb([0.932, 0.824, 0.932]), + Thistle3: fromRgb([0.804, 0.71, 0.804]), + Thistle4: fromRgb([0.545, 0.484, 0.545]), + Tomato1: fromRgb([1, 0.39, 0.28]), + Tomato2: fromRgb([0.932, 0.36, 0.26]), + Tomato3: fromRgb([0.804, 0.31, 0.224]), + Tomato4: fromRgb([0.545, 0.21, 0.15]), + Turquoise1: fromRgb([0, 0.96, 1]), + Turquoise2: fromRgb([0, 0.898, 0.932]), + Turquoise3: fromRgb([0, 0.772, 0.804]), + Turquoise4: fromRgb([0, 0.525, 0.545]), + VioletRed1: fromRgb([1, 0.244, 0.59]), + VioletRed2: fromRgb([0.932, 0.228, 0.55]), + VioletRed3: fromRgb([0.804, 0.196, 0.47]), + VioletRed4: fromRgb([0.545, 0.132, 0.32]), + Wheat1: fromRgb([1, 0.905, 0.73]), + Wheat2: fromRgb([0.932, 0.848, 0.684]), + Wheat3: fromRgb([0.804, 0.73, 0.59]), + Wheat4: fromRgb([0.545, 0.494, 0.4]), + Yellow1: fromRgb([1, 1, 0]), + Yellow2: fromRgb([0.932, 0.932, 0]), + Yellow3: fromRgb([0.804, 0.804, 0]), + Yellow4: fromRgb([0.545, 0.545, 0]), + Gray0: fromRgb([0.745, 0.745, 0.745]), + Green0: fromRgb([0, 1, 0]), + Grey0: fromRgb([0.745, 0.745, 0.745]), + Maroon0: fromRgb([0.69, 0.19, 0.376]), + Purple0: fromRgb([0.628, 0.125, 0.94]) +}; +var XColorCoreModelToColor = { + rgb: ([r, g, b]) => Color2([r * 255, g * 255, b * 255], "rgb"), + cmy: ([c, m, y]) => XColorCoreModelToColor.rgb([1 - c, 1 - m, 1 - y]), + cmyk: ([c, m, y, k]) => Color2([c * 255, m * 255, y * 255, k * 100], "cmyk"), + hsb: ([h, s2, b]) => Color2([h * 360, s2 * 100, b * 100], "hsv"), + gray: ([v]) => Color2([v * 255, v * 255, v * 255], "rgb") +}; +({ + // Core colors + red: XColorCoreModelToColor.rgb([1, 0, 0]), + green: XColorCoreModelToColor.rgb([0, 1, 0]), + blue: XColorCoreModelToColor.rgb([0, 0, 1]), + brown: XColorCoreModelToColor.rgb([0.75, 0.5, 0.25]), + lime: XColorCoreModelToColor.rgb([0.75, 1, 0]), + orange: XColorCoreModelToColor.rgb([1, 0.5, 0]), + pink: XColorCoreModelToColor.rgb([1, 0.75, 0.75]), + purple: XColorCoreModelToColor.rgb([0.75, 0, 0.25]), + teal: XColorCoreModelToColor.rgb([0, 0.5, 0.5]), + violet: XColorCoreModelToColor.rgb([0.5, 0, 0.5]), + cyan: XColorCoreModelToColor.rgb([0, 1, 1]), + magenta: XColorCoreModelToColor.rgb([1, 0, 1]), + yellow: XColorCoreModelToColor.rgb([1, 1, 0]), + olive: XColorCoreModelToColor.rgb([0.5, 0.5, 0]), + black: XColorCoreModelToColor.rgb([0, 0, 0]), + darkgray: XColorCoreModelToColor.rgb([0.25, 0.25, 0.25]), + gray: XColorCoreModelToColor.rgb([0.5, 0.5, 0.5]), + lightgray: XColorCoreModelToColor.rgb([0.75, 0.75, 0.75]), + white: XColorCoreModelToColor.rgb([1, 1, 1]), + ...DVI_PS_NAMES, + ...SVG_NAMES, + ...X11_NAMES +}); +var macros14 = { + NewDocumentCommand: { + signature: "m m m", + renderInfo: { breakAround: true } + }, + RenewDocumentCommand: { + signature: "m m m", + renderInfo: { breakAround: true } + }, + ProvideDocumentCommand: { + signature: "m m m", + renderInfo: { breakAround: true } + }, + DeclareDocumentCommand: { + signature: "m m m", + renderInfo: { breakAround: true } + }, + NewDocumentEnvironment: { + signature: "m m m m", + renderInfo: { breakAround: true } + }, + RenewDocumentEnvironment: { + signature: "m m m m", + renderInfo: { breakAround: true } + }, + ProvideDocumentEnvironment: { + signature: "m m m m", + renderInfo: { breakAround: true } + }, + DeclareDocumentEnvironment: { + signature: "m m m m", + renderInfo: { breakAround: true } + }, + NewExpandableDocumentCommand: { + signature: "m m m", + renderInfo: { breakAround: true } + }, + RenewExpandableDocumentCommand: { + signature: "m m m", + renderInfo: { breakAround: true } + }, + ProvideExpandableDocumentCommand: { + signature: "m m m", + renderInfo: { breakAround: true } + }, + DeclareExpandableDocumentCommand: { + signature: "m m m", + renderInfo: { breakAround: true } + }, + RequirePackage: { + signature: "o m", + renderInfo: { pgfkeysArgs: true, breakAround: true } + }, + DeclareOption: { signature: "m m", renderInfo: { breakAround: true } } +}; +var environments14 = {}; +var macros15 = { + mode: { signature: "s d<> d{}", renderInfo: { breakAround: true } }, + insertnavigation: { signature: "m", renderInfo: { breakAround: true } }, + insertsectionnavigation: { + signature: "m", + renderInfo: { breakAround: true } + }, + insertsectionnavigationhorizontal: { + signature: "m m m", + renderInfo: { breakAround: true } + }, + insertauthor: { signature: "o", renderInfo: { breakAround: true } }, + insertshortauthor: { signature: "o", renderInfo: { breakAround: true } }, + insertshortdate: { signature: "o", renderInfo: { breakAround: true } }, + insertshortinstitute: { signature: "o", renderInfo: { breakAround: true } }, + insertshortpart: { signature: "o", renderInfo: { breakAround: true } }, + insertshorttitle: { signature: "o", renderInfo: { breakAround: true } }, + insertsubsectionnavigation: { + signature: "m", + renderInfo: { breakAround: true } + }, + insertsubsectionnavigationhorizontal: { + signature: "m m m", + renderInfo: { breakAround: true } + }, + insertverticalnavigation: { + signature: "m", + renderInfo: { breakAround: true } + }, + usebeamercolor: { signature: "s m", renderInfo: { breakAround: true } }, + usebeamertemplate: { signature: "s m", renderInfo: { breakAround: true } }, + setbeamercolor: { + signature: "m m", + renderInfo: { breakAround: true, pgfkeysArgs: true } + }, + setbeamersize: { + signature: "m o o", + renderInfo: { breakAround: true, pgfkeysArgs: true } + }, + setbeamertemplate: { + signature: "m o o d{}", + renderInfo: { breakAround: true, pgfkeysArgs: true } + }, + newcommand: { + signature: "s d<> +m o +o +m", + renderInfo: { + breakAround: true, + namedArguments: [ + "starred", + null, + "name", + "numArgs", + "default", + "body" + ] + } + }, + renewcommand: { + signature: "s d<> +m o +o +m", + renderInfo: { + breakAround: true, + namedArguments: [ + "starred", + null, + "name", + "numArgs", + "default", + "body" + ] + } + }, + newenvironment: { + signature: "s d<> m o o m m", + renderInfo: { breakAround: true } + }, + renewenvironment: { + signature: "s d<> m o o m m", + renderInfo: { breakAround: true } + }, + resetcounteronoverlays: { + signature: "m", + renderInfo: { breakAround: true } + }, + resetcountonoverlays: { signature: "m", renderInfo: { breakAround: true } }, + logo: { signature: "m", renderInfo: { breakAround: true } }, + frametitle: { signature: "d<> o m", renderInfo: { breakAround: true } }, + framesubtitle: { signature: "d<> m", renderInfo: { breakAround: true } }, + pause: { signature: "o" }, + onslide: { signature: "t+ t* d<> d{}" }, + only: { signature: "d<> m d<>" }, + uncover: { signature: "d<> m" }, + visible: { signature: "d<> m" }, + invisible: { signature: "d<> m" }, + alt: { signature: "d<> m m d<>" }, + temporal: { signature: "r<> m m m" }, + item: { + signature: "d<> o d<>", + renderInfo: { + hangingIndent: true, + namedArguments: [null, "label", null] + } + }, + label: { signature: "d<> o m" }, + // cleveref adds an optional argument to label; this gives maximum compatibility. + action: { signature: "d<> m" }, + beamerdefaultoverlayspecification: { signature: "m" }, + titlegraphic: { signature: "m", renderInfo: { breakAround: true } }, + subject: { signature: "m", renderInfo: { breakAround: true } }, + keywords: { signature: "m", renderInfo: { breakAround: true } }, + lecture: { signature: "o m m", renderInfo: { breakAround: true } }, + partpage: { renderInfo: { breakAround: true } }, + sectionpage: { renderInfo: { breakAround: true } }, + subsectionpage: { renderInfo: { breakAround: true } }, + AtBeginLecture: { signature: "m", renderInfo: { breakAround: true } }, + AtBeginPart: { signature: "m", renderInfo: { breakAround: true } }, + tableofcontents: { + signature: "o", + renderInfo: { breakAround: true, pgfkeysArgs: true } + }, + againframe: { signature: "d<> o o m", renderInfo: { breakAround: true } }, + framezoom: { + signature: "r<> r<> o r() r()", + renderInfo: { breakAround: true } + }, + column: { signature: "d<> o m", renderInfo: { breakAround: true } }, + animate: { signature: "r<>", renderInfo: { breakAround: true } }, + animatevalue: { signature: "r<> m m m", renderInfo: { breakAround: true } }, + sound: { + signature: "o m m", + renderInfo: { breakAround: true, pgfkeysArgs: true } + }, + hyperlinksound: { + signature: "o m m", + renderInfo: { breakAround: true, pgfkeysArgs: true } + }, + hyperlinkmute: { signature: "m", renderInfo: { breakAround: true } }, + // These signatures conflict with the default signatures. + // Care must be taken when processing an AST. + section: { + signature: "s d<> o m", + renderInfo: { + breakAround: true, + namedArguments: ["starred", null, "tocTitle", "title"] + } + }, + subsection: { + signature: "s d<> o m", + renderInfo: { + breakAround: true, + namedArguments: ["starred", null, "tocTitle", "title"] + } + }, + subsubsection: { + signature: "s d<> o m", + renderInfo: { + breakAround: true, + namedArguments: ["starred", null, "tocTitle", "title"] + } + }, + part: { + signature: "s d<> o m", + renderInfo: { + breakAround: true, + namedArguments: ["starred", null, "tocTitle", "title"] + } + }, + bibitem: { + signature: "s d<> o m", + renderInfo: { + hangingIndent: true, + namedArguments: ["starred", null, "tocTitle", "title"] + } + } +}; +var environments15 = { + frame: { + signature: "!d<> !o !o !d{} !d{}" + }, + block: { + signature: "!d<> !d{} !d<>" + }, + alertblock: { + signature: "!d<> !d{} !d<>" + }, + exampleblock: { + signature: "!d<> !d{} !d<>" + }, + onlyenv: { + signature: "!d<>" + }, + altenv: { + signature: "!d<> m m m m !d<>" + }, + overlayarea: { signature: "m m" }, + overprint: { signature: "o" }, + actionenv: { signature: "!d<>" }, + columns: { signature: "d<> o" }, + column: { signature: "d<> o m" } +}; +var macros16 = { + columnbreak: { renderInfo: { breakAround: true } } +}; +var environments16 = { + multicols: { + signature: "m o o" + }, + "multicols*": { + signature: "m o o" + } +}; +var macroInfo = { + cleveref: macros, + exam: macros2, + geometry: macros3, + hyperref: macros4, + latex2e: macros5, + listings: macros6, + makeidx: macros7, + mathtools: macros8, + minted: macros9, + nicematrix: macros10, + systeme: macros11, + tikz: macros12, + xcolor: macros13, + xparse: macros14, + beamer: macros15, + multicol: macros16 +}; +var environmentInfo = { + cleveref: environments, + exam: environments2, + geometry: environments3, + hyperref: environments4, + latex2e: environments5, + listings: environments6, + makeidx: environments7, + mathtools: environments8, + minted: environments9, + nicematrix: environments10, + systeme: environments11, + tikz: environments12, + xcolor: environments13, + xparse: environments14, + beamer: environments15, + multicol: environments16 +}; +function processEnvironment(envNode, envInfo) { + if (envInfo.signature && envNode.args == null) { + const { args } = gobbleArguments(envNode.content, envInfo.signature); + envNode.args = args; + } + updateRenderInfo(envNode, envInfo.renderInfo); + if (typeof envInfo.processContent === "function") { + envNode.content = envInfo.processContent(envNode.content); + } +} +function findRegionInArray(tree, start, end) { + const ret = []; + let currRegion = { start: void 0, end: tree.length }; + for (let i = 0; i < tree.length; i++) { + const node = tree[i]; + if (start(node)) { + currRegion.start = i; + } + if (end(node)) { + currRegion.end = i + 1; + ret.push(currRegion); + currRegion = { start: void 0, end: tree.length }; + } + } + if (currRegion.start != null) { + ret.push(currRegion); + } + return ret; +} +function refineRegions(regions) { + const _regions = [...regions]; + _regions.sort((a, b) => a.start - b.start); + const cutPointsSet = new Set(_regions.flatMap((r) => [r.start, r.end])); + const cutPoints = Array.from(cutPointsSet); + cutPoints.sort((a, b) => a - b); + const retRegions = []; + const retRegionsContainedIn = []; + let seekIndex = 0; + for (let i = 0; i < cutPoints.length - 1; i++) { + const start = cutPoints[i]; + const end = cutPoints[i + 1]; + const region = { start, end }; + const regionContainedIn = /* @__PURE__ */ new Set(); + let encounteredEndPastStart = false; + for (let j = seekIndex; j < _regions.length; j++) { + const superRegion = _regions[j]; + if (superRegion.end >= region.start) { + encounteredEndPastStart = true; + } + if (!encounteredEndPastStart && superRegion.end < region.start) { + seekIndex = j + 1; + continue; + } + if (superRegion.start > end) { + break; + } + if (superRegion.start <= region.start && superRegion.end >= region.end) { + encounteredEndPastStart = true; + regionContainedIn.add(superRegion); + } + } + if (regionContainedIn.size > 0) { + retRegions.push(region); + retRegionsContainedIn.push(regionContainedIn); + } + } + return { regions: retRegions, regionsContainedIn: retRegionsContainedIn }; +} +function splitByRegions(array, regionsRecord) { + const ret = []; + const indices = [0, array.length]; + const reverseMap = {}; + for (const [key, records] of Object.entries(regionsRecord)) { + indices.push( + ...records.flatMap((r) => { + reverseMap["" + [r.start, r.end]] = key; + return [r.start, r.end]; + }) + ); + } + indices.sort((a, b) => a - b); + for (let i = 0; i < indices.length - 1; i++) { + const start = indices[i]; + const end = indices[i + 1]; + if (start === end) { + continue; + } + const regionKey = reverseMap["" + [start, end]]; + ret.push([regionKey || null, array.slice(start, end)]); + } + return ret; +} +function escapeRegExp(str) { + return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"); +} +function buildWordRegex(allowedSet) { + const regexpStr = `^(${["\\p{L}"].concat(Array.from(allowedSet).map(escapeRegExp)).join("|")})*`; + return new RegExp(regexpStr, "u"); +} +function hasReparsableMacroNamesInArray(tree, allowedTokens) { + for (let i = 0; i < tree.length; i++) { + const macro = tree[i]; + const string = tree[i + 1]; + if (match.anyMacro(macro) && match.anyString(string)) { + if (allowedTokens.has( + macro.content.charAt(macro.content.length - 1) + ) || allowedTokens.has(string.content.charAt(0))) { + return true; + } + } + } + return false; +} +function hasReparsableMacroNames(tree, allowedTokens) { + if (typeof allowedTokens === "string") { + allowedTokens = new Set(allowedTokens.split("")); + } + const _allowedTokens = allowedTokens; + for (const v of _allowedTokens) { + if (v.length > 1) { + throw new Error( + `Only single characters are allowed as \`allowedTokens\` when reparsing macro names, not \`${v}\`.` + ); + } + } + let ret = false; + visit( + tree, + (nodes) => { + if (hasReparsableMacroNamesInArray(nodes, _allowedTokens)) { + ret = true; + return EXIT; + } + }, + { includeArrays: true, test: Array.isArray } + ); + return ret; +} +function reparseMacroNamesInArray(tree, allowedTokens) { + var _a, _b, _c; + const regex = buildWordRegex(allowedTokens); + let i = 0; + while (i < tree.length) { + const macro = tree[i]; + const string = tree[i + 1]; + if (match.anyMacro(macro) && // The _^ macros in math mode should not be extended no-matter what; + // So we check to make sure that the macro we're dealing with has the default escape token. + (macro.escapeToken == null || macro.escapeToken === "\\") && match.anyString(string) && // There are two options. Either the macro ends with the special character, + // e.g. `\@foo` or the special character starts the next string, e.g. `\foo@`. + (allowedTokens.has( + macro.content.charAt(macro.content.length - 1) + ) || allowedTokens.has(string.content.charAt(0)))) { + const match3 = string.content.match(regex); + const takeable = match3 ? match3[0] : ""; + if (takeable.length > 0) { + if (takeable.length === string.content.length) { + macro.content += string.content; + tree.splice(i + 1, 1); + if (macro.position && ((_a = string.position) == null ? void 0 : _a.end)) { + macro.position.end = string.position.end; + } + } else { + macro.content += takeable; + string.content = string.content.slice(takeable.length); + if ((_b = macro.position) == null ? void 0 : _b.end) { + macro.position.end.offset += takeable.length; + macro.position.end.column += takeable.length; + } + if ((_c = string.position) == null ? void 0 : _c.start) { + string.position.start.offset += takeable.length; + string.position.start.column += takeable.length; + } + } + } else { + i++; + } + } else { + ++i; + } + } +} +function reparseMacroNames(tree, allowedTokens) { + if (typeof allowedTokens === "string") { + allowedTokens = new Set(allowedTokens.split("")); + } + const _allowedTokens = allowedTokens; + for (const v of _allowedTokens) { + if (v.length > 1) { + throw new Error( + `Only single characters are allowed as \`allowedTokens\` when reparsing macro names, not \`${v}\`.` + ); + } + } + visit( + tree, + (nodes) => { + reparseMacroNamesInArray(nodes, _allowedTokens); + }, + { includeArrays: true, test: Array.isArray } + ); +} +var expl3Find = { + start: match.createMacroMatcher(["ExplSyntaxOn"]), + end: match.createMacroMatcher(["ExplSyntaxOff"]) +}; +var atLetterFind = { + start: match.createMacroMatcher(["makeatletter"]), + end: match.createMacroMatcher(["makeatother"]) +}; +function findExpl3AndAtLetterRegionsInArray(tree) { + const expl3 = findRegionInArray(tree, expl3Find.start, expl3Find.end); + const atLetter = findRegionInArray( + tree, + atLetterFind.start, + atLetterFind.end + ); + const regionMap = new Map([ + ...expl3.map((x) => [x, "expl"]), + ...atLetter.map((x) => [x, "atLetter"]) + ]); + const all = refineRegions([...expl3, ...atLetter]); + const ret = { + explOnly: [], + atLetterOnly: [], + both: [] + }; + for (let i = 0; i < all.regions.length; i++) { + const region = all.regions[i]; + const containedIn = all.regionsContainedIn[i]; + if (containedIn.size === 2) { + ret.both.push(region); + continue; + } + for (const v of containedIn.values()) { + if (regionMap.get(v) === "expl") { + ret.explOnly.push(region); + } + if (regionMap.get(v) === "atLetter") { + ret.atLetterOnly.push(region); + } + } + } + ret.explOnly = ret.explOnly.filter((r) => r.end - r.start > 1); + ret.atLetterOnly = ret.atLetterOnly.filter((r) => r.end - r.start > 1); + ret.both = ret.both.filter((r) => r.end - r.start > 1); + return ret; +} +var atLetterSet = /* @__PURE__ */ new Set(["@"]); +var explSet = /* @__PURE__ */ new Set(["_", ":"]); +var bothSet = /* @__PURE__ */ new Set(["_", ":", "@"]); +function reparseExpl3AndAtLetterRegions(tree) { + visit( + tree, + { + leave: (nodes) => { + const regions = findExpl3AndAtLetterRegionsInArray(nodes); + const totalNumRegions = regions.both.length + regions.atLetterOnly.length + regions.explOnly.length; + if (totalNumRegions === 0) { + return; + } + const splits = splitByRegions(nodes, regions); + const processed = []; + for (const [key, slice2] of splits) { + switch (key) { + case null: + processed.push(...slice2); + continue; + case "atLetterOnly": + reparseMacroNames(slice2, atLetterSet); + processed.push(...slice2); + continue; + case "explOnly": + reparseMacroNames(slice2, explSet); + processed.push(...slice2); + continue; + case "both": + reparseMacroNames(slice2, bothSet); + processed.push(...slice2); + continue; + default: + throw new Error( + `Unexpected case when splitting ${key}` + ); + } + } + nodes.length = 0; + nodes.push(...processed); + return SKIP; + } + }, + { includeArrays: true, test: Array.isArray } + ); +} +var unifiedLatexAstComplier = function unifiedLatexAstComplier2() { + Object.assign(this, { Compiler: (x) => x }); +}; +function parseMinimal(str) { + return LatexPegParser.parse(str); +} +function parseMathMinimal(str) { + return LatexPegParser.parse(str, { startRule: "math" }); +} +var unifiedLatexFromStringMinimal = function unifiedLatexFromStringMinimal2(options2) { + const parser2 = (str) => { + if ((options2 == null ? void 0 : options2.mode) === "math") { + return { + type: "root", + content: parseMathMinimal(str), + _renderInfo: { inMathMode: true } + }; + } + return parseMinimal(str); + }; + Object.assign(this, { Parser: parser2 }); +}; +function unifiedLatexReparseMathConstructPlugin({ + mathEnvs, + mathMacros +}) { + const isMathEnvironment = match.createEnvironmentMatcher(mathEnvs); + const isMathMacro = match.createMacroMatcher(mathMacros); + return (tree) => { + visit( + tree, + (node) => { + if (match.anyMacro(node)) { + for (const arg2 of node.args || []) { + if (arg2.content.length > 0 && !wasParsedInMathMode(arg2.content)) { + arg2.content = parseMathMinimal( + printRaw(arg2.content) + ); + } + } + } + if (match.anyEnvironment(node)) { + if (!wasParsedInMathMode(node.content)) { + node.content = parseMathMinimal(printRaw(node.content)); + } + } + }, + { + test: (node) => isMathEnvironment(node) || isMathMacro(node) + } + ); + }; +} +function wasParsedInMathMode(nodes) { + return !nodes.some( + (node) => ( + // If there are multi-char strings or ^ and _ have been parsed as strings, we know + // that we were not parsed in math mode. + match.anyString(node) && node.content.length > 1 || match.string(node, "^") || match.string(node, "_") + ) + ); +} +var unifiedLatexProcessMacrosAndEnvironmentsWithMathReparse = function unifiedLatexProcessMacrosAndEnvironmentsWithMathReparse2(options2) { + const { environments: environments17 = {}, macros: macros17 = {} } = options2 || {}; + const mathMacros = Object.fromEntries( + Object.entries(macros17).filter( + ([_, info]) => { + var _a; + return ((_a = info.renderInfo) == null ? void 0 : _a.inMathMode) === true; + } + ) + ); + const mathEnvs = Object.fromEntries( + Object.entries(environments17).filter( + ([_, info]) => { + var _a; + return ((_a = info.renderInfo) == null ? void 0 : _a.inMathMode) === true; + } + ) + ); + const mathReparser = unifiedLatexReparseMathConstructPlugin({ + mathEnvs: Object.keys(mathEnvs), + mathMacros: Object.keys(mathMacros) + }); + const isRelevantEnvironment = match.createEnvironmentMatcher(environments17); + const isRelevantMathEnvironment = match.createEnvironmentMatcher(mathEnvs); + return (tree) => { + visit( + tree, + { + enter: (nodes) => { + if (!Array.isArray(nodes)) { + return; + } + attachMacroArgsInArray(nodes, mathMacros); + }, + leave: (node) => { + if (!isRelevantMathEnvironment(node)) { + return; + } + const envName = printRaw(node.env); + const envInfo = environments17[envName]; + if (!envInfo) { + throw new Error( + `Could not find environment info for environment "${envName}"` + ); + } + processEnvironment(node, envInfo); + } + }, + { includeArrays: true } + ); + mathReparser(tree); + visit( + tree, + { + enter: (nodes) => { + if (!Array.isArray(nodes)) { + return; + } + attachMacroArgsInArray(nodes, macros17); + }, + leave: (node) => { + if (!isRelevantEnvironment(node)) { + return; + } + const envName = printRaw(node.env); + const envInfo = environments17[envName]; + if (!envInfo) { + throw new Error( + `Could not find environment info for environment "${envName}"` + ); + } + processEnvironment(node, envInfo); + } + }, + { includeArrays: true } + ); + }; +}; +var unifiedLatexProcessAtLetterAndExplMacros = function unifiedLatexProcessAtLetterAndExplMacros2(options2) { + let { + atLetter = false, + expl3 = false, + autodetectExpl3AndAtLetter = false + } = options2 || {}; + return (tree) => { + reparseExpl3AndAtLetterRegions(tree); + if (atLetter || expl3) { + autodetectExpl3AndAtLetter = false; + } + if (autodetectExpl3AndAtLetter) { + atLetter = hasReparsableMacroNames(tree, "@"); + expl3 = hasReparsableMacroNames(tree, "_"); + } + const charSet = /* @__PURE__ */ new Set(); + if (atLetter) { + charSet.add("@"); + } + if (expl3) { + charSet.add(":"); + charSet.add("_"); + } + if (charSet.size > 0) { + reparseMacroNames(tree, charSet); + } + }; +}; +var unifiedLatexFromString = function unifiedLatexFromString2(options2) { + const { + mode = "regular", + macros: macros17 = {}, + environments: environments17 = {}, + flags: { + atLetter = false, + expl3 = false, + autodetectExpl3AndAtLetter = false + } = {} + } = options2 || {}; + const allMacroInfo = Object.assign( + {}, + ...Object.values(macroInfo), + macros17 + ); + const allEnvInfo = Object.assign( + {}, + ...Object.values(environmentInfo), + environments17 + ); + const fullParser = unified().use(unifiedLatexFromStringMinimal, { mode }).use(unifiedLatexProcessAtLetterAndExplMacros, { + atLetter, + expl3, + autodetectExpl3AndAtLetter + }).use(unifiedLatexProcessMacrosAndEnvironmentsWithMathReparse, { + macros: allMacroInfo, + environments: allEnvInfo + }).use(unifiedLatexTrimEnvironmentContents).use(unifiedLatexTrimRoot).use(unifiedLatexAstComplier); + const parser2 = (str) => { + const file = fullParser.processSync({ value: str }); + return file.result; + }; + Object.assign(this, { Parser: parser2 }); +}; +var parser = unified().use(unifiedLatexFromString).freeze(); +function parse(str) { + return parser.parse(str); +} +var __accessCheck = (obj, member, msg) => { + if (!member.has(obj)) + throw TypeError("Cannot " + msg); +}; +var __privateGet = (obj, member, getter) => { + __accessCheck(obj, member, "read from private field"); + return getter ? getter.call(obj) : member.get(obj); +}; +var __privateAdd = (obj, member, value) => { + if (member.has(obj)) + throw TypeError("Cannot add the same private member more than once"); + member instanceof WeakSet ? member.add(obj) : member.set(obj, value); +}; +var __privateSet = (obj, member, value, setter) => { + __accessCheck(obj, member, "write to private field"); + setter ? setter.call(obj, value) : member.set(obj, value); + return value; +}; +var __defProp2 = Object.defineProperty; +var __export = (target, all) => { + for (var name in all) + __defProp2(target, name, { get: all[name], enumerable: true }); +}; +var public_exports = {}; +__export(public_exports, { + builders: () => builders, + printer: () => printer, + utils: () => utils +}); +var DOC_TYPE_STRING = "string"; +var DOC_TYPE_ARRAY = "array"; +var DOC_TYPE_CURSOR = "cursor"; +var DOC_TYPE_INDENT = "indent"; +var DOC_TYPE_ALIGN = "align"; +var DOC_TYPE_TRIM = "trim"; +var DOC_TYPE_GROUP = "group"; +var DOC_TYPE_FILL = "fill"; +var DOC_TYPE_IF_BREAK = "if-break"; +var DOC_TYPE_INDENT_IF_BREAK = "indent-if-break"; +var DOC_TYPE_LINE_SUFFIX = "line-suffix"; +var DOC_TYPE_LINE_SUFFIX_BOUNDARY = "line-suffix-boundary"; +var DOC_TYPE_LINE = "line"; +var DOC_TYPE_LABEL = "label"; +var DOC_TYPE_BREAK_PARENT = "break-parent"; +var VALID_OBJECT_DOC_TYPES = /* @__PURE__ */ new Set([ + DOC_TYPE_CURSOR, + DOC_TYPE_INDENT, + DOC_TYPE_ALIGN, + DOC_TYPE_TRIM, + DOC_TYPE_GROUP, + DOC_TYPE_FILL, + DOC_TYPE_IF_BREAK, + DOC_TYPE_INDENT_IF_BREAK, + DOC_TYPE_LINE_SUFFIX, + DOC_TYPE_LINE_SUFFIX_BOUNDARY, + DOC_TYPE_LINE, + DOC_TYPE_LABEL, + DOC_TYPE_BREAK_PARENT +]); +function getDocType(doc) { + if (typeof doc === "string") { + return DOC_TYPE_STRING; + } + if (Array.isArray(doc)) { + return DOC_TYPE_ARRAY; + } + if (!doc) { + return; + } + const { type } = doc; + if (VALID_OBJECT_DOC_TYPES.has(type)) { + return type; + } +} +var get_doc_type_default = getDocType; +var disjunctionListFormat = (list) => new Intl.ListFormat("en-US", { type: "disjunction" }).format(list); +function getDocErrorMessage(doc) { + const type = doc === null ? "null" : typeof doc; + if (type !== "string" && type !== "object") { + return `Unexpected doc '${type}', +Expected it to be 'string' or 'object'.`; + } + if (get_doc_type_default(doc)) { + throw new Error("doc is valid."); + } + const objectType = Object.prototype.toString.call(doc); + if (objectType !== "[object Object]") { + return `Unexpected doc '${objectType}'.`; + } + const EXPECTED_TYPE_VALUES = disjunctionListFormat( + [...VALID_OBJECT_DOC_TYPES].map((type2) => `'${type2}'`) + ); + return `Unexpected doc.type '${doc.type}'. +Expected it to be ${EXPECTED_TYPE_VALUES}.`; +} +var InvalidDocError = class extends Error { + constructor(doc) { + super(getDocErrorMessage(doc)); + __publicField(this, "name", "InvalidDocError"); + this.doc = doc; + } +}; +var invalid_doc_error_default = InvalidDocError; +var traverseDocOnExitStackMarker = {}; +function traverseDoc(doc, onEnter, onExit, shouldTraverseConditionalGroups) { + const docsStack = [doc]; + while (docsStack.length > 0) { + const doc2 = docsStack.pop(); + if (doc2 === traverseDocOnExitStackMarker) { + onExit(docsStack.pop()); + continue; + } + if (onExit) { + docsStack.push(doc2, traverseDocOnExitStackMarker); + } + const docType = get_doc_type_default(doc2); + if (!docType) { + throw new invalid_doc_error_default(doc2); + } + if ((onEnter == null ? void 0 : onEnter(doc2)) === false) { + continue; + } + switch (docType) { + case DOC_TYPE_ARRAY: + case DOC_TYPE_FILL: { + const parts = docType === DOC_TYPE_ARRAY ? doc2 : doc2.parts; + for (let ic = parts.length, i = ic - 1; i >= 0; --i) { + docsStack.push(parts[i]); + } + break; + } + case DOC_TYPE_IF_BREAK: + docsStack.push(doc2.flatContents, doc2.breakContents); + break; + case DOC_TYPE_GROUP: + if (shouldTraverseConditionalGroups && doc2.expandedStates) { + for (let ic = doc2.expandedStates.length, i = ic - 1; i >= 0; --i) { + docsStack.push(doc2.expandedStates[i]); + } + } else { + docsStack.push(doc2.contents); + } + break; + case DOC_TYPE_ALIGN: + case DOC_TYPE_INDENT: + case DOC_TYPE_INDENT_IF_BREAK: + case DOC_TYPE_LABEL: + case DOC_TYPE_LINE_SUFFIX: + docsStack.push(doc2.contents); + break; + case DOC_TYPE_STRING: + case DOC_TYPE_CURSOR: + case DOC_TYPE_TRIM: + case DOC_TYPE_LINE_SUFFIX_BOUNDARY: + case DOC_TYPE_LINE: + case DOC_TYPE_BREAK_PARENT: + break; + default: + throw new invalid_doc_error_default(doc2); + } + } +} +var traverse_doc_default = traverseDoc; +var noop = () => { +}; +var assertDocArray = noop; +function indent(contents) { + return { type: DOC_TYPE_INDENT, contents }; +} +function align(widthOrString, contents) { + return { type: DOC_TYPE_ALIGN, contents, n: widthOrString }; +} +function group(contents, opts = {}) { + assertDocArray( + opts.expandedStates + ); + return { + type: DOC_TYPE_GROUP, + id: opts.id, + contents, + break: Boolean(opts.shouldBreak), + expandedStates: opts.expandedStates + }; +} +function dedentToRoot(contents) { + return align(Number.NEGATIVE_INFINITY, contents); +} +function markAsRoot(contents) { + return align({ type: "root" }, contents); +} +function dedent(contents) { + return align(-1, contents); +} +function conditionalGroup(states, opts) { + return group(states[0], { ...opts, expandedStates: states }); +} +function fill(parts) { + return { type: DOC_TYPE_FILL, parts }; +} +function ifBreak(breakContents, flatContents = "", opts = {}) { + return { + type: DOC_TYPE_IF_BREAK, + breakContents, + flatContents, + groupId: opts.groupId + }; +} +function indentIfBreak(contents, opts) { + return { + type: DOC_TYPE_INDENT_IF_BREAK, + contents, + groupId: opts.groupId, + negate: opts.negate + }; +} +function lineSuffix(contents) { + return { type: DOC_TYPE_LINE_SUFFIX, contents }; +} +var lineSuffixBoundary = { type: DOC_TYPE_LINE_SUFFIX_BOUNDARY }; +var breakParent = { type: DOC_TYPE_BREAK_PARENT }; +var trim = { type: DOC_TYPE_TRIM }; +var hardlineWithoutBreakParent = { type: DOC_TYPE_LINE, hard: true }; +var literallineWithoutBreakParent = { + type: DOC_TYPE_LINE, + hard: true, + literal: true +}; +var line = { type: DOC_TYPE_LINE }; +var softline = { type: DOC_TYPE_LINE, soft: true }; +var hardline = [hardlineWithoutBreakParent, breakParent]; +var literalline = [literallineWithoutBreakParent, breakParent]; +var cursor = { type: DOC_TYPE_CURSOR }; +function join(separator, docs) { + const parts = []; + for (let i = 0; i < docs.length; i++) { + if (i !== 0) { + parts.push(separator); + } + parts.push(docs[i]); + } + return parts; +} +function addAlignmentToDoc(doc, size, tabWidth) { + let aligned = doc; + if (size > 0) { + for (let i = 0; i < Math.floor(size / tabWidth); ++i) { + aligned = indent(aligned); + } + aligned = align(size % tabWidth, aligned); + aligned = align(Number.NEGATIVE_INFINITY, aligned); + } + return aligned; +} +function label(label2, contents) { + return label2 ? { type: DOC_TYPE_LABEL, label: label2, contents } : contents; +} +var at = (isOptionalObject, object, index2) => { + if (isOptionalObject && (object === void 0 || object === null)) { + return; + } + if (Array.isArray(object) || typeof object === "string") { + return object[index2 < 0 ? object.length + index2 : index2]; + } + return object.at(index2); +}; +var at_default = at; +var stringReplaceAll = (isOptionalObject, original, pattern, replacement) => { + if (isOptionalObject && (original === void 0 || original === null)) { + return; + } + if (original.replaceAll) { + return original.replaceAll(pattern, replacement); + } + if (pattern.global) { + return original.replace(pattern, replacement); + } + return original.split(pattern).join(replacement); +}; +var string_replace_all_default = stringReplaceAll; +function convertEndOfLineToChars(value) { + switch (value) { + case "cr": + return "\r"; + case "crlf": + return "\r\n"; + default: + return "\n"; + } +} +var emoji_regex_default = () => { + return /[#*0-9]\uFE0F?\u20E3|[\xA9\xAE\u203C\u2049\u2122\u2139\u2194-\u2199\u21A9\u21AA\u231A\u231B\u2328\u23CF\u23ED-\u23EF\u23F1\u23F2\u23F8-\u23FA\u24C2\u25AA\u25AB\u25B6\u25C0\u25FB\u25FC\u25FE\u2600-\u2604\u260E\u2611\u2614\u2615\u2618\u2620\u2622\u2623\u2626\u262A\u262E\u262F\u2638-\u263A\u2640\u2642\u2648-\u2653\u265F\u2660\u2663\u2665\u2666\u2668\u267B\u267E\u267F\u2692\u2694-\u2697\u2699\u269B\u269C\u26A0\u26A7\u26AA\u26B0\u26B1\u26BD\u26BE\u26C4\u26C8\u26CF\u26D1\u26D3\u26E9\u26F0-\u26F5\u26F7\u26F8\u26FA\u2702\u2708\u2709\u270F\u2712\u2714\u2716\u271D\u2721\u2733\u2734\u2744\u2747\u2757\u2763\u27A1\u2934\u2935\u2B05-\u2B07\u2B1B\u2B1C\u2B55\u3030\u303D\u3297\u3299]\uFE0F?|[\u261D\u270C\u270D](?:\uFE0F|\uD83C[\uDFFB-\uDFFF])?|[\u270A\u270B](?:\uD83C[\uDFFB-\uDFFF])?|[\u23E9-\u23EC\u23F0\u23F3\u25FD\u2693\u26A1\u26AB\u26C5\u26CE\u26D4\u26EA\u26FD\u2705\u2728\u274C\u274E\u2753-\u2755\u2795-\u2797\u27B0\u27BF\u2B50]|\u26F9(?:\uFE0F|\uD83C[\uDFFB-\uDFFF])?(?:\u200D[\u2640\u2642]\uFE0F?)?|\u2764\uFE0F?(?:\u200D(?:\uD83D\uDD25|\uD83E\uDE79))?|\uD83C(?:[\uDC04\uDD70\uDD71\uDD7E\uDD7F\uDE02\uDE37\uDF21\uDF24-\uDF2C\uDF36\uDF7D\uDF96\uDF97\uDF99-\uDF9B\uDF9E\uDF9F\uDFCD\uDFCE\uDFD4-\uDFDF\uDFF5\uDFF7]\uFE0F?|[\uDF85\uDFC2\uDFC7](?:\uD83C[\uDFFB-\uDFFF])?|[\uDFC3\uDFC4\uDFCA](?:\uD83C[\uDFFB-\uDFFF])?(?:\u200D[\u2640\u2642]\uFE0F?)?|[\uDFCB\uDFCC](?:\uFE0F|\uD83C[\uDFFB-\uDFFF])?(?:\u200D[\u2640\u2642]\uFE0F?)?|[\uDCCF\uDD8E\uDD91-\uDD9A\uDE01\uDE1A\uDE2F\uDE32-\uDE36\uDE38-\uDE3A\uDE50\uDE51\uDF00-\uDF20\uDF2D-\uDF35\uDF37-\uDF7C\uDF7E-\uDF84\uDF86-\uDF93\uDFA0-\uDFC1\uDFC5\uDFC6\uDFC8\uDFC9\uDFCF-\uDFD3\uDFE0-\uDFF0\uDFF8-\uDFFF]|\uDDE6\uD83C[\uDDE8-\uDDEC\uDDEE\uDDF1\uDDF2\uDDF4\uDDF6-\uDDFA\uDDFC\uDDFD\uDDFF]|\uDDE7\uD83C[\uDDE6\uDDE7\uDDE9-\uDDEF\uDDF1-\uDDF4\uDDF6-\uDDF9\uDDFB\uDDFC\uDDFE\uDDFF]|\uDDE8\uD83C[\uDDE6\uDDE8\uDDE9\uDDEB-\uDDEE\uDDF0-\uDDF5\uDDF7\uDDFA-\uDDFF]|\uDDE9\uD83C[\uDDEA\uDDEC\uDDEF\uDDF0\uDDF2\uDDF4\uDDFF]|\uDDEA\uD83C[\uDDE6\uDDE8\uDDEA\uDDEC\uDDED\uDDF7-\uDDFA]|\uDDEB\uD83C[\uDDEE-\uDDF0\uDDF2\uDDF4\uDDF7]|\uDDEC\uD83C[\uDDE6\uDDE7\uDDE9-\uDDEE\uDDF1-\uDDF3\uDDF5-\uDDFA\uDDFC\uDDFE]|\uDDED\uD83C[\uDDF0\uDDF2\uDDF3\uDDF7\uDDF9\uDDFA]|\uDDEE\uD83C[\uDDE8-\uDDEA\uDDF1-\uDDF4\uDDF6-\uDDF9]|\uDDEF\uD83C[\uDDEA\uDDF2\uDDF4\uDDF5]|\uDDF0\uD83C[\uDDEA\uDDEC-\uDDEE\uDDF2\uDDF3\uDDF5\uDDF7\uDDFC\uDDFE\uDDFF]|\uDDF1\uD83C[\uDDE6-\uDDE8\uDDEE\uDDF0\uDDF7-\uDDFB\uDDFE]|\uDDF2\uD83C[\uDDE6\uDDE8-\uDDED\uDDF0-\uDDFF]|\uDDF3\uD83C[\uDDE6\uDDE8\uDDEA-\uDDEC\uDDEE\uDDF1\uDDF4\uDDF5\uDDF7\uDDFA\uDDFF]|\uDDF4\uD83C\uDDF2|\uDDF5\uD83C[\uDDE6\uDDEA-\uDDED\uDDF0-\uDDF3\uDDF7-\uDDF9\uDDFC\uDDFE]|\uDDF6\uD83C\uDDE6|\uDDF7\uD83C[\uDDEA\uDDF4\uDDF8\uDDFA\uDDFC]|\uDDF8\uD83C[\uDDE6-\uDDEA\uDDEC-\uDDF4\uDDF7-\uDDF9\uDDFB\uDDFD-\uDDFF]|\uDDF9\uD83C[\uDDE6\uDDE8\uDDE9\uDDEB-\uDDED\uDDEF-\uDDF4\uDDF7\uDDF9\uDDFB\uDDFC\uDDFF]|\uDDFA\uD83C[\uDDE6\uDDEC\uDDF2\uDDF3\uDDF8\uDDFE\uDDFF]|\uDDFB\uD83C[\uDDE6\uDDE8\uDDEA\uDDEC\uDDEE\uDDF3\uDDFA]|\uDDFC\uD83C[\uDDEB\uDDF8]|\uDDFD\uD83C\uDDF0|\uDDFE\uD83C[\uDDEA\uDDF9]|\uDDFF\uD83C[\uDDE6\uDDF2\uDDFC]|\uDFF3\uFE0F?(?:\u200D(?:\u26A7\uFE0F?|\uD83C\uDF08))?|\uDFF4(?:\u200D\u2620\uFE0F?|\uDB40\uDC67\uDB40\uDC62\uDB40(?:\uDC65\uDB40\uDC6E\uDB40\uDC67|\uDC73\uDB40\uDC63\uDB40\uDC74|\uDC77\uDB40\uDC6C\uDB40\uDC73)\uDB40\uDC7F)?)|\uD83D(?:[\uDC08\uDC26](?:\u200D\u2B1B)?|[\uDC3F\uDCFD\uDD49\uDD4A\uDD6F\uDD70\uDD73\uDD76-\uDD79\uDD87\uDD8A-\uDD8D\uDDA5\uDDA8\uDDB1\uDDB2\uDDBC\uDDC2-\uDDC4\uDDD1-\uDDD3\uDDDC-\uDDDE\uDDE1\uDDE3\uDDE8\uDDEF\uDDF3\uDDFA\uDECB\uDECD-\uDECF\uDEE0-\uDEE5\uDEE9\uDEF0\uDEF3]\uFE0F?|[\uDC42\uDC43\uDC46-\uDC50\uDC66\uDC67\uDC6B-\uDC6D\uDC72\uDC74-\uDC76\uDC78\uDC7C\uDC83\uDC85\uDC8F\uDC91\uDCAA\uDD7A\uDD95\uDD96\uDE4C\uDE4F\uDEC0\uDECC](?:\uD83C[\uDFFB-\uDFFF])?|[\uDC6E\uDC70\uDC71\uDC73\uDC77\uDC81\uDC82\uDC86\uDC87\uDE45-\uDE47\uDE4B\uDE4D\uDE4E\uDEA3\uDEB4-\uDEB6](?:\uD83C[\uDFFB-\uDFFF])?(?:\u200D[\u2640\u2642]\uFE0F?)?|[\uDD74\uDD90](?:\uFE0F|\uD83C[\uDFFB-\uDFFF])?|[\uDC00-\uDC07\uDC09-\uDC14\uDC16-\uDC25\uDC27-\uDC3A\uDC3C-\uDC3E\uDC40\uDC44\uDC45\uDC51-\uDC65\uDC6A\uDC79-\uDC7B\uDC7D-\uDC80\uDC84\uDC88-\uDC8E\uDC90\uDC92-\uDCA9\uDCAB-\uDCFC\uDCFF-\uDD3D\uDD4B-\uDD4E\uDD50-\uDD67\uDDA4\uDDFB-\uDE2D\uDE2F-\uDE34\uDE37-\uDE44\uDE48-\uDE4A\uDE80-\uDEA2\uDEA4-\uDEB3\uDEB7-\uDEBF\uDEC1-\uDEC5\uDED0-\uDED2\uDED5-\uDED7\uDEDC-\uDEDF\uDEEB\uDEEC\uDEF4-\uDEFC\uDFE0-\uDFEB\uDFF0]|\uDC15(?:\u200D\uD83E\uDDBA)?|\uDC3B(?:\u200D\u2744\uFE0F?)?|\uDC41\uFE0F?(?:\u200D\uD83D\uDDE8\uFE0F?)?|\uDC68(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:\uDC8B\u200D\uD83D)?\uDC68|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D(?:[\uDC68\uDC69]\u200D\uD83D(?:\uDC66(?:\u200D\uD83D\uDC66)?|\uDC67(?:\u200D\uD83D[\uDC66\uDC67])?)|[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uDC66(?:\u200D\uD83D\uDC66)?|\uDC67(?:\u200D\uD83D[\uDC66\uDC67])?)|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\uD83C(?:\uDFFB(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:\uDC8B\u200D\uD83D)?\uDC68\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF-\uDDB3\uDDBC\uDDBD]|\uDD1D\u200D\uD83D\uDC68\uD83C[\uDFFC-\uDFFF])))?|\uDFFC(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:\uDC8B\u200D\uD83D)?\uDC68\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF-\uDDB3\uDDBC\uDDBD]|\uDD1D\u200D\uD83D\uDC68\uD83C[\uDFFB\uDFFD-\uDFFF])))?|\uDFFD(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:\uDC8B\u200D\uD83D)?\uDC68\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF-\uDDB3\uDDBC\uDDBD]|\uDD1D\u200D\uD83D\uDC68\uD83C[\uDFFB\uDFFC\uDFFE\uDFFF])))?|\uDFFE(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:\uDC8B\u200D\uD83D)?\uDC68\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF-\uDDB3\uDDBC\uDDBD]|\uDD1D\u200D\uD83D\uDC68\uD83C[\uDFFB-\uDFFD\uDFFF])))?|\uDFFF(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:\uDC8B\u200D\uD83D)?\uDC68\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF-\uDDB3\uDDBC\uDDBD]|\uDD1D\u200D\uD83D\uDC68\uD83C[\uDFFB-\uDFFE])))?))?|\uDC69(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:\uDC8B\u200D\uD83D)?[\uDC68\uDC69]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D(?:[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uDC66(?:\u200D\uD83D\uDC66)?|\uDC67(?:\u200D\uD83D[\uDC66\uDC67])?|\uDC69\u200D\uD83D(?:\uDC66(?:\u200D\uD83D\uDC66)?|\uDC67(?:\u200D\uD83D[\uDC66\uDC67])?))|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\uD83C(?:\uDFFB(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:[\uDC68\uDC69]|\uDC8B\u200D\uD83D[\uDC68\uDC69])\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF-\uDDB3\uDDBC\uDDBD]|\uDD1D\u200D\uD83D[\uDC68\uDC69]\uD83C[\uDFFC-\uDFFF])))?|\uDFFC(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:[\uDC68\uDC69]|\uDC8B\u200D\uD83D[\uDC68\uDC69])\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF-\uDDB3\uDDBC\uDDBD]|\uDD1D\u200D\uD83D[\uDC68\uDC69]\uD83C[\uDFFB\uDFFD-\uDFFF])))?|\uDFFD(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:[\uDC68\uDC69]|\uDC8B\u200D\uD83D[\uDC68\uDC69])\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF-\uDDB3\uDDBC\uDDBD]|\uDD1D\u200D\uD83D[\uDC68\uDC69]\uD83C[\uDFFB\uDFFC\uDFFE\uDFFF])))?|\uDFFE(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:[\uDC68\uDC69]|\uDC8B\u200D\uD83D[\uDC68\uDC69])\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF-\uDDB3\uDDBC\uDDBD]|\uDD1D\u200D\uD83D[\uDC68\uDC69]\uD83C[\uDFFB-\uDFFD\uDFFF])))?|\uDFFF(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:[\uDC68\uDC69]|\uDC8B\u200D\uD83D[\uDC68\uDC69])\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF-\uDDB3\uDDBC\uDDBD]|\uDD1D\u200D\uD83D[\uDC68\uDC69]\uD83C[\uDFFB-\uDFFE])))?))?|\uDC6F(?:\u200D[\u2640\u2642]\uFE0F?)?|\uDD75(?:\uFE0F|\uD83C[\uDFFB-\uDFFF])?(?:\u200D[\u2640\u2642]\uFE0F?)?|\uDE2E(?:\u200D\uD83D\uDCA8)?|\uDE35(?:\u200D\uD83D\uDCAB)?|\uDE36(?:\u200D\uD83C\uDF2B\uFE0F?)?)|\uD83E(?:[\uDD0C\uDD0F\uDD18-\uDD1F\uDD30-\uDD34\uDD36\uDD77\uDDB5\uDDB6\uDDBB\uDDD2\uDDD3\uDDD5\uDEC3-\uDEC5\uDEF0\uDEF2-\uDEF8](?:\uD83C[\uDFFB-\uDFFF])?|[\uDD26\uDD35\uDD37-\uDD39\uDD3D\uDD3E\uDDB8\uDDB9\uDDCD-\uDDCF\uDDD4\uDDD6-\uDDDD](?:\uD83C[\uDFFB-\uDFFF])?(?:\u200D[\u2640\u2642]\uFE0F?)?|[\uDDDE\uDDDF](?:\u200D[\u2640\u2642]\uFE0F?)?|[\uDD0D\uDD0E\uDD10-\uDD17\uDD20-\uDD25\uDD27-\uDD2F\uDD3A\uDD3F-\uDD45\uDD47-\uDD76\uDD78-\uDDB4\uDDB7\uDDBA\uDDBC-\uDDCC\uDDD0\uDDE0-\uDDFF\uDE70-\uDE7C\uDE80-\uDE88\uDE90-\uDEBD\uDEBF-\uDEC2\uDECE-\uDEDB\uDEE0-\uDEE8]|\uDD3C(?:\u200D[\u2640\u2642]\uFE0F?|\uD83C[\uDFFB-\uDFFF])?|\uDDD1(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\uD83C[\uDF3E\uDF73\uDF7C\uDF84\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF-\uDDB3\uDDBC\uDDBD]|\uDD1D\u200D\uD83E\uDDD1))|\uD83C(?:\uDFFB(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D(?:\uD83D\uDC8B\u200D)?\uD83E\uDDD1\uD83C[\uDFFC-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF84\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF-\uDDB3\uDDBC\uDDBD]|\uDD1D\u200D\uD83E\uDDD1\uD83C[\uDFFB-\uDFFF])))?|\uDFFC(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D(?:\uD83D\uDC8B\u200D)?\uD83E\uDDD1\uD83C[\uDFFB\uDFFD-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF84\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF-\uDDB3\uDDBC\uDDBD]|\uDD1D\u200D\uD83E\uDDD1\uD83C[\uDFFB-\uDFFF])))?|\uDFFD(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D(?:\uD83D\uDC8B\u200D)?\uD83E\uDDD1\uD83C[\uDFFB\uDFFC\uDFFE\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF84\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF-\uDDB3\uDDBC\uDDBD]|\uDD1D\u200D\uD83E\uDDD1\uD83C[\uDFFB-\uDFFF])))?|\uDFFE(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D(?:\uD83D\uDC8B\u200D)?\uD83E\uDDD1\uD83C[\uDFFB-\uDFFD\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF84\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF-\uDDB3\uDDBC\uDDBD]|\uDD1D\u200D\uD83E\uDDD1\uD83C[\uDFFB-\uDFFF])))?|\uDFFF(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D(?:\uD83D\uDC8B\u200D)?\uD83E\uDDD1\uD83C[\uDFFB-\uDFFE]|\uD83C[\uDF3E\uDF73\uDF7C\uDF84\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF-\uDDB3\uDDBC\uDDBD]|\uDD1D\u200D\uD83E\uDDD1\uD83C[\uDFFB-\uDFFF])))?))?|\uDEF1(?:\uD83C(?:\uDFFB(?:\u200D\uD83E\uDEF2\uD83C[\uDFFC-\uDFFF])?|\uDFFC(?:\u200D\uD83E\uDEF2\uD83C[\uDFFB\uDFFD-\uDFFF])?|\uDFFD(?:\u200D\uD83E\uDEF2\uD83C[\uDFFB\uDFFC\uDFFE\uDFFF])?|\uDFFE(?:\u200D\uD83E\uDEF2\uD83C[\uDFFB-\uDFFD\uDFFF])?|\uDFFF(?:\u200D\uD83E\uDEF2\uD83C[\uDFFB-\uDFFE])?))?)/g; +}; +var eastasianwidth_default = { + eastAsianWidth(character) { + var x = character.charCodeAt(0); + var y = character.length == 2 ? character.charCodeAt(1) : 0; + var codePoint = x; + if (55296 <= x && x <= 56319 && 56320 <= y && y <= 57343) { + x &= 1023; + y &= 1023; + codePoint = x << 10 | y; + codePoint += 65536; + } + if (12288 == codePoint || 65281 <= codePoint && codePoint <= 65376 || 65504 <= codePoint && codePoint <= 65510) { + return "F"; + } + if (4352 <= codePoint && codePoint <= 4447 || 4515 <= codePoint && codePoint <= 4519 || 4602 <= codePoint && codePoint <= 4607 || 9001 <= codePoint && codePoint <= 9002 || 11904 <= codePoint && codePoint <= 11929 || 11931 <= codePoint && codePoint <= 12019 || 12032 <= codePoint && codePoint <= 12245 || 12272 <= codePoint && codePoint <= 12283 || 12289 <= codePoint && codePoint <= 12350 || 12353 <= codePoint && codePoint <= 12438 || 12441 <= codePoint && codePoint <= 12543 || 12549 <= codePoint && codePoint <= 12589 || 12593 <= codePoint && codePoint <= 12686 || 12688 <= codePoint && codePoint <= 12730 || 12736 <= codePoint && codePoint <= 12771 || 12784 <= codePoint && codePoint <= 12830 || 12832 <= codePoint && codePoint <= 12871 || 12880 <= codePoint && codePoint <= 13054 || 13056 <= codePoint && codePoint <= 19903 || 19968 <= codePoint && codePoint <= 42124 || 42128 <= codePoint && codePoint <= 42182 || 43360 <= codePoint && codePoint <= 43388 || 44032 <= codePoint && codePoint <= 55203 || 55216 <= codePoint && codePoint <= 55238 || 55243 <= codePoint && codePoint <= 55291 || 63744 <= codePoint && codePoint <= 64255 || 65040 <= codePoint && codePoint <= 65049 || 65072 <= codePoint && codePoint <= 65106 || 65108 <= codePoint && codePoint <= 65126 || 65128 <= codePoint && codePoint <= 65131 || 110592 <= codePoint && codePoint <= 110593 || 127488 <= codePoint && codePoint <= 127490 || 127504 <= codePoint && codePoint <= 127546 || 127552 <= codePoint && codePoint <= 127560 || 127568 <= codePoint && codePoint <= 127569 || 131072 <= codePoint && codePoint <= 194367 || 177984 <= codePoint && codePoint <= 196605 || 196608 <= codePoint && codePoint <= 262141) { + return "W"; + } + return "N"; + } +}; +var notAsciiRegex = /[^\x20-\x7F]/; +function getStringWidth(text) { + if (!text) { + return 0; + } + if (!notAsciiRegex.test(text)) { + return text.length; + } + text = text.replace(emoji_regex_default(), " "); + let width = 0; + for (const character of text) { + const codePoint = character.codePointAt(0); + if (codePoint <= 31 || codePoint >= 127 && codePoint <= 159) { + continue; + } + if (codePoint >= 768 && codePoint <= 879) { + continue; + } + const code = eastasianwidth_default.eastAsianWidth(character); + width += code === "F" || code === "W" ? 2 : 1; + } + return width; +} +var get_string_width_default = getStringWidth; +var getDocParts = (doc) => { + if (Array.isArray(doc)) { + return doc; + } + if (doc.type !== DOC_TYPE_FILL) { + throw new Error(`Expect doc to be 'array' or '${DOC_TYPE_FILL}'.`); + } + return doc.parts; +}; +function mapDoc(doc, cb) { + if (typeof doc === "string") { + return cb(doc); + } + const mapped = /* @__PURE__ */ new Map(); + return rec(doc); + function rec(doc2) { + if (mapped.has(doc2)) { + return mapped.get(doc2); + } + const result = process2(doc2); + mapped.set(doc2, result); + return result; + } + function process2(doc2) { + switch (get_doc_type_default(doc2)) { + case DOC_TYPE_ARRAY: + return cb(doc2.map(rec)); + case DOC_TYPE_FILL: + return cb({ + ...doc2, + parts: doc2.parts.map(rec) + }); + case DOC_TYPE_IF_BREAK: + return cb({ + ...doc2, + breakContents: rec(doc2.breakContents), + flatContents: rec(doc2.flatContents) + }); + case DOC_TYPE_GROUP: { + let { + expandedStates, + contents + } = doc2; + if (expandedStates) { + expandedStates = expandedStates.map(rec); + contents = expandedStates[0]; + } else { + contents = rec(contents); + } + return cb({ + ...doc2, + contents, + expandedStates + }); + } + case DOC_TYPE_ALIGN: + case DOC_TYPE_INDENT: + case DOC_TYPE_INDENT_IF_BREAK: + case DOC_TYPE_LABEL: + case DOC_TYPE_LINE_SUFFIX: + return cb({ + ...doc2, + contents: rec(doc2.contents) + }); + case DOC_TYPE_STRING: + case DOC_TYPE_CURSOR: + case DOC_TYPE_TRIM: + case DOC_TYPE_LINE_SUFFIX_BOUNDARY: + case DOC_TYPE_LINE: + case DOC_TYPE_BREAK_PARENT: + return cb(doc2); + default: + throw new invalid_doc_error_default(doc2); + } + } +} +function findInDoc(doc, fn, defaultValue) { + let result = defaultValue; + let shouldSkipFurtherProcessing = false; + function findInDocOnEnterFn(doc2) { + if (shouldSkipFurtherProcessing) { + return false; + } + const maybeResult = fn(doc2); + if (maybeResult !== void 0) { + shouldSkipFurtherProcessing = true; + result = maybeResult; + } + } + traverse_doc_default(doc, findInDocOnEnterFn); + return result; +} +function willBreakFn(doc) { + if (doc.type === DOC_TYPE_GROUP && doc.break) { + return true; + } + if (doc.type === DOC_TYPE_LINE && doc.hard) { + return true; + } + if (doc.type === DOC_TYPE_BREAK_PARENT) { + return true; + } +} +function willBreak(doc) { + return findInDoc(doc, willBreakFn, false); +} +function breakParentGroup(groupStack) { + if (groupStack.length > 0) { + const parentGroup = at_default( + /* isOptionalObject*/ + false, + groupStack, + -1 + ); + if (!parentGroup.expandedStates && !parentGroup.break) { + parentGroup.break = "propagated"; + } + } + return null; +} +function propagateBreaks(doc) { + const alreadyVisitedSet = /* @__PURE__ */ new Set(); + const groupStack = []; + function propagateBreaksOnEnterFn(doc2) { + if (doc2.type === DOC_TYPE_BREAK_PARENT) { + breakParentGroup(groupStack); + } + if (doc2.type === DOC_TYPE_GROUP) { + groupStack.push(doc2); + if (alreadyVisitedSet.has(doc2)) { + return false; + } + alreadyVisitedSet.add(doc2); + } + } + function propagateBreaksOnExitFn(doc2) { + if (doc2.type === DOC_TYPE_GROUP) { + const group22 = groupStack.pop(); + if (group22.break) { + breakParentGroup(groupStack); + } + } + } + traverse_doc_default( + doc, + propagateBreaksOnEnterFn, + propagateBreaksOnExitFn, + /* shouldTraverseConditionalGroups */ + true + ); +} +function removeLinesFn(doc) { + if (doc.type === DOC_TYPE_LINE && !doc.hard) { + return doc.soft ? "" : " "; + } + if (doc.type === DOC_TYPE_IF_BREAK) { + return doc.flatContents; + } + return doc; +} +function removeLines(doc) { + return mapDoc(doc, removeLinesFn); +} +function stripTrailingHardlineFromParts(parts) { + parts = [...parts]; + while (parts.length >= 2 && at_default( + /* isOptionalObject*/ + false, + parts, + -2 + ).type === DOC_TYPE_LINE && at_default( + /* isOptionalObject*/ + false, + parts, + -1 + ).type === DOC_TYPE_BREAK_PARENT) { + parts.length -= 2; + } + if (parts.length > 0) { + const lastPart = stripTrailingHardlineFromDoc(at_default( + /* isOptionalObject*/ + false, + parts, + -1 + )); + parts[parts.length - 1] = lastPart; + } + return parts; +} +function stripTrailingHardlineFromDoc(doc) { + switch (get_doc_type_default(doc)) { + case DOC_TYPE_ALIGN: + case DOC_TYPE_INDENT: + case DOC_TYPE_INDENT_IF_BREAK: + case DOC_TYPE_GROUP: + case DOC_TYPE_LINE_SUFFIX: + case DOC_TYPE_LABEL: { + const contents = stripTrailingHardlineFromDoc(doc.contents); + return { + ...doc, + contents + }; + } + case DOC_TYPE_IF_BREAK: + return { + ...doc, + breakContents: stripTrailingHardlineFromDoc(doc.breakContents), + flatContents: stripTrailingHardlineFromDoc(doc.flatContents) + }; + case DOC_TYPE_FILL: + return { + ...doc, + parts: stripTrailingHardlineFromParts(doc.parts) + }; + case DOC_TYPE_ARRAY: + return stripTrailingHardlineFromParts(doc); + case DOC_TYPE_STRING: + return doc.replace(/[\n\r]*$/, ""); + case DOC_TYPE_CURSOR: + case DOC_TYPE_TRIM: + case DOC_TYPE_LINE_SUFFIX_BOUNDARY: + case DOC_TYPE_LINE: + case DOC_TYPE_BREAK_PARENT: + break; + default: + throw new invalid_doc_error_default(doc); + } + return doc; +} +function stripTrailingHardline(doc) { + return stripTrailingHardlineFromDoc(cleanDoc(doc)); +} +function cleanDocFn(doc) { + switch (get_doc_type_default(doc)) { + case DOC_TYPE_FILL: + if (doc.parts.every((part) => part === "")) { + return ""; + } + break; + case DOC_TYPE_GROUP: + if (!doc.contents && !doc.id && !doc.break && !doc.expandedStates) { + return ""; + } + if (doc.contents.type === DOC_TYPE_GROUP && doc.contents.id === doc.id && doc.contents.break === doc.break && doc.contents.expandedStates === doc.expandedStates) { + return doc.contents; + } + break; + case DOC_TYPE_ALIGN: + case DOC_TYPE_INDENT: + case DOC_TYPE_INDENT_IF_BREAK: + case DOC_TYPE_LINE_SUFFIX: + if (!doc.contents) { + return ""; + } + break; + case DOC_TYPE_IF_BREAK: + if (!doc.flatContents && !doc.breakContents) { + return ""; + } + break; + case DOC_TYPE_ARRAY: { + const parts = []; + for (const part of doc) { + if (!part) { + continue; + } + const [currentPart, ...restParts] = Array.isArray(part) ? part : [part]; + if (typeof currentPart === "string" && typeof at_default( + /* isOptionalObject*/ + false, + parts, + -1 + ) === "string") { + parts[parts.length - 1] += currentPart; + } else { + parts.push(currentPart); + } + parts.push(...restParts); + } + if (parts.length === 0) { + return ""; + } + if (parts.length === 1) { + return parts[0]; + } + return parts; + } + case DOC_TYPE_STRING: + case DOC_TYPE_CURSOR: + case DOC_TYPE_TRIM: + case DOC_TYPE_LINE_SUFFIX_BOUNDARY: + case DOC_TYPE_LINE: + case DOC_TYPE_LABEL: + case DOC_TYPE_BREAK_PARENT: + break; + default: + throw new invalid_doc_error_default(doc); + } + return doc; +} +function cleanDoc(doc) { + return mapDoc(doc, (currentDoc) => cleanDocFn(currentDoc)); +} +function replaceEndOfLine(doc, replacement = literalline) { + return mapDoc(doc, (currentDoc) => typeof currentDoc === "string" ? join(replacement, currentDoc.split("\n")) : currentDoc); +} +function canBreakFn(doc) { + if (doc.type === DOC_TYPE_LINE) { + return true; + } +} +function canBreak(doc) { + return findInDoc(doc, canBreakFn, false); +} +var MODE_BREAK = Symbol("MODE_BREAK"); +var MODE_FLAT = Symbol("MODE_FLAT"); +var CURSOR_PLACEHOLDER = Symbol("cursor"); +function rootIndent() { + return { + value: "", + length: 0, + queue: [] + }; +} +function makeIndent(ind, options2) { + return generateInd(ind, { + type: "indent" + }, options2); +} +function makeAlign(indent22, widthOrDoc, options2) { + if (widthOrDoc === Number.NEGATIVE_INFINITY) { + return indent22.root || rootIndent(); + } + if (widthOrDoc < 0) { + return generateInd(indent22, { + type: "dedent" + }, options2); + } + if (!widthOrDoc) { + return indent22; + } + if (widthOrDoc.type === "root") { + return { + ...indent22, + root: indent22 + }; + } + const alignType = typeof widthOrDoc === "string" ? "stringAlign" : "numberAlign"; + return generateInd(indent22, { + type: alignType, + n: widthOrDoc + }, options2); +} +function generateInd(ind, newPart, options2) { + const queue = newPart.type === "dedent" ? ind.queue.slice(0, -1) : [...ind.queue, newPart]; + let value = ""; + let length = 0; + let lastTabs = 0; + let lastSpaces = 0; + for (const part of queue) { + switch (part.type) { + case "indent": + flush(); + if (options2.useTabs) { + addTabs(1); + } else { + addSpaces(options2.tabWidth); + } + break; + case "stringAlign": + flush(); + value += part.n; + length += part.n.length; + break; + case "numberAlign": + lastTabs += 1; + lastSpaces += part.n; + break; + default: + throw new Error(`Unexpected type '${part.type}'`); + } + } + flushSpaces(); + return { + ...ind, + value, + length, + queue + }; + function addTabs(count) { + value += " ".repeat(count); + length += options2.tabWidth * count; + } + function addSpaces(count) { + value += " ".repeat(count); + length += count; + } + function flush() { + if (options2.useTabs) { + flushTabs(); + } else { + flushSpaces(); + } + } + function flushTabs() { + if (lastTabs > 0) { + addTabs(lastTabs); + } + resetLast(); + } + function flushSpaces() { + if (lastSpaces > 0) { + addSpaces(lastSpaces); + } + resetLast(); + } + function resetLast() { + lastTabs = 0; + lastSpaces = 0; + } +} +function trim2(out) { + let trimCount = 0; + let cursorCount = 0; + let outIndex = out.length; + outer: + while (outIndex--) { + const last = out[outIndex]; + if (last === CURSOR_PLACEHOLDER) { + cursorCount++; + continue; + } + for (let charIndex = last.length - 1; charIndex >= 0; charIndex--) { + const char = last[charIndex]; + if (char === " " || char === " ") { + trimCount++; + } else { + out[outIndex] = last.slice(0, charIndex + 1); + break outer; + } + } + } + if (trimCount > 0 || cursorCount > 0) { + out.length = outIndex + 1; + while (cursorCount-- > 0) { + out.push(CURSOR_PLACEHOLDER); + } + } + return trimCount; +} +function fits(next, restCommands, width, hasLineSuffix, groupModeMap, mustBeFlat) { + if (width === Number.POSITIVE_INFINITY) { + return true; + } + let restIdx = restCommands.length; + const cmds = [next]; + const out = []; + while (width >= 0) { + if (cmds.length === 0) { + if (restIdx === 0) { + return true; + } + cmds.push(restCommands[--restIdx]); + continue; + } + const { + mode, + doc + } = cmds.pop(); + switch (get_doc_type_default(doc)) { + case DOC_TYPE_STRING: + out.push(doc); + width -= get_string_width_default(doc); + break; + case DOC_TYPE_ARRAY: + case DOC_TYPE_FILL: { + const parts = getDocParts(doc); + for (let i = parts.length - 1; i >= 0; i--) { + cmds.push({ + mode, + doc: parts[i] + }); + } + break; + } + case DOC_TYPE_INDENT: + case DOC_TYPE_ALIGN: + case DOC_TYPE_INDENT_IF_BREAK: + case DOC_TYPE_LABEL: + cmds.push({ + mode, + doc: doc.contents + }); + break; + case DOC_TYPE_TRIM: + width += trim2(out); + break; + case DOC_TYPE_GROUP: { + if (mustBeFlat && doc.break) { + return false; + } + const groupMode = doc.break ? MODE_BREAK : mode; + const contents = doc.expandedStates && groupMode === MODE_BREAK ? at_default( + /* isOptionalObject*/ + false, + doc.expandedStates, + -1 + ) : doc.contents; + cmds.push({ + mode: groupMode, + doc: contents + }); + break; + } + case DOC_TYPE_IF_BREAK: { + const groupMode = doc.groupId ? groupModeMap[doc.groupId] || MODE_FLAT : mode; + const contents = groupMode === MODE_BREAK ? doc.breakContents : doc.flatContents; + if (contents) { + cmds.push({ + mode, + doc: contents + }); + } + break; + } + case DOC_TYPE_LINE: + if (mode === MODE_BREAK || doc.hard) { + return true; + } + if (!doc.soft) { + out.push(" "); + width--; + } + break; + case DOC_TYPE_LINE_SUFFIX: + hasLineSuffix = true; + break; + case DOC_TYPE_LINE_SUFFIX_BOUNDARY: + if (hasLineSuffix) { + return false; + } + break; + } + } + return false; +} +function printDocToString(doc, options2) { + const groupModeMap = {}; + const width = options2.printWidth; + const newLine = convertEndOfLineToChars(options2.endOfLine); + let pos = 0; + const cmds = [{ + ind: rootIndent(), + mode: MODE_BREAK, + doc + }]; + const out = []; + let shouldRemeasure = false; + const lineSuffix22 = []; + let printedCursorCount = 0; + propagateBreaks(doc); + while (cmds.length > 0) { + const { + ind, + mode, + doc: doc2 + } = cmds.pop(); + switch (get_doc_type_default(doc2)) { + case DOC_TYPE_STRING: { + const formatted = newLine !== "\n" ? string_replace_all_default( + /* isOptionalObject*/ + false, + doc2, + "\n", + newLine + ) : doc2; + out.push(formatted); + if (cmds.length > 0) { + pos += get_string_width_default(formatted); + } + break; + } + case DOC_TYPE_ARRAY: + for (let i = doc2.length - 1; i >= 0; i--) { + cmds.push({ + ind, + mode, + doc: doc2[i] + }); + } + break; + case DOC_TYPE_CURSOR: + if (printedCursorCount >= 2) { + throw new Error("There are too many 'cursor' in doc."); + } + out.push(CURSOR_PLACEHOLDER); + printedCursorCount++; + break; + case DOC_TYPE_INDENT: + cmds.push({ + ind: makeIndent(ind, options2), + mode, + doc: doc2.contents + }); + break; + case DOC_TYPE_ALIGN: + cmds.push({ + ind: makeAlign(ind, doc2.n, options2), + mode, + doc: doc2.contents + }); + break; + case DOC_TYPE_TRIM: + pos -= trim2(out); + break; + case DOC_TYPE_GROUP: + switch (mode) { + case MODE_FLAT: + if (!shouldRemeasure) { + cmds.push({ + ind, + mode: doc2.break ? MODE_BREAK : MODE_FLAT, + doc: doc2.contents + }); + break; + } + case MODE_BREAK: { + shouldRemeasure = false; + const next = { + ind, + mode: MODE_FLAT, + doc: doc2.contents + }; + const rem = width - pos; + const hasLineSuffix = lineSuffix22.length > 0; + if (!doc2.break && fits(next, cmds, rem, hasLineSuffix, groupModeMap)) { + cmds.push(next); + } else { + if (doc2.expandedStates) { + const mostExpanded = at_default( + /* isOptionalObject*/ + false, + doc2.expandedStates, + -1 + ); + if (doc2.break) { + cmds.push({ + ind, + mode: MODE_BREAK, + doc: mostExpanded + }); + break; + } else { + for (let i = 1; i < doc2.expandedStates.length + 1; i++) { + if (i >= doc2.expandedStates.length) { + cmds.push({ + ind, + mode: MODE_BREAK, + doc: mostExpanded + }); + break; + } else { + const state = doc2.expandedStates[i]; + const cmd = { + ind, + mode: MODE_FLAT, + doc: state + }; + if (fits(cmd, cmds, rem, hasLineSuffix, groupModeMap)) { + cmds.push(cmd); + break; + } + } + } + } + } else { + cmds.push({ + ind, + mode: MODE_BREAK, + doc: doc2.contents + }); + } + } + break; + } + } + if (doc2.id) { + groupModeMap[doc2.id] = at_default( + /* isOptionalObject*/ + false, + cmds, + -1 + ).mode; + } + break; + case DOC_TYPE_FILL: { + const rem = width - pos; + const { + parts + } = doc2; + if (parts.length === 0) { + break; + } + const [content, whitespace] = parts; + const contentFlatCmd = { + ind, + mode: MODE_FLAT, + doc: content + }; + const contentBreakCmd = { + ind, + mode: MODE_BREAK, + doc: content + }; + const contentFits = fits(contentFlatCmd, [], rem, lineSuffix22.length > 0, groupModeMap, true); + if (parts.length === 1) { + if (contentFits) { + cmds.push(contentFlatCmd); + } else { + cmds.push(contentBreakCmd); + } + break; + } + const whitespaceFlatCmd = { + ind, + mode: MODE_FLAT, + doc: whitespace + }; + const whitespaceBreakCmd = { + ind, + mode: MODE_BREAK, + doc: whitespace + }; + if (parts.length === 2) { + if (contentFits) { + cmds.push(whitespaceFlatCmd, contentFlatCmd); + } else { + cmds.push(whitespaceBreakCmd, contentBreakCmd); + } + break; + } + parts.splice(0, 2); + const remainingCmd = { + ind, + mode, + doc: fill(parts) + }; + const secondContent = parts[0]; + const firstAndSecondContentFlatCmd = { + ind, + mode: MODE_FLAT, + doc: [content, whitespace, secondContent] + }; + const firstAndSecondContentFits = fits(firstAndSecondContentFlatCmd, [], rem, lineSuffix22.length > 0, groupModeMap, true); + if (firstAndSecondContentFits) { + cmds.push(remainingCmd, whitespaceFlatCmd, contentFlatCmd); + } else if (contentFits) { + cmds.push(remainingCmd, whitespaceBreakCmd, contentFlatCmd); + } else { + cmds.push(remainingCmd, whitespaceBreakCmd, contentBreakCmd); + } + break; + } + case DOC_TYPE_IF_BREAK: + case DOC_TYPE_INDENT_IF_BREAK: { + const groupMode = doc2.groupId ? groupModeMap[doc2.groupId] : mode; + if (groupMode === MODE_BREAK) { + const breakContents = doc2.type === DOC_TYPE_IF_BREAK ? doc2.breakContents : doc2.negate ? doc2.contents : indent(doc2.contents); + if (breakContents) { + cmds.push({ + ind, + mode, + doc: breakContents + }); + } + } + if (groupMode === MODE_FLAT) { + const flatContents = doc2.type === DOC_TYPE_IF_BREAK ? doc2.flatContents : doc2.negate ? indent(doc2.contents) : doc2.contents; + if (flatContents) { + cmds.push({ + ind, + mode, + doc: flatContents + }); + } + } + break; + } + case DOC_TYPE_LINE_SUFFIX: + lineSuffix22.push({ + ind, + mode, + doc: doc2.contents + }); + break; + case DOC_TYPE_LINE_SUFFIX_BOUNDARY: + if (lineSuffix22.length > 0) { + cmds.push({ + ind, + mode, + doc: hardlineWithoutBreakParent + }); + } + break; + case DOC_TYPE_LINE: + switch (mode) { + case MODE_FLAT: + if (!doc2.hard) { + if (!doc2.soft) { + out.push(" "); + pos += 1; + } + break; + } else { + shouldRemeasure = true; + } + case MODE_BREAK: + if (lineSuffix22.length > 0) { + cmds.push({ + ind, + mode, + doc: doc2 + }, ...lineSuffix22.reverse()); + lineSuffix22.length = 0; + break; + } + if (doc2.literal) { + if (ind.root) { + out.push(newLine, ind.root.value); + pos = ind.root.length; + } else { + out.push(newLine); + pos = 0; + } + } else { + pos -= trim2(out); + out.push(newLine + ind.value); + pos = ind.length; + } + break; + } + break; + case DOC_TYPE_LABEL: + cmds.push({ + ind, + mode, + doc: doc2.contents + }); + break; + case DOC_TYPE_BREAK_PARENT: + break; + default: + throw new invalid_doc_error_default(doc2); + } + if (cmds.length === 0 && lineSuffix22.length > 0) { + cmds.push(...lineSuffix22.reverse()); + lineSuffix22.length = 0; + } + } + const cursorPlaceholderIndex = out.indexOf(CURSOR_PLACEHOLDER); + if (cursorPlaceholderIndex !== -1) { + const otherCursorPlaceholderIndex = out.indexOf(CURSOR_PLACEHOLDER, cursorPlaceholderIndex + 1); + const beforeCursor = out.slice(0, cursorPlaceholderIndex).join(""); + const aroundCursor = out.slice(cursorPlaceholderIndex + 1, otherCursorPlaceholderIndex).join(""); + const afterCursor = out.slice(otherCursorPlaceholderIndex + 1).join(""); + return { + formatted: beforeCursor + aroundCursor + afterCursor, + cursorNodeStart: beforeCursor.length, + cursorNodeText: aroundCursor + }; + } + return { + formatted: out.join("") + }; +} +var builders = { + join, + line, + softline, + hardline, + literalline, + group, + conditionalGroup, + fill, + lineSuffix, + lineSuffixBoundary, + cursor, + breakParent, + ifBreak, + trim, + indent, + indentIfBreak, + align, + addAlignmentToDoc, + markAsRoot, + dedentToRoot, + dedent, + hardlineWithoutBreakParent, + literallineWithoutBreakParent, + label, + // TODO: Remove this in v4 + concat: (parts) => parts +}; +var printer = { printDocToString }; +var utils = { + willBreak, + traverseDoc: traverse_doc_default, + findInDoc, + mapDoc, + removeLines, + stripTrailingHardline, + replaceEndOfLine, + canBreak +}; +function formatEnvSurround(node) { + const env = printRaw(node.env); + return { + envName: env, + start: ESCAPE + "begin{" + env + "}", + end: ESCAPE + "end{" + env + "}" + }; +} +function isLineType(elm) { + if (elm == null || typeof elm === "string") { + return false; + } + if (Array.isArray(elm)) { + return isLineType(elm[0]); + } + if (elm.type === "concat") { + return isLineType(elm.parts); + } + return elm.type === "line"; +} +function joinWithSoftline(arr) { + if (arr.length === 0 || arr.length === 1) { + return arr; + } + const ret = [arr[0]]; + for (let i = 1; i < arr.length; i++) { + const prevNode = arr[i - 1]; + const nextNode = arr[i]; + if (!isLineType(prevNode) && !isLineType(nextNode)) { + ret.push(softline2); + } + ret.push(nextNode); + } + return ret; +} +function getNodeInfo(node, options2) { + if (!node) { + return { renderInfo: {} }; + } + const renderInfo = node._renderInfo || {}; + const previousNode = options2.referenceMap && options2.referenceMap.getPreviousNode(node); + const nextNode = options2.referenceMap && options2.referenceMap.getNextNode(node); + const renderCache = options2.referenceMap && options2.referenceMap.getRenderCache(node); + return { + renderInfo, + renderCache, + previousNode, + nextNode, + referenceMap: options2.referenceMap + }; +} +var ESCAPE = "\\"; +var { + group: group2, + fill: fill2, + ifBreak: ifBreak2, + line: line2, + softline: softline2, + hardline: hardline2, + lineSuffix: lineSuffix2, + lineSuffixBoundary: lineSuffixBoundary2, + breakParent: breakParent2, + indent: indent2, + markAsRoot: markAsRoot2, + join: join2 +} = builders; +function formatDocArray(nodes, docArray, options2) { + const ret = []; + for (let i = 0; i < nodes.length; i++) { + const rawNode = nodes[i]; + const printedNode = docArray[i]; + const { renderInfo, referenceMap, previousNode, nextNode } = getNodeInfo(rawNode, options2); + const renderCache = referenceMap && referenceMap.getRenderCache(rawNode); + switch (rawNode.type) { + case "comment": + if (!rawNode.sameline && previousNode && !match.comment(previousNode) && !match.parbreak(previousNode)) { + ret.push(hardline2); + } + ret.push(printedNode); + if (nextNode && !rawNode.suffixParbreak) { + ret.push(hardline2); + } + break; + case "environment": + case "displaymath": + case "mathenv": + if (previousNode && (previousNode == null ? void 0 : previousNode.type) !== "parbreak") { + if (ret[ret.length - 1] === line2) { + ret.pop(); + } + if (ret[ret.length - 1] !== hardline2) { + ret.push(hardline2); + } + } + ret.push(printedNode); + if ((nextNode == null ? void 0 : nextNode.type) === "whitespace") { + ret.push(hardline2); + i++; + } + break; + case "macro": + if (renderInfo.breakBefore || renderInfo.breakAround) { + if (previousNode) { + if (ret[ret.length - 1] === line2 || ret[ret.length - 1] === hardline2) { + ret.pop(); + ret.push(hardline2); + } else if (!match.comment(previousNode) && !match.parbreak(previousNode)) { + ret.push(hardline2); + } + } + } + if (renderInfo.inParMode && !renderInfo.hangingIndent && renderCache) { + ret.push( + renderCache.content, + ...renderCache.rawArgs || [] + ); + } else { + ret.push(printedNode); + } + if (renderInfo.breakAfter || renderInfo.breakAround) { + if (nextNode) { + if (match.whitespace(nextNode)) { + ret.push(hardline2); + i++; + } else if (match.parbreak(nextNode)) + ; + else if (!match.comment(nextNode)) { + ret.push(hardline2); + } + } + } + break; + case "parbreak": + ret.push(hardline2, hardline2); + break; + default: + ret.push(printedNode); + break; + } + } + return ret; +} +function zip(array1, array2) { + const ret = []; + const len = Math.min(array1.length, array2.length); + for (let i = 0; i < len; i++) { + ret.push([array1[i], array2[i]]); + } + return ret; +} +function printMacro(path2, print, options2) { + const node = path2.getNode(); + const { renderInfo, previousNode, nextNode, referenceMap } = getNodeInfo( + node, + options2 + ); + const content = (node.escapeToken != null ? node.escapeToken : ESCAPE) + node.content; + const args = node.args ? path2.map(print, "args") : []; + const rawArgs = []; + for (const [arg2, printedArg] of zip(node.args || [], args)) { + const renderCache = referenceMap && referenceMap.getRenderCache(arg2); + if (renderInfo.inParMode && renderCache) { + rawArgs.push(...renderCache); + } else { + rawArgs.push(printedArg); + } + } + if (referenceMap) { + referenceMap.setRenderCache(node, { rawArgs, content }); + } + if (renderInfo.hangingIndent) { + return indent2(fill2([content, ...rawArgs])); + } + return group2([content, ...rawArgs]); +} +function printArgumentPgfkeys(nodes, options2) { + const { allowParenGroups = false } = options2; + const parsed = parsePgfkeys(nodes, { allowParenGroups }); + const content = []; + for (const part of parsed) { + const isLastItem = part === parsed[parsed.length - 1]; + if (part.itemParts) { + const parts = part.itemParts.map( + (node) => printRaw(node, { asArray: true }).map( + (token) => token === linebreak ? hardline2 : token + ) + ); + const row = join2("=", parts); + content.push(row); + if (part.trailingComma) { + content.push(","); + } + } + if (part.trailingComment) { + const leadingContent = part.itemParts ? [" "] : []; + if (part.leadingParbreak) { + leadingContent.push(hardline2); + } + content.push( + ...leadingContent, + // We're carefully and manually controlling the newlines, + // so print the comment directly without any newlines + "%", + part.trailingComment.content, + breakParent2 + ); + } + if (!isLastItem) { + content.push(line2); + } + } + let leadingComment = [""]; + if (options2.leadingComment) { + if (options2.leadingComment.leadingWhitespace) { + leadingComment.push(" "); + } + leadingComment.push("%" + options2.leadingComment.content, breakParent2); + } + return group2([ + options2.openMark, + ...leadingComment, + // If there is no content, we don't want to push an extra `softline`. + // This matters because the braces group could still be broken by `leadingComment` + content.length > 0 ? indent2([softline2, ...content]) : "", + softline2, + options2.closeMark + ]); +} +function printTikzArgument(path2, print, options2) { + const node = path2.getNode(); + getNodeInfo( + node, + options2 + ); + const content = []; + const nodes = [...node.content]; + trim$1(nodes); + try { + const tikzAst = parse$1(nodes); + if (tikzAst.content.length === 0) { + content.push(";"); + return content; + } + const printer2 = new TikzArgumentPrinter(tikzAst, path2, print); + return printer2.toDoc(); + } catch (e) { + console.warn("Encountered error when trying to parse tikz argument", e); + } + content.push(";"); + return content; +} +function printFragment(fragment, path2, print) { + const tmpKey = Symbol(); + const currNode = path2.getNode(); + if (!currNode) { + throw new Error( + "tried to print a fragment, but the current node is `null`" + ); + } + currNode[tmpKey] = fragment; + const ret = print(tmpKey); + delete currNode[tmpKey]; + return ret; +} +function printTikzPathSpecNode(node, path2, print) { + switch (node.type) { + case "comment": + return printFragment(node, path2, print); + case "unknown": + return printFragment(node.content, path2, print); + case "coordinate": + return [printRaw(node.prefix), "(", printRaw(node.content), ")"]; + case "line_to": + return node.command; + case "square_brace_group": + return printOptionalArgs(node.content); + case "operation": + return node.content.content; + case "svg_operation": { + const comments = node.comments.map( + (n) => printTikzPathSpecNode(n, path2, print) + ); + const options2 = node.options ? printOptionalArgs(node.options) : []; + const rest = node.options ? [group2(indent2([line2, printRaw(node.content)]))] : [" ", printRaw(node.content)]; + return [...comments, "svg", options2, ...rest]; + } + case "curve_to": { + const comments = node.comments.map( + (n) => printTikzPathSpecNode(n, path2, print) + ); + const printedControls = node.controls.length > 1 ? [ + printTikzPathSpecNode(node.controls[0], path2, print), + " ", + "and", + line2, + printTikzPathSpecNode(node.controls[1], path2, print) + ] : [printTikzPathSpecNode(node.controls[0], path2, print)]; + return [ + ...comments, + "..", + " ", + group2( + indent2(["controls", line2, ...printedControls, " ", ".."]) + ) + ]; + } + case "animation": { + const comments = node.comments.map( + (n) => printTikzPathSpecNode(n, path2, print) + ); + return [ + ...comments, + ":", + node.attribute, + " ", + "=", + " ", + group2( + indent2([ + printArgumentPgfkeys(node.content, { + openMark: "{", + closeMark: "}" + }) + ]) + ) + ]; + } + case "foreach": { + const comments = node.comments.map( + (n) => printTikzPathSpecNode(n, path2, print) + ); + const variables = [...node.variables]; + trim$1(variables); + const list = node.list.type === "macro" ? printFragment(node.list, path2, print) : printArgumentPgfkeys(node.list.content, { + openMark: "{", + closeMark: "}", + allowParenGroups: true + }); + const doc = [ + ...comments, + printRaw(node.start), + " ", + printRaw(variables) + ]; + if (node.options) { + doc.push(" ", indent2(printOptionalArgs(node.options))); + } + doc.push(" ", "in", " ", group2(indent2(list))); + const commandType = node.command.type; + switch (commandType) { + case "foreach": + doc.push( + indent2([ + line2, + printTikzPathSpecNode(node.command, path2, print) + ]) + ); + break; + case "macro": + doc.push( + indent2([line2, printFragment(node.command, path2, print)]) + ); + break; + case "group": { + const groupContent = [...node.command.content]; + trim$1(groupContent); + doc.push( + " ", + indent2( + group2([ + "{", + indent2([ + softline2, + ...groupContent.map( + (n) => printFragment(n, path2, print) + ) + ]), + softline2, + "}" + ]) + ) + ); + break; + } + default: + const invalidType = commandType; + console.warn( + `Unhandled command type when printing "foreach": ${invalidType}` + ); + } + return indent2(doc); + } + } + console.warn( + `Encountered unknown type when trying to print tikz PathSpec: "${node.type}"` + ); + return []; +} +function printOptionalArgs(nodes) { + return printArgumentPgfkeys(nodes, { + openMark: "[", + closeMark: "]" + }); +} +var _path, _print; +var TikzArgumentPrinter = class { + constructor(spec, path2, print) { + __privateAdd(this, _path, void 0); + __privateAdd(this, _print, void 0); + __privateSet(this, _path, path2); + __privateSet(this, _print, print); + this.nodes = [...spec.content]; + } + nodeToDoc(node) { + return printTikzPathSpecNode(node, __privateGet(this, _path), __privateGet(this, _print)); + } + toDoc() { + const doc = []; + const startArg = this.eatOptionalArg(); + if (startArg.optionalArg) { + doc.push( + ...startArg.comments.map( + (c) => printFragment(c, __privateGet(this, _path), __privateGet(this, _print)) + ) + ); + doc.push(printOptionalArgs(startArg.optionalArg.content)); + } + const innerDoc = []; + doc.push(group2([indent2(innerDoc), ";"])); + let cycle = -1; + while (this.nodes.length > 0) { + cycle++; + const firstSep = cycle === 0 && !startArg.optionalArg ? " " : line2; + const comingUp = this.peek(); + switch (comingUp) { + case "short_path": { + const [n0, n1, n2] = this.nodes.splice(0, 3); + innerDoc.push( + firstSep, + this.nodeToDoc(n0), + " ", + this.nodeToDoc(n1), + " ", + this.nodeToDoc(n2) + ); + continue; + } + case "long_path": { + const [n0, n1] = this.nodes.splice(0, 2); + if (n1.type === "operation") { + this.nodes.unshift(n1); + innerDoc.push( + firstSep, + this.nodeToDoc(n0), + " ", + this.eatOperation() + ); + } else { + innerDoc.push( + firstSep, + this.nodeToDoc(n0), + " ", + this.nodeToDoc(n1) + ); + } + continue; + } + case "node": + { + const eatenNode = this.eatNode(); + if (eatenNode) { + innerDoc.push(line2, ...eatenNode); + continue; + } + console.warn( + "Expected to print a tikz `node` PathSpec but couldn't find the text `node`" + ); + } + continue; + case "operation": + innerDoc.push(firstSep, this.eatOperation()); + continue; + case "unknown": { + const node = this.nodes.shift(); + innerDoc.push(firstSep, this.nodeToDoc(node)); + continue; + } + } + this.nodes.shift(); + } + return doc; + } + /** + * Look at the current node and the nodes that follow. Return what + * "type" is recognized. + */ + peek() { + const [n0, n1, n2, n3] = [ + this.nodes[0], + this.nodes[1], + this.nodes[2], + this.nodes[3] + ]; + if ((n0 == null ? void 0 : n0.type) === "coordinate" && isPathJoinOperation(n1)) { + if ((n2 == null ? void 0 : n2.type) === "coordinate" && !((n3 == null ? void 0 : n3.type) === "coordinate" || isPathJoinOperation(n3))) { + return "short_path"; + } + return "long_path"; + } + if ((n0 == null ? void 0 : n0.type) === "operation") { + if (n0.content.content === "node") { + return "node"; + } + return "operation"; + } + return "unknown"; + } + /** + * Eat comments and an optional arg if present. If no optional + * arg is present, do nothing. + */ + eatOptionalArg() { + let i = 0; + const comments = []; + let optionalArg = null; + for (; i < this.nodes.length; i++) { + const node = this.nodes[i]; + if (node.type === "square_brace_group") { + optionalArg = node; + i++; + break; + } + if (node.type === "comment") { + comments.push(node); + continue; + } + break; + } + if (optionalArg) { + this.nodes.splice(0, i); + } + return { optionalArg, comments }; + } + /** + * Eat a `type === "operation"` node whose contents is `"node"`. I.e., + * the type of thing that shows up in `\path node at (1,1) {foo};` + */ + eatNode() { + const firstNode = this.nodes[0]; + if ((firstNode == null ? void 0 : firstNode.type) === "operation" && firstNode.content.content === "node") { + this.nodes.shift(); + } else { + return null; + } + const innerDoc = []; + const commentBlock = []; + const doc = [commentBlock, "node", group2(indent2(innerDoc))]; + let hasNodeArgument = false; + let shouldBail = false; + let i = 0; + const comments = []; + const options2 = []; + const name = []; + const atLocations = []; + const animations = []; + let content = []; + for (; i < this.nodes.length && !shouldBail; i++) { + const node = this.nodes[i]; + switch (node.type) { + case "animation": + animations.push(this.nodeToDoc(node)); + continue; + case "comment": { + const comment = { + ...node, + leadingWhitespace: false + }; + comments.push(this.nodeToDoc(comment)); + continue; + } + case "square_brace_group": + options2.push(printOptionalArgs(node.content)); + continue; + case "coordinate": + name.push(this.nodeToDoc(node)); + continue; + case "operation": { + if (node.content.content === "at") { + const nextNode = this.nodes[i + 1]; + if (!nextNode || !(nextNode.type === "coordinate" || nextNode.type === "unknown" && match.anyMacro(nextNode.content))) { + shouldBail = true; + continue; + } + atLocations.push(["at", " ", this.nodeToDoc(nextNode)]); + i++; + continue; + } + shouldBail = true; + continue; + } + case "unknown": { + if (match.group(node.content)) { + hasNodeArgument = true; + content = this.nodeToDoc(node); + } + } + } + break; + } + if (!hasNodeArgument) { + return innerDoc; + } + this.nodes.splice(0, i + 1); + let isFirstElement = true; + let isNamed = !(Array.isArray(name) && name.length === 0); + for (const comment of comments) { + commentBlock.push(comment, hardline2); + } + if (options2.length > 0) { + innerDoc.push(join2(" ", options2)); + isFirstElement = false; + } + if (animations.length > 0) { + innerDoc.push(isFirstElement ? " " : line2); + innerDoc.push(join2(line2, animations)); + isFirstElement = false; + } + if (isNamed) { + innerDoc.push(isFirstElement ? " " : line2); + innerDoc.push(name); + isFirstElement = false; + } + if (atLocations.length > 0) { + innerDoc.push(isFirstElement || isNamed ? " " : line2); + innerDoc.push(join2(line2, atLocations)); + isFirstElement = false; + } + innerDoc.push(line2, content); + return doc; + } + /** + * Eat a `type === "operation"` node, including its optional arguments. + */ + eatOperation() { + const node = this.nodes[0]; + if ((node == null ? void 0 : node.type) === "operation") { + this.nodes.shift(); + } else { + return []; + } + const doc = []; + if ((node == null ? void 0 : node.type) !== "operation") { + throw new Error("Expecting `operation` node."); + } + const options2 = this.eatOptionalArg(); + doc.push( + ...options2.comments.map( + (c) => printFragment(c, __privateGet(this, _path), __privateGet(this, _print)) + ), + node.content.content + ); + if (options2.optionalArg) { + doc.push(indent2(printOptionalArgs(options2.optionalArg.content))); + } + return doc; + } +}; +_path = /* @__PURE__ */ new WeakMap(); +_print = /* @__PURE__ */ new WeakMap(); +var PATH_JOIN_OPERATIONS = /* @__PURE__ */ new Set(["rectangle", "grid", "sin", "cos", "to"]); +function isPathJoinOperation(node) { + if (!node) { + return false; + } + switch (node.type) { + case "line_to": + case "curve_to": + return true; + case "operation": + return PATH_JOIN_OPERATIONS.has(node.content.content); + } + return false; +} +function printArgument(path2, print, options2) { + const node = path2.getNode(); + const { renderInfo, previousNode, nextNode, referenceMap } = getNodeInfo( + node, + options2 + ); + if (node.openMark === "" && node.closeMark === "" && node.content.length === 0) { + return []; + } + const parentNode = path2.getParentNode(); + const { renderInfo: parentRenderInfo } = getNodeInfo(parentNode, options2); + if (parentRenderInfo.pgfkeysArgs) { + const leadingComment = node.content.length > 0 && match.comment(node.content[0]) && node.content[0].sameline ? node.content[0] : null; + const content2 = leadingComment ? node.content.slice(1) : node.content; + trim$1(content2); + return printArgumentPgfkeys(content2, { + openMark: node.openMark, + closeMark: node.closeMark, + leadingComment + }); + } + if (parentRenderInfo.tikzPathCommand) { + return printTikzArgument(path2, print, options2); + } + const openMark = node.openMark; + const closeMark = node.closeMark; + let content = path2.map(print, "content"); + content = formatDocArray(node.content, content, options2); + if (match.comment(node.content[node.content.length - 1])) { + content.push(hardline2); + } + let rawRet = [openMark, fill2(content), closeMark]; + if (renderInfo.inParMode) { + rawRet = [openMark, ...content, closeMark]; + } + if (referenceMap) { + referenceMap.setRenderCache(node, rawRet); + } + return rawRet; +} +function hasPreambleCode(nodes) { + return nodes.some((node) => match.macro(node, "documentclass")); +} +function printRoot(path2, print, options2) { + const node = path2.getNode(); + getNodeInfo( + node, + options2 + ); + const content = path2.map(print, "content"); + const rawContent = formatDocArray(node.content, content, options2); + const concatFunction = hasPreambleCode(node.content) ? (x) => x : fill2; + return concatFunction(rawContent); +} +function printComment(path2, _print2, _options) { + const node = path2.getNode(); + let leadingWhitespace = ""; + if (node.leadingWhitespace && node.sameline) { + leadingWhitespace = " "; + } + const content = [leadingWhitespace, "%" + printRaw(node.content)]; + return content; +} +function printInlineMath(path2, print, options2) { + const node = path2.getNode(); + if (node.content.length === 0) { + return ["$", " ", "$"]; + } + let content = path2.map(print, "content"); + content = formatDocArray(node.content, content, options2); + content = joinWithSoftline(content); + if (node.content[node.content.length - 1].type === "comment") { + content.push(hardline2); + } + return fill2(["$", ...content, "$"]); +} +function printDisplayMath(path2, print, options2) { + const node = path2.getNode(); + let content = path2.map(print, "content"); + content = formatDocArray(node.content, content, options2); + content = joinWithSoftline(content); + const bodyStartToken = [hardline2]; + if (node.content.length === 0 || node.content[0].type === "comment" && node.content[0].sameline) { + bodyStartToken.pop(); + } + return [ + ESCAPE + "[", + indent2(fill2(bodyStartToken.concat(content))), + hardline2, + ESCAPE + "]" + ]; +} +function printVerbatimEnvironment(path2, print, options2) { + const node = path2.getNode(); + const env = formatEnvSurround(node); + return [env.start, node.content, env.end]; +} +function printEnvironment(path2, print, options2) { + const node = path2.getNode(); + const { renderInfo, previousNode, nextNode, referenceMap } = getNodeInfo( + node, + options2 + ); + const args = node.args ? path2.map(print, "args") : []; + const env = formatEnvSurround(node); + let content = path2.map(print, "content"); + content = formatDocArray(node.content, content, options2); + if (renderInfo.inMathMode) { + content = joinWithSoftline(content); + } + let bodyStartToken = [hardline2]; + if (node.content.length === 0 || node.content[0].type === "comment" && node.content[0].sameline) { + bodyStartToken.pop(); + } + return [ + env.start, + ...args, + indent2(fill2(bodyStartToken.concat(content))), + hardline2, + env.end + ]; +} +function printAlignedEnvironment(path2, print, options2) { + const node = path2.getNode(); + getNodeInfo( + node, + options2 + ); + const args = node.args ? path2.map(print, "args") : []; + const env = formatEnvSurround(node); + const leadingComment = node.content[0] && node.content[0].type === "comment" && node.content[0].sameline ? node.content[0] : null; + const { rows, rowSeps, trailingComments } = formatAlignedContent( + leadingComment ? node.content.slice(1) : node.content + ); + const content = []; + for (let i = 0; i < rows.length; i++) { + const row = rows[i]; + const rowSep = rowSeps[i]; + const trailingComment = trailingComments[i]; + content.push(row); + if (rowSep) { + content.push(printRaw(rowSep)); + } + if (rowSep && trailingComment) { + content.push(" "); + } + if (trailingComment) { + content.push(["%", printRaw(trailingComment.content)]); + } + if (rowSep || trailingComment) { + content.push(hardline2); + } + } + if (content[content.length - 1] === hardline2) { + content.pop(); + } + if (leadingComment) { + content.unshift( + leadingComment.leadingWhitespace ? " " : "", + "%" + printRaw(leadingComment.content), + hardline2 + ); + return [env.start, ...args, indent2(content), hardline2, env.end]; + } + return [ + env.start, + ...args, + indent2([hardline2, ...content]), + hardline2, + env.end + ]; +} +function formatAlignedContent(nodes) { + function getSpace(len = 1) { + return " ".repeat(len); + } + const rows = parseAlignEnvironment(nodes); + const numCols = Math.max(...rows.map((r) => r.cells.length)); + const rowSeps = rows.map(({ rowSep }) => printRaw(rowSep || [])); + const trailingComments = rows.map(({ trailingComment }) => trailingComment); + const renderedRows = rows.map(({ cells, colSeps }) => ({ + cells: cells.map((nodes2) => { + trim$1(nodes2); + return printRaw(nodes2); + }), + seps: colSeps.map((nodes2) => printRaw(nodes2)) + })); + const colWidths = []; + for (let i = 0; i < numCols; i++) { + colWidths.push( + Math.max( + ...renderedRows.map( + ({ cells, seps }) => ((cells[i] || "") + (seps[i] || "")).length + ) + ) + ); + } + const joinedRows = renderedRows.map(({ cells, seps }) => { + if (cells.length === 1 && cells[0] === "") { + return ""; + } + let ret = ""; + for (let i = 0; i < cells.length; i++) { + const width = colWidths[i] - (seps[i] || "").length; + ret += (i === 0 ? "" : " ") + cells[i] + getSpace(width - cells[i].length + 1) + (seps[i] || ""); + } + return ret; + }); + return { rows: joinedRows, rowSeps, trailingComments }; +} +var ReferenceMap = class { + constructor(ast) { + this.ast = ast; + this.map = /* @__PURE__ */ new Map(); + visit( + this.ast, + (nodeList) => { + for (let i = 0; i < nodeList.length; i++) { + this.map.set(nodeList[i], { + previous: nodeList[i - 1], + next: nodeList[i + 1] + }); + } + }, + { includeArrays: true, test: Array.isArray } + ); + } + /** + * Associate render-specific data with this node. This data + * will be overwritten if `setRenderCache` is called twice. + * + * @param {Ast.Ast} node + * @param {*} data + * @memberof ReferenceMap + */ + setRenderCache(node, data) { + const currData = this.map.get(node) || {}; + this.map.set(node, { ...currData, renderCache: data }); + } + /** + * Retrieve data associated with `node` via `setRenderCache` + * + * @param {Ast.Ast} node + * @returns {(object | undefined)} + * @memberof ReferenceMap + */ + getRenderCache(node) { + var _a; + return (_a = this.map.get(node)) == null ? void 0 : _a.renderCache; + } + getPreviousNode(node) { + return (this.map.get(node) || {}).previous; + } + getNextNode(node) { + return (this.map.get(node) || {}).next; + } +}; +function printLatexAst(path2, options2, print) { + const node = path2.getValue(); + const { renderInfo } = getNodeInfo(node, options2); + if (node == null) { + return node; + } + if (typeof node === "string") { + return node; + } + switch (node.type) { + case "root": + if (options2.referenceMap) { + console.warn( + "Processing root node, but ReferenceMap already exists. Are there multiple nodes of type 'root'?" + ); + } + options2.referenceMap = new ReferenceMap(node); + return printRoot(path2, print, options2); + case "argument": + return printArgument(path2, print, options2); + case "comment": + return printComment(path2); + case "environment": + case "mathenv": + if (renderInfo.alignContent) { + return printAlignedEnvironment(path2, print, options2); + } + return printEnvironment(path2, print, options2); + case "displaymath": + return printDisplayMath(path2, print, options2); + case "group": + const content = printRaw(node.content, { + asArray: true + }).map((token) => token === linebreak ? hardline2 : token); + return ["{", ...content, "}"]; + case "inlinemath": + return printInlineMath(path2, print, options2); + case "macro": + return printMacro(path2, print, options2); + case "parbreak": + return [hardline2, hardline2]; + case "string": + return node.content; + case "verb": + return [ + ESCAPE, + node.env, + node.escape, + printRaw(node.content), + node.escape + ]; + case "verbatim": + return printVerbatimEnvironment(path2); + case "whitespace": + return line2; + default: + console.warn("Printing unknown type", node); + return printRaw(node); + } +} +var languages$1 = [ + { + name: "latex", + extensions: [".tex"], + parsers: ["latex-parser"] + } +]; +var parsers$1 = { + "latex-parser": { + parse, + astFormat: "latex-ast", + locStart: (node) => node.position ? node.position.start.offset : 0, + locEnd: (node) => node.position ? node.position.end.offset : 1 + } +}; +var printers$1 = { + "latex-ast": { + print: printLatexAst + } +}; +var prettierPluginLatex$1 = { languages: languages$1, parsers: parsers$1, printers: printers$1 }; +const options = {}; +const defaultOptions = { + useTabs: true +}; +const languages = prettierPluginLatex$1.languages; +const parsers = prettierPluginLatex$1.parsers; +const printers = prettierPluginLatex$1.printers; +const prettierPluginLatex = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({ + __proto__: null, + defaultOptions, + languages, + options, + parsers, + printers +}, Symbol.toStringTag, { value: "Module" })); +exports.defaultOptions = defaultOptions; +exports.languages = languages; +exports.options = options; +exports.parsers = parsers; +exports.prettierPluginLatex = prettierPluginLatex; +exports.printers = printers; +//# sourceMappingURL=prettier-plugin-latex-f9d12326.js.map diff --git a/node_modules/prettier-plugin-latex/dist/prettier-plugin-latex-f9d12326.js.map b/node_modules/prettier-plugin-latex/dist/prettier-plugin-latex-f9d12326.js.map new file mode 100644 index 0000000..d3cf703 --- /dev/null +++ b/node_modules/prettier-plugin-latex/dist/prettier-plugin-latex-f9d12326.js.map @@ -0,0 +1 @@ +{"version":3,"file":"prettier-plugin-latex-f9d12326.js","sources":["../node_modules/@unified-latex/unified-latex-util-print-raw/index.js","../node_modules/@unified-latex/unified-latex-util-match/index.js","../node_modules/@unified-latex/unified-latex-util-visit/index.js","../node_modules/@unified-latex/unified-latex-util-trim/index.js","../node_modules/@unified-latex/unified-latex-util-pegjs/index.js","../node_modules/@unified-latex/unified-latex-util-argspec/index.js","../node_modules/@unified-latex/unified-latex-builder/index.js","../node_modules/trie-prefix-tree/dist/config.js","../node_modules/trie-prefix-tree/dist/append.js","../node_modules/trie-prefix-tree/dist/create.js","../node_modules/trie-prefix-tree/dist/utils.js","../node_modules/trie-prefix-tree/dist/checkPrefix.js","../node_modules/trie-prefix-tree/dist/recursePrefix.js","../node_modules/trie-prefix-tree/dist/recurseRandomWord.js","../node_modules/trie-prefix-tree/dist/permutations.js","../node_modules/trie-prefix-tree/dist/index.js","../node_modules/@unified-latex/unified-latex-util-scan/index.js","../node_modules/@unified-latex/unified-latex-util-render-info/index.js","../node_modules/@unified-latex/unified-latex-util-arguments/index.js","../node_modules/@unified-latex/unified-latex-ctan/package/tikz/index.js","../node_modules/@unified-latex/unified-latex-util-pgfkeys/index.js","../node_modules/@unified-latex/unified-latex-util-align/index.js","../node_modules/bail/index.js","../node_modules/is-buffer/index.js","../node_modules/extend/index.js","../node_modules/is-plain-obj/index.js","../node_modules/trough/index.js","../node_modules/unist-util-stringify-position/lib/index.js","../node_modules/vfile-message/lib/index.js","../node_modules/vfile/lib/minpath.browser.js","../node_modules/vfile/lib/minproc.browser.js","../node_modules/vfile/lib/minurl.shared.js","../node_modules/vfile/lib/minurl.browser.js","../node_modules/vfile/lib/index.js","../node_modules/unified/lib/index.js","../node_modules/@unified-latex/unified-latex-util-split/index.js","../node_modules/@unified-latex/unified-latex-util-replace/index.js","../node_modules/color-name/index.js","../node_modules/is-arrayish/index.js","../node_modules/simple-swizzle/index.js","../node_modules/color-string/index.js","../node_modules/color-convert/conversions.js","../node_modules/color-convert/route.js","../node_modules/color-convert/index.js","../node_modules/color/index.js","../node_modules/@unified-latex/unified-latex-ctan/index.js","../node_modules/@unified-latex/unified-latex-util-environments/index.js","../node_modules/@unified-latex/unified-latex-util-catcode/index.js","../node_modules/@unified-latex/unified-latex-util-parse/index.js","../node_modules/@unified-latex/unified-latex-prettier/index.js","../src/prettier-plugin-latex.ts"],"sourcesContent":["// libs/print-raw.ts\nvar linebreak = Symbol(\"linebreak\");\nvar ESCAPE = \"\\\\\";\nfunction _printRaw(node) {\n if (typeof node === \"string\") {\n return [node];\n }\n if (Array.isArray(node)) {\n return [].concat(\n ...node.map((n) => _printRaw(n))\n );\n }\n let argsString, escape;\n switch (node.type) {\n case \"root\":\n return _printRaw(node.content);\n case \"argument\":\n return [node.openMark, ..._printRaw(node.content), node.closeMark];\n case \"comment\":\n var suffix = node.suffixParbreak ? \"\" : linebreak;\n var leadingWhitespace = \"\";\n if (node.sameline && node.leadingWhitespace) {\n leadingWhitespace = \" \";\n }\n if (node.sameline) {\n return [\n leadingWhitespace,\n \"%\",\n ..._printRaw(node.content),\n suffix\n ];\n }\n return [linebreak, \"%\", ..._printRaw(node.content), suffix];\n case \"environment\":\n case \"mathenv\":\n case \"verbatim\":\n var env = _printRaw(node.env);\n var envStart = [ESCAPE + \"begin{\", ...env, \"}\"];\n var envEnd = [ESCAPE + \"end{\", ...env, \"}\"];\n argsString = node.args == null ? [] : _printRaw(node.args);\n return [\n ...envStart,\n ...argsString,\n ..._printRaw(node.content),\n ...envEnd\n ];\n case \"displaymath\":\n return [ESCAPE + \"[\", ..._printRaw(node.content), ESCAPE + \"]\"];\n case \"group\":\n return [\"{\", ..._printRaw(node.content), \"}\"];\n case \"inlinemath\":\n return [\"$\", ..._printRaw(node.content), \"$\"];\n case \"macro\":\n argsString = node.args == null ? [] : _printRaw(node.args);\n escape = node.escapeToken == null ? ESCAPE : node.escapeToken;\n return [escape, ..._printRaw(node.content), ...argsString];\n case \"parbreak\":\n return [linebreak, linebreak];\n case \"string\":\n return [node.content];\n case \"verb\":\n return [\n ESCAPE,\n node.env,\n node.escape,\n ..._printRaw(node.content),\n node.escape\n ];\n case \"whitespace\":\n return [\" \"];\n default:\n console.warn(\n \"Cannot find render for node \",\n node,\n `(of type ${typeof node})`\n );\n return [\"\" + node];\n }\n}\nfunction printRaw(node, options) {\n const asArray = options != null ? options.asArray : false;\n const printedTokens = _printRaw(node);\n if (asArray) {\n return printedTokens;\n }\n return printedTokens.map((x) => x === linebreak ? \"\\n\" : x).join(\"\");\n}\nexport {\n linebreak,\n printRaw\n};\n//# sourceMappingURL=index.js.map\n","// libs/match.ts\nimport { printRaw } from \"@unified-latex/unified-latex-util-print-raw\";\nfunction createMacroMatcher(macros) {\n const macrosHash = Array.isArray(macros) ? macros.length > 0 ? typeof macros[0] === \"string\" ? Object.fromEntries(\n macros.map((macro2) => {\n if (typeof macro2 !== \"string\") {\n throw new Error(\"Wrong branch of map function\");\n }\n return [macro2, {}];\n })\n ) : Object.fromEntries(\n macros.map((macro2) => {\n if (typeof macro2 === \"string\") {\n throw new Error(\"Wrong branch of map function\");\n }\n if (macro2.escapeToken != null) {\n return [\n macro2.content,\n { escapeToken: macro2.escapeToken }\n ];\n }\n return [macro2.content, {}];\n })\n ) : {} : macros;\n return function matchAgainstMacros(node) {\n if (node == null || node.type !== \"macro\") {\n return false;\n }\n const spec = macrosHash[node.content];\n if (!spec) {\n return false;\n }\n if (typeof spec === \"object\" && \"escapeToken\" in spec) {\n return spec.escapeToken == null || spec.escapeToken === node.escapeToken;\n }\n return true;\n };\n}\nfunction createEnvironmentMatcher(macros) {\n const environmentsHash = Array.isArray(macros) ? Object.fromEntries(\n macros.map((str) => {\n return [str, {}];\n })\n ) : macros;\n return function matchAgainstEnvironments(node) {\n if (!match.anyEnvironment(node)) {\n return false;\n }\n const envName = printRaw(node.env);\n const spec = environmentsHash[envName];\n if (!spec) {\n return false;\n }\n return true;\n };\n}\nvar match = {\n macro(node, macroName) {\n if (node == null) {\n return false;\n }\n return node.type === \"macro\" && (macroName == null || node.content === macroName);\n },\n anyMacro(node) {\n return match.macro(node);\n },\n environment(node, envName) {\n if (node == null) {\n return false;\n }\n return (node.type === \"environment\" || node.type === \"mathenv\") && (envName == null || printRaw(node.env) === envName);\n },\n anyEnvironment(node) {\n return match.environment(node);\n },\n comment(node) {\n if (node == null) {\n return false;\n }\n return node.type === \"comment\";\n },\n parbreak(node) {\n if (node == null) {\n return false;\n }\n return node.type === \"parbreak\";\n },\n whitespace(node) {\n if (node == null) {\n return false;\n }\n return node.type === \"whitespace\";\n },\n /**\n * Matches whitespace or a comment with leading whitespace.\n */\n whitespaceLike(node) {\n if (node == null) {\n return false;\n }\n return node.type === \"whitespace\" || node.type === \"whitespace\" && node.leadingWhitespace === true;\n },\n string(node, value) {\n if (node == null) {\n return false;\n }\n return node.type === \"string\" && (value == null || node.content === value);\n },\n anyString(node) {\n return match.string(node);\n },\n group(node) {\n if (node == null) {\n return false;\n }\n return node.type === \"group\";\n },\n argument(node) {\n if (node == null) {\n return false;\n }\n return node.type === \"argument\";\n },\n blankArgument(node) {\n if (!match.argument(node)) {\n return false;\n }\n return node.openMark === \"\" && node.closeMark === \"\" && node.content.length === 0;\n },\n math(node) {\n if (node == null) {\n return false;\n }\n return node.type === \"displaymath\" || node.type === \"inlinemath\";\n },\n createMacroMatcher,\n createEnvironmentMatcher\n};\nvar {\n anyEnvironment,\n anyMacro,\n anyString,\n argument,\n blankArgument,\n comment,\n environment,\n group,\n macro,\n math,\n parbreak,\n string,\n whitespace\n} = match;\nexport {\n anyEnvironment,\n anyMacro,\n anyString,\n argument,\n blankArgument,\n comment,\n environment,\n group,\n macro,\n match,\n math,\n parbreak,\n string,\n whitespace\n};\n//# sourceMappingURL=index.js.map\n","// libs/list-math-children.ts\nimport { match } from \"@unified-latex/unified-latex-util-match\";\nfunction listMathChildren(node) {\n const NULL_RETURN = { enter: [], leave: [] };\n if (Array.isArray(node)) {\n return NULL_RETURN;\n }\n if (match.math(node)) {\n return { enter: [\"content\"], leave: [] };\n }\n const renderInfo = node._renderInfo || {};\n if (renderInfo.inMathMode == null) {\n return NULL_RETURN;\n }\n if (match.macro(node)) {\n if (renderInfo.inMathMode === true) {\n return { enter: [\"args\"], leave: [] };\n } else if (renderInfo.inMathMode === false) {\n return { enter: [], leave: [\"args\"] };\n }\n }\n if (match.environment(node)) {\n if (renderInfo.inMathMode === true) {\n return { enter: [\"content\"], leave: [] };\n } else {\n return { enter: [], leave: [\"content\"] };\n }\n }\n return NULL_RETURN;\n}\n\n// libs/visit.ts\nvar CONTINUE = Symbol(\"continue\");\nvar SKIP = Symbol(\"skip\");\nvar EXIT = Symbol(\"exit\");\nvar DEFAULT_CONTEXT = {\n inMathMode: false,\n hasMathModeAncestor: false\n};\nfunction visit(tree, visitor, options) {\n const {\n startingContext = DEFAULT_CONTEXT,\n test = () => true,\n includeArrays = false\n } = options || {};\n let enter;\n let leave;\n if (typeof visitor === \"function\") {\n enter = visitor;\n } else if (visitor && typeof visitor === \"object\") {\n enter = visitor.enter;\n leave = visitor.leave;\n }\n walk(tree, {\n key: void 0,\n index: void 0,\n parents: [],\n containingArray: void 0,\n context: { ...startingContext }\n });\n function walk(node, { key, index, parents, context, containingArray }) {\n const nodePassesTest = includeArrays ? test(node, { key, index, parents, context, containingArray }) : !Array.isArray(node) && test(node, { key, index, parents, context, containingArray });\n const result = enter && nodePassesTest ? toResult(\n enter(node, {\n key,\n index,\n parents,\n context,\n containingArray\n })\n ) : [CONTINUE];\n if (result[0] === EXIT) {\n return result;\n }\n if (result[0] === SKIP) {\n return leave && nodePassesTest ? toResult(\n leave(node, {\n key,\n index,\n parents,\n context,\n containingArray\n })\n ) : result;\n }\n if (Array.isArray(node)) {\n for (let index2 = 0; index2 > -1 && index2 < node.length; index2++) {\n const item = node[index2];\n const result2 = walk(item, {\n key,\n index: index2,\n parents,\n context,\n containingArray: node\n });\n if (result2[0] === EXIT) {\n return result2;\n }\n if (typeof result2[1] === \"number\") {\n index2 = result2[1] - 1;\n }\n }\n } else {\n let childProps = [\"content\", \"args\"];\n switch (node.type) {\n case \"macro\":\n childProps = [\"args\"];\n break;\n case \"comment\":\n case \"string\":\n case \"verb\":\n case \"verbatim\":\n childProps = [];\n break;\n default:\n break;\n }\n const mathModeProps = listMathChildren(node);\n for (const key2 of childProps) {\n const value = node[key2];\n const grandparents = [node].concat(parents);\n if (value == null) {\n continue;\n }\n const newContext = { ...context };\n if (mathModeProps.enter.includes(key2)) {\n newContext.inMathMode = true;\n newContext.hasMathModeAncestor = true;\n } else if (mathModeProps.leave.includes(key2)) {\n newContext.inMathMode = false;\n }\n const result2 = walk(value, {\n key: key2,\n index: void 0,\n parents: grandparents,\n context: newContext,\n containingArray: void 0\n });\n if (result2[0] === EXIT) {\n return result2;\n }\n }\n }\n return leave && nodePassesTest ? toResult(\n leave(node, {\n key,\n index,\n parents,\n context,\n containingArray\n })\n ) : result;\n }\n}\nfunction toResult(value) {\n if (value == null) {\n return [CONTINUE];\n }\n if (Array.isArray(value)) {\n return value;\n }\n if (typeof value === \"number\") {\n return [CONTINUE, value];\n }\n return [value];\n}\nexport {\n CONTINUE,\n EXIT,\n SKIP,\n visit\n};\n//# sourceMappingURL=index.js.map\n","// libs/trim.ts\nimport { match } from \"@unified-latex/unified-latex-util-match\";\nfunction trim(nodes) {\n if (!Array.isArray(nodes)) {\n console.warn(\"Trying to trim a non-array ast\", nodes);\n return nodes;\n }\n const { trimmedStart } = trimStart(nodes);\n const { trimmedEnd } = trimEnd(nodes);\n return { trimmedStart, trimmedEnd };\n}\nfunction trimStart(nodes) {\n const { start } = amountOfLeadingAndTrailingWhitespace(nodes);\n nodes.splice(0, start);\n for (const leadingToken of nodes) {\n if (!match.comment(leadingToken)) {\n break;\n }\n if (leadingToken.leadingWhitespace || leadingToken.sameline) {\n leadingToken.leadingWhitespace = false;\n delete leadingToken.position;\n }\n if (start > 0 && leadingToken.sameline) {\n leadingToken.sameline = false;\n delete leadingToken.position;\n }\n }\n return { trimmedStart: start };\n}\nfunction trimEnd(nodes) {\n const { end } = amountOfLeadingAndTrailingWhitespace(nodes);\n nodes.splice(nodes.length - end, end);\n for (let i = nodes.length - 1; i >= 0; i--) {\n const trailingToken = nodes[i];\n if (!match.comment(trailingToken)) {\n break;\n }\n delete trailingToken.suffixParbreak;\n if (match.comment(trailingToken) && trailingToken.leadingWhitespace && !trailingToken.sameline) {\n trailingToken.leadingWhitespace = false;\n delete trailingToken.position;\n }\n }\n return { trimmedEnd: end };\n}\nfunction amountOfLeadingAndTrailingWhitespace(ast) {\n let start = 0;\n let end = 0;\n for (const node of ast) {\n if (match.whitespace(node) || match.parbreak(node)) {\n start++;\n } else {\n break;\n }\n }\n if (start === ast.length) {\n return { start, end: 0 };\n }\n for (let i = ast.length - 1; i >= 0; i--) {\n const node = ast[i];\n if (match.whitespace(node) || match.parbreak(node)) {\n end++;\n } else {\n break;\n }\n }\n return { start, end };\n}\n\n// libs/unified-latex-trim-environment-contents.ts\nimport { match as match2 } from \"@unified-latex/unified-latex-util-match\";\nimport { visit } from \"@unified-latex/unified-latex-util-visit\";\nvar unifiedLatexTrimEnvironmentContents = function unifiedLatexTrimEnvironmentContents2() {\n return (tree) => {\n visit(tree, (node) => {\n if (!(match2.math(node) || match2.anyEnvironment(node))) {\n return;\n }\n let firstNode = node.content[0];\n if (match2.comment(firstNode) && firstNode.sameline) {\n firstNode.suffixParbreak = false;\n trimEnd(node.content);\n const { trimmedStart } = trimStart(node.content.slice(1));\n node.content.splice(1, trimmedStart);\n } else {\n trim(node.content);\n }\n });\n };\n};\n\n// libs/unified-latex-trim-root.ts\nvar unifiedLatexTrimRoot = function unifiedLatexTrimRoot2() {\n return (tree) => {\n trim(tree.content);\n };\n};\n\n// libs/has-whitespace-equivalent.ts\nimport { match as match3 } from \"@unified-latex/unified-latex-util-match\";\nfunction hasWhitespaceEquivalent(nodes) {\n let start = false;\n let end = false;\n for (let i = 0; i < nodes.length; i++) {\n const node = nodes[i];\n if (match3.comment(node)) {\n if (node.leadingWhitespace) {\n start = true;\n break;\n }\n continue;\n }\n if (match3.whitespace(node)) {\n start = true;\n }\n break;\n }\n for (let j = nodes.length - 1; j >= 0; j--) {\n const node = nodes[j];\n if (match3.comment(node)) {\n if (node.leadingWhitespace) {\n end = true;\n break;\n }\n continue;\n }\n if (match3.whitespace(node)) {\n end = true;\n }\n break;\n }\n return { start, end };\n}\nexport {\n hasWhitespaceEquivalent,\n trim,\n trimEnd,\n trimStart,\n unifiedLatexTrimEnvironmentContents,\n unifiedLatexTrimRoot\n};\n//# sourceMappingURL=index.js.map\n","// libs/decorate-array-for-pegjs.ts\nfunction decorateArrayForPegjs(array) {\n array.charAt = function(i) {\n return this[i];\n };\n array.charCodeAt = () => 0;\n array.substring = function(i, j) {\n return this.slice(i, j);\n };\n array.replace = function(a, b) {\n const ret = JSON.stringify(this);\n return ret.replace(a, b);\n };\n return array;\n}\n\n// libs/split-strings.ts\nimport { match } from \"@unified-latex/unified-latex-util-match\";\nfunction splitStringsIntoSingleChars(nodes) {\n return nodes.flatMap(\n (node) => match.anyString(node) ? Array.from(node.content).map((c) => ({\n type: \"string\",\n content: c\n })) : node\n );\n}\n\n// grammars/latex.pegjs\nvar latex_default = (\n // Generated by Peggy 2.0.1.\n //\n // https://peggyjs.org/\n function() {\n \"use strict\";\n function peg$subclass(child, parent) {\n function C() {\n this.constructor = child;\n }\n C.prototype = parent.prototype;\n child.prototype = new C();\n }\n function peg$SyntaxError(message, expected, found, location) {\n var self = Error.call(this, message);\n if (Object.setPrototypeOf) {\n Object.setPrototypeOf(self, peg$SyntaxError.prototype);\n }\n self.expected = expected;\n self.found = found;\n self.location = location;\n self.name = \"SyntaxError\";\n return self;\n }\n peg$subclass(peg$SyntaxError, Error);\n function peg$padEnd(str, targetLength, padString) {\n padString = padString || \" \";\n if (str.length > targetLength) {\n return str;\n }\n targetLength -= str.length;\n padString += padString.repeat(targetLength);\n return str + padString.slice(0, targetLength);\n }\n peg$SyntaxError.prototype.format = function(sources) {\n var str = \"Error: \" + this.message;\n if (this.location) {\n var src = null;\n var k;\n for (k = 0; k < sources.length; k++) {\n if (sources[k].source === this.location.source) {\n src = sources[k].text.split(/\\r\\n|\\n|\\r/g);\n break;\n }\n }\n var s = this.location.start;\n var loc = this.location.source + \":\" + s.line + \":\" + s.column;\n if (src) {\n var e = this.location.end;\n var filler = peg$padEnd(\"\", s.line.toString().length, \" \");\n var line = src[s.line - 1];\n var last = s.line === e.line ? e.column : line.length + 1;\n var hatLen = last - s.column || 1;\n str += \"\\n --> \" + loc + \"\\n\" + filler + \" |\\n\" + s.line + \" | \" + line + \"\\n\" + filler + \" | \" + peg$padEnd(\"\", s.column - 1, \" \") + peg$padEnd(\"\", hatLen, \"^\");\n } else {\n str += \"\\n at \" + loc;\n }\n }\n return str;\n };\n peg$SyntaxError.buildMessage = function(expected, found) {\n var DESCRIBE_EXPECTATION_FNS = {\n literal: function(expectation) {\n return '\"' + literalEscape(expectation.text) + '\"';\n },\n class: function(expectation) {\n var escapedParts = expectation.parts.map(function(part) {\n return Array.isArray(part) ? classEscape(part[0]) + \"-\" + classEscape(part[1]) : classEscape(part);\n });\n return \"[\" + (expectation.inverted ? \"^\" : \"\") + escapedParts.join(\"\") + \"]\";\n },\n any: function() {\n return \"any character\";\n },\n end: function() {\n return \"end of input\";\n },\n other: function(expectation) {\n return expectation.description;\n }\n };\n function hex(ch) {\n return ch.charCodeAt(0).toString(16).toUpperCase();\n }\n function literalEscape(s) {\n return s.replace(/\\\\/g, \"\\\\\\\\\").replace(/\"/g, '\\\\\"').replace(/\\0/g, \"\\\\0\").replace(/\\t/g, \"\\\\t\").replace(/\\n/g, \"\\\\n\").replace(/\\r/g, \"\\\\r\").replace(/[\\x00-\\x0F]/g, function(ch) {\n return \"\\\\x0\" + hex(ch);\n }).replace(/[\\x10-\\x1F\\x7F-\\x9F]/g, function(ch) {\n return \"\\\\x\" + hex(ch);\n });\n }\n function classEscape(s) {\n return s.replace(/\\\\/g, \"\\\\\\\\\").replace(/\\]/g, \"\\\\]\").replace(/\\^/g, \"\\\\^\").replace(/-/g, \"\\\\-\").replace(/\\0/g, \"\\\\0\").replace(/\\t/g, \"\\\\t\").replace(/\\n/g, \"\\\\n\").replace(/\\r/g, \"\\\\r\").replace(/[\\x00-\\x0F]/g, function(ch) {\n return \"\\\\x0\" + hex(ch);\n }).replace(/[\\x10-\\x1F\\x7F-\\x9F]/g, function(ch) {\n return \"\\\\x\" + hex(ch);\n });\n }\n function describeExpectation(expectation) {\n return DESCRIBE_EXPECTATION_FNS[expectation.type](expectation);\n }\n function describeExpected(expected2) {\n var descriptions = expected2.map(describeExpectation);\n var i, j;\n descriptions.sort();\n if (descriptions.length > 0) {\n for (i = 1, j = 1; i < descriptions.length; i++) {\n if (descriptions[i - 1] !== descriptions[i]) {\n descriptions[j] = descriptions[i];\n j++;\n }\n }\n descriptions.length = j;\n }\n switch (descriptions.length) {\n case 1:\n return descriptions[0];\n case 2:\n return descriptions[0] + \" or \" + descriptions[1];\n default:\n return descriptions.slice(0, -1).join(\", \") + \", or \" + descriptions[descriptions.length - 1];\n }\n }\n function describeFound(found2) {\n return found2 ? '\"' + literalEscape(found2) + '\"' : \"end of input\";\n }\n return \"Expected \" + describeExpected(expected) + \" but \" + describeFound(found) + \" found.\";\n };\n function peg$parse(input, options) {\n options = options !== void 0 ? options : {};\n var peg$FAILED = {};\n var peg$source = options.grammarSource;\n var peg$startRuleFunctions = { document: peg$parsedocument, math: peg$parsemath };\n var peg$startRuleFunction = peg$parsedocument;\n var peg$c0 = \"%\";\n var peg$c1 = \".\";\n var peg$c2 = \"verb*\";\n var peg$c3 = \"verb\";\n var peg$c4 = \"[\";\n var peg$c5 = \"]\";\n var peg$c6 = \"lstinline\";\n var peg$c7 = \"mintinline\";\n var peg$c8 = \"mint\";\n var peg$c9 = \"minted\";\n var peg$c10 = \"verbatim*\";\n var peg$c11 = \"verbatim\";\n var peg$c12 = \"filecontents*\";\n var peg$c13 = \"filecontents\";\n var peg$c14 = \"comment\";\n var peg$c15 = \"lstlisting\";\n var peg$c16 = \"(\";\n var peg$c17 = \")\";\n var peg$c18 = \"begin\";\n var peg$c19 = \"end\";\n var peg$c20 = \"equation*\";\n var peg$c21 = \"equation\";\n var peg$c22 = \"align*\";\n var peg$c23 = \"align\";\n var peg$c24 = \"alignat*\";\n var peg$c25 = \"alignat\";\n var peg$c26 = \"gather*\";\n var peg$c27 = \"gather\";\n var peg$c28 = \"multline*\";\n var peg$c29 = \"multline\";\n var peg$c30 = \"flalign*\";\n var peg$c31 = \"flalign\";\n var peg$c32 = \"split\";\n var peg$c33 = \"math\";\n var peg$c34 = \"displaymath\";\n var peg$c35 = \"\\\\\";\n var peg$c36 = \"{\";\n var peg$c37 = \"}\";\n var peg$c38 = \"$\";\n var peg$c39 = \"&\";\n var peg$c40 = \"\\r\";\n var peg$c41 = \"\\n\";\n var peg$c42 = \"\\r\\n\";\n var peg$c43 = \"#\";\n var peg$c44 = \"^\";\n var peg$c45 = \"_\";\n var peg$c46 = \"\\0\";\n var peg$r0 = /^[^ \\t\\n\\r]/;\n var peg$r1 = /^[ \\t]/;\n var peg$r2 = /^[a-zA-Z]/;\n var peg$r3 = /^[0-9]/;\n var peg$r4 = /^[.,;:\\-*\\/()!?=+<>[\\]`'\"~]/;\n var peg$e0 = peg$otherExpectation(\"document\");\n var peg$e1 = peg$otherExpectation(\"math\");\n var peg$e2 = peg$otherExpectation(\"token\");\n var peg$e3 = peg$anyExpectation();\n var peg$e4 = peg$otherExpectation(\"parbreak\");\n var peg$e5 = peg$otherExpectation(\"math token\");\n var peg$e6 = peg$otherExpectation(\"nonchar token\");\n var peg$e7 = peg$literalExpectation(\"%\", false);\n var peg$e8 = peg$otherExpectation(\"whitespace\");\n var peg$e9 = peg$otherExpectation(\"number\");\n var peg$e10 = peg$literalExpectation(\".\", false);\n var peg$e11 = peg$otherExpectation(\"special macro\");\n var peg$e12 = peg$literalExpectation(\"verb*\", false);\n var peg$e13 = peg$literalExpectation(\"verb\", false);\n var peg$e14 = peg$literalExpectation(\"[\", false);\n var peg$e15 = peg$literalExpectation(\"]\", false);\n var peg$e16 = peg$classExpectation([\" \", \"\t\", \"\\n\", \"\\r\"], true, false);\n var peg$e17 = peg$otherExpectation(\"verbatim listings\");\n var peg$e18 = peg$literalExpectation(\"lstinline\", false);\n var peg$e19 = peg$otherExpectation(\"verbatim minted\");\n var peg$e20 = peg$literalExpectation(\"mintinline\", false);\n var peg$e21 = peg$literalExpectation(\"mint\", false);\n var peg$e22 = peg$otherExpectation(\"verbatim minted environment\");\n var peg$e23 = peg$literalExpectation(\"minted\", false);\n var peg$e24 = peg$otherExpectation(\"verbatim environment\");\n var peg$e25 = peg$literalExpectation(\"verbatim*\", false);\n var peg$e26 = peg$literalExpectation(\"verbatim\", false);\n var peg$e27 = peg$literalExpectation(\"filecontents*\", false);\n var peg$e28 = peg$literalExpectation(\"filecontents\", false);\n var peg$e29 = peg$literalExpectation(\"comment\", false);\n var peg$e30 = peg$literalExpectation(\"lstlisting\", false);\n var peg$e31 = peg$otherExpectation(\"macro\");\n var peg$e32 = peg$otherExpectation(\"group\");\n var peg$e33 = peg$otherExpectation(\"environment\");\n var peg$e34 = peg$otherExpectation(\"math environment\");\n var peg$e35 = peg$otherExpectation(\"math group\");\n var peg$e36 = peg$literalExpectation(\"(\", false);\n var peg$e37 = peg$literalExpectation(\")\", false);\n var peg$e38 = peg$literalExpectation(\"begin\", false);\n var peg$e39 = peg$literalExpectation(\"end\", false);\n var peg$e40 = peg$literalExpectation(\"equation*\", false);\n var peg$e41 = peg$literalExpectation(\"equation\", false);\n var peg$e42 = peg$literalExpectation(\"align*\", false);\n var peg$e43 = peg$literalExpectation(\"align\", false);\n var peg$e44 = peg$literalExpectation(\"alignat*\", false);\n var peg$e45 = peg$literalExpectation(\"alignat\", false);\n var peg$e46 = peg$literalExpectation(\"gather*\", false);\n var peg$e47 = peg$literalExpectation(\"gather\", false);\n var peg$e48 = peg$literalExpectation(\"multline*\", false);\n var peg$e49 = peg$literalExpectation(\"multline\", false);\n var peg$e50 = peg$literalExpectation(\"flalign*\", false);\n var peg$e51 = peg$literalExpectation(\"flalign\", false);\n var peg$e52 = peg$literalExpectation(\"split\", false);\n var peg$e53 = peg$literalExpectation(\"math\", false);\n var peg$e54 = peg$literalExpectation(\"displaymath\", false);\n var peg$e55 = peg$otherExpectation(\"escape\");\n var peg$e56 = peg$literalExpectation(\"\\\\\", false);\n var peg$e57 = peg$literalExpectation(\"{\", false);\n var peg$e58 = peg$literalExpectation(\"}\", false);\n var peg$e59 = peg$literalExpectation(\"$\", false);\n var peg$e60 = peg$literalExpectation(\"&\", false);\n var peg$e61 = peg$otherExpectation(\"newline\");\n var peg$e62 = peg$literalExpectation(\"\\r\", false);\n var peg$e63 = peg$literalExpectation(\"\\n\", false);\n var peg$e64 = peg$literalExpectation(\"\\r\\n\", false);\n var peg$e65 = peg$literalExpectation(\"#\", false);\n var peg$e66 = peg$literalExpectation(\"^\", false);\n var peg$e67 = peg$literalExpectation(\"_\", false);\n var peg$e68 = peg$literalExpectation(\"\\0\", false);\n var peg$e69 = peg$classExpectation([\" \", \"\t\"], false, false);\n var peg$e70 = peg$otherExpectation(\"letter\");\n var peg$e71 = peg$classExpectation([[\"a\", \"z\"], [\"A\", \"Z\"]], false, false);\n var peg$e72 = peg$otherExpectation(\"digit\");\n var peg$e73 = peg$classExpectation([[\"0\", \"9\"]], false, false);\n var peg$e74 = peg$otherExpectation(\"punctuation\");\n var peg$e75 = peg$classExpectation([\".\", \",\", \";\", \":\", \"-\", \"*\", \"/\", \"(\", \")\", \"!\", \"?\", \"=\", \"+\", \"<\", \">\", \"[\", \"]\", \"`\", \"'\", '\"', \"~\"], false, false);\n var peg$e76 = peg$otherExpectation(\"full comment\");\n var peg$e77 = peg$otherExpectation(\"comment\");\n var peg$f0 = function(content) {\n return createNode(\"root\", { content: content.flatMap((x) => x) });\n };\n var peg$f1 = function(t) {\n return t;\n };\n var peg$f2 = function(eq) {\n return createNode(\"inlinemath\", { content: eq.flatMap((x) => x) });\n };\n var peg$f3 = function(s) {\n return createNode(\"string\", { content: s });\n };\n var peg$f4 = function(s) {\n return createNode(\"string\", { content: s });\n };\n var peg$f5 = function() {\n return createNode(\"parbreak\");\n };\n var peg$f6 = function(x) {\n return x;\n };\n var peg$f7 = function(x) {\n return x;\n };\n var peg$f8 = function() {\n return createNode(\"macro\", { content: \"^\", escapeToken: \"\" });\n };\n var peg$f9 = function() {\n return createNode(\"macro\", { content: \"_\", escapeToken: \"\" });\n };\n var peg$f10 = function(s) {\n return createNode(\"string\", { content: s });\n };\n var peg$f11 = function() {\n return createNode(\"whitespace\");\n };\n var peg$f12 = function(a, b) {\n return a.join(\"\") + \".\" + b.join(\"\");\n };\n var peg$f13 = function(b) {\n return \".\" + b.join(\"\");\n };\n var peg$f14 = function(a) {\n return a.join(\"\") + \".\";\n };\n var peg$f15 = function(s) {\n return createNode(\"string\", { content: s });\n };\n var peg$f16 = function(env, e, end) {\n return end == e;\n };\n var peg$f17 = function(env, e, x) {\n return x;\n };\n var peg$f18 = function(env, e, x, end) {\n return end == e;\n };\n var peg$f19 = function(env, e, x) {\n return createNode(\"verb\", {\n env,\n escape: e,\n content: x.join(\"\")\n });\n };\n var peg$f20 = function(x) {\n return x;\n };\n var peg$f21 = function(x) {\n return createNode(\"displaymath\", { content: x.flatMap((x2) => x2) });\n };\n var peg$f22 = function(x) {\n return x;\n };\n var peg$f23 = function(x) {\n return createNode(\"inlinemath\", { content: x.flatMap((x2) => x2) });\n };\n var peg$f24 = function(x) {\n return x;\n };\n var peg$f25 = function(x) {\n return createNode(\"displaymath\", { content: x.flatMap((x2) => x2) });\n };\n var peg$f26 = function(end) {\n return end.type === \"string\" && end.content === \"]\";\n };\n var peg$f27 = function(x) {\n return x;\n };\n var peg$f28 = function(o) {\n return [\n createNode(\"string\", { content: \"[\" }),\n ...o,\n createNode(\"string\", { content: \"]\" })\n ];\n };\n var peg$f29 = function(x) {\n return x;\n };\n var peg$f30 = function(v) {\n return createNode(\"group\", {\n content: createNode(\"string\", { content: v.join(\"\") })\n });\n };\n var peg$f31 = function(d, end) {\n return end == d;\n };\n var peg$f32 = function(d, x) {\n return x;\n };\n var peg$f33 = function(d, v, end) {\n return end == d;\n };\n var peg$f34 = function(d, v) {\n return [\n createNode(\"string\", { content: d }),\n createNode(\"string\", { content: v.join(\"\") }),\n createNode(\"string\", { content: d })\n ];\n };\n var peg$f35 = function(macro, option, verbatim) {\n return [\n createNode(\"macro\", { content: macro }),\n ...option || [],\n ...[].concat(verbatim)\n ];\n };\n var peg$f36 = function(macro, option, language, verbatim) {\n return [\n createNode(\"macro\", { content: macro }),\n ...option || [],\n language,\n ...[].concat(verbatim)\n ];\n };\n var peg$f37 = function(env, lang, end_env) {\n return compare_env({ content: [env] }, end_env);\n };\n var peg$f38 = function(env, lang, x) {\n return x;\n };\n var peg$f39 = function(env, lang, body) {\n return createNode(\"verbatim\", {\n env: `${env}{${lang.content.content}}`,\n content: body.join(\"\")\n });\n };\n var peg$f40 = function(env, end_env) {\n return compare_env({ content: [env] }, end_env);\n };\n var peg$f41 = function(env, x) {\n return x;\n };\n var peg$f42 = function(env, body) {\n return createNode(\"verbatim\", {\n env,\n content: body.join(\"\")\n });\n };\n var peg$f43 = function(n) {\n return n.join(\"\");\n };\n var peg$f44 = function(n) {\n return n;\n };\n var peg$f45 = function(m) {\n return createNode(\"macro\", { content: m });\n };\n var peg$f46 = function(c) {\n return c;\n };\n var peg$f47 = function(x) {\n return createNode(\"group\", { content: x.flatMap((x2) => x2) });\n };\n var peg$f48 = function(g) {\n return text().slice(1, -1);\n };\n var peg$f49 = function(env, env_comment, end_env) {\n return compare_env(env, end_env);\n };\n var peg$f50 = function(env, env_comment, x) {\n return x;\n };\n var peg$f51 = function(env, env_comment, body) {\n body = body.flatMap((x) => x);\n return createNode(\"environment\", {\n env,\n content: env_comment ? [env_comment, ...body] : body\n });\n };\n var peg$f52 = function(env, env_comment, end_env) {\n return compare_env({ content: [env] }, end_env);\n };\n var peg$f53 = function(env, env_comment, x) {\n return x;\n };\n var peg$f54 = function(env, env_comment, body) {\n body = body.flatMap((x) => x);\n return createNode(\"mathenv\", {\n env,\n content: env_comment ? [env_comment, ...body] : body\n });\n };\n var peg$f55 = function(c) {\n return c;\n };\n var peg$f56 = function(x) {\n return createNode(\"group\", { content: x.flatMap((x2) => x2) });\n };\n var peg$f57 = function(e) {\n return createNode(\"string\", { content: e });\n };\n var peg$f58 = function() {\n return createNode(\"string\", { content: \"\\\\\" });\n };\n var peg$f59 = function(s) {\n return createNode(\"string\", { content: s });\n };\n var peg$f60 = function(s) {\n return createNode(\"string\", { content: s });\n };\n var peg$f61 = function(s) {\n return createNode(\"string\", { content: s });\n };\n var peg$f62 = function(s) {\n return createNode(\"string\", { content: s });\n };\n var peg$f63 = function(s) {\n return createNode(\"string\", { content: s });\n };\n var peg$f64 = function(s) {\n return createNode(\"string\", { content: s });\n };\n var peg$f65 = function(s) {\n return createNode(\"string\", { content: s });\n };\n var peg$f66 = function() {\n return \" \";\n };\n var peg$f67 = function(p) {\n return createNode(\"string\", { content: p });\n };\n var peg$f68 = function(leading_sp, comment) {\n return createNode(\"comment\", {\n ...comment,\n sameline: false,\n leadingWhitespace: leading_sp.length > 0\n });\n };\n var peg$f69 = function(spaces, x) {\n return createNode(\"comment\", {\n ...x,\n sameline: true,\n leadingWhitespace: spaces.length > 0\n });\n };\n var peg$f70 = function(c) {\n return c;\n };\n var peg$f71 = function(c) {\n return { content: c.join(\"\"), suffixParbreak: true };\n };\n var peg$f72 = function(c) {\n return c;\n };\n var peg$f73 = function(c) {\n return { content: c.join(\"\") };\n };\n var peg$f74 = function() {\n var loc = location();\n return loc.start.column === 1;\n };\n var peg$currPos = 0;\n var peg$savedPos = 0;\n var peg$posDetailsCache = [{ line: 1, column: 1 }];\n var peg$maxFailPos = 0;\n var peg$maxFailExpected = [];\n var peg$silentFails = 0;\n var peg$result;\n if (\"startRule\" in options) {\n if (!(options.startRule in peg$startRuleFunctions)) {\n throw new Error(`Can't start parsing from rule \"` + options.startRule + '\".');\n }\n peg$startRuleFunction = peg$startRuleFunctions[options.startRule];\n }\n function text() {\n return input.substring(peg$savedPos, peg$currPos);\n }\n function offset() {\n return peg$savedPos;\n }\n function range() {\n return {\n source: peg$source,\n start: peg$savedPos,\n end: peg$currPos\n };\n }\n function location() {\n return peg$computeLocation(peg$savedPos, peg$currPos);\n }\n function expected(description, location2) {\n location2 = location2 !== void 0 ? location2 : peg$computeLocation(peg$savedPos, peg$currPos);\n throw peg$buildStructuredError(\n [peg$otherExpectation(description)],\n input.substring(peg$savedPos, peg$currPos),\n location2\n );\n }\n function error(message, location2) {\n location2 = location2 !== void 0 ? location2 : peg$computeLocation(peg$savedPos, peg$currPos);\n throw peg$buildSimpleError(message, location2);\n }\n function peg$literalExpectation(text2, ignoreCase) {\n return { type: \"literal\", text: text2, ignoreCase };\n }\n function peg$classExpectation(parts, inverted, ignoreCase) {\n return { type: \"class\", parts, inverted, ignoreCase };\n }\n function peg$anyExpectation() {\n return { type: \"any\" };\n }\n function peg$endExpectation() {\n return { type: \"end\" };\n }\n function peg$otherExpectation(description) {\n return { type: \"other\", description };\n }\n function peg$computePosDetails(pos) {\n var details = peg$posDetailsCache[pos];\n var p;\n if (details) {\n return details;\n } else {\n p = pos - 1;\n while (!peg$posDetailsCache[p]) {\n p--;\n }\n details = peg$posDetailsCache[p];\n details = {\n line: details.line,\n column: details.column\n };\n while (p < pos) {\n if (input.charCodeAt(p) === 10) {\n details.line++;\n details.column = 1;\n } else {\n details.column++;\n }\n p++;\n }\n peg$posDetailsCache[pos] = details;\n return details;\n }\n }\n function peg$computeLocation(startPos, endPos) {\n var startPosDetails = peg$computePosDetails(startPos);\n var endPosDetails = peg$computePosDetails(endPos);\n return {\n source: peg$source,\n start: {\n offset: startPos,\n line: startPosDetails.line,\n column: startPosDetails.column\n },\n end: {\n offset: endPos,\n line: endPosDetails.line,\n column: endPosDetails.column\n }\n };\n }\n function peg$fail(expected2) {\n if (peg$currPos < peg$maxFailPos) {\n return;\n }\n if (peg$currPos > peg$maxFailPos) {\n peg$maxFailPos = peg$currPos;\n peg$maxFailExpected = [];\n }\n peg$maxFailExpected.push(expected2);\n }\n function peg$buildSimpleError(message, location2) {\n return new peg$SyntaxError(message, null, null, location2);\n }\n function peg$buildStructuredError(expected2, found, location2) {\n return new peg$SyntaxError(\n peg$SyntaxError.buildMessage(expected2, found),\n expected2,\n found,\n location2\n );\n }\n function peg$parsedocument() {\n var s0, s1, s2;\n peg$silentFails++;\n s0 = peg$currPos;\n s1 = [];\n s2 = peg$parsetoken();\n while (s2 !== peg$FAILED) {\n s1.push(s2);\n s2 = peg$parsetoken();\n }\n peg$savedPos = s0;\n s1 = peg$f0(s1);\n s0 = s1;\n peg$silentFails--;\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n return s0;\n }\n function peg$parsemath() {\n var s0, s1;\n peg$silentFails++;\n s0 = [];\n s1 = peg$parsemath_token();\n while (s1 !== peg$FAILED) {\n s0.push(s1);\n s1 = peg$parsemath_token();\n }\n peg$silentFails--;\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e1);\n }\n return s0;\n }\n function peg$parsetoken() {\n var s0, s1, s2, s3, s4, s5;\n peg$silentFails++;\n s0 = peg$parsespecial_macro();\n if (s0 === peg$FAILED) {\n s0 = peg$parsemacro();\n if (s0 === peg$FAILED) {\n s0 = peg$parsefull_comment();\n if (s0 === peg$FAILED) {\n s0 = peg$parsegroup();\n if (s0 === peg$FAILED) {\n s0 = peg$currPos;\n s1 = peg$parsemath_shift();\n if (s1 !== peg$FAILED) {\n s2 = [];\n s3 = peg$currPos;\n s4 = peg$currPos;\n peg$silentFails++;\n s5 = peg$parsemath_shift();\n peg$silentFails--;\n if (s5 === peg$FAILED) {\n s4 = void 0;\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n if (s4 !== peg$FAILED) {\n s5 = peg$parsemath_token();\n if (s5 !== peg$FAILED) {\n peg$savedPos = s3;\n s3 = peg$f1(s5);\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n if (s3 !== peg$FAILED) {\n while (s3 !== peg$FAILED) {\n s2.push(s3);\n s3 = peg$currPos;\n s4 = peg$currPos;\n peg$silentFails++;\n s5 = peg$parsemath_shift();\n peg$silentFails--;\n if (s5 === peg$FAILED) {\n s4 = void 0;\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n if (s4 !== peg$FAILED) {\n s5 = peg$parsemath_token();\n if (s5 !== peg$FAILED) {\n peg$savedPos = s3;\n s3 = peg$f1(s5);\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n }\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n s3 = peg$parsemath_shift();\n if (s3 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f2(s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n if (s0 === peg$FAILED) {\n s0 = peg$parsealignment_tab();\n if (s0 === peg$FAILED) {\n s0 = peg$parseparbreak();\n if (s0 === peg$FAILED) {\n s0 = peg$parsemacro_parameter();\n if (s0 === peg$FAILED) {\n s0 = peg$parseignore();\n if (s0 === peg$FAILED) {\n s0 = peg$parsenumber();\n if (s0 === peg$FAILED) {\n s0 = peg$parsewhitespace();\n if (s0 === peg$FAILED) {\n s0 = peg$parsepunctuation();\n if (s0 === peg$FAILED) {\n s0 = peg$currPos;\n s1 = peg$currPos;\n s2 = [];\n s3 = peg$currPos;\n s4 = peg$currPos;\n peg$silentFails++;\n s5 = peg$parsenonchar_token();\n peg$silentFails--;\n if (s5 === peg$FAILED) {\n s4 = void 0;\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n if (s4 !== peg$FAILED) {\n if (input.length > peg$currPos) {\n s5 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s5 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e3);\n }\n }\n if (s5 !== peg$FAILED) {\n s4 = [s4, s5];\n s3 = s4;\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n if (s3 !== peg$FAILED) {\n while (s3 !== peg$FAILED) {\n s2.push(s3);\n s3 = peg$currPos;\n s4 = peg$currPos;\n peg$silentFails++;\n s5 = peg$parsenonchar_token();\n peg$silentFails--;\n if (s5 === peg$FAILED) {\n s4 = void 0;\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n if (s4 !== peg$FAILED) {\n if (input.length > peg$currPos) {\n s5 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s5 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e3);\n }\n }\n if (s5 !== peg$FAILED) {\n s4 = [s4, s5];\n s3 = s4;\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n }\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n s1 = input.substring(s1, peg$currPos);\n } else {\n s1 = s2;\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = s0;\n s1 = peg$f3(s1);\n }\n s0 = s1;\n if (s0 === peg$FAILED) {\n s0 = peg$parsebegin_group();\n if (s0 === peg$FAILED) {\n s0 = peg$parseend_group();\n if (s0 === peg$FAILED) {\n s0 = peg$parsemath_shift();\n if (s0 === peg$FAILED) {\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e3);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = s0;\n s1 = peg$f4(s1);\n }\n s0 = s1;\n }\n }\n }\n }\n }\n }\n }\n }\n }\n }\n }\n }\n }\n }\n }\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e2);\n }\n }\n return s0;\n }\n function peg$parseparbreak() {\n var s0, s1, s2, s3, s4, s5, s6, s7;\n peg$silentFails++;\n s0 = peg$currPos;\n s1 = peg$currPos;\n s2 = [];\n s3 = peg$parsesp();\n while (s3 !== peg$FAILED) {\n s2.push(s3);\n s3 = peg$parsesp();\n }\n s3 = peg$parsenl();\n if (s3 !== peg$FAILED) {\n s4 = [];\n s5 = peg$currPos;\n s6 = [];\n s7 = peg$parsesp();\n while (s7 !== peg$FAILED) {\n s6.push(s7);\n s7 = peg$parsesp();\n }\n s7 = peg$parsenl();\n if (s7 !== peg$FAILED) {\n s6 = [s6, s7];\n s5 = s6;\n } else {\n peg$currPos = s5;\n s5 = peg$FAILED;\n }\n if (s5 !== peg$FAILED) {\n while (s5 !== peg$FAILED) {\n s4.push(s5);\n s5 = peg$currPos;\n s6 = [];\n s7 = peg$parsesp();\n while (s7 !== peg$FAILED) {\n s6.push(s7);\n s7 = peg$parsesp();\n }\n s7 = peg$parsenl();\n if (s7 !== peg$FAILED) {\n s6 = [s6, s7];\n s5 = s6;\n } else {\n peg$currPos = s5;\n s5 = peg$FAILED;\n }\n }\n } else {\n s4 = peg$FAILED;\n }\n if (s4 !== peg$FAILED) {\n s5 = [];\n s6 = peg$parsesp();\n while (s6 !== peg$FAILED) {\n s5.push(s6);\n s6 = peg$parsesp();\n }\n s6 = peg$currPos;\n peg$silentFails++;\n s7 = peg$parsecomment_start();\n peg$silentFails--;\n if (s7 === peg$FAILED) {\n s6 = void 0;\n } else {\n peg$currPos = s6;\n s6 = peg$FAILED;\n }\n if (s6 !== peg$FAILED) {\n s2 = [s2, s3, s4, s5, s6];\n s1 = s2;\n } else {\n peg$currPos = s1;\n s1 = peg$FAILED;\n }\n } else {\n peg$currPos = s1;\n s1 = peg$FAILED;\n }\n } else {\n peg$currPos = s1;\n s1 = peg$FAILED;\n }\n if (s1 === peg$FAILED) {\n s1 = peg$currPos;\n s2 = [];\n s3 = peg$parsesp();\n while (s3 !== peg$FAILED) {\n s2.push(s3);\n s3 = peg$parsesp();\n }\n s3 = peg$parsenl();\n if (s3 !== peg$FAILED) {\n s4 = [];\n s5 = peg$currPos;\n s6 = [];\n s7 = peg$parsesp();\n while (s7 !== peg$FAILED) {\n s6.push(s7);\n s7 = peg$parsesp();\n }\n s7 = peg$parsenl();\n if (s7 !== peg$FAILED) {\n s6 = [s6, s7];\n s5 = s6;\n } else {\n peg$currPos = s5;\n s5 = peg$FAILED;\n }\n if (s5 !== peg$FAILED) {\n while (s5 !== peg$FAILED) {\n s4.push(s5);\n s5 = peg$currPos;\n s6 = [];\n s7 = peg$parsesp();\n while (s7 !== peg$FAILED) {\n s6.push(s7);\n s7 = peg$parsesp();\n }\n s7 = peg$parsenl();\n if (s7 !== peg$FAILED) {\n s6 = [s6, s7];\n s5 = s6;\n } else {\n peg$currPos = s5;\n s5 = peg$FAILED;\n }\n }\n } else {\n s4 = peg$FAILED;\n }\n if (s4 !== peg$FAILED) {\n s2 = [s2, s3, s4];\n s1 = s2;\n } else {\n peg$currPos = s1;\n s1 = peg$FAILED;\n }\n } else {\n peg$currPos = s1;\n s1 = peg$FAILED;\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = s0;\n s1 = peg$f5();\n }\n s0 = s1;\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e4);\n }\n }\n return s0;\n }\n function peg$parsemath_token() {\n var s0, s1, s2, s3, s4;\n peg$silentFails++;\n s0 = peg$parsespecial_macro();\n if (s0 === peg$FAILED) {\n s0 = peg$parsemacro();\n if (s0 === peg$FAILED) {\n s0 = peg$parsefull_comment();\n if (s0 === peg$FAILED) {\n s0 = peg$currPos;\n s1 = [];\n s2 = peg$parsewhitespace();\n while (s2 !== peg$FAILED) {\n s1.push(s2);\n s2 = peg$parsewhitespace();\n }\n s2 = peg$parsegroup();\n if (s2 !== peg$FAILED) {\n s3 = [];\n s4 = peg$parsewhitespace();\n while (s4 !== peg$FAILED) {\n s3.push(s4);\n s4 = peg$parsewhitespace();\n }\n peg$savedPos = s0;\n s0 = peg$f6(s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n if (s0 === peg$FAILED) {\n s0 = peg$currPos;\n s1 = [];\n s2 = peg$parsewhitespace();\n while (s2 !== peg$FAILED) {\n s1.push(s2);\n s2 = peg$parsewhitespace();\n }\n s2 = peg$parsealignment_tab();\n if (s2 !== peg$FAILED) {\n s3 = [];\n s4 = peg$parsewhitespace();\n while (s4 !== peg$FAILED) {\n s3.push(s4);\n s4 = peg$parsewhitespace();\n }\n peg$savedPos = s0;\n s0 = peg$f7(s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n if (s0 === peg$FAILED) {\n s0 = peg$parsemacro_parameter();\n if (s0 === peg$FAILED) {\n s0 = peg$currPos;\n s1 = [];\n s2 = peg$parsewhitespace();\n while (s2 !== peg$FAILED) {\n s1.push(s2);\n s2 = peg$parsewhitespace();\n }\n s2 = peg$parsesuperscript();\n if (s2 !== peg$FAILED) {\n s3 = [];\n s4 = peg$parsewhitespace();\n while (s4 !== peg$FAILED) {\n s3.push(s4);\n s4 = peg$parsewhitespace();\n }\n peg$savedPos = s0;\n s0 = peg$f8();\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n if (s0 === peg$FAILED) {\n s0 = peg$currPos;\n s1 = [];\n s2 = peg$parsewhitespace();\n while (s2 !== peg$FAILED) {\n s1.push(s2);\n s2 = peg$parsewhitespace();\n }\n s2 = peg$parsesubscript();\n if (s2 !== peg$FAILED) {\n s3 = [];\n s4 = peg$parsewhitespace();\n while (s4 !== peg$FAILED) {\n s3.push(s4);\n s4 = peg$parsewhitespace();\n }\n peg$savedPos = s0;\n s0 = peg$f9();\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n if (s0 === peg$FAILED) {\n s0 = peg$parseignore();\n if (s0 === peg$FAILED) {\n s0 = peg$parsewhitespace();\n if (s0 === peg$FAILED) {\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e3);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = s0;\n s1 = peg$f10(s1);\n }\n s0 = s1;\n }\n }\n }\n }\n }\n }\n }\n }\n }\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e5);\n }\n }\n return s0;\n }\n function peg$parsenonchar_token() {\n var s0, s1;\n peg$silentFails++;\n s0 = peg$parseescape();\n if (s0 === peg$FAILED) {\n if (input.charCodeAt(peg$currPos) === 37) {\n s0 = peg$c0;\n peg$currPos++;\n } else {\n s0 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e7);\n }\n }\n if (s0 === peg$FAILED) {\n s0 = peg$parsebegin_group();\n if (s0 === peg$FAILED) {\n s0 = peg$parseend_group();\n if (s0 === peg$FAILED) {\n s0 = peg$parsemath_shift();\n if (s0 === peg$FAILED) {\n s0 = peg$parsealignment_tab();\n if (s0 === peg$FAILED) {\n s0 = peg$parsenl();\n if (s0 === peg$FAILED) {\n s0 = peg$parsemacro_parameter();\n if (s0 === peg$FAILED) {\n s0 = peg$parseignore();\n if (s0 === peg$FAILED) {\n s0 = peg$parsesp();\n if (s0 === peg$FAILED) {\n s0 = peg$parsepunctuation();\n if (s0 === peg$FAILED) {\n s0 = peg$parseEOF();\n }\n }\n }\n }\n }\n }\n }\n }\n }\n }\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e6);\n }\n }\n return s0;\n }\n function peg$parsewhitespace() {\n var s0, s1, s2, s3, s4, s5, s6, s7;\n peg$silentFails++;\n s0 = peg$currPos;\n s1 = peg$currPos;\n s2 = peg$parsenl();\n if (s2 !== peg$FAILED) {\n s3 = [];\n s4 = peg$parsesp();\n while (s4 !== peg$FAILED) {\n s3.push(s4);\n s4 = peg$parsesp();\n }\n s2 = [s2, s3];\n s1 = s2;\n } else {\n peg$currPos = s1;\n s1 = peg$FAILED;\n }\n if (s1 === peg$FAILED) {\n s1 = peg$currPos;\n s2 = [];\n s3 = peg$parsesp();\n if (s3 !== peg$FAILED) {\n while (s3 !== peg$FAILED) {\n s2.push(s3);\n s3 = peg$parsesp();\n }\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n s3 = peg$parsenl();\n if (s3 !== peg$FAILED) {\n s4 = peg$currPos;\n peg$silentFails++;\n s5 = peg$parsecomment_start();\n peg$silentFails--;\n if (s5 === peg$FAILED) {\n s4 = void 0;\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n if (s4 !== peg$FAILED) {\n s5 = [];\n s6 = peg$parsesp();\n while (s6 !== peg$FAILED) {\n s5.push(s6);\n s6 = peg$parsesp();\n }\n s6 = peg$currPos;\n peg$silentFails++;\n s7 = peg$parsenl();\n peg$silentFails--;\n if (s7 === peg$FAILED) {\n s6 = void 0;\n } else {\n peg$currPos = s6;\n s6 = peg$FAILED;\n }\n if (s6 !== peg$FAILED) {\n s2 = [s2, s3, s4, s5, s6];\n s1 = s2;\n } else {\n peg$currPos = s1;\n s1 = peg$FAILED;\n }\n } else {\n peg$currPos = s1;\n s1 = peg$FAILED;\n }\n } else {\n peg$currPos = s1;\n s1 = peg$FAILED;\n }\n } else {\n peg$currPos = s1;\n s1 = peg$FAILED;\n }\n if (s1 === peg$FAILED) {\n s1 = [];\n s2 = peg$parsesp();\n if (s2 !== peg$FAILED) {\n while (s2 !== peg$FAILED) {\n s1.push(s2);\n s2 = peg$parsesp();\n }\n } else {\n s1 = peg$FAILED;\n }\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = s0;\n s1 = peg$f11();\n }\n s0 = s1;\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e8);\n }\n }\n return s0;\n }\n function peg$parsenumber() {\n var s0, s1, s2, s3, s4, s5;\n peg$silentFails++;\n s0 = peg$currPos;\n s1 = peg$currPos;\n s2 = [];\n s3 = peg$parsenum();\n if (s3 !== peg$FAILED) {\n while (s3 !== peg$FAILED) {\n s2.push(s3);\n s3 = peg$parsenum();\n }\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n if (input.charCodeAt(peg$currPos) === 46) {\n s3 = peg$c1;\n peg$currPos++;\n } else {\n s3 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e10);\n }\n }\n if (s3 !== peg$FAILED) {\n s4 = [];\n s5 = peg$parsenum();\n if (s5 !== peg$FAILED) {\n while (s5 !== peg$FAILED) {\n s4.push(s5);\n s5 = peg$parsenum();\n }\n } else {\n s4 = peg$FAILED;\n }\n if (s4 !== peg$FAILED) {\n peg$savedPos = s1;\n s1 = peg$f12(s2, s4);\n } else {\n peg$currPos = s1;\n s1 = peg$FAILED;\n }\n } else {\n peg$currPos = s1;\n s1 = peg$FAILED;\n }\n } else {\n peg$currPos = s1;\n s1 = peg$FAILED;\n }\n if (s1 === peg$FAILED) {\n s1 = peg$currPos;\n if (input.charCodeAt(peg$currPos) === 46) {\n s2 = peg$c1;\n peg$currPos++;\n } else {\n s2 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e10);\n }\n }\n if (s2 !== peg$FAILED) {\n s3 = [];\n s4 = peg$parsenum();\n if (s4 !== peg$FAILED) {\n while (s4 !== peg$FAILED) {\n s3.push(s4);\n s4 = peg$parsenum();\n }\n } else {\n s3 = peg$FAILED;\n }\n if (s3 !== peg$FAILED) {\n peg$savedPos = s1;\n s1 = peg$f13(s3);\n } else {\n peg$currPos = s1;\n s1 = peg$FAILED;\n }\n } else {\n peg$currPos = s1;\n s1 = peg$FAILED;\n }\n if (s1 === peg$FAILED) {\n s1 = peg$currPos;\n s2 = [];\n s3 = peg$parsenum();\n if (s3 !== peg$FAILED) {\n while (s3 !== peg$FAILED) {\n s2.push(s3);\n s3 = peg$parsenum();\n }\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n if (input.charCodeAt(peg$currPos) === 46) {\n s3 = peg$c1;\n peg$currPos++;\n } else {\n s3 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e10);\n }\n }\n if (s3 !== peg$FAILED) {\n peg$savedPos = s1;\n s1 = peg$f14(s2);\n } else {\n peg$currPos = s1;\n s1 = peg$FAILED;\n }\n } else {\n peg$currPos = s1;\n s1 = peg$FAILED;\n }\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = s0;\n s1 = peg$f15(s1);\n }\n s0 = s1;\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e9);\n }\n }\n return s0;\n }\n function peg$parsespecial_macro() {\n var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;\n peg$silentFails++;\n s0 = peg$currPos;\n s1 = peg$parseescape();\n if (s1 !== peg$FAILED) {\n if (input.substr(peg$currPos, 5) === peg$c2) {\n s2 = peg$c2;\n peg$currPos += 5;\n } else {\n s2 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e12);\n }\n }\n if (s2 === peg$FAILED) {\n if (input.substr(peg$currPos, 4) === peg$c3) {\n s2 = peg$c3;\n peg$currPos += 4;\n } else {\n s2 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e13);\n }\n }\n }\n if (s2 !== peg$FAILED) {\n if (input.length > peg$currPos) {\n s3 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s3 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e3);\n }\n }\n if (s3 !== peg$FAILED) {\n s4 = [];\n s5 = peg$currPos;\n s6 = peg$currPos;\n peg$silentFails++;\n s7 = peg$currPos;\n if (input.length > peg$currPos) {\n s8 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s8 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e3);\n }\n }\n if (s8 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s9 = peg$f16(s2, s3, s8);\n if (s9) {\n s9 = void 0;\n } else {\n s9 = peg$FAILED;\n }\n if (s9 !== peg$FAILED) {\n s8 = [s8, s9];\n s7 = s8;\n } else {\n peg$currPos = s7;\n s7 = peg$FAILED;\n }\n } else {\n peg$currPos = s7;\n s7 = peg$FAILED;\n }\n peg$silentFails--;\n if (s7 === peg$FAILED) {\n s6 = void 0;\n } else {\n peg$currPos = s6;\n s6 = peg$FAILED;\n }\n if (s6 !== peg$FAILED) {\n if (input.length > peg$currPos) {\n s7 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s7 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e3);\n }\n }\n if (s7 !== peg$FAILED) {\n peg$savedPos = s5;\n s5 = peg$f17(s2, s3, s7);\n } else {\n peg$currPos = s5;\n s5 = peg$FAILED;\n }\n } else {\n peg$currPos = s5;\n s5 = peg$FAILED;\n }\n while (s5 !== peg$FAILED) {\n s4.push(s5);\n s5 = peg$currPos;\n s6 = peg$currPos;\n peg$silentFails++;\n s7 = peg$currPos;\n if (input.length > peg$currPos) {\n s8 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s8 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e3);\n }\n }\n if (s8 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s9 = peg$f16(s2, s3, s8);\n if (s9) {\n s9 = void 0;\n } else {\n s9 = peg$FAILED;\n }\n if (s9 !== peg$FAILED) {\n s8 = [s8, s9];\n s7 = s8;\n } else {\n peg$currPos = s7;\n s7 = peg$FAILED;\n }\n } else {\n peg$currPos = s7;\n s7 = peg$FAILED;\n }\n peg$silentFails--;\n if (s7 === peg$FAILED) {\n s6 = void 0;\n } else {\n peg$currPos = s6;\n s6 = peg$FAILED;\n }\n if (s6 !== peg$FAILED) {\n if (input.length > peg$currPos) {\n s7 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s7 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e3);\n }\n }\n if (s7 !== peg$FAILED) {\n peg$savedPos = s5;\n s5 = peg$f17(s2, s3, s7);\n } else {\n peg$currPos = s5;\n s5 = peg$FAILED;\n }\n } else {\n peg$currPos = s5;\n s5 = peg$FAILED;\n }\n }\n s5 = peg$currPos;\n if (input.length > peg$currPos) {\n s6 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s6 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e3);\n }\n }\n if (s6 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s7 = peg$f18(s2, s3, s4, s6);\n if (s7) {\n s7 = void 0;\n } else {\n s7 = peg$FAILED;\n }\n if (s7 !== peg$FAILED) {\n s6 = [s6, s7];\n s5 = s6;\n } else {\n peg$currPos = s5;\n s5 = peg$FAILED;\n }\n } else {\n peg$currPos = s5;\n s5 = peg$FAILED;\n }\n if (s5 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f19(s2, s3, s4);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n if (s0 === peg$FAILED) {\n s0 = peg$parseverbatim_listings();\n if (s0 === peg$FAILED) {\n s0 = peg$parseverbatim_minted();\n if (s0 === peg$FAILED) {\n s0 = peg$parseverbatim_environment();\n if (s0 === peg$FAILED) {\n s0 = peg$currPos;\n s1 = peg$parsebegin_display_math();\n if (s1 !== peg$FAILED) {\n s2 = [];\n s3 = peg$currPos;\n s4 = peg$currPos;\n peg$silentFails++;\n s5 = peg$parseend_display_math();\n peg$silentFails--;\n if (s5 === peg$FAILED) {\n s4 = void 0;\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n if (s4 !== peg$FAILED) {\n s5 = peg$parsemath_token();\n if (s5 !== peg$FAILED) {\n peg$savedPos = s3;\n s3 = peg$f20(s5);\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n while (s3 !== peg$FAILED) {\n s2.push(s3);\n s3 = peg$currPos;\n s4 = peg$currPos;\n peg$silentFails++;\n s5 = peg$parseend_display_math();\n peg$silentFails--;\n if (s5 === peg$FAILED) {\n s4 = void 0;\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n if (s4 !== peg$FAILED) {\n s5 = peg$parsemath_token();\n if (s5 !== peg$FAILED) {\n peg$savedPos = s3;\n s3 = peg$f20(s5);\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n }\n s3 = peg$parseend_display_math();\n if (s3 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f21(s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n if (s0 === peg$FAILED) {\n s0 = peg$currPos;\n s1 = peg$parsebegin_inline_math();\n if (s1 !== peg$FAILED) {\n s2 = [];\n s3 = peg$currPos;\n s4 = peg$currPos;\n peg$silentFails++;\n s5 = peg$parseend_inline_math();\n peg$silentFails--;\n if (s5 === peg$FAILED) {\n s4 = void 0;\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n if (s4 !== peg$FAILED) {\n s5 = peg$parsemath_token();\n if (s5 !== peg$FAILED) {\n peg$savedPos = s3;\n s3 = peg$f22(s5);\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n while (s3 !== peg$FAILED) {\n s2.push(s3);\n s3 = peg$currPos;\n s4 = peg$currPos;\n peg$silentFails++;\n s5 = peg$parseend_inline_math();\n peg$silentFails--;\n if (s5 === peg$FAILED) {\n s4 = void 0;\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n if (s4 !== peg$FAILED) {\n s5 = peg$parsemath_token();\n if (s5 !== peg$FAILED) {\n peg$savedPos = s3;\n s3 = peg$f22(s5);\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n }\n s3 = peg$parseend_inline_math();\n if (s3 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f23(s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n if (s0 === peg$FAILED) {\n s0 = peg$currPos;\n s1 = peg$parsemath_shift();\n if (s1 !== peg$FAILED) {\n s2 = peg$parsemath_shift();\n if (s2 !== peg$FAILED) {\n s3 = [];\n s4 = peg$currPos;\n s5 = peg$currPos;\n peg$silentFails++;\n s6 = peg$currPos;\n s7 = peg$parsemath_shift();\n if (s7 !== peg$FAILED) {\n s8 = peg$parsemath_shift();\n if (s8 !== peg$FAILED) {\n s7 = [s7, s8];\n s6 = s7;\n } else {\n peg$currPos = s6;\n s6 = peg$FAILED;\n }\n } else {\n peg$currPos = s6;\n s6 = peg$FAILED;\n }\n peg$silentFails--;\n if (s6 === peg$FAILED) {\n s5 = void 0;\n } else {\n peg$currPos = s5;\n s5 = peg$FAILED;\n }\n if (s5 !== peg$FAILED) {\n s6 = peg$parsemath_token();\n if (s6 !== peg$FAILED) {\n peg$savedPos = s4;\n s4 = peg$f24(s6);\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n while (s4 !== peg$FAILED) {\n s3.push(s4);\n s4 = peg$currPos;\n s5 = peg$currPos;\n peg$silentFails++;\n s6 = peg$currPos;\n s7 = peg$parsemath_shift();\n if (s7 !== peg$FAILED) {\n s8 = peg$parsemath_shift();\n if (s8 !== peg$FAILED) {\n s7 = [s7, s8];\n s6 = s7;\n } else {\n peg$currPos = s6;\n s6 = peg$FAILED;\n }\n } else {\n peg$currPos = s6;\n s6 = peg$FAILED;\n }\n peg$silentFails--;\n if (s6 === peg$FAILED) {\n s5 = void 0;\n } else {\n peg$currPos = s5;\n s5 = peg$FAILED;\n }\n if (s5 !== peg$FAILED) {\n s6 = peg$parsemath_token();\n if (s6 !== peg$FAILED) {\n peg$savedPos = s4;\n s4 = peg$f24(s6);\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n }\n s4 = peg$parsemath_shift();\n if (s4 !== peg$FAILED) {\n s5 = peg$parsemath_shift();\n if (s5 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f25(s3);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n if (s0 === peg$FAILED) {\n s0 = peg$parsemath_environment();\n if (s0 === peg$FAILED) {\n s0 = peg$parseenvironment();\n }\n }\n }\n }\n }\n }\n }\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e11);\n }\n }\n return s0;\n }\n function peg$parsesquare_bracket_argument() {\n var s0, s1, s2, s3, s4, s5, s6, s7;\n s0 = peg$currPos;\n if (input.charCodeAt(peg$currPos) === 91) {\n s1 = peg$c4;\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e14);\n }\n }\n if (s1 !== peg$FAILED) {\n s2 = [];\n s3 = peg$currPos;\n s4 = peg$currPos;\n peg$silentFails++;\n s5 = peg$currPos;\n s6 = peg$parsetoken();\n if (s6 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s7 = peg$f26(s6);\n if (s7) {\n s7 = void 0;\n } else {\n s7 = peg$FAILED;\n }\n if (s7 !== peg$FAILED) {\n s6 = [s6, s7];\n s5 = s6;\n } else {\n peg$currPos = s5;\n s5 = peg$FAILED;\n }\n } else {\n peg$currPos = s5;\n s5 = peg$FAILED;\n }\n peg$silentFails--;\n if (s5 === peg$FAILED) {\n s4 = void 0;\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n if (s4 !== peg$FAILED) {\n s5 = peg$parsetoken();\n if (s5 !== peg$FAILED) {\n peg$savedPos = s3;\n s3 = peg$f27(s5);\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n while (s3 !== peg$FAILED) {\n s2.push(s3);\n s3 = peg$currPos;\n s4 = peg$currPos;\n peg$silentFails++;\n s5 = peg$currPos;\n s6 = peg$parsetoken();\n if (s6 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s7 = peg$f26(s6);\n if (s7) {\n s7 = void 0;\n } else {\n s7 = peg$FAILED;\n }\n if (s7 !== peg$FAILED) {\n s6 = [s6, s7];\n s5 = s6;\n } else {\n peg$currPos = s5;\n s5 = peg$FAILED;\n }\n } else {\n peg$currPos = s5;\n s5 = peg$FAILED;\n }\n peg$silentFails--;\n if (s5 === peg$FAILED) {\n s4 = void 0;\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n if (s4 !== peg$FAILED) {\n s5 = peg$parsetoken();\n if (s5 !== peg$FAILED) {\n peg$savedPos = s3;\n s3 = peg$f27(s5);\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n }\n if (input.charCodeAt(peg$currPos) === 93) {\n s3 = peg$c5;\n peg$currPos++;\n } else {\n s3 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e15);\n }\n }\n if (s3 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f28(s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parseverbatim_group() {\n var s0, s1, s2, s3, s4, s5;\n s0 = peg$currPos;\n s1 = peg$parsebegin_group();\n if (s1 !== peg$FAILED) {\n s2 = [];\n s3 = peg$currPos;\n s4 = peg$currPos;\n peg$silentFails++;\n s5 = peg$parseend_group();\n peg$silentFails--;\n if (s5 === peg$FAILED) {\n s4 = void 0;\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n if (s4 !== peg$FAILED) {\n if (input.length > peg$currPos) {\n s5 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s5 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e3);\n }\n }\n if (s5 !== peg$FAILED) {\n peg$savedPos = s3;\n s3 = peg$f29(s5);\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n while (s3 !== peg$FAILED) {\n s2.push(s3);\n s3 = peg$currPos;\n s4 = peg$currPos;\n peg$silentFails++;\n s5 = peg$parseend_group();\n peg$silentFails--;\n if (s5 === peg$FAILED) {\n s4 = void 0;\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n if (s4 !== peg$FAILED) {\n if (input.length > peg$currPos) {\n s5 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s5 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e3);\n }\n }\n if (s5 !== peg$FAILED) {\n peg$savedPos = s3;\n s3 = peg$f29(s5);\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n }\n s3 = peg$parseend_group();\n if (s3 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f30(s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parseverbatim_delimited_by_char() {\n var s0, s1, s2, s3, s4, s5, s6, s7;\n s0 = peg$currPos;\n if (peg$r0.test(input.charAt(peg$currPos))) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e16);\n }\n }\n if (s1 !== peg$FAILED) {\n s2 = [];\n s3 = peg$currPos;\n s4 = peg$currPos;\n peg$silentFails++;\n s5 = peg$currPos;\n if (input.length > peg$currPos) {\n s6 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s6 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e3);\n }\n }\n if (s6 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s7 = peg$f31(s1, s6);\n if (s7) {\n s7 = void 0;\n } else {\n s7 = peg$FAILED;\n }\n if (s7 !== peg$FAILED) {\n s6 = [s6, s7];\n s5 = s6;\n } else {\n peg$currPos = s5;\n s5 = peg$FAILED;\n }\n } else {\n peg$currPos = s5;\n s5 = peg$FAILED;\n }\n peg$silentFails--;\n if (s5 === peg$FAILED) {\n s4 = void 0;\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n if (s4 !== peg$FAILED) {\n if (input.length > peg$currPos) {\n s5 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s5 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e3);\n }\n }\n if (s5 !== peg$FAILED) {\n peg$savedPos = s3;\n s3 = peg$f32(s1, s5);\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n while (s3 !== peg$FAILED) {\n s2.push(s3);\n s3 = peg$currPos;\n s4 = peg$currPos;\n peg$silentFails++;\n s5 = peg$currPos;\n if (input.length > peg$currPos) {\n s6 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s6 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e3);\n }\n }\n if (s6 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s7 = peg$f31(s1, s6);\n if (s7) {\n s7 = void 0;\n } else {\n s7 = peg$FAILED;\n }\n if (s7 !== peg$FAILED) {\n s6 = [s6, s7];\n s5 = s6;\n } else {\n peg$currPos = s5;\n s5 = peg$FAILED;\n }\n } else {\n peg$currPos = s5;\n s5 = peg$FAILED;\n }\n peg$silentFails--;\n if (s5 === peg$FAILED) {\n s4 = void 0;\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n if (s4 !== peg$FAILED) {\n if (input.length > peg$currPos) {\n s5 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s5 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e3);\n }\n }\n if (s5 !== peg$FAILED) {\n peg$savedPos = s3;\n s3 = peg$f32(s1, s5);\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n }\n s3 = peg$currPos;\n if (input.length > peg$currPos) {\n s4 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s4 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e3);\n }\n }\n if (s4 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s5 = peg$f33(s1, s2, s4);\n if (s5) {\n s5 = void 0;\n } else {\n s5 = peg$FAILED;\n }\n if (s5 !== peg$FAILED) {\n s4 = [s4, s5];\n s3 = s4;\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n if (s3 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f34(s1, s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parseverbatim_listings() {\n var s0, s1, s2, s3, s4;\n peg$silentFails++;\n s0 = peg$currPos;\n s1 = peg$parseescape();\n if (s1 !== peg$FAILED) {\n if (input.substr(peg$currPos, 9) === peg$c6) {\n s2 = peg$c6;\n peg$currPos += 9;\n } else {\n s2 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e18);\n }\n }\n if (s2 !== peg$FAILED) {\n s3 = peg$parsesquare_bracket_argument();\n if (s3 === peg$FAILED) {\n s3 = null;\n }\n s4 = peg$parseverbatim_group();\n if (s4 === peg$FAILED) {\n s4 = peg$parseverbatim_delimited_by_char();\n }\n if (s4 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f35(s2, s3, s4);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e17);\n }\n }\n return s0;\n }\n function peg$parseverbatim_minted() {\n var s0, s1, s2, s3, s4, s5;\n peg$silentFails++;\n s0 = peg$currPos;\n s1 = peg$parseescape();\n if (s1 !== peg$FAILED) {\n if (input.substr(peg$currPos, 10) === peg$c7) {\n s2 = peg$c7;\n peg$currPos += 10;\n } else {\n s2 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e20);\n }\n }\n if (s2 === peg$FAILED) {\n if (input.substr(peg$currPos, 4) === peg$c8) {\n s2 = peg$c8;\n peg$currPos += 4;\n } else {\n s2 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e21);\n }\n }\n }\n if (s2 !== peg$FAILED) {\n s3 = peg$parsesquare_bracket_argument();\n if (s3 === peg$FAILED) {\n s3 = null;\n }\n s4 = peg$parsegroup();\n if (s4 !== peg$FAILED) {\n s5 = peg$parseverbatim_group();\n if (s5 === peg$FAILED) {\n s5 = peg$parseverbatim_delimited_by_char();\n }\n if (s5 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f36(s2, s3, s4, s5);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e19);\n }\n }\n return s0;\n }\n function peg$parseverbatim_minted_environment() {\n var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12;\n peg$silentFails++;\n s0 = peg$currPos;\n s1 = peg$parsebegin_env();\n if (s1 !== peg$FAILED) {\n s2 = peg$parsebegin_group();\n if (s2 !== peg$FAILED) {\n if (input.substr(peg$currPos, 6) === peg$c9) {\n s3 = peg$c9;\n peg$currPos += 6;\n } else {\n s3 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e23);\n }\n }\n if (s3 !== peg$FAILED) {\n s4 = peg$parseend_group();\n if (s4 !== peg$FAILED) {\n s5 = peg$parsegroup();\n if (s5 !== peg$FAILED) {\n s6 = [];\n s7 = peg$currPos;\n s8 = peg$currPos;\n peg$silentFails++;\n s9 = peg$currPos;\n s10 = peg$parseend_env();\n if (s10 !== peg$FAILED) {\n s11 = peg$parsegroup();\n if (s11 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s12 = peg$f37(s3, s5, s11);\n if (s12) {\n s12 = void 0;\n } else {\n s12 = peg$FAILED;\n }\n if (s12 !== peg$FAILED) {\n s10 = [s10, s11, s12];\n s9 = s10;\n } else {\n peg$currPos = s9;\n s9 = peg$FAILED;\n }\n } else {\n peg$currPos = s9;\n s9 = peg$FAILED;\n }\n } else {\n peg$currPos = s9;\n s9 = peg$FAILED;\n }\n peg$silentFails--;\n if (s9 === peg$FAILED) {\n s8 = void 0;\n } else {\n peg$currPos = s8;\n s8 = peg$FAILED;\n }\n if (s8 !== peg$FAILED) {\n if (input.length > peg$currPos) {\n s9 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s9 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e3);\n }\n }\n if (s9 !== peg$FAILED) {\n peg$savedPos = s7;\n s7 = peg$f38(s3, s5, s9);\n } else {\n peg$currPos = s7;\n s7 = peg$FAILED;\n }\n } else {\n peg$currPos = s7;\n s7 = peg$FAILED;\n }\n while (s7 !== peg$FAILED) {\n s6.push(s7);\n s7 = peg$currPos;\n s8 = peg$currPos;\n peg$silentFails++;\n s9 = peg$currPos;\n s10 = peg$parseend_env();\n if (s10 !== peg$FAILED) {\n s11 = peg$parsegroup();\n if (s11 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s12 = peg$f37(s3, s5, s11);\n if (s12) {\n s12 = void 0;\n } else {\n s12 = peg$FAILED;\n }\n if (s12 !== peg$FAILED) {\n s10 = [s10, s11, s12];\n s9 = s10;\n } else {\n peg$currPos = s9;\n s9 = peg$FAILED;\n }\n } else {\n peg$currPos = s9;\n s9 = peg$FAILED;\n }\n } else {\n peg$currPos = s9;\n s9 = peg$FAILED;\n }\n peg$silentFails--;\n if (s9 === peg$FAILED) {\n s8 = void 0;\n } else {\n peg$currPos = s8;\n s8 = peg$FAILED;\n }\n if (s8 !== peg$FAILED) {\n if (input.length > peg$currPos) {\n s9 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s9 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e3);\n }\n }\n if (s9 !== peg$FAILED) {\n peg$savedPos = s7;\n s7 = peg$f38(s3, s5, s9);\n } else {\n peg$currPos = s7;\n s7 = peg$FAILED;\n }\n } else {\n peg$currPos = s7;\n s7 = peg$FAILED;\n }\n }\n s7 = peg$parseend_env();\n if (s7 !== peg$FAILED) {\n s8 = peg$parsebegin_group();\n if (s8 !== peg$FAILED) {\n s9 = peg$parseverbatim_env_name();\n if (s9 !== peg$FAILED) {\n s10 = peg$parseend_group();\n if (s10 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f39(s3, s5, s6);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e22);\n }\n }\n return s0;\n }\n function peg$parseverbatim_environment() {\n var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11;\n peg$silentFails++;\n s0 = peg$currPos;\n s1 = peg$parsebegin_env();\n if (s1 !== peg$FAILED) {\n s2 = peg$parsebegin_group();\n if (s2 !== peg$FAILED) {\n s3 = peg$parseverbatim_env_name();\n if (s3 !== peg$FAILED) {\n s4 = peg$parseend_group();\n if (s4 !== peg$FAILED) {\n s5 = [];\n s6 = peg$currPos;\n s7 = peg$currPos;\n peg$silentFails++;\n s8 = peg$currPos;\n s9 = peg$parseend_env();\n if (s9 !== peg$FAILED) {\n s10 = peg$parsegroup();\n if (s10 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s11 = peg$f40(s3, s10);\n if (s11) {\n s11 = void 0;\n } else {\n s11 = peg$FAILED;\n }\n if (s11 !== peg$FAILED) {\n s9 = [s9, s10, s11];\n s8 = s9;\n } else {\n peg$currPos = s8;\n s8 = peg$FAILED;\n }\n } else {\n peg$currPos = s8;\n s8 = peg$FAILED;\n }\n } else {\n peg$currPos = s8;\n s8 = peg$FAILED;\n }\n peg$silentFails--;\n if (s8 === peg$FAILED) {\n s7 = void 0;\n } else {\n peg$currPos = s7;\n s7 = peg$FAILED;\n }\n if (s7 !== peg$FAILED) {\n if (input.length > peg$currPos) {\n s8 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s8 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e3);\n }\n }\n if (s8 !== peg$FAILED) {\n peg$savedPos = s6;\n s6 = peg$f41(s3, s8);\n } else {\n peg$currPos = s6;\n s6 = peg$FAILED;\n }\n } else {\n peg$currPos = s6;\n s6 = peg$FAILED;\n }\n while (s6 !== peg$FAILED) {\n s5.push(s6);\n s6 = peg$currPos;\n s7 = peg$currPos;\n peg$silentFails++;\n s8 = peg$currPos;\n s9 = peg$parseend_env();\n if (s9 !== peg$FAILED) {\n s10 = peg$parsegroup();\n if (s10 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s11 = peg$f40(s3, s10);\n if (s11) {\n s11 = void 0;\n } else {\n s11 = peg$FAILED;\n }\n if (s11 !== peg$FAILED) {\n s9 = [s9, s10, s11];\n s8 = s9;\n } else {\n peg$currPos = s8;\n s8 = peg$FAILED;\n }\n } else {\n peg$currPos = s8;\n s8 = peg$FAILED;\n }\n } else {\n peg$currPos = s8;\n s8 = peg$FAILED;\n }\n peg$silentFails--;\n if (s8 === peg$FAILED) {\n s7 = void 0;\n } else {\n peg$currPos = s7;\n s7 = peg$FAILED;\n }\n if (s7 !== peg$FAILED) {\n if (input.length > peg$currPos) {\n s8 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s8 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e3);\n }\n }\n if (s8 !== peg$FAILED) {\n peg$savedPos = s6;\n s6 = peg$f41(s3, s8);\n } else {\n peg$currPos = s6;\n s6 = peg$FAILED;\n }\n } else {\n peg$currPos = s6;\n s6 = peg$FAILED;\n }\n }\n s6 = peg$parseend_env();\n if (s6 !== peg$FAILED) {\n s7 = peg$parsebegin_group();\n if (s7 !== peg$FAILED) {\n s8 = peg$parseverbatim_env_name();\n if (s8 !== peg$FAILED) {\n s9 = peg$parseend_group();\n if (s9 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f42(s3, s5);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e24);\n }\n }\n return s0;\n }\n function peg$parseverbatim_env_name() {\n var s0;\n if (input.substr(peg$currPos, 9) === peg$c10) {\n s0 = peg$c10;\n peg$currPos += 9;\n } else {\n s0 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e25);\n }\n }\n if (s0 === peg$FAILED) {\n if (input.substr(peg$currPos, 8) === peg$c11) {\n s0 = peg$c11;\n peg$currPos += 8;\n } else {\n s0 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e26);\n }\n }\n if (s0 === peg$FAILED) {\n if (input.substr(peg$currPos, 13) === peg$c12) {\n s0 = peg$c12;\n peg$currPos += 13;\n } else {\n s0 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e27);\n }\n }\n if (s0 === peg$FAILED) {\n if (input.substr(peg$currPos, 12) === peg$c13) {\n s0 = peg$c13;\n peg$currPos += 12;\n } else {\n s0 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e28);\n }\n }\n if (s0 === peg$FAILED) {\n if (input.substr(peg$currPos, 7) === peg$c14) {\n s0 = peg$c14;\n peg$currPos += 7;\n } else {\n s0 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e29);\n }\n }\n if (s0 === peg$FAILED) {\n if (input.substr(peg$currPos, 10) === peg$c15) {\n s0 = peg$c15;\n peg$currPos += 10;\n } else {\n s0 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e30);\n }\n }\n }\n }\n }\n }\n }\n return s0;\n }\n function peg$parsemacro() {\n var s0, s1, s2, s3, s4;\n peg$silentFails++;\n s0 = peg$currPos;\n s1 = peg$currPos;\n s2 = peg$parseescape();\n if (s2 !== peg$FAILED) {\n s3 = [];\n s4 = peg$parsechar();\n if (s4 !== peg$FAILED) {\n while (s4 !== peg$FAILED) {\n s3.push(s4);\n s4 = peg$parsechar();\n }\n } else {\n s3 = peg$FAILED;\n }\n if (s3 !== peg$FAILED) {\n peg$savedPos = s1;\n s1 = peg$f43(s3);\n } else {\n peg$currPos = s1;\n s1 = peg$FAILED;\n }\n } else {\n peg$currPos = s1;\n s1 = peg$FAILED;\n }\n if (s1 === peg$FAILED) {\n s1 = peg$currPos;\n s2 = peg$parseescape();\n if (s2 !== peg$FAILED) {\n if (input.length > peg$currPos) {\n s3 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s3 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e3);\n }\n }\n if (s3 !== peg$FAILED) {\n peg$savedPos = s1;\n s1 = peg$f44(s3);\n } else {\n peg$currPos = s1;\n s1 = peg$FAILED;\n }\n } else {\n peg$currPos = s1;\n s1 = peg$FAILED;\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = s0;\n s1 = peg$f45(s1);\n }\n s0 = s1;\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e31);\n }\n }\n return s0;\n }\n function peg$parsegroup() {\n var s0, s1, s2, s3, s4, s5;\n peg$silentFails++;\n s0 = peg$currPos;\n s1 = peg$parsebegin_group();\n if (s1 !== peg$FAILED) {\n s2 = [];\n s3 = peg$currPos;\n s4 = peg$currPos;\n peg$silentFails++;\n s5 = peg$parseend_group();\n peg$silentFails--;\n if (s5 === peg$FAILED) {\n s4 = void 0;\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n if (s4 !== peg$FAILED) {\n s5 = peg$parsetoken();\n if (s5 !== peg$FAILED) {\n peg$savedPos = s3;\n s3 = peg$f46(s5);\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n while (s3 !== peg$FAILED) {\n s2.push(s3);\n s3 = peg$currPos;\n s4 = peg$currPos;\n peg$silentFails++;\n s5 = peg$parseend_group();\n peg$silentFails--;\n if (s5 === peg$FAILED) {\n s4 = void 0;\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n if (s4 !== peg$FAILED) {\n s5 = peg$parsetoken();\n if (s5 !== peg$FAILED) {\n peg$savedPos = s3;\n s3 = peg$f46(s5);\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n }\n s3 = peg$parseend_group();\n if (s3 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f47(s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e32);\n }\n }\n return s0;\n }\n function peg$parsegroup_contents_as_string() {\n var s0, s1;\n s0 = peg$currPos;\n s1 = peg$parsegroup();\n if (s1 !== peg$FAILED) {\n peg$savedPos = s0;\n s1 = peg$f48(s1);\n }\n s0 = s1;\n return s0;\n }\n function peg$parseenvironment() {\n var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10;\n peg$silentFails++;\n s0 = peg$currPos;\n s1 = peg$parsebegin_env();\n if (s1 !== peg$FAILED) {\n s2 = peg$parsegroup_contents_as_string();\n if (s2 !== peg$FAILED) {\n s3 = peg$parsesameline_comment();\n if (s3 === peg$FAILED) {\n s3 = null;\n }\n s4 = [];\n s5 = peg$currPos;\n s6 = peg$currPos;\n peg$silentFails++;\n s7 = peg$currPos;\n s8 = peg$parseend_env();\n if (s8 !== peg$FAILED) {\n s9 = peg$parsegroup_contents_as_string();\n if (s9 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s10 = peg$f49(s2, s3, s9);\n if (s10) {\n s10 = void 0;\n } else {\n s10 = peg$FAILED;\n }\n if (s10 !== peg$FAILED) {\n s8 = [s8, s9, s10];\n s7 = s8;\n } else {\n peg$currPos = s7;\n s7 = peg$FAILED;\n }\n } else {\n peg$currPos = s7;\n s7 = peg$FAILED;\n }\n } else {\n peg$currPos = s7;\n s7 = peg$FAILED;\n }\n peg$silentFails--;\n if (s7 === peg$FAILED) {\n s6 = void 0;\n } else {\n peg$currPos = s6;\n s6 = peg$FAILED;\n }\n if (s6 !== peg$FAILED) {\n s7 = peg$parsetoken();\n if (s7 !== peg$FAILED) {\n peg$savedPos = s5;\n s5 = peg$f50(s2, s3, s7);\n } else {\n peg$currPos = s5;\n s5 = peg$FAILED;\n }\n } else {\n peg$currPos = s5;\n s5 = peg$FAILED;\n }\n while (s5 !== peg$FAILED) {\n s4.push(s5);\n s5 = peg$currPos;\n s6 = peg$currPos;\n peg$silentFails++;\n s7 = peg$currPos;\n s8 = peg$parseend_env();\n if (s8 !== peg$FAILED) {\n s9 = peg$parsegroup_contents_as_string();\n if (s9 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s10 = peg$f49(s2, s3, s9);\n if (s10) {\n s10 = void 0;\n } else {\n s10 = peg$FAILED;\n }\n if (s10 !== peg$FAILED) {\n s8 = [s8, s9, s10];\n s7 = s8;\n } else {\n peg$currPos = s7;\n s7 = peg$FAILED;\n }\n } else {\n peg$currPos = s7;\n s7 = peg$FAILED;\n }\n } else {\n peg$currPos = s7;\n s7 = peg$FAILED;\n }\n peg$silentFails--;\n if (s7 === peg$FAILED) {\n s6 = void 0;\n } else {\n peg$currPos = s6;\n s6 = peg$FAILED;\n }\n if (s6 !== peg$FAILED) {\n s7 = peg$parsetoken();\n if (s7 !== peg$FAILED) {\n peg$savedPos = s5;\n s5 = peg$f50(s2, s3, s7);\n } else {\n peg$currPos = s5;\n s5 = peg$FAILED;\n }\n } else {\n peg$currPos = s5;\n s5 = peg$FAILED;\n }\n }\n s5 = peg$parseend_env();\n if (s5 !== peg$FAILED) {\n s6 = peg$parsegroup_contents_as_string();\n if (s6 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f51(s2, s3, s4);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e33);\n }\n }\n return s0;\n }\n function peg$parsemath_environment() {\n var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12;\n peg$silentFails++;\n s0 = peg$currPos;\n s1 = peg$parsebegin_env();\n if (s1 !== peg$FAILED) {\n s2 = peg$parsebegin_group();\n if (s2 !== peg$FAILED) {\n s3 = peg$parsemath_env_name();\n if (s3 !== peg$FAILED) {\n s4 = peg$parseend_group();\n if (s4 !== peg$FAILED) {\n s5 = peg$parsesameline_comment();\n if (s5 === peg$FAILED) {\n s5 = null;\n }\n s6 = [];\n s7 = peg$currPos;\n s8 = peg$currPos;\n peg$silentFails++;\n s9 = peg$currPos;\n s10 = peg$parseend_env();\n if (s10 !== peg$FAILED) {\n s11 = peg$parsegroup();\n if (s11 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s12 = peg$f52(s3, s5, s11);\n if (s12) {\n s12 = void 0;\n } else {\n s12 = peg$FAILED;\n }\n if (s12 !== peg$FAILED) {\n s10 = [s10, s11, s12];\n s9 = s10;\n } else {\n peg$currPos = s9;\n s9 = peg$FAILED;\n }\n } else {\n peg$currPos = s9;\n s9 = peg$FAILED;\n }\n } else {\n peg$currPos = s9;\n s9 = peg$FAILED;\n }\n peg$silentFails--;\n if (s9 === peg$FAILED) {\n s8 = void 0;\n } else {\n peg$currPos = s8;\n s8 = peg$FAILED;\n }\n if (s8 !== peg$FAILED) {\n s9 = peg$parsemath_token();\n if (s9 !== peg$FAILED) {\n peg$savedPos = s7;\n s7 = peg$f53(s3, s5, s9);\n } else {\n peg$currPos = s7;\n s7 = peg$FAILED;\n }\n } else {\n peg$currPos = s7;\n s7 = peg$FAILED;\n }\n while (s7 !== peg$FAILED) {\n s6.push(s7);\n s7 = peg$currPos;\n s8 = peg$currPos;\n peg$silentFails++;\n s9 = peg$currPos;\n s10 = peg$parseend_env();\n if (s10 !== peg$FAILED) {\n s11 = peg$parsegroup();\n if (s11 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s12 = peg$f52(s3, s5, s11);\n if (s12) {\n s12 = void 0;\n } else {\n s12 = peg$FAILED;\n }\n if (s12 !== peg$FAILED) {\n s10 = [s10, s11, s12];\n s9 = s10;\n } else {\n peg$currPos = s9;\n s9 = peg$FAILED;\n }\n } else {\n peg$currPos = s9;\n s9 = peg$FAILED;\n }\n } else {\n peg$currPos = s9;\n s9 = peg$FAILED;\n }\n peg$silentFails--;\n if (s9 === peg$FAILED) {\n s8 = void 0;\n } else {\n peg$currPos = s8;\n s8 = peg$FAILED;\n }\n if (s8 !== peg$FAILED) {\n s9 = peg$parsemath_token();\n if (s9 !== peg$FAILED) {\n peg$savedPos = s7;\n s7 = peg$f53(s3, s5, s9);\n } else {\n peg$currPos = s7;\n s7 = peg$FAILED;\n }\n } else {\n peg$currPos = s7;\n s7 = peg$FAILED;\n }\n }\n s7 = peg$parseend_env();\n if (s7 !== peg$FAILED) {\n s8 = peg$parsebegin_group();\n if (s8 !== peg$FAILED) {\n s9 = peg$parsemath_env_name();\n if (s9 !== peg$FAILED) {\n s10 = peg$parseend_group();\n if (s10 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f54(s3, s5, s6);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e34);\n }\n }\n return s0;\n }\n function peg$parsemath_group() {\n var s0, s1, s2, s3, s4, s5;\n peg$silentFails++;\n s0 = peg$currPos;\n s1 = peg$parsebegin_group();\n if (s1 !== peg$FAILED) {\n s2 = [];\n s3 = peg$currPos;\n s4 = peg$currPos;\n peg$silentFails++;\n s5 = peg$parseend_group();\n peg$silentFails--;\n if (s5 === peg$FAILED) {\n s4 = void 0;\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n if (s4 !== peg$FAILED) {\n s5 = peg$parsemath_token();\n if (s5 !== peg$FAILED) {\n peg$savedPos = s3;\n s3 = peg$f55(s5);\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n while (s3 !== peg$FAILED) {\n s2.push(s3);\n s3 = peg$currPos;\n s4 = peg$currPos;\n peg$silentFails++;\n s5 = peg$parseend_group();\n peg$silentFails--;\n if (s5 === peg$FAILED) {\n s4 = void 0;\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n if (s4 !== peg$FAILED) {\n s5 = peg$parsemath_token();\n if (s5 !== peg$FAILED) {\n peg$savedPos = s3;\n s3 = peg$f55(s5);\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n }\n s3 = peg$parseend_group();\n if (s3 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f56(s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e35);\n }\n }\n return s0;\n }\n function peg$parsebegin_display_math() {\n var s0, s1, s2;\n s0 = peg$currPos;\n s1 = peg$parseescape();\n if (s1 !== peg$FAILED) {\n if (input.charCodeAt(peg$currPos) === 91) {\n s2 = peg$c4;\n peg$currPos++;\n } else {\n s2 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e14);\n }\n }\n if (s2 !== peg$FAILED) {\n s1 = [s1, s2];\n s0 = s1;\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parseend_display_math() {\n var s0, s1, s2;\n s0 = peg$currPos;\n s1 = peg$parseescape();\n if (s1 !== peg$FAILED) {\n if (input.charCodeAt(peg$currPos) === 93) {\n s2 = peg$c5;\n peg$currPos++;\n } else {\n s2 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e15);\n }\n }\n if (s2 !== peg$FAILED) {\n s1 = [s1, s2];\n s0 = s1;\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parsebegin_inline_math() {\n var s0, s1, s2;\n s0 = peg$currPos;\n s1 = peg$parseescape();\n if (s1 !== peg$FAILED) {\n if (input.charCodeAt(peg$currPos) === 40) {\n s2 = peg$c16;\n peg$currPos++;\n } else {\n s2 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e36);\n }\n }\n if (s2 !== peg$FAILED) {\n s1 = [s1, s2];\n s0 = s1;\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parseend_inline_math() {\n var s0, s1, s2;\n s0 = peg$currPos;\n s1 = peg$parseescape();\n if (s1 !== peg$FAILED) {\n if (input.charCodeAt(peg$currPos) === 41) {\n s2 = peg$c17;\n peg$currPos++;\n } else {\n s2 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e37);\n }\n }\n if (s2 !== peg$FAILED) {\n s1 = [s1, s2];\n s0 = s1;\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parsebegin_env() {\n var s0, s1, s2;\n s0 = peg$currPos;\n s1 = peg$parseescape();\n if (s1 !== peg$FAILED) {\n if (input.substr(peg$currPos, 5) === peg$c18) {\n s2 = peg$c18;\n peg$currPos += 5;\n } else {\n s2 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e38);\n }\n }\n if (s2 !== peg$FAILED) {\n s1 = [s1, s2];\n s0 = s1;\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parseend_env() {\n var s0, s1, s2;\n s0 = peg$currPos;\n s1 = peg$parseescape();\n if (s1 !== peg$FAILED) {\n if (input.substr(peg$currPos, 3) === peg$c19) {\n s2 = peg$c19;\n peg$currPos += 3;\n } else {\n s2 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e39);\n }\n }\n if (s2 !== peg$FAILED) {\n s1 = [s1, s2];\n s0 = s1;\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parsemath_env_name() {\n var s0, s1;\n s0 = peg$currPos;\n if (input.substr(peg$currPos, 9) === peg$c20) {\n s1 = peg$c20;\n peg$currPos += 9;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e40);\n }\n }\n if (s1 === peg$FAILED) {\n if (input.substr(peg$currPos, 8) === peg$c21) {\n s1 = peg$c21;\n peg$currPos += 8;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e41);\n }\n }\n if (s1 === peg$FAILED) {\n if (input.substr(peg$currPos, 6) === peg$c22) {\n s1 = peg$c22;\n peg$currPos += 6;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e42);\n }\n }\n if (s1 === peg$FAILED) {\n if (input.substr(peg$currPos, 5) === peg$c23) {\n s1 = peg$c23;\n peg$currPos += 5;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e43);\n }\n }\n if (s1 === peg$FAILED) {\n if (input.substr(peg$currPos, 8) === peg$c24) {\n s1 = peg$c24;\n peg$currPos += 8;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e44);\n }\n }\n if (s1 === peg$FAILED) {\n if (input.substr(peg$currPos, 7) === peg$c25) {\n s1 = peg$c25;\n peg$currPos += 7;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e45);\n }\n }\n if (s1 === peg$FAILED) {\n if (input.substr(peg$currPos, 7) === peg$c26) {\n s1 = peg$c26;\n peg$currPos += 7;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e46);\n }\n }\n if (s1 === peg$FAILED) {\n if (input.substr(peg$currPos, 6) === peg$c27) {\n s1 = peg$c27;\n peg$currPos += 6;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e47);\n }\n }\n if (s1 === peg$FAILED) {\n if (input.substr(peg$currPos, 9) === peg$c28) {\n s1 = peg$c28;\n peg$currPos += 9;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e48);\n }\n }\n if (s1 === peg$FAILED) {\n if (input.substr(peg$currPos, 8) === peg$c29) {\n s1 = peg$c29;\n peg$currPos += 8;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e49);\n }\n }\n if (s1 === peg$FAILED) {\n if (input.substr(peg$currPos, 8) === peg$c30) {\n s1 = peg$c30;\n peg$currPos += 8;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e50);\n }\n }\n if (s1 === peg$FAILED) {\n if (input.substr(peg$currPos, 7) === peg$c31) {\n s1 = peg$c31;\n peg$currPos += 7;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e51);\n }\n }\n if (s1 === peg$FAILED) {\n if (input.substr(peg$currPos, 5) === peg$c32) {\n s1 = peg$c32;\n peg$currPos += 5;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e52);\n }\n }\n if (s1 === peg$FAILED) {\n if (input.substr(peg$currPos, 4) === peg$c33) {\n s1 = peg$c33;\n peg$currPos += 4;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e53);\n }\n }\n if (s1 === peg$FAILED) {\n if (input.substr(peg$currPos, 11) === peg$c34) {\n s1 = peg$c34;\n peg$currPos += 11;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e54);\n }\n }\n }\n }\n }\n }\n }\n }\n }\n }\n }\n }\n }\n }\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = s0;\n s1 = peg$f57(s1);\n }\n s0 = s1;\n return s0;\n }\n function peg$parseescape() {\n var s0, s1;\n peg$silentFails++;\n s0 = peg$currPos;\n if (input.charCodeAt(peg$currPos) === 92) {\n s1 = peg$c35;\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e56);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = s0;\n s1 = peg$f58();\n }\n s0 = s1;\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e55);\n }\n }\n return s0;\n }\n function peg$parsebegin_group() {\n var s0, s1;\n s0 = peg$currPos;\n if (input.charCodeAt(peg$currPos) === 123) {\n s1 = peg$c36;\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e57);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = s0;\n s1 = peg$f59(s1);\n }\n s0 = s1;\n return s0;\n }\n function peg$parseend_group() {\n var s0, s1;\n s0 = peg$currPos;\n if (input.charCodeAt(peg$currPos) === 125) {\n s1 = peg$c37;\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e58);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = s0;\n s1 = peg$f60(s1);\n }\n s0 = s1;\n return s0;\n }\n function peg$parsemath_shift() {\n var s0, s1;\n s0 = peg$currPos;\n if (input.charCodeAt(peg$currPos) === 36) {\n s1 = peg$c38;\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e59);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = s0;\n s1 = peg$f61(s1);\n }\n s0 = s1;\n return s0;\n }\n function peg$parsealignment_tab() {\n var s0, s1;\n s0 = peg$currPos;\n if (input.charCodeAt(peg$currPos) === 38) {\n s1 = peg$c39;\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e60);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = s0;\n s1 = peg$f62(s1);\n }\n s0 = s1;\n return s0;\n }\n function peg$parsenl() {\n var s0, s1, s2;\n peg$silentFails++;\n s0 = peg$currPos;\n s1 = peg$currPos;\n peg$silentFails++;\n if (input.charCodeAt(peg$currPos) === 13) {\n s2 = peg$c40;\n peg$currPos++;\n } else {\n s2 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e62);\n }\n }\n peg$silentFails--;\n if (s2 === peg$FAILED) {\n s1 = void 0;\n } else {\n peg$currPos = s1;\n s1 = peg$FAILED;\n }\n if (s1 !== peg$FAILED) {\n if (input.charCodeAt(peg$currPos) === 10) {\n s2 = peg$c41;\n peg$currPos++;\n } else {\n s2 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e63);\n }\n }\n if (s2 !== peg$FAILED) {\n s1 = [s1, s2];\n s0 = s1;\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n if (s0 === peg$FAILED) {\n if (input.charCodeAt(peg$currPos) === 13) {\n s0 = peg$c40;\n peg$currPos++;\n } else {\n s0 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e62);\n }\n }\n if (s0 === peg$FAILED) {\n if (input.substr(peg$currPos, 2) === peg$c42) {\n s0 = peg$c42;\n peg$currPos += 2;\n } else {\n s0 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e64);\n }\n }\n }\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e61);\n }\n }\n return s0;\n }\n function peg$parsemacro_parameter() {\n var s0, s1;\n s0 = peg$currPos;\n if (input.charCodeAt(peg$currPos) === 35) {\n s1 = peg$c43;\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e65);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = s0;\n s1 = peg$f63(s1);\n }\n s0 = s1;\n return s0;\n }\n function peg$parsesuperscript() {\n var s0, s1;\n s0 = peg$currPos;\n if (input.charCodeAt(peg$currPos) === 94) {\n s1 = peg$c44;\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e66);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = s0;\n s1 = peg$f64(s1);\n }\n s0 = s1;\n return s0;\n }\n function peg$parsesubscript() {\n var s0, s1;\n s0 = peg$currPos;\n if (input.charCodeAt(peg$currPos) === 95) {\n s1 = peg$c45;\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e67);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = s0;\n s1 = peg$f65(s1);\n }\n s0 = s1;\n return s0;\n }\n function peg$parseignore() {\n var s0;\n if (input.charCodeAt(peg$currPos) === 0) {\n s0 = peg$c46;\n peg$currPos++;\n } else {\n s0 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e68);\n }\n }\n return s0;\n }\n function peg$parsesp() {\n var s0, s1, s2;\n peg$silentFails++;\n s0 = peg$currPos;\n s1 = [];\n if (peg$r1.test(input.charAt(peg$currPos))) {\n s2 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s2 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e69);\n }\n }\n if (s2 !== peg$FAILED) {\n while (s2 !== peg$FAILED) {\n s1.push(s2);\n if (peg$r1.test(input.charAt(peg$currPos))) {\n s2 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s2 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e69);\n }\n }\n }\n } else {\n s1 = peg$FAILED;\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = s0;\n s1 = peg$f66();\n }\n s0 = s1;\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e8);\n }\n }\n return s0;\n }\n function peg$parsechar() {\n var s0, s1;\n peg$silentFails++;\n if (peg$r2.test(input.charAt(peg$currPos))) {\n s0 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s0 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e71);\n }\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e70);\n }\n }\n return s0;\n }\n function peg$parsenum() {\n var s0, s1;\n peg$silentFails++;\n if (peg$r3.test(input.charAt(peg$currPos))) {\n s0 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s0 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e73);\n }\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e72);\n }\n }\n return s0;\n }\n function peg$parsepunctuation() {\n var s0, s1;\n peg$silentFails++;\n s0 = peg$currPos;\n if (peg$r4.test(input.charAt(peg$currPos))) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e75);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = s0;\n s1 = peg$f67(s1);\n }\n s0 = s1;\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e74);\n }\n }\n return s0;\n }\n function peg$parsecomment_start() {\n var s0;\n if (input.charCodeAt(peg$currPos) === 37) {\n s0 = peg$c0;\n peg$currPos++;\n } else {\n s0 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e7);\n }\n }\n return s0;\n }\n function peg$parsefull_comment() {\n var s0, s1;\n peg$silentFails++;\n s0 = peg$parseownline_comment();\n if (s0 === peg$FAILED) {\n s0 = peg$parsesameline_comment();\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e76);\n }\n }\n return s0;\n }\n function peg$parseownline_comment() {\n var s0, s1, s2, s3;\n s0 = peg$currPos;\n s1 = peg$currPos;\n s2 = [];\n s3 = peg$parsesp();\n while (s3 !== peg$FAILED) {\n s2.push(s3);\n s3 = peg$parsesp();\n }\n s3 = peg$parsenl();\n if (s3 !== peg$FAILED) {\n s2 = [s2, s3];\n s1 = s2;\n } else {\n peg$currPos = s1;\n s1 = peg$FAILED;\n }\n if (s1 === peg$FAILED) {\n s1 = null;\n }\n s2 = peg$parseleading_sp();\n if (s2 !== peg$FAILED) {\n s3 = peg$parsecomment();\n if (s3 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f68(s2, s3);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parsesameline_comment() {\n var s0, s1, s2;\n s0 = peg$currPos;\n s1 = [];\n s2 = peg$parsesp();\n while (s2 !== peg$FAILED) {\n s1.push(s2);\n s2 = peg$parsesp();\n }\n s2 = peg$parsecomment();\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f69(s1, s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parsecomment() {\n var s0, s1, s2, s3, s4, s5, s6, s7;\n peg$silentFails++;\n s0 = peg$currPos;\n s1 = peg$parsecomment_start();\n if (s1 !== peg$FAILED) {\n s2 = [];\n s3 = peg$currPos;\n s4 = peg$currPos;\n peg$silentFails++;\n s5 = peg$parsenl();\n peg$silentFails--;\n if (s5 === peg$FAILED) {\n s4 = void 0;\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n if (s4 !== peg$FAILED) {\n if (input.length > peg$currPos) {\n s5 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s5 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e3);\n }\n }\n if (s5 !== peg$FAILED) {\n peg$savedPos = s3;\n s3 = peg$f70(s5);\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n while (s3 !== peg$FAILED) {\n s2.push(s3);\n s3 = peg$currPos;\n s4 = peg$currPos;\n peg$silentFails++;\n s5 = peg$parsenl();\n peg$silentFails--;\n if (s5 === peg$FAILED) {\n s4 = void 0;\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n if (s4 !== peg$FAILED) {\n if (input.length > peg$currPos) {\n s5 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s5 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e3);\n }\n }\n if (s5 !== peg$FAILED) {\n peg$savedPos = s3;\n s3 = peg$f70(s5);\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n }\n s3 = peg$currPos;\n peg$silentFails++;\n s4 = peg$parseparbreak();\n peg$silentFails--;\n if (s4 !== peg$FAILED) {\n peg$currPos = s3;\n s3 = void 0;\n } else {\n s3 = peg$FAILED;\n }\n if (s3 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f71(s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n if (s0 === peg$FAILED) {\n s0 = peg$currPos;\n s1 = peg$parsecomment_start();\n if (s1 !== peg$FAILED) {\n s2 = [];\n s3 = peg$currPos;\n s4 = peg$currPos;\n peg$silentFails++;\n s5 = peg$parsenl();\n peg$silentFails--;\n if (s5 === peg$FAILED) {\n s4 = void 0;\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n if (s4 !== peg$FAILED) {\n if (input.length > peg$currPos) {\n s5 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s5 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e3);\n }\n }\n if (s5 !== peg$FAILED) {\n peg$savedPos = s3;\n s3 = peg$f72(s5);\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n while (s3 !== peg$FAILED) {\n s2.push(s3);\n s3 = peg$currPos;\n s4 = peg$currPos;\n peg$silentFails++;\n s5 = peg$parsenl();\n peg$silentFails--;\n if (s5 === peg$FAILED) {\n s4 = void 0;\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n if (s4 !== peg$FAILED) {\n if (input.length > peg$currPos) {\n s5 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s5 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e3);\n }\n }\n if (s5 !== peg$FAILED) {\n peg$savedPos = s3;\n s3 = peg$f72(s5);\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n }\n s3 = peg$currPos;\n s4 = peg$parsenl();\n if (s4 !== peg$FAILED) {\n s5 = [];\n s6 = peg$parsesp();\n while (s6 !== peg$FAILED) {\n s5.push(s6);\n s6 = peg$parsesp();\n }\n s6 = peg$currPos;\n peg$silentFails++;\n s7 = peg$parsecomment_start();\n peg$silentFails--;\n if (s7 === peg$FAILED) {\n s6 = void 0;\n } else {\n peg$currPos = s6;\n s6 = peg$FAILED;\n }\n if (s6 !== peg$FAILED) {\n s4 = [s4, s5, s6];\n s3 = s4;\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n if (s3 === peg$FAILED) {\n s3 = peg$parsenl();\n if (s3 === peg$FAILED) {\n s3 = peg$parseEOF();\n }\n }\n if (s3 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f73(s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e77);\n }\n }\n return s0;\n }\n function peg$parseleading_sp() {\n var s0, s1, s2, s3, s4;\n s0 = peg$currPos;\n s1 = peg$currPos;\n s2 = peg$parsestart_of_line();\n if (s2 !== peg$FAILED) {\n s3 = [];\n s4 = peg$parsesp();\n while (s4 !== peg$FAILED) {\n s3.push(s4);\n s4 = peg$parsesp();\n }\n s2 = [s2, s3];\n s1 = s2;\n } else {\n peg$currPos = s1;\n s1 = peg$FAILED;\n }\n if (s1 !== peg$FAILED) {\n s0 = input.substring(s0, peg$currPos);\n } else {\n s0 = s1;\n }\n return s0;\n }\n function peg$parsestart_of_line() {\n var s0;\n peg$savedPos = peg$currPos;\n s0 = peg$f74();\n if (s0) {\n s0 = void 0;\n } else {\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parseEOF() {\n var s0, s1;\n s0 = peg$currPos;\n peg$silentFails++;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e3);\n }\n }\n peg$silentFails--;\n if (s1 === peg$FAILED) {\n s0 = void 0;\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function toString(e) {\n if (typeof e === \"string\") {\n return e;\n }\n if (typeof e.content === \"string\") {\n return e.content;\n }\n if (e && e.type === \"whitespace\") {\n return \" \";\n }\n return e;\n }\n function compare_env(g1, g2) {\n const g1Name = typeof g1 === \"string\" ? g1 : g1.content.map(toString).join(\"\");\n const g2Name = typeof g2 === \"string\" ? g2 : g2.content.map(toString).join(\"\");\n return g1Name === g2Name;\n }\n function createNode(type, extra = {}) {\n return { type, ...extra, position: location() };\n }\n peg$result = peg$startRuleFunction();\n if (peg$result !== peg$FAILED && peg$currPos === input.length) {\n return peg$result;\n } else {\n if (peg$result !== peg$FAILED && peg$currPos < input.length) {\n peg$fail(peg$endExpectation());\n }\n throw peg$buildStructuredError(\n peg$maxFailExpected,\n peg$maxFailPos < input.length ? input.charAt(peg$maxFailPos) : null,\n peg$maxFailPos < input.length ? peg$computeLocation(peg$maxFailPos, peg$maxFailPos + 1) : peg$computeLocation(peg$maxFailPos, peg$maxFailPos)\n );\n }\n }\n return {\n SyntaxError: peg$SyntaxError,\n parse: peg$parse\n };\n }()\n);\n\n// grammars/align-environment.pegjs\nvar align_environment_default = (\n // Generated by Peggy 2.0.1.\n //\n // https://peggyjs.org/\n function() {\n \"use strict\";\n function peg$subclass(child, parent) {\n function C() {\n this.constructor = child;\n }\n C.prototype = parent.prototype;\n child.prototype = new C();\n }\n function peg$SyntaxError(message, expected, found, location) {\n var self = Error.call(this, message);\n if (Object.setPrototypeOf) {\n Object.setPrototypeOf(self, peg$SyntaxError.prototype);\n }\n self.expected = expected;\n self.found = found;\n self.location = location;\n self.name = \"SyntaxError\";\n return self;\n }\n peg$subclass(peg$SyntaxError, Error);\n function peg$padEnd(str, targetLength, padString) {\n padString = padString || \" \";\n if (str.length > targetLength) {\n return str;\n }\n targetLength -= str.length;\n padString += padString.repeat(targetLength);\n return str + padString.slice(0, targetLength);\n }\n peg$SyntaxError.prototype.format = function(sources) {\n var str = \"Error: \" + this.message;\n if (this.location) {\n var src = null;\n var k;\n for (k = 0; k < sources.length; k++) {\n if (sources[k].source === this.location.source) {\n src = sources[k].text.split(/\\r\\n|\\n|\\r/g);\n break;\n }\n }\n var s = this.location.start;\n var loc = this.location.source + \":\" + s.line + \":\" + s.column;\n if (src) {\n var e = this.location.end;\n var filler = peg$padEnd(\"\", s.line.toString().length, \" \");\n var line = src[s.line - 1];\n var last = s.line === e.line ? e.column : line.length + 1;\n var hatLen = last - s.column || 1;\n str += \"\\n --> \" + loc + \"\\n\" + filler + \" |\\n\" + s.line + \" | \" + line + \"\\n\" + filler + \" | \" + peg$padEnd(\"\", s.column - 1, \" \") + peg$padEnd(\"\", hatLen, \"^\");\n } else {\n str += \"\\n at \" + loc;\n }\n }\n return str;\n };\n peg$SyntaxError.buildMessage = function(expected, found) {\n var DESCRIBE_EXPECTATION_FNS = {\n literal: function(expectation) {\n return '\"' + literalEscape(expectation.text) + '\"';\n },\n class: function(expectation) {\n var escapedParts = expectation.parts.map(function(part) {\n return Array.isArray(part) ? classEscape(part[0]) + \"-\" + classEscape(part[1]) : classEscape(part);\n });\n return \"[\" + (expectation.inverted ? \"^\" : \"\") + escapedParts.join(\"\") + \"]\";\n },\n any: function() {\n return \"any character\";\n },\n end: function() {\n return \"end of input\";\n },\n other: function(expectation) {\n return expectation.description;\n }\n };\n function hex(ch) {\n return ch.charCodeAt(0).toString(16).toUpperCase();\n }\n function literalEscape(s) {\n return s.replace(/\\\\/g, \"\\\\\\\\\").replace(/\"/g, '\\\\\"').replace(/\\0/g, \"\\\\0\").replace(/\\t/g, \"\\\\t\").replace(/\\n/g, \"\\\\n\").replace(/\\r/g, \"\\\\r\").replace(/[\\x00-\\x0F]/g, function(ch) {\n return \"\\\\x0\" + hex(ch);\n }).replace(/[\\x10-\\x1F\\x7F-\\x9F]/g, function(ch) {\n return \"\\\\x\" + hex(ch);\n });\n }\n function classEscape(s) {\n return s.replace(/\\\\/g, \"\\\\\\\\\").replace(/\\]/g, \"\\\\]\").replace(/\\^/g, \"\\\\^\").replace(/-/g, \"\\\\-\").replace(/\\0/g, \"\\\\0\").replace(/\\t/g, \"\\\\t\").replace(/\\n/g, \"\\\\n\").replace(/\\r/g, \"\\\\r\").replace(/[\\x00-\\x0F]/g, function(ch) {\n return \"\\\\x0\" + hex(ch);\n }).replace(/[\\x10-\\x1F\\x7F-\\x9F]/g, function(ch) {\n return \"\\\\x\" + hex(ch);\n });\n }\n function describeExpectation(expectation) {\n return DESCRIBE_EXPECTATION_FNS[expectation.type](expectation);\n }\n function describeExpected(expected2) {\n var descriptions = expected2.map(describeExpectation);\n var i, j;\n descriptions.sort();\n if (descriptions.length > 0) {\n for (i = 1, j = 1; i < descriptions.length; i++) {\n if (descriptions[i - 1] !== descriptions[i]) {\n descriptions[j] = descriptions[i];\n j++;\n }\n }\n descriptions.length = j;\n }\n switch (descriptions.length) {\n case 1:\n return descriptions[0];\n case 2:\n return descriptions[0] + \" or \" + descriptions[1];\n default:\n return descriptions.slice(0, -1).join(\", \") + \", or \" + descriptions[descriptions.length - 1];\n }\n }\n function describeFound(found2) {\n return found2 ? '\"' + literalEscape(found2) + '\"' : \"end of input\";\n }\n return \"Expected \" + describeExpected(expected) + \" but \" + describeFound(found) + \" found.\";\n };\n function peg$parse(input, options) {\n options = options !== void 0 ? options : {};\n var peg$FAILED = {};\n var peg$source = options.grammarSource;\n var peg$startRuleFunctions = { body: peg$parsebody };\n var peg$startRuleFunction = peg$parsebody;\n var peg$e0 = peg$anyExpectation();\n var peg$f0 = function() {\n return [];\n };\n var peg$f1 = function(x) {\n return { cells: [], colSeps: [], ...x };\n };\n var peg$f2 = function(rowItems, rowSep, trailingComment) {\n return { ...rowItems, rowSep, trailingComment };\n };\n var peg$f3 = function(rowItems, trailingComment) {\n return { ...rowItems, rowSep: null, trailingComment };\n };\n var peg$f4 = function(x) {\n return x;\n };\n var peg$f5 = function(x) {\n return {\n cells: [],\n colSeps: [],\n rowSep: null,\n trailingComment: x\n };\n };\n var peg$f6 = function(x) {\n return x;\n };\n var peg$f7 = function(colSep, cell) {\n return { colSep, cell };\n };\n var peg$f8 = function(colSep) {\n return { colSep };\n };\n var peg$f9 = function(a, b) {\n return processRow(a, b);\n };\n var peg$f10 = function(b) {\n return processRow(null, b);\n };\n var peg$f11 = function(tok) {\n return options.isSameLineComment(tok);\n };\n var peg$f12 = function(tok) {\n return tok;\n };\n var peg$f13 = function(tok) {\n return options.isOwnLineComment(tok);\n };\n var peg$f14 = function(tok) {\n return tok;\n };\n var peg$f15 = function(tok) {\n return options.isWhitespace(tok);\n };\n var peg$f16 = function(tok) {\n return tok;\n };\n var peg$f17 = function(tok) {\n return options.isRowSep(tok);\n };\n var peg$f18 = function(tok) {\n return tok;\n };\n var peg$f19 = function(tok) {\n return options.isColSep(tok);\n };\n var peg$f20 = function(tok) {\n return tok;\n };\n var peg$currPos = 0;\n var peg$savedPos = 0;\n var peg$posDetailsCache = [{ line: 1, column: 1 }];\n var peg$maxFailPos = 0;\n var peg$maxFailExpected = [];\n var peg$silentFails = 0;\n var peg$result;\n if (\"startRule\" in options) {\n if (!(options.startRule in peg$startRuleFunctions)) {\n throw new Error(`Can't start parsing from rule \"` + options.startRule + '\".');\n }\n peg$startRuleFunction = peg$startRuleFunctions[options.startRule];\n }\n function text() {\n return input.substring(peg$savedPos, peg$currPos);\n }\n function offset() {\n return peg$savedPos;\n }\n function range() {\n return {\n source: peg$source,\n start: peg$savedPos,\n end: peg$currPos\n };\n }\n function location() {\n return peg$computeLocation(peg$savedPos, peg$currPos);\n }\n function expected(description, location2) {\n location2 = location2 !== void 0 ? location2 : peg$computeLocation(peg$savedPos, peg$currPos);\n throw peg$buildStructuredError(\n [peg$otherExpectation(description)],\n input.substring(peg$savedPos, peg$currPos),\n location2\n );\n }\n function error(message, location2) {\n location2 = location2 !== void 0 ? location2 : peg$computeLocation(peg$savedPos, peg$currPos);\n throw peg$buildSimpleError(message, location2);\n }\n function peg$literalExpectation(text2, ignoreCase) {\n return { type: \"literal\", text: text2, ignoreCase };\n }\n function peg$classExpectation(parts, inverted, ignoreCase) {\n return { type: \"class\", parts, inverted, ignoreCase };\n }\n function peg$anyExpectation() {\n return { type: \"any\" };\n }\n function peg$endExpectation() {\n return { type: \"end\" };\n }\n function peg$otherExpectation(description) {\n return { type: \"other\", description };\n }\n function peg$computePosDetails(pos) {\n var details = peg$posDetailsCache[pos];\n var p;\n if (details) {\n return details;\n } else {\n p = pos - 1;\n while (!peg$posDetailsCache[p]) {\n p--;\n }\n details = peg$posDetailsCache[p];\n details = {\n line: details.line,\n column: details.column\n };\n while (p < pos) {\n if (input.charCodeAt(p) === 10) {\n details.line++;\n details.column = 1;\n } else {\n details.column++;\n }\n p++;\n }\n peg$posDetailsCache[pos] = details;\n return details;\n }\n }\n function peg$computeLocation(startPos, endPos) {\n var startPosDetails = peg$computePosDetails(startPos);\n var endPosDetails = peg$computePosDetails(endPos);\n return {\n source: peg$source,\n start: {\n offset: startPos,\n line: startPosDetails.line,\n column: startPosDetails.column\n },\n end: {\n offset: endPos,\n line: endPosDetails.line,\n column: endPosDetails.column\n }\n };\n }\n function peg$fail(expected2) {\n if (peg$currPos < peg$maxFailPos) {\n return;\n }\n if (peg$currPos > peg$maxFailPos) {\n peg$maxFailPos = peg$currPos;\n peg$maxFailExpected = [];\n }\n peg$maxFailExpected.push(expected2);\n }\n function peg$buildSimpleError(message, location2) {\n return new peg$SyntaxError(message, null, null, location2);\n }\n function peg$buildStructuredError(expected2, found, location2) {\n return new peg$SyntaxError(\n peg$SyntaxError.buildMessage(expected2, found),\n expected2,\n found,\n location2\n );\n }\n function peg$parsebody() {\n var s0, s1;\n s0 = [];\n s1 = peg$parsecomment_only_line();\n if (s1 === peg$FAILED) {\n s1 = peg$parserow_with_end();\n if (s1 === peg$FAILED) {\n s1 = peg$parserow_without_end();\n }\n }\n if (s1 !== peg$FAILED) {\n while (s1 !== peg$FAILED) {\n s0.push(s1);\n s1 = peg$parsecomment_only_line();\n if (s1 === peg$FAILED) {\n s1 = peg$parserow_with_end();\n if (s1 === peg$FAILED) {\n s1 = peg$parserow_without_end();\n }\n }\n }\n } else {\n s0 = peg$FAILED;\n }\n if (s0 === peg$FAILED) {\n s0 = peg$currPos;\n s1 = peg$parseEOL();\n if (s1 !== peg$FAILED) {\n peg$savedPos = s0;\n s1 = peg$f0();\n }\n s0 = s1;\n }\n return s0;\n }\n function peg$parserow_with_end() {\n var s0, s1, s2, s3;\n s0 = peg$currPos;\n s1 = peg$currPos;\n s2 = peg$parserow_items();\n if (s2 === peg$FAILED) {\n s2 = null;\n }\n peg$savedPos = s1;\n s2 = peg$f1(s2);\n s1 = s2;\n s2 = peg$parserow_sep();\n if (s2 !== peg$FAILED) {\n s3 = peg$parsetrailing_comment();\n if (s3 === peg$FAILED) {\n s3 = null;\n }\n peg$savedPos = s0;\n s0 = peg$f2(s1, s2, s3);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parserow_without_end() {\n var s0, s1, s2;\n s0 = peg$currPos;\n s1 = peg$parserow_items();\n if (s1 !== peg$FAILED) {\n s2 = peg$parsetrailing_comment();\n if (s2 === peg$FAILED) {\n s2 = null;\n }\n peg$savedPos = s0;\n s0 = peg$f3(s1, s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parsetrailing_comment() {\n var s0, s1, s2;\n s0 = peg$currPos;\n s1 = [];\n s2 = peg$parsewhitespace();\n while (s2 !== peg$FAILED) {\n s1.push(s2);\n s2 = peg$parsewhitespace();\n }\n s2 = peg$parsesame_line_comment();\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f4(s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parsecomment_only_line() {\n var s0, s1, s2;\n s0 = peg$currPos;\n s1 = [];\n s2 = peg$parsewhitespace();\n while (s2 !== peg$FAILED) {\n s1.push(s2);\n s2 = peg$parsewhitespace();\n }\n s2 = peg$parseown_line_comment();\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f5(s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parsetoken() {\n var s0, s1, s2;\n s0 = peg$currPos;\n s1 = peg$currPos;\n peg$silentFails++;\n s2 = peg$parserow_sep();\n if (s2 === peg$FAILED) {\n s2 = peg$parsecol_sep();\n if (s2 === peg$FAILED) {\n s2 = peg$parsetrailing_comment();\n if (s2 === peg$FAILED) {\n s2 = peg$parseown_line_comment();\n }\n }\n }\n peg$silentFails--;\n if (s2 === peg$FAILED) {\n s1 = void 0;\n } else {\n peg$currPos = s1;\n s1 = peg$FAILED;\n }\n if (s1 !== peg$FAILED) {\n if (input.length > peg$currPos) {\n s2 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s2 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f6(s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parsecell() {\n var s0, s1, s2;\n s0 = peg$currPos;\n s1 = [];\n s2 = peg$parsetoken();\n if (s2 !== peg$FAILED) {\n while (s2 !== peg$FAILED) {\n s1.push(s2);\n s2 = peg$parsetoken();\n }\n } else {\n s1 = peg$FAILED;\n }\n if (s1 !== peg$FAILED) {\n s0 = input.substring(s0, peg$currPos);\n } else {\n s0 = s1;\n }\n return s0;\n }\n function peg$parseseparated_cell() {\n var s0, s1, s2;\n s0 = peg$currPos;\n s1 = peg$parsecol_sep();\n if (s1 !== peg$FAILED) {\n s2 = peg$parsecell();\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f7(s1, s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n if (s0 === peg$FAILED) {\n s0 = peg$currPos;\n s1 = peg$parsecol_sep();\n if (s1 !== peg$FAILED) {\n peg$savedPos = s0;\n s1 = peg$f8(s1);\n }\n s0 = s1;\n }\n return s0;\n }\n function peg$parserow_items() {\n var s0, s1, s2, s3;\n s0 = peg$currPos;\n s1 = peg$parsecell();\n if (s1 !== peg$FAILED) {\n s2 = [];\n s3 = peg$parseseparated_cell();\n while (s3 !== peg$FAILED) {\n s2.push(s3);\n s3 = peg$parseseparated_cell();\n }\n peg$savedPos = s0;\n s0 = peg$f9(s1, s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n if (s0 === peg$FAILED) {\n s0 = peg$currPos;\n s1 = [];\n s2 = peg$parseseparated_cell();\n if (s2 !== peg$FAILED) {\n while (s2 !== peg$FAILED) {\n s1.push(s2);\n s2 = peg$parseseparated_cell();\n }\n } else {\n s1 = peg$FAILED;\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = s0;\n s1 = peg$f10(s1);\n }\n s0 = s1;\n }\n return s0;\n }\n function peg$parsesame_line_comment() {\n var s0, s1, s2;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f11(s1);\n if (s2) {\n s2 = void 0;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f12(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parseown_line_comment() {\n var s0, s1, s2;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f13(s1);\n if (s2) {\n s2 = void 0;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f14(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parsewhitespace() {\n var s0, s1, s2;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f15(s1);\n if (s2) {\n s2 = void 0;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f16(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parserow_sep() {\n var s0, s1, s2;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f17(s1);\n if (s2) {\n s2 = void 0;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f18(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parsecol_sep() {\n var s0, s1, s2;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f19(s1);\n if (s2) {\n s2 = void 0;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f20(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parseEOL() {\n var s0, s1;\n s0 = peg$currPos;\n peg$silentFails++;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n peg$silentFails--;\n if (s1 === peg$FAILED) {\n s0 = void 0;\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function processRow(leadCell, otherCells) {\n const cells = [leadCell || []];\n const seps = [];\n for (const x of otherCells) {\n cells.push(x.cell || []);\n seps.push(x.colSep);\n }\n return { cells, colSeps: seps };\n }\n if (!options.isWhitespace) {\n try {\n Object.assign(\n options,\n createMatchers([\"\\\\\", \"hline\", \"cr\"], [\"&\"])\n );\n } catch (e) {\n console.warn(\"Error when initializing parser\", e);\n }\n }\n peg$result = peg$startRuleFunction();\n if (peg$result !== peg$FAILED && peg$currPos === input.length) {\n return peg$result;\n } else {\n if (peg$result !== peg$FAILED && peg$currPos < input.length) {\n peg$fail(peg$endExpectation());\n }\n throw peg$buildStructuredError(\n peg$maxFailExpected,\n peg$maxFailPos < input.length ? input.charAt(peg$maxFailPos) : null,\n peg$maxFailPos < input.length ? peg$computeLocation(peg$maxFailPos, peg$maxFailPos + 1) : peg$computeLocation(peg$maxFailPos, peg$maxFailPos)\n );\n }\n }\n return {\n SyntaxError: peg$SyntaxError,\n parse: peg$parse\n };\n }()\n);\n\n// grammars/xparse-argspec.pegjs\nvar xparse_argspec_default = (\n // Generated by Peggy 2.0.1.\n //\n // https://peggyjs.org/\n function() {\n \"use strict\";\n function peg$subclass(child, parent) {\n function C() {\n this.constructor = child;\n }\n C.prototype = parent.prototype;\n child.prototype = new C();\n }\n function peg$SyntaxError(message, expected, found, location) {\n var self = Error.call(this, message);\n if (Object.setPrototypeOf) {\n Object.setPrototypeOf(self, peg$SyntaxError.prototype);\n }\n self.expected = expected;\n self.found = found;\n self.location = location;\n self.name = \"SyntaxError\";\n return self;\n }\n peg$subclass(peg$SyntaxError, Error);\n function peg$padEnd(str, targetLength, padString) {\n padString = padString || \" \";\n if (str.length > targetLength) {\n return str;\n }\n targetLength -= str.length;\n padString += padString.repeat(targetLength);\n return str + padString.slice(0, targetLength);\n }\n peg$SyntaxError.prototype.format = function(sources) {\n var str = \"Error: \" + this.message;\n if (this.location) {\n var src = null;\n var k;\n for (k = 0; k < sources.length; k++) {\n if (sources[k].source === this.location.source) {\n src = sources[k].text.split(/\\r\\n|\\n|\\r/g);\n break;\n }\n }\n var s = this.location.start;\n var loc = this.location.source + \":\" + s.line + \":\" + s.column;\n if (src) {\n var e = this.location.end;\n var filler = peg$padEnd(\"\", s.line.toString().length, \" \");\n var line = src[s.line - 1];\n var last = s.line === e.line ? e.column : line.length + 1;\n var hatLen = last - s.column || 1;\n str += \"\\n --> \" + loc + \"\\n\" + filler + \" |\\n\" + s.line + \" | \" + line + \"\\n\" + filler + \" | \" + peg$padEnd(\"\", s.column - 1, \" \") + peg$padEnd(\"\", hatLen, \"^\");\n } else {\n str += \"\\n at \" + loc;\n }\n }\n return str;\n };\n peg$SyntaxError.buildMessage = function(expected, found) {\n var DESCRIBE_EXPECTATION_FNS = {\n literal: function(expectation) {\n return '\"' + literalEscape(expectation.text) + '\"';\n },\n class: function(expectation) {\n var escapedParts = expectation.parts.map(function(part) {\n return Array.isArray(part) ? classEscape(part[0]) + \"-\" + classEscape(part[1]) : classEscape(part);\n });\n return \"[\" + (expectation.inverted ? \"^\" : \"\") + escapedParts.join(\"\") + \"]\";\n },\n any: function() {\n return \"any character\";\n },\n end: function() {\n return \"end of input\";\n },\n other: function(expectation) {\n return expectation.description;\n }\n };\n function hex(ch) {\n return ch.charCodeAt(0).toString(16).toUpperCase();\n }\n function literalEscape(s) {\n return s.replace(/\\\\/g, \"\\\\\\\\\").replace(/\"/g, '\\\\\"').replace(/\\0/g, \"\\\\0\").replace(/\\t/g, \"\\\\t\").replace(/\\n/g, \"\\\\n\").replace(/\\r/g, \"\\\\r\").replace(/[\\x00-\\x0F]/g, function(ch) {\n return \"\\\\x0\" + hex(ch);\n }).replace(/[\\x10-\\x1F\\x7F-\\x9F]/g, function(ch) {\n return \"\\\\x\" + hex(ch);\n });\n }\n function classEscape(s) {\n return s.replace(/\\\\/g, \"\\\\\\\\\").replace(/\\]/g, \"\\\\]\").replace(/\\^/g, \"\\\\^\").replace(/-/g, \"\\\\-\").replace(/\\0/g, \"\\\\0\").replace(/\\t/g, \"\\\\t\").replace(/\\n/g, \"\\\\n\").replace(/\\r/g, \"\\\\r\").replace(/[\\x00-\\x0F]/g, function(ch) {\n return \"\\\\x0\" + hex(ch);\n }).replace(/[\\x10-\\x1F\\x7F-\\x9F]/g, function(ch) {\n return \"\\\\x\" + hex(ch);\n });\n }\n function describeExpectation(expectation) {\n return DESCRIBE_EXPECTATION_FNS[expectation.type](expectation);\n }\n function describeExpected(expected2) {\n var descriptions = expected2.map(describeExpectation);\n var i, j;\n descriptions.sort();\n if (descriptions.length > 0) {\n for (i = 1, j = 1; i < descriptions.length; i++) {\n if (descriptions[i - 1] !== descriptions[i]) {\n descriptions[j] = descriptions[i];\n j++;\n }\n }\n descriptions.length = j;\n }\n switch (descriptions.length) {\n case 1:\n return descriptions[0];\n case 2:\n return descriptions[0] + \" or \" + descriptions[1];\n default:\n return descriptions.slice(0, -1).join(\", \") + \", or \" + descriptions[descriptions.length - 1];\n }\n }\n function describeFound(found2) {\n return found2 ? '\"' + literalEscape(found2) + '\"' : \"end of input\";\n }\n return \"Expected \" + describeExpected(expected) + \" but \" + describeFound(found) + \" found.\";\n };\n function peg$parse(input, options) {\n options = options !== void 0 ? options : {};\n var peg$FAILED = {};\n var peg$source = options.grammarSource;\n var peg$startRuleFunctions = { args_spec_list: peg$parseargs_spec_list };\n var peg$startRuleFunction = peg$parseargs_spec_list;\n var peg$c0 = \"+\";\n var peg$c1 = \"v\";\n var peg$c2 = \"b\";\n var peg$c3 = \"!\";\n var peg$c4 = \"D\";\n var peg$c5 = \"d\";\n var peg$c6 = \"s\";\n var peg$c7 = \"O\";\n var peg$c8 = \"o\";\n var peg$c9 = \"e\";\n var peg$c10 = \"E\";\n var peg$c11 = \"t\";\n var peg$c12 = \"R\";\n var peg$c13 = \"r\";\n var peg$c14 = \"u\";\n var peg$c15 = \"m\";\n var peg$c16 = \"{\";\n var peg$c17 = \"}\";\n var peg$c18 = \" \";\n var peg$c19 = \"\\n\";\n var peg$c20 = \"\\r\";\n var peg$r0 = /^[{ ]/;\n var peg$e0 = peg$literalExpectation(\"+\", false);\n var peg$e1 = peg$literalExpectation(\"v\", false);\n var peg$e2 = peg$anyExpectation();\n var peg$e3 = peg$literalExpectation(\"b\", false);\n var peg$e4 = peg$literalExpectation(\"!\", false);\n var peg$e5 = peg$literalExpectation(\"D\", false);\n var peg$e6 = peg$literalExpectation(\"d\", false);\n var peg$e7 = peg$literalExpectation(\"s\", false);\n var peg$e8 = peg$literalExpectation(\"O\", false);\n var peg$e9 = peg$literalExpectation(\"o\", false);\n var peg$e10 = peg$literalExpectation(\"e\", false);\n var peg$e11 = peg$literalExpectation(\"E\", false);\n var peg$e12 = peg$literalExpectation(\"t\", false);\n var peg$e13 = peg$literalExpectation(\"R\", false);\n var peg$e14 = peg$literalExpectation(\"r\", false);\n var peg$e15 = peg$literalExpectation(\"u\", false);\n var peg$e16 = peg$classExpectation([\"{\", \" \"], false, false);\n var peg$e17 = peg$literalExpectation(\"m\", false);\n var peg$e18 = peg$literalExpectation(\"{\", false);\n var peg$e19 = peg$literalExpectation(\"}\", false);\n var peg$e20 = peg$literalExpectation(\" \", false);\n var peg$e21 = peg$literalExpectation(\"\\n\", false);\n var peg$e22 = peg$literalExpectation(\"\\r\", false);\n var peg$f0 = function(x) {\n return x;\n };\n var peg$f1 = function(spec) {\n return spec;\n };\n var peg$f2 = function(spec) {\n return spec;\n };\n var peg$f3 = function(openBrace) {\n return createNode(\"verbatim\", { openBrace, closeBrace: openBrace });\n };\n var peg$f4 = function() {\n return createNode(\"body\");\n };\n var peg$f5 = function(leading_bang, spec) {\n return leading_bang ? { ...spec, noLeadingWhitespace: true } : spec;\n };\n var peg$f6 = function(braceSpec, defaultArg) {\n return createNode(\"optional\", { ...braceSpec, defaultArg });\n };\n var peg$f7 = function(braceSpec) {\n return createNode(\"optional\", braceSpec);\n };\n var peg$f8 = function() {\n return createNode(\"optionalStar\");\n };\n var peg$f9 = function(g) {\n return createNode(\"optional\", { defaultArg: g });\n };\n var peg$f10 = function() {\n return createNode(\"optional\");\n };\n var peg$f11 = function(args) {\n return createNode(\"embellishment\", {\n embellishmentTokens: args.content\n });\n };\n var peg$f12 = function(args, g) {\n return createNode(\"embellishment\", {\n embellishmentTokens: args.content,\n defaultArg: g\n });\n };\n var peg$f13 = function(tok) {\n return createNode(\"optionalToken\", { token: tok });\n };\n var peg$f14 = function(braceSpec, defaultArg) {\n return createNode(\"mandatory\", { ...braceSpec, defaultArg });\n };\n var peg$f15 = function(braceSpec) {\n return createNode(\"mandatory\", braceSpec);\n };\n var peg$f16 = function(stopTokens) {\n return createNode(\"until\", { stopTokens });\n };\n var peg$f17 = function(x) {\n return [x];\n };\n var peg$f18 = function(g) {\n return g.content;\n };\n var peg$f19 = function() {\n return createNode(\"mandatory\");\n };\n var peg$f20 = function(openBrace, closeBrace) {\n return { openBrace, closeBrace };\n };\n var peg$f21 = function(content) {\n return { type: \"group\", content };\n };\n var peg$f22 = function() {\n return \"\";\n };\n var peg$currPos = 0;\n var peg$savedPos = 0;\n var peg$posDetailsCache = [{ line: 1, column: 1 }];\n var peg$maxFailPos = 0;\n var peg$maxFailExpected = [];\n var peg$silentFails = 0;\n var peg$result;\n if (\"startRule\" in options) {\n if (!(options.startRule in peg$startRuleFunctions)) {\n throw new Error(`Can't start parsing from rule \"` + options.startRule + '\".');\n }\n peg$startRuleFunction = peg$startRuleFunctions[options.startRule];\n }\n function text() {\n return input.substring(peg$savedPos, peg$currPos);\n }\n function offset() {\n return peg$savedPos;\n }\n function range() {\n return {\n source: peg$source,\n start: peg$savedPos,\n end: peg$currPos\n };\n }\n function location() {\n return peg$computeLocation(peg$savedPos, peg$currPos);\n }\n function expected(description, location2) {\n location2 = location2 !== void 0 ? location2 : peg$computeLocation(peg$savedPos, peg$currPos);\n throw peg$buildStructuredError(\n [peg$otherExpectation(description)],\n input.substring(peg$savedPos, peg$currPos),\n location2\n );\n }\n function error(message, location2) {\n location2 = location2 !== void 0 ? location2 : peg$computeLocation(peg$savedPos, peg$currPos);\n throw peg$buildSimpleError(message, location2);\n }\n function peg$literalExpectation(text2, ignoreCase) {\n return { type: \"literal\", text: text2, ignoreCase };\n }\n function peg$classExpectation(parts, inverted, ignoreCase) {\n return { type: \"class\", parts, inverted, ignoreCase };\n }\n function peg$anyExpectation() {\n return { type: \"any\" };\n }\n function peg$endExpectation() {\n return { type: \"end\" };\n }\n function peg$otherExpectation(description) {\n return { type: \"other\", description };\n }\n function peg$computePosDetails(pos) {\n var details = peg$posDetailsCache[pos];\n var p;\n if (details) {\n return details;\n } else {\n p = pos - 1;\n while (!peg$posDetailsCache[p]) {\n p--;\n }\n details = peg$posDetailsCache[p];\n details = {\n line: details.line,\n column: details.column\n };\n while (p < pos) {\n if (input.charCodeAt(p) === 10) {\n details.line++;\n details.column = 1;\n } else {\n details.column++;\n }\n p++;\n }\n peg$posDetailsCache[pos] = details;\n return details;\n }\n }\n function peg$computeLocation(startPos, endPos) {\n var startPosDetails = peg$computePosDetails(startPos);\n var endPosDetails = peg$computePosDetails(endPos);\n return {\n source: peg$source,\n start: {\n offset: startPos,\n line: startPosDetails.line,\n column: startPosDetails.column\n },\n end: {\n offset: endPos,\n line: endPosDetails.line,\n column: endPosDetails.column\n }\n };\n }\n function peg$fail(expected2) {\n if (peg$currPos < peg$maxFailPos) {\n return;\n }\n if (peg$currPos > peg$maxFailPos) {\n peg$maxFailPos = peg$currPos;\n peg$maxFailExpected = [];\n }\n peg$maxFailExpected.push(expected2);\n }\n function peg$buildSimpleError(message, location2) {\n return new peg$SyntaxError(message, null, null, location2);\n }\n function peg$buildStructuredError(expected2, found, location2) {\n return new peg$SyntaxError(\n peg$SyntaxError.buildMessage(expected2, found),\n expected2,\n found,\n location2\n );\n }\n function peg$parseargs_spec_list() {\n var s0, s1, s2, s3, s4;\n s0 = peg$currPos;\n s1 = [];\n s2 = peg$currPos;\n s3 = peg$parsewhitespace();\n s4 = peg$parsearg_spec();\n if (s4 !== peg$FAILED) {\n peg$savedPos = s2;\n s2 = peg$f0(s4);\n } else {\n peg$currPos = s2;\n s2 = peg$FAILED;\n }\n while (s2 !== peg$FAILED) {\n s1.push(s2);\n s2 = peg$currPos;\n s3 = peg$parsewhitespace();\n s4 = peg$parsearg_spec();\n if (s4 !== peg$FAILED) {\n peg$savedPos = s2;\n s2 = peg$f0(s4);\n } else {\n peg$currPos = s2;\n s2 = peg$FAILED;\n }\n }\n s2 = peg$parsewhitespace();\n peg$savedPos = s0;\n s0 = peg$f1(s1);\n return s0;\n }\n function peg$parsearg_spec() {\n var s0, s1, s2;\n s0 = peg$currPos;\n if (input.charCodeAt(peg$currPos) === 43) {\n s1 = peg$c0;\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n if (s1 === peg$FAILED) {\n s1 = null;\n }\n s2 = peg$parseoptional();\n if (s2 === peg$FAILED) {\n s2 = peg$parsemandatory();\n if (s2 === peg$FAILED) {\n s2 = peg$parseverbatim();\n if (s2 === peg$FAILED) {\n s2 = peg$parserequired();\n if (s2 === peg$FAILED) {\n s2 = peg$parsebody();\n if (s2 === peg$FAILED) {\n s2 = peg$parseuntil();\n }\n }\n }\n }\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f2(s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parseverbatim() {\n var s0, s1, s2;\n s0 = peg$currPos;\n if (input.charCodeAt(peg$currPos) === 118) {\n s1 = peg$c1;\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e1);\n }\n }\n if (s1 !== peg$FAILED) {\n if (input.length > peg$currPos) {\n s2 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s2 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e2);\n }\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f3(s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parsebody() {\n var s0, s1;\n s0 = peg$currPos;\n if (input.charCodeAt(peg$currPos) === 98) {\n s1 = peg$c2;\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e3);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = s0;\n s1 = peg$f4();\n }\n s0 = s1;\n return s0;\n }\n function peg$parseoptional() {\n var s0, s1, s2;\n s0 = peg$currPos;\n if (input.charCodeAt(peg$currPos) === 33) {\n s1 = peg$c3;\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e4);\n }\n }\n if (s1 === peg$FAILED) {\n s1 = null;\n }\n s2 = peg$parseoptional_star();\n if (s2 === peg$FAILED) {\n s2 = peg$parseoptional_standard();\n if (s2 === peg$FAILED) {\n s2 = peg$parseoptional_delimited();\n if (s2 === peg$FAILED) {\n s2 = peg$parseoptional_embellishment();\n if (s2 === peg$FAILED) {\n s2 = peg$parseoptional_token();\n }\n }\n }\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f5(s1, s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parseoptional_delimited() {\n var s0, s1, s2, s3;\n s0 = peg$currPos;\n if (input.charCodeAt(peg$currPos) === 68) {\n s1 = peg$c4;\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e5);\n }\n }\n if (s1 !== peg$FAILED) {\n s2 = peg$parsebrace_spec();\n s3 = peg$parsebraced_group();\n if (s3 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f6(s2, s3);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n if (s0 === peg$FAILED) {\n s0 = peg$currPos;\n if (input.charCodeAt(peg$currPos) === 100) {\n s1 = peg$c5;\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e6);\n }\n }\n if (s1 !== peg$FAILED) {\n s2 = peg$parsebrace_spec();\n peg$savedPos = s0;\n s0 = peg$f7(s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n }\n return s0;\n }\n function peg$parseoptional_star() {\n var s0, s1;\n s0 = peg$currPos;\n if (input.charCodeAt(peg$currPos) === 115) {\n s1 = peg$c6;\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e7);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = s0;\n s1 = peg$f8();\n }\n s0 = s1;\n return s0;\n }\n function peg$parseoptional_standard() {\n var s0, s1, s2;\n s0 = peg$currPos;\n if (input.charCodeAt(peg$currPos) === 79) {\n s1 = peg$c7;\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e8);\n }\n }\n if (s1 !== peg$FAILED) {\n s2 = peg$parsebraced_group();\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f9(s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n if (s0 === peg$FAILED) {\n s0 = peg$currPos;\n if (input.charCodeAt(peg$currPos) === 111) {\n s1 = peg$c8;\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e9);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = s0;\n s1 = peg$f10();\n }\n s0 = s1;\n }\n return s0;\n }\n function peg$parseoptional_embellishment() {\n var s0, s1, s2, s3;\n s0 = peg$currPos;\n if (input.charCodeAt(peg$currPos) === 101) {\n s1 = peg$c9;\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e10);\n }\n }\n if (s1 !== peg$FAILED) {\n s2 = peg$parsebraced_group();\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f11(s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n if (s0 === peg$FAILED) {\n s0 = peg$currPos;\n if (input.charCodeAt(peg$currPos) === 69) {\n s1 = peg$c10;\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e11);\n }\n }\n if (s1 !== peg$FAILED) {\n s2 = peg$parsebraced_group();\n if (s2 !== peg$FAILED) {\n s3 = peg$parsebraced_group();\n if (s3 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f12(s2, s3);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n }\n return s0;\n }\n function peg$parseoptional_token() {\n var s0, s1, s2;\n s0 = peg$currPos;\n if (input.charCodeAt(peg$currPos) === 116) {\n s1 = peg$c11;\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e12);\n }\n }\n if (s1 !== peg$FAILED) {\n if (input.length > peg$currPos) {\n s2 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s2 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e2);\n }\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f13(s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parserequired() {\n var s0, s1, s2, s3;\n s0 = peg$currPos;\n if (input.charCodeAt(peg$currPos) === 82) {\n s1 = peg$c12;\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e13);\n }\n }\n if (s1 !== peg$FAILED) {\n s2 = peg$parsebrace_spec();\n s3 = peg$parsebraced_group();\n if (s3 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f14(s2, s3);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n if (s0 === peg$FAILED) {\n s0 = peg$currPos;\n if (input.charCodeAt(peg$currPos) === 114) {\n s1 = peg$c13;\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e14);\n }\n }\n if (s1 !== peg$FAILED) {\n s2 = peg$parsebrace_spec();\n peg$savedPos = s0;\n s0 = peg$f15(s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n }\n return s0;\n }\n function peg$parseuntil() {\n var s0, s1, s2;\n s0 = peg$currPos;\n if (input.charCodeAt(peg$currPos) === 117) {\n s1 = peg$c14;\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e15);\n }\n }\n if (s1 !== peg$FAILED) {\n s2 = peg$parseuntil_stop_token();\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f16(s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parseuntil_stop_token() {\n var s0, s1, s2;\n s0 = peg$currPos;\n s1 = peg$currPos;\n peg$silentFails++;\n if (peg$r0.test(input.charAt(peg$currPos))) {\n s2 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s2 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e16);\n }\n }\n peg$silentFails--;\n if (s2 === peg$FAILED) {\n s1 = void 0;\n } else {\n peg$currPos = s1;\n s1 = peg$FAILED;\n }\n if (s1 !== peg$FAILED) {\n if (input.length > peg$currPos) {\n s2 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s2 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e2);\n }\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f17(s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n if (s0 === peg$FAILED) {\n s0 = peg$currPos;\n s1 = peg$parsebraced_group();\n if (s1 !== peg$FAILED) {\n peg$savedPos = s0;\n s1 = peg$f18(s1);\n }\n s0 = s1;\n }\n return s0;\n }\n function peg$parsemandatory() {\n var s0, s1;\n s0 = peg$currPos;\n if (input.charCodeAt(peg$currPos) === 109) {\n s1 = peg$c15;\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e17);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = s0;\n s1 = peg$f19();\n }\n s0 = s1;\n return s0;\n }\n function peg$parsebrace_spec() {\n var s0, s1, s2, s3, s4, s5;\n s0 = peg$currPos;\n s1 = peg$currPos;\n s2 = peg$currPos;\n s3 = peg$currPos;\n peg$silentFails++;\n s4 = peg$parsewhitespace_token();\n peg$silentFails--;\n if (s4 === peg$FAILED) {\n s3 = void 0;\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n if (s3 !== peg$FAILED) {\n if (input.length > peg$currPos) {\n s4 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s4 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e2);\n }\n }\n if (s4 !== peg$FAILED) {\n s3 = [s3, s4];\n s2 = s3;\n } else {\n peg$currPos = s2;\n s2 = peg$FAILED;\n }\n } else {\n peg$currPos = s2;\n s2 = peg$FAILED;\n }\n if (s2 === peg$FAILED) {\n s2 = null;\n }\n s1 = input.substring(s1, peg$currPos);\n s2 = peg$currPos;\n s3 = peg$currPos;\n s4 = peg$currPos;\n peg$silentFails++;\n s5 = peg$parsewhitespace_token();\n peg$silentFails--;\n if (s5 === peg$FAILED) {\n s4 = void 0;\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n if (s4 !== peg$FAILED) {\n if (input.length > peg$currPos) {\n s5 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s5 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e2);\n }\n }\n if (s5 !== peg$FAILED) {\n s4 = [s4, s5];\n s3 = s4;\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n if (s3 === peg$FAILED) {\n s3 = null;\n }\n s2 = input.substring(s2, peg$currPos);\n peg$savedPos = s0;\n s0 = peg$f20(s1, s2);\n return s0;\n }\n function peg$parsebraced_group() {\n var s0, s1, s2, s3, s4, s5, s6, s7;\n s0 = peg$currPos;\n if (input.charCodeAt(peg$currPos) === 123) {\n s1 = peg$c16;\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e18);\n }\n }\n if (s1 !== peg$FAILED) {\n s2 = [];\n s3 = peg$currPos;\n s4 = peg$currPos;\n s5 = peg$currPos;\n peg$silentFails++;\n if (input.charCodeAt(peg$currPos) === 125) {\n s6 = peg$c17;\n peg$currPos++;\n } else {\n s6 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e19);\n }\n }\n peg$silentFails--;\n if (s6 === peg$FAILED) {\n s5 = void 0;\n } else {\n peg$currPos = s5;\n s5 = peg$FAILED;\n }\n if (s5 !== peg$FAILED) {\n s6 = peg$currPos;\n peg$silentFails++;\n s7 = peg$parsebraced_group();\n peg$silentFails--;\n if (s7 === peg$FAILED) {\n s6 = void 0;\n } else {\n peg$currPos = s6;\n s6 = peg$FAILED;\n }\n if (s6 !== peg$FAILED) {\n if (input.length > peg$currPos) {\n s7 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s7 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e2);\n }\n }\n if (s7 !== peg$FAILED) {\n s5 = [s5, s6, s7];\n s4 = s5;\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n if (s4 !== peg$FAILED) {\n s3 = input.substring(s3, peg$currPos);\n } else {\n s3 = s4;\n }\n if (s3 === peg$FAILED) {\n s3 = peg$parsebraced_group();\n }\n while (s3 !== peg$FAILED) {\n s2.push(s3);\n s3 = peg$currPos;\n s4 = peg$currPos;\n s5 = peg$currPos;\n peg$silentFails++;\n if (input.charCodeAt(peg$currPos) === 125) {\n s6 = peg$c17;\n peg$currPos++;\n } else {\n s6 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e19);\n }\n }\n peg$silentFails--;\n if (s6 === peg$FAILED) {\n s5 = void 0;\n } else {\n peg$currPos = s5;\n s5 = peg$FAILED;\n }\n if (s5 !== peg$FAILED) {\n s6 = peg$currPos;\n peg$silentFails++;\n s7 = peg$parsebraced_group();\n peg$silentFails--;\n if (s7 === peg$FAILED) {\n s6 = void 0;\n } else {\n peg$currPos = s6;\n s6 = peg$FAILED;\n }\n if (s6 !== peg$FAILED) {\n if (input.length > peg$currPos) {\n s7 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s7 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e2);\n }\n }\n if (s7 !== peg$FAILED) {\n s5 = [s5, s6, s7];\n s4 = s5;\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n if (s4 !== peg$FAILED) {\n s3 = input.substring(s3, peg$currPos);\n } else {\n s3 = s4;\n }\n if (s3 === peg$FAILED) {\n s3 = peg$parsebraced_group();\n }\n }\n if (input.charCodeAt(peg$currPos) === 125) {\n s3 = peg$c17;\n peg$currPos++;\n } else {\n s3 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e19);\n }\n }\n if (s3 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f21(s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parsewhitespace() {\n var s0, s1, s2;\n s0 = peg$currPos;\n s1 = [];\n s2 = peg$parsewhitespace_token();\n while (s2 !== peg$FAILED) {\n s1.push(s2);\n s2 = peg$parsewhitespace_token();\n }\n peg$savedPos = s0;\n s1 = peg$f22();\n s0 = s1;\n return s0;\n }\n function peg$parsewhitespace_token() {\n var s0;\n if (input.charCodeAt(peg$currPos) === 32) {\n s0 = peg$c18;\n peg$currPos++;\n } else {\n s0 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e20);\n }\n }\n if (s0 === peg$FAILED) {\n if (input.charCodeAt(peg$currPos) === 10) {\n s0 = peg$c19;\n peg$currPos++;\n } else {\n s0 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e21);\n }\n }\n if (s0 === peg$FAILED) {\n if (input.charCodeAt(peg$currPos) === 13) {\n s0 = peg$c20;\n peg$currPos++;\n } else {\n s0 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e22);\n }\n }\n }\n }\n return s0;\n }\n const DEFAULT_OPTIONS = {\n optional: { openBrace: \"[\", closeBrace: \"]\" },\n mandatory: { openBrace: \"{\", closeBrace: \"}\" }\n };\n function createNode(type, options2) {\n const computedOptions = DEFAULT_OPTIONS[type] || {};\n return { type, ...computedOptions, ...options2 };\n }\n peg$result = peg$startRuleFunction();\n if (peg$result !== peg$FAILED && peg$currPos === input.length) {\n return peg$result;\n } else {\n if (peg$result !== peg$FAILED && peg$currPos < input.length) {\n peg$fail(peg$endExpectation());\n }\n throw peg$buildStructuredError(\n peg$maxFailExpected,\n peg$maxFailPos < input.length ? input.charAt(peg$maxFailPos) : null,\n peg$maxFailPos < input.length ? peg$computeLocation(peg$maxFailPos, peg$maxFailPos + 1) : peg$computeLocation(peg$maxFailPos, peg$maxFailPos)\n );\n }\n }\n return {\n SyntaxError: peg$SyntaxError,\n parse: peg$parse\n };\n }()\n);\n\n// grammars/pgfkeys.pegjs\nvar pgfkeys_default = (\n // Generated by Peggy 2.0.1.\n //\n // https://peggyjs.org/\n function() {\n \"use strict\";\n function peg$subclass(child, parent) {\n function C() {\n this.constructor = child;\n }\n C.prototype = parent.prototype;\n child.prototype = new C();\n }\n function peg$SyntaxError(message, expected, found, location) {\n var self = Error.call(this, message);\n if (Object.setPrototypeOf) {\n Object.setPrototypeOf(self, peg$SyntaxError.prototype);\n }\n self.expected = expected;\n self.found = found;\n self.location = location;\n self.name = \"SyntaxError\";\n return self;\n }\n peg$subclass(peg$SyntaxError, Error);\n function peg$padEnd(str, targetLength, padString) {\n padString = padString || \" \";\n if (str.length > targetLength) {\n return str;\n }\n targetLength -= str.length;\n padString += padString.repeat(targetLength);\n return str + padString.slice(0, targetLength);\n }\n peg$SyntaxError.prototype.format = function(sources) {\n var str = \"Error: \" + this.message;\n if (this.location) {\n var src = null;\n var k;\n for (k = 0; k < sources.length; k++) {\n if (sources[k].source === this.location.source) {\n src = sources[k].text.split(/\\r\\n|\\n|\\r/g);\n break;\n }\n }\n var s = this.location.start;\n var loc = this.location.source + \":\" + s.line + \":\" + s.column;\n if (src) {\n var e = this.location.end;\n var filler = peg$padEnd(\"\", s.line.toString().length, \" \");\n var line = src[s.line - 1];\n var last = s.line === e.line ? e.column : line.length + 1;\n var hatLen = last - s.column || 1;\n str += \"\\n --> \" + loc + \"\\n\" + filler + \" |\\n\" + s.line + \" | \" + line + \"\\n\" + filler + \" | \" + peg$padEnd(\"\", s.column - 1, \" \") + peg$padEnd(\"\", hatLen, \"^\");\n } else {\n str += \"\\n at \" + loc;\n }\n }\n return str;\n };\n peg$SyntaxError.buildMessage = function(expected, found) {\n var DESCRIBE_EXPECTATION_FNS = {\n literal: function(expectation) {\n return '\"' + literalEscape(expectation.text) + '\"';\n },\n class: function(expectation) {\n var escapedParts = expectation.parts.map(function(part) {\n return Array.isArray(part) ? classEscape(part[0]) + \"-\" + classEscape(part[1]) : classEscape(part);\n });\n return \"[\" + (expectation.inverted ? \"^\" : \"\") + escapedParts.join(\"\") + \"]\";\n },\n any: function() {\n return \"any character\";\n },\n end: function() {\n return \"end of input\";\n },\n other: function(expectation) {\n return expectation.description;\n }\n };\n function hex(ch) {\n return ch.charCodeAt(0).toString(16).toUpperCase();\n }\n function literalEscape(s) {\n return s.replace(/\\\\/g, \"\\\\\\\\\").replace(/\"/g, '\\\\\"').replace(/\\0/g, \"\\\\0\").replace(/\\t/g, \"\\\\t\").replace(/\\n/g, \"\\\\n\").replace(/\\r/g, \"\\\\r\").replace(/[\\x00-\\x0F]/g, function(ch) {\n return \"\\\\x0\" + hex(ch);\n }).replace(/[\\x10-\\x1F\\x7F-\\x9F]/g, function(ch) {\n return \"\\\\x\" + hex(ch);\n });\n }\n function classEscape(s) {\n return s.replace(/\\\\/g, \"\\\\\\\\\").replace(/\\]/g, \"\\\\]\").replace(/\\^/g, \"\\\\^\").replace(/-/g, \"\\\\-\").replace(/\\0/g, \"\\\\0\").replace(/\\t/g, \"\\\\t\").replace(/\\n/g, \"\\\\n\").replace(/\\r/g, \"\\\\r\").replace(/[\\x00-\\x0F]/g, function(ch) {\n return \"\\\\x0\" + hex(ch);\n }).replace(/[\\x10-\\x1F\\x7F-\\x9F]/g, function(ch) {\n return \"\\\\x\" + hex(ch);\n });\n }\n function describeExpectation(expectation) {\n return DESCRIBE_EXPECTATION_FNS[expectation.type](expectation);\n }\n function describeExpected(expected2) {\n var descriptions = expected2.map(describeExpectation);\n var i, j;\n descriptions.sort();\n if (descriptions.length > 0) {\n for (i = 1, j = 1; i < descriptions.length; i++) {\n if (descriptions[i - 1] !== descriptions[i]) {\n descriptions[j] = descriptions[i];\n j++;\n }\n }\n descriptions.length = j;\n }\n switch (descriptions.length) {\n case 1:\n return descriptions[0];\n case 2:\n return descriptions[0] + \" or \" + descriptions[1];\n default:\n return descriptions.slice(0, -1).join(\", \") + \", or \" + descriptions[descriptions.length - 1];\n }\n }\n function describeFound(found2) {\n return found2 ? '\"' + literalEscape(found2) + '\"' : \"end of input\";\n }\n return \"Expected \" + describeExpected(expected) + \" but \" + describeFound(found) + \" found.\";\n };\n function peg$parse(input, options) {\n options = options !== void 0 ? options : {};\n var peg$FAILED = {};\n var peg$source = options.grammarSource;\n var peg$startRuleFunctions = { body: peg$parsebody };\n var peg$startRuleFunction = peg$parsebody;\n var peg$e0 = peg$anyExpectation();\n var peg$f0 = function() {\n return [];\n };\n var peg$f1 = function(rowItems, trailingComment) {\n return {\n itemParts: [],\n ...rowItems,\n trailingComment,\n trailingComma: true\n };\n };\n var peg$f2 = function(rowItems, trailingComment) {\n return { ...rowItems, trailingComment };\n };\n var peg$f3 = function(a, b) {\n return processItem(a, b);\n };\n var peg$f4 = function(b) {\n return processItem(null, b);\n };\n var peg$f5 = function(cell) {\n return { cell };\n };\n var peg$f6 = function() {\n return {};\n };\n var peg$f7 = function(part) {\n return part;\n };\n var peg$f8 = function(x) {\n return x;\n };\n var peg$f9 = function(space, x) {\n return {\n trailingComment: x,\n leadingParbreak: space.parbreak > 0\n };\n };\n var peg$f10 = function(list) {\n return {\n whitespace: list.filter((x) => options.isWhitespace(x)).length,\n parbreak: list.filter((x) => options.isParbreak(x)).length\n };\n };\n var peg$f11 = function() {\n return !options.allowParenGroups;\n };\n var peg$f12 = function(tok) {\n return options.isSameLineComment(tok);\n };\n var peg$f13 = function(tok) {\n return tok;\n };\n var peg$f14 = function(tok) {\n return options.isOwnLineComment(tok);\n };\n var peg$f15 = function(tok) {\n return tok;\n };\n var peg$f16 = function(tok) {\n return options.isWhitespace(tok);\n };\n var peg$f17 = function(tok) {\n return tok;\n };\n var peg$f18 = function(tok) {\n return options.isParbreak(tok);\n };\n var peg$f19 = function(tok) {\n return tok;\n };\n var peg$f20 = function(tok) {\n return options.isComma(tok);\n };\n var peg$f21 = function(tok) {\n return tok;\n };\n var peg$f22 = function(tok) {\n return options.isEquals(tok);\n };\n var peg$f23 = function(tok) {\n return tok;\n };\n var peg$f24 = function(tok) {\n return options.isChar(tok, \"(\");\n };\n var peg$f25 = function(tok) {\n return tok;\n };\n var peg$f26 = function(tok) {\n return options.isChar(tok, \")\");\n };\n var peg$f27 = function(tok) {\n return tok;\n };\n var peg$currPos = 0;\n var peg$savedPos = 0;\n var peg$posDetailsCache = [{ line: 1, column: 1 }];\n var peg$maxFailPos = 0;\n var peg$maxFailExpected = [];\n var peg$silentFails = 0;\n var peg$result;\n if (\"startRule\" in options) {\n if (!(options.startRule in peg$startRuleFunctions)) {\n throw new Error(`Can't start parsing from rule \"` + options.startRule + '\".');\n }\n peg$startRuleFunction = peg$startRuleFunctions[options.startRule];\n }\n function text() {\n return input.substring(peg$savedPos, peg$currPos);\n }\n function offset() {\n return peg$savedPos;\n }\n function range() {\n return {\n source: peg$source,\n start: peg$savedPos,\n end: peg$currPos\n };\n }\n function location() {\n return peg$computeLocation(peg$savedPos, peg$currPos);\n }\n function expected(description, location2) {\n location2 = location2 !== void 0 ? location2 : peg$computeLocation(peg$savedPos, peg$currPos);\n throw peg$buildStructuredError(\n [peg$otherExpectation(description)],\n input.substring(peg$savedPos, peg$currPos),\n location2\n );\n }\n function error(message, location2) {\n location2 = location2 !== void 0 ? location2 : peg$computeLocation(peg$savedPos, peg$currPos);\n throw peg$buildSimpleError(message, location2);\n }\n function peg$literalExpectation(text2, ignoreCase) {\n return { type: \"literal\", text: text2, ignoreCase };\n }\n function peg$classExpectation(parts, inverted, ignoreCase) {\n return { type: \"class\", parts, inverted, ignoreCase };\n }\n function peg$anyExpectation() {\n return { type: \"any\" };\n }\n function peg$endExpectation() {\n return { type: \"end\" };\n }\n function peg$otherExpectation(description) {\n return { type: \"other\", description };\n }\n function peg$computePosDetails(pos) {\n var details = peg$posDetailsCache[pos];\n var p;\n if (details) {\n return details;\n } else {\n p = pos - 1;\n while (!peg$posDetailsCache[p]) {\n p--;\n }\n details = peg$posDetailsCache[p];\n details = {\n line: details.line,\n column: details.column\n };\n while (p < pos) {\n if (input.charCodeAt(p) === 10) {\n details.line++;\n details.column = 1;\n } else {\n details.column++;\n }\n p++;\n }\n peg$posDetailsCache[pos] = details;\n return details;\n }\n }\n function peg$computeLocation(startPos, endPos) {\n var startPosDetails = peg$computePosDetails(startPos);\n var endPosDetails = peg$computePosDetails(endPos);\n return {\n source: peg$source,\n start: {\n offset: startPos,\n line: startPosDetails.line,\n column: startPosDetails.column\n },\n end: {\n offset: endPos,\n line: endPosDetails.line,\n column: endPosDetails.column\n }\n };\n }\n function peg$fail(expected2) {\n if (peg$currPos < peg$maxFailPos) {\n return;\n }\n if (peg$currPos > peg$maxFailPos) {\n peg$maxFailPos = peg$currPos;\n peg$maxFailExpected = [];\n }\n peg$maxFailExpected.push(expected2);\n }\n function peg$buildSimpleError(message, location2) {\n return new peg$SyntaxError(message, null, null, location2);\n }\n function peg$buildStructuredError(expected2, found, location2) {\n return new peg$SyntaxError(\n peg$SyntaxError.buildMessage(expected2, found),\n expected2,\n found,\n location2\n );\n }\n function peg$parsebody() {\n var s0, s1, s2;\n s0 = [];\n s1 = peg$parsecomment_only_line();\n if (s1 === peg$FAILED) {\n s1 = peg$parseitem_with_end();\n if (s1 === peg$FAILED) {\n s1 = peg$parseitem_without_end();\n }\n }\n if (s1 !== peg$FAILED) {\n while (s1 !== peg$FAILED) {\n s0.push(s1);\n s1 = peg$parsecomment_only_line();\n if (s1 === peg$FAILED) {\n s1 = peg$parseitem_with_end();\n if (s1 === peg$FAILED) {\n s1 = peg$parseitem_without_end();\n }\n }\n }\n } else {\n s0 = peg$FAILED;\n }\n if (s0 === peg$FAILED) {\n s0 = peg$currPos;\n s1 = [];\n s2 = peg$parsewhitespace();\n while (s2 !== peg$FAILED) {\n s1.push(s2);\n s2 = peg$parsewhitespace();\n }\n s2 = peg$parseEOL();\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f0();\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n }\n return s0;\n }\n function peg$parseitem_with_end() {\n var s0, s1, s2, s3, s4, s5, s6, s7, s8;\n s0 = peg$currPos;\n s1 = peg$parsewhitespace_or_parbreaks();\n s2 = peg$parserow_items();\n if (s2 === peg$FAILED) {\n s2 = null;\n }\n s3 = peg$parsewhitespace_or_parbreaks();\n s4 = peg$parseitem_sep();\n if (s4 !== peg$FAILED) {\n s5 = [];\n s6 = peg$parsewhitespace();\n while (s6 !== peg$FAILED) {\n s5.push(s6);\n s6 = peg$parsewhitespace();\n }\n s6 = peg$parsetrailing_comment();\n if (s6 === peg$FAILED) {\n s6 = null;\n }\n s7 = [];\n s8 = peg$parsewhitespace();\n while (s8 !== peg$FAILED) {\n s7.push(s8);\n s8 = peg$parsewhitespace();\n }\n peg$savedPos = s0;\n s0 = peg$f1(s2, s6);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parseitem_without_end() {\n var s0, s1, s2, s3;\n s0 = peg$currPos;\n s1 = peg$parsewhitespace_or_parbreaks();\n s2 = peg$parserow_items();\n if (s2 !== peg$FAILED) {\n s3 = peg$parsetrailing_comment();\n if (s3 === peg$FAILED) {\n s3 = null;\n }\n peg$savedPos = s0;\n s0 = peg$f2(s2, s3);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parserow_items() {\n var s0, s1, s2, s3;\n s0 = peg$currPos;\n s1 = peg$parseitem_part();\n if (s1 !== peg$FAILED) {\n s2 = [];\n s3 = peg$parseseparated_part();\n while (s3 !== peg$FAILED) {\n s2.push(s3);\n s3 = peg$parseseparated_part();\n }\n peg$savedPos = s0;\n s0 = peg$f3(s1, s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n if (s0 === peg$FAILED) {\n s0 = peg$currPos;\n s1 = [];\n s2 = peg$parseseparated_part();\n if (s2 !== peg$FAILED) {\n while (s2 !== peg$FAILED) {\n s1.push(s2);\n s2 = peg$parseseparated_part();\n }\n } else {\n s1 = peg$FAILED;\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = s0;\n s1 = peg$f4(s1);\n }\n s0 = s1;\n }\n return s0;\n }\n function peg$parseseparated_part() {\n var s0, s1, s2, s3, s4;\n s0 = peg$currPos;\n s1 = [];\n s2 = peg$parseparbreak();\n while (s2 !== peg$FAILED) {\n s1.push(s2);\n s2 = peg$parseparbreak();\n }\n s2 = peg$parseequals();\n if (s2 !== peg$FAILED) {\n s3 = [];\n s4 = peg$parseparbreak();\n while (s4 !== peg$FAILED) {\n s3.push(s4);\n s4 = peg$parseparbreak();\n }\n s4 = peg$parseitem_part();\n if (s4 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f5(s4);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n if (s0 === peg$FAILED) {\n s0 = peg$currPos;\n s1 = [];\n s2 = peg$parseparbreak();\n while (s2 !== peg$FAILED) {\n s1.push(s2);\n s2 = peg$parseparbreak();\n }\n s2 = peg$parseequals();\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f6();\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n }\n return s0;\n }\n function peg$parseitem_part() {\n var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;\n s0 = peg$currPos;\n s1 = [];\n s2 = peg$parsewhitespace();\n while (s2 !== peg$FAILED) {\n s1.push(s2);\n s2 = peg$parsewhitespace();\n }\n s2 = peg$currPos;\n s3 = [];\n s4 = peg$parsenon_whitespace_non_parbreak_token();\n if (s4 === peg$FAILED) {\n s4 = peg$currPos;\n s5 = peg$parsewhitespace();\n if (s5 === peg$FAILED) {\n s5 = peg$parseparbreak();\n }\n if (s5 !== peg$FAILED) {\n s6 = peg$currPos;\n peg$silentFails++;\n s7 = peg$currPos;\n s8 = [];\n s9 = peg$parsewhitespace();\n if (s9 === peg$FAILED) {\n s9 = peg$parseparbreak();\n }\n while (s9 !== peg$FAILED) {\n s8.push(s9);\n s9 = peg$parsewhitespace();\n if (s9 === peg$FAILED) {\n s9 = peg$parseparbreak();\n }\n }\n s9 = peg$parsenon_whitespace_non_parbreak_token();\n if (s9 !== peg$FAILED) {\n s8 = [s8, s9];\n s7 = s8;\n } else {\n peg$currPos = s7;\n s7 = peg$FAILED;\n }\n peg$silentFails--;\n if (s7 !== peg$FAILED) {\n peg$currPos = s6;\n s6 = void 0;\n } else {\n s6 = peg$FAILED;\n }\n if (s6 !== peg$FAILED) {\n s5 = [s5, s6];\n s4 = s5;\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n }\n if (s4 !== peg$FAILED) {\n while (s4 !== peg$FAILED) {\n s3.push(s4);\n s4 = peg$parsenon_whitespace_non_parbreak_token();\n if (s4 === peg$FAILED) {\n s4 = peg$currPos;\n s5 = peg$parsewhitespace();\n if (s5 === peg$FAILED) {\n s5 = peg$parseparbreak();\n }\n if (s5 !== peg$FAILED) {\n s6 = peg$currPos;\n peg$silentFails++;\n s7 = peg$currPos;\n s8 = [];\n s9 = peg$parsewhitespace();\n if (s9 === peg$FAILED) {\n s9 = peg$parseparbreak();\n }\n while (s9 !== peg$FAILED) {\n s8.push(s9);\n s9 = peg$parsewhitespace();\n if (s9 === peg$FAILED) {\n s9 = peg$parseparbreak();\n }\n }\n s9 = peg$parsenon_whitespace_non_parbreak_token();\n if (s9 !== peg$FAILED) {\n s8 = [s8, s9];\n s7 = s8;\n } else {\n peg$currPos = s7;\n s7 = peg$FAILED;\n }\n peg$silentFails--;\n if (s7 !== peg$FAILED) {\n peg$currPos = s6;\n s6 = void 0;\n } else {\n s6 = peg$FAILED;\n }\n if (s6 !== peg$FAILED) {\n s5 = [s5, s6];\n s4 = s5;\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n }\n }\n } else {\n s3 = peg$FAILED;\n }\n if (s3 !== peg$FAILED) {\n s2 = input.substring(s2, peg$currPos);\n } else {\n s2 = s3;\n }\n if (s2 !== peg$FAILED) {\n s3 = [];\n s4 = peg$parsewhitespace();\n while (s4 !== peg$FAILED) {\n s3.push(s4);\n s4 = peg$parsewhitespace();\n }\n peg$savedPos = s0;\n s0 = peg$f7(s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parsetrailing_comment() {\n var s0, s1, s2;\n s0 = peg$currPos;\n s1 = [];\n s2 = peg$parsewhitespace();\n while (s2 !== peg$FAILED) {\n s1.push(s2);\n s2 = peg$parsewhitespace();\n }\n s2 = peg$parsesame_line_comment();\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f8(s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parsecomment_only_line() {\n var s0, s1, s2;\n s0 = peg$currPos;\n s1 = peg$parsewhitespace_or_parbreaks();\n s2 = peg$parseown_line_comment();\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f9(s1, s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parsetoken() {\n var s0, s1, s2, s3;\n s0 = peg$currPos;\n s1 = peg$currPos;\n s2 = peg$currPos;\n peg$silentFails++;\n s3 = peg$parsenon_token();\n peg$silentFails--;\n if (s3 === peg$FAILED) {\n s2 = void 0;\n } else {\n peg$currPos = s2;\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n if (input.length > peg$currPos) {\n s3 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s3 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n if (s3 !== peg$FAILED) {\n s2 = [s2, s3];\n s1 = s2;\n } else {\n peg$currPos = s1;\n s1 = peg$FAILED;\n }\n } else {\n peg$currPos = s1;\n s1 = peg$FAILED;\n }\n if (s1 !== peg$FAILED) {\n s0 = input.substring(s0, peg$currPos);\n } else {\n s0 = s1;\n }\n return s0;\n }\n function peg$parsenon_whitespace_non_parbreak_token() {\n var s0, s1, s2, s3;\n s0 = peg$currPos;\n s1 = peg$currPos;\n s2 = peg$currPos;\n peg$silentFails++;\n s3 = peg$parsewhitespace();\n if (s3 === peg$FAILED) {\n s3 = peg$parseparbreak();\n }\n peg$silentFails--;\n if (s3 === peg$FAILED) {\n s2 = void 0;\n } else {\n peg$currPos = s2;\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n s3 = peg$parseparen_block();\n if (s3 === peg$FAILED) {\n s3 = peg$parsetoken();\n }\n if (s3 !== peg$FAILED) {\n s2 = [s2, s3];\n s1 = s2;\n } else {\n peg$currPos = s1;\n s1 = peg$FAILED;\n }\n } else {\n peg$currPos = s1;\n s1 = peg$FAILED;\n }\n if (s1 !== peg$FAILED) {\n s0 = input.substring(s0, peg$currPos);\n } else {\n s0 = s1;\n }\n return s0;\n }\n function peg$parsenon_token() {\n var s0;\n s0 = peg$parseitem_sep();\n if (s0 === peg$FAILED) {\n s0 = peg$parseequals();\n if (s0 === peg$FAILED) {\n s0 = peg$parsetrailing_comment();\n if (s0 === peg$FAILED) {\n s0 = peg$parseown_line_comment();\n }\n }\n }\n return s0;\n }\n function peg$parsewhitespace_or_parbreaks() {\n var s0, s1, s2;\n s0 = peg$currPos;\n s1 = [];\n s2 = peg$parsewhitespace();\n if (s2 === peg$FAILED) {\n s2 = peg$parseparbreak();\n }\n while (s2 !== peg$FAILED) {\n s1.push(s2);\n s2 = peg$parsewhitespace();\n if (s2 === peg$FAILED) {\n s2 = peg$parseparbreak();\n }\n }\n peg$savedPos = s0;\n s1 = peg$f10(s1);\n s0 = s1;\n return s0;\n }\n function peg$parseparen_block() {\n var s0, s1, s2, s3, s4, s5, s6, s7, s8;\n s0 = peg$currPos;\n peg$savedPos = peg$currPos;\n s1 = peg$f11();\n if (s1) {\n s1 = peg$FAILED;\n } else {\n s1 = void 0;\n }\n if (s1 !== peg$FAILED) {\n s2 = peg$currPos;\n s3 = peg$currPos;\n s4 = peg$parseopen_paren();\n if (s4 !== peg$FAILED) {\n s5 = [];\n s6 = peg$currPos;\n s7 = peg$currPos;\n peg$silentFails++;\n s8 = peg$parseclose_paren();\n peg$silentFails--;\n if (s8 === peg$FAILED) {\n s7 = void 0;\n } else {\n peg$currPos = s7;\n s7 = peg$FAILED;\n }\n if (s7 !== peg$FAILED) {\n if (input.length > peg$currPos) {\n s8 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s8 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n if (s8 !== peg$FAILED) {\n s7 = [s7, s8];\n s6 = s7;\n } else {\n peg$currPos = s6;\n s6 = peg$FAILED;\n }\n } else {\n peg$currPos = s6;\n s6 = peg$FAILED;\n }\n while (s6 !== peg$FAILED) {\n s5.push(s6);\n s6 = peg$currPos;\n s7 = peg$currPos;\n peg$silentFails++;\n s8 = peg$parseclose_paren();\n peg$silentFails--;\n if (s8 === peg$FAILED) {\n s7 = void 0;\n } else {\n peg$currPos = s7;\n s7 = peg$FAILED;\n }\n if (s7 !== peg$FAILED) {\n if (input.length > peg$currPos) {\n s8 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s8 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n if (s8 !== peg$FAILED) {\n s7 = [s7, s8];\n s6 = s7;\n } else {\n peg$currPos = s6;\n s6 = peg$FAILED;\n }\n } else {\n peg$currPos = s6;\n s6 = peg$FAILED;\n }\n }\n s6 = peg$parseclose_paren();\n if (s6 !== peg$FAILED) {\n s4 = [s4, s5, s6];\n s3 = s4;\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n if (s3 !== peg$FAILED) {\n s2 = input.substring(s2, peg$currPos);\n } else {\n s2 = s3;\n }\n if (s2 !== peg$FAILED) {\n s1 = [s1, s2];\n s0 = s1;\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parsesame_line_comment() {\n var s0, s1, s2;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f12(s1);\n if (s2) {\n s2 = void 0;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f13(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parseown_line_comment() {\n var s0, s1, s2;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f14(s1);\n if (s2) {\n s2 = void 0;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f15(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parsewhitespace() {\n var s0, s1, s2;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f16(s1);\n if (s2) {\n s2 = void 0;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f17(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parseparbreak() {\n var s0, s1, s2;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f18(s1);\n if (s2) {\n s2 = void 0;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f19(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parseitem_sep() {\n var s0, s1, s2;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f20(s1);\n if (s2) {\n s2 = void 0;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f21(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parseequals() {\n var s0, s1, s2;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f22(s1);\n if (s2) {\n s2 = void 0;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f23(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parseopen_paren() {\n var s0, s1, s2;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f24(s1);\n if (s2) {\n s2 = void 0;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f25(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parseclose_paren() {\n var s0, s1, s2;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f26(s1);\n if (s2) {\n s2 = void 0;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f27(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parseEOL() {\n var s0, s1;\n s0 = peg$currPos;\n peg$silentFails++;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n peg$silentFails--;\n if (s1 === peg$FAILED) {\n s0 = void 0;\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function processItem(leadCell, otherCells) {\n const cells = [leadCell || []];\n for (const x of otherCells) {\n cells.push(x.cell || []);\n }\n return { itemParts: cells };\n }\n if (!options.isWhitespace) {\n try {\n Object.assign(options, {\n isChar: (node, char) => node.type === \"string\" && node.content === char,\n isComma(node) {\n return node.type === \"string\" && node.content === \",\";\n },\n isEquals(node) {\n return node.type === \"string\" && node.content === \"=\";\n },\n isParbreak(node) {\n return node.type === \"parbreak\";\n },\n isWhitespace(node) {\n return node.type === \"whitespace\";\n },\n isSameLineComment: (node) => node.type === \"comment\" && node.sameline,\n isOwnLineComment: (node) => node.type === \"comment\" && !node.sameline,\n isComment: (node) => node.type === \"comment\",\n allowParenGroups: true\n });\n } catch (e) {\n console.warn(\"Error when initializing parser\", e);\n }\n }\n peg$result = peg$startRuleFunction();\n if (peg$result !== peg$FAILED && peg$currPos === input.length) {\n return peg$result;\n } else {\n if (peg$result !== peg$FAILED && peg$currPos < input.length) {\n peg$fail(peg$endExpectation());\n }\n throw peg$buildStructuredError(\n peg$maxFailExpected,\n peg$maxFailPos < input.length ? input.charAt(peg$maxFailPos) : null,\n peg$maxFailPos < input.length ? peg$computeLocation(peg$maxFailPos, peg$maxFailPos + 1) : peg$computeLocation(peg$maxFailPos, peg$maxFailPos)\n );\n }\n }\n return {\n SyntaxError: peg$SyntaxError,\n parse: peg$parse\n };\n }()\n);\n\n// grammars/macro-substitutions.pegjs\nvar macro_substitutions_default = (\n // Generated by Peggy 2.0.1.\n //\n // https://peggyjs.org/\n function() {\n \"use strict\";\n function peg$subclass(child, parent) {\n function C() {\n this.constructor = child;\n }\n C.prototype = parent.prototype;\n child.prototype = new C();\n }\n function peg$SyntaxError(message, expected, found, location) {\n var self = Error.call(this, message);\n if (Object.setPrototypeOf) {\n Object.setPrototypeOf(self, peg$SyntaxError.prototype);\n }\n self.expected = expected;\n self.found = found;\n self.location = location;\n self.name = \"SyntaxError\";\n return self;\n }\n peg$subclass(peg$SyntaxError, Error);\n function peg$padEnd(str, targetLength, padString) {\n padString = padString || \" \";\n if (str.length > targetLength) {\n return str;\n }\n targetLength -= str.length;\n padString += padString.repeat(targetLength);\n return str + padString.slice(0, targetLength);\n }\n peg$SyntaxError.prototype.format = function(sources) {\n var str = \"Error: \" + this.message;\n if (this.location) {\n var src = null;\n var k;\n for (k = 0; k < sources.length; k++) {\n if (sources[k].source === this.location.source) {\n src = sources[k].text.split(/\\r\\n|\\n|\\r/g);\n break;\n }\n }\n var s = this.location.start;\n var loc = this.location.source + \":\" + s.line + \":\" + s.column;\n if (src) {\n var e = this.location.end;\n var filler = peg$padEnd(\"\", s.line.toString().length, \" \");\n var line = src[s.line - 1];\n var last = s.line === e.line ? e.column : line.length + 1;\n var hatLen = last - s.column || 1;\n str += \"\\n --> \" + loc + \"\\n\" + filler + \" |\\n\" + s.line + \" | \" + line + \"\\n\" + filler + \" | \" + peg$padEnd(\"\", s.column - 1, \" \") + peg$padEnd(\"\", hatLen, \"^\");\n } else {\n str += \"\\n at \" + loc;\n }\n }\n return str;\n };\n peg$SyntaxError.buildMessage = function(expected, found) {\n var DESCRIBE_EXPECTATION_FNS = {\n literal: function(expectation) {\n return '\"' + literalEscape(expectation.text) + '\"';\n },\n class: function(expectation) {\n var escapedParts = expectation.parts.map(function(part) {\n return Array.isArray(part) ? classEscape(part[0]) + \"-\" + classEscape(part[1]) : classEscape(part);\n });\n return \"[\" + (expectation.inverted ? \"^\" : \"\") + escapedParts.join(\"\") + \"]\";\n },\n any: function() {\n return \"any character\";\n },\n end: function() {\n return \"end of input\";\n },\n other: function(expectation) {\n return expectation.description;\n }\n };\n function hex(ch) {\n return ch.charCodeAt(0).toString(16).toUpperCase();\n }\n function literalEscape(s) {\n return s.replace(/\\\\/g, \"\\\\\\\\\").replace(/\"/g, '\\\\\"').replace(/\\0/g, \"\\\\0\").replace(/\\t/g, \"\\\\t\").replace(/\\n/g, \"\\\\n\").replace(/\\r/g, \"\\\\r\").replace(/[\\x00-\\x0F]/g, function(ch) {\n return \"\\\\x0\" + hex(ch);\n }).replace(/[\\x10-\\x1F\\x7F-\\x9F]/g, function(ch) {\n return \"\\\\x\" + hex(ch);\n });\n }\n function classEscape(s) {\n return s.replace(/\\\\/g, \"\\\\\\\\\").replace(/\\]/g, \"\\\\]\").replace(/\\^/g, \"\\\\^\").replace(/-/g, \"\\\\-\").replace(/\\0/g, \"\\\\0\").replace(/\\t/g, \"\\\\t\").replace(/\\n/g, \"\\\\n\").replace(/\\r/g, \"\\\\r\").replace(/[\\x00-\\x0F]/g, function(ch) {\n return \"\\\\x0\" + hex(ch);\n }).replace(/[\\x10-\\x1F\\x7F-\\x9F]/g, function(ch) {\n return \"\\\\x\" + hex(ch);\n });\n }\n function describeExpectation(expectation) {\n return DESCRIBE_EXPECTATION_FNS[expectation.type](expectation);\n }\n function describeExpected(expected2) {\n var descriptions = expected2.map(describeExpectation);\n var i, j;\n descriptions.sort();\n if (descriptions.length > 0) {\n for (i = 1, j = 1; i < descriptions.length; i++) {\n if (descriptions[i - 1] !== descriptions[i]) {\n descriptions[j] = descriptions[i];\n j++;\n }\n }\n descriptions.length = j;\n }\n switch (descriptions.length) {\n case 1:\n return descriptions[0];\n case 2:\n return descriptions[0] + \" or \" + descriptions[1];\n default:\n return descriptions.slice(0, -1).join(\", \") + \", or \" + descriptions[descriptions.length - 1];\n }\n }\n function describeFound(found2) {\n return found2 ? '\"' + literalEscape(found2) + '\"' : \"end of input\";\n }\n return \"Expected \" + describeExpected(expected) + \" but \" + describeFound(found) + \" found.\";\n };\n function peg$parse(input, options) {\n options = options !== void 0 ? options : {};\n var peg$FAILED = {};\n var peg$source = options.grammarSource;\n var peg$startRuleFunctions = { body: peg$parsebody };\n var peg$startRuleFunction = peg$parsebody;\n var peg$e0 = peg$anyExpectation();\n var peg$f0 = function(e) {\n return [].concat(...e).filter((n) => !!n);\n };\n var peg$f1 = function() {\n return [];\n };\n var peg$f2 = function(tok) {\n return options.isHash(tok);\n };\n var peg$f3 = function(tok) {\n return tok;\n };\n var peg$f4 = function(tok) {\n return options.isNumber(tok);\n };\n var peg$f5 = function(tok) {\n return tok;\n };\n var peg$f6 = function() {\n return { type: \"string\", content: \"#\" };\n };\n var peg$f7 = function(num) {\n const split = options.splitNumber(num);\n return [{ type: \"hash_number\", number: split.number }, split.rest];\n };\n var peg$currPos = 0;\n var peg$savedPos = 0;\n var peg$posDetailsCache = [{ line: 1, column: 1 }];\n var peg$maxFailPos = 0;\n var peg$maxFailExpected = [];\n var peg$silentFails = 0;\n var peg$result;\n if (\"startRule\" in options) {\n if (!(options.startRule in peg$startRuleFunctions)) {\n throw new Error(`Can't start parsing from rule \"` + options.startRule + '\".');\n }\n peg$startRuleFunction = peg$startRuleFunctions[options.startRule];\n }\n function text() {\n return input.substring(peg$savedPos, peg$currPos);\n }\n function offset() {\n return peg$savedPos;\n }\n function range() {\n return {\n source: peg$source,\n start: peg$savedPos,\n end: peg$currPos\n };\n }\n function location() {\n return peg$computeLocation(peg$savedPos, peg$currPos);\n }\n function expected(description, location2) {\n location2 = location2 !== void 0 ? location2 : peg$computeLocation(peg$savedPos, peg$currPos);\n throw peg$buildStructuredError(\n [peg$otherExpectation(description)],\n input.substring(peg$savedPos, peg$currPos),\n location2\n );\n }\n function error(message, location2) {\n location2 = location2 !== void 0 ? location2 : peg$computeLocation(peg$savedPos, peg$currPos);\n throw peg$buildSimpleError(message, location2);\n }\n function peg$literalExpectation(text2, ignoreCase) {\n return { type: \"literal\", text: text2, ignoreCase };\n }\n function peg$classExpectation(parts, inverted, ignoreCase) {\n return { type: \"class\", parts, inverted, ignoreCase };\n }\n function peg$anyExpectation() {\n return { type: \"any\" };\n }\n function peg$endExpectation() {\n return { type: \"end\" };\n }\n function peg$otherExpectation(description) {\n return { type: \"other\", description };\n }\n function peg$computePosDetails(pos) {\n var details = peg$posDetailsCache[pos];\n var p;\n if (details) {\n return details;\n } else {\n p = pos - 1;\n while (!peg$posDetailsCache[p]) {\n p--;\n }\n details = peg$posDetailsCache[p];\n details = {\n line: details.line,\n column: details.column\n };\n while (p < pos) {\n if (input.charCodeAt(p) === 10) {\n details.line++;\n details.column = 1;\n } else {\n details.column++;\n }\n p++;\n }\n peg$posDetailsCache[pos] = details;\n return details;\n }\n }\n function peg$computeLocation(startPos, endPos) {\n var startPosDetails = peg$computePosDetails(startPos);\n var endPosDetails = peg$computePosDetails(endPos);\n return {\n source: peg$source,\n start: {\n offset: startPos,\n line: startPosDetails.line,\n column: startPosDetails.column\n },\n end: {\n offset: endPos,\n line: endPosDetails.line,\n column: endPosDetails.column\n }\n };\n }\n function peg$fail(expected2) {\n if (peg$currPos < peg$maxFailPos) {\n return;\n }\n if (peg$currPos > peg$maxFailPos) {\n peg$maxFailPos = peg$currPos;\n peg$maxFailExpected = [];\n }\n peg$maxFailExpected.push(expected2);\n }\n function peg$buildSimpleError(message, location2) {\n return new peg$SyntaxError(message, null, null, location2);\n }\n function peg$buildStructuredError(expected2, found, location2) {\n return new peg$SyntaxError(\n peg$SyntaxError.buildMessage(expected2, found),\n expected2,\n found,\n location2\n );\n }\n function peg$parsebody() {\n var s0, s1, s2;\n s0 = peg$currPos;\n s1 = [];\n s2 = peg$parsedouble_hash();\n if (s2 === peg$FAILED) {\n s2 = peg$parsehash_number();\n if (s2 === peg$FAILED) {\n if (input.length > peg$currPos) {\n s2 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s2 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n }\n }\n if (s2 !== peg$FAILED) {\n while (s2 !== peg$FAILED) {\n s1.push(s2);\n s2 = peg$parsedouble_hash();\n if (s2 === peg$FAILED) {\n s2 = peg$parsehash_number();\n if (s2 === peg$FAILED) {\n if (input.length > peg$currPos) {\n s2 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s2 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n }\n }\n }\n } else {\n s1 = peg$FAILED;\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = s0;\n s1 = peg$f0(s1);\n }\n s0 = s1;\n if (s0 === peg$FAILED) {\n s0 = peg$currPos;\n s1 = peg$parseEOL();\n if (s1 !== peg$FAILED) {\n peg$savedPos = s0;\n s1 = peg$f1();\n }\n s0 = s1;\n }\n return s0;\n }\n function peg$parsehash() {\n var s0, s1, s2;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f2(s1);\n if (s2) {\n s2 = void 0;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f3(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parsenumber() {\n var s0, s1, s2;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f4(s1);\n if (s2) {\n s2 = void 0;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f5(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parsedouble_hash() {\n var s0, s1, s2;\n s0 = peg$currPos;\n s1 = peg$parsehash();\n if (s1 !== peg$FAILED) {\n s2 = peg$parsehash();\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f6();\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parsehash_number() {\n var s0, s1, s2;\n s0 = peg$currPos;\n s1 = peg$parsehash();\n if (s1 !== peg$FAILED) {\n s2 = peg$parsenumber();\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f7(s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parseEOL() {\n var s0, s1;\n s0 = peg$currPos;\n peg$silentFails++;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n peg$silentFails--;\n if (s1 === peg$FAILED) {\n s0 = void 0;\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n if (!options.isHash) {\n try {\n Object.assign(options, {\n isHash: (node) => node.type === \"string\" && node.content === \"#\",\n isNumber: (node) => node.type === \"string\" && 0 < +node.content.charAt(0),\n splitNumber: (node) => {\n const number = +node.content.charAt(0);\n if (node.content.length > 1) {\n return {\n number,\n rest: {\n type: \"string\",\n content: node.content.slice(1)\n }\n };\n }\n return { number };\n }\n });\n } catch (e) {\n console.warn(\"Error when initializing parser\", e);\n }\n }\n peg$result = peg$startRuleFunction();\n if (peg$result !== peg$FAILED && peg$currPos === input.length) {\n return peg$result;\n } else {\n if (peg$result !== peg$FAILED && peg$currPos < input.length) {\n peg$fail(peg$endExpectation());\n }\n throw peg$buildStructuredError(\n peg$maxFailExpected,\n peg$maxFailPos < input.length ? input.charAt(peg$maxFailPos) : null,\n peg$maxFailPos < input.length ? peg$computeLocation(peg$maxFailPos, peg$maxFailPos + 1) : peg$computeLocation(peg$maxFailPos, peg$maxFailPos)\n );\n }\n }\n return {\n SyntaxError: peg$SyntaxError,\n parse: peg$parse\n };\n }()\n);\n\n// grammars/ligatures.pegjs\nvar ligatures_default = (\n // Generated by Peggy 2.0.1.\n //\n // https://peggyjs.org/\n function() {\n \"use strict\";\n function peg$subclass(child, parent) {\n function C() {\n this.constructor = child;\n }\n C.prototype = parent.prototype;\n child.prototype = new C();\n }\n function peg$SyntaxError(message, expected, found, location) {\n var self = Error.call(this, message);\n if (Object.setPrototypeOf) {\n Object.setPrototypeOf(self, peg$SyntaxError.prototype);\n }\n self.expected = expected;\n self.found = found;\n self.location = location;\n self.name = \"SyntaxError\";\n return self;\n }\n peg$subclass(peg$SyntaxError, Error);\n function peg$padEnd(str, targetLength, padString) {\n padString = padString || \" \";\n if (str.length > targetLength) {\n return str;\n }\n targetLength -= str.length;\n padString += padString.repeat(targetLength);\n return str + padString.slice(0, targetLength);\n }\n peg$SyntaxError.prototype.format = function(sources) {\n var str = \"Error: \" + this.message;\n if (this.location) {\n var src = null;\n var k;\n for (k = 0; k < sources.length; k++) {\n if (sources[k].source === this.location.source) {\n src = sources[k].text.split(/\\r\\n|\\n|\\r/g);\n break;\n }\n }\n var s = this.location.start;\n var loc = this.location.source + \":\" + s.line + \":\" + s.column;\n if (src) {\n var e = this.location.end;\n var filler = peg$padEnd(\"\", s.line.toString().length, \" \");\n var line = src[s.line - 1];\n var last = s.line === e.line ? e.column : line.length + 1;\n var hatLen = last - s.column || 1;\n str += \"\\n --> \" + loc + \"\\n\" + filler + \" |\\n\" + s.line + \" | \" + line + \"\\n\" + filler + \" | \" + peg$padEnd(\"\", s.column - 1, \" \") + peg$padEnd(\"\", hatLen, \"^\");\n } else {\n str += \"\\n at \" + loc;\n }\n }\n return str;\n };\n peg$SyntaxError.buildMessage = function(expected, found) {\n var DESCRIBE_EXPECTATION_FNS = {\n literal: function(expectation) {\n return '\"' + literalEscape(expectation.text) + '\"';\n },\n class: function(expectation) {\n var escapedParts = expectation.parts.map(function(part) {\n return Array.isArray(part) ? classEscape(part[0]) + \"-\" + classEscape(part[1]) : classEscape(part);\n });\n return \"[\" + (expectation.inverted ? \"^\" : \"\") + escapedParts.join(\"\") + \"]\";\n },\n any: function() {\n return \"any character\";\n },\n end: function() {\n return \"end of input\";\n },\n other: function(expectation) {\n return expectation.description;\n }\n };\n function hex(ch) {\n return ch.charCodeAt(0).toString(16).toUpperCase();\n }\n function literalEscape(s) {\n return s.replace(/\\\\/g, \"\\\\\\\\\").replace(/\"/g, '\\\\\"').replace(/\\0/g, \"\\\\0\").replace(/\\t/g, \"\\\\t\").replace(/\\n/g, \"\\\\n\").replace(/\\r/g, \"\\\\r\").replace(/[\\x00-\\x0F]/g, function(ch) {\n return \"\\\\x0\" + hex(ch);\n }).replace(/[\\x10-\\x1F\\x7F-\\x9F]/g, function(ch) {\n return \"\\\\x\" + hex(ch);\n });\n }\n function classEscape(s) {\n return s.replace(/\\\\/g, \"\\\\\\\\\").replace(/\\]/g, \"\\\\]\").replace(/\\^/g, \"\\\\^\").replace(/-/g, \"\\\\-\").replace(/\\0/g, \"\\\\0\").replace(/\\t/g, \"\\\\t\").replace(/\\n/g, \"\\\\n\").replace(/\\r/g, \"\\\\r\").replace(/[\\x00-\\x0F]/g, function(ch) {\n return \"\\\\x0\" + hex(ch);\n }).replace(/[\\x10-\\x1F\\x7F-\\x9F]/g, function(ch) {\n return \"\\\\x\" + hex(ch);\n });\n }\n function describeExpectation(expectation) {\n return DESCRIBE_EXPECTATION_FNS[expectation.type](expectation);\n }\n function describeExpected(expected2) {\n var descriptions = expected2.map(describeExpectation);\n var i, j;\n descriptions.sort();\n if (descriptions.length > 0) {\n for (i = 1, j = 1; i < descriptions.length; i++) {\n if (descriptions[i - 1] !== descriptions[i]) {\n descriptions[j] = descriptions[i];\n j++;\n }\n }\n descriptions.length = j;\n }\n switch (descriptions.length) {\n case 1:\n return descriptions[0];\n case 2:\n return descriptions[0] + \" or \" + descriptions[1];\n default:\n return descriptions.slice(0, -1).join(\", \") + \", or \" + descriptions[descriptions.length - 1];\n }\n }\n function describeFound(found2) {\n return found2 ? '\"' + literalEscape(found2) + '\"' : \"end of input\";\n }\n return \"Expected \" + describeExpected(expected) + \" but \" + describeFound(found) + \" found.\";\n };\n function peg$parse(input, options) {\n options = options !== void 0 ? options : {};\n var peg$FAILED = {};\n var peg$source = options.grammarSource;\n var peg$startRuleFunctions = { body: peg$parsebody };\n var peg$startRuleFunction = peg$parsebody;\n var peg$e0 = peg$anyExpectation();\n var peg$f0 = function(e) {\n return [].concat(...e).filter((n) => !!n);\n };\n var peg$f1 = function() {\n return [];\n };\n var peg$f2 = function(toks) {\n return options.isRecognized(toks);\n };\n var peg$f3 = function(toks) {\n return options.isRecognized(toks);\n };\n var peg$f4 = function(tok1, tok2) {\n const split = options.split(tok2);\n return options.isRecognized([tok1, split[0]]);\n };\n var peg$f5 = function(tok1, tok2) {\n const split = options.split(tok2);\n return [options.isRecognized([tok1, split[0]]), split[1]];\n };\n var peg$f6 = function(tok1, tok2) {\n return options.isRecognized([tok1, tok2]);\n };\n var peg$f7 = function(tok1, tok2) {\n return options.isRecognized([tok1, tok2]);\n };\n var peg$f8 = function(toks) {\n return options.isRecognized(toks);\n };\n var peg$f9 = function(toks) {\n return options.isRecognized(toks);\n };\n var peg$f10 = function(tok) {\n return options.isRecognized([tok]);\n };\n var peg$f11 = function(tok) {\n return options.isRecognized([tok]);\n };\n var peg$f12 = function(tok) {\n return options.isMacro(tok);\n };\n var peg$f13 = function(tok) {\n return tok;\n };\n var peg$f14 = function(tok) {\n return options.isWhitespace(tok);\n };\n var peg$f15 = function(tok) {\n return tok;\n };\n var peg$f16 = function(tok) {\n return options.isSplitable(tok);\n };\n var peg$f17 = function(tok) {\n return tok;\n };\n var peg$currPos = 0;\n var peg$savedPos = 0;\n var peg$posDetailsCache = [{ line: 1, column: 1 }];\n var peg$maxFailPos = 0;\n var peg$maxFailExpected = [];\n var peg$silentFails = 0;\n var peg$result;\n if (\"startRule\" in options) {\n if (!(options.startRule in peg$startRuleFunctions)) {\n throw new Error(`Can't start parsing from rule \"` + options.startRule + '\".');\n }\n peg$startRuleFunction = peg$startRuleFunctions[options.startRule];\n }\n function text() {\n return input.substring(peg$savedPos, peg$currPos);\n }\n function offset() {\n return peg$savedPos;\n }\n function range() {\n return {\n source: peg$source,\n start: peg$savedPos,\n end: peg$currPos\n };\n }\n function location() {\n return peg$computeLocation(peg$savedPos, peg$currPos);\n }\n function expected(description, location2) {\n location2 = location2 !== void 0 ? location2 : peg$computeLocation(peg$savedPos, peg$currPos);\n throw peg$buildStructuredError(\n [peg$otherExpectation(description)],\n input.substring(peg$savedPos, peg$currPos),\n location2\n );\n }\n function error(message, location2) {\n location2 = location2 !== void 0 ? location2 : peg$computeLocation(peg$savedPos, peg$currPos);\n throw peg$buildSimpleError(message, location2);\n }\n function peg$literalExpectation(text2, ignoreCase) {\n return { type: \"literal\", text: text2, ignoreCase };\n }\n function peg$classExpectation(parts, inverted, ignoreCase) {\n return { type: \"class\", parts, inverted, ignoreCase };\n }\n function peg$anyExpectation() {\n return { type: \"any\" };\n }\n function peg$endExpectation() {\n return { type: \"end\" };\n }\n function peg$otherExpectation(description) {\n return { type: \"other\", description };\n }\n function peg$computePosDetails(pos) {\n var details = peg$posDetailsCache[pos];\n var p;\n if (details) {\n return details;\n } else {\n p = pos - 1;\n while (!peg$posDetailsCache[p]) {\n p--;\n }\n details = peg$posDetailsCache[p];\n details = {\n line: details.line,\n column: details.column\n };\n while (p < pos) {\n if (input.charCodeAt(p) === 10) {\n details.line++;\n details.column = 1;\n } else {\n details.column++;\n }\n p++;\n }\n peg$posDetailsCache[pos] = details;\n return details;\n }\n }\n function peg$computeLocation(startPos, endPos) {\n var startPosDetails = peg$computePosDetails(startPos);\n var endPosDetails = peg$computePosDetails(endPos);\n return {\n source: peg$source,\n start: {\n offset: startPos,\n line: startPosDetails.line,\n column: startPosDetails.column\n },\n end: {\n offset: endPos,\n line: endPosDetails.line,\n column: endPosDetails.column\n }\n };\n }\n function peg$fail(expected2) {\n if (peg$currPos < peg$maxFailPos) {\n return;\n }\n if (peg$currPos > peg$maxFailPos) {\n peg$maxFailPos = peg$currPos;\n peg$maxFailExpected = [];\n }\n peg$maxFailExpected.push(expected2);\n }\n function peg$buildSimpleError(message, location2) {\n return new peg$SyntaxError(message, null, null, location2);\n }\n function peg$buildStructuredError(expected2, found, location2) {\n return new peg$SyntaxError(\n peg$SyntaxError.buildMessage(expected2, found),\n expected2,\n found,\n location2\n );\n }\n function peg$parsebody() {\n var s0, s1, s2;\n s0 = peg$currPos;\n s1 = [];\n s2 = peg$parsetriple_ligature();\n if (s2 === peg$FAILED) {\n s2 = peg$parsedouble_ligature();\n if (s2 === peg$FAILED) {\n s2 = peg$parsemono_ligature();\n if (s2 === peg$FAILED) {\n if (input.length > peg$currPos) {\n s2 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s2 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n }\n }\n }\n if (s2 !== peg$FAILED) {\n while (s2 !== peg$FAILED) {\n s1.push(s2);\n s2 = peg$parsetriple_ligature();\n if (s2 === peg$FAILED) {\n s2 = peg$parsedouble_ligature();\n if (s2 === peg$FAILED) {\n s2 = peg$parsemono_ligature();\n if (s2 === peg$FAILED) {\n if (input.length > peg$currPos) {\n s2 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s2 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n }\n }\n }\n }\n } else {\n s1 = peg$FAILED;\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = s0;\n s1 = peg$f0(s1);\n }\n s0 = s1;\n if (s0 === peg$FAILED) {\n s0 = peg$currPos;\n s1 = peg$parseEOL();\n if (s1 !== peg$FAILED) {\n peg$savedPos = s0;\n s1 = peg$f1();\n }\n s0 = s1;\n }\n return s0;\n }\n function peg$parsetriple_ligature() {\n var s0, s1, s2, s3, s4;\n s0 = peg$currPos;\n s1 = peg$currPos;\n if (input.length > peg$currPos) {\n s2 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s2 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n if (s2 !== peg$FAILED) {\n if (input.length > peg$currPos) {\n s3 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s3 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n if (s3 !== peg$FAILED) {\n if (input.length > peg$currPos) {\n s4 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s4 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n if (s4 !== peg$FAILED) {\n s2 = [s2, s3, s4];\n s1 = s2;\n } else {\n peg$currPos = s1;\n s1 = peg$FAILED;\n }\n } else {\n peg$currPos = s1;\n s1 = peg$FAILED;\n }\n } else {\n peg$currPos = s1;\n s1 = peg$FAILED;\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f2(s1);\n if (s2) {\n s2 = void 0;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f3(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parsedouble_ligature() {\n var s0;\n s0 = peg$parsedouble_macro_ligature();\n if (s0 === peg$FAILED) {\n s0 = peg$parsedouble_macro_ligature_extracted();\n if (s0 === peg$FAILED) {\n s0 = peg$parsedouble_char_ligature();\n }\n }\n return s0;\n }\n function peg$parsedouble_macro_ligature_extracted() {\n var s0, s1, s2, s3, s4;\n s0 = peg$currPos;\n s1 = peg$parsemacro();\n if (s1 !== peg$FAILED) {\n s2 = [];\n s3 = peg$parsewhitespace();\n while (s3 !== peg$FAILED) {\n s2.push(s3);\n s3 = peg$parsewhitespace();\n }\n s3 = peg$parsesplitable();\n if (s3 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s4 = peg$f4(s1, s3);\n if (s4) {\n s4 = void 0;\n } else {\n s4 = peg$FAILED;\n }\n if (s4 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f5(s1, s3);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parsedouble_macro_ligature() {\n var s0, s1, s2, s3, s4;\n s0 = peg$currPos;\n s1 = peg$parsemacro();\n if (s1 !== peg$FAILED) {\n s2 = [];\n s3 = peg$parsewhitespace();\n while (s3 !== peg$FAILED) {\n s2.push(s3);\n s3 = peg$parsewhitespace();\n }\n if (input.length > peg$currPos) {\n s3 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s3 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n if (s3 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s4 = peg$f6(s1, s3);\n if (s4) {\n s4 = void 0;\n } else {\n s4 = peg$FAILED;\n }\n if (s4 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f7(s1, s3);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parsedouble_char_ligature() {\n var s0, s1, s2, s3;\n s0 = peg$currPos;\n s1 = peg$currPos;\n if (input.length > peg$currPos) {\n s2 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s2 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n if (s2 !== peg$FAILED) {\n if (input.length > peg$currPos) {\n s3 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s3 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n if (s3 !== peg$FAILED) {\n s2 = [s2, s3];\n s1 = s2;\n } else {\n peg$currPos = s1;\n s1 = peg$FAILED;\n }\n } else {\n peg$currPos = s1;\n s1 = peg$FAILED;\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f8(s1);\n if (s2) {\n s2 = void 0;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f9(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parsemono_ligature() {\n var s0, s1, s2;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f10(s1);\n if (s2) {\n s2 = void 0;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f11(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parsemacro() {\n var s0, s1, s2;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f12(s1);\n if (s2) {\n s2 = void 0;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f13(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parsewhitespace() {\n var s0, s1, s2;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f14(s1);\n if (s2) {\n s2 = void 0;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f15(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parsesplitable() {\n var s0, s1, s2;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f16(s1);\n if (s2) {\n s2 = void 0;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f17(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parseEOL() {\n var s0, s1;\n s0 = peg$currPos;\n peg$silentFails++;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n peg$silentFails--;\n if (s1 === peg$FAILED) {\n s0 = void 0;\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n if (!options.isWhitespace) {\n try {\n Object.assign(options, {\n isMacro: (node) => node.type === \"macro\",\n isWhitespace: (node) => node.type === \"whitespace\",\n isRecognized: (nodes) => {\n if (nodes.length == 2 && nodes[0].content === \"^\" && nodes[1].content === \"o\") {\n return { type: \"string\", content: \"\\xF4\" };\n }\n return null;\n },\n isSplitable: (node) => node.type === \"string\" && node.content.length > 1,\n split: (node) => [\n { type: \"string\", content: node.content.charAt(0) },\n { type: \"string\", content: node.content.slice(1) }\n ]\n });\n } catch (e) {\n console.warn(\"Error when initializing parser\", e);\n }\n }\n peg$result = peg$startRuleFunction();\n if (peg$result !== peg$FAILED && peg$currPos === input.length) {\n return peg$result;\n } else {\n if (peg$result !== peg$FAILED && peg$currPos < input.length) {\n peg$fail(peg$endExpectation());\n }\n throw peg$buildStructuredError(\n peg$maxFailExpected,\n peg$maxFailPos < input.length ? input.charAt(peg$maxFailPos) : null,\n peg$maxFailPos < input.length ? peg$computeLocation(peg$maxFailPos, peg$maxFailPos + 1) : peg$computeLocation(peg$maxFailPos, peg$maxFailPos)\n );\n }\n }\n return {\n SyntaxError: peg$SyntaxError,\n parse: peg$parse\n };\n }()\n);\n\n// grammars/xcolor-expressions.pegjs\nvar xcolor_expressions_default = (\n // Generated by Peggy 2.0.1.\n //\n // https://peggyjs.org/\n function() {\n \"use strict\";\n function peg$subclass(child, parent) {\n function C() {\n this.constructor = child;\n }\n C.prototype = parent.prototype;\n child.prototype = new C();\n }\n function peg$SyntaxError(message, expected, found, location) {\n var self = Error.call(this, message);\n if (Object.setPrototypeOf) {\n Object.setPrototypeOf(self, peg$SyntaxError.prototype);\n }\n self.expected = expected;\n self.found = found;\n self.location = location;\n self.name = \"SyntaxError\";\n return self;\n }\n peg$subclass(peg$SyntaxError, Error);\n function peg$padEnd(str, targetLength, padString) {\n padString = padString || \" \";\n if (str.length > targetLength) {\n return str;\n }\n targetLength -= str.length;\n padString += padString.repeat(targetLength);\n return str + padString.slice(0, targetLength);\n }\n peg$SyntaxError.prototype.format = function(sources) {\n var str = \"Error: \" + this.message;\n if (this.location) {\n var src = null;\n var k;\n for (k = 0; k < sources.length; k++) {\n if (sources[k].source === this.location.source) {\n src = sources[k].text.split(/\\r\\n|\\n|\\r/g);\n break;\n }\n }\n var s = this.location.start;\n var loc = this.location.source + \":\" + s.line + \":\" + s.column;\n if (src) {\n var e = this.location.end;\n var filler = peg$padEnd(\"\", s.line.toString().length, \" \");\n var line = src[s.line - 1];\n var last = s.line === e.line ? e.column : line.length + 1;\n var hatLen = last - s.column || 1;\n str += \"\\n --> \" + loc + \"\\n\" + filler + \" |\\n\" + s.line + \" | \" + line + \"\\n\" + filler + \" | \" + peg$padEnd(\"\", s.column - 1, \" \") + peg$padEnd(\"\", hatLen, \"^\");\n } else {\n str += \"\\n at \" + loc;\n }\n }\n return str;\n };\n peg$SyntaxError.buildMessage = function(expected, found) {\n var DESCRIBE_EXPECTATION_FNS = {\n literal: function(expectation) {\n return '\"' + literalEscape(expectation.text) + '\"';\n },\n class: function(expectation) {\n var escapedParts = expectation.parts.map(function(part) {\n return Array.isArray(part) ? classEscape(part[0]) + \"-\" + classEscape(part[1]) : classEscape(part);\n });\n return \"[\" + (expectation.inverted ? \"^\" : \"\") + escapedParts.join(\"\") + \"]\";\n },\n any: function() {\n return \"any character\";\n },\n end: function() {\n return \"end of input\";\n },\n other: function(expectation) {\n return expectation.description;\n }\n };\n function hex(ch) {\n return ch.charCodeAt(0).toString(16).toUpperCase();\n }\n function literalEscape(s) {\n return s.replace(/\\\\/g, \"\\\\\\\\\").replace(/\"/g, '\\\\\"').replace(/\\0/g, \"\\\\0\").replace(/\\t/g, \"\\\\t\").replace(/\\n/g, \"\\\\n\").replace(/\\r/g, \"\\\\r\").replace(/[\\x00-\\x0F]/g, function(ch) {\n return \"\\\\x0\" + hex(ch);\n }).replace(/[\\x10-\\x1F\\x7F-\\x9F]/g, function(ch) {\n return \"\\\\x\" + hex(ch);\n });\n }\n function classEscape(s) {\n return s.replace(/\\\\/g, \"\\\\\\\\\").replace(/\\]/g, \"\\\\]\").replace(/\\^/g, \"\\\\^\").replace(/-/g, \"\\\\-\").replace(/\\0/g, \"\\\\0\").replace(/\\t/g, \"\\\\t\").replace(/\\n/g, \"\\\\n\").replace(/\\r/g, \"\\\\r\").replace(/[\\x00-\\x0F]/g, function(ch) {\n return \"\\\\x0\" + hex(ch);\n }).replace(/[\\x10-\\x1F\\x7F-\\x9F]/g, function(ch) {\n return \"\\\\x\" + hex(ch);\n });\n }\n function describeExpectation(expectation) {\n return DESCRIBE_EXPECTATION_FNS[expectation.type](expectation);\n }\n function describeExpected(expected2) {\n var descriptions = expected2.map(describeExpectation);\n var i, j;\n descriptions.sort();\n if (descriptions.length > 0) {\n for (i = 1, j = 1; i < descriptions.length; i++) {\n if (descriptions[i - 1] !== descriptions[i]) {\n descriptions[j] = descriptions[i];\n j++;\n }\n }\n descriptions.length = j;\n }\n switch (descriptions.length) {\n case 1:\n return descriptions[0];\n case 2:\n return descriptions[0] + \" or \" + descriptions[1];\n default:\n return descriptions.slice(0, -1).join(\", \") + \", or \" + descriptions[descriptions.length - 1];\n }\n }\n function describeFound(found2) {\n return found2 ? '\"' + literalEscape(found2) + '\"' : \"end of input\";\n }\n return \"Expected \" + describeExpected(expected) + \" but \" + describeFound(found) + \" found.\";\n };\n function peg$parse(input, options) {\n options = options !== void 0 ? options : {};\n var peg$FAILED = {};\n var peg$source = options.grammarSource;\n var peg$startRuleFunctions = { start: peg$parsestart };\n var peg$startRuleFunction = peg$parsestart;\n var peg$c0 = \";\";\n var peg$c1 = \",\";\n var peg$c2 = \":\";\n var peg$c3 = \"/\";\n var peg$c4 = \">\";\n var peg$c5 = \"!\";\n var peg$c6 = \".\";\n var peg$c7 = \"!![\";\n var peg$c8 = \"]\";\n var peg$c9 = \"!!\";\n var peg$c10 = \"+\";\n var peg$c11 = \"-\";\n var peg$r0 = /^[a-zA-Z0-9]/;\n var peg$r1 = /^[0-9]/;\n var peg$r2 = /^[ \\t\\n\\r]/;\n var peg$r3 = /^[0-9a-fA-F]/;\n var peg$e0 = peg$anyExpectation();\n var peg$e1 = peg$literalExpectation(\";\", false);\n var peg$e2 = peg$literalExpectation(\",\", false);\n var peg$e3 = peg$otherExpectation(\"model list\");\n var peg$e4 = peg$literalExpectation(\":\", false);\n var peg$e5 = peg$literalExpectation(\"/\", false);\n var peg$e6 = peg$otherExpectation(\"model\");\n var peg$e7 = peg$otherExpectation(\"color spec list\");\n var peg$e8 = peg$otherExpectation(\"color spec\");\n var peg$e9 = peg$otherExpectation(\"color\");\n var peg$e10 = peg$otherExpectation(\"function expression\");\n var peg$e11 = peg$literalExpectation(\">\", false);\n var peg$e12 = peg$otherExpectation(\"function\");\n var peg$e13 = peg$otherExpectation(\"extended expression\");\n var peg$e14 = peg$otherExpectation(\"core model\");\n var peg$e15 = peg$otherExpectation(\"expr\");\n var peg$e16 = peg$literalExpectation(\"!\", false);\n var peg$e17 = peg$otherExpectation(\"mix expr\");\n var peg$e18 = peg$otherExpectation(\"name\");\n var peg$e19 = peg$literalExpectation(\".\", false);\n var peg$e20 = peg$classExpectation([[\"a\", \"z\"], [\"A\", \"Z\"], [\"0\", \"9\"]], false, false);\n var peg$e21 = peg$otherExpectation(\"postfix\");\n var peg$e22 = peg$literalExpectation(\"!![\", false);\n var peg$e23 = peg$literalExpectation(\"]\", false);\n var peg$e24 = peg$literalExpectation(\"!!\", false);\n var peg$e25 = peg$otherExpectation(\"prefix\");\n var peg$e26 = peg$otherExpectation(\"plus\");\n var peg$e27 = peg$literalExpectation(\"+\", false);\n var peg$e28 = peg$otherExpectation(\"minus\");\n var peg$e29 = peg$literalExpectation(\"-\", false);\n var peg$e30 = peg$otherExpectation(\"num\");\n var peg$e31 = peg$classExpectation([[\"0\", \"9\"]], false, false);\n var peg$e32 = peg$otherExpectation(\"positive float\");\n var peg$e33 = peg$otherExpectation(\"divisor\");\n var peg$e34 = peg$otherExpectation(\"int\");\n var peg$e35 = peg$otherExpectation(\"whitespace\");\n var peg$e36 = peg$classExpectation([\" \", \"\t\", \"\\n\", \"\\r\"], false, false);\n var peg$e37 = peg$classExpectation([[\"0\", \"9\"], [\"a\", \"f\"], [\"A\", \"F\"]], false, false);\n var peg$f0 = function(m) {\n return m;\n };\n var peg$f1 = function(m) {\n return m;\n };\n var peg$f2 = function(m) {\n return m;\n };\n var peg$f3 = function(m) {\n return m;\n };\n var peg$f4 = function(m) {\n return m;\n };\n var peg$f5 = function(a) {\n return { type: \"invalid_spec\", content: a };\n };\n var peg$f6 = function(f, c) {\n return c;\n };\n var peg$f7 = function(f, r) {\n return { type: \"color_set\", content: [f].concat(r) };\n };\n var peg$f8 = function(n, s) {\n return { type: \"color_set_item\", name: n, spec_list: s };\n };\n var peg$f9 = function(c, m) {\n return { type: \"model_list\", contents: m, core_model: c };\n };\n var peg$f10 = function(m) {\n return { type: \"model_list\", contents: m, core_model: null };\n };\n var peg$f11 = function(m, a) {\n return a;\n };\n var peg$f12 = function(m, r) {\n return [m].concat(r);\n };\n var peg$f13 = function(s, a) {\n return a;\n };\n var peg$f14 = function(s, r) {\n return { type: \"spec_list\", content: [s].concat(r) };\n };\n var peg$f15 = function(c) {\n return { type: \"hex_spec\", content: [c] };\n };\n var peg$f16 = function(c, d) {\n return d;\n };\n var peg$f17 = function(c, d) {\n return d;\n };\n var peg$f18 = function(c, r) {\n return { type: \"num_spec\", content: r ? [c].concat(r) : [c] };\n };\n var peg$f19 = function(c, fs) {\n return { type: \"color\", color: c, functions: fs };\n };\n var peg$f20 = function(f, n) {\n return n;\n };\n var peg$f21 = function(f, args) {\n return { type: \"function\", name: f, args };\n };\n var peg$f22 = function(core, d, e, es) {\n return {\n type: \"extended_expr\",\n core_model: core,\n div: d,\n expressions: [e].concat(es)\n };\n };\n var peg$f23 = function(core, e, es) {\n return {\n type: \"extended_expr\",\n core_model: core,\n div: null,\n expressions: [e].concat(es)\n };\n };\n var peg$f24 = function(e, d) {\n return { type: \"weighted_expr\", color: e, weight: d };\n };\n var peg$f25 = function(e) {\n return e;\n };\n var peg$f26 = function(p, n, e, po) {\n return {\n type: \"expr\",\n prefix: p,\n name: n,\n mix_expr: e,\n postfix: po\n };\n };\n var peg$f27 = function(p, n) {\n return { type: \"complete_mix\", mix_percent: p, name: n };\n };\n var peg$f28 = function(p) {\n return { type: \"partial_mix\", mix_percent: p };\n };\n var peg$f29 = function(c, p) {\n return c.concat(p || []);\n };\n var peg$f30 = function(n) {\n return { type: \"postfix\", num: n };\n };\n var peg$f31 = function(p) {\n return { type: \"postfix\", plusses: p };\n };\n var peg$f32 = function(n) {\n return parseInt(n, 10);\n };\n var peg$f33 = function(n) {\n return parseFloat(n);\n };\n var peg$f34 = function(n) {\n return n;\n };\n var peg$f35 = function(n) {\n return -n;\n };\n var peg$f36 = function(m, n) {\n return m ? -n : n;\n };\n var peg$f37 = function(h) {\n return h.toUpperCase();\n };\n var peg$currPos = 0;\n var peg$savedPos = 0;\n var peg$posDetailsCache = [{ line: 1, column: 1 }];\n var peg$maxFailPos = 0;\n var peg$maxFailExpected = [];\n var peg$silentFails = 0;\n var peg$result;\n if (\"startRule\" in options) {\n if (!(options.startRule in peg$startRuleFunctions)) {\n throw new Error(`Can't start parsing from rule \"` + options.startRule + '\".');\n }\n peg$startRuleFunction = peg$startRuleFunctions[options.startRule];\n }\n function text() {\n return input.substring(peg$savedPos, peg$currPos);\n }\n function offset() {\n return peg$savedPos;\n }\n function range() {\n return {\n source: peg$source,\n start: peg$savedPos,\n end: peg$currPos\n };\n }\n function location() {\n return peg$computeLocation(peg$savedPos, peg$currPos);\n }\n function expected(description, location2) {\n location2 = location2 !== void 0 ? location2 : peg$computeLocation(peg$savedPos, peg$currPos);\n throw peg$buildStructuredError(\n [peg$otherExpectation(description)],\n input.substring(peg$savedPos, peg$currPos),\n location2\n );\n }\n function error(message, location2) {\n location2 = location2 !== void 0 ? location2 : peg$computeLocation(peg$savedPos, peg$currPos);\n throw peg$buildSimpleError(message, location2);\n }\n function peg$literalExpectation(text2, ignoreCase) {\n return { type: \"literal\", text: text2, ignoreCase };\n }\n function peg$classExpectation(parts, inverted, ignoreCase) {\n return { type: \"class\", parts, inverted, ignoreCase };\n }\n function peg$anyExpectation() {\n return { type: \"any\" };\n }\n function peg$endExpectation() {\n return { type: \"end\" };\n }\n function peg$otherExpectation(description) {\n return { type: \"other\", description };\n }\n function peg$computePosDetails(pos) {\n var details = peg$posDetailsCache[pos];\n var p;\n if (details) {\n return details;\n } else {\n p = pos - 1;\n while (!peg$posDetailsCache[p]) {\n p--;\n }\n details = peg$posDetailsCache[p];\n details = {\n line: details.line,\n column: details.column\n };\n while (p < pos) {\n if (input.charCodeAt(p) === 10) {\n details.line++;\n details.column = 1;\n } else {\n details.column++;\n }\n p++;\n }\n peg$posDetailsCache[pos] = details;\n return details;\n }\n }\n function peg$computeLocation(startPos, endPos) {\n var startPosDetails = peg$computePosDetails(startPos);\n var endPosDetails = peg$computePosDetails(endPos);\n return {\n source: peg$source,\n start: {\n offset: startPos,\n line: startPosDetails.line,\n column: startPosDetails.column\n },\n end: {\n offset: endPos,\n line: endPosDetails.line,\n column: endPosDetails.column\n }\n };\n }\n function peg$fail(expected2) {\n if (peg$currPos < peg$maxFailPos) {\n return;\n }\n if (peg$currPos > peg$maxFailPos) {\n peg$maxFailPos = peg$currPos;\n peg$maxFailExpected = [];\n }\n peg$maxFailExpected.push(expected2);\n }\n function peg$buildSimpleError(message, location2) {\n return new peg$SyntaxError(message, null, null, location2);\n }\n function peg$buildStructuredError(expected2, found, location2) {\n return new peg$SyntaxError(\n peg$SyntaxError.buildMessage(expected2, found),\n expected2,\n found,\n location2\n );\n }\n function peg$parsestart() {\n var s0, s1, s2, s3;\n s0 = peg$currPos;\n s1 = peg$parsespec();\n if (s1 !== peg$FAILED) {\n s2 = peg$parseEOL();\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f0(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n if (s0 === peg$FAILED) {\n s0 = peg$currPos;\n s1 = peg$parsespec_list();\n if (s1 !== peg$FAILED) {\n s2 = peg$parseEOL();\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f1(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n if (s0 === peg$FAILED) {\n s0 = peg$currPos;\n s1 = peg$parsecolor();\n if (s1 !== peg$FAILED) {\n s2 = peg$parseEOL();\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f2(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n if (s0 === peg$FAILED) {\n s0 = peg$currPos;\n s1 = peg$parsemodel_list();\n if (s1 !== peg$FAILED) {\n s2 = peg$parseEOL();\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f3(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n if (s0 === peg$FAILED) {\n s0 = peg$currPos;\n s1 = peg$parsecolor_set_spec();\n if (s1 !== peg$FAILED) {\n s2 = peg$parseEOL();\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f4(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n if (s0 === peg$FAILED) {\n s0 = peg$currPos;\n s1 = peg$currPos;\n s2 = [];\n if (input.length > peg$currPos) {\n s3 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s3 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n while (s3 !== peg$FAILED) {\n s2.push(s3);\n if (input.length > peg$currPos) {\n s3 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s3 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n }\n s1 = input.substring(s1, peg$currPos);\n peg$savedPos = s0;\n s1 = peg$f5(s1);\n s0 = s1;\n }\n }\n }\n }\n }\n return s0;\n }\n function peg$parsecolor_set_spec() {\n var s0, s1, s2, s3, s4, s5;\n s0 = peg$currPos;\n s1 = peg$parsecolor_set_item();\n if (s1 !== peg$FAILED) {\n s2 = [];\n s3 = peg$currPos;\n if (input.charCodeAt(peg$currPos) === 59) {\n s4 = peg$c0;\n peg$currPos++;\n } else {\n s4 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e1);\n }\n }\n if (s4 !== peg$FAILED) {\n s5 = peg$parsecolor_set_item();\n if (s5 !== peg$FAILED) {\n peg$savedPos = s3;\n s3 = peg$f6(s1, s5);\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n while (s3 !== peg$FAILED) {\n s2.push(s3);\n s3 = peg$currPos;\n if (input.charCodeAt(peg$currPos) === 59) {\n s4 = peg$c0;\n peg$currPos++;\n } else {\n s4 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e1);\n }\n }\n if (s4 !== peg$FAILED) {\n s5 = peg$parsecolor_set_item();\n if (s5 !== peg$FAILED) {\n peg$savedPos = s3;\n s3 = peg$f6(s1, s5);\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n }\n peg$savedPos = s0;\n s0 = peg$f7(s1, s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parsecolor_set_item() {\n var s0, s1, s2, s3;\n s0 = peg$currPos;\n s1 = peg$parsename();\n if (s1 !== peg$FAILED) {\n if (input.charCodeAt(peg$currPos) === 44) {\n s2 = peg$c1;\n peg$currPos++;\n } else {\n s2 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e2);\n }\n }\n if (s2 !== peg$FAILED) {\n s3 = peg$parsespec_list();\n if (s3 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f8(s1, s3);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parsemodel_list() {\n var s0, s1, s2, s3;\n peg$silentFails++;\n s0 = peg$currPos;\n s1 = peg$parsecore_model();\n if (s1 !== peg$FAILED) {\n if (input.charCodeAt(peg$currPos) === 58) {\n s2 = peg$c2;\n peg$currPos++;\n } else {\n s2 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e4);\n }\n }\n if (s2 !== peg$FAILED) {\n s3 = peg$parsemodel_list_tail();\n if (s3 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f9(s1, s3);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n if (s0 === peg$FAILED) {\n s0 = peg$currPos;\n s1 = peg$parsemodel_list_tail();\n if (s1 !== peg$FAILED) {\n peg$savedPos = s0;\n s1 = peg$f10(s1);\n }\n s0 = s1;\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e3);\n }\n }\n return s0;\n }\n function peg$parsemodel_list_tail() {\n var s0, s1, s2, s3, s4, s5;\n s0 = peg$currPos;\n s1 = peg$parsemodel();\n if (s1 !== peg$FAILED) {\n s2 = [];\n s3 = peg$currPos;\n if (input.charCodeAt(peg$currPos) === 47) {\n s4 = peg$c3;\n peg$currPos++;\n } else {\n s4 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e5);\n }\n }\n if (s4 !== peg$FAILED) {\n s5 = peg$parsemodel();\n if (s5 !== peg$FAILED) {\n peg$savedPos = s3;\n s3 = peg$f11(s1, s5);\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n while (s3 !== peg$FAILED) {\n s2.push(s3);\n s3 = peg$currPos;\n if (input.charCodeAt(peg$currPos) === 47) {\n s4 = peg$c3;\n peg$currPos++;\n } else {\n s4 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e5);\n }\n }\n if (s4 !== peg$FAILED) {\n s5 = peg$parsemodel();\n if (s5 !== peg$FAILED) {\n peg$savedPos = s3;\n s3 = peg$f11(s1, s5);\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n }\n peg$savedPos = s0;\n s0 = peg$f12(s1, s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parsemodel() {\n var s0, s1;\n peg$silentFails++;\n s0 = peg$parsecore_model();\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e6);\n }\n }\n return s0;\n }\n function peg$parsespec_list() {\n var s0, s1, s2, s3, s4, s5;\n peg$silentFails++;\n s0 = peg$currPos;\n s1 = peg$parsespec();\n if (s1 !== peg$FAILED) {\n s2 = [];\n s3 = peg$currPos;\n if (input.charCodeAt(peg$currPos) === 47) {\n s4 = peg$c3;\n peg$currPos++;\n } else {\n s4 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e5);\n }\n }\n if (s4 !== peg$FAILED) {\n s5 = peg$parsespec();\n if (s5 !== peg$FAILED) {\n peg$savedPos = s3;\n s3 = peg$f13(s1, s5);\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n while (s3 !== peg$FAILED) {\n s2.push(s3);\n s3 = peg$currPos;\n if (input.charCodeAt(peg$currPos) === 47) {\n s4 = peg$c3;\n peg$currPos++;\n } else {\n s4 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e5);\n }\n }\n if (s4 !== peg$FAILED) {\n s5 = peg$parsespec();\n if (s5 !== peg$FAILED) {\n peg$savedPos = s3;\n s3 = peg$f13(s1, s5);\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n }\n peg$savedPos = s0;\n s0 = peg$f14(s1, s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e7);\n }\n }\n return s0;\n }\n function peg$parsespec() {\n var s0, s1, s2, s3, s4, s5, s6, s7, s8;\n peg$silentFails++;\n s0 = peg$currPos;\n s1 = peg$currPos;\n s2 = peg$currPos;\n s3 = peg$parsehex();\n if (s3 !== peg$FAILED) {\n s4 = peg$parsehex();\n if (s4 !== peg$FAILED) {\n s5 = peg$parsehex();\n if (s5 !== peg$FAILED) {\n s6 = peg$parsehex();\n if (s6 !== peg$FAILED) {\n s7 = peg$parsehex();\n if (s7 !== peg$FAILED) {\n s8 = peg$parsehex();\n if (s8 !== peg$FAILED) {\n s3 = [s3, s4, s5, s6, s7, s8];\n s2 = s3;\n } else {\n peg$currPos = s2;\n s2 = peg$FAILED;\n }\n } else {\n peg$currPos = s2;\n s2 = peg$FAILED;\n }\n } else {\n peg$currPos = s2;\n s2 = peg$FAILED;\n }\n } else {\n peg$currPos = s2;\n s2 = peg$FAILED;\n }\n } else {\n peg$currPos = s2;\n s2 = peg$FAILED;\n }\n } else {\n peg$currPos = s2;\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n s1 = input.substring(s1, peg$currPos);\n } else {\n s1 = s2;\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = s0;\n s1 = peg$f15(s1);\n }\n s0 = s1;\n if (s0 === peg$FAILED) {\n s0 = peg$currPos;\n s1 = peg$parsedec();\n if (s1 !== peg$FAILED) {\n s2 = [];\n s3 = peg$currPos;\n if (input.charCodeAt(peg$currPos) === 44) {\n s4 = peg$c1;\n peg$currPos++;\n } else {\n s4 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e2);\n }\n }\n if (s4 !== peg$FAILED) {\n s5 = peg$parsedec();\n if (s5 !== peg$FAILED) {\n peg$savedPos = s3;\n s3 = peg$f16(s1, s5);\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n if (s3 !== peg$FAILED) {\n while (s3 !== peg$FAILED) {\n s2.push(s3);\n s3 = peg$currPos;\n if (input.charCodeAt(peg$currPos) === 44) {\n s4 = peg$c1;\n peg$currPos++;\n } else {\n s4 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e2);\n }\n }\n if (s4 !== peg$FAILED) {\n s5 = peg$parsedec();\n if (s5 !== peg$FAILED) {\n peg$savedPos = s3;\n s3 = peg$f16(s1, s5);\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n }\n } else {\n s2 = peg$FAILED;\n }\n if (s2 === peg$FAILED) {\n s2 = [];\n s3 = peg$currPos;\n s4 = peg$parsesp();\n if (s4 !== peg$FAILED) {\n s5 = peg$parsedec();\n if (s5 !== peg$FAILED) {\n peg$savedPos = s3;\n s3 = peg$f17(s1, s5);\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n if (s3 !== peg$FAILED) {\n while (s3 !== peg$FAILED) {\n s2.push(s3);\n s3 = peg$currPos;\n s4 = peg$parsesp();\n if (s4 !== peg$FAILED) {\n s5 = peg$parsedec();\n if (s5 !== peg$FAILED) {\n peg$savedPos = s3;\n s3 = peg$f17(s1, s5);\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n } else {\n peg$currPos = s3;\n s3 = peg$FAILED;\n }\n }\n } else {\n s2 = peg$FAILED;\n }\n }\n if (s2 === peg$FAILED) {\n s2 = null;\n }\n peg$savedPos = s0;\n s0 = peg$f18(s1, s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e8);\n }\n }\n return s0;\n }\n function peg$parsecolor() {\n var s0, s1, s2, s3;\n peg$silentFails++;\n s0 = peg$currPos;\n s1 = peg$parsecolor_expr();\n if (s1 !== peg$FAILED) {\n s2 = [];\n s3 = peg$parsefunc_expr();\n while (s3 !== peg$FAILED) {\n s2.push(s3);\n s3 = peg$parsefunc_expr();\n }\n peg$savedPos = s0;\n s0 = peg$f19(s1, s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e9);\n }\n }\n return s0;\n }\n function peg$parsecolor_expr() {\n var s0;\n s0 = peg$parseext_expr();\n if (s0 === peg$FAILED) {\n s0 = peg$parseexpr();\n if (s0 === peg$FAILED) {\n s0 = peg$parsename();\n }\n }\n return s0;\n }\n function peg$parsefunc_expr() {\n var s0, s1, s2, s3, s4, s5, s6;\n peg$silentFails++;\n s0 = peg$currPos;\n if (input.charCodeAt(peg$currPos) === 62) {\n s1 = peg$c4;\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e11);\n }\n }\n if (s1 !== peg$FAILED) {\n s2 = peg$parsefunction();\n if (s2 !== peg$FAILED) {\n s3 = [];\n s4 = peg$currPos;\n if (input.charCodeAt(peg$currPos) === 44) {\n s5 = peg$c1;\n peg$currPos++;\n } else {\n s5 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e2);\n }\n }\n if (s5 !== peg$FAILED) {\n s6 = peg$parseint();\n if (s6 !== peg$FAILED) {\n peg$savedPos = s4;\n s4 = peg$f20(s2, s6);\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n while (s4 !== peg$FAILED) {\n s3.push(s4);\n s4 = peg$currPos;\n if (input.charCodeAt(peg$currPos) === 44) {\n s5 = peg$c1;\n peg$currPos++;\n } else {\n s5 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e2);\n }\n }\n if (s5 !== peg$FAILED) {\n s6 = peg$parseint();\n if (s6 !== peg$FAILED) {\n peg$savedPos = s4;\n s4 = peg$f20(s2, s6);\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n }\n peg$savedPos = s0;\n s0 = peg$f21(s2, s3);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e10);\n }\n }\n return s0;\n }\n function peg$parsefunction() {\n var s0, s1;\n peg$silentFails++;\n s0 = peg$parsename();\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e12);\n }\n }\n return s0;\n }\n function peg$parseext_expr() {\n var s0, s1, s2, s3, s4, s5, s6, s7;\n peg$silentFails++;\n s0 = peg$currPos;\n s1 = peg$parsecore_model();\n if (s1 !== peg$FAILED) {\n if (input.charCodeAt(peg$currPos) === 44) {\n s2 = peg$c1;\n peg$currPos++;\n } else {\n s2 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e2);\n }\n }\n if (s2 !== peg$FAILED) {\n s3 = peg$parsediv();\n if (s3 !== peg$FAILED) {\n if (input.charCodeAt(peg$currPos) === 58) {\n s4 = peg$c2;\n peg$currPos++;\n } else {\n s4 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e4);\n }\n }\n if (s4 !== peg$FAILED) {\n s5 = peg$parseweighted_expr();\n if (s5 !== peg$FAILED) {\n s6 = [];\n s7 = peg$parseadditional_weighted_expr();\n while (s7 !== peg$FAILED) {\n s6.push(s7);\n s7 = peg$parseadditional_weighted_expr();\n }\n peg$savedPos = s0;\n s0 = peg$f22(s1, s3, s5, s6);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n if (s0 === peg$FAILED) {\n s0 = peg$currPos;\n s1 = peg$parsecore_model();\n if (s1 !== peg$FAILED) {\n if (input.charCodeAt(peg$currPos) === 58) {\n s2 = peg$c2;\n peg$currPos++;\n } else {\n s2 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e4);\n }\n }\n if (s2 !== peg$FAILED) {\n s3 = peg$parseweighted_expr();\n if (s3 !== peg$FAILED) {\n s4 = [];\n s5 = peg$parseadditional_weighted_expr();\n while (s5 !== peg$FAILED) {\n s4.push(s5);\n s5 = peg$parseadditional_weighted_expr();\n }\n peg$savedPos = s0;\n s0 = peg$f23(s1, s3, s4);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e13);\n }\n }\n return s0;\n }\n function peg$parseweighted_expr() {\n var s0, s1, s2, s3;\n s0 = peg$currPos;\n s1 = peg$parseexpr();\n if (s1 !== peg$FAILED) {\n if (input.charCodeAt(peg$currPos) === 44) {\n s2 = peg$c1;\n peg$currPos++;\n } else {\n s2 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e2);\n }\n }\n if (s2 !== peg$FAILED) {\n s3 = peg$parsedec();\n if (s3 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f24(s1, s3);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parseadditional_weighted_expr() {\n var s0, s1, s2;\n s0 = peg$currPos;\n if (input.charCodeAt(peg$currPos) === 59) {\n s1 = peg$c0;\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e1);\n }\n }\n if (s1 !== peg$FAILED) {\n s2 = peg$parseweighted_expr();\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f25(s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parsecore_model() {\n var s0, s1;\n peg$silentFails++;\n s0 = peg$parsename();\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e14);\n }\n }\n return s0;\n }\n function peg$parseexpr() {\n var s0, s1, s2, s3, s4;\n peg$silentFails++;\n s0 = peg$currPos;\n s1 = peg$parseprefix();\n s2 = peg$parsename();\n if (s2 !== peg$FAILED) {\n s3 = peg$parsemix_expr();\n s4 = peg$parsepostfix();\n if (s4 === peg$FAILED) {\n s4 = null;\n }\n peg$savedPos = s0;\n s0 = peg$f26(s1, s2, s3, s4);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e15);\n }\n }\n return s0;\n }\n function peg$parsecomplete_mix() {\n var s0, s1, s2, s3, s4;\n s0 = peg$currPos;\n if (input.charCodeAt(peg$currPos) === 33) {\n s1 = peg$c5;\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e16);\n }\n }\n if (s1 !== peg$FAILED) {\n s2 = peg$parsepct();\n if (s2 !== peg$FAILED) {\n if (input.charCodeAt(peg$currPos) === 33) {\n s3 = peg$c5;\n peg$currPos++;\n } else {\n s3 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e16);\n }\n }\n if (s3 !== peg$FAILED) {\n s4 = peg$parsename();\n if (s4 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f27(s2, s4);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parsepartial_mix() {\n var s0, s1, s2;\n s0 = peg$currPos;\n if (input.charCodeAt(peg$currPos) === 33) {\n s1 = peg$c5;\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e16);\n }\n }\n if (s1 !== peg$FAILED) {\n s2 = peg$parsepct();\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f28(s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parsemix_expr() {\n var s0, s1, s2;\n peg$silentFails++;\n s0 = peg$currPos;\n s1 = [];\n s2 = peg$parsecomplete_mix();\n while (s2 !== peg$FAILED) {\n s1.push(s2);\n s2 = peg$parsecomplete_mix();\n }\n s2 = peg$parsepartial_mix();\n if (s2 === peg$FAILED) {\n s2 = null;\n }\n peg$savedPos = s0;\n s0 = peg$f29(s1, s2);\n peg$silentFails--;\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e17);\n }\n return s0;\n }\n function peg$parsename() {\n var s0, s1, s2;\n peg$silentFails++;\n if (input.charCodeAt(peg$currPos) === 46) {\n s0 = peg$c6;\n peg$currPos++;\n } else {\n s0 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e19);\n }\n }\n if (s0 === peg$FAILED) {\n s0 = peg$currPos;\n s1 = [];\n if (peg$r0.test(input.charAt(peg$currPos))) {\n s2 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s2 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e20);\n }\n }\n if (s2 !== peg$FAILED) {\n while (s2 !== peg$FAILED) {\n s1.push(s2);\n if (peg$r0.test(input.charAt(peg$currPos))) {\n s2 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s2 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e20);\n }\n }\n }\n } else {\n s1 = peg$FAILED;\n }\n if (s1 !== peg$FAILED) {\n s0 = input.substring(s0, peg$currPos);\n } else {\n s0 = s1;\n }\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e18);\n }\n }\n return s0;\n }\n function peg$parsepostfix() {\n var s0, s1, s2, s3, s4;\n peg$silentFails++;\n s0 = peg$currPos;\n if (input.substr(peg$currPos, 3) === peg$c7) {\n s1 = peg$c7;\n peg$currPos += 3;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e22);\n }\n }\n if (s1 !== peg$FAILED) {\n s2 = peg$parsenum();\n if (s2 !== peg$FAILED) {\n if (input.charCodeAt(peg$currPos) === 93) {\n s3 = peg$c8;\n peg$currPos++;\n } else {\n s3 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e23);\n }\n }\n if (s3 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f30(s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n if (s0 === peg$FAILED) {\n s0 = peg$currPos;\n if (input.substr(peg$currPos, 2) === peg$c9) {\n s1 = peg$c9;\n peg$currPos += 2;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e24);\n }\n }\n if (s1 !== peg$FAILED) {\n s2 = peg$currPos;\n s3 = [];\n s4 = peg$parseplus();\n if (s4 !== peg$FAILED) {\n while (s4 !== peg$FAILED) {\n s3.push(s4);\n s4 = peg$parseplus();\n }\n } else {\n s3 = peg$FAILED;\n }\n if (s3 !== peg$FAILED) {\n s2 = input.substring(s2, peg$currPos);\n } else {\n s2 = s3;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f31(s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e21);\n }\n }\n return s0;\n }\n function peg$parseprefix() {\n var s0, s1;\n peg$silentFails++;\n s0 = peg$parseminus();\n if (s0 === peg$FAILED) {\n s0 = null;\n }\n peg$silentFails--;\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e25);\n }\n return s0;\n }\n function peg$parseplus() {\n var s0, s1, s2;\n peg$silentFails++;\n s0 = peg$currPos;\n s1 = [];\n if (input.charCodeAt(peg$currPos) === 43) {\n s2 = peg$c10;\n peg$currPos++;\n } else {\n s2 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e27);\n }\n }\n if (s2 !== peg$FAILED) {\n while (s2 !== peg$FAILED) {\n s1.push(s2);\n if (input.charCodeAt(peg$currPos) === 43) {\n s2 = peg$c10;\n peg$currPos++;\n } else {\n s2 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e27);\n }\n }\n }\n } else {\n s1 = peg$FAILED;\n }\n if (s1 !== peg$FAILED) {\n s0 = input.substring(s0, peg$currPos);\n } else {\n s0 = s1;\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e26);\n }\n }\n return s0;\n }\n function peg$parseminus() {\n var s0, s1, s2;\n peg$silentFails++;\n s0 = peg$currPos;\n s1 = [];\n if (input.charCodeAt(peg$currPos) === 45) {\n s2 = peg$c11;\n peg$currPos++;\n } else {\n s2 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e29);\n }\n }\n if (s2 !== peg$FAILED) {\n while (s2 !== peg$FAILED) {\n s1.push(s2);\n if (input.charCodeAt(peg$currPos) === 45) {\n s2 = peg$c11;\n peg$currPos++;\n } else {\n s2 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e29);\n }\n }\n }\n } else {\n s1 = peg$FAILED;\n }\n if (s1 !== peg$FAILED) {\n s0 = input.substring(s0, peg$currPos);\n } else {\n s0 = s1;\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e28);\n }\n }\n return s0;\n }\n function peg$parsenum() {\n var s0, s1, s2, s3;\n peg$silentFails++;\n s0 = peg$currPos;\n s1 = peg$currPos;\n s2 = [];\n if (peg$r1.test(input.charAt(peg$currPos))) {\n s3 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s3 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e31);\n }\n }\n if (s3 !== peg$FAILED) {\n while (s3 !== peg$FAILED) {\n s2.push(s3);\n if (peg$r1.test(input.charAt(peg$currPos))) {\n s3 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s3 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e31);\n }\n }\n }\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n s1 = input.substring(s1, peg$currPos);\n } else {\n s1 = s2;\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = s0;\n s1 = peg$f32(s1);\n }\n s0 = s1;\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e30);\n }\n }\n return s0;\n }\n function peg$parsepct() {\n var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;\n peg$silentFails++;\n s0 = peg$currPos;\n s1 = peg$currPos;\n s2 = peg$currPos;\n s3 = peg$currPos;\n s4 = [];\n if (peg$r1.test(input.charAt(peg$currPos))) {\n s5 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s5 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e31);\n }\n }\n if (s5 !== peg$FAILED) {\n while (s5 !== peg$FAILED) {\n s4.push(s5);\n if (peg$r1.test(input.charAt(peg$currPos))) {\n s5 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s5 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e31);\n }\n }\n }\n } else {\n s4 = peg$FAILED;\n }\n if (s4 !== peg$FAILED) {\n s3 = input.substring(s3, peg$currPos);\n } else {\n s3 = s4;\n }\n if (s3 !== peg$FAILED) {\n s4 = peg$currPos;\n s5 = peg$currPos;\n if (input.charCodeAt(peg$currPos) === 46) {\n s6 = peg$c6;\n peg$currPos++;\n } else {\n s6 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e19);\n }\n }\n if (s6 !== peg$FAILED) {\n s7 = peg$currPos;\n s8 = [];\n if (peg$r1.test(input.charAt(peg$currPos))) {\n s9 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s9 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e31);\n }\n }\n while (s9 !== peg$FAILED) {\n s8.push(s9);\n if (peg$r1.test(input.charAt(peg$currPos))) {\n s9 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s9 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e31);\n }\n }\n }\n s7 = input.substring(s7, peg$currPos);\n s6 = [s6, s7];\n s5 = s6;\n } else {\n peg$currPos = s5;\n s5 = peg$FAILED;\n }\n if (s5 === peg$FAILED) {\n s5 = null;\n }\n s4 = input.substring(s4, peg$currPos);\n s3 = [s3, s4];\n s2 = s3;\n } else {\n peg$currPos = s2;\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n s1 = input.substring(s1, peg$currPos);\n } else {\n s1 = s2;\n }\n if (s1 === peg$FAILED) {\n s1 = peg$currPos;\n s2 = peg$currPos;\n if (input.charCodeAt(peg$currPos) === 46) {\n s3 = peg$c6;\n peg$currPos++;\n } else {\n s3 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e19);\n }\n }\n if (s3 !== peg$FAILED) {\n s4 = peg$currPos;\n s5 = [];\n if (peg$r1.test(input.charAt(peg$currPos))) {\n s6 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s6 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e31);\n }\n }\n if (s6 !== peg$FAILED) {\n while (s6 !== peg$FAILED) {\n s5.push(s6);\n if (peg$r1.test(input.charAt(peg$currPos))) {\n s6 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s6 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e31);\n }\n }\n }\n } else {\n s5 = peg$FAILED;\n }\n if (s5 !== peg$FAILED) {\n s4 = input.substring(s4, peg$currPos);\n } else {\n s4 = s5;\n }\n if (s4 !== peg$FAILED) {\n s3 = [s3, s4];\n s2 = s3;\n } else {\n peg$currPos = s2;\n s2 = peg$FAILED;\n }\n } else {\n peg$currPos = s2;\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n s1 = input.substring(s1, peg$currPos);\n } else {\n s1 = s2;\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = s0;\n s1 = peg$f33(s1);\n }\n s0 = s1;\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e32);\n }\n }\n return s0;\n }\n function peg$parsediv() {\n var s0, s1;\n peg$silentFails++;\n s0 = peg$parsepct();\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e33);\n }\n }\n return s0;\n }\n function peg$parsedec() {\n var s0, s1, s2;\n s0 = peg$parsepct();\n if (s0 === peg$FAILED) {\n s0 = peg$currPos;\n if (input.charCodeAt(peg$currPos) === 43) {\n s1 = peg$c10;\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e27);\n }\n }\n if (s1 !== peg$FAILED) {\n s2 = peg$parsepct();\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f34(s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n if (s0 === peg$FAILED) {\n s0 = peg$currPos;\n if (input.charCodeAt(peg$currPos) === 45) {\n s1 = peg$c11;\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e29);\n }\n }\n if (s1 !== peg$FAILED) {\n s2 = peg$parsepct();\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f35(s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n }\n }\n return s0;\n }\n function peg$parseint() {\n var s0, s1, s2;\n peg$silentFails++;\n s0 = peg$currPos;\n s1 = peg$parseminus();\n if (s1 === peg$FAILED) {\n s1 = null;\n }\n s2 = peg$parsenum();\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f36(s1, s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e34);\n }\n }\n return s0;\n }\n function peg$parse_() {\n var s0, s1;\n peg$silentFails++;\n s0 = [];\n if (peg$r2.test(input.charAt(peg$currPos))) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e36);\n }\n }\n while (s1 !== peg$FAILED) {\n s0.push(s1);\n if (peg$r2.test(input.charAt(peg$currPos))) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e36);\n }\n }\n }\n peg$silentFails--;\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e35);\n }\n return s0;\n }\n function peg$parsesp() {\n var s0, s1;\n s0 = [];\n if (peg$r2.test(input.charAt(peg$currPos))) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e36);\n }\n }\n if (s1 !== peg$FAILED) {\n while (s1 !== peg$FAILED) {\n s0.push(s1);\n if (peg$r2.test(input.charAt(peg$currPos))) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e36);\n }\n }\n }\n } else {\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parsehex() {\n var s0, s1;\n s0 = peg$currPos;\n if (peg$r3.test(input.charAt(peg$currPos))) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e37);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = s0;\n s1 = peg$f37(s1);\n }\n s0 = s1;\n return s0;\n }\n function peg$parseEOL() {\n var s0, s1;\n s0 = peg$currPos;\n peg$silentFails++;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n peg$silentFails--;\n if (s1 === peg$FAILED) {\n s0 = void 0;\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n peg$result = peg$startRuleFunction();\n if (peg$result !== peg$FAILED && peg$currPos === input.length) {\n return peg$result;\n } else {\n if (peg$result !== peg$FAILED && peg$currPos < input.length) {\n peg$fail(peg$endExpectation());\n }\n throw peg$buildStructuredError(\n peg$maxFailExpected,\n peg$maxFailPos < input.length ? input.charAt(peg$maxFailPos) : null,\n peg$maxFailPos < input.length ? peg$computeLocation(peg$maxFailPos, peg$maxFailPos + 1) : peg$computeLocation(peg$maxFailPos, peg$maxFailPos)\n );\n }\n }\n return {\n SyntaxError: peg$SyntaxError,\n parse: peg$parse\n };\n }()\n);\n\n// grammars/tabular-spec.pegjs\nvar tabular_spec_default = (\n // Generated by Peggy 2.0.1.\n //\n // https://peggyjs.org/\n function() {\n \"use strict\";\n function peg$subclass(child, parent) {\n function C() {\n this.constructor = child;\n }\n C.prototype = parent.prototype;\n child.prototype = new C();\n }\n function peg$SyntaxError(message, expected, found, location) {\n var self = Error.call(this, message);\n if (Object.setPrototypeOf) {\n Object.setPrototypeOf(self, peg$SyntaxError.prototype);\n }\n self.expected = expected;\n self.found = found;\n self.location = location;\n self.name = \"SyntaxError\";\n return self;\n }\n peg$subclass(peg$SyntaxError, Error);\n function peg$padEnd(str, targetLength, padString) {\n padString = padString || \" \";\n if (str.length > targetLength) {\n return str;\n }\n targetLength -= str.length;\n padString += padString.repeat(targetLength);\n return str + padString.slice(0, targetLength);\n }\n peg$SyntaxError.prototype.format = function(sources) {\n var str = \"Error: \" + this.message;\n if (this.location) {\n var src = null;\n var k;\n for (k = 0; k < sources.length; k++) {\n if (sources[k].source === this.location.source) {\n src = sources[k].text.split(/\\r\\n|\\n|\\r/g);\n break;\n }\n }\n var s = this.location.start;\n var loc = this.location.source + \":\" + s.line + \":\" + s.column;\n if (src) {\n var e = this.location.end;\n var filler = peg$padEnd(\"\", s.line.toString().length, \" \");\n var line = src[s.line - 1];\n var last = s.line === e.line ? e.column : line.length + 1;\n var hatLen = last - s.column || 1;\n str += \"\\n --> \" + loc + \"\\n\" + filler + \" |\\n\" + s.line + \" | \" + line + \"\\n\" + filler + \" | \" + peg$padEnd(\"\", s.column - 1, \" \") + peg$padEnd(\"\", hatLen, \"^\");\n } else {\n str += \"\\n at \" + loc;\n }\n }\n return str;\n };\n peg$SyntaxError.buildMessage = function(expected, found) {\n var DESCRIBE_EXPECTATION_FNS = {\n literal: function(expectation) {\n return '\"' + literalEscape(expectation.text) + '\"';\n },\n class: function(expectation) {\n var escapedParts = expectation.parts.map(function(part) {\n return Array.isArray(part) ? classEscape(part[0]) + \"-\" + classEscape(part[1]) : classEscape(part);\n });\n return \"[\" + (expectation.inverted ? \"^\" : \"\") + escapedParts.join(\"\") + \"]\";\n },\n any: function() {\n return \"any character\";\n },\n end: function() {\n return \"end of input\";\n },\n other: function(expectation) {\n return expectation.description;\n }\n };\n function hex(ch) {\n return ch.charCodeAt(0).toString(16).toUpperCase();\n }\n function literalEscape(s) {\n return s.replace(/\\\\/g, \"\\\\\\\\\").replace(/\"/g, '\\\\\"').replace(/\\0/g, \"\\\\0\").replace(/\\t/g, \"\\\\t\").replace(/\\n/g, \"\\\\n\").replace(/\\r/g, \"\\\\r\").replace(/[\\x00-\\x0F]/g, function(ch) {\n return \"\\\\x0\" + hex(ch);\n }).replace(/[\\x10-\\x1F\\x7F-\\x9F]/g, function(ch) {\n return \"\\\\x\" + hex(ch);\n });\n }\n function classEscape(s) {\n return s.replace(/\\\\/g, \"\\\\\\\\\").replace(/\\]/g, \"\\\\]\").replace(/\\^/g, \"\\\\^\").replace(/-/g, \"\\\\-\").replace(/\\0/g, \"\\\\0\").replace(/\\t/g, \"\\\\t\").replace(/\\n/g, \"\\\\n\").replace(/\\r/g, \"\\\\r\").replace(/[\\x00-\\x0F]/g, function(ch) {\n return \"\\\\x0\" + hex(ch);\n }).replace(/[\\x10-\\x1F\\x7F-\\x9F]/g, function(ch) {\n return \"\\\\x\" + hex(ch);\n });\n }\n function describeExpectation(expectation) {\n return DESCRIBE_EXPECTATION_FNS[expectation.type](expectation);\n }\n function describeExpected(expected2) {\n var descriptions = expected2.map(describeExpectation);\n var i, j;\n descriptions.sort();\n if (descriptions.length > 0) {\n for (i = 1, j = 1; i < descriptions.length; i++) {\n if (descriptions[i - 1] !== descriptions[i]) {\n descriptions[j] = descriptions[i];\n j++;\n }\n }\n descriptions.length = j;\n }\n switch (descriptions.length) {\n case 1:\n return descriptions[0];\n case 2:\n return descriptions[0] + \" or \" + descriptions[1];\n default:\n return descriptions.slice(0, -1).join(\", \") + \", or \" + descriptions[descriptions.length - 1];\n }\n }\n function describeFound(found2) {\n return found2 ? '\"' + literalEscape(found2) + '\"' : \"end of input\";\n }\n return \"Expected \" + describeExpected(expected) + \" but \" + describeFound(found) + \" found.\";\n };\n function peg$parse(input, options) {\n options = options !== void 0 ? options : {};\n var peg$FAILED = {};\n var peg$source = options.grammarSource;\n var peg$startRuleFunctions = { body: peg$parsebody };\n var peg$startRuleFunction = peg$parsebody;\n var peg$e0 = peg$otherExpectation(\"decl_start\");\n var peg$e1 = peg$otherExpectation(\"decl_end\");\n var peg$e2 = peg$otherExpectation(\"vert\");\n var peg$e3 = peg$anyExpectation();\n var peg$e4 = peg$otherExpectation(\"l\");\n var peg$e5 = peg$otherExpectation(\"r\");\n var peg$e6 = peg$otherExpectation(\"c\");\n var peg$e7 = peg$otherExpectation(\"p\");\n var peg$e8 = peg$otherExpectation(\"m\");\n var peg$e9 = peg$otherExpectation(\"b\");\n var peg$e10 = peg$otherExpectation(\"w\");\n var peg$e11 = peg$otherExpectation(\"W\");\n var peg$e12 = peg$otherExpectation(\"X\");\n var peg$e13 = peg$otherExpectation(\"!\");\n var peg$e14 = peg$otherExpectation(\"@\");\n var peg$e15 = peg$otherExpectation(\"<\");\n var peg$e16 = peg$otherExpectation(\">\");\n var peg$e17 = peg$otherExpectation(\"group\");\n var peg$e18 = peg$otherExpectation(\"whitespace\");\n var peg$f0 = function(c) {\n return c;\n };\n var peg$f1 = function(cols) {\n return cols;\n };\n var peg$f2 = function() {\n return [];\n };\n var peg$f3 = function(divs1, start, a, end, divs2) {\n return {\n type: \"column\",\n pre_dividers: divs1,\n post_dividers: divs2,\n before_start_code: start,\n before_end_code: end,\n alignment: a\n };\n };\n var peg$f4 = function() {\n return {\n type: \"vert_divider\"\n };\n };\n var peg$f5 = function(b, g) {\n return {\n type: \"bang_divider\",\n content: g[0].content\n };\n };\n var peg$f6 = function(g) {\n return {\n type: \"at_divider\",\n content: g[0].content\n };\n };\n var peg$f7 = function(div) {\n return div;\n };\n var peg$f8 = function(g) {\n return { type: \"decl_code\", code: g[0].content };\n };\n var peg$f9 = function(g) {\n return { type: \"decl_code\", code: g[0].content };\n };\n var peg$f10 = function() {\n return { type: \"alignment\", alignment: \"left\" };\n };\n var peg$f11 = function() {\n return { type: \"alignment\", alignment: \"center\" };\n };\n var peg$f12 = function() {\n return { type: \"alignment\", alignment: \"right\" };\n };\n var peg$f13 = function() {\n return { type: \"alignment\", alignment: \"X\" };\n };\n var peg$f14 = function() {\n return \"top\";\n };\n var peg$f15 = function() {\n return \"default\";\n };\n var peg$f16 = function() {\n return \"bottom\";\n };\n var peg$f17 = function(a, g) {\n return {\n type: \"alignment\",\n alignment: \"parbox\",\n baseline: a,\n size: g[0].content\n };\n };\n var peg$f18 = function(g1, g2) {\n return {\n type: \"alignment\",\n alignment: \"parbox\",\n baseline: g1[0].content,\n size: g2[0].content\n };\n };\n var peg$f19 = function(tok) {\n return options.matchChar(tok, \"|\");\n };\n var peg$f20 = function(tok) {\n return options.matchChar(tok, \"l\");\n };\n var peg$f21 = function(tok) {\n return options.matchChar(tok, \"r\");\n };\n var peg$f22 = function(tok) {\n return options.matchChar(tok, \"c\");\n };\n var peg$f23 = function(tok) {\n return options.matchChar(tok, \"p\");\n };\n var peg$f24 = function(tok) {\n return options.matchChar(tok, \"m\");\n };\n var peg$f25 = function(tok) {\n return options.matchChar(tok, \"b\");\n };\n var peg$f26 = function(tok) {\n return options.matchChar(tok, \"w\");\n };\n var peg$f27 = function(tok) {\n return options.matchChar(tok, \"W\");\n };\n var peg$f28 = function(tok) {\n return options.matchChar(tok, \"X\");\n };\n var peg$f29 = function(tok) {\n return options.matchChar(tok, \"!\");\n };\n var peg$f30 = function(tok) {\n return options.matchChar(tok, \"@\");\n };\n var peg$f31 = function(tok) {\n return options.matchChar(tok, \"<\");\n };\n var peg$f32 = function(tok) {\n return options.matchChar(tok, \">\");\n };\n var peg$f33 = function(tok) {\n return options.isGroup(tok);\n };\n var peg$f34 = function(tok) {\n return options.isWhitespace(tok);\n };\n var peg$currPos = 0;\n var peg$savedPos = 0;\n var peg$posDetailsCache = [{ line: 1, column: 1 }];\n var peg$maxFailPos = 0;\n var peg$maxFailExpected = [];\n var peg$silentFails = 0;\n var peg$result;\n if (\"startRule\" in options) {\n if (!(options.startRule in peg$startRuleFunctions)) {\n throw new Error(`Can't start parsing from rule \"` + options.startRule + '\".');\n }\n peg$startRuleFunction = peg$startRuleFunctions[options.startRule];\n }\n function text() {\n return input.substring(peg$savedPos, peg$currPos);\n }\n function offset() {\n return peg$savedPos;\n }\n function range() {\n return {\n source: peg$source,\n start: peg$savedPos,\n end: peg$currPos\n };\n }\n function location() {\n return peg$computeLocation(peg$savedPos, peg$currPos);\n }\n function expected(description, location2) {\n location2 = location2 !== void 0 ? location2 : peg$computeLocation(peg$savedPos, peg$currPos);\n throw peg$buildStructuredError(\n [peg$otherExpectation(description)],\n input.substring(peg$savedPos, peg$currPos),\n location2\n );\n }\n function error(message, location2) {\n location2 = location2 !== void 0 ? location2 : peg$computeLocation(peg$savedPos, peg$currPos);\n throw peg$buildSimpleError(message, location2);\n }\n function peg$literalExpectation(text2, ignoreCase) {\n return { type: \"literal\", text: text2, ignoreCase };\n }\n function peg$classExpectation(parts, inverted, ignoreCase) {\n return { type: \"class\", parts, inverted, ignoreCase };\n }\n function peg$anyExpectation() {\n return { type: \"any\" };\n }\n function peg$endExpectation() {\n return { type: \"end\" };\n }\n function peg$otherExpectation(description) {\n return { type: \"other\", description };\n }\n function peg$computePosDetails(pos) {\n var details = peg$posDetailsCache[pos];\n var p;\n if (details) {\n return details;\n } else {\n p = pos - 1;\n while (!peg$posDetailsCache[p]) {\n p--;\n }\n details = peg$posDetailsCache[p];\n details = {\n line: details.line,\n column: details.column\n };\n while (p < pos) {\n if (input.charCodeAt(p) === 10) {\n details.line++;\n details.column = 1;\n } else {\n details.column++;\n }\n p++;\n }\n peg$posDetailsCache[pos] = details;\n return details;\n }\n }\n function peg$computeLocation(startPos, endPos) {\n var startPosDetails = peg$computePosDetails(startPos);\n var endPosDetails = peg$computePosDetails(endPos);\n return {\n source: peg$source,\n start: {\n offset: startPos,\n line: startPosDetails.line,\n column: startPosDetails.column\n },\n end: {\n offset: endPos,\n line: endPosDetails.line,\n column: endPosDetails.column\n }\n };\n }\n function peg$fail(expected2) {\n if (peg$currPos < peg$maxFailPos) {\n return;\n }\n if (peg$currPos > peg$maxFailPos) {\n peg$maxFailPos = peg$currPos;\n peg$maxFailExpected = [];\n }\n peg$maxFailExpected.push(expected2);\n }\n function peg$buildSimpleError(message, location2) {\n return new peg$SyntaxError(message, null, null, location2);\n }\n function peg$buildStructuredError(expected2, found, location2) {\n return new peg$SyntaxError(\n peg$SyntaxError.buildMessage(expected2, found),\n expected2,\n found,\n location2\n );\n }\n function peg$parsebody() {\n var s0, s1, s2, s3, s4, s5;\n s0 = peg$currPos;\n s1 = [];\n s2 = peg$currPos;\n s3 = peg$parsecolumn();\n if (s3 !== peg$FAILED) {\n s4 = [];\n s5 = peg$parse_();\n while (s5 !== peg$FAILED) {\n s4.push(s5);\n s5 = peg$parse_();\n }\n peg$savedPos = s2;\n s2 = peg$f0(s3);\n } else {\n peg$currPos = s2;\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n while (s2 !== peg$FAILED) {\n s1.push(s2);\n s2 = peg$currPos;\n s3 = peg$parsecolumn();\n if (s3 !== peg$FAILED) {\n s4 = [];\n s5 = peg$parse_();\n while (s5 !== peg$FAILED) {\n s4.push(s5);\n s5 = peg$parse_();\n }\n peg$savedPos = s2;\n s2 = peg$f0(s3);\n } else {\n peg$currPos = s2;\n s2 = peg$FAILED;\n }\n }\n } else {\n s1 = peg$FAILED;\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = s0;\n s1 = peg$f1(s1);\n }\n s0 = s1;\n if (s0 === peg$FAILED) {\n s0 = peg$currPos;\n s1 = peg$parseEOL();\n if (s1 !== peg$FAILED) {\n peg$savedPos = s0;\n s1 = peg$f2();\n }\n s0 = s1;\n }\n return s0;\n }\n function peg$parsecolumn() {\n var s0, s1, s2, s3, s4, s5, s6;\n s0 = peg$currPos;\n s1 = [];\n s2 = peg$parsecolumn_divider();\n while (s2 !== peg$FAILED) {\n s1.push(s2);\n s2 = peg$parsecolumn_divider();\n }\n s2 = peg$parsedecl_start();\n if (s2 === peg$FAILED) {\n s2 = null;\n }\n s3 = peg$parsealignment();\n if (s3 !== peg$FAILED) {\n s4 = peg$parsedecl_end();\n if (s4 === peg$FAILED) {\n s4 = null;\n }\n s5 = [];\n s6 = peg$parsecolumn_divider();\n while (s6 !== peg$FAILED) {\n s5.push(s6);\n s6 = peg$parsecolumn_divider();\n }\n peg$savedPos = s0;\n s0 = peg$f3(s1, s2, s3, s4, s5);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parsecolumn_divider() {\n var s0, s1, s2, s3, s4;\n s0 = peg$currPos;\n s1 = [];\n s2 = peg$parse_();\n while (s2 !== peg$FAILED) {\n s1.push(s2);\n s2 = peg$parse_();\n }\n s2 = peg$currPos;\n s3 = peg$parsevert();\n if (s3 !== peg$FAILED) {\n peg$savedPos = s2;\n s3 = peg$f4();\n }\n s2 = s3;\n if (s2 === peg$FAILED) {\n s2 = peg$currPos;\n s3 = peg$parsebang();\n if (s3 !== peg$FAILED) {\n s4 = peg$parsegroup();\n if (s4 !== peg$FAILED) {\n peg$savedPos = s2;\n s2 = peg$f5(s3, s4);\n } else {\n peg$currPos = s2;\n s2 = peg$FAILED;\n }\n } else {\n peg$currPos = s2;\n s2 = peg$FAILED;\n }\n if (s2 === peg$FAILED) {\n s2 = peg$currPos;\n s3 = peg$parseat();\n if (s3 !== peg$FAILED) {\n s4 = peg$parsegroup();\n if (s4 !== peg$FAILED) {\n peg$savedPos = s2;\n s2 = peg$f6(s4);\n } else {\n peg$currPos = s2;\n s2 = peg$FAILED;\n }\n } else {\n peg$currPos = s2;\n s2 = peg$FAILED;\n }\n }\n }\n if (s2 !== peg$FAILED) {\n s3 = [];\n s4 = peg$parse_();\n while (s4 !== peg$FAILED) {\n s3.push(s4);\n s4 = peg$parse_();\n }\n peg$savedPos = s0;\n s0 = peg$f7(s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parsedecl_start() {\n var s0, s1, s2;\n peg$silentFails++;\n s0 = peg$currPos;\n s1 = peg$parsegreater();\n if (s1 !== peg$FAILED) {\n s2 = peg$parsegroup();\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f8(s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n return s0;\n }\n function peg$parsedecl_end() {\n var s0, s1, s2;\n peg$silentFails++;\n s0 = peg$currPos;\n s1 = peg$parseless();\n if (s1 !== peg$FAILED) {\n s2 = peg$parsegroup();\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f9(s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e1);\n }\n }\n return s0;\n }\n function peg$parsealignment() {\n var s0, s1, s2, s3, s4, s5;\n s0 = peg$currPos;\n s1 = peg$parsel();\n if (s1 !== peg$FAILED) {\n peg$savedPos = s0;\n s1 = peg$f10();\n }\n s0 = s1;\n if (s0 === peg$FAILED) {\n s0 = peg$currPos;\n s1 = peg$parsec();\n if (s1 !== peg$FAILED) {\n peg$savedPos = s0;\n s1 = peg$f11();\n }\n s0 = s1;\n if (s0 === peg$FAILED) {\n s0 = peg$currPos;\n s1 = peg$parser();\n if (s1 !== peg$FAILED) {\n peg$savedPos = s0;\n s1 = peg$f12();\n }\n s0 = s1;\n if (s0 === peg$FAILED) {\n s0 = peg$currPos;\n s1 = peg$parseX();\n if (s1 !== peg$FAILED) {\n peg$savedPos = s0;\n s1 = peg$f13();\n }\n s0 = s1;\n if (s0 === peg$FAILED) {\n s0 = peg$currPos;\n s1 = peg$currPos;\n s2 = peg$parsep();\n if (s2 !== peg$FAILED) {\n peg$savedPos = s1;\n s2 = peg$f14();\n }\n s1 = s2;\n if (s1 === peg$FAILED) {\n s1 = peg$currPos;\n s2 = peg$parsem();\n if (s2 !== peg$FAILED) {\n peg$savedPos = s1;\n s2 = peg$f15();\n }\n s1 = s2;\n if (s1 === peg$FAILED) {\n s1 = peg$currPos;\n s2 = peg$parseb();\n if (s2 !== peg$FAILED) {\n peg$savedPos = s1;\n s2 = peg$f16();\n }\n s1 = s2;\n }\n }\n if (s1 !== peg$FAILED) {\n s2 = [];\n s3 = peg$parse_();\n while (s3 !== peg$FAILED) {\n s2.push(s3);\n s3 = peg$parse_();\n }\n s3 = peg$parsegroup();\n if (s3 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f17(s1, s3);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n if (s0 === peg$FAILED) {\n s0 = peg$currPos;\n s1 = peg$parsew();\n if (s1 === peg$FAILED) {\n s1 = peg$parseW();\n }\n if (s1 !== peg$FAILED) {\n s2 = [];\n s3 = peg$parse_();\n while (s3 !== peg$FAILED) {\n s2.push(s3);\n s3 = peg$parse_();\n }\n s3 = peg$parsegroup();\n if (s3 !== peg$FAILED) {\n s4 = [];\n s5 = peg$parse_();\n while (s5 !== peg$FAILED) {\n s4.push(s5);\n s5 = peg$parse_();\n }\n s5 = peg$parsegroup();\n if (s5 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f18(s3, s5);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n }\n }\n }\n }\n }\n return s0;\n }\n function peg$parsevert() {\n var s0, s1, s2;\n peg$silentFails++;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e3);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f19(s1);\n if (s2) {\n s2 = void 0;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n s1 = [s1, s2];\n s0 = s1;\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e2);\n }\n }\n return s0;\n }\n function peg$parsel() {\n var s0, s1, s2;\n peg$silentFails++;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e3);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f20(s1);\n if (s2) {\n s2 = void 0;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n s1 = [s1, s2];\n s0 = s1;\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e4);\n }\n }\n return s0;\n }\n function peg$parser() {\n var s0, s1, s2;\n peg$silentFails++;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e3);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f21(s1);\n if (s2) {\n s2 = void 0;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n s1 = [s1, s2];\n s0 = s1;\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e5);\n }\n }\n return s0;\n }\n function peg$parsec() {\n var s0, s1, s2;\n peg$silentFails++;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e3);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f22(s1);\n if (s2) {\n s2 = void 0;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n s1 = [s1, s2];\n s0 = s1;\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e6);\n }\n }\n return s0;\n }\n function peg$parsep() {\n var s0, s1, s2;\n peg$silentFails++;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e3);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f23(s1);\n if (s2) {\n s2 = void 0;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n s1 = [s1, s2];\n s0 = s1;\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e7);\n }\n }\n return s0;\n }\n function peg$parsem() {\n var s0, s1, s2;\n peg$silentFails++;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e3);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f24(s1);\n if (s2) {\n s2 = void 0;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n s1 = [s1, s2];\n s0 = s1;\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e8);\n }\n }\n return s0;\n }\n function peg$parseb() {\n var s0, s1, s2;\n peg$silentFails++;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e3);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f25(s1);\n if (s2) {\n s2 = void 0;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n s1 = [s1, s2];\n s0 = s1;\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e9);\n }\n }\n return s0;\n }\n function peg$parsew() {\n var s0, s1, s2;\n peg$silentFails++;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e3);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f26(s1);\n if (s2) {\n s2 = void 0;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n s1 = [s1, s2];\n s0 = s1;\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e10);\n }\n }\n return s0;\n }\n function peg$parseW() {\n var s0, s1, s2;\n peg$silentFails++;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e3);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f27(s1);\n if (s2) {\n s2 = void 0;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n s1 = [s1, s2];\n s0 = s1;\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e11);\n }\n }\n return s0;\n }\n function peg$parseX() {\n var s0, s1, s2;\n peg$silentFails++;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e3);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f28(s1);\n if (s2) {\n s2 = void 0;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n s1 = [s1, s2];\n s0 = s1;\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e12);\n }\n }\n return s0;\n }\n function peg$parsebang() {\n var s0, s1, s2;\n peg$silentFails++;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e3);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f29(s1);\n if (s2) {\n s2 = void 0;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n s1 = [s1, s2];\n s0 = s1;\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e13);\n }\n }\n return s0;\n }\n function peg$parseat() {\n var s0, s1, s2;\n peg$silentFails++;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e3);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f30(s1);\n if (s2) {\n s2 = void 0;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n s1 = [s1, s2];\n s0 = s1;\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e14);\n }\n }\n return s0;\n }\n function peg$parseless() {\n var s0, s1, s2;\n peg$silentFails++;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e3);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f31(s1);\n if (s2) {\n s2 = void 0;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n s1 = [s1, s2];\n s0 = s1;\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e15);\n }\n }\n return s0;\n }\n function peg$parsegreater() {\n var s0, s1, s2;\n peg$silentFails++;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e3);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f32(s1);\n if (s2) {\n s2 = void 0;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n s1 = [s1, s2];\n s0 = s1;\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e16);\n }\n }\n return s0;\n }\n function peg$parsegroup() {\n var s0, s1, s2;\n peg$silentFails++;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e3);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f33(s1);\n if (s2) {\n s2 = void 0;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n s1 = [s1, s2];\n s0 = s1;\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e17);\n }\n }\n return s0;\n }\n function peg$parse_() {\n var s0, s1, s2;\n peg$silentFails++;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e3);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f34(s1);\n if (s2) {\n s2 = void 0;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n s1 = [s1, s2];\n s0 = s1;\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e18);\n }\n }\n return s0;\n }\n function peg$parseEOL() {\n var s0, s1;\n s0 = peg$currPos;\n peg$silentFails++;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e3);\n }\n }\n peg$silentFails--;\n if (s1 === peg$FAILED) {\n s0 = void 0;\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n if (!options.isHash) {\n try {\n Object.assign(options, {\n matchChar: (node, char) => node.type === \"string\" && node.content === char,\n isGroup: (node) => node.type === \"group\",\n isWhitespace: (node) => node.type === \"whitespace\"\n });\n } catch (e) {\n console.warn(\"Error when initializing parser\", e);\n }\n }\n peg$result = peg$startRuleFunction();\n if (peg$result !== peg$FAILED && peg$currPos === input.length) {\n return peg$result;\n } else {\n if (peg$result !== peg$FAILED && peg$currPos < input.length) {\n peg$fail(peg$endExpectation());\n }\n throw peg$buildStructuredError(\n peg$maxFailExpected,\n peg$maxFailPos < input.length ? input.charAt(peg$maxFailPos) : null,\n peg$maxFailPos < input.length ? peg$computeLocation(peg$maxFailPos, peg$maxFailPos + 1) : peg$computeLocation(peg$maxFailPos, peg$maxFailPos)\n );\n }\n }\n return {\n SyntaxError: peg$SyntaxError,\n parse: peg$parse\n };\n }()\n);\n\n// grammars/systeme-environment.pegjs\nvar systeme_environment_default = (\n // Generated by Peggy 2.0.1.\n //\n // https://peggyjs.org/\n function() {\n \"use strict\";\n function peg$subclass(child, parent) {\n function C() {\n this.constructor = child;\n }\n C.prototype = parent.prototype;\n child.prototype = new C();\n }\n function peg$SyntaxError(message, expected, found, location) {\n var self = Error.call(this, message);\n if (Object.setPrototypeOf) {\n Object.setPrototypeOf(self, peg$SyntaxError.prototype);\n }\n self.expected = expected;\n self.found = found;\n self.location = location;\n self.name = \"SyntaxError\";\n return self;\n }\n peg$subclass(peg$SyntaxError, Error);\n function peg$padEnd(str, targetLength, padString) {\n padString = padString || \" \";\n if (str.length > targetLength) {\n return str;\n }\n targetLength -= str.length;\n padString += padString.repeat(targetLength);\n return str + padString.slice(0, targetLength);\n }\n peg$SyntaxError.prototype.format = function(sources) {\n var str = \"Error: \" + this.message;\n if (this.location) {\n var src = null;\n var k;\n for (k = 0; k < sources.length; k++) {\n if (sources[k].source === this.location.source) {\n src = sources[k].text.split(/\\r\\n|\\n|\\r/g);\n break;\n }\n }\n var s = this.location.start;\n var loc = this.location.source + \":\" + s.line + \":\" + s.column;\n if (src) {\n var e = this.location.end;\n var filler = peg$padEnd(\"\", s.line.toString().length, \" \");\n var line = src[s.line - 1];\n var last = s.line === e.line ? e.column : line.length + 1;\n var hatLen = last - s.column || 1;\n str += \"\\n --> \" + loc + \"\\n\" + filler + \" |\\n\" + s.line + \" | \" + line + \"\\n\" + filler + \" | \" + peg$padEnd(\"\", s.column - 1, \" \") + peg$padEnd(\"\", hatLen, \"^\");\n } else {\n str += \"\\n at \" + loc;\n }\n }\n return str;\n };\n peg$SyntaxError.buildMessage = function(expected, found) {\n var DESCRIBE_EXPECTATION_FNS = {\n literal: function(expectation) {\n return '\"' + literalEscape(expectation.text) + '\"';\n },\n class: function(expectation) {\n var escapedParts = expectation.parts.map(function(part) {\n return Array.isArray(part) ? classEscape(part[0]) + \"-\" + classEscape(part[1]) : classEscape(part);\n });\n return \"[\" + (expectation.inverted ? \"^\" : \"\") + escapedParts.join(\"\") + \"]\";\n },\n any: function() {\n return \"any character\";\n },\n end: function() {\n return \"end of input\";\n },\n other: function(expectation) {\n return expectation.description;\n }\n };\n function hex(ch) {\n return ch.charCodeAt(0).toString(16).toUpperCase();\n }\n function literalEscape(s) {\n return s.replace(/\\\\/g, \"\\\\\\\\\").replace(/\"/g, '\\\\\"').replace(/\\0/g, \"\\\\0\").replace(/\\t/g, \"\\\\t\").replace(/\\n/g, \"\\\\n\").replace(/\\r/g, \"\\\\r\").replace(/[\\x00-\\x0F]/g, function(ch) {\n return \"\\\\x0\" + hex(ch);\n }).replace(/[\\x10-\\x1F\\x7F-\\x9F]/g, function(ch) {\n return \"\\\\x\" + hex(ch);\n });\n }\n function classEscape(s) {\n return s.replace(/\\\\/g, \"\\\\\\\\\").replace(/\\]/g, \"\\\\]\").replace(/\\^/g, \"\\\\^\").replace(/-/g, \"\\\\-\").replace(/\\0/g, \"\\\\0\").replace(/\\t/g, \"\\\\t\").replace(/\\n/g, \"\\\\n\").replace(/\\r/g, \"\\\\r\").replace(/[\\x00-\\x0F]/g, function(ch) {\n return \"\\\\x0\" + hex(ch);\n }).replace(/[\\x10-\\x1F\\x7F-\\x9F]/g, function(ch) {\n return \"\\\\x\" + hex(ch);\n });\n }\n function describeExpectation(expectation) {\n return DESCRIBE_EXPECTATION_FNS[expectation.type](expectation);\n }\n function describeExpected(expected2) {\n var descriptions = expected2.map(describeExpectation);\n var i, j;\n descriptions.sort();\n if (descriptions.length > 0) {\n for (i = 1, j = 1; i < descriptions.length; i++) {\n if (descriptions[i - 1] !== descriptions[i]) {\n descriptions[j] = descriptions[i];\n j++;\n }\n }\n descriptions.length = j;\n }\n switch (descriptions.length) {\n case 1:\n return descriptions[0];\n case 2:\n return descriptions[0] + \" or \" + descriptions[1];\n default:\n return descriptions.slice(0, -1).join(\", \") + \", or \" + descriptions[descriptions.length - 1];\n }\n }\n function describeFound(found2) {\n return found2 ? '\"' + literalEscape(found2) + '\"' : \"end of input\";\n }\n return \"Expected \" + describeExpected(expected) + \" but \" + describeFound(found) + \" found.\";\n };\n function peg$parse(input, options) {\n options = options !== void 0 ? options : {};\n var peg$FAILED = {};\n var peg$source = options.grammarSource;\n var peg$startRuleFunctions = { body: peg$parsebody };\n var peg$startRuleFunction = peg$parsebody;\n var peg$e0 = peg$otherExpectation(\"partial item\");\n var peg$e1 = peg$otherExpectation(\"item\");\n var peg$e2 = peg$anyExpectation();\n var peg$e3 = peg$otherExpectation(\"equation\");\n var peg$e4 = peg$otherExpectation(\"trailing comment\");\n var peg$e5 = peg$otherExpectation(\"comment only line\");\n var peg$e6 = peg$otherExpectation(\"non-var token\");\n var peg$e7 = peg$otherExpectation(\"token\");\n var peg$e8 = peg$otherExpectation(\"same line comment\");\n var peg$e9 = peg$otherExpectation(\"own line comment\");\n var peg$e10 = peg$otherExpectation(\",\");\n var peg$e11 = peg$otherExpectation(\"@\");\n var peg$e12 = peg$otherExpectation(\"variable token\");\n var peg$e13 = peg$otherExpectation(\"+/-\");\n var peg$e14 = peg$otherExpectation(\"=\");\n var peg$f0 = function(a, b) {\n return a.concat(b ? b : []);\n };\n var peg$f1 = function() {\n return [];\n };\n var peg$f2 = function(a, b, c) {\n return a.concat(b, c);\n };\n var peg$f3 = function(op, a, b, c) {\n return { type: \"item\", op, variable: b, content: a.concat(b, c) };\n };\n var peg$f4 = function(op, a) {\n return { type: \"item\", op, variable: null, content: a };\n };\n var peg$f5 = function(line, sep, comment) {\n return { ...line, sep: [].concat(sep), trailingComment: comment };\n };\n var peg$f6 = function(line, comment) {\n return { ...line, trailingComment: comment };\n };\n var peg$f7 = function(eq, ann) {\n return {\n type: \"line\",\n equation: eq,\n annotation: ann,\n sep: null\n };\n };\n var peg$f8 = function(at, ann) {\n return at ? { type: \"annotation\", marker: at, content: ann } : null;\n };\n var peg$f9 = function(left, eq, right) {\n return { type: \"equation\", left, right, equals: eq };\n };\n var peg$f10 = function(x) {\n return x;\n };\n var peg$f11 = function(x) {\n return {\n type: \"line\",\n trailingComment: x\n };\n };\n var peg$f12 = function(v, s) {\n return [v].concat(s ? s : []);\n };\n var peg$f13 = function(t) {\n return t;\n };\n var peg$f14 = function(x) {\n return x;\n };\n var peg$f15 = function(x) {\n return x;\n };\n var peg$f16 = function(tok) {\n return options.isSameLineComment(tok);\n };\n var peg$f17 = function(tok) {\n return tok;\n };\n var peg$f18 = function(tok) {\n return options.isOwnLineComment(tok);\n };\n var peg$f19 = function(tok) {\n return tok;\n };\n var peg$f20 = function(tok) {\n return options.isWhitespace(tok);\n };\n var peg$f21 = function(tok) {\n return tok;\n };\n var peg$f22 = function(tok) {\n return options.isSep(tok);\n };\n var peg$f23 = function(tok) {\n return tok;\n };\n var peg$f24 = function(tok) {\n return options.isAt(tok);\n };\n var peg$f25 = function(tok) {\n return tok;\n };\n var peg$f26 = function(tok) {\n return options.isVar(tok);\n };\n var peg$f27 = function(tok) {\n return tok;\n };\n var peg$f28 = function(tok) {\n return options.isOperation(tok);\n };\n var peg$f29 = function(tok) {\n return tok;\n };\n var peg$f30 = function(tok) {\n return options.isEquals(tok);\n };\n var peg$f31 = function(tok) {\n return tok;\n };\n var peg$f32 = function(tok) {\n return options.isSubscript(tok);\n };\n var peg$f33 = function(tok) {\n return tok;\n };\n var peg$currPos = 0;\n var peg$savedPos = 0;\n var peg$posDetailsCache = [{ line: 1, column: 1 }];\n var peg$maxFailPos = 0;\n var peg$maxFailExpected = [];\n var peg$silentFails = 0;\n var peg$result;\n if (\"startRule\" in options) {\n if (!(options.startRule in peg$startRuleFunctions)) {\n throw new Error(`Can't start parsing from rule \"` + options.startRule + '\".');\n }\n peg$startRuleFunction = peg$startRuleFunctions[options.startRule];\n }\n function text() {\n return input.substring(peg$savedPos, peg$currPos);\n }\n function offset() {\n return peg$savedPos;\n }\n function range() {\n return {\n source: peg$source,\n start: peg$savedPos,\n end: peg$currPos\n };\n }\n function location() {\n return peg$computeLocation(peg$savedPos, peg$currPos);\n }\n function expected(description, location2) {\n location2 = location2 !== void 0 ? location2 : peg$computeLocation(peg$savedPos, peg$currPos);\n throw peg$buildStructuredError(\n [peg$otherExpectation(description)],\n input.substring(peg$savedPos, peg$currPos),\n location2\n );\n }\n function error(message, location2) {\n location2 = location2 !== void 0 ? location2 : peg$computeLocation(peg$savedPos, peg$currPos);\n throw peg$buildSimpleError(message, location2);\n }\n function peg$literalExpectation(text2, ignoreCase) {\n return { type: \"literal\", text: text2, ignoreCase };\n }\n function peg$classExpectation(parts, inverted, ignoreCase) {\n return { type: \"class\", parts, inverted, ignoreCase };\n }\n function peg$anyExpectation() {\n return { type: \"any\" };\n }\n function peg$endExpectation() {\n return { type: \"end\" };\n }\n function peg$otherExpectation(description) {\n return { type: \"other\", description };\n }\n function peg$computePosDetails(pos) {\n var details = peg$posDetailsCache[pos];\n var p;\n if (details) {\n return details;\n } else {\n p = pos - 1;\n while (!peg$posDetailsCache[p]) {\n p--;\n }\n details = peg$posDetailsCache[p];\n details = {\n line: details.line,\n column: details.column\n };\n while (p < pos) {\n if (input.charCodeAt(p) === 10) {\n details.line++;\n details.column = 1;\n } else {\n details.column++;\n }\n p++;\n }\n peg$posDetailsCache[pos] = details;\n return details;\n }\n }\n function peg$computeLocation(startPos, endPos) {\n var startPosDetails = peg$computePosDetails(startPos);\n var endPosDetails = peg$computePosDetails(endPos);\n return {\n source: peg$source,\n start: {\n offset: startPos,\n line: startPosDetails.line,\n column: startPosDetails.column\n },\n end: {\n offset: endPos,\n line: endPosDetails.line,\n column: endPosDetails.column\n }\n };\n }\n function peg$fail(expected2) {\n if (peg$currPos < peg$maxFailPos) {\n return;\n }\n if (peg$currPos > peg$maxFailPos) {\n peg$maxFailPos = peg$currPos;\n peg$maxFailExpected = [];\n }\n peg$maxFailExpected.push(expected2);\n }\n function peg$buildSimpleError(message, location2) {\n return new peg$SyntaxError(message, null, null, location2);\n }\n function peg$buildStructuredError(expected2, found, location2) {\n return new peg$SyntaxError(\n peg$SyntaxError.buildMessage(expected2, found),\n expected2,\n found,\n location2\n );\n }\n function peg$parsebody() {\n var s0, s1, s2;\n s0 = peg$currPos;\n s1 = [];\n s2 = peg$parsecomment_only_line();\n if (s2 === peg$FAILED) {\n s2 = peg$parseline_with_sep();\n if (s2 === peg$FAILED) {\n s2 = peg$parsepartial_line_with_comment();\n }\n }\n while (s2 !== peg$FAILED) {\n s1.push(s2);\n s2 = peg$parsecomment_only_line();\n if (s2 === peg$FAILED) {\n s2 = peg$parseline_with_sep();\n if (s2 === peg$FAILED) {\n s2 = peg$parsepartial_line_with_comment();\n }\n }\n }\n s2 = peg$parseline_without_sep();\n if (s2 === peg$FAILED) {\n s2 = peg$parseEOL();\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f0(s1, s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n if (s0 === peg$FAILED) {\n s0 = peg$currPos;\n s1 = peg$parseEOL();\n if (s1 !== peg$FAILED) {\n peg$savedPos = s0;\n s1 = peg$f1();\n }\n s0 = s1;\n }\n return s0;\n }\n function peg$parsepartial_item() {\n var s0, s1, s2, s3, s4, s5, s6, s7, s8;\n peg$silentFails++;\n s0 = peg$currPos;\n s1 = [];\n s2 = peg$parse_();\n while (s2 !== peg$FAILED) {\n s1.push(s2);\n s2 = peg$parse_();\n }\n s2 = [];\n s3 = peg$parsenon_var_token();\n while (s3 !== peg$FAILED) {\n s2.push(s3);\n s3 = peg$parsenon_var_token();\n }\n s3 = [];\n s4 = peg$parse_();\n while (s4 !== peg$FAILED) {\n s3.push(s4);\n s4 = peg$parse_();\n }\n s4 = peg$parsevar();\n if (s4 !== peg$FAILED) {\n s5 = [];\n s6 = peg$parse_();\n while (s6 !== peg$FAILED) {\n s5.push(s6);\n s6 = peg$parse_();\n }\n s6 = [];\n s7 = peg$parsetoken();\n while (s7 !== peg$FAILED) {\n s6.push(s7);\n s7 = peg$parsetoken();\n }\n s7 = [];\n s8 = peg$parse_();\n while (s8 !== peg$FAILED) {\n s7.push(s8);\n s8 = peg$parse_();\n }\n peg$savedPos = s0;\n s0 = peg$f2(s2, s4, s6);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n return s0;\n }\n function peg$parseitem() {\n var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;\n peg$silentFails++;\n s0 = peg$currPos;\n s1 = peg$parseoperation();\n if (s1 === peg$FAILED) {\n s1 = null;\n }\n s2 = [];\n s3 = peg$parse_();\n while (s3 !== peg$FAILED) {\n s2.push(s3);\n s3 = peg$parse_();\n }\n s3 = [];\n s4 = peg$parsenon_var_token();\n while (s4 !== peg$FAILED) {\n s3.push(s4);\n s4 = peg$parsenon_var_token();\n }\n s4 = [];\n s5 = peg$parse_();\n while (s5 !== peg$FAILED) {\n s4.push(s5);\n s5 = peg$parse_();\n }\n s5 = peg$parsevar();\n if (s5 !== peg$FAILED) {\n s6 = [];\n s7 = peg$parse_();\n while (s7 !== peg$FAILED) {\n s6.push(s7);\n s7 = peg$parse_();\n }\n s7 = [];\n s8 = peg$parsetoken();\n while (s8 !== peg$FAILED) {\n s7.push(s8);\n s8 = peg$parsetoken();\n }\n s8 = [];\n s9 = peg$parse_();\n while (s9 !== peg$FAILED) {\n s8.push(s9);\n s9 = peg$parse_();\n }\n peg$savedPos = s0;\n s0 = peg$f3(s1, s3, s5, s7);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n if (s0 === peg$FAILED) {\n s0 = peg$currPos;\n s1 = peg$parseoperation();\n if (s1 === peg$FAILED) {\n s1 = null;\n }\n s2 = [];\n s3 = peg$parse_();\n while (s3 !== peg$FAILED) {\n s2.push(s3);\n s3 = peg$parse_();\n }\n s3 = [];\n s4 = peg$parsenon_var_token();\n if (s4 !== peg$FAILED) {\n while (s4 !== peg$FAILED) {\n s3.push(s4);\n s4 = peg$parsenon_var_token();\n }\n } else {\n s3 = peg$FAILED;\n }\n if (s3 !== peg$FAILED) {\n s4 = [];\n s5 = peg$parse_();\n while (s5 !== peg$FAILED) {\n s4.push(s5);\n s5 = peg$parse_();\n }\n peg$savedPos = s0;\n s0 = peg$f4(s1, s3);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e1);\n }\n }\n return s0;\n }\n function peg$parseline_with_sep() {\n var s0, s1, s2, s3;\n s0 = peg$currPos;\n s1 = peg$parseline_without_sep();\n if (s1 !== peg$FAILED) {\n s2 = peg$parsesep();\n if (s2 !== peg$FAILED) {\n s3 = peg$parsetrailing_comment();\n if (s3 === peg$FAILED) {\n s3 = null;\n }\n peg$savedPos = s0;\n s0 = peg$f5(s1, s2, s3);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parsepartial_line_with_comment() {\n var s0, s1, s2;\n s0 = peg$currPos;\n s1 = peg$parseline_without_sep();\n if (s1 !== peg$FAILED) {\n s2 = peg$parsetrailing_comment();\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f6(s1, s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parseline_without_sep() {\n var s0, s1, s2, s3;\n s0 = peg$currPos;\n s1 = peg$currPos;\n peg$silentFails++;\n if (input.length > peg$currPos) {\n s2 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s2 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e2);\n }\n }\n peg$silentFails--;\n if (s2 !== peg$FAILED) {\n peg$currPos = s1;\n s1 = void 0;\n } else {\n s1 = peg$FAILED;\n }\n if (s1 !== peg$FAILED) {\n s2 = peg$parseequation();\n s3 = peg$parseannotation();\n if (s3 === peg$FAILED) {\n s3 = null;\n }\n peg$savedPos = s0;\n s0 = peg$f7(s2, s3);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parseannotation() {\n var s0, s1, s2, s3;\n s0 = peg$currPos;\n s1 = peg$parseat();\n if (s1 !== peg$FAILED) {\n s2 = [];\n s3 = peg$parsenon_sep_token();\n while (s3 !== peg$FAILED) {\n s2.push(s3);\n s3 = peg$parsenon_sep_token();\n }\n peg$savedPos = s0;\n s0 = peg$f8(s1, s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parseequation() {\n var s0, s1, s2, s3, s4;\n peg$silentFails++;\n s0 = peg$currPos;\n s1 = [];\n s2 = peg$parseitem();\n while (s2 !== peg$FAILED) {\n s1.push(s2);\n s2 = peg$parseitem();\n }\n s2 = peg$parseequals();\n if (s2 === peg$FAILED) {\n s2 = null;\n }\n s3 = [];\n s4 = peg$parsetoken();\n if (s4 === peg$FAILED) {\n s4 = peg$parseoperation();\n }\n while (s4 !== peg$FAILED) {\n s3.push(s4);\n s4 = peg$parsetoken();\n if (s4 === peg$FAILED) {\n s4 = peg$parseoperation();\n }\n }\n peg$savedPos = s0;\n s0 = peg$f9(s1, s2, s3);\n peg$silentFails--;\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e3);\n }\n return s0;\n }\n function peg$parsetrailing_comment() {\n var s0, s1, s2;\n peg$silentFails++;\n s0 = peg$currPos;\n s1 = [];\n s2 = peg$parse_();\n while (s2 !== peg$FAILED) {\n s1.push(s2);\n s2 = peg$parse_();\n }\n s2 = peg$parsesame_line_comment();\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f10(s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e4);\n }\n }\n return s0;\n }\n function peg$parsecomment_only_line() {\n var s0, s1, s2;\n peg$silentFails++;\n s0 = peg$currPos;\n s1 = [];\n s2 = peg$parse_();\n while (s2 !== peg$FAILED) {\n s1.push(s2);\n s2 = peg$parse_();\n }\n s2 = peg$parseown_line_comment();\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f11(s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e5);\n }\n }\n return s0;\n }\n function peg$parsevar() {\n var s0, s1, s2, s3;\n s0 = peg$currPos;\n s1 = peg$parsevar_token();\n if (s1 !== peg$FAILED) {\n s2 = [];\n s3 = peg$parse_();\n while (s3 !== peg$FAILED) {\n s2.push(s3);\n s3 = peg$parse_();\n }\n s3 = peg$parsesubscript();\n if (s3 === peg$FAILED) {\n s3 = null;\n }\n peg$savedPos = s0;\n s0 = peg$f12(s1, s3);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parsenon_var_token() {\n var s0, s1, s2;\n peg$silentFails++;\n s0 = peg$currPos;\n s1 = peg$currPos;\n peg$silentFails++;\n s2 = peg$parsevar();\n peg$silentFails--;\n if (s2 === peg$FAILED) {\n s1 = void 0;\n } else {\n peg$currPos = s1;\n s1 = peg$FAILED;\n }\n if (s1 !== peg$FAILED) {\n s2 = peg$parsetoken();\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f13(s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e6);\n }\n }\n return s0;\n }\n function peg$parsenon_sep_token() {\n var s0, s1, s2;\n s0 = peg$currPos;\n s1 = peg$currPos;\n peg$silentFails++;\n s2 = peg$parsesep();\n if (s2 === peg$FAILED) {\n s2 = peg$parsetrailing_comment();\n if (s2 === peg$FAILED) {\n s2 = peg$parseown_line_comment();\n }\n }\n peg$silentFails--;\n if (s2 === peg$FAILED) {\n s1 = void 0;\n } else {\n peg$currPos = s1;\n s1 = peg$FAILED;\n }\n if (s1 !== peg$FAILED) {\n if (input.length > peg$currPos) {\n s2 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s2 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e2);\n }\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f14(s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parsetoken() {\n var s0, s1, s2;\n peg$silentFails++;\n s0 = peg$currPos;\n s1 = peg$currPos;\n peg$silentFails++;\n s2 = peg$parsesep();\n if (s2 === peg$FAILED) {\n s2 = peg$parseat();\n if (s2 === peg$FAILED) {\n s2 = peg$parseoperation();\n if (s2 === peg$FAILED) {\n s2 = peg$parseequals();\n if (s2 === peg$FAILED) {\n s2 = peg$parsetrailing_comment();\n if (s2 === peg$FAILED) {\n s2 = peg$parseown_line_comment();\n }\n }\n }\n }\n }\n peg$silentFails--;\n if (s2 === peg$FAILED) {\n s1 = void 0;\n } else {\n peg$currPos = s1;\n s1 = peg$FAILED;\n }\n if (s1 !== peg$FAILED) {\n if (input.length > peg$currPos) {\n s2 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s2 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e2);\n }\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f15(s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e7);\n }\n }\n return s0;\n }\n function peg$parsesame_line_comment() {\n var s0, s1, s2;\n peg$silentFails++;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e2);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f16(s1);\n if (s2) {\n s2 = void 0;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f17(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e8);\n }\n }\n return s0;\n }\n function peg$parseown_line_comment() {\n var s0, s1, s2;\n peg$silentFails++;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e2);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f18(s1);\n if (s2) {\n s2 = void 0;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f19(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e9);\n }\n }\n return s0;\n }\n function peg$parse_() {\n var s0, s1, s2;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e2);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f20(s1);\n if (s2) {\n s2 = void 0;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f21(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parsesep() {\n var s0, s1, s2;\n peg$silentFails++;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e2);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f22(s1);\n if (s2) {\n s2 = void 0;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f23(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e10);\n }\n }\n return s0;\n }\n function peg$parseat() {\n var s0, s1, s2;\n peg$silentFails++;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e2);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f24(s1);\n if (s2) {\n s2 = void 0;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f25(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e11);\n }\n }\n return s0;\n }\n function peg$parsevar_token() {\n var s0, s1, s2;\n peg$silentFails++;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e2);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f26(s1);\n if (s2) {\n s2 = void 0;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f27(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e12);\n }\n }\n return s0;\n }\n function peg$parseoperation() {\n var s0, s1, s2, s3, s4;\n peg$silentFails++;\n s0 = peg$currPos;\n s1 = [];\n s2 = peg$parse_();\n while (s2 !== peg$FAILED) {\n s1.push(s2);\n s2 = peg$parse_();\n }\n if (input.length > peg$currPos) {\n s2 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s2 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e2);\n }\n }\n if (s2 !== peg$FAILED) {\n s3 = [];\n s4 = peg$parse_();\n while (s4 !== peg$FAILED) {\n s3.push(s4);\n s4 = peg$parse_();\n }\n peg$savedPos = peg$currPos;\n s4 = peg$f28(s2);\n if (s4) {\n s4 = void 0;\n } else {\n s4 = peg$FAILED;\n }\n if (s4 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f29(s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e13);\n }\n }\n return s0;\n }\n function peg$parseequals() {\n var s0, s1, s2;\n peg$silentFails++;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e2);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f30(s1);\n if (s2) {\n s2 = void 0;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f31(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e14);\n }\n }\n return s0;\n }\n function peg$parsesubscript() {\n var s0, s1, s2;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e2);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f32(s1);\n if (s2) {\n s2 = void 0;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f33(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parseEOL() {\n var s0, s1;\n s0 = peg$currPos;\n peg$silentFails++;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e2);\n }\n }\n peg$silentFails--;\n if (s1 === peg$FAILED) {\n s0 = void 0;\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n if (!options.isWhitespace) {\n try {\n Object.assign(options, {\n isSep: (node) => node.type === \"string\" && node.content === \",\",\n isVar: (node) => node.type === \"string\" && node.content.match(/[a-zA-Z]/),\n isOperation: (node) => node.type === \"string\" && node.content.match(/[+-]/),\n isEquals: (node) => node.type === \"string\" && node.content === \"=\",\n isAt: (node) => node.type === \"string\" && node.content === \"@\",\n isSubscript: (node) => node.content === \"_\",\n isWhitespace: (node) => node.type === \"whitespace\",\n isSameLineComment: (node) => node.type === \"comment\" && node.sameline,\n isOwnLineComment: (node) => node.type === \"comment\" && !node.sameline\n });\n } catch (e) {\n console.warn(\"Error when initializing parser\", e);\n }\n }\n peg$result = peg$startRuleFunction();\n if (peg$result !== peg$FAILED && peg$currPos === input.length) {\n return peg$result;\n } else {\n if (peg$result !== peg$FAILED && peg$currPos < input.length) {\n peg$fail(peg$endExpectation());\n }\n throw peg$buildStructuredError(\n peg$maxFailExpected,\n peg$maxFailPos < input.length ? input.charAt(peg$maxFailPos) : null,\n peg$maxFailPos < input.length ? peg$computeLocation(peg$maxFailPos, peg$maxFailPos + 1) : peg$computeLocation(peg$maxFailPos, peg$maxFailPos)\n );\n }\n }\n return {\n SyntaxError: peg$SyntaxError,\n parse: peg$parse\n };\n }()\n);\n\n// grammars/tex-glue.pegjs\nvar tex_glue_default = (\n // Generated by Peggy 2.0.1.\n //\n // https://peggyjs.org/\n function() {\n \"use strict\";\n function peg$subclass(child, parent) {\n function C() {\n this.constructor = child;\n }\n C.prototype = parent.prototype;\n child.prototype = new C();\n }\n function peg$SyntaxError(message, expected, found, location) {\n var self = Error.call(this, message);\n if (Object.setPrototypeOf) {\n Object.setPrototypeOf(self, peg$SyntaxError.prototype);\n }\n self.expected = expected;\n self.found = found;\n self.location = location;\n self.name = \"SyntaxError\";\n return self;\n }\n peg$subclass(peg$SyntaxError, Error);\n function peg$padEnd(str, targetLength, padString) {\n padString = padString || \" \";\n if (str.length > targetLength) {\n return str;\n }\n targetLength -= str.length;\n padString += padString.repeat(targetLength);\n return str + padString.slice(0, targetLength);\n }\n peg$SyntaxError.prototype.format = function(sources) {\n var str = \"Error: \" + this.message;\n if (this.location) {\n var src = null;\n var k;\n for (k = 0; k < sources.length; k++) {\n if (sources[k].source === this.location.source) {\n src = sources[k].text.split(/\\r\\n|\\n|\\r/g);\n break;\n }\n }\n var s = this.location.start;\n var loc = this.location.source + \":\" + s.line + \":\" + s.column;\n if (src) {\n var e = this.location.end;\n var filler = peg$padEnd(\"\", s.line.toString().length, \" \");\n var line = src[s.line - 1];\n var last = s.line === e.line ? e.column : line.length + 1;\n var hatLen = last - s.column || 1;\n str += \"\\n --> \" + loc + \"\\n\" + filler + \" |\\n\" + s.line + \" | \" + line + \"\\n\" + filler + \" | \" + peg$padEnd(\"\", s.column - 1, \" \") + peg$padEnd(\"\", hatLen, \"^\");\n } else {\n str += \"\\n at \" + loc;\n }\n }\n return str;\n };\n peg$SyntaxError.buildMessage = function(expected, found) {\n var DESCRIBE_EXPECTATION_FNS = {\n literal: function(expectation) {\n return '\"' + literalEscape(expectation.text) + '\"';\n },\n class: function(expectation) {\n var escapedParts = expectation.parts.map(function(part) {\n return Array.isArray(part) ? classEscape(part[0]) + \"-\" + classEscape(part[1]) : classEscape(part);\n });\n return \"[\" + (expectation.inverted ? \"^\" : \"\") + escapedParts.join(\"\") + \"]\";\n },\n any: function() {\n return \"any character\";\n },\n end: function() {\n return \"end of input\";\n },\n other: function(expectation) {\n return expectation.description;\n }\n };\n function hex(ch) {\n return ch.charCodeAt(0).toString(16).toUpperCase();\n }\n function literalEscape(s) {\n return s.replace(/\\\\/g, \"\\\\\\\\\").replace(/\"/g, '\\\\\"').replace(/\\0/g, \"\\\\0\").replace(/\\t/g, \"\\\\t\").replace(/\\n/g, \"\\\\n\").replace(/\\r/g, \"\\\\r\").replace(/[\\x00-\\x0F]/g, function(ch) {\n return \"\\\\x0\" + hex(ch);\n }).replace(/[\\x10-\\x1F\\x7F-\\x9F]/g, function(ch) {\n return \"\\\\x\" + hex(ch);\n });\n }\n function classEscape(s) {\n return s.replace(/\\\\/g, \"\\\\\\\\\").replace(/\\]/g, \"\\\\]\").replace(/\\^/g, \"\\\\^\").replace(/-/g, \"\\\\-\").replace(/\\0/g, \"\\\\0\").replace(/\\t/g, \"\\\\t\").replace(/\\n/g, \"\\\\n\").replace(/\\r/g, \"\\\\r\").replace(/[\\x00-\\x0F]/g, function(ch) {\n return \"\\\\x0\" + hex(ch);\n }).replace(/[\\x10-\\x1F\\x7F-\\x9F]/g, function(ch) {\n return \"\\\\x\" + hex(ch);\n });\n }\n function describeExpectation(expectation) {\n return DESCRIBE_EXPECTATION_FNS[expectation.type](expectation);\n }\n function describeExpected(expected2) {\n var descriptions = expected2.map(describeExpectation);\n var i, j;\n descriptions.sort();\n if (descriptions.length > 0) {\n for (i = 1, j = 1; i < descriptions.length; i++) {\n if (descriptions[i - 1] !== descriptions[i]) {\n descriptions[j] = descriptions[i];\n j++;\n }\n }\n descriptions.length = j;\n }\n switch (descriptions.length) {\n case 1:\n return descriptions[0];\n case 2:\n return descriptions[0] + \" or \" + descriptions[1];\n default:\n return descriptions.slice(0, -1).join(\", \") + \", or \" + descriptions[descriptions.length - 1];\n }\n }\n function describeFound(found2) {\n return found2 ? '\"' + literalEscape(found2) + '\"' : \"end of input\";\n }\n return \"Expected \" + describeExpected(expected) + \" but \" + describeFound(found) + \" found.\";\n };\n function peg$parse(input, options) {\n options = options !== void 0 ? options : {};\n var peg$FAILED = {};\n var peg$source = options.grammarSource;\n var peg$startRuleFunctions = { root: peg$parseroot };\n var peg$startRuleFunction = peg$parseroot;\n var peg$c0 = \"plus\";\n var peg$c1 = \"minus\";\n var peg$c2 = \"pt\";\n var peg$c3 = \"mm\";\n var peg$c4 = \"cm\";\n var peg$c5 = \"in\";\n var peg$c6 = \"ex\";\n var peg$c7 = \"em\";\n var peg$c8 = \"bp\";\n var peg$c9 = \"pc\";\n var peg$c10 = \"dd\";\n var peg$c11 = \"cc\";\n var peg$c12 = \"nd\";\n var peg$c13 = \"nc\";\n var peg$c14 = \"sp\";\n var peg$c15 = \"filll\";\n var peg$c16 = \"fill\";\n var peg$c17 = \"fil\";\n var peg$c18 = \".\";\n var peg$c19 = \"+\";\n var peg$c20 = \"-\";\n var peg$r0 = /^[0-9]/;\n var peg$e0 = peg$anyExpectation();\n var peg$e1 = peg$literalExpectation(\"plus\", false);\n var peg$e2 = peg$literalExpectation(\"minus\", false);\n var peg$e3 = peg$literalExpectation(\"pt\", false);\n var peg$e4 = peg$literalExpectation(\"mm\", false);\n var peg$e5 = peg$literalExpectation(\"cm\", false);\n var peg$e6 = peg$literalExpectation(\"in\", false);\n var peg$e7 = peg$literalExpectation(\"ex\", false);\n var peg$e8 = peg$literalExpectation(\"em\", false);\n var peg$e9 = peg$literalExpectation(\"bp\", false);\n var peg$e10 = peg$literalExpectation(\"pc\", false);\n var peg$e11 = peg$literalExpectation(\"dd\", false);\n var peg$e12 = peg$literalExpectation(\"cc\", false);\n var peg$e13 = peg$literalExpectation(\"nd\", false);\n var peg$e14 = peg$literalExpectation(\"nc\", false);\n var peg$e15 = peg$literalExpectation(\"sp\", false);\n var peg$e16 = peg$literalExpectation(\"filll\", false);\n var peg$e17 = peg$literalExpectation(\"fill\", false);\n var peg$e18 = peg$literalExpectation(\"fil\", false);\n var peg$e19 = peg$otherExpectation(\"number\");\n var peg$e20 = peg$classExpectation([[\"0\", \"9\"]], false, false);\n var peg$e21 = peg$literalExpectation(\".\", false);\n var peg$e22 = peg$literalExpectation(\"+\", false);\n var peg$e23 = peg$literalExpectation(\"-\", false);\n var peg$f0 = function(b, st, sh) {\n return {\n type: \"glue\",\n fixed: b,\n stretchable: st,\n shrinkable: sh,\n position: location()\n };\n };\n var peg$f1 = function(glue) {\n return glue;\n };\n var peg$f2 = function(n, u) {\n return { type: \"dim\", value: n, unit: u };\n };\n var peg$f3 = function(n, u) {\n return { type: \"dim\", value: n, unit: u };\n };\n var peg$f4 = function(n, u) {\n return { type: \"dim\", value: n, unit: u };\n };\n var peg$f5 = function(n) {\n return parseFloat(n);\n };\n var peg$currPos = 0;\n var peg$savedPos = 0;\n var peg$posDetailsCache = [{ line: 1, column: 1 }];\n var peg$maxFailPos = 0;\n var peg$maxFailExpected = [];\n var peg$silentFails = 0;\n var peg$result;\n if (\"startRule\" in options) {\n if (!(options.startRule in peg$startRuleFunctions)) {\n throw new Error(`Can't start parsing from rule \"` + options.startRule + '\".');\n }\n peg$startRuleFunction = peg$startRuleFunctions[options.startRule];\n }\n function text() {\n return input.substring(peg$savedPos, peg$currPos);\n }\n function offset() {\n return peg$savedPos;\n }\n function range() {\n return {\n source: peg$source,\n start: peg$savedPos,\n end: peg$currPos\n };\n }\n function location() {\n return peg$computeLocation(peg$savedPos, peg$currPos);\n }\n function expected(description, location2) {\n location2 = location2 !== void 0 ? location2 : peg$computeLocation(peg$savedPos, peg$currPos);\n throw peg$buildStructuredError(\n [peg$otherExpectation(description)],\n input.substring(peg$savedPos, peg$currPos),\n location2\n );\n }\n function error(message, location2) {\n location2 = location2 !== void 0 ? location2 : peg$computeLocation(peg$savedPos, peg$currPos);\n throw peg$buildSimpleError(message, location2);\n }\n function peg$literalExpectation(text2, ignoreCase) {\n return { type: \"literal\", text: text2, ignoreCase };\n }\n function peg$classExpectation(parts, inverted, ignoreCase) {\n return { type: \"class\", parts, inverted, ignoreCase };\n }\n function peg$anyExpectation() {\n return { type: \"any\" };\n }\n function peg$endExpectation() {\n return { type: \"end\" };\n }\n function peg$otherExpectation(description) {\n return { type: \"other\", description };\n }\n function peg$computePosDetails(pos) {\n var details = peg$posDetailsCache[pos];\n var p;\n if (details) {\n return details;\n } else {\n p = pos - 1;\n while (!peg$posDetailsCache[p]) {\n p--;\n }\n details = peg$posDetailsCache[p];\n details = {\n line: details.line,\n column: details.column\n };\n while (p < pos) {\n if (input.charCodeAt(p) === 10) {\n details.line++;\n details.column = 1;\n } else {\n details.column++;\n }\n p++;\n }\n peg$posDetailsCache[pos] = details;\n return details;\n }\n }\n function peg$computeLocation(startPos, endPos) {\n var startPosDetails = peg$computePosDetails(startPos);\n var endPosDetails = peg$computePosDetails(endPos);\n return {\n source: peg$source,\n start: {\n offset: startPos,\n line: startPosDetails.line,\n column: startPosDetails.column\n },\n end: {\n offset: endPos,\n line: endPosDetails.line,\n column: endPosDetails.column\n }\n };\n }\n function peg$fail(expected2) {\n if (peg$currPos < peg$maxFailPos) {\n return;\n }\n if (peg$currPos > peg$maxFailPos) {\n peg$maxFailPos = peg$currPos;\n peg$maxFailExpected = [];\n }\n peg$maxFailExpected.push(expected2);\n }\n function peg$buildSimpleError(message, location2) {\n return new peg$SyntaxError(message, null, null, location2);\n }\n function peg$buildStructuredError(expected2, found, location2) {\n return new peg$SyntaxError(\n peg$SyntaxError.buildMessage(expected2, found),\n expected2,\n found,\n location2\n );\n }\n function peg$parseroot() {\n var s0, s1, s2, s3, s4;\n s0 = peg$currPos;\n s1 = peg$currPos;\n s2 = peg$parsebase();\n if (s2 !== peg$FAILED) {\n s3 = peg$parsestretchable();\n if (s3 === peg$FAILED) {\n s3 = null;\n }\n s4 = peg$parseshrinkable();\n if (s4 === peg$FAILED) {\n s4 = null;\n }\n peg$savedPos = s1;\n s1 = peg$f0(s2, s3, s4);\n } else {\n peg$currPos = s1;\n s1 = peg$FAILED;\n }\n if (s1 !== peg$FAILED) {\n s2 = [];\n if (input.length > peg$currPos) {\n s3 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s3 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n while (s3 !== peg$FAILED) {\n s2.push(s3);\n if (input.length > peg$currPos) {\n s3 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s3 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n }\n peg$savedPos = s0;\n s0 = peg$f1(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parsebase() {\n var s0, s1, s2;\n s0 = peg$currPos;\n s1 = peg$parsenumber();\n if (s1 !== peg$FAILED) {\n s2 = peg$parseunit();\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f2(s1, s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parsestretchable() {\n var s0, s1, s2, s3;\n s0 = peg$currPos;\n if (input.substr(peg$currPos, 4) === peg$c0) {\n s1 = peg$c0;\n peg$currPos += 4;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e1);\n }\n }\n if (s1 !== peg$FAILED) {\n s2 = peg$parsenumber();\n if (s2 !== peg$FAILED) {\n s3 = peg$parserubber_unit();\n if (s3 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f3(s2, s3);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parseshrinkable() {\n var s0, s1, s2, s3;\n s0 = peg$currPos;\n if (input.substr(peg$currPos, 5) === peg$c1) {\n s1 = peg$c1;\n peg$currPos += 5;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e2);\n }\n }\n if (s1 !== peg$FAILED) {\n s2 = peg$parsenumber();\n if (s2 !== peg$FAILED) {\n s3 = peg$parserubber_unit();\n if (s3 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f4(s2, s3);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parseunit() {\n var s0;\n if (input.substr(peg$currPos, 2) === peg$c2) {\n s0 = peg$c2;\n peg$currPos += 2;\n } else {\n s0 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e3);\n }\n }\n if (s0 === peg$FAILED) {\n if (input.substr(peg$currPos, 2) === peg$c3) {\n s0 = peg$c3;\n peg$currPos += 2;\n } else {\n s0 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e4);\n }\n }\n if (s0 === peg$FAILED) {\n if (input.substr(peg$currPos, 2) === peg$c4) {\n s0 = peg$c4;\n peg$currPos += 2;\n } else {\n s0 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e5);\n }\n }\n if (s0 === peg$FAILED) {\n if (input.substr(peg$currPos, 2) === peg$c5) {\n s0 = peg$c5;\n peg$currPos += 2;\n } else {\n s0 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e6);\n }\n }\n if (s0 === peg$FAILED) {\n if (input.substr(peg$currPos, 2) === peg$c6) {\n s0 = peg$c6;\n peg$currPos += 2;\n } else {\n s0 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e7);\n }\n }\n if (s0 === peg$FAILED) {\n if (input.substr(peg$currPos, 2) === peg$c7) {\n s0 = peg$c7;\n peg$currPos += 2;\n } else {\n s0 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e8);\n }\n }\n if (s0 === peg$FAILED) {\n if (input.substr(peg$currPos, 2) === peg$c8) {\n s0 = peg$c8;\n peg$currPos += 2;\n } else {\n s0 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e9);\n }\n }\n if (s0 === peg$FAILED) {\n if (input.substr(peg$currPos, 2) === peg$c9) {\n s0 = peg$c9;\n peg$currPos += 2;\n } else {\n s0 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e10);\n }\n }\n if (s0 === peg$FAILED) {\n if (input.substr(peg$currPos, 2) === peg$c10) {\n s0 = peg$c10;\n peg$currPos += 2;\n } else {\n s0 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e11);\n }\n }\n if (s0 === peg$FAILED) {\n if (input.substr(peg$currPos, 2) === peg$c11) {\n s0 = peg$c11;\n peg$currPos += 2;\n } else {\n s0 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e12);\n }\n }\n if (s0 === peg$FAILED) {\n if (input.substr(peg$currPos, 2) === peg$c12) {\n s0 = peg$c12;\n peg$currPos += 2;\n } else {\n s0 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e13);\n }\n }\n if (s0 === peg$FAILED) {\n if (input.substr(peg$currPos, 2) === peg$c13) {\n s0 = peg$c13;\n peg$currPos += 2;\n } else {\n s0 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e14);\n }\n }\n if (s0 === peg$FAILED) {\n if (input.substr(peg$currPos, 2) === peg$c14) {\n s0 = peg$c14;\n peg$currPos += 2;\n } else {\n s0 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e15);\n }\n }\n }\n }\n }\n }\n }\n }\n }\n }\n }\n }\n }\n }\n return s0;\n }\n function peg$parserubber_unit() {\n var s0;\n s0 = peg$parseunit();\n if (s0 === peg$FAILED) {\n if (input.substr(peg$currPos, 5) === peg$c15) {\n s0 = peg$c15;\n peg$currPos += 5;\n } else {\n s0 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e16);\n }\n }\n if (s0 === peg$FAILED) {\n if (input.substr(peg$currPos, 4) === peg$c16) {\n s0 = peg$c16;\n peg$currPos += 4;\n } else {\n s0 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e17);\n }\n }\n if (s0 === peg$FAILED) {\n if (input.substr(peg$currPos, 3) === peg$c17) {\n s0 = peg$c17;\n peg$currPos += 3;\n } else {\n s0 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e18);\n }\n }\n }\n }\n }\n return s0;\n }\n function peg$parsenumber() {\n var s0, s1, s2, s3, s4, s5, s6, s7, s8;\n peg$silentFails++;\n s0 = peg$currPos;\n s1 = peg$currPos;\n s2 = peg$currPos;\n s3 = peg$parsesign();\n if (s3 === peg$FAILED) {\n s3 = null;\n }\n s4 = peg$currPos;\n s5 = [];\n if (peg$r0.test(input.charAt(peg$currPos))) {\n s6 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s6 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e20);\n }\n }\n while (s6 !== peg$FAILED) {\n s5.push(s6);\n if (peg$r0.test(input.charAt(peg$currPos))) {\n s6 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s6 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e20);\n }\n }\n }\n if (input.charCodeAt(peg$currPos) === 46) {\n s6 = peg$c18;\n peg$currPos++;\n } else {\n s6 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e21);\n }\n }\n if (s6 !== peg$FAILED) {\n s7 = [];\n if (peg$r0.test(input.charAt(peg$currPos))) {\n s8 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s8 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e20);\n }\n }\n if (s8 !== peg$FAILED) {\n while (s8 !== peg$FAILED) {\n s7.push(s8);\n if (peg$r0.test(input.charAt(peg$currPos))) {\n s8 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s8 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e20);\n }\n }\n }\n } else {\n s7 = peg$FAILED;\n }\n if (s7 !== peg$FAILED) {\n s5 = [s5, s6, s7];\n s4 = s5;\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n if (s4 === peg$FAILED) {\n s4 = [];\n if (peg$r0.test(input.charAt(peg$currPos))) {\n s5 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s5 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e20);\n }\n }\n if (s5 !== peg$FAILED) {\n while (s5 !== peg$FAILED) {\n s4.push(s5);\n if (peg$r0.test(input.charAt(peg$currPos))) {\n s5 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s5 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e20);\n }\n }\n }\n } else {\n s4 = peg$FAILED;\n }\n }\n if (s4 !== peg$FAILED) {\n s3 = [s3, s4];\n s2 = s3;\n } else {\n peg$currPos = s2;\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n s1 = input.substring(s1, peg$currPos);\n } else {\n s1 = s2;\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = s0;\n s1 = peg$f5(s1);\n }\n s0 = s1;\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e19);\n }\n }\n return s0;\n }\n function peg$parsesign() {\n var s0;\n if (input.charCodeAt(peg$currPos) === 43) {\n s0 = peg$c19;\n peg$currPos++;\n } else {\n s0 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e22);\n }\n }\n if (s0 === peg$FAILED) {\n if (input.charCodeAt(peg$currPos) === 45) {\n s0 = peg$c20;\n peg$currPos++;\n } else {\n s0 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e23);\n }\n }\n }\n return s0;\n }\n function peg$parseEOL() {\n var s0, s1;\n s0 = peg$currPos;\n peg$silentFails++;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n peg$silentFails--;\n if (s1 === peg$FAILED) {\n s0 = void 0;\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n peg$result = peg$startRuleFunction();\n if (peg$result !== peg$FAILED && peg$currPos === input.length) {\n return peg$result;\n } else {\n if (peg$result !== peg$FAILED && peg$currPos < input.length) {\n peg$fail(peg$endExpectation());\n }\n throw peg$buildStructuredError(\n peg$maxFailExpected,\n peg$maxFailPos < input.length ? input.charAt(peg$maxFailPos) : null,\n peg$maxFailPos < input.length ? peg$computeLocation(peg$maxFailPos, peg$maxFailPos + 1) : peg$computeLocation(peg$maxFailPos, peg$maxFailPos)\n );\n }\n }\n return {\n SyntaxError: peg$SyntaxError,\n parse: peg$parse\n };\n }()\n);\n\n// grammars/tikz.pegjs\nvar tikz_default = (\n // Generated by Peggy 2.0.1.\n //\n // https://peggyjs.org/\n function() {\n \"use strict\";\n function peg$subclass(child, parent) {\n function C() {\n this.constructor = child;\n }\n C.prototype = parent.prototype;\n child.prototype = new C();\n }\n function peg$SyntaxError(message, expected, found, location) {\n var self = Error.call(this, message);\n if (Object.setPrototypeOf) {\n Object.setPrototypeOf(self, peg$SyntaxError.prototype);\n }\n self.expected = expected;\n self.found = found;\n self.location = location;\n self.name = \"SyntaxError\";\n return self;\n }\n peg$subclass(peg$SyntaxError, Error);\n function peg$padEnd(str, targetLength, padString) {\n padString = padString || \" \";\n if (str.length > targetLength) {\n return str;\n }\n targetLength -= str.length;\n padString += padString.repeat(targetLength);\n return str + padString.slice(0, targetLength);\n }\n peg$SyntaxError.prototype.format = function(sources) {\n var str = \"Error: \" + this.message;\n if (this.location) {\n var src = null;\n var k;\n for (k = 0; k < sources.length; k++) {\n if (sources[k].source === this.location.source) {\n src = sources[k].text.split(/\\r\\n|\\n|\\r/g);\n break;\n }\n }\n var s = this.location.start;\n var loc = this.location.source + \":\" + s.line + \":\" + s.column;\n if (src) {\n var e = this.location.end;\n var filler = peg$padEnd(\"\", s.line.toString().length, \" \");\n var line = src[s.line - 1];\n var last = s.line === e.line ? e.column : line.length + 1;\n var hatLen = last - s.column || 1;\n str += \"\\n --> \" + loc + \"\\n\" + filler + \" |\\n\" + s.line + \" | \" + line + \"\\n\" + filler + \" | \" + peg$padEnd(\"\", s.column - 1, \" \") + peg$padEnd(\"\", hatLen, \"^\");\n } else {\n str += \"\\n at \" + loc;\n }\n }\n return str;\n };\n peg$SyntaxError.buildMessage = function(expected, found) {\n var DESCRIBE_EXPECTATION_FNS = {\n literal: function(expectation) {\n return '\"' + literalEscape(expectation.text) + '\"';\n },\n class: function(expectation) {\n var escapedParts = expectation.parts.map(function(part) {\n return Array.isArray(part) ? classEscape(part[0]) + \"-\" + classEscape(part[1]) : classEscape(part);\n });\n return \"[\" + (expectation.inverted ? \"^\" : \"\") + escapedParts.join(\"\") + \"]\";\n },\n any: function() {\n return \"any character\";\n },\n end: function() {\n return \"end of input\";\n },\n other: function(expectation) {\n return expectation.description;\n }\n };\n function hex(ch) {\n return ch.charCodeAt(0).toString(16).toUpperCase();\n }\n function literalEscape(s) {\n return s.replace(/\\\\/g, \"\\\\\\\\\").replace(/\"/g, '\\\\\"').replace(/\\0/g, \"\\\\0\").replace(/\\t/g, \"\\\\t\").replace(/\\n/g, \"\\\\n\").replace(/\\r/g, \"\\\\r\").replace(/[\\x00-\\x0F]/g, function(ch) {\n return \"\\\\x0\" + hex(ch);\n }).replace(/[\\x10-\\x1F\\x7F-\\x9F]/g, function(ch) {\n return \"\\\\x\" + hex(ch);\n });\n }\n function classEscape(s) {\n return s.replace(/\\\\/g, \"\\\\\\\\\").replace(/\\]/g, \"\\\\]\").replace(/\\^/g, \"\\\\^\").replace(/-/g, \"\\\\-\").replace(/\\0/g, \"\\\\0\").replace(/\\t/g, \"\\\\t\").replace(/\\n/g, \"\\\\n\").replace(/\\r/g, \"\\\\r\").replace(/[\\x00-\\x0F]/g, function(ch) {\n return \"\\\\x0\" + hex(ch);\n }).replace(/[\\x10-\\x1F\\x7F-\\x9F]/g, function(ch) {\n return \"\\\\x\" + hex(ch);\n });\n }\n function describeExpectation(expectation) {\n return DESCRIBE_EXPECTATION_FNS[expectation.type](expectation);\n }\n function describeExpected(expected2) {\n var descriptions = expected2.map(describeExpectation);\n var i, j;\n descriptions.sort();\n if (descriptions.length > 0) {\n for (i = 1, j = 1; i < descriptions.length; i++) {\n if (descriptions[i - 1] !== descriptions[i]) {\n descriptions[j] = descriptions[i];\n j++;\n }\n }\n descriptions.length = j;\n }\n switch (descriptions.length) {\n case 1:\n return descriptions[0];\n case 2:\n return descriptions[0] + \" or \" + descriptions[1];\n default:\n return descriptions.slice(0, -1).join(\", \") + \", or \" + descriptions[descriptions.length - 1];\n }\n }\n function describeFound(found2) {\n return found2 ? '\"' + literalEscape(found2) + '\"' : \"end of input\";\n }\n return \"Expected \" + describeExpected(expected) + \" but \" + describeFound(found) + \" found.\";\n };\n function peg$parse(input, options) {\n options = options !== void 0 ? options : {};\n var peg$FAILED = {};\n var peg$source = options.grammarSource;\n var peg$startRuleFunctions = { path_spec: peg$parsepath_spec, foreach_body: peg$parseforeach_body };\n var peg$startRuleFunction = peg$parsepath_spec;\n var peg$e0 = peg$anyExpectation();\n var peg$e1 = peg$otherExpectation(\"same line comment\");\n var peg$e2 = peg$otherExpectation(\"own line comment\");\n var peg$e3 = peg$otherExpectation(\"comment\");\n var peg$e4 = peg$otherExpectation(\"floating comment\");\n var peg$e5 = peg$otherExpectation(\"operation\");\n var peg$e6 = peg$otherExpectation(\"=\");\n var peg$f0 = function(v) {\n return v;\n };\n var peg$f1 = function(ops) {\n return { type: \"path_spec\", content: ops };\n };\n var peg$f2 = function(c1, op, comment) {\n return { op, comment };\n };\n var peg$f3 = function(c1, ops, c2, body) {\n const comments = [c1, ...ops.map((x) => x.comment), c2].filter(\n (x) => x\n );\n const attribute = ops.map((x) => x.op.content.content).join(\" \");\n return {\n type: \"animation\",\n comments,\n attribute,\n content: body.content\n };\n };\n var peg$f4 = function(start, b) {\n return { ...b, start, type: \"foreach\" };\n };\n var peg$f5 = function(c1, variables, options2, c2, c3, list, c4, command) {\n const comments = [c1, c2, c3, c4].filter((x) => x);\n return {\n type: \"foreach_body\",\n variables,\n options: options2 && options2.content,\n list,\n command,\n comments\n };\n };\n var peg$f6 = function(c1, options2, c2, body) {\n const comments = [c1, c2].filter((x) => x);\n return {\n type: \"svg_operation\",\n options: options2 && options2.content,\n content: body,\n comments\n };\n };\n var peg$f7 = function(c1, c2, coord, c3, c4, x) {\n return { coord: x, comment: c4 };\n };\n var peg$f8 = function(c1, c2, coord, c3, a, c5) {\n const comments = [c1, c2, c3, a && a.comment, c5].filter((x) => x);\n return {\n type: \"curve_to\",\n controls: a ? [coord, a.coord] : [coord],\n comments\n };\n };\n var peg$f9 = function() {\n return { type: \"line_to\", command: \"|-\" };\n };\n var peg$f10 = function() {\n return { type: \"line_to\", command: \"-|\" };\n };\n var peg$f11 = function() {\n return { type: \"line_to\", command: \"--\" };\n };\n var peg$f12 = function(prefix, content) {\n return { type: \"coordinate\", content, prefix };\n };\n var peg$f13 = function(content) {\n return { type: \"square_brace_group\", content };\n };\n var peg$f14 = function(v) {\n return { type: \"unknown\", content: v };\n };\n var peg$f15 = function(tok) {\n return options.isSameLineComment(tok);\n };\n var peg$f16 = function(tok) {\n return tok;\n };\n var peg$f17 = function(tok) {\n return options.isOwnLineComment(tok);\n };\n var peg$f18 = function(tok) {\n return tok;\n };\n var peg$f19 = function(tok) {\n return options.isComment(tok);\n };\n var peg$f20 = function(tok) {\n return tok;\n };\n var peg$f21 = function(tok) {\n return options.isWhitespace(tok);\n };\n var peg$f22 = function(tok) {\n return tok;\n };\n var peg$f23 = function(c) {\n return c;\n };\n var peg$f24 = function(tok) {\n return options.isOperation(tok);\n };\n var peg$f25 = function(tok) {\n return { type: \"operation\", content: tok };\n };\n var peg$f26 = function(tok) {\n return options.isChar(tok, \"=\");\n };\n var peg$f27 = function(tok) {\n return tok;\n };\n var peg$f28 = function(tok) {\n return options.isChar(tok, \"[\");\n };\n var peg$f29 = function(tok) {\n return tok;\n };\n var peg$f30 = function(tok) {\n return options.isChar(tok, \"]\");\n };\n var peg$f31 = function(tok) {\n return tok;\n };\n var peg$f32 = function(tok) {\n return options.isChar(tok, \"(\");\n };\n var peg$f33 = function(tok) {\n return tok;\n };\n var peg$f34 = function(tok) {\n return options.isChar(tok, \")\");\n };\n var peg$f35 = function(tok) {\n return tok;\n };\n var peg$f36 = function(tok) {\n return options.isChar(tok, \"+\");\n };\n var peg$f37 = function(tok) {\n return tok;\n };\n var peg$f38 = function(tok) {\n return options.isChar(tok, \"-\");\n };\n var peg$f39 = function(tok) {\n return tok;\n };\n var peg$f40 = function(tok) {\n return options.isChar(tok, \"|\");\n };\n var peg$f41 = function(tok) {\n return tok;\n };\n var peg$f42 = function(tok) {\n return options.isChar(tok, \".\");\n };\n var peg$f43 = function(tok) {\n return tok;\n };\n var peg$f44 = function(tok) {\n return options.isChar(tok, \"controls\");\n };\n var peg$f45 = function(tok) {\n return tok;\n };\n var peg$f46 = function(tok) {\n return options.isChar(tok, \"and\");\n };\n var peg$f47 = function(tok) {\n return tok;\n };\n var peg$f48 = function(tok) {\n return options.isChar(tok, \"svg\");\n };\n var peg$f49 = function(tok) {\n return tok;\n };\n var peg$f50 = function(tok) {\n return options.isGroup(tok);\n };\n var peg$f51 = function(tok) {\n return tok;\n };\n var peg$f52 = function(tok) {\n return options.isAnyMacro(tok);\n };\n var peg$f53 = function(tok) {\n return tok;\n };\n var peg$f54 = function(tok) {\n return options.isChar(tok, \"foreach\");\n };\n var peg$f55 = function(tok) {\n return tok;\n };\n var peg$f56 = function(tok) {\n return options.isMacro(tok, \"foreach\");\n };\n var peg$f57 = function(tok) {\n return tok;\n };\n var peg$f58 = function(tok) {\n return options.isChar(tok, \"in\");\n };\n var peg$f59 = function(tok) {\n return tok;\n };\n var peg$f60 = function(tok) {\n return options.isChar(tok, \":\");\n };\n var peg$f61 = function(tok) {\n return tok;\n };\n var peg$currPos = 0;\n var peg$savedPos = 0;\n var peg$posDetailsCache = [{ line: 1, column: 1 }];\n var peg$maxFailPos = 0;\n var peg$maxFailExpected = [];\n var peg$silentFails = 0;\n var peg$result;\n if (\"startRule\" in options) {\n if (!(options.startRule in peg$startRuleFunctions)) {\n throw new Error(`Can't start parsing from rule \"` + options.startRule + '\".');\n }\n peg$startRuleFunction = peg$startRuleFunctions[options.startRule];\n }\n function text() {\n return input.substring(peg$savedPos, peg$currPos);\n }\n function offset() {\n return peg$savedPos;\n }\n function range() {\n return {\n source: peg$source,\n start: peg$savedPos,\n end: peg$currPos\n };\n }\n function location() {\n return peg$computeLocation(peg$savedPos, peg$currPos);\n }\n function expected(description, location2) {\n location2 = location2 !== void 0 ? location2 : peg$computeLocation(peg$savedPos, peg$currPos);\n throw peg$buildStructuredError(\n [peg$otherExpectation(description)],\n input.substring(peg$savedPos, peg$currPos),\n location2\n );\n }\n function error(message, location2) {\n location2 = location2 !== void 0 ? location2 : peg$computeLocation(peg$savedPos, peg$currPos);\n throw peg$buildSimpleError(message, location2);\n }\n function peg$literalExpectation(text2, ignoreCase) {\n return { type: \"literal\", text: text2, ignoreCase };\n }\n function peg$classExpectation(parts, inverted, ignoreCase) {\n return { type: \"class\", parts, inverted, ignoreCase };\n }\n function peg$anyExpectation() {\n return { type: \"any\" };\n }\n function peg$endExpectation() {\n return { type: \"end\" };\n }\n function peg$otherExpectation(description) {\n return { type: \"other\", description };\n }\n function peg$computePosDetails(pos) {\n var details = peg$posDetailsCache[pos];\n var p;\n if (details) {\n return details;\n } else {\n p = pos - 1;\n while (!peg$posDetailsCache[p]) {\n p--;\n }\n details = peg$posDetailsCache[p];\n details = {\n line: details.line,\n column: details.column\n };\n while (p < pos) {\n if (input.charCodeAt(p) === 10) {\n details.line++;\n details.column = 1;\n } else {\n details.column++;\n }\n p++;\n }\n peg$posDetailsCache[pos] = details;\n return details;\n }\n }\n function peg$computeLocation(startPos, endPos) {\n var startPosDetails = peg$computePosDetails(startPos);\n var endPosDetails = peg$computePosDetails(endPos);\n return {\n source: peg$source,\n start: {\n offset: startPos,\n line: startPosDetails.line,\n column: startPosDetails.column\n },\n end: {\n offset: endPos,\n line: endPosDetails.line,\n column: endPosDetails.column\n }\n };\n }\n function peg$fail(expected2) {\n if (peg$currPos < peg$maxFailPos) {\n return;\n }\n if (peg$currPos > peg$maxFailPos) {\n peg$maxFailPos = peg$currPos;\n peg$maxFailExpected = [];\n }\n peg$maxFailExpected.push(expected2);\n }\n function peg$buildSimpleError(message, location2) {\n return new peg$SyntaxError(message, null, null, location2);\n }\n function peg$buildStructuredError(expected2, found, location2) {\n return new peg$SyntaxError(\n peg$SyntaxError.buildMessage(expected2, found),\n expected2,\n found,\n location2\n );\n }\n function peg$parsepath_spec() {\n var s0, s1, s2, s3, s4, s5;\n s0 = peg$currPos;\n s1 = [];\n s2 = peg$currPos;\n s3 = peg$parsesquare_brace_group();\n if (s3 === peg$FAILED) {\n s3 = peg$parsecoordinate();\n if (s3 === peg$FAILED) {\n s3 = peg$parsecurve_to();\n if (s3 === peg$FAILED) {\n s3 = peg$parseline_to();\n if (s3 === peg$FAILED) {\n s3 = peg$parsesvg();\n if (s3 === peg$FAILED) {\n s3 = peg$parseforeach();\n if (s3 === peg$FAILED) {\n s3 = peg$parseoperation();\n if (s3 === peg$FAILED) {\n s3 = peg$parsecomment();\n if (s3 === peg$FAILED) {\n s3 = peg$parseanimation();\n if (s3 === peg$FAILED) {\n s3 = peg$parseunknown();\n }\n }\n }\n }\n }\n }\n }\n }\n }\n if (s3 !== peg$FAILED) {\n s4 = [];\n s5 = peg$parse_();\n while (s5 !== peg$FAILED) {\n s4.push(s5);\n s5 = peg$parse_();\n }\n peg$savedPos = s2;\n s2 = peg$f0(s3);\n } else {\n peg$currPos = s2;\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n while (s2 !== peg$FAILED) {\n s1.push(s2);\n s2 = peg$currPos;\n s3 = peg$parsesquare_brace_group();\n if (s3 === peg$FAILED) {\n s3 = peg$parsecoordinate();\n if (s3 === peg$FAILED) {\n s3 = peg$parsecurve_to();\n if (s3 === peg$FAILED) {\n s3 = peg$parseline_to();\n if (s3 === peg$FAILED) {\n s3 = peg$parsesvg();\n if (s3 === peg$FAILED) {\n s3 = peg$parseforeach();\n if (s3 === peg$FAILED) {\n s3 = peg$parseoperation();\n if (s3 === peg$FAILED) {\n s3 = peg$parsecomment();\n if (s3 === peg$FAILED) {\n s3 = peg$parseanimation();\n if (s3 === peg$FAILED) {\n s3 = peg$parseunknown();\n }\n }\n }\n }\n }\n }\n }\n }\n }\n if (s3 !== peg$FAILED) {\n s4 = [];\n s5 = peg$parse_();\n while (s5 !== peg$FAILED) {\n s4.push(s5);\n s5 = peg$parse_();\n }\n peg$savedPos = s2;\n s2 = peg$f0(s3);\n } else {\n peg$currPos = s2;\n s2 = peg$FAILED;\n }\n }\n } else {\n s1 = peg$FAILED;\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = s0;\n s1 = peg$f1(s1);\n }\n s0 = s1;\n return s0;\n }\n function peg$parseanimation() {\n var s0, s1, s2, s3, s4, s5, s6;\n s0 = peg$currPos;\n s1 = peg$parsecolon();\n if (s1 !== peg$FAILED) {\n s2 = peg$parse_comment_();\n s3 = [];\n s4 = peg$currPos;\n s5 = peg$parseoperation();\n if (s5 !== peg$FAILED) {\n s6 = peg$parse_comment_();\n peg$savedPos = s4;\n s4 = peg$f2(s2, s5, s6);\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n if (s4 !== peg$FAILED) {\n while (s4 !== peg$FAILED) {\n s3.push(s4);\n s4 = peg$currPos;\n s5 = peg$parseoperation();\n if (s5 !== peg$FAILED) {\n s6 = peg$parse_comment_();\n peg$savedPos = s4;\n s4 = peg$f2(s2, s5, s6);\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n }\n } else {\n s3 = peg$FAILED;\n }\n if (s3 !== peg$FAILED) {\n s4 = peg$parseequals();\n if (s4 !== peg$FAILED) {\n s5 = peg$parse_comment_();\n s6 = peg$parsegroup();\n if (s6 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f3(s2, s3, s5, s6);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parseforeach() {\n var s0, s1, s2;\n s0 = peg$currPos;\n s1 = peg$parseforeach_keyword();\n if (s1 === peg$FAILED) {\n s1 = peg$parseforeach_macro();\n }\n if (s1 !== peg$FAILED) {\n s2 = peg$parseforeach_body();\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f4(s1, s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parseforeach_body() {\n var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;\n s0 = peg$currPos;\n s1 = peg$parse_comment_();\n s2 = peg$currPos;\n s3 = [];\n s4 = peg$currPos;\n s5 = peg$currPos;\n peg$silentFails++;\n s6 = peg$parsein_keyword();\n if (s6 === peg$FAILED) {\n s6 = peg$parsesquare_brace_group();\n }\n peg$silentFails--;\n if (s6 === peg$FAILED) {\n s5 = void 0;\n } else {\n peg$currPos = s5;\n s5 = peg$FAILED;\n }\n if (s5 !== peg$FAILED) {\n if (input.length > peg$currPos) {\n s6 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s6 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n if (s6 !== peg$FAILED) {\n s5 = [s5, s6];\n s4 = s5;\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n while (s4 !== peg$FAILED) {\n s3.push(s4);\n s4 = peg$currPos;\n s5 = peg$currPos;\n peg$silentFails++;\n s6 = peg$parsein_keyword();\n if (s6 === peg$FAILED) {\n s6 = peg$parsesquare_brace_group();\n }\n peg$silentFails--;\n if (s6 === peg$FAILED) {\n s5 = void 0;\n } else {\n peg$currPos = s5;\n s5 = peg$FAILED;\n }\n if (s5 !== peg$FAILED) {\n if (input.length > peg$currPos) {\n s6 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s6 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n if (s6 !== peg$FAILED) {\n s5 = [s5, s6];\n s4 = s5;\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n }\n s2 = input.substring(s2, peg$currPos);\n s3 = peg$parsesquare_brace_group();\n if (s3 === peg$FAILED) {\n s3 = null;\n }\n s4 = peg$parse_comment_();\n s5 = peg$parsein_keyword();\n if (s5 !== peg$FAILED) {\n s6 = peg$parse_comment_();\n s7 = peg$parsegroup();\n if (s7 === peg$FAILED) {\n s7 = peg$parsemacro();\n }\n if (s7 !== peg$FAILED) {\n s8 = peg$parse_comment_();\n s9 = peg$parseforeach();\n if (s9 === peg$FAILED) {\n s9 = peg$parsegroup();\n if (s9 === peg$FAILED) {\n s9 = peg$parsemacro();\n }\n }\n if (s9 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f5(s1, s2, s3, s4, s6, s7, s8, s9);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parsesvg() {\n var s0, s1, s2, s3, s4, s5;\n s0 = peg$currPos;\n s1 = peg$parsesvg_keyword();\n if (s1 !== peg$FAILED) {\n s2 = peg$parse_comment_();\n s3 = peg$parsesquare_brace_group();\n if (s3 === peg$FAILED) {\n s3 = null;\n }\n s4 = peg$parse_comment_();\n s5 = peg$parsegroup();\n if (s5 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f6(s2, s3, s4, s5);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parsecurve_to() {\n var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10;\n s0 = peg$currPos;\n s1 = peg$parsedotdot();\n if (s1 !== peg$FAILED) {\n s2 = peg$parse_comment_();\n s3 = peg$parsecontrols_keyword();\n if (s3 !== peg$FAILED) {\n s4 = peg$parse_comment_();\n s5 = peg$parsecoordinate();\n if (s5 !== peg$FAILED) {\n s6 = peg$parse_comment_();\n s7 = peg$currPos;\n s8 = peg$parseand_keyword();\n if (s8 !== peg$FAILED) {\n s9 = peg$parse_comment_();\n s10 = peg$parsecoordinate();\n if (s10 !== peg$FAILED) {\n peg$savedPos = s7;\n s7 = peg$f7(s2, s4, s5, s6, s9, s10);\n } else {\n peg$currPos = s7;\n s7 = peg$FAILED;\n }\n } else {\n peg$currPos = s7;\n s7 = peg$FAILED;\n }\n if (s7 === peg$FAILED) {\n s7 = null;\n }\n s8 = peg$parse_comment_();\n s9 = peg$parsedotdot();\n if (s9 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f8(s2, s4, s5, s6, s7, s8);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parseline_to() {\n var s0, s1, s2;\n s0 = peg$currPos;\n s1 = peg$parsepipe();\n if (s1 !== peg$FAILED) {\n s2 = peg$parseminus();\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f9();\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n if (s0 === peg$FAILED) {\n s0 = peg$currPos;\n s1 = peg$parseminus();\n if (s1 !== peg$FAILED) {\n s2 = peg$parsepipe();\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f10();\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n if (s0 === peg$FAILED) {\n s0 = peg$currPos;\n s1 = peg$parseminus();\n if (s1 !== peg$FAILED) {\n s2 = peg$parseminus();\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f11();\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n }\n }\n return s0;\n }\n function peg$parsecoordinate() {\n var s0, s1, s2, s3, s4, s5, s6, s7;\n s0 = peg$currPos;\n s1 = peg$currPos;\n s2 = peg$currPos;\n s3 = peg$parseplus();\n if (s3 !== peg$FAILED) {\n s4 = peg$parseplus();\n if (s4 === peg$FAILED) {\n s4 = null;\n }\n s3 = [s3, s4];\n s2 = s3;\n } else {\n peg$currPos = s2;\n s2 = peg$FAILED;\n }\n if (s2 === peg$FAILED) {\n s2 = null;\n }\n s1 = input.substring(s1, peg$currPos);\n s2 = peg$parseopen_paren();\n if (s2 !== peg$FAILED) {\n s3 = peg$currPos;\n s4 = [];\n s5 = peg$currPos;\n s6 = peg$currPos;\n peg$silentFails++;\n s7 = peg$parseclose_paren();\n peg$silentFails--;\n if (s7 === peg$FAILED) {\n s6 = void 0;\n } else {\n peg$currPos = s6;\n s6 = peg$FAILED;\n }\n if (s6 !== peg$FAILED) {\n if (input.length > peg$currPos) {\n s7 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s7 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n if (s7 !== peg$FAILED) {\n s6 = [s6, s7];\n s5 = s6;\n } else {\n peg$currPos = s5;\n s5 = peg$FAILED;\n }\n } else {\n peg$currPos = s5;\n s5 = peg$FAILED;\n }\n while (s5 !== peg$FAILED) {\n s4.push(s5);\n s5 = peg$currPos;\n s6 = peg$currPos;\n peg$silentFails++;\n s7 = peg$parseclose_paren();\n peg$silentFails--;\n if (s7 === peg$FAILED) {\n s6 = void 0;\n } else {\n peg$currPos = s6;\n s6 = peg$FAILED;\n }\n if (s6 !== peg$FAILED) {\n if (input.length > peg$currPos) {\n s7 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s7 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n if (s7 !== peg$FAILED) {\n s6 = [s6, s7];\n s5 = s6;\n } else {\n peg$currPos = s5;\n s5 = peg$FAILED;\n }\n } else {\n peg$currPos = s5;\n s5 = peg$FAILED;\n }\n }\n s3 = input.substring(s3, peg$currPos);\n s4 = peg$parseclose_paren();\n if (s4 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f12(s1, s3);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parsesquare_brace_group() {\n var s0, s1, s2, s3, s4, s5, s6;\n s0 = peg$currPos;\n s1 = peg$parseopen_square_brace();\n if (s1 !== peg$FAILED) {\n s2 = peg$currPos;\n s3 = [];\n s4 = peg$currPos;\n s5 = peg$currPos;\n peg$silentFails++;\n s6 = peg$parseclose_square_brace();\n peg$silentFails--;\n if (s6 === peg$FAILED) {\n s5 = void 0;\n } else {\n peg$currPos = s5;\n s5 = peg$FAILED;\n }\n if (s5 !== peg$FAILED) {\n if (input.length > peg$currPos) {\n s6 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s6 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n if (s6 !== peg$FAILED) {\n s5 = [s5, s6];\n s4 = s5;\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n while (s4 !== peg$FAILED) {\n s3.push(s4);\n s4 = peg$currPos;\n s5 = peg$currPos;\n peg$silentFails++;\n s6 = peg$parseclose_square_brace();\n peg$silentFails--;\n if (s6 === peg$FAILED) {\n s5 = void 0;\n } else {\n peg$currPos = s5;\n s5 = peg$FAILED;\n }\n if (s5 !== peg$FAILED) {\n if (input.length > peg$currPos) {\n s6 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s6 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n if (s6 !== peg$FAILED) {\n s5 = [s5, s6];\n s4 = s5;\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n } else {\n peg$currPos = s4;\n s4 = peg$FAILED;\n }\n }\n s2 = input.substring(s2, peg$currPos);\n s3 = peg$parseclose_square_brace();\n if (s3 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f13(s2);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parsedotdot() {\n var s0, s1, s2;\n s0 = peg$currPos;\n s1 = peg$parsedot();\n if (s1 !== peg$FAILED) {\n s2 = peg$parsedot();\n if (s2 !== peg$FAILED) {\n s1 = [s1, s2];\n s0 = s1;\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parseunknown() {\n var s0, s1;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = s0;\n s1 = peg$f14(s1);\n }\n s0 = s1;\n return s0;\n }\n function peg$parsesame_line_comment() {\n var s0, s1, s2;\n peg$silentFails++;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f15(s1);\n if (s2) {\n s2 = void 0;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f16(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e1);\n }\n }\n return s0;\n }\n function peg$parseown_line_comment() {\n var s0, s1, s2;\n peg$silentFails++;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f17(s1);\n if (s2) {\n s2 = void 0;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f18(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e2);\n }\n }\n return s0;\n }\n function peg$parsecomment() {\n var s0, s1, s2;\n peg$silentFails++;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f19(s1);\n if (s2) {\n s2 = void 0;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f20(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e3);\n }\n }\n return s0;\n }\n function peg$parse_() {\n var s0, s1, s2;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f21(s1);\n if (s2) {\n s2 = void 0;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f22(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parse_comment_() {\n var s0, s1, s2, s3, s4;\n peg$silentFails++;\n s0 = peg$currPos;\n s1 = [];\n s2 = peg$parse_();\n while (s2 !== peg$FAILED) {\n s1.push(s2);\n s2 = peg$parse_();\n }\n s2 = peg$parsecomment();\n if (s2 === peg$FAILED) {\n s2 = null;\n }\n s3 = [];\n s4 = peg$parse_();\n while (s4 !== peg$FAILED) {\n s3.push(s4);\n s4 = peg$parse_();\n }\n peg$savedPos = s0;\n s0 = peg$f23(s2);\n peg$silentFails--;\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e4);\n }\n return s0;\n }\n function peg$parseoperation() {\n var s0, s1, s2;\n peg$silentFails++;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f24(s1);\n if (s2) {\n s2 = void 0;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f25(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e5);\n }\n }\n return s0;\n }\n function peg$parseequals() {\n var s0, s1, s2;\n peg$silentFails++;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f26(s1);\n if (s2) {\n s2 = void 0;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f27(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n peg$silentFails--;\n if (s0 === peg$FAILED) {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e6);\n }\n }\n return s0;\n }\n function peg$parseopen_square_brace() {\n var s0, s1, s2;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f28(s1);\n if (s2) {\n s2 = void 0;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f29(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parseclose_square_brace() {\n var s0, s1, s2;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f30(s1);\n if (s2) {\n s2 = void 0;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f31(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parseopen_paren() {\n var s0, s1, s2;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f32(s1);\n if (s2) {\n s2 = void 0;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f33(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parseclose_paren() {\n var s0, s1, s2;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f34(s1);\n if (s2) {\n s2 = void 0;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f35(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parseplus() {\n var s0, s1, s2;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f36(s1);\n if (s2) {\n s2 = void 0;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f37(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parseminus() {\n var s0, s1, s2;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f38(s1);\n if (s2) {\n s2 = void 0;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f39(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parsepipe() {\n var s0, s1, s2;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f40(s1);\n if (s2) {\n s2 = void 0;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f41(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parsedot() {\n var s0, s1, s2;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f42(s1);\n if (s2) {\n s2 = void 0;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f43(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parsecontrols_keyword() {\n var s0, s1, s2;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f44(s1);\n if (s2) {\n s2 = void 0;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f45(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parseand_keyword() {\n var s0, s1, s2;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f46(s1);\n if (s2) {\n s2 = void 0;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f47(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parsesvg_keyword() {\n var s0, s1, s2;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f48(s1);\n if (s2) {\n s2 = void 0;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f49(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parsegroup() {\n var s0, s1, s2;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f50(s1);\n if (s2) {\n s2 = void 0;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f51(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parsemacro() {\n var s0, s1, s2;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f52(s1);\n if (s2) {\n s2 = void 0;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f53(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parseforeach_keyword() {\n var s0, s1, s2;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f54(s1);\n if (s2) {\n s2 = void 0;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f55(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parseforeach_macro() {\n var s0, s1, s2;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f56(s1);\n if (s2) {\n s2 = void 0;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f57(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parsein_keyword() {\n var s0, s1, s2;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f58(s1);\n if (s2) {\n s2 = void 0;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f59(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parsecolon() {\n var s0, s1, s2;\n s0 = peg$currPos;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n if (s1 !== peg$FAILED) {\n peg$savedPos = peg$currPos;\n s2 = peg$f60(s1);\n if (s2) {\n s2 = void 0;\n } else {\n s2 = peg$FAILED;\n }\n if (s2 !== peg$FAILED) {\n peg$savedPos = s0;\n s0 = peg$f61(s1);\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n function peg$parseEOL() {\n var s0, s1;\n s0 = peg$currPos;\n peg$silentFails++;\n if (input.length > peg$currPos) {\n s1 = input.charAt(peg$currPos);\n peg$currPos++;\n } else {\n s1 = peg$FAILED;\n if (peg$silentFails === 0) {\n peg$fail(peg$e0);\n }\n }\n peg$silentFails--;\n if (s1 === peg$FAILED) {\n s0 = void 0;\n } else {\n peg$currPos = s0;\n s0 = peg$FAILED;\n }\n return s0;\n }\n if (!options.isWhitespace) {\n try {\n Object.assign(options, {\n isChar: (node, char) => node.type === \"string\" && node.content === char,\n isOperation: (node) => node.type === \"string\" && node.content.match(/[a-zA-Z]/),\n isWhitespace: (node) => node.type === \"whitespace\" || node.type === \"parbreak\",\n isSameLineComment: (node) => node.type === \"comment\" && node.sameline,\n isOwnLineComment: (node) => node.type === \"comment\" && !node.sameline,\n isComment: (node) => node.type === \"comment\",\n isGroup: (node) => node.type === \"group\",\n isMacro: (node, name) => node.type === \"macro\" && node.content === name,\n isAnyMacro: (node) => node.type === \"macro\"\n });\n } catch (e) {\n console.warn(\"Error when initializing parser\", e);\n }\n }\n peg$result = peg$startRuleFunction();\n if (peg$result !== peg$FAILED && peg$currPos === input.length) {\n return peg$result;\n } else {\n if (peg$result !== peg$FAILED && peg$currPos < input.length) {\n peg$fail(peg$endExpectation());\n }\n throw peg$buildStructuredError(\n peg$maxFailExpected,\n peg$maxFailPos < input.length ? input.charAt(peg$maxFailPos) : null,\n peg$maxFailPos < input.length ? peg$computeLocation(peg$maxFailPos, peg$maxFailPos + 1) : peg$computeLocation(peg$maxFailPos, peg$maxFailPos)\n );\n }\n }\n return {\n SyntaxError: peg$SyntaxError,\n parse: peg$parse\n };\n }()\n);\n\n// libs/pegjs-parsers.ts\nvar LatexPegParser = latex_default;\nvar AlignEnvironmentPegParser = align_environment_default;\nvar ArgSpecPegParser = xparse_argspec_default;\nvar PgfkeysPegParser = pgfkeys_default;\nvar MacroSubstitutionPegParser = macro_substitutions_default;\nvar LigaturesPegParser = ligatures_default;\nvar XColorPegParser = xcolor_expressions_default;\nvar TabularPegParser = tabular_spec_default;\nvar SystemePegParser = systeme_environment_default;\nvar GluePegParser = tex_glue_default;\nvar TikzPegParser = tikz_default;\nexport {\n AlignEnvironmentPegParser,\n ArgSpecPegParser,\n GluePegParser,\n LatexPegParser,\n LigaturesPegParser,\n MacroSubstitutionPegParser,\n PgfkeysPegParser,\n SystemePegParser,\n TabularPegParser,\n TikzPegParser,\n XColorPegParser,\n decorateArrayForPegjs,\n splitStringsIntoSingleChars\n};\n//# sourceMappingURL=index.js.map\n","// libs/argspec-parser.ts\nimport { ArgSpecPegParser as PegParser } from \"@unified-latex/unified-latex-util-pegjs\";\nfunction getDecorators(node) {\n let ret = \"\";\n if (node.noLeadingWhitespace) {\n ret += \"!\";\n }\n return ret;\n}\nfunction printRaw(node, root = false) {\n if (typeof node === \"string\") {\n return node;\n }\n if (Array.isArray(node)) {\n const sepToken = root ? \" \" : \"\";\n return node.map((tok) => printRaw(tok)).join(sepToken);\n }\n const decorators = getDecorators(node);\n const defaultArg = node.defaultArg ? printRaw(node.defaultArg) : \"\";\n let spec = decorators;\n const type = node.type;\n switch (type) {\n case \"body\":\n return decorators + \"b\";\n case \"optionalStar\":\n return decorators + \"s\";\n case \"optionalToken\":\n return spec + \"t\" + node.token;\n case \"optional\":\n if (node.openBrace === \"[\" && node.closeBrace === \"]\") {\n spec += node.defaultArg ? \"O\" : \"o\";\n } else {\n spec += node.defaultArg ? \"D\" : \"d\";\n spec += node.openBrace + node.closeBrace;\n }\n return spec + defaultArg;\n case \"mandatory\":\n if (node.openBrace === \"{\" && node.closeBrace === \"}\") {\n spec += \"m\";\n } else {\n spec += node.defaultArg ? \"R\" : \"r\";\n spec += node.openBrace + node.closeBrace;\n }\n return spec + defaultArg;\n case \"embellishment\":\n spec += node.defaultArg ? \"E\" : \"e\";\n return spec + \"{\" + printRaw(node.embellishmentTokens) + \"}\" + defaultArg;\n case \"verbatim\":\n return spec + \"v\" + node.openBrace;\n case \"group\":\n return spec + \"{\" + printRaw(node.content) + \"}\";\n case \"until\": {\n const stopTokens = printRaw(node.stopTokens);\n return stopTokens.length > 1 || stopTokens[0] === \" \" ? `u{${stopTokens}}` : `u${stopTokens}`;\n }\n default:\n const neverType = type;\n console.warn(`Unknown node type \"${neverType}\" for node`, node);\n return \"\";\n }\n}\nvar parseCache = {};\nfunction parse(str = \"\") {\n parseCache[str] = parseCache[str] || PegParser.parse(str);\n return parseCache[str];\n}\n\n// libs/argspec-types.ts\nvar argspec_types_exports = {};\nexport {\n argspec_types_exports as ArgSpecAst,\n parse,\n printRaw\n};\n//# sourceMappingURL=index.js.map\n","// libs/builders.ts\nfunction normalizeNode(node) {\n if (typeof node === \"string\") {\n return s(node);\n }\n return node;\n}\nfunction normalizeArgument(arg2, openMark = \"{\", closeMark = \"}\") {\n if (arg2 == null) {\n return { type: \"argument\", content: [], openMark: \"\", closeMark: \"\" };\n }\n if (typeof arg2 === \"string\") {\n return {\n type: \"argument\",\n openMark,\n closeMark,\n content: [s(arg2)]\n };\n }\n if (arg2.type === \"argument\") {\n return arg2;\n }\n return { type: \"argument\", openMark, closeMark, content: [arg2] };\n}\nfunction normalizeArgumentsList(args2, openMark = \"{\", closeMark = \"}\") {\n if (args2 == null) {\n return [];\n }\n if (Array.isArray(args2)) {\n return args2.map((arg2) => normalizeArgument(arg2, openMark, closeMark));\n }\n return [normalizeArgument(args2, openMark, closeMark)];\n}\nvar BRACES_MAP = {\n \"*\": { openMark: \"\", closeMark: \"\" },\n \"{\": { openMark: \"{\", closeMark: \"}\" },\n \"[\": { openMark: \"[\", closeMark: \"]\" },\n \"(\": { openMark: \"(\", closeMark: \")\" },\n \"<\": { openMark: \"<\", closeMark: \">\" }\n};\nvar CLOSE_BRACES = new Set(\n Object.values(BRACES_MAP).map((x) => x.closeMark).filter((x) => x)\n);\nfunction bracesToOpenAndCloseMarks(braces) {\n const ret = [];\n for (const char of braces.split(\"\")) {\n if (CLOSE_BRACES.has(char)) {\n continue;\n }\n const braces2 = BRACES_MAP[char];\n if (braces2 == null) {\n throw new Error(`Unknown open/close mark type \"${char}\"`);\n }\n braces2;\n ret.push(braces2);\n }\n return ret;\n}\nfunction args(args2, special) {\n if (!Array.isArray(args2)) {\n args2 = [args2];\n }\n if (special == null ? void 0 : special.braces) {\n const braces = bracesToOpenAndCloseMarks(special.braces);\n if (braces.length !== args2.length) {\n throw new Error(\n `There is a difference between the number of supplied braces and the number of supplied arguments. ${args2.length} supplied with braces signature ${special.braces}`\n );\n }\n return args2.map(\n (arg2, i) => normalizeArgument(arg2, braces[i].openMark, braces[i].closeMark)\n );\n }\n const openMark = (special == null ? void 0 : special.defaultOpenMark) ?? \"{\";\n const closeMark = (special == null ? void 0 : special.defaultCloseMark) ?? \"}\";\n return normalizeArgumentsList(args2, openMark, closeMark);\n}\nfunction arg(args2, special) {\n if (args2 == null) {\n return { type: \"argument\", content: [], openMark: \"\", closeMark: \"\" };\n }\n if (typeof args2 === \"string\") {\n args2 = s(args2);\n }\n if (!Array.isArray(args2) && args2.type === \"argument\") {\n return args2;\n }\n let openMark = (special == null ? void 0 : special.openMark) ?? \"{\";\n let closeMark = (special == null ? void 0 : special.closeMark) ?? \"}\";\n if (special == null ? void 0 : special.braces) {\n const braces = bracesToOpenAndCloseMarks(special.braces);\n if (braces[0]) {\n openMark = braces[0].openMark;\n closeMark = braces[0].closeMark;\n }\n }\n if (!Array.isArray(args2)) {\n args2 = [args2];\n }\n return { type: \"argument\", content: args2, openMark, closeMark };\n}\nfunction m(name, marcoArgs, special) {\n const args2 = normalizeArgumentsList(marcoArgs);\n const escapeToken = special == null ? void 0 : special.escapeToken;\n const ret = { type: \"macro\", content: name };\n if (args2.length > 0) {\n ret.args = args2;\n }\n if (escapeToken != null) {\n ret.escapeToken = escapeToken;\n }\n return ret;\n}\nfunction s(value) {\n if (typeof value === \"string\") {\n return { type: \"string\", content: value };\n }\n return value;\n}\nfunction env(name, body, envArgs, special) {\n if (!Array.isArray(body)) {\n body = [body];\n }\n const args2 = normalizeArgumentsList(envArgs, \"[\", \"]\");\n const ret = {\n type: \"environment\",\n env: name,\n content: body.map(normalizeNode)\n };\n if (args2.length > 0) {\n ret.args = args2;\n }\n return ret;\n}\nvar SP = { type: \"whitespace\" };\nexport {\n SP,\n arg,\n args,\n env,\n m,\n s\n};\n//# sourceMappingURL=index.js.map\n","'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\nexports.default = {\n END_WORD: '$',\n END_WORD_REPLACER: '9a219a89-91cd-42e2-abd5-eb113af08ca8',\n PERMS_MIN_LEN: 2\n};\nmodule.exports = exports['default'];","'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\nexports.default = append;\n\nvar _config = require('./config');\n\nvar _config2 = _interopRequireDefault(_config);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nfunction append(trie, letter, index, array) {\n var isEndWordLetter = letter === _config2.default.END_WORD;\n var isLastLetter = index === array.length - 1;\n\n if (isEndWordLetter && !isLastLetter) {\n trie[_config2.default.END_WORD] = 1;\n trie[_config2.default.END_WORD_REPLACER] = {};\n trie = trie[_config2.default.END_WORD_REPLACER];\n } else {\n trie[letter] = trie[letter] || {};\n trie = trie[letter];\n }\n\n if (isLastLetter) {\n trie[_config2.default.END_WORD] = 1;\n }\n\n return trie;\n}\nmodule.exports = exports['default'];","'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\n\nvar _typeof = typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; };\n\nexports.default = create;\n\nvar _append = require('./append');\n\nvar _append2 = _interopRequireDefault(_append);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nfunction create(input) {\n if (!Array.isArray(input)) {\n throw 'Expected parameter Array, received ' + (typeof input === 'undefined' ? 'undefined' : _typeof(input));\n }\n\n var trie = input.reduce(function (accumulator, item) {\n item.toLowerCase().split('').reduce(_append2.default, accumulator);\n\n return accumulator;\n }, {});\n\n return trie;\n};\nmodule.exports = exports['default'];","'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\nexports.default = {\n objectCopy: function objectCopy(obj) {\n if (typeof obj === 'undefined') {\n return {};\n }\n return JSON.parse(JSON.stringify(obj));\n },\n stringify: function stringify(obj) {\n var spacer = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 2;\n\n if (typeof obj === 'undefined') {\n return '';\n }\n return JSON.stringify(obj, null, spacer);\n }\n};\nmodule.exports = exports['default'];","'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\nexports.default = checkPrefix;\n\nvar _utils = require('./utils');\n\nvar _utils2 = _interopRequireDefault(_utils);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nfunction checkPrefix(prefixNode, prefix) {\n var input = prefix.toLowerCase().split('');\n var prefixFound = input.every(function (letter, index) {\n if (!prefixNode[letter]) {\n return false;\n }\n return prefixNode = prefixNode[letter];\n });\n\n return {\n prefixFound: prefixFound,\n prefixNode: prefixNode\n };\n};\nmodule.exports = exports['default'];","'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\nexports.default = recursePrefix;\n\nvar _config = require('./config');\n\nvar _config2 = _interopRequireDefault(_config);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\n// sort items as they're being found\n// to prevent slow .sort() in NodeJs\nvar pushInOrder = function pushInOrder(word, prefixes) {\n var i = 0;\n\n while (i < prefixes.length) {\n if (word < prefixes[i]) {\n break;\n }\n i += 1;\n }\n\n prefixes.splice(i, 0, word);\n\n return prefixes;\n};\n\nfunction recursePrefix(node, prefix, sorted) {\n var prefixes = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : [];\n\n var word = prefix;\n\n for (var branch in node) {\n var currentLetter = branch;\n if (branch === _config2.default.END_WORD && typeof node[branch] === 'number') {\n if (sorted) {\n pushInOrder(word, prefixes);\n } else {\n prefixes.push(word);\n }\n word = '';\n } else if (branch === _config2.default.END_WORD_REPLACER) {\n currentLetter = _config2.default.END_WORD;\n }\n recursePrefix(node[branch], prefix + currentLetter, sorted, prefixes);\n }\n\n return prefixes;\n}\nmodule.exports = exports['default'];","'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\nexports.default = recurseRandomWord;\n\nvar _config = require('./config');\n\nvar _config2 = _interopRequireDefault(_config);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nfunction recurseRandomWord(node, prefix) {\n var word = prefix;\n var branches = Object.keys(node);\n var branch = branches[Math.floor(Math.random() * branches.length)];\n\n if (branch === _config2.default.END_WORD) {\n return word;\n }\n return recurseRandomWord(node[branch], prefix + branch);\n};\nmodule.exports = exports['default'];","'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\n\nvar _typeof = typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; };\n\nexports.default = permutations;\n\nvar _config = require('./config');\n\nvar _config2 = _interopRequireDefault(_config);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nfunction permutations(letters, trie) {\n var opts = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {\n type: 'anagram'\n };\n\n if (typeof letters !== 'string') {\n throw 'Permutations expects string letters, received ' + (typeof letters === 'undefined' ? 'undefined' : _typeof(letters));\n }\n\n var words = [];\n\n var permute = function permute(word, node) {\n var prefix = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : '';\n\n var wordIsEmpty = word.length === 0;\n var wordFound = words.indexOf(prefix) !== -1;\n var endWordFound = node[_config2.default.END_WORD] === 1;\n\n if (wordIsEmpty && endWordFound && !wordFound) {\n words.push(prefix);\n }\n\n for (var i = 0, len = word.length; i < len; i++) {\n var letter = word[i];\n\n if (opts.type === 'sub-anagram') {\n if (endWordFound && !(words.indexOf(prefix) !== -1)) {\n words.push(prefix);\n }\n }\n\n if (node[letter]) {\n var remaining = word.substring(0, i) + word.substring(i + 1, len);\n permute(remaining, node[letter], prefix + letter, words);\n }\n }\n\n return words.sort();\n };\n\n return permute(letters, trie);\n};\nmodule.exports = exports['default'];","'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\n\nvar _typeof = typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; };\n\nexports.default = function (input) {\n if (!Array.isArray(input)) {\n throw 'Expected parameter Array, received ' + (typeof input === 'undefined' ? 'undefined' : _typeof(input));\n }\n\n var trie = (0, _create2.default)([].concat(_toConsumableArray(input)));\n\n return {\n /**\n * Get the generated raw trie object\n */\n tree: function tree() {\n return trie;\n },\n\n\n /**\n * Get a string representation of the trie\n */\n dump: function dump() {\n var spacer = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;\n\n return _utils2.default.stringify(trie, spacer);\n },\n\n\n /**\n * Add a new word to the trie\n */\n addWord: function addWord(word) {\n if (typeof word !== 'string' || word === '') {\n throw 'Expected parameter string, received ' + (typeof word === 'undefined' ? 'undefined' : _typeof(word));\n }\n\n var reducer = function reducer() {\n return _append2.default.apply(undefined, arguments);\n };\n\n var input = word.toLowerCase().split('');\n input.reduce(reducer, trie);\n\n return this;\n },\n\n\n /**\n * Remove an existing word from the trie\n */\n removeWord: function removeWord(word) {\n if (typeof word !== 'string' || word === '') {\n throw 'Expected parameter string, received ' + (typeof word === 'undefined' ? 'undefined' : _typeof(word));\n }\n\n var _checkPrefix = (0, _checkPrefix6.default)(trie, word),\n prefixFound = _checkPrefix.prefixFound,\n prefixNode = _checkPrefix.prefixNode;\n\n if (prefixFound) {\n delete prefixNode[_config2.default.END_WORD];\n }\n\n return this;\n },\n\n\n /**\n * Check a prefix is valid\n * @returns Boolean\n */\n isPrefix: function isPrefix(prefix) {\n if (typeof prefix !== 'string') {\n throw 'Expected string prefix, received ' + (typeof prefix === 'undefined' ? 'undefined' : _typeof(prefix));\n }\n\n var _checkPrefix2 = (0, _checkPrefix6.default)(trie, prefix),\n prefixFound = _checkPrefix2.prefixFound;\n\n return prefixFound;\n },\n\n\n /**\n * Get a list of all words in the trie with the given prefix\n * @returns Array\n */\n getPrefix: function getPrefix(strPrefix) {\n var sorted = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;\n\n if (typeof strPrefix !== 'string') {\n throw 'Expected string prefix, received ' + (typeof strPrefix === 'undefined' ? 'undefined' : _typeof(strPrefix));\n }\n\n if (typeof sorted !== 'boolean') {\n throw 'Expected sort parameter as boolean, received ' + (typeof sorted === 'undefined' ? 'undefined' : _typeof(sorted));\n }\n\n if (!this.isPrefix(strPrefix)) {\n return [];\n }\n\n var prefixNode = strPrefix.length ? (0, _checkPrefix6.default)(trie, strPrefix).prefixNode : trie;\n\n return (0, _recursePrefix2.default)(prefixNode, strPrefix, sorted);\n },\n\n\n /**\n * Get a random word in the trie with the given prefix\n * @returns Array\n */\n getRandomWordWithPrefix: function getRandomWordWithPrefix(strPrefix) {\n if (typeof strPrefix !== 'string') {\n throw 'Expected string prefix, received ' + (typeof strPrefix === 'undefined' ? 'undefined' : _typeof(strPrefix));\n }\n\n if (!this.isPrefix(strPrefix)) {\n return '';\n }\n\n var _checkPrefix3 = (0, _checkPrefix6.default)(trie, strPrefix),\n prefixNode = _checkPrefix3.prefixNode;\n\n return (0, _recurseRandomWord2.default)(prefixNode, strPrefix);\n },\n\n\n /**\n * Count the number of words with the given prefixSearch\n * @returns Number\n */\n countPrefix: function countPrefix(strPrefix) {\n var prefixes = this.getPrefix(strPrefix);\n\n return prefixes.length;\n },\n\n\n /**\n * Get all words in the trie\n * @returns Array\n */\n getWords: function getWords() {\n var sorted = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;\n\n return this.getPrefix('', sorted);\n },\n\n\n /**\n * Check the existence of a word in the trie\n * @returns Boolean\n */\n hasWord: function hasWord(word) {\n if (typeof word !== 'string') {\n throw 'Expected string word, received ' + (typeof word === 'undefined' ? 'undefined' : _typeof(word));\n }\n\n var _checkPrefix4 = (0, _checkPrefix6.default)(trie, word),\n prefixFound = _checkPrefix4.prefixFound,\n prefixNode = _checkPrefix4.prefixNode;\n\n if (prefixFound) {\n return prefixNode[_config2.default.END_WORD] === 1;\n }\n\n return false;\n },\n\n\n /**\n * Get a list of valid anagrams that can be made from the given letters\n * @returns Array\n */\n getAnagrams: function getAnagrams(letters) {\n if (typeof letters !== 'string') {\n throw 'Anagrams expected string letters, received ' + (typeof letters === 'undefined' ? 'undefined' : _typeof(letters));\n }\n\n if (letters.length < PERMS_MIN_LEN) {\n throw 'getAnagrams expects at least ' + PERMS_MIN_LEN + ' letters';\n }\n\n return (0, _permutations2.default)(letters, trie, {\n type: 'anagram'\n });\n },\n\n\n /**\n * Get a list of all sub-anagrams that can be made from the given letters\n * @returns Array\n */\n getSubAnagrams: function getSubAnagrams(letters) {\n if (typeof letters !== 'string') {\n throw 'Expected string letters, received ' + (typeof letters === 'undefined' ? 'undefined' : _typeof(letters));\n }\n\n if (letters.length < PERMS_MIN_LEN) {\n throw 'getSubAnagrams expects at least ' + PERMS_MIN_LEN + ' letters';\n }\n\n return (0, _permutations2.default)(letters, trie, {\n type: 'sub-anagram'\n });\n }\n };\n};\n\nvar _create = require('./create');\n\nvar _create2 = _interopRequireDefault(_create);\n\nvar _append = require('./append');\n\nvar _append2 = _interopRequireDefault(_append);\n\nvar _checkPrefix5 = require('./checkPrefix');\n\nvar _checkPrefix6 = _interopRequireDefault(_checkPrefix5);\n\nvar _recursePrefix = require('./recursePrefix');\n\nvar _recursePrefix2 = _interopRequireDefault(_recursePrefix);\n\nvar _recurseRandomWord = require('./recurseRandomWord');\n\nvar _recurseRandomWord2 = _interopRequireDefault(_recurseRandomWord);\n\nvar _utils = require('./utils');\n\nvar _utils2 = _interopRequireDefault(_utils);\n\nvar _config = require('./config');\n\nvar _config2 = _interopRequireDefault(_config);\n\nvar _permutations = require('./permutations');\n\nvar _permutations2 = _interopRequireDefault(_permutations);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nfunction _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } else { return Array.from(arr); } }\n\nvar PERMS_MIN_LEN = _config2.default.PERMS_MIN_LEN;\n\n;\nmodule.exports = exports['default'];","// libs/scan.ts\nimport { match } from \"@unified-latex/unified-latex-util-match\";\nimport { printRaw } from \"@unified-latex/unified-latex-util-print-raw\";\nfunction scan(nodes, token, options) {\n const { startIndex, onlySkipWhitespaceAndComments, allowSubstringMatches } = options || {};\n if (typeof token === \"string\") {\n token = { type: \"string\", content: token };\n }\n for (let i = startIndex || 0; i < nodes.length; i++) {\n const node = nodes[i];\n if (node.type === token.type) {\n switch (node.type) {\n case \"comment\":\n case \"displaymath\":\n case \"inlinemath\":\n case \"root\":\n case \"parbreak\":\n case \"whitespace\":\n case \"verb\":\n case \"verbatim\":\n case \"group\":\n return i;\n case \"macro\":\n if (node.content === token.content) {\n return i;\n }\n break;\n case \"environment\":\n case \"mathenv\":\n if (printRaw(node.env) === printRaw(token.env)) {\n return i;\n }\n break;\n case \"string\":\n if (node.content === token.content) {\n return i;\n }\n if (allowSubstringMatches && node.content.indexOf(token.content) >= 0) {\n return i;\n }\n break;\n }\n }\n if (onlySkipWhitespaceAndComments && !match.whitespace(node) && !match.comment(node)) {\n return null;\n }\n }\n return null;\n}\n\n// libs/prefix-match.ts\nimport Trie from \"trie-prefix-tree\";\nimport { match as match2 } from \"@unified-latex/unified-latex-util-match\";\nfunction prefixMatch(nodes, prefixes, options) {\n const {\n startIndex = 0,\n matchSubstrings = false,\n assumeOneCharStrings = false\n } = options || {};\n if (typeof prefixes === \"string\") {\n prefixes = [prefixes];\n }\n if (Array.isArray(prefixes)) {\n prefixes = Trie(prefixes);\n }\n const prefixTree = prefixes;\n const history = {\n lastPrefix: \"\",\n lastWord: \"\",\n index: startIndex,\n partialMatch: \"\"\n };\n function tryToMatchNextChar(char, index) {\n let ret = false;\n if (prefixTree.isPrefix(history.lastPrefix + char)) {\n history.lastPrefix += char;\n history.index = index;\n ret = true;\n }\n if (prefixTree.hasWord(history.lastPrefix)) {\n history.lastWord = history.lastPrefix;\n }\n return ret;\n }\n for (let i = 0; startIndex + i < nodes.length; i++) {\n const node = nodes[startIndex + i];\n if (!match2.string(node)) {\n break;\n }\n if (assumeOneCharStrings && node.content.length !== 1) {\n break;\n }\n if (matchSubstrings) {\n let fullMatch = true;\n history.partialMatch = \"\";\n for (let j = 0; j < node.content.length; j++) {\n const char = node.content[j];\n if (tryToMatchNextChar(char, startIndex + i)) {\n history.partialMatch += char;\n } else {\n fullMatch = false;\n break;\n }\n }\n if (fullMatch) {\n history.partialMatch = \"\";\n } else {\n break;\n }\n } else {\n if (!tryToMatchNextChar(node.content, startIndex + i)) {\n break;\n }\n }\n }\n return history.lastWord ? {\n match: history.lastWord,\n endNodeIndex: history.index,\n endNodePartialMatch: history.partialMatch ? history.partialMatch : null\n } : null;\n}\nexport {\n Trie,\n prefixMatch,\n scan\n};\n//# sourceMappingURL=index.js.map\n","// index.ts\nimport { visit } from \"@unified-latex/unified-latex-util-visit\";\nfunction updateRenderInfo(node, renderInfo) {\n if (renderInfo != null) {\n node._renderInfo = { ...node._renderInfo || {}, ...renderInfo };\n }\n return node;\n}\nfunction trimRenderInfo(ast) {\n visit(ast, (node) => {\n delete node._renderInfo;\n delete node.position;\n });\n return ast;\n}\nexport {\n trimRenderInfo,\n updateRenderInfo\n};\n//# sourceMappingURL=index.js.map\n","// libs/gobble-arguments.ts\nimport {\n parse as parseArgspec\n} from \"@unified-latex/unified-latex-util-argspec\";\nimport { arg as arg2 } from \"@unified-latex/unified-latex-builder\";\n\n// libs/gobble-single-argument.ts\nimport { match } from \"@unified-latex/unified-latex-util-match\";\nimport { scan } from \"@unified-latex/unified-latex-util-scan\";\nimport { arg } from \"@unified-latex/unified-latex-builder\";\nfunction gobbleSingleArgument(nodes, argSpec, startPos = 0) {\n if (typeof argSpec === \"string\" || !argSpec.type) {\n throw new Error(\n `argSpec must be an already-parsed argument specification, not \"${JSON.stringify(\n argSpec\n )}\"`\n );\n }\n let argument = null;\n let currPos = startPos;\n const gobbleWhitespace = argSpec.noLeadingWhitespace ? () => {\n } : () => {\n while (currPos < nodes.length) {\n if (!match.whitespace(nodes[currPos])) {\n break;\n }\n currPos++;\n }\n };\n const openMark = argSpec.openBrace || \"\";\n const closeMark = argSpec.closeBrace || \"\";\n const acceptGroup = (argSpec.type === \"mandatory\" || argSpec.type === \"optional\") && openMark === \"{\" && closeMark === \"}\";\n function findBracePositions() {\n let openMarkPos = null;\n if (openMark) {\n openMarkPos = nodes.findIndex(\n (node, i) => i >= currPos && match.string(node, openMark)\n );\n if (openMarkPos < currPos) {\n openMarkPos = null;\n }\n }\n let closeMarkPos = null;\n if (openMarkPos != null) {\n closeMarkPos = nodes.findIndex(\n (node, i) => i >= openMarkPos + 1 && match.string(node, closeMark)\n );\n if (closeMarkPos < openMarkPos + 1) {\n closeMarkPos = null;\n }\n }\n return [openMarkPos, closeMarkPos];\n }\n gobbleWhitespace();\n const currNode = nodes[currPos];\n if (currNode == null || match.comment(currNode) || match.parbreak(currNode)) {\n return { argument, nodesRemoved: 0 };\n }\n switch (argSpec.type) {\n case \"mandatory\":\n if (acceptGroup) {\n let content = [currNode];\n if (match.group(currNode)) {\n content = currNode.content;\n }\n argument = arg(content, {\n openMark,\n closeMark\n });\n currPos++;\n break;\n }\n case \"optional\":\n if (acceptGroup && match.group(currNode)) {\n argument = arg(currNode.content, {\n openMark,\n closeMark\n });\n currPos++;\n break;\n }\n if (match.string(currNode, openMark)) {\n const [openMarkPos, closeMarkPos] = findBracePositions();\n if (openMarkPos != null && closeMarkPos != null) {\n argument = arg(nodes.slice(openMarkPos + 1, closeMarkPos), {\n openMark,\n closeMark\n });\n currPos = closeMarkPos + 1;\n break;\n }\n }\n break;\n case \"optionalStar\":\n case \"optionalToken\":\n if (match.string(\n currNode,\n argSpec.type === \"optionalStar\" ? \"*\" : argSpec.token\n )) {\n argument = arg([currNode], { openMark: \"\", closeMark: \"\" });\n currPos++;\n break;\n }\n break;\n case \"until\": {\n if (argSpec.stopTokens.length > 1) {\n console.warn(\n `\"until\" matches with multi-token stop conditions are not yet implemented`\n );\n break;\n }\n const rawToken = argSpec.stopTokens[0];\n const stopToken = rawToken === \" \" ? { type: \"whitespace\" } : { type: \"string\", content: argSpec.stopTokens[0] };\n let matchPos = scan(nodes, stopToken, {\n startIndex: startPos,\n allowSubstringMatches: true\n });\n if (matchPos != null && partialStringMatch(nodes[matchPos], stopToken)) {\n console.warn(\n `\"until\" arguments that stop at non-punctuation symbols is not yet implemented`\n );\n break;\n }\n if (matchPos == null) {\n break;\n }\n argument = arg(nodes.slice(startPos, matchPos), {\n openMark: \"\",\n closeMark: rawToken\n });\n currPos = matchPos;\n if (currPos < nodes.length) {\n currPos++;\n }\n break;\n }\n default:\n console.warn(\n `Don't know how to find an argument of argspec type \"${argSpec.type}\"`\n );\n }\n const nodesRemoved = argument ? currPos - startPos : 0;\n nodes.splice(startPos, nodesRemoved);\n return { argument, nodesRemoved };\n}\nfunction partialStringMatch(node, token) {\n return match.anyString(node) && match.anyString(token) && node.content.length > token.content.length;\n}\n\n// libs/gobble-arguments.ts\nfunction gobbleArguments(nodes, argSpec, startPos = 0) {\n if (typeof argSpec === \"function\") {\n return argSpec(nodes, startPos);\n }\n if (typeof argSpec === \"string\") {\n argSpec = parseArgspec(argSpec);\n }\n const args = [];\n let nodesRemoved = 0;\n for (const spec of argSpec) {\n const { argument, nodesRemoved: removed } = gobbleSingleArgument(\n nodes,\n spec,\n startPos\n );\n if (argument) {\n args.push(argument);\n nodesRemoved += removed;\n } else {\n args.push(arg2([], { openMark: \"\", closeMark: \"\" }));\n }\n }\n return { args, nodesRemoved };\n}\n\n// libs/attach-arguments.ts\nimport { match as match2 } from \"@unified-latex/unified-latex-util-match\";\nimport { updateRenderInfo } from \"@unified-latex/unified-latex-util-render-info\";\nimport { visit } from \"@unified-latex/unified-latex-util-visit\";\nfunction attachMacroArgsInArray(nodes, macros) {\n let currIndex;\n const isRelevantMacro = match2.createMacroMatcher(macros);\n function gobbleUntilMacro() {\n while (currIndex >= 0 && !isRelevantMacro(nodes[currIndex])) {\n currIndex--;\n }\n }\n currIndex = nodes.length - 1;\n while (currIndex >= 0) {\n gobbleUntilMacro();\n if (currIndex < 0) {\n return;\n }\n const macroIndex = currIndex;\n const macro = nodes[macroIndex];\n const macroName = macro.content;\n const macroInfo = macros[macroName];\n updateRenderInfo(macro, macroInfo.renderInfo);\n const signatureOrParser = macroInfo.argumentParser || macroInfo.signature;\n if (signatureOrParser == null) {\n currIndex--;\n continue;\n }\n if (macro.args != null) {\n currIndex = macroIndex - 1;\n continue;\n }\n currIndex++;\n const { args } = gobbleArguments(nodes, signatureOrParser, currIndex);\n macro.args = args;\n currIndex = macroIndex - 1;\n }\n}\nfunction attachMacroArgs(tree, macros) {\n visit(\n tree,\n (nodes) => {\n attachMacroArgsInArray(nodes, macros);\n },\n { includeArrays: true, test: Array.isArray }\n );\n}\n\n// libs/unified-latex-attach-macro-arguments.ts\nimport { visit as visit2 } from \"@unified-latex/unified-latex-util-visit\";\nvar unifiedLatexAttachMacroArguments = function unifiedLatexAttachMacroArguments2(options) {\n return (tree) => {\n const { macros = {} } = options || {};\n if (Object.keys(macros).length === 0) {\n console.warn(\n \"Attempting to attach macro arguments but no macros are specified.\"\n );\n }\n visit2(\n tree,\n (nodes) => {\n attachMacroArgsInArray(nodes, macros);\n },\n { includeArrays: true, test: Array.isArray }\n );\n };\n};\n\n// libs/get-args-content.ts\nfunction getArgsContent(node) {\n if (!Array.isArray(node.args)) {\n return [];\n }\n return node.args.map((arg3) => {\n if (arg3.openMark === \"\" && arg3.content.length === 0) {\n return null;\n }\n return arg3.content;\n });\n}\nfunction getNamedArgsContent(node, namedArgumentsFallback = []) {\n var _a;\n const names = ((_a = node._renderInfo) == null ? void 0 : _a.namedArguments) || namedArgumentsFallback;\n if (!Array.isArray(node.args) || !Array.isArray(names) || names.length === 0) {\n return {};\n }\n const ret = {};\n node.args.forEach((arg3, i) => {\n const name = names[i];\n if (name == null) {\n return;\n }\n let val = arg3.content;\n if (arg3.openMark === \"\" && arg3.content.length === 0) {\n val = null;\n }\n ret[name] = val;\n });\n return ret;\n}\nexport {\n attachMacroArgs,\n attachMacroArgsInArray,\n getArgsContent,\n getNamedArgsContent,\n gobbleArguments,\n gobbleSingleArgument,\n unifiedLatexAttachMacroArguments\n};\n//# sourceMappingURL=index.js.map\n","// package/tikz/provides.ts\nimport { attachMacroArgsInArray } from \"@unified-latex/unified-latex-util-arguments\";\n\n// package/tikz/libs/tikz-command-argument-parser.ts\nimport { arg } from \"@unified-latex/unified-latex-builder\";\nimport {\n parse as parseArgspec\n} from \"@unified-latex/unified-latex-util-argspec\";\nimport { gobbleSingleArgument } from \"@unified-latex/unified-latex-util-arguments\";\nimport { match } from \"@unified-latex/unified-latex-util-match\";\nimport { scan } from \"@unified-latex/unified-latex-util-scan\";\nimport { trim } from \"@unified-latex/unified-latex-util-trim\";\nvar OPTIONAL_ARGUMENT_ARG_SPEC = parseArgspec(\"o\")[0];\nfunction blankArg() {\n return arg([], { openMark: \"\", closeMark: \"\" });\n}\nvar tikzCommandArgumentParser = (nodes, startPos) => {\n const origStartPos = startPos;\n let pos = startPos;\n let nodesRemoved = 0;\n const cursorPosAfterAnimations = eatAllAnimationSpecs(nodes, pos);\n let animationArg = blankArg();\n if (cursorPosAfterAnimations !== pos) {\n const argContent = nodes.splice(pos, cursorPosAfterAnimations - pos);\n trim(argContent);\n animationArg = arg(argContent, {\n openMark: \" \",\n closeMark: \" \"\n });\n }\n nodesRemoved += cursorPosAfterAnimations - pos;\n const {\n argument: _optionalArgument,\n nodesRemoved: optionalArgumentNodesRemoved\n } = gobbleSingleArgument(nodes, OPTIONAL_ARGUMENT_ARG_SPEC, pos);\n nodesRemoved += optionalArgumentNodesRemoved;\n const optionalArg = _optionalArgument || blankArg();\n while (match.whitespace(nodes[pos])) {\n pos++;\n }\n const firstNode = nodes[pos];\n if (!firstNode) {\n return {\n args: [animationArg, optionalArg, blankArg()],\n nodesRemoved: 0\n };\n }\n if (match.group(firstNode)) {\n const args = [animationArg, optionalArg, arg(firstNode.content)];\n nodes.splice(origStartPos, pos - origStartPos + 1);\n return { args, nodesRemoved: pos - origStartPos + 1 + nodesRemoved };\n }\n const semicolonPosition = scan(nodes, \";\", { startIndex: pos });\n if (semicolonPosition != null) {\n const argNodes = nodes.splice(\n origStartPos,\n semicolonPosition - origStartPos + 1\n );\n trim(argNodes);\n const args = [animationArg, optionalArg, arg(argNodes)];\n return {\n args,\n nodesRemoved: origStartPos - semicolonPosition + 1 + nodesRemoved\n };\n }\n return {\n args: [animationArg, optionalArg, blankArg()],\n nodesRemoved: 0\n };\n};\nfunction eatAllAnimationSpecs(nodes, startPos) {\n const colonPos = scan(nodes, \":\", {\n startIndex: startPos,\n allowSubstringMatches: true,\n onlySkipWhitespaceAndComments: true\n });\n if (!colonPos) {\n return startPos;\n }\n let lastMatchPos = startPos;\n let i = colonPos + 1;\n for (; i < nodes.length; i++) {\n const node = nodes[i];\n if (match.string(node, \"[\")) {\n break;\n }\n if (match.string(node, \"=\")) {\n i++;\n while (match.whitespace(nodes[i]) || match.comment(nodes[i])) {\n i++;\n }\n if (!match.group(nodes[i])) {\n break;\n }\n lastMatchPos = i + 1;\n const colonPos2 = scan(nodes, \":\", {\n startIndex: lastMatchPos,\n allowSubstringMatches: true,\n onlySkipWhitespaceAndComments: true\n });\n if (colonPos2 == null) {\n break;\n }\n i = colonPos2 + 1;\n }\n }\n return lastMatchPos;\n}\n\n// package/tikz/provides.ts\nvar macros = {\n pgfkeys: {\n signature: \"m\",\n renderInfo: { breakAround: true, pgfkeysArgs: true }\n },\n tikzoption: {\n signature: \"m\",\n renderInfo: { breakAround: true, pgfkeysArgs: true }\n },\n tikzstyle: {\n signature: \"m\",\n renderInfo: { breakAround: true, pgfkeysArgs: true }\n },\n usetikzlibrary: {\n signature: \"m\",\n renderInfo: { breakAround: true, pgfkeysArgs: true }\n },\n usepgfmodule: { signature: \"m\", renderInfo: { pgfkeysArgs: true } },\n usepgflibrary: { signature: \"m\", renderInfo: { pgfkeysArgs: true } },\n pgfplotsset: {\n signature: \"m\",\n renderInfo: { breakAround: true, pgfkeysArgs: true }\n },\n pgfplotstabletypeset: {\n signature: \"o m\",\n renderInfo: { breakAround: true, pgfkeysArgs: true }\n },\n tikz: {\n signature: \"o o m\",\n argumentParser: tikzCommandArgumentParser,\n renderInfo: { namedArguments: [\"animation\", \"options\", \"command\"] }\n }\n};\nvar environments = {\n tikzpicture: {\n signature: \"o\",\n renderInfo: { pgfkeysArgs: true, tikzEnvironment: true },\n processContent: processTikzEnvironmentContent\n },\n axis: {\n signature: \"o\",\n renderInfo: { pgfkeysArgs: true, tikzEnvironment: true },\n processContent: processTikzEnvironmentContent\n },\n scope: {\n signature: \"o\",\n renderInfo: { pgfkeysArgs: true, tikzEnvironment: true },\n processContent: processTikzEnvironmentContent\n },\n pgfonlayer: {\n signature: \"m\",\n renderInfo: { tikzEnvironment: true },\n processContent: processTikzEnvironmentContent\n },\n pgflowlevelscope: {\n signature: \"m\",\n renderInfo: { tikzEnvironment: true },\n processContent: processTikzEnvironmentContent\n },\n pgfviewboxscope: {\n signature: \"m m m m m\",\n renderInfo: { tikzEnvironment: true },\n processContent: processTikzEnvironmentContent\n },\n pgftransparencygroup: {\n signature: \"o\",\n renderInfo: { pgfkeysArgs: true, tikzEnvironment: true },\n processContent: processTikzEnvironmentContent\n },\n behindforegroundpath: {\n signature: \"m\",\n processContent: processTikzEnvironmentContent\n },\n pgfmetadecoration: {\n signature: \"m\",\n processContent: processTikzEnvironmentContent\n },\n colormixin: { signature: \"m\", renderInfo: { pgfkeysArgs: true } }\n};\nfunction processTikzEnvironmentContent(nodes) {\n attachMacroArgsInArray(nodes, conditionalMacros);\n return nodes;\n}\nvar conditionalMacros = {\n pgfextra: { signature: \"m\" },\n beginpgfgraphicnamed: { signature: \"m\" },\n pgfrealjobname: { signature: \"m\" },\n pgfplotstreampoint: { signature: \"m\" },\n pgfplotstreampointoutlier: { signature: \"m\" },\n pgfplotstreamspecial: { signature: \"m\" },\n pgfplotxyfile: { signature: \"m\" },\n pgfplotxyzfile: { signature: \"m\" },\n pgfplotfunction: { signature: \"mmm\" },\n pgfplotgnuplot: { signature: \"o m\" },\n pgfplothandlerrecord: { signature: \"m\" },\n pgfdeclareplothandler: { signature: \"m m m\" },\n pgfdeclarelayer: { signature: \"m\" },\n pgfsetlayers: { signature: \"m\", renderInfo: { pgfkeysArgs: true } },\n pgfonlayer: { signature: \"m\" },\n startpgfonlayer: { signature: \"m\" },\n pgfdeclarehorizontalshading: { signature: \"o m m m \" },\n pgfdeclareradialshading: { signature: \"o m m m\" },\n pgfdeclarefunctionalshading: { signature: \"o m m m m m\" },\n pgfshadecolortorgb: { signature: \"m m\" },\n pgfshadecolortocmyk: { signature: \"m m\" },\n pgfshadecolortogray: { signature: \"m m\" },\n pgfuseshading: { signature: \"m\" },\n pgfshadepath: { signature: \"m m\" },\n pgfsetadditionalshadetransform: { signature: \"m\" },\n pgfsetstrokeopacity: { signature: \"m\" },\n pgfsetfillopacity: { signature: \"m\" },\n pgfsetblendmode: { signature: \"m\" },\n pgfdeclarefading: { signature: \"m m\" },\n pgfsetfading: { signature: \"m m\" },\n pgfsetfadingforcurrentpath: { signature: \"m m\" },\n pgfsetfadingforcurrentpathstroked: { signature: \"m m\" },\n pgfanimateattribute: { signature: \"m m\" },\n pgfsnapshot: { signature: \"m\" },\n pgfqpoint: { signature: \"m m\" },\n pgfqpointxy: { signature: \"m m\" },\n pgfqpointxyz: { signature: \"m m m\" },\n pgfqpointscale: { signature: \"m m\" },\n pgfpathqmoveto: { signature: \"m m\" },\n pgfpathqlineto: { signature: \"m m\" },\n pgfpathqcurveto: { signature: \"m m m m m m\" },\n pgfpathqcircle: { signature: \"m\" },\n pgfqbox: { signature: \"m\" },\n pgfqboxsynced: { signature: \"m\" },\n pgfaliasimage: { signature: \"m m\" },\n pgfuseimage: { signature: \"m\" },\n pgfimage: { signature: \"o m\", renderInfo: { pgfkeysArgs: true } },\n pgfdeclaremask: { signature: \"o m m\", renderInfo: { pgfkeysArgs: true } },\n pgfdeclarepatternformonly: { signature: \"o m m m m m\" },\n pgfdeclarepatterninherentlycolored: { signature: \"o m m m m m\" },\n pgfsetfillpattern: { signature: \"m m\" },\n // Coordinate canvas and nonlinear transformations\n pgftransformshift: { signature: \"m\" },\n pgftransformxshift: { signature: \"m\" },\n pgftransformyshift: { signature: \"m\" },\n pgftransformscale: { signature: \"m\" },\n pgftransformxscale: { signature: \"m\" },\n pgftransformyscale: { signature: \"m\" },\n pgftransformxslant: { signature: \"m\" },\n pgftransformyslant: { signature: \"m\" },\n pgftransformrotate: { signature: \"m\" },\n pgftransformtriangle: { signature: \"m m m\" },\n pgftransformcm: { signature: \"m m m m m\" },\n pgftransformarrow: { signature: \"m m\" },\n pgftransformlineattime: { signature: \"m m m\" },\n pgftransformcurveattime: { signature: \"m m m m m\" },\n pgftransformarcaxesattime: { signature: \"m m m m m m\" },\n pgfgettransform: { signature: \"m\" },\n pgfsettransform: { signature: \"m\" },\n pgfgettransformentries: { signature: \"m m m m m m\" },\n pgfsettransformentries: { signature: \"m m m m m m\" },\n pgfpointtransformed: { signature: \"m\" },\n pgflowlevel: { signature: \"m\" },\n pgflowlevelobj: { signature: \"m m\" },\n pgflowlevelscope: { signature: \"m\" },\n startpgflowlevelscope: { signature: \"m\" },\n pgfviewboxscope: { signature: \"m m m m m\" },\n startpgfviewboxscope: { signature: \"m m m m m\" },\n pgftransformnonlinear: { signature: \"m\" },\n pgfpointtransformednonlinear: { signature: \"m\" },\n pgfsetcurvilinearbeziercurve: { signature: \"m m m m\" },\n pgfcurvilineardistancetotime: { signature: \"m\" },\n pgfpointcurvilinearbezierorthogonal: { signature: \"m m\" },\n pgfpointcurvilinearbezierpolar: { signature: \"m m\" },\n // Matrices\n pgfmatrix: { signature: \"m m m m m m m\" },\n pgfsetmatrixcolumnsep: { signature: \"m\" },\n pgfmatrixnextcell: { signature: \"o\" },\n pgfsetmatrixrowsep: { signature: \"m\" },\n pgfmatrixendrow: { signature: \"o\" },\n // Nodes and shapes\n pgfnode: { signature: \"m m m m m\" },\n pgfmultipartnode: { signature: \"m m m m\" },\n pgfcoordinate: { signature: \"m m\" },\n pgfnodealias: { signature: \"m m\" },\n pgfnoderename: { signature: \"m m\" },\n pgfpositionnodelater: { signature: \"m\" },\n pgfpositionnodenow: { signature: \"m\" },\n pgfnodepostsetupcode: { signature: \"m m\" },\n pgfpointanchor: { signature: \"m m\" },\n pgfpointshapeborder: { signature: \"m m\" },\n pgfdeclareshape: { signature: \"m m\" },\n saveddimen: { signature: \"m m\" },\n savedmacro: { signature: \" m\" },\n anchor: { signature: \"m m\" },\n deferredanchor: { signature: \"m m\" },\n anchorborder: { signature: \"m\" },\n backgroundpath: { signature: \"m\" },\n foregroundpath: { signature: \"m\" },\n behindbackgroundpath: { signature: \"m\" },\n beforebackgroundpath: { signature: \"m\" },\n beforeforegroundpath: { signature: \"m\" },\n behindforegroundpath: { signature: \"m\" },\n // Arrows\n pgfdeclarearrow: { signature: \"m\" },\n pgfarrowssettipend: { signature: \"m\" },\n pgfarrowssetbackend: { signature: \"m\" },\n pgfarrowssetlineend: { signature: \"m\" },\n pgfarrowssetvisualbackend: { signature: \"m\" },\n pgfarrowssetvisualtipend: { signature: \"m\" },\n pgfarrowshullpoint: { signature: \"m m\" },\n pgfarrowsupperhullpoint: { signature: \"m m\" },\n pgfarrowssave: { signature: \"m\" },\n pgfarrowssavethe: { signature: \"m\" },\n pgfarrowsaddtooptions: { signature: \"m\" },\n pgfarrowsaddtolateoptions: { signature: \"m\" },\n pgfarrowsaddtolengthscalelist: { signature: \"m\" },\n pgfarrowsaddtowidthscalelist: { signature: \"m\" },\n pgfarrowsthreeparameters: { signature: \"m\" },\n pgfarrowslinewidthdependent: { signature: \"m m m\" },\n pgfarrowslengthdependent: { signature: \"m\" },\n // Path\n pgfusepath: { signature: \"m\" },\n pgfsetlinewidth: { signature: \"m\" },\n pgfsetmiterlimit: { signature: \"m\" },\n pgfsetdash: { signature: \"m m\" },\n pgfsetstrokecolor: { signature: \"m\" },\n pgfsetcolor: { signature: \"m\" },\n pgfsetinnerlinewidth: { signature: \"m\" },\n pgfsetinnerstrokecolor: { signature: \"m\" },\n pgfsetarrowsstart: { signature: \"m\" },\n pgfsetarrowsend: { signature: \"m\" },\n pgfsetarrows: { signature: \"m\" },\n pgfsetshortenstart: { signature: \"m\" },\n pgfsetshortenend: { signature: \"m\" },\n pgfsetfillcolor: { signature: \"m\" },\n // Decorations\n pgfdeclaredecoration: { signature: \"m m m\" },\n state: { signature: \"m o m\" },\n pgfdecoratepath: { signature: \"m m\" },\n startpgfdecoration: { signature: \"m\" },\n pgfdecoration: { signature: \"m\" },\n pgfdecoratecurrentpath: { signature: \"m\" },\n pgfsetdecorationsegmenttransformation: { signature: \"m\" },\n pgfdeclaremetadecorate: { signature: \"m m m\" },\n pgfmetadecoration: { signature: \"m\" },\n startpgfmetadecoration: { signature: \"m\" },\n // Constructing paths\n pgfpathmoveto: { signature: \"m\" },\n pgfpathlineto: { signature: \"m\" },\n pgfpathcurveto: { signature: \"m m m\" },\n pgfpathquadraticcurveto: { signature: \"m m\" },\n pgfpathcurvebetweentime: { signature: \"m m m m m m\" },\n pgfpathcurvebetweentimecontinue: { signature: \"m m m m m m\" },\n pgfpatharc: { signature: \"m m m\" },\n pgfpatharcaxes: { signature: \"m m m m\" },\n pgfpatharcto: { signature: \"m m m m m m\" },\n pgfpatharctoprecomputed: { signature: \"m m m m m m m m\" },\n pgfpathellipse: { signature: \"m m m\" },\n pgfpathcircle: { signature: \"m m\" },\n pgfpathrectangle: { signature: \"m m\" },\n pgfpathrectanglecorners: { signature: \"m m\" },\n pgfpathgrid: { signature: \" o m m\" },\n pgfpathparabola: { signature: \"m m\" },\n pgfpathsine: { signature: \"m\" },\n pgfpathcosine: { signature: \"m\" },\n pgfsetcornersarced: { signature: \"m\" },\n \"pgf@protocolsizes\": { signature: \"m m\" },\n // Specifying coordinates\n pgfpoint: { signature: \"m m\" },\n pgfpointpolar: { signature: \"m m m\" },\n pgfpointxy: { signature: \"m m\" },\n pgfsetxvec: { signature: \"m\" },\n pgfsetyvec: { signature: \"m\" },\n pgfpointpolarxy: { signature: \"m m\" },\n pgfpointxyz: { signature: \"m m m\" },\n pgfsetzvec: { signature: \"m\" },\n pgfpointcylindrical: { signature: \"m m m\" },\n pgfpointspherical: { signature: \"m m m\" },\n pgfpointadd: { signature: \"m m\" },\n pgfpointscale: { signature: \"m m\" },\n pgfpointdiff: { signature: \"m m\" },\n pgfpointnormalised: { signature: \"m\" },\n pgfpointlineattime: { signature: \"m m m\" },\n pgfpointlineatdistance: { signature: \"m m m\" },\n pgfpointarcaxesattime: { signature: \"m m m m m m\" },\n pgfpointcurveattime: { signature: \"m m m m m\" },\n pgfpointborderrectangle: { signature: \"m m\" },\n pgfpointborderellipse: { signature: \"m m\" },\n pgfpointintersectionoflines: { signature: \"m m m m\" },\n pgfpointintersectionofcircles: { signature: \"m m m m m\" },\n pgfintersectionofpaths: { signature: \"m m\" },\n pgfpointintersectionsolution: { signature: \"m\" },\n pgfextractx: { signature: \"m m\" },\n pgfextracty: { signature: \"m m\" },\n pgfgetlastxy: { signature: \"m m\" },\n \"pgf@process\": { signature: \"m\" },\n // Heirarchical structres ...\n pgfsetbaseline: { signature: \"m\" },\n pgfsetbaselinepointnow: { signature: \"m\" },\n pgfsetbaselinepointlater: { signature: \"m\" },\n pgftext: { signature: \"o m\", renderInfo: { pgfkeysArgs: true } },\n pgfuseid: { signature: \"m\" },\n pgfusetype: { signature: \"m\" },\n pgfidrefnextuse: { signature: \"m m\" },\n pgfidrefprevuse: { signature: \"m m\" },\n pgfaliasid: { signature: \"m m\" },\n pgfgaliasid: { signature: \"m m\" },\n pgfifidreferenced: { signature: \"m m m\" },\n pgfrdfabout: { signature: \"m\" },\n pgfrdfcontent: { signature: \"m\" },\n pgfrdfdatatype: { signature: \"m\" },\n pgfrdfhref: { signature: \"m\" },\n pgfrdfprefix: { signature: \"m\" },\n pgfrdfproperty: { signature: \"m\" },\n pgfrdfrel: { signature: \"m\" },\n pgfrdfresource: { signature: \"m\" },\n pgfrdfrev: { signature: \"m\" },\n pgfrdfsrc: { signature: \"m\" },\n pgfrdftypeof: { signature: \"m\" },\n pgfrdfvocab: { signature: \"m\" },\n pgferror: { signature: \"m\" },\n pgfwarning: { signature: \"m\" },\n path: {\n signature: \"u;\",\n renderInfo: { breakAround: true, tikzPathCommand: true }\n },\n draw: {\n signature: \"u;\",\n renderInfo: { breakAround: true, tikzPathCommand: true }\n },\n fill: {\n signature: \"u;\",\n renderInfo: { breakAround: true, tikzPathCommand: true }\n },\n filldraw: {\n signature: \"u;\",\n renderInfo: { breakAround: true, tikzPathCommand: true }\n },\n pattern: {\n signature: \"u;\",\n renderInfo: { breakAround: true, tikzPathCommand: true }\n },\n shade: {\n signature: \"u;\",\n renderInfo: { breakAround: true, tikzPathCommand: true }\n },\n clip: {\n signature: \"u;\",\n renderInfo: { breakAround: true, tikzPathCommand: true }\n },\n useasboundingbox: {\n signature: \"u;\",\n renderInfo: { breakAround: true, tikzPathCommand: true }\n },\n node: {\n signature: \"u;\",\n renderInfo: { breakAround: true, tikzPathCommand: true }\n },\n coordinate: {\n signature: \"u;\",\n renderInfo: { breakAround: true, tikzPathCommand: true }\n },\n graph: {\n signature: \"u;\",\n renderInfo: { breakAround: true, tikzPathCommand: true }\n },\n scoped: {\n signature: \"o o m\",\n argumentParser: tikzCommandArgumentParser,\n renderInfo: {\n namedArguments: [\"animation\", \"options\", \"command\"],\n breakAround: true\n }\n }\n};\n\n// package/tikz/libs/print-raw.ts\nimport { printRaw as latexPrintRaw } from \"@unified-latex/unified-latex-util-print-raw\";\nimport { trim as trim2 } from \"@unified-latex/unified-latex-util-trim\";\nfunction printRaw(node, root = false) {\n if (typeof node === \"string\") {\n return node;\n }\n if (Array.isArray(node)) {\n const sepToken = root ? \" \" : \"\";\n const printed = [];\n for (let i = 0; i < node.length; i++) {\n const tok = node[i];\n const prevTok = node[i - 1];\n if (!prevTok) {\n printed.push(printRaw(tok));\n continue;\n }\n if (prevTok.type === \"comment\") {\n printed.push(printRaw(tok));\n continue;\n }\n if (tok.type !== \"comment\") {\n printed.push(sepToken);\n }\n printed.push(printRaw(tok));\n }\n return printed.join(\"\");\n }\n const type = node.type;\n switch (type) {\n case \"path_spec\":\n return printRaw(node.content, root = true);\n case \"coordinate\":\n return `${latexPrintRaw(node.prefix)}(${latexPrintRaw(\n node.content\n )})`;\n case \"operation\":\n return latexPrintRaw(node.content);\n case \"comment\":\n return latexPrintRaw(node);\n case \"line_to\":\n return node.command;\n case \"curve_to\": {\n const comments = node.comments.map((c) => latexPrintRaw({ ...c, leadingWhitespace: false })).join(\"\");\n if (node.controls.length === 1) {\n return `${comments}.. controls ${printRaw(\n node.controls[0]\n )} ..`;\n } else {\n return `${comments}.. controls ${printRaw(\n node.controls[0]\n )} and ${printRaw(node.controls[1])} ..`;\n }\n }\n case \"unknown\":\n return latexPrintRaw(node.content);\n case \"square_brace_group\":\n return `[${latexPrintRaw(node.content)}]`;\n case \"foreach\": {\n const comments = node.comments.map((c) => latexPrintRaw({ ...c, leadingWhitespace: false })).join(\"\");\n let options = \"\";\n if (node.options) {\n options = ` [${latexPrintRaw(node.options)}]`;\n }\n const start = latexPrintRaw(node.start);\n const variables = [...node.variables];\n trim2(variables);\n let printedVariables = latexPrintRaw(variables);\n if (printedVariables.length > 0) {\n printedVariables = \" \" + printedVariables;\n }\n const command = node.command.type === \"foreach\" ? printRaw(node.command) : latexPrintRaw(node.command);\n return `${comments}${start}${printedVariables}${options} in ${latexPrintRaw(\n node.list\n )} ${command}`;\n }\n case \"svg_operation\": {\n const comments = node.comments.map((c) => latexPrintRaw({ ...c, leadingWhitespace: false })).join(\"\");\n let options = \"\";\n if (node.options) {\n options = `[${latexPrintRaw(node.options)}]`;\n }\n return `${comments}svg${options} ${latexPrintRaw(node.content)}`;\n }\n case \"animation\": {\n const comments = node.comments.map((c) => latexPrintRaw({ ...c, leadingWhitespace: false })).join(\"\");\n return `${comments}:${node.attribute} = {${latexPrintRaw(\n node.content\n )}}`;\n }\n default:\n const unprintedType = type;\n console.warn(`Unknown node type \"${unprintedType}\" for node`, node);\n return \"\";\n }\n}\n\n// package/tikz/libs/parser.ts\nimport { match as match2 } from \"@unified-latex/unified-latex-util-match\";\nimport { decorateArrayForPegjs } from \"@unified-latex/unified-latex-util-pegjs\";\nimport { TikzPegParser } from \"@unified-latex/unified-latex-util-pegjs\";\nfunction createMatchers() {\n return {\n isChar: match2.string,\n isTerminal: (node) => match2.string(node, \";\"),\n isOperation: (node) => match2.anyString(node) && node.content.match(/[a-zA-Z]/),\n isWhitespace: (node) => match2.whitespace(node) || match2.parbreak(node),\n isComment: match2.comment,\n isGroup: match2.group,\n isMacro: match2.macro,\n isAnyMacro: match2.anyMacro\n };\n}\nvar matchers = createMatchers();\nfunction parse(ast, options) {\n const { startRule = \"path_spec\" } = options || {};\n if (!Array.isArray(ast)) {\n throw new Error(\"You must pass an array of nodes\");\n }\n ast = decorateArrayForPegjs([...ast]);\n return TikzPegParser.parse(ast, {\n ...matchers,\n startRule\n });\n}\nexport {\n conditionalMacros,\n environments,\n macros,\n parse,\n printRaw\n};\n//# sourceMappingURL=index.js.map\n","// libs/pgfkeys-parser.ts\nimport { PgfkeysPegParser } from \"@unified-latex/unified-latex-util-pegjs\";\nimport { match } from \"@unified-latex/unified-latex-util-match\";\nimport { decorateArrayForPegjs } from \"@unified-latex/unified-latex-util-pegjs\";\nfunction createMatchers() {\n return {\n isChar: (node, char) => match.string(node, char),\n isComma: (node) => match.string(node, \",\"),\n isEquals: (node) => match.string(node, \"=\"),\n isWhitespace: (node) => match.whitespace(node),\n isParbreak: (node) => match.parbreak(node),\n isSameLineComment: (node) => match.comment(node) && node.sameline,\n isOwnLineComment: (node) => match.comment(node) && !node.sameline\n };\n}\nfunction parsePgfkeys(ast, options) {\n if (!Array.isArray(ast)) {\n throw new Error(\"You must pass an array of nodes\");\n }\n const { allowParenGroups = false } = options || {};\n ast = decorateArrayForPegjs([...ast]);\n return PgfkeysPegParser.parse(ast, {\n ...createMatchers(),\n allowParenGroups\n });\n}\n\n// libs/pgfkeys-to-object.ts\nimport { match as match2 } from \"@unified-latex/unified-latex-util-match\";\nimport { printRaw } from \"@unified-latex/unified-latex-util-print-raw\";\nfunction pgfkeysArgToObject(arg) {\n function parseFront(nodes) {\n return printRaw(nodes);\n }\n function parseBack(nodes) {\n if (!nodes) {\n return [];\n }\n if (nodes.length === 1 && match2.group(nodes[0])) {\n return nodes[0].content;\n }\n return nodes;\n }\n let nodeList;\n if (match2.argument(arg)) {\n nodeList = arg.content;\n } else {\n nodeList = arg;\n }\n const parsedArgs = parsePgfkeys(nodeList);\n return Object.fromEntries(\n parsedArgs.filter((part) => part.itemParts).map((part) => [\n parseFront(part.itemParts[0]),\n parseBack(part.itemParts[1])\n ])\n );\n}\nexport {\n createMatchers,\n parsePgfkeys,\n pgfkeysArgToObject\n};\n//# sourceMappingURL=index.js.map\n","// libs/parse-align-environment.ts\nimport { match } from \"@unified-latex/unified-latex-util-match\";\nimport {\n AlignEnvironmentPegParser,\n decorateArrayForPegjs\n} from \"@unified-latex/unified-latex-util-pegjs\";\nfunction createMatchers(rowSepMacros, colSep) {\n const isRowSep = match.createMacroMatcher(rowSepMacros);\n return {\n isRowSep,\n isColSep: (node) => colSep.some((sep) => match.string(node, sep)),\n isWhitespace: (node) => match.whitespace(node),\n isSameLineComment: (node) => match.comment(node) && node.sameline,\n isOwnLineComment: (node) => match.comment(node) && !node.sameline\n };\n}\nfunction parseAlignEnvironment(ast, colSep = [\"&\"], rowSepMacros = [\"\\\\\", \"hline\", \"cr\"]) {\n if (!Array.isArray(ast)) {\n throw new Error(\"You must pass an array of nodes\");\n }\n ast = decorateArrayForPegjs([...ast]);\n return AlignEnvironmentPegParser.parse(\n ast,\n createMatchers(rowSepMacros, colSep)\n );\n}\nexport {\n createMatchers,\n parseAlignEnvironment\n};\n//# sourceMappingURL=index.js.map\n","/**\n * Throw a given error.\n *\n * @param {Error|null|undefined} [error]\n * Maybe error.\n * @returns {asserts error is null|undefined}\n */\nexport function bail(error) {\n if (error) {\n throw error\n }\n}\n","/*!\n * Determine if an object is a Buffer\n *\n * @author Feross Aboukhadijeh \n * @license MIT\n */\n\nmodule.exports = function isBuffer (obj) {\n return obj != null && obj.constructor != null &&\n typeof obj.constructor.isBuffer === 'function' && obj.constructor.isBuffer(obj)\n}\n","'use strict';\n\nvar hasOwn = Object.prototype.hasOwnProperty;\nvar toStr = Object.prototype.toString;\nvar defineProperty = Object.defineProperty;\nvar gOPD = Object.getOwnPropertyDescriptor;\n\nvar isArray = function isArray(arr) {\n\tif (typeof Array.isArray === 'function') {\n\t\treturn Array.isArray(arr);\n\t}\n\n\treturn toStr.call(arr) === '[object Array]';\n};\n\nvar isPlainObject = function isPlainObject(obj) {\n\tif (!obj || toStr.call(obj) !== '[object Object]') {\n\t\treturn false;\n\t}\n\n\tvar hasOwnConstructor = hasOwn.call(obj, 'constructor');\n\tvar hasIsPrototypeOf = obj.constructor && obj.constructor.prototype && hasOwn.call(obj.constructor.prototype, 'isPrototypeOf');\n\t// Not own constructor property must be Object\n\tif (obj.constructor && !hasOwnConstructor && !hasIsPrototypeOf) {\n\t\treturn false;\n\t}\n\n\t// Own properties are enumerated firstly, so to speed up,\n\t// if last one is own, then all properties are own.\n\tvar key;\n\tfor (key in obj) { /**/ }\n\n\treturn typeof key === 'undefined' || hasOwn.call(obj, key);\n};\n\n// If name is '__proto__', and Object.defineProperty is available, define __proto__ as an own property on target\nvar setProperty = function setProperty(target, options) {\n\tif (defineProperty && options.name === '__proto__') {\n\t\tdefineProperty(target, options.name, {\n\t\t\tenumerable: true,\n\t\t\tconfigurable: true,\n\t\t\tvalue: options.newValue,\n\t\t\twritable: true\n\t\t});\n\t} else {\n\t\ttarget[options.name] = options.newValue;\n\t}\n};\n\n// Return undefined instead of __proto__ if '__proto__' is not an own property\nvar getProperty = function getProperty(obj, name) {\n\tif (name === '__proto__') {\n\t\tif (!hasOwn.call(obj, name)) {\n\t\t\treturn void 0;\n\t\t} else if (gOPD) {\n\t\t\t// In early versions of node, obj['__proto__'] is buggy when obj has\n\t\t\t// __proto__ as an own property. Object.getOwnPropertyDescriptor() works.\n\t\t\treturn gOPD(obj, name).value;\n\t\t}\n\t}\n\n\treturn obj[name];\n};\n\nmodule.exports = function extend() {\n\tvar options, name, src, copy, copyIsArray, clone;\n\tvar target = arguments[0];\n\tvar i = 1;\n\tvar length = arguments.length;\n\tvar deep = false;\n\n\t// Handle a deep copy situation\n\tif (typeof target === 'boolean') {\n\t\tdeep = target;\n\t\ttarget = arguments[1] || {};\n\t\t// skip the boolean and the target\n\t\ti = 2;\n\t}\n\tif (target == null || (typeof target !== 'object' && typeof target !== 'function')) {\n\t\ttarget = {};\n\t}\n\n\tfor (; i < length; ++i) {\n\t\toptions = arguments[i];\n\t\t// Only deal with non-null/undefined values\n\t\tif (options != null) {\n\t\t\t// Extend the base object\n\t\t\tfor (name in options) {\n\t\t\t\tsrc = getProperty(target, name);\n\t\t\t\tcopy = getProperty(options, name);\n\n\t\t\t\t// Prevent never-ending loop\n\t\t\t\tif (target !== copy) {\n\t\t\t\t\t// Recurse if we're merging plain objects or arrays\n\t\t\t\t\tif (deep && copy && (isPlainObject(copy) || (copyIsArray = isArray(copy)))) {\n\t\t\t\t\t\tif (copyIsArray) {\n\t\t\t\t\t\t\tcopyIsArray = false;\n\t\t\t\t\t\t\tclone = src && isArray(src) ? src : [];\n\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\tclone = src && isPlainObject(src) ? src : {};\n\t\t\t\t\t\t}\n\n\t\t\t\t\t\t// Never move original objects, clone them\n\t\t\t\t\t\tsetProperty(target, { name: name, newValue: extend(deep, clone, copy) });\n\n\t\t\t\t\t// Don't bring in undefined values\n\t\t\t\t\t} else if (typeof copy !== 'undefined') {\n\t\t\t\t\t\tsetProperty(target, { name: name, newValue: copy });\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\t// Return the modified object\n\treturn target;\n};\n","export default function isPlainObject(value) {\n\tif (typeof value !== 'object' || value === null) {\n\t\treturn false;\n\t}\n\n\tconst prototype = Object.getPrototypeOf(value);\n\treturn (prototype === null || prototype === Object.prototype || Object.getPrototypeOf(prototype) === null) && !(Symbol.toStringTag in value) && !(Symbol.iterator in value);\n}\n","/**\n * @typedef {(error?: Error|null|undefined, ...output: Array) => void} Callback\n * @typedef {(...input: Array) => any} Middleware\n *\n * @typedef {(...input: Array) => void} Run\n * Call all middleware.\n * @typedef {(fn: Middleware) => Pipeline} Use\n * Add `fn` (middleware) to the list.\n * @typedef {{run: Run, use: Use}} Pipeline\n * Middleware.\n */\n\n/**\n * Create new middleware.\n *\n * @returns {Pipeline}\n */\nexport function trough() {\n /** @type {Array} */\n const fns = []\n /** @type {Pipeline} */\n const pipeline = {run, use}\n\n return pipeline\n\n /** @type {Run} */\n function run(...values) {\n let middlewareIndex = -1\n /** @type {Callback} */\n const callback = values.pop()\n\n if (typeof callback !== 'function') {\n throw new TypeError('Expected function as last argument, not ' + callback)\n }\n\n next(null, ...values)\n\n /**\n * Run the next `fn`, or we’re done.\n *\n * @param {Error|null|undefined} error\n * @param {Array} output\n */\n function next(error, ...output) {\n const fn = fns[++middlewareIndex]\n let index = -1\n\n if (error) {\n callback(error)\n return\n }\n\n // Copy non-nullish input into values.\n while (++index < values.length) {\n if (output[index] === null || output[index] === undefined) {\n output[index] = values[index]\n }\n }\n\n // Save the newly created `output` for the next call.\n values = output\n\n // Next or done.\n if (fn) {\n wrap(fn, next)(...output)\n } else {\n callback(null, ...output)\n }\n }\n }\n\n /** @type {Use} */\n function use(middelware) {\n if (typeof middelware !== 'function') {\n throw new TypeError(\n 'Expected `middelware` to be a function, not ' + middelware\n )\n }\n\n fns.push(middelware)\n return pipeline\n }\n}\n\n/**\n * Wrap `middleware`.\n * Can be sync or async; return a promise, receive a callback, or return new\n * values and errors.\n *\n * @param {Middleware} middleware\n * @param {Callback} callback\n */\nexport function wrap(middleware, callback) {\n /** @type {boolean} */\n let called\n\n return wrapped\n\n /**\n * Call `middleware`.\n * @this {any}\n * @param {Array} parameters\n * @returns {void}\n */\n function wrapped(...parameters) {\n const fnExpectsCallback = middleware.length > parameters.length\n /** @type {any} */\n let result\n\n if (fnExpectsCallback) {\n parameters.push(done)\n }\n\n try {\n result = middleware.apply(this, parameters)\n } catch (error) {\n const exception = /** @type {Error} */ (error)\n\n // Well, this is quite the pickle.\n // `middleware` received a callback and called it synchronously, but that\n // threw an error.\n // The only thing left to do is to throw the thing instead.\n if (fnExpectsCallback && called) {\n throw exception\n }\n\n return done(exception)\n }\n\n if (!fnExpectsCallback) {\n if (result instanceof Promise) {\n result.then(then, done)\n } else if (result instanceof Error) {\n done(result)\n } else {\n then(result)\n }\n }\n }\n\n /**\n * Call `callback`, only once.\n * @type {Callback}\n */\n function done(error, ...output) {\n if (!called) {\n called = true\n callback(error, ...output)\n }\n }\n\n /**\n * Call `done` with one value.\n *\n * @param {any} [value]\n */\n function then(value) {\n done(null, value)\n }\n}\n","/**\n * @typedef {import('unist').Node} Node\n * @typedef {import('unist').Point} Point\n * @typedef {import('unist').Position} Position\n */\n\n/**\n * @typedef NodeLike\n * @property {string} type\n * @property {PositionLike | null | undefined} [position]\n *\n * @typedef PositionLike\n * @property {PointLike | null | undefined} [start]\n * @property {PointLike | null | undefined} [end]\n *\n * @typedef PointLike\n * @property {number | null | undefined} [line]\n * @property {number | null | undefined} [column]\n * @property {number | null | undefined} [offset]\n */\n\n/**\n * Serialize the positional info of a point, position (start and end points),\n * or node.\n *\n * @param {Node | NodeLike | Position | PositionLike | Point | PointLike | null | undefined} [value]\n * Node, position, or point.\n * @returns {string}\n * Pretty printed positional info of a node (`string`).\n *\n * In the format of a range `ls:cs-le:ce` (when given `node` or `position`)\n * or a point `l:c` (when given `point`), where `l` stands for line, `c` for\n * column, `s` for `start`, and `e` for end.\n * An empty string (`''`) is returned if the given value is neither `node`,\n * `position`, nor `point`.\n */\nexport function stringifyPosition(value) {\n // Nothing.\n if (!value || typeof value !== 'object') {\n return ''\n }\n\n // Node.\n if ('position' in value || 'type' in value) {\n return position(value.position)\n }\n\n // Position.\n if ('start' in value || 'end' in value) {\n return position(value)\n }\n\n // Point.\n if ('line' in value || 'column' in value) {\n return point(value)\n }\n\n // ?\n return ''\n}\n\n/**\n * @param {Point | PointLike | null | undefined} point\n * @returns {string}\n */\nfunction point(point) {\n return index(point && point.line) + ':' + index(point && point.column)\n}\n\n/**\n * @param {Position | PositionLike | null | undefined} pos\n * @returns {string}\n */\nfunction position(pos) {\n return point(pos && pos.start) + '-' + point(pos && pos.end)\n}\n\n/**\n * @param {number | null | undefined} value\n * @returns {number}\n */\nfunction index(value) {\n return value && typeof value === 'number' ? value : 1\n}\n","/**\n * @typedef {import('unist').Node} Node\n * @typedef {import('unist').Position} Position\n * @typedef {import('unist').Point} Point\n * @typedef {object & {type: string, position?: Position | undefined}} NodeLike\n */\n\nimport {stringifyPosition} from 'unist-util-stringify-position'\n\n/**\n * Message.\n */\nexport class VFileMessage extends Error {\n /**\n * Create a message for `reason` at `place` from `origin`.\n *\n * When an error is passed in as `reason`, the `stack` is copied.\n *\n * @param {string | Error | VFileMessage} reason\n * Reason for message, uses the stack and message of the error if given.\n *\n * > 👉 **Note**: you should use markdown.\n * @param {Node | NodeLike | Position | Point | null | undefined} [place]\n * Place in file where the message occurred.\n * @param {string | null | undefined} [origin]\n * Place in code where the message originates (example:\n * `'my-package:my-rule'` or `'my-rule'`).\n * @returns\n * Instance of `VFileMessage`.\n */\n // To do: next major: expose `undefined` everywhere instead of `null`.\n constructor(reason, place, origin) {\n /** @type {[string | null, string | null]} */\n const parts = [null, null]\n /** @type {Position} */\n let position = {\n // @ts-expect-error: we always follows the structure of `position`.\n start: {line: null, column: null},\n // @ts-expect-error: \"\n end: {line: null, column: null}\n }\n\n super()\n\n if (typeof place === 'string') {\n origin = place\n place = undefined\n }\n\n if (typeof origin === 'string') {\n const index = origin.indexOf(':')\n\n if (index === -1) {\n parts[1] = origin\n } else {\n parts[0] = origin.slice(0, index)\n parts[1] = origin.slice(index + 1)\n }\n }\n\n if (place) {\n // Node.\n if ('type' in place || 'position' in place) {\n if (place.position) {\n // To do: next major: deep clone.\n // @ts-expect-error: looks like a position.\n position = place.position\n }\n }\n // Position.\n else if ('start' in place || 'end' in place) {\n // @ts-expect-error: looks like a position.\n // To do: next major: deep clone.\n position = place\n }\n // Point.\n else if ('line' in place || 'column' in place) {\n // To do: next major: deep clone.\n position.start = place\n }\n }\n\n // Fields from `Error`.\n /**\n * Serialized positional info of error.\n *\n * On normal errors, this would be something like `ParseError`, buit in\n * `VFile` messages we use this space to show where an error happened.\n */\n this.name = stringifyPosition(place) || '1:1'\n\n /**\n * Reason for message.\n *\n * @type {string}\n */\n this.message = typeof reason === 'object' ? reason.message : reason\n\n /**\n * Stack of message.\n *\n * This is used by normal errors to show where something happened in\n * programming code, irrelevant for `VFile` messages,\n *\n * @type {string}\n */\n this.stack = ''\n\n if (typeof reason === 'object' && reason.stack) {\n this.stack = reason.stack\n }\n\n /**\n * Reason for message.\n *\n * > 👉 **Note**: you should use markdown.\n *\n * @type {string}\n */\n this.reason = this.message\n\n /* eslint-disable no-unused-expressions */\n /**\n * State of problem.\n *\n * * `true` — marks associated file as no longer processable (error)\n * * `false` — necessitates a (potential) change (warning)\n * * `null | undefined` — for things that might not need changing (info)\n *\n * @type {boolean | null | undefined}\n */\n this.fatal\n\n /**\n * Starting line of error.\n *\n * @type {number | null}\n */\n this.line = position.start.line\n\n /**\n * Starting column of error.\n *\n * @type {number | null}\n */\n this.column = position.start.column\n\n /**\n * Full unist position.\n *\n * @type {Position | null}\n */\n this.position = position\n\n /**\n * Namespace of message (example: `'my-package'`).\n *\n * @type {string | null}\n */\n this.source = parts[0]\n\n /**\n * Category of message (example: `'my-rule'`).\n *\n * @type {string | null}\n */\n this.ruleId = parts[1]\n\n /**\n * Path of a file (used throughout the `VFile` ecosystem).\n *\n * @type {string | null}\n */\n this.file\n\n // The following fields are “well known”.\n // Not standard.\n // Feel free to add other non-standard fields to your messages.\n\n /**\n * Specify the source value that’s being reported, which is deemed\n * incorrect.\n *\n * @type {string | null}\n */\n this.actual\n\n /**\n * Suggest acceptable values that can be used instead of `actual`.\n *\n * @type {Array | null}\n */\n this.expected\n\n /**\n * Link to docs for the message.\n *\n * > 👉 **Note**: this must be an absolute URL that can be passed as `x`\n * > to `new URL(x)`.\n *\n * @type {string | null}\n */\n this.url\n\n /**\n * Long form description of the message (you should use markdown).\n *\n * @type {string | null}\n */\n this.note\n /* eslint-enable no-unused-expressions */\n }\n}\n\nVFileMessage.prototype.file = ''\nVFileMessage.prototype.name = ''\nVFileMessage.prototype.reason = ''\nVFileMessage.prototype.message = ''\nVFileMessage.prototype.stack = ''\nVFileMessage.prototype.fatal = null\nVFileMessage.prototype.column = null\nVFileMessage.prototype.line = null\nVFileMessage.prototype.source = null\nVFileMessage.prototype.ruleId = null\nVFileMessage.prototype.position = null\n","// A derivative work based on:\n// .\n// Which is licensed:\n//\n// MIT License\n//\n// Copyright (c) 2013 James Halliday\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy of\n// this software and associated documentation files (the \"Software\"), to deal in\n// the Software without restriction, including without limitation the rights to\n// use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of\n// the Software, and to permit persons to whom the Software is furnished to do so,\n// subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in all\n// copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS\n// FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR\n// COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER\n// IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN\n// CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.\n// A derivative work based on:\n//\n// Parts of that are extracted from Node’s internal `path` module:\n// .\n// Which is licensed:\n//\n// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\nexport const path = {basename, dirname, extname, join, sep: '/'}\n\n/* eslint-disable max-depth, complexity */\n\n/**\n * Get the basename from a path.\n *\n * @param {string} path\n * File path.\n * @param {string | undefined} [ext]\n * Extension to strip.\n * @returns {string}\n * Stem or basename.\n */\nfunction basename(path, ext) {\n if (ext !== undefined && typeof ext !== 'string') {\n throw new TypeError('\"ext\" argument must be a string')\n }\n\n assertPath(path)\n let start = 0\n let end = -1\n let index = path.length\n /** @type {boolean | undefined} */\n let seenNonSlash\n\n if (ext === undefined || ext.length === 0 || ext.length > path.length) {\n while (index--) {\n if (path.charCodeAt(index) === 47 /* `/` */) {\n // If we reached a path separator that was not part of a set of path\n // separators at the end of the string, stop now.\n if (seenNonSlash) {\n start = index + 1\n break\n }\n } else if (end < 0) {\n // We saw the first non-path separator, mark this as the end of our\n // path component.\n seenNonSlash = true\n end = index + 1\n }\n }\n\n return end < 0 ? '' : path.slice(start, end)\n }\n\n if (ext === path) {\n return ''\n }\n\n let firstNonSlashEnd = -1\n let extIndex = ext.length - 1\n\n while (index--) {\n if (path.charCodeAt(index) === 47 /* `/` */) {\n // If we reached a path separator that was not part of a set of path\n // separators at the end of the string, stop now.\n if (seenNonSlash) {\n start = index + 1\n break\n }\n } else {\n if (firstNonSlashEnd < 0) {\n // We saw the first non-path separator, remember this index in case\n // we need it if the extension ends up not matching.\n seenNonSlash = true\n firstNonSlashEnd = index + 1\n }\n\n if (extIndex > -1) {\n // Try to match the explicit extension.\n if (path.charCodeAt(index) === ext.charCodeAt(extIndex--)) {\n if (extIndex < 0) {\n // We matched the extension, so mark this as the end of our path\n // component\n end = index\n }\n } else {\n // Extension does not match, so our result is the entire path\n // component\n extIndex = -1\n end = firstNonSlashEnd\n }\n }\n }\n }\n\n if (start === end) {\n end = firstNonSlashEnd\n } else if (end < 0) {\n end = path.length\n }\n\n return path.slice(start, end)\n}\n\n/**\n * Get the dirname from a path.\n *\n * @param {string} path\n * File path.\n * @returns {string}\n * File path.\n */\nfunction dirname(path) {\n assertPath(path)\n\n if (path.length === 0) {\n return '.'\n }\n\n let end = -1\n let index = path.length\n /** @type {boolean | undefined} */\n let unmatchedSlash\n\n // Prefix `--` is important to not run on `0`.\n while (--index) {\n if (path.charCodeAt(index) === 47 /* `/` */) {\n if (unmatchedSlash) {\n end = index\n break\n }\n } else if (!unmatchedSlash) {\n // We saw the first non-path separator\n unmatchedSlash = true\n }\n }\n\n return end < 0\n ? path.charCodeAt(0) === 47 /* `/` */\n ? '/'\n : '.'\n : end === 1 && path.charCodeAt(0) === 47 /* `/` */\n ? '//'\n : path.slice(0, end)\n}\n\n/**\n * Get an extname from a path.\n *\n * @param {string} path\n * File path.\n * @returns {string}\n * Extname.\n */\nfunction extname(path) {\n assertPath(path)\n\n let index = path.length\n\n let end = -1\n let startPart = 0\n let startDot = -1\n // Track the state of characters (if any) we see before our first dot and\n // after any path separator we find.\n let preDotState = 0\n /** @type {boolean | undefined} */\n let unmatchedSlash\n\n while (index--) {\n const code = path.charCodeAt(index)\n\n if (code === 47 /* `/` */) {\n // If we reached a path separator that was not part of a set of path\n // separators at the end of the string, stop now.\n if (unmatchedSlash) {\n startPart = index + 1\n break\n }\n\n continue\n }\n\n if (end < 0) {\n // We saw the first non-path separator, mark this as the end of our\n // extension.\n unmatchedSlash = true\n end = index + 1\n }\n\n if (code === 46 /* `.` */) {\n // If this is our first dot, mark it as the start of our extension.\n if (startDot < 0) {\n startDot = index\n } else if (preDotState !== 1) {\n preDotState = 1\n }\n } else if (startDot > -1) {\n // We saw a non-dot and non-path separator before our dot, so we should\n // have a good chance at having a non-empty extension.\n preDotState = -1\n }\n }\n\n if (\n startDot < 0 ||\n end < 0 ||\n // We saw a non-dot character immediately before the dot.\n preDotState === 0 ||\n // The (right-most) trimmed path component is exactly `..`.\n (preDotState === 1 && startDot === end - 1 && startDot === startPart + 1)\n ) {\n return ''\n }\n\n return path.slice(startDot, end)\n}\n\n/**\n * Join segments from a path.\n *\n * @param {Array} segments\n * Path segments.\n * @returns {string}\n * File path.\n */\nfunction join(...segments) {\n let index = -1\n /** @type {string | undefined} */\n let joined\n\n while (++index < segments.length) {\n assertPath(segments[index])\n\n if (segments[index]) {\n joined =\n joined === undefined ? segments[index] : joined + '/' + segments[index]\n }\n }\n\n return joined === undefined ? '.' : normalize(joined)\n}\n\n/**\n * Normalize a basic file path.\n *\n * @param {string} path\n * File path.\n * @returns {string}\n * File path.\n */\n// Note: `normalize` is not exposed as `path.normalize`, so some code is\n// manually removed from it.\nfunction normalize(path) {\n assertPath(path)\n\n const absolute = path.charCodeAt(0) === 47 /* `/` */\n\n // Normalize the path according to POSIX rules.\n let value = normalizeString(path, !absolute)\n\n if (value.length === 0 && !absolute) {\n value = '.'\n }\n\n if (value.length > 0 && path.charCodeAt(path.length - 1) === 47 /* / */) {\n value += '/'\n }\n\n return absolute ? '/' + value : value\n}\n\n/**\n * Resolve `.` and `..` elements in a path with directory names.\n *\n * @param {string} path\n * File path.\n * @param {boolean} allowAboveRoot\n * Whether `..` can move above root.\n * @returns {string}\n * File path.\n */\nfunction normalizeString(path, allowAboveRoot) {\n let result = ''\n let lastSegmentLength = 0\n let lastSlash = -1\n let dots = 0\n let index = -1\n /** @type {number | undefined} */\n let code\n /** @type {number} */\n let lastSlashIndex\n\n while (++index <= path.length) {\n if (index < path.length) {\n code = path.charCodeAt(index)\n } else if (code === 47 /* `/` */) {\n break\n } else {\n code = 47 /* `/` */\n }\n\n if (code === 47 /* `/` */) {\n if (lastSlash === index - 1 || dots === 1) {\n // Empty.\n } else if (lastSlash !== index - 1 && dots === 2) {\n if (\n result.length < 2 ||\n lastSegmentLength !== 2 ||\n result.charCodeAt(result.length - 1) !== 46 /* `.` */ ||\n result.charCodeAt(result.length - 2) !== 46 /* `.` */\n ) {\n if (result.length > 2) {\n lastSlashIndex = result.lastIndexOf('/')\n\n if (lastSlashIndex !== result.length - 1) {\n if (lastSlashIndex < 0) {\n result = ''\n lastSegmentLength = 0\n } else {\n result = result.slice(0, lastSlashIndex)\n lastSegmentLength = result.length - 1 - result.lastIndexOf('/')\n }\n\n lastSlash = index\n dots = 0\n continue\n }\n } else if (result.length > 0) {\n result = ''\n lastSegmentLength = 0\n lastSlash = index\n dots = 0\n continue\n }\n }\n\n if (allowAboveRoot) {\n result = result.length > 0 ? result + '/..' : '..'\n lastSegmentLength = 2\n }\n } else {\n if (result.length > 0) {\n result += '/' + path.slice(lastSlash + 1, index)\n } else {\n result = path.slice(lastSlash + 1, index)\n }\n\n lastSegmentLength = index - lastSlash - 1\n }\n\n lastSlash = index\n dots = 0\n } else if (code === 46 /* `.` */ && dots > -1) {\n dots++\n } else {\n dots = -1\n }\n }\n\n return result\n}\n\n/**\n * Make sure `path` is a string.\n *\n * @param {string} path\n * File path.\n * @returns {asserts path is string}\n * Nothing.\n */\nfunction assertPath(path) {\n if (typeof path !== 'string') {\n throw new TypeError(\n 'Path must be a string. Received ' + JSON.stringify(path)\n )\n }\n}\n\n/* eslint-enable max-depth, complexity */\n","// Somewhat based on:\n// .\n// But I don’t think one tiny line of code can be copyrighted. 😅\nexport const proc = {cwd}\n\nfunction cwd() {\n return '/'\n}\n","/**\n * @typedef URL\n * @property {string} hash\n * @property {string} host\n * @property {string} hostname\n * @property {string} href\n * @property {string} origin\n * @property {string} password\n * @property {string} pathname\n * @property {string} port\n * @property {string} protocol\n * @property {string} search\n * @property {any} searchParams\n * @property {string} username\n * @property {() => string} toString\n * @property {() => string} toJSON\n */\n\n/**\n * Check if `fileUrlOrPath` looks like a URL.\n *\n * @param {unknown} fileUrlOrPath\n * File path or URL.\n * @returns {fileUrlOrPath is URL}\n * Whether it’s a URL.\n */\n// From: \nexport function isUrl(fileUrlOrPath) {\n return (\n fileUrlOrPath !== null &&\n typeof fileUrlOrPath === 'object' &&\n // @ts-expect-error: indexable.\n fileUrlOrPath.href &&\n // @ts-expect-error: indexable.\n fileUrlOrPath.origin\n )\n}\n","/// \n\nimport {isUrl} from './minurl.shared.js'\n\n// See: \n\n/**\n * @param {string | URL} path\n * File URL.\n * @returns {string}\n * File URL.\n */\nexport function urlToPath(path) {\n if (typeof path === 'string') {\n path = new URL(path)\n } else if (!isUrl(path)) {\n /** @type {NodeJS.ErrnoException} */\n const error = new TypeError(\n 'The \"path\" argument must be of type string or an instance of URL. Received `' +\n path +\n '`'\n )\n error.code = 'ERR_INVALID_ARG_TYPE'\n throw error\n }\n\n if (path.protocol !== 'file:') {\n /** @type {NodeJS.ErrnoException} */\n const error = new TypeError('The URL must be of scheme file')\n error.code = 'ERR_INVALID_URL_SCHEME'\n throw error\n }\n\n return getPathFromURLPosix(path)\n}\n\n/**\n * Get a path from a POSIX URL.\n *\n * @param {URL} url\n * URL.\n * @returns {string}\n * File path.\n */\nfunction getPathFromURLPosix(url) {\n if (url.hostname !== '') {\n /** @type {NodeJS.ErrnoException} */\n const error = new TypeError(\n 'File URL host must be \"localhost\" or empty on darwin'\n )\n error.code = 'ERR_INVALID_FILE_URL_HOST'\n throw error\n }\n\n const pathname = url.pathname\n let index = -1\n\n while (++index < pathname.length) {\n if (\n pathname.charCodeAt(index) === 37 /* `%` */ &&\n pathname.charCodeAt(index + 1) === 50 /* `2` */\n ) {\n const third = pathname.charCodeAt(index + 2)\n if (third === 70 /* `F` */ || third === 102 /* `f` */) {\n /** @type {NodeJS.ErrnoException} */\n const error = new TypeError(\n 'File URL path must not include encoded / characters'\n )\n error.code = 'ERR_INVALID_FILE_URL_PATH'\n throw error\n }\n }\n }\n\n return decodeURIComponent(pathname)\n}\n\nexport {isUrl} from './minurl.shared.js'\n","/**\n * @typedef {import('unist').Node} Node\n * @typedef {import('unist').Position} Position\n * @typedef {import('unist').Point} Point\n * @typedef {import('./minurl.shared.js').URL} URL\n * @typedef {import('../index.js').Data} Data\n * @typedef {import('../index.js').Value} Value\n */\n\n/**\n * @typedef {Record & {type: string, position?: Position | undefined}} NodeLike\n *\n * @typedef {'ascii' | 'utf8' | 'utf-8' | 'utf16le' | 'ucs2' | 'ucs-2' | 'base64' | 'base64url' | 'latin1' | 'binary' | 'hex'} BufferEncoding\n * Encodings supported by the buffer class.\n *\n * This is a copy of the types from Node, copied to prevent Node globals from\n * being needed.\n * Copied from: \n *\n * @typedef {Options | URL | Value | VFile} Compatible\n * Things that can be passed to the constructor.\n *\n * @typedef VFileCoreOptions\n * Set multiple values.\n * @property {Value | null | undefined} [value]\n * Set `value`.\n * @property {string | null | undefined} [cwd]\n * Set `cwd`.\n * @property {Array | null | undefined} [history]\n * Set `history`.\n * @property {URL | string | null | undefined} [path]\n * Set `path`.\n * @property {string | null | undefined} [basename]\n * Set `basename`.\n * @property {string | null | undefined} [stem]\n * Set `stem`.\n * @property {string | null | undefined} [extname]\n * Set `extname`.\n * @property {string | null | undefined} [dirname]\n * Set `dirname`.\n * @property {Data | null | undefined} [data]\n * Set `data`.\n *\n * @typedef Map\n * Raw source map.\n *\n * See:\n * .\n * @property {number} version\n * Which version of the source map spec this map is following.\n * @property {Array} sources\n * An array of URLs to the original source files.\n * @property {Array} names\n * An array of identifiers which can be referenced by individual mappings.\n * @property {string | undefined} [sourceRoot]\n * The URL root from which all sources are relative.\n * @property {Array | undefined} [sourcesContent]\n * An array of contents of the original source files.\n * @property {string} mappings\n * A string of base64 VLQs which contain the actual mappings.\n * @property {string} file\n * The generated file this source map is associated with.\n *\n * @typedef {{[key: string]: unknown} & VFileCoreOptions} Options\n * Configuration.\n *\n * A bunch of keys that will be shallow copied over to the new file.\n *\n * @typedef {Record} ReporterSettings\n * Configuration for reporters.\n */\n\n/**\n * @template {ReporterSettings} Settings\n * Options type.\n * @callback Reporter\n * Type for a reporter.\n * @param {Array} files\n * Files to report.\n * @param {Settings} options\n * Configuration.\n * @returns {string}\n * Report.\n */\n\nimport bufferLike from 'is-buffer'\nimport {VFileMessage} from 'vfile-message'\nimport {path} from './minpath.js'\nimport {proc} from './minproc.js'\nimport {urlToPath, isUrl} from './minurl.js'\n\n/**\n * Order of setting (least specific to most), we need this because otherwise\n * `{stem: 'a', path: '~/b.js'}` would throw, as a path is needed before a\n * stem can be set.\n *\n * @type {Array<'basename' | 'dirname' | 'extname' | 'history' | 'path' | 'stem'>}\n */\nconst order = ['history', 'path', 'basename', 'stem', 'extname', 'dirname']\n\nexport class VFile {\n /**\n * Create a new virtual file.\n *\n * `options` is treated as:\n *\n * * `string` or `Buffer` — `{value: options}`\n * * `URL` — `{path: options}`\n * * `VFile` — shallow copies its data over to the new file\n * * `object` — all fields are shallow copied over to the new file\n *\n * Path related fields are set in the following order (least specific to\n * most specific): `history`, `path`, `basename`, `stem`, `extname`,\n * `dirname`.\n *\n * You cannot set `dirname` or `extname` without setting either `history`,\n * `path`, `basename`, or `stem` too.\n *\n * @param {Compatible | null | undefined} [value]\n * File value.\n * @returns\n * New instance.\n */\n constructor(value) {\n /** @type {Options | VFile} */\n let options\n\n if (!value) {\n options = {}\n } else if (typeof value === 'string' || buffer(value)) {\n options = {value}\n } else if (isUrl(value)) {\n options = {path: value}\n } else {\n options = value\n }\n\n /**\n * Place to store custom information (default: `{}`).\n *\n * It’s OK to store custom data directly on the file but moving it to\n * `data` is recommended.\n *\n * @type {Data}\n */\n this.data = {}\n\n /**\n * List of messages associated with the file.\n *\n * @type {Array}\n */\n this.messages = []\n\n /**\n * List of filepaths the file moved between.\n *\n * The first is the original path and the last is the current path.\n *\n * @type {Array}\n */\n this.history = []\n\n /**\n * Base of `path` (default: `process.cwd()` or `'/'` in browsers).\n *\n * @type {string}\n */\n this.cwd = proc.cwd()\n\n /* eslint-disable no-unused-expressions */\n /**\n * Raw value.\n *\n * @type {Value}\n */\n this.value\n\n // The below are non-standard, they are “well-known”.\n // As in, used in several tools.\n\n /**\n * Whether a file was saved to disk.\n *\n * This is used by vfile reporters.\n *\n * @type {boolean}\n */\n this.stored\n\n /**\n * Custom, non-string, compiled, representation.\n *\n * This is used by unified to store non-string results.\n * One example is when turning markdown into React nodes.\n *\n * @type {unknown}\n */\n this.result\n\n /**\n * Source map.\n *\n * This type is equivalent to the `RawSourceMap` type from the `source-map`\n * module.\n *\n * @type {Map | null | undefined}\n */\n this.map\n /* eslint-enable no-unused-expressions */\n\n // Set path related properties in the correct order.\n let index = -1\n\n while (++index < order.length) {\n const prop = order[index]\n\n // Note: we specifically use `in` instead of `hasOwnProperty` to accept\n // `vfile`s too.\n if (\n prop in options &&\n options[prop] !== undefined &&\n options[prop] !== null\n ) {\n // @ts-expect-error: TS doesn’t understand basic reality.\n this[prop] = prop === 'history' ? [...options[prop]] : options[prop]\n }\n }\n\n /** @type {string} */\n let prop\n\n // Set non-path related properties.\n for (prop in options) {\n // @ts-expect-error: fine to set other things.\n if (!order.includes(prop)) {\n // @ts-expect-error: fine to set other things.\n this[prop] = options[prop]\n }\n }\n }\n\n /**\n * Get the full path (example: `'~/index.min.js'`).\n *\n * @returns {string}\n */\n get path() {\n return this.history[this.history.length - 1]\n }\n\n /**\n * Set the full path (example: `'~/index.min.js'`).\n *\n * Cannot be nullified.\n * You can set a file URL (a `URL` object with a `file:` protocol) which will\n * be turned into a path with `url.fileURLToPath`.\n *\n * @param {string | URL} path\n */\n set path(path) {\n if (isUrl(path)) {\n path = urlToPath(path)\n }\n\n assertNonEmpty(path, 'path')\n\n if (this.path !== path) {\n this.history.push(path)\n }\n }\n\n /**\n * Get the parent path (example: `'~'`).\n */\n get dirname() {\n return typeof this.path === 'string' ? path.dirname(this.path) : undefined\n }\n\n /**\n * Set the parent path (example: `'~'`).\n *\n * Cannot be set if there’s no `path` yet.\n */\n set dirname(dirname) {\n assertPath(this.basename, 'dirname')\n this.path = path.join(dirname || '', this.basename)\n }\n\n /**\n * Get the basename (including extname) (example: `'index.min.js'`).\n */\n get basename() {\n return typeof this.path === 'string' ? path.basename(this.path) : undefined\n }\n\n /**\n * Set basename (including extname) (`'index.min.js'`).\n *\n * Cannot contain path separators (`'/'` on unix, macOS, and browsers, `'\\'`\n * on windows).\n * Cannot be nullified (use `file.path = file.dirname` instead).\n */\n set basename(basename) {\n assertNonEmpty(basename, 'basename')\n assertPart(basename, 'basename')\n this.path = path.join(this.dirname || '', basename)\n }\n\n /**\n * Get the extname (including dot) (example: `'.js'`).\n */\n get extname() {\n return typeof this.path === 'string' ? path.extname(this.path) : undefined\n }\n\n /**\n * Set the extname (including dot) (example: `'.js'`).\n *\n * Cannot contain path separators (`'/'` on unix, macOS, and browsers, `'\\'`\n * on windows).\n * Cannot be set if there’s no `path` yet.\n */\n set extname(extname) {\n assertPart(extname, 'extname')\n assertPath(this.dirname, 'extname')\n\n if (extname) {\n if (extname.charCodeAt(0) !== 46 /* `.` */) {\n throw new Error('`extname` must start with `.`')\n }\n\n if (extname.includes('.', 1)) {\n throw new Error('`extname` cannot contain multiple dots')\n }\n }\n\n this.path = path.join(this.dirname, this.stem + (extname || ''))\n }\n\n /**\n * Get the stem (basename w/o extname) (example: `'index.min'`).\n */\n get stem() {\n return typeof this.path === 'string'\n ? path.basename(this.path, this.extname)\n : undefined\n }\n\n /**\n * Set the stem (basename w/o extname) (example: `'index.min'`).\n *\n * Cannot contain path separators (`'/'` on unix, macOS, and browsers, `'\\'`\n * on windows).\n * Cannot be nullified (use `file.path = file.dirname` instead).\n */\n set stem(stem) {\n assertNonEmpty(stem, 'stem')\n assertPart(stem, 'stem')\n this.path = path.join(this.dirname || '', stem + (this.extname || ''))\n }\n\n /**\n * Serialize the file.\n *\n * @param {BufferEncoding | null | undefined} [encoding='utf8']\n * Character encoding to understand `value` as when it’s a `Buffer`\n * (default: `'utf8'`).\n * @returns {string}\n * Serialized file.\n */\n toString(encoding) {\n return (this.value || '').toString(encoding || undefined)\n }\n\n /**\n * Create a warning message associated with the file.\n *\n * Its `fatal` is set to `false` and `file` is set to the current file path.\n * Its added to `file.messages`.\n *\n * @param {string | Error | VFileMessage} reason\n * Reason for message, uses the stack and message of the error if given.\n * @param {Node | NodeLike | Position | Point | null | undefined} [place]\n * Place in file where the message occurred.\n * @param {string | null | undefined} [origin]\n * Place in code where the message originates (example:\n * `'my-package:my-rule'` or `'my-rule'`).\n * @returns {VFileMessage}\n * Message.\n */\n message(reason, place, origin) {\n const message = new VFileMessage(reason, place, origin)\n\n if (this.path) {\n message.name = this.path + ':' + message.name\n message.file = this.path\n }\n\n message.fatal = false\n\n this.messages.push(message)\n\n return message\n }\n\n /**\n * Create an info message associated with the file.\n *\n * Its `fatal` is set to `null` and `file` is set to the current file path.\n * Its added to `file.messages`.\n *\n * @param {string | Error | VFileMessage} reason\n * Reason for message, uses the stack and message of the error if given.\n * @param {Node | NodeLike | Position | Point | null | undefined} [place]\n * Place in file where the message occurred.\n * @param {string | null | undefined} [origin]\n * Place in code where the message originates (example:\n * `'my-package:my-rule'` or `'my-rule'`).\n * @returns {VFileMessage}\n * Message.\n */\n info(reason, place, origin) {\n const message = this.message(reason, place, origin)\n\n message.fatal = null\n\n return message\n }\n\n /**\n * Create a fatal error associated with the file.\n *\n * Its `fatal` is set to `true` and `file` is set to the current file path.\n * Its added to `file.messages`.\n *\n * > 👉 **Note**: a fatal error means that a file is no longer processable.\n *\n * @param {string | Error | VFileMessage} reason\n * Reason for message, uses the stack and message of the error if given.\n * @param {Node | NodeLike | Position | Point | null | undefined} [place]\n * Place in file where the message occurred.\n * @param {string | null | undefined} [origin]\n * Place in code where the message originates (example:\n * `'my-package:my-rule'` or `'my-rule'`).\n * @returns {never}\n * Message.\n * @throws {VFileMessage}\n * Message.\n */\n fail(reason, place, origin) {\n const message = this.message(reason, place, origin)\n\n message.fatal = true\n\n throw message\n }\n}\n\n/**\n * Assert that `part` is not a path (as in, does not contain `path.sep`).\n *\n * @param {string | null | undefined} part\n * File path part.\n * @param {string} name\n * Part name.\n * @returns {void}\n * Nothing.\n */\nfunction assertPart(part, name) {\n if (part && part.includes(path.sep)) {\n throw new Error(\n '`' + name + '` cannot be a path: did not expect `' + path.sep + '`'\n )\n }\n}\n\n/**\n * Assert that `part` is not empty.\n *\n * @param {string | undefined} part\n * Thing.\n * @param {string} name\n * Part name.\n * @returns {asserts part is string}\n * Nothing.\n */\nfunction assertNonEmpty(part, name) {\n if (!part) {\n throw new Error('`' + name + '` cannot be empty')\n }\n}\n\n/**\n * Assert `path` exists.\n *\n * @param {string | undefined} path\n * Path.\n * @param {string} name\n * Dependency name.\n * @returns {asserts path is string}\n * Nothing.\n */\nfunction assertPath(path, name) {\n if (!path) {\n throw new Error('Setting `' + name + '` requires `path` to be set too')\n }\n}\n\n/**\n * Assert `value` is a buffer.\n *\n * @param {unknown} value\n * thing.\n * @returns {value is Buffer}\n * Whether `value` is a Node.js buffer.\n */\nfunction buffer(value) {\n return bufferLike(value)\n}\n","/**\n * @typedef {import('unist').Node} Node\n * @typedef {import('vfile').VFileCompatible} VFileCompatible\n * @typedef {import('vfile').VFileValue} VFileValue\n * @typedef {import('..').Processor} Processor\n * @typedef {import('..').Plugin} Plugin\n * @typedef {import('..').Preset} Preset\n * @typedef {import('..').Pluggable} Pluggable\n * @typedef {import('..').PluggableList} PluggableList\n * @typedef {import('..').Transformer} Transformer\n * @typedef {import('..').Parser} Parser\n * @typedef {import('..').Compiler} Compiler\n * @typedef {import('..').RunCallback} RunCallback\n * @typedef {import('..').ProcessCallback} ProcessCallback\n *\n * @typedef Context\n * @property {Node} tree\n * @property {VFile} file\n */\n\nimport {bail} from 'bail'\nimport isBuffer from 'is-buffer'\nimport extend from 'extend'\nimport isPlainObj from 'is-plain-obj'\nimport {trough} from 'trough'\nimport {VFile} from 'vfile'\n\n// Expose a frozen processor.\nexport const unified = base().freeze()\n\nconst own = {}.hasOwnProperty\n\n// Function to create the first processor.\n/**\n * @returns {Processor}\n */\nfunction base() {\n const transformers = trough()\n /** @type {Processor['attachers']} */\n const attachers = []\n /** @type {Record} */\n let namespace = {}\n /** @type {boolean|undefined} */\n let frozen\n let freezeIndex = -1\n\n // Data management.\n // @ts-expect-error: overloads are handled.\n processor.data = data\n processor.Parser = undefined\n processor.Compiler = undefined\n\n // Lock.\n processor.freeze = freeze\n\n // Plugins.\n processor.attachers = attachers\n // @ts-expect-error: overloads are handled.\n processor.use = use\n\n // API.\n processor.parse = parse\n processor.stringify = stringify\n // @ts-expect-error: overloads are handled.\n processor.run = run\n processor.runSync = runSync\n // @ts-expect-error: overloads are handled.\n processor.process = process\n processor.processSync = processSync\n\n // Expose.\n return processor\n\n // Create a new processor based on the processor in the current scope.\n /** @type {Processor} */\n function processor() {\n const destination = base()\n let index = -1\n\n while (++index < attachers.length) {\n destination.use(...attachers[index])\n }\n\n destination.data(extend(true, {}, namespace))\n\n return destination\n }\n\n /**\n * @param {string|Record} [key]\n * @param {unknown} [value]\n * @returns {unknown}\n */\n function data(key, value) {\n if (typeof key === 'string') {\n // Set `key`.\n if (arguments.length === 2) {\n assertUnfrozen('data', frozen)\n namespace[key] = value\n return processor\n }\n\n // Get `key`.\n return (own.call(namespace, key) && namespace[key]) || null\n }\n\n // Set space.\n if (key) {\n assertUnfrozen('data', frozen)\n namespace = key\n return processor\n }\n\n // Get space.\n return namespace\n }\n\n /** @type {Processor['freeze']} */\n function freeze() {\n if (frozen) {\n return processor\n }\n\n while (++freezeIndex < attachers.length) {\n const [attacher, ...options] = attachers[freezeIndex]\n\n if (options[0] === false) {\n continue\n }\n\n if (options[0] === true) {\n options[0] = undefined\n }\n\n /** @type {Transformer|void} */\n const transformer = attacher.call(processor, ...options)\n\n if (typeof transformer === 'function') {\n transformers.use(transformer)\n }\n }\n\n frozen = true\n freezeIndex = Number.POSITIVE_INFINITY\n\n return processor\n }\n\n /**\n * @param {Pluggable|null|undefined} [value]\n * @param {...unknown} options\n * @returns {Processor}\n */\n function use(value, ...options) {\n /** @type {Record|undefined} */\n let settings\n\n assertUnfrozen('use', frozen)\n\n if (value === null || value === undefined) {\n // Empty.\n } else if (typeof value === 'function') {\n addPlugin(value, ...options)\n } else if (typeof value === 'object') {\n if (Array.isArray(value)) {\n addList(value)\n } else {\n addPreset(value)\n }\n } else {\n throw new TypeError('Expected usable value, not `' + value + '`')\n }\n\n if (settings) {\n namespace.settings = Object.assign(namespace.settings || {}, settings)\n }\n\n return processor\n\n /**\n * @param {import('..').Pluggable} value\n * @returns {void}\n */\n function add(value) {\n if (typeof value === 'function') {\n addPlugin(value)\n } else if (typeof value === 'object') {\n if (Array.isArray(value)) {\n const [plugin, ...options] = value\n addPlugin(plugin, ...options)\n } else {\n addPreset(value)\n }\n } else {\n throw new TypeError('Expected usable value, not `' + value + '`')\n }\n }\n\n /**\n * @param {Preset} result\n * @returns {void}\n */\n function addPreset(result) {\n addList(result.plugins)\n\n if (result.settings) {\n settings = Object.assign(settings || {}, result.settings)\n }\n }\n\n /**\n * @param {PluggableList|null|undefined} [plugins]\n * @returns {void}\n */\n function addList(plugins) {\n let index = -1\n\n if (plugins === null || plugins === undefined) {\n // Empty.\n } else if (Array.isArray(plugins)) {\n while (++index < plugins.length) {\n const thing = plugins[index]\n add(thing)\n }\n } else {\n throw new TypeError('Expected a list of plugins, not `' + plugins + '`')\n }\n }\n\n /**\n * @param {Plugin} plugin\n * @param {...unknown} [value]\n * @returns {void}\n */\n function addPlugin(plugin, value) {\n let index = -1\n /** @type {Processor['attachers'][number]|undefined} */\n let entry\n\n while (++index < attachers.length) {\n if (attachers[index][0] === plugin) {\n entry = attachers[index]\n break\n }\n }\n\n if (entry) {\n if (isPlainObj(entry[1]) && isPlainObj(value)) {\n value = extend(true, entry[1], value)\n }\n\n entry[1] = value\n } else {\n // @ts-expect-error: fine.\n attachers.push([...arguments])\n }\n }\n }\n\n /** @type {Processor['parse']} */\n function parse(doc) {\n processor.freeze()\n const file = vfile(doc)\n const Parser = processor.Parser\n assertParser('parse', Parser)\n\n if (newable(Parser, 'parse')) {\n // @ts-expect-error: `newable` checks this.\n return new Parser(String(file), file).parse()\n }\n\n // @ts-expect-error: `newable` checks this.\n return Parser(String(file), file) // eslint-disable-line new-cap\n }\n\n /** @type {Processor['stringify']} */\n function stringify(node, doc) {\n processor.freeze()\n const file = vfile(doc)\n const Compiler = processor.Compiler\n assertCompiler('stringify', Compiler)\n assertNode(node)\n\n if (newable(Compiler, 'compile')) {\n // @ts-expect-error: `newable` checks this.\n return new Compiler(node, file).compile()\n }\n\n // @ts-expect-error: `newable` checks this.\n return Compiler(node, file) // eslint-disable-line new-cap\n }\n\n /**\n * @param {Node} node\n * @param {VFileCompatible|RunCallback} [doc]\n * @param {RunCallback} [callback]\n * @returns {Promise|void}\n */\n function run(node, doc, callback) {\n assertNode(node)\n processor.freeze()\n\n if (!callback && typeof doc === 'function') {\n callback = doc\n doc = undefined\n }\n\n if (!callback) {\n return new Promise(executor)\n }\n\n executor(null, callback)\n\n /**\n * @param {null|((node: Node) => void)} resolve\n * @param {(error: Error) => void} reject\n * @returns {void}\n */\n function executor(resolve, reject) {\n // @ts-expect-error: `doc` can’t be a callback anymore, we checked.\n transformers.run(node, vfile(doc), done)\n\n /**\n * @param {Error|null} error\n * @param {Node} tree\n * @param {VFile} file\n * @returns {void}\n */\n function done(error, tree, file) {\n tree = tree || node\n if (error) {\n reject(error)\n } else if (resolve) {\n resolve(tree)\n } else {\n // @ts-expect-error: `callback` is defined if `resolve` is not.\n callback(null, tree, file)\n }\n }\n }\n }\n\n /** @type {Processor['runSync']} */\n function runSync(node, file) {\n /** @type {Node|undefined} */\n let result\n /** @type {boolean|undefined} */\n let complete\n\n processor.run(node, file, done)\n\n assertDone('runSync', 'run', complete)\n\n // @ts-expect-error: we either bailed on an error or have a tree.\n return result\n\n /**\n * @param {Error|null} [error]\n * @param {Node} [tree]\n * @returns {void}\n */\n function done(error, tree) {\n bail(error)\n result = tree\n complete = true\n }\n }\n\n /**\n * @param {VFileCompatible} doc\n * @param {ProcessCallback} [callback]\n * @returns {Promise|undefined}\n */\n function process(doc, callback) {\n processor.freeze()\n assertParser('process', processor.Parser)\n assertCompiler('process', processor.Compiler)\n\n if (!callback) {\n return new Promise(executor)\n }\n\n executor(null, callback)\n\n /**\n * @param {null|((file: VFile) => void)} resolve\n * @param {(error?: Error|null|undefined) => void} reject\n * @returns {void}\n */\n function executor(resolve, reject) {\n const file = vfile(doc)\n\n processor.run(processor.parse(file), file, (error, tree, file) => {\n if (error || !tree || !file) {\n done(error)\n } else {\n /** @type {unknown} */\n const result = processor.stringify(tree, file)\n\n if (result === undefined || result === null) {\n // Empty.\n } else if (looksLikeAVFileValue(result)) {\n file.value = result\n } else {\n file.result = result\n }\n\n done(error, file)\n }\n })\n\n /**\n * @param {Error|null|undefined} [error]\n * @param {VFile|undefined} [file]\n * @returns {void}\n */\n function done(error, file) {\n if (error || !file) {\n reject(error)\n } else if (resolve) {\n resolve(file)\n } else {\n // @ts-expect-error: `callback` is defined if `resolve` is not.\n callback(null, file)\n }\n }\n }\n }\n\n /** @type {Processor['processSync']} */\n function processSync(doc) {\n /** @type {boolean|undefined} */\n let complete\n\n processor.freeze()\n assertParser('processSync', processor.Parser)\n assertCompiler('processSync', processor.Compiler)\n\n const file = vfile(doc)\n\n processor.process(file, done)\n\n assertDone('processSync', 'process', complete)\n\n return file\n\n /**\n * @param {Error|null|undefined} [error]\n * @returns {void}\n */\n function done(error) {\n complete = true\n bail(error)\n }\n }\n}\n\n/**\n * Check if `value` is a constructor.\n *\n * @param {unknown} value\n * @param {string} name\n * @returns {boolean}\n */\nfunction newable(value, name) {\n return (\n typeof value === 'function' &&\n // Prototypes do exist.\n // type-coverage:ignore-next-line\n value.prototype &&\n // A function with keys in its prototype is probably a constructor.\n // Classes’ prototype methods are not enumerable, so we check if some value\n // exists in the prototype.\n // type-coverage:ignore-next-line\n (keys(value.prototype) || name in value.prototype)\n )\n}\n\n/**\n * Check if `value` is an object with keys.\n *\n * @param {Record} value\n * @returns {boolean}\n */\nfunction keys(value) {\n /** @type {string} */\n let key\n\n for (key in value) {\n if (own.call(value, key)) {\n return true\n }\n }\n\n return false\n}\n\n/**\n * Assert a parser is available.\n *\n * @param {string} name\n * @param {unknown} value\n * @returns {asserts value is Parser}\n */\nfunction assertParser(name, value) {\n if (typeof value !== 'function') {\n throw new TypeError('Cannot `' + name + '` without `Parser`')\n }\n}\n\n/**\n * Assert a compiler is available.\n *\n * @param {string} name\n * @param {unknown} value\n * @returns {asserts value is Compiler}\n */\nfunction assertCompiler(name, value) {\n if (typeof value !== 'function') {\n throw new TypeError('Cannot `' + name + '` without `Compiler`')\n }\n}\n\n/**\n * Assert the processor is not frozen.\n *\n * @param {string} name\n * @param {unknown} frozen\n * @returns {asserts frozen is false}\n */\nfunction assertUnfrozen(name, frozen) {\n if (frozen) {\n throw new Error(\n 'Cannot call `' +\n name +\n '` on a frozen processor.\\nCreate a new processor first, by calling it: use `processor()` instead of `processor`.'\n )\n }\n}\n\n/**\n * Assert `node` is a unist node.\n *\n * @param {unknown} node\n * @returns {asserts node is Node}\n */\nfunction assertNode(node) {\n // `isPlainObj` unfortunately uses `any` instead of `unknown`.\n // type-coverage:ignore-next-line\n if (!isPlainObj(node) || typeof node.type !== 'string') {\n throw new TypeError('Expected node, got `' + node + '`')\n // Fine.\n }\n}\n\n/**\n * Assert that `complete` is `true`.\n *\n * @param {string} name\n * @param {string} asyncName\n * @param {unknown} complete\n * @returns {asserts complete is true}\n */\nfunction assertDone(name, asyncName, complete) {\n if (!complete) {\n throw new Error(\n '`' + name + '` finished async. Use `' + asyncName + '` instead'\n )\n }\n}\n\n/**\n * @param {VFileCompatible} [value]\n * @returns {VFile}\n */\nfunction vfile(value) {\n return looksLikeAVFile(value) ? value : new VFile(value)\n}\n\n/**\n * @param {VFileCompatible} [value]\n * @returns {value is VFile}\n */\nfunction looksLikeAVFile(value) {\n return Boolean(\n value &&\n typeof value === 'object' &&\n 'message' in value &&\n 'messages' in value\n )\n}\n\n/**\n * @param {unknown} [value]\n * @returns {value is VFileValue}\n */\nfunction looksLikeAVFileValue(value) {\n return typeof value === 'string' || isBuffer(value)\n}\n","// libs/split-on-macro.ts\nimport { match } from \"@unified-latex/unified-latex-util-match\";\n\n// libs/split-on-condition.ts\nfunction splitOnCondition(nodes, splitFunc = () => false, options) {\n if (!Array.isArray(nodes)) {\n throw new Error(`Can only split an Array, not ${nodes}`);\n }\n const { onlySplitOnFirstOccurrence = false } = options || {};\n const splitIndices = [];\n for (let i = 0; i < nodes.length; i++) {\n if (splitFunc(nodes[i])) {\n splitIndices.push(i);\n if (onlySplitOnFirstOccurrence) {\n break;\n }\n }\n }\n if (splitIndices.length === 0) {\n return { segments: [nodes], separators: [] };\n }\n let separators = splitIndices.map((i) => nodes[i]);\n let segments = splitIndices.map((splitEnd, i) => {\n const splitStart = i === 0 ? 0 : splitIndices[i - 1] + 1;\n return nodes.slice(splitStart, splitEnd);\n });\n segments.push(\n nodes.slice(splitIndices[splitIndices.length - 1] + 1, nodes.length)\n );\n return { segments, separators };\n}\n\n// libs/split-on-macro.ts\nfunction splitOnMacro(ast, macroName) {\n if (typeof macroName === \"string\") {\n macroName = [macroName];\n }\n if (!Array.isArray(macroName)) {\n throw new Error(\"Type coercion failed\");\n }\n const isSeparator = match.createMacroMatcher(macroName);\n const { segments, separators } = splitOnCondition(ast, isSeparator);\n return { segments, macros: separators };\n}\n\n// libs/unsplit-on-macro.ts\nfunction unsplitOnMacro({\n segments,\n macros\n}) {\n if (segments.length === 0) {\n console.warn(\"Trying to join zero segments\");\n return [];\n }\n if (segments.length !== macros.length + 1) {\n console.warn(\n \"Mismatch between lengths of macros and segments when trying to unsplit\"\n );\n }\n let ret = segments[0];\n for (let i = 0; i < macros.length; i++) {\n ret = ret.concat(macros[i]).concat(segments[i + 1]);\n }\n return ret;\n}\n\n// libs/array-join.ts\nfunction arrayJoin(array, sep) {\n return array.flatMap((item, i) => {\n if (i === 0) {\n return item;\n }\n if (Array.isArray(sep)) {\n return [...sep, ...item];\n } else {\n return [sep, ...item];\n }\n });\n}\nexport {\n arrayJoin,\n splitOnCondition,\n splitOnMacro,\n unsplitOnMacro\n};\n//# sourceMappingURL=index.js.map\n","// libs/replace-node.ts\nimport {\n visit\n} from \"@unified-latex/unified-latex-util-visit\";\nfunction replaceNode(ast, visitor) {\n visit(ast, {\n leave: (node, info) => {\n let replacement = visitor(node, info);\n if (typeof replacement === \"undefined\" || replacement === node) {\n return;\n }\n if (!info.containingArray || info.index == null) {\n throw new Error(\n \"Trying to replace node, but cannot find containing array\"\n );\n }\n if (replacement === null || Array.isArray(replacement) && replacement.length === 0) {\n info.containingArray.splice(info.index, 1);\n return info.index;\n }\n if (!Array.isArray(replacement)) {\n replacement = [replacement];\n }\n info.containingArray.splice(info.index, 1, ...replacement);\n return info.index + replacement.length;\n }\n });\n}\n\n// libs/unified-latex-streaming-command.ts\nimport { match as match5 } from \"@unified-latex/unified-latex-util-match\";\nimport { trimEnd as trimEnd3, trimStart as trimStart4 } from \"@unified-latex/unified-latex-util-trim\";\nimport { visit as visit2 } from \"@unified-latex/unified-latex-util-visit\";\n\n// libs/replace-streaming-command.ts\nimport { match as match4 } from \"@unified-latex/unified-latex-util-match\";\nimport {\n splitOnCondition,\n unsplitOnMacro\n} from \"@unified-latex/unified-latex-util-split\";\nimport {\n trim,\n trimEnd as trimEnd2,\n trimStart as trimStart3\n} from \"@unified-latex/unified-latex-util-trim\";\n\n// libs/utils/significant-node.ts\nimport { match } from \"@unified-latex/unified-latex-util-match\";\nfunction firstSignificantNode(nodes, parbreaksAreInsignificant) {\n const index = firstSignificantNodeIndex(nodes, parbreaksAreInsignificant);\n if (index == null) {\n return null;\n }\n return nodes[index];\n}\nfunction lastSignificantNode(nodes, parbreaksAreInsignificant) {\n const index = lastSignificantNodeIndex(nodes, parbreaksAreInsignificant);\n if (index == null) {\n return null;\n }\n return nodes[index];\n}\nfunction lastSignificantNodeIndex(nodes, parbreaksAreInsignificant) {\n for (let i = nodes.length - 1; i >= 0; i--) {\n const node = nodes[i];\n if (match.whitespace(node) || match.comment(node) || parbreaksAreInsignificant && match.parbreak(node)) {\n continue;\n }\n return i;\n }\n return void 0;\n}\nfunction firstSignificantNodeIndex(nodes, parbreaksAreInsignificant) {\n for (let i = 0; i < nodes.length; i++) {\n const node = nodes[i];\n if (match.whitespace(node) || match.comment(node) || parbreaksAreInsignificant && match.parbreak(node)) {\n continue;\n }\n return i;\n }\n return void 0;\n}\n\n// libs/utils/replace-streaming-command-in-array.ts\nimport { trimEnd, trimStart as trimStart2 } from \"@unified-latex/unified-latex-util-trim\";\n\n// libs/utils/join-without-excess-whitespace.ts\nimport { match as match2 } from \"@unified-latex/unified-latex-util-match\";\nimport { trimStart } from \"@unified-latex/unified-latex-util-trim\";\nfunction isSpaceLike(node) {\n return match2.whitespace(node) || match2.comment(node) && Boolean(node.leadingWhitespace);\n}\nfunction joinWithoutExcessWhitespace(head, tail) {\n if (tail.length === 0) {\n return;\n }\n if (head.length === 0) {\n head.push(...tail);\n return;\n }\n const headEnd = head[head.length - 1];\n const tailStart = tail[0];\n if (match2.whitespace(headEnd) && match2.whitespace(tailStart)) {\n head.push(...tail.slice(1));\n return;\n }\n if (!isSpaceLike(headEnd) || !isSpaceLike(tailStart)) {\n if (match2.whitespace(headEnd) && match2.comment(tailStart)) {\n const comment2 = {\n type: \"comment\",\n content: tailStart.content,\n sameline: true,\n leadingWhitespace: true\n };\n tail = tail.slice(1);\n trimStart(tail);\n head.pop();\n head.push(comment2, ...tail);\n return;\n }\n head.push(...tail);\n return;\n }\n if (match2.comment(headEnd) && match2.comment(tailStart)) {\n if (tailStart.leadingWhitespace || tailStart.sameline) {\n head.push(\n { type: \"comment\", content: tailStart.content },\n ...tail.slice(1)\n );\n return;\n }\n head.push(...tail);\n return;\n }\n let comment = match2.comment(headEnd) ? headEnd : tailStart;\n if (!match2.comment(comment)) {\n throw new Error(\n `Expected a comment but found ${JSON.stringify(comment)}`\n );\n }\n if (!comment.leadingWhitespace || !comment.sameline) {\n comment = {\n type: \"comment\",\n content: comment.content,\n leadingWhitespace: true,\n sameline: true\n };\n }\n head.pop();\n head.push(comment, ...tail.slice(1));\n}\n\n// libs/utils/wrap-significant-content.ts\nimport { match as match3 } from \"@unified-latex/unified-latex-util-match\";\nfunction wrapSignificantContent(content, wrapper) {\n let hoistUntil = 0;\n let hoistAfter = content.length;\n for (let i = 0; i < content.length; i++) {\n if (match3.whitespace(content[i]) || match3.comment(content[i])) {\n hoistUntil = i + 1;\n continue;\n }\n break;\n }\n for (let j = content.length - 1; j >= 0; j--) {\n if (match3.whitespace(content[j]) || match3.comment(content[j])) {\n hoistAfter = j;\n continue;\n }\n break;\n }\n if (hoistUntil === 0 && hoistAfter === content.length) {\n return ensureArray(wrapper(content));\n }\n const frontMatter = content.slice(0, hoistUntil);\n const middle = content.slice(hoistUntil, hoistAfter);\n const backMatter = content.slice(hoistAfter, content.length);\n return frontMatter.concat(wrapper(middle), backMatter);\n}\nfunction ensureArray(x) {\n if (!Array.isArray(x)) {\n return [x];\n }\n return x;\n}\n\n// libs/utils/replace-streaming-command-in-array.ts\nfunction replaceStreamingCommandInArray(nodes, isStreamingCommand, replacer) {\n while (nodes.length > 0 && isStreamingCommand(nodes[nodes.length - 1])) {\n nodes.pop();\n trimEnd(nodes);\n }\n const foundStreamingCommands = [];\n for (let i = nodes.length - 1; i >= 0; i--) {\n const node = nodes[i];\n if (isStreamingCommand(node)) {\n const wrapper = (content) => replacer(content, node);\n let tail = nodes.slice(i + 1);\n trimStart2(tail);\n tail = wrapSignificantContent(tail, wrapper);\n foundStreamingCommands.push(node);\n nodes.splice(i);\n joinWithoutExcessWhitespace(nodes, tail);\n }\n }\n return { foundStreamingCommands };\n}\n\n// libs/replace-streaming-command.ts\nfunction replaceStreamingCommandInGroup(group, isStreamingCommand, replacer, options) {\n const content = group.content;\n let popFromGroup = isStreamingCommand(firstSignificantNode(content));\n let innerProcessed = replaceStreamingCommand(\n content,\n isStreamingCommand,\n replacer,\n options\n );\n if (innerProcessed.length === 0) {\n return [];\n }\n if (popFromGroup) {\n return innerProcessed;\n } else {\n return [{ type: \"group\", content: innerProcessed }];\n }\n}\nfunction replaceStreamingCommand(ast, isStreamingCommand, replacer, options) {\n if (typeof isStreamingCommand !== \"function\") {\n throw new Error(\n `'isStreamingCommand' must be a function, not '${typeof isStreamingCommand}'`\n );\n }\n const {\n macrosThatBreakPars = [\n \"part\",\n \"chapter\",\n \"section\",\n \"subsection\",\n \"subsubsection\",\n \"vspace\",\n \"smallskip\",\n \"medskip\",\n \"bigskip\",\n \"hfill\"\n ],\n environmentsThatDontBreakPars = []\n } = options || {};\n let processedContent = [];\n if (match4.group(ast)) {\n processedContent = replaceStreamingCommandInGroup(\n ast,\n isStreamingCommand,\n replacer\n );\n }\n if (Array.isArray(ast)) {\n const nodes = ast;\n let scanIndex = nodes.length;\n let sliceIndex = scanIndex;\n while (scanIndex > 0 && (isStreamingCommand(nodes[scanIndex - 1]) || match4.whitespace(nodes[scanIndex - 1]))) {\n scanIndex--;\n if (isStreamingCommand(nodes[scanIndex])) {\n sliceIndex = scanIndex;\n }\n }\n if (sliceIndex !== nodes.length) {\n nodes.splice(sliceIndex);\n }\n const macroThatBreaks = match4.createMacroMatcher(macrosThatBreakPars);\n const envThatDoesntBreak = match4.createEnvironmentMatcher(\n environmentsThatDontBreakPars\n );\n const isPar = (node) => match4.parbreak(node) || match4.macro(node, \"par\") || macroThatBreaks(node) || match4.environment(node) && !envThatDoesntBreak(node) || node.type === \"displaymath\";\n const splitByPar = splitOnCondition(nodes, isPar);\n splitByPar.separators = splitByPar.separators.map(\n (sep) => match4.macro(sep, \"par\") ? { type: \"parbreak\" } : sep\n );\n const replacers = [];\n let segments = splitByPar.segments.map((segment) => {\n if (segment.length === 0) {\n return segment;\n }\n function applyAccumulatedReplacers(nodes2) {\n if (replacers.length === 0) {\n return nodes2;\n }\n return wrapSignificantContent(\n nodes2,\n composeReplacers(replacers)\n );\n }\n const { foundStreamingCommands } = replaceStreamingCommandInArray(\n segment,\n isStreamingCommand,\n replacer\n );\n const ret = applyAccumulatedReplacers(segment);\n foundStreamingCommands.forEach((macro) => {\n replacers.push((nodes2) => {\n const ret2 = replacer(nodes2, macro);\n if (!Array.isArray(ret2)) {\n return [ret2];\n }\n return ret2;\n });\n });\n return ret;\n });\n if (segments.length > 1) {\n segments.forEach((segment, i) => {\n if (i === 0) {\n trimEnd2(segment);\n } else if (i === segments.length - 1) {\n trimStart3(segment);\n } else {\n trim(segment);\n }\n });\n }\n processedContent = unsplitOnMacro({\n segments,\n macros: splitByPar.separators\n });\n }\n return processedContent;\n}\nfunction composeReplacers(replacers) {\n if (replacers.length === 0) {\n throw new Error(\"Cannot compose zero replacement functions\");\n }\n return (nodes) => {\n let ret = nodes;\n for (let i = 0; i < replacers.length; i++) {\n const func = replacers[i];\n ret = func(ret);\n }\n return ret;\n };\n}\n\n// libs/replace-node-during-visit.ts\nfunction replaceNodeDuringVisit(replacement, info) {\n const parent = info.parents[0];\n if (!parent) {\n throw new Error(`Cannot replace node: parent not found`);\n }\n const container = parent[info.key];\n if (!Array.isArray(container)) {\n throw new Error(`Cannot replace node: containing array not found`);\n }\n if (info.index == null) {\n throw new Error(`Cannot replace node: node index undefined`);\n }\n if (!Array.isArray(replacement)) {\n container[info.index] = replacement;\n } else {\n container.splice(info.index, 1, ...replacement);\n }\n}\n\n// libs/unified-latex-streaming-command.ts\nvar unifiedLatexReplaceStreamingCommands = function unifiedLatexReplaceStreamingCommands2(options) {\n const { replacers = {} } = options || {};\n const isReplaceable = match5.createMacroMatcher(replacers);\n return (tree) => {\n visit2(\n tree,\n (group, info) => {\n if (info.context.hasMathModeAncestor || !group.content.some(isReplaceable)) {\n return;\n }\n let fixed = replaceStreamingCommand(\n group,\n isReplaceable,\n (content, command) => {\n return replacers[command.content](content, command);\n }\n );\n if (!info.containingArray || info.index == null) {\n return;\n }\n const prevToken = info.containingArray[info.index - 1];\n const nextToken = info.containingArray[info.index + 1];\n if (match5.whitespaceLike(prevToken) && match5.whitespaceLike(fixed[0])) {\n trimStart4(fixed);\n }\n if (match5.whitespaceLike(nextToken) && match5.whitespaceLike(fixed[fixed.length - 1])) {\n trimEnd3(fixed);\n }\n replaceNodeDuringVisit(fixed, info);\n },\n { test: match5.group }\n );\n visit2(\n tree,\n (nodes, info) => {\n if (info.context.hasMathModeAncestor || !nodes.some(isReplaceable)) {\n return;\n }\n const replaced = replaceStreamingCommand(\n nodes,\n isReplaceable,\n (content, command) => {\n return replacers[command.content](content, command);\n }\n );\n if (replaced !== nodes) {\n nodes.length = 0;\n nodes.push(...replaced);\n }\n },\n { includeArrays: true, test: Array.isArray }\n );\n };\n};\nexport {\n firstSignificantNode,\n firstSignificantNodeIndex,\n lastSignificantNode,\n lastSignificantNodeIndex,\n replaceNode,\n replaceNodeDuringVisit,\n replaceStreamingCommand,\n replaceStreamingCommandInGroup,\n unifiedLatexReplaceStreamingCommands\n};\n//# sourceMappingURL=index.js.map\n","'use strict'\r\n\r\nmodule.exports = {\r\n\t\"aliceblue\": [240, 248, 255],\r\n\t\"antiquewhite\": [250, 235, 215],\r\n\t\"aqua\": [0, 255, 255],\r\n\t\"aquamarine\": [127, 255, 212],\r\n\t\"azure\": [240, 255, 255],\r\n\t\"beige\": [245, 245, 220],\r\n\t\"bisque\": [255, 228, 196],\r\n\t\"black\": [0, 0, 0],\r\n\t\"blanchedalmond\": [255, 235, 205],\r\n\t\"blue\": [0, 0, 255],\r\n\t\"blueviolet\": [138, 43, 226],\r\n\t\"brown\": [165, 42, 42],\r\n\t\"burlywood\": [222, 184, 135],\r\n\t\"cadetblue\": [95, 158, 160],\r\n\t\"chartreuse\": [127, 255, 0],\r\n\t\"chocolate\": [210, 105, 30],\r\n\t\"coral\": [255, 127, 80],\r\n\t\"cornflowerblue\": [100, 149, 237],\r\n\t\"cornsilk\": [255, 248, 220],\r\n\t\"crimson\": [220, 20, 60],\r\n\t\"cyan\": [0, 255, 255],\r\n\t\"darkblue\": [0, 0, 139],\r\n\t\"darkcyan\": [0, 139, 139],\r\n\t\"darkgoldenrod\": [184, 134, 11],\r\n\t\"darkgray\": [169, 169, 169],\r\n\t\"darkgreen\": [0, 100, 0],\r\n\t\"darkgrey\": [169, 169, 169],\r\n\t\"darkkhaki\": [189, 183, 107],\r\n\t\"darkmagenta\": [139, 0, 139],\r\n\t\"darkolivegreen\": [85, 107, 47],\r\n\t\"darkorange\": [255, 140, 0],\r\n\t\"darkorchid\": [153, 50, 204],\r\n\t\"darkred\": [139, 0, 0],\r\n\t\"darksalmon\": [233, 150, 122],\r\n\t\"darkseagreen\": [143, 188, 143],\r\n\t\"darkslateblue\": [72, 61, 139],\r\n\t\"darkslategray\": [47, 79, 79],\r\n\t\"darkslategrey\": [47, 79, 79],\r\n\t\"darkturquoise\": [0, 206, 209],\r\n\t\"darkviolet\": [148, 0, 211],\r\n\t\"deeppink\": [255, 20, 147],\r\n\t\"deepskyblue\": [0, 191, 255],\r\n\t\"dimgray\": [105, 105, 105],\r\n\t\"dimgrey\": [105, 105, 105],\r\n\t\"dodgerblue\": [30, 144, 255],\r\n\t\"firebrick\": [178, 34, 34],\r\n\t\"floralwhite\": [255, 250, 240],\r\n\t\"forestgreen\": [34, 139, 34],\r\n\t\"fuchsia\": [255, 0, 255],\r\n\t\"gainsboro\": [220, 220, 220],\r\n\t\"ghostwhite\": [248, 248, 255],\r\n\t\"gold\": [255, 215, 0],\r\n\t\"goldenrod\": [218, 165, 32],\r\n\t\"gray\": [128, 128, 128],\r\n\t\"green\": [0, 128, 0],\r\n\t\"greenyellow\": [173, 255, 47],\r\n\t\"grey\": [128, 128, 128],\r\n\t\"honeydew\": [240, 255, 240],\r\n\t\"hotpink\": [255, 105, 180],\r\n\t\"indianred\": [205, 92, 92],\r\n\t\"indigo\": [75, 0, 130],\r\n\t\"ivory\": [255, 255, 240],\r\n\t\"khaki\": [240, 230, 140],\r\n\t\"lavender\": [230, 230, 250],\r\n\t\"lavenderblush\": [255, 240, 245],\r\n\t\"lawngreen\": [124, 252, 0],\r\n\t\"lemonchiffon\": [255, 250, 205],\r\n\t\"lightblue\": [173, 216, 230],\r\n\t\"lightcoral\": [240, 128, 128],\r\n\t\"lightcyan\": [224, 255, 255],\r\n\t\"lightgoldenrodyellow\": [250, 250, 210],\r\n\t\"lightgray\": [211, 211, 211],\r\n\t\"lightgreen\": [144, 238, 144],\r\n\t\"lightgrey\": [211, 211, 211],\r\n\t\"lightpink\": [255, 182, 193],\r\n\t\"lightsalmon\": [255, 160, 122],\r\n\t\"lightseagreen\": [32, 178, 170],\r\n\t\"lightskyblue\": [135, 206, 250],\r\n\t\"lightslategray\": [119, 136, 153],\r\n\t\"lightslategrey\": [119, 136, 153],\r\n\t\"lightsteelblue\": [176, 196, 222],\r\n\t\"lightyellow\": [255, 255, 224],\r\n\t\"lime\": [0, 255, 0],\r\n\t\"limegreen\": [50, 205, 50],\r\n\t\"linen\": [250, 240, 230],\r\n\t\"magenta\": [255, 0, 255],\r\n\t\"maroon\": [128, 0, 0],\r\n\t\"mediumaquamarine\": [102, 205, 170],\r\n\t\"mediumblue\": [0, 0, 205],\r\n\t\"mediumorchid\": [186, 85, 211],\r\n\t\"mediumpurple\": [147, 112, 219],\r\n\t\"mediumseagreen\": [60, 179, 113],\r\n\t\"mediumslateblue\": [123, 104, 238],\r\n\t\"mediumspringgreen\": [0, 250, 154],\r\n\t\"mediumturquoise\": [72, 209, 204],\r\n\t\"mediumvioletred\": [199, 21, 133],\r\n\t\"midnightblue\": [25, 25, 112],\r\n\t\"mintcream\": [245, 255, 250],\r\n\t\"mistyrose\": [255, 228, 225],\r\n\t\"moccasin\": [255, 228, 181],\r\n\t\"navajowhite\": [255, 222, 173],\r\n\t\"navy\": [0, 0, 128],\r\n\t\"oldlace\": [253, 245, 230],\r\n\t\"olive\": [128, 128, 0],\r\n\t\"olivedrab\": [107, 142, 35],\r\n\t\"orange\": [255, 165, 0],\r\n\t\"orangered\": [255, 69, 0],\r\n\t\"orchid\": [218, 112, 214],\r\n\t\"palegoldenrod\": [238, 232, 170],\r\n\t\"palegreen\": [152, 251, 152],\r\n\t\"paleturquoise\": [175, 238, 238],\r\n\t\"palevioletred\": [219, 112, 147],\r\n\t\"papayawhip\": [255, 239, 213],\r\n\t\"peachpuff\": [255, 218, 185],\r\n\t\"peru\": [205, 133, 63],\r\n\t\"pink\": [255, 192, 203],\r\n\t\"plum\": [221, 160, 221],\r\n\t\"powderblue\": [176, 224, 230],\r\n\t\"purple\": [128, 0, 128],\r\n\t\"rebeccapurple\": [102, 51, 153],\r\n\t\"red\": [255, 0, 0],\r\n\t\"rosybrown\": [188, 143, 143],\r\n\t\"royalblue\": [65, 105, 225],\r\n\t\"saddlebrown\": [139, 69, 19],\r\n\t\"salmon\": [250, 128, 114],\r\n\t\"sandybrown\": [244, 164, 96],\r\n\t\"seagreen\": [46, 139, 87],\r\n\t\"seashell\": [255, 245, 238],\r\n\t\"sienna\": [160, 82, 45],\r\n\t\"silver\": [192, 192, 192],\r\n\t\"skyblue\": [135, 206, 235],\r\n\t\"slateblue\": [106, 90, 205],\r\n\t\"slategray\": [112, 128, 144],\r\n\t\"slategrey\": [112, 128, 144],\r\n\t\"snow\": [255, 250, 250],\r\n\t\"springgreen\": [0, 255, 127],\r\n\t\"steelblue\": [70, 130, 180],\r\n\t\"tan\": [210, 180, 140],\r\n\t\"teal\": [0, 128, 128],\r\n\t\"thistle\": [216, 191, 216],\r\n\t\"tomato\": [255, 99, 71],\r\n\t\"turquoise\": [64, 224, 208],\r\n\t\"violet\": [238, 130, 238],\r\n\t\"wheat\": [245, 222, 179],\r\n\t\"white\": [255, 255, 255],\r\n\t\"whitesmoke\": [245, 245, 245],\r\n\t\"yellow\": [255, 255, 0],\r\n\t\"yellowgreen\": [154, 205, 50]\r\n};\r\n","module.exports = function isArrayish(obj) {\n\tif (!obj || typeof obj === 'string') {\n\t\treturn false;\n\t}\n\n\treturn obj instanceof Array || Array.isArray(obj) ||\n\t\t(obj.length >= 0 && (obj.splice instanceof Function ||\n\t\t\t(Object.getOwnPropertyDescriptor(obj, (obj.length - 1)) && obj.constructor.name !== 'String')));\n};\n","'use strict';\n\nvar isArrayish = require('is-arrayish');\n\nvar concat = Array.prototype.concat;\nvar slice = Array.prototype.slice;\n\nvar swizzle = module.exports = function swizzle(args) {\n\tvar results = [];\n\n\tfor (var i = 0, len = args.length; i < len; i++) {\n\t\tvar arg = args[i];\n\n\t\tif (isArrayish(arg)) {\n\t\t\t// http://jsperf.com/javascript-array-concat-vs-push/98\n\t\t\tresults = concat.call(results, slice.call(arg));\n\t\t} else {\n\t\t\tresults.push(arg);\n\t\t}\n\t}\n\n\treturn results;\n};\n\nswizzle.wrap = function (fn) {\n\treturn function () {\n\t\treturn fn(swizzle(arguments));\n\t};\n};\n","/* MIT license */\nvar colorNames = require('color-name');\nvar swizzle = require('simple-swizzle');\nvar hasOwnProperty = Object.hasOwnProperty;\n\nvar reverseNames = Object.create(null);\n\n// create a list of reverse color names\nfor (var name in colorNames) {\n\tif (hasOwnProperty.call(colorNames, name)) {\n\t\treverseNames[colorNames[name]] = name;\n\t}\n}\n\nvar cs = module.exports = {\n\tto: {},\n\tget: {}\n};\n\ncs.get = function (string) {\n\tvar prefix = string.substring(0, 3).toLowerCase();\n\tvar val;\n\tvar model;\n\tswitch (prefix) {\n\t\tcase 'hsl':\n\t\t\tval = cs.get.hsl(string);\n\t\t\tmodel = 'hsl';\n\t\t\tbreak;\n\t\tcase 'hwb':\n\t\t\tval = cs.get.hwb(string);\n\t\t\tmodel = 'hwb';\n\t\t\tbreak;\n\t\tdefault:\n\t\t\tval = cs.get.rgb(string);\n\t\t\tmodel = 'rgb';\n\t\t\tbreak;\n\t}\n\n\tif (!val) {\n\t\treturn null;\n\t}\n\n\treturn {model: model, value: val};\n};\n\ncs.get.rgb = function (string) {\n\tif (!string) {\n\t\treturn null;\n\t}\n\n\tvar abbr = /^#([a-f0-9]{3,4})$/i;\n\tvar hex = /^#([a-f0-9]{6})([a-f0-9]{2})?$/i;\n\tvar rgba = /^rgba?\\(\\s*([+-]?\\d+)(?=[\\s,])\\s*(?:,\\s*)?([+-]?\\d+)(?=[\\s,])\\s*(?:,\\s*)?([+-]?\\d+)\\s*(?:[,|\\/]\\s*([+-]?[\\d\\.]+)(%?)\\s*)?\\)$/;\n\tvar per = /^rgba?\\(\\s*([+-]?[\\d\\.]+)\\%\\s*,?\\s*([+-]?[\\d\\.]+)\\%\\s*,?\\s*([+-]?[\\d\\.]+)\\%\\s*(?:[,|\\/]\\s*([+-]?[\\d\\.]+)(%?)\\s*)?\\)$/;\n\tvar keyword = /^(\\w+)$/;\n\n\tvar rgb = [0, 0, 0, 1];\n\tvar match;\n\tvar i;\n\tvar hexAlpha;\n\n\tif (match = string.match(hex)) {\n\t\thexAlpha = match[2];\n\t\tmatch = match[1];\n\n\t\tfor (i = 0; i < 3; i++) {\n\t\t\t// https://jsperf.com/slice-vs-substr-vs-substring-methods-long-string/19\n\t\t\tvar i2 = i * 2;\n\t\t\trgb[i] = parseInt(match.slice(i2, i2 + 2), 16);\n\t\t}\n\n\t\tif (hexAlpha) {\n\t\t\trgb[3] = parseInt(hexAlpha, 16) / 255;\n\t\t}\n\t} else if (match = string.match(abbr)) {\n\t\tmatch = match[1];\n\t\thexAlpha = match[3];\n\n\t\tfor (i = 0; i < 3; i++) {\n\t\t\trgb[i] = parseInt(match[i] + match[i], 16);\n\t\t}\n\n\t\tif (hexAlpha) {\n\t\t\trgb[3] = parseInt(hexAlpha + hexAlpha, 16) / 255;\n\t\t}\n\t} else if (match = string.match(rgba)) {\n\t\tfor (i = 0; i < 3; i++) {\n\t\t\trgb[i] = parseInt(match[i + 1], 0);\n\t\t}\n\n\t\tif (match[4]) {\n\t\t\tif (match[5]) {\n\t\t\t\trgb[3] = parseFloat(match[4]) * 0.01;\n\t\t\t} else {\n\t\t\t\trgb[3] = parseFloat(match[4]);\n\t\t\t}\n\t\t}\n\t} else if (match = string.match(per)) {\n\t\tfor (i = 0; i < 3; i++) {\n\t\t\trgb[i] = Math.round(parseFloat(match[i + 1]) * 2.55);\n\t\t}\n\n\t\tif (match[4]) {\n\t\t\tif (match[5]) {\n\t\t\t\trgb[3] = parseFloat(match[4]) * 0.01;\n\t\t\t} else {\n\t\t\t\trgb[3] = parseFloat(match[4]);\n\t\t\t}\n\t\t}\n\t} else if (match = string.match(keyword)) {\n\t\tif (match[1] === 'transparent') {\n\t\t\treturn [0, 0, 0, 0];\n\t\t}\n\n\t\tif (!hasOwnProperty.call(colorNames, match[1])) {\n\t\t\treturn null;\n\t\t}\n\n\t\trgb = colorNames[match[1]];\n\t\trgb[3] = 1;\n\n\t\treturn rgb;\n\t} else {\n\t\treturn null;\n\t}\n\n\tfor (i = 0; i < 3; i++) {\n\t\trgb[i] = clamp(rgb[i], 0, 255);\n\t}\n\trgb[3] = clamp(rgb[3], 0, 1);\n\n\treturn rgb;\n};\n\ncs.get.hsl = function (string) {\n\tif (!string) {\n\t\treturn null;\n\t}\n\n\tvar hsl = /^hsla?\\(\\s*([+-]?(?:\\d{0,3}\\.)?\\d+)(?:deg)?\\s*,?\\s*([+-]?[\\d\\.]+)%\\s*,?\\s*([+-]?[\\d\\.]+)%\\s*(?:[,|\\/]\\s*([+-]?(?=\\.\\d|\\d)(?:0|[1-9]\\d*)?(?:\\.\\d*)?(?:[eE][+-]?\\d+)?)\\s*)?\\)$/;\n\tvar match = string.match(hsl);\n\n\tif (match) {\n\t\tvar alpha = parseFloat(match[4]);\n\t\tvar h = ((parseFloat(match[1]) % 360) + 360) % 360;\n\t\tvar s = clamp(parseFloat(match[2]), 0, 100);\n\t\tvar l = clamp(parseFloat(match[3]), 0, 100);\n\t\tvar a = clamp(isNaN(alpha) ? 1 : alpha, 0, 1);\n\n\t\treturn [h, s, l, a];\n\t}\n\n\treturn null;\n};\n\ncs.get.hwb = function (string) {\n\tif (!string) {\n\t\treturn null;\n\t}\n\n\tvar hwb = /^hwb\\(\\s*([+-]?\\d{0,3}(?:\\.\\d+)?)(?:deg)?\\s*,\\s*([+-]?[\\d\\.]+)%\\s*,\\s*([+-]?[\\d\\.]+)%\\s*(?:,\\s*([+-]?(?=\\.\\d|\\d)(?:0|[1-9]\\d*)?(?:\\.\\d*)?(?:[eE][+-]?\\d+)?)\\s*)?\\)$/;\n\tvar match = string.match(hwb);\n\n\tif (match) {\n\t\tvar alpha = parseFloat(match[4]);\n\t\tvar h = ((parseFloat(match[1]) % 360) + 360) % 360;\n\t\tvar w = clamp(parseFloat(match[2]), 0, 100);\n\t\tvar b = clamp(parseFloat(match[3]), 0, 100);\n\t\tvar a = clamp(isNaN(alpha) ? 1 : alpha, 0, 1);\n\t\treturn [h, w, b, a];\n\t}\n\n\treturn null;\n};\n\ncs.to.hex = function () {\n\tvar rgba = swizzle(arguments);\n\n\treturn (\n\t\t'#' +\n\t\thexDouble(rgba[0]) +\n\t\thexDouble(rgba[1]) +\n\t\thexDouble(rgba[2]) +\n\t\t(rgba[3] < 1\n\t\t\t? (hexDouble(Math.round(rgba[3] * 255)))\n\t\t\t: '')\n\t);\n};\n\ncs.to.rgb = function () {\n\tvar rgba = swizzle(arguments);\n\n\treturn rgba.length < 4 || rgba[3] === 1\n\t\t? 'rgb(' + Math.round(rgba[0]) + ', ' + Math.round(rgba[1]) + ', ' + Math.round(rgba[2]) + ')'\n\t\t: 'rgba(' + Math.round(rgba[0]) + ', ' + Math.round(rgba[1]) + ', ' + Math.round(rgba[2]) + ', ' + rgba[3] + ')';\n};\n\ncs.to.rgb.percent = function () {\n\tvar rgba = swizzle(arguments);\n\n\tvar r = Math.round(rgba[0] / 255 * 100);\n\tvar g = Math.round(rgba[1] / 255 * 100);\n\tvar b = Math.round(rgba[2] / 255 * 100);\n\n\treturn rgba.length < 4 || rgba[3] === 1\n\t\t? 'rgb(' + r + '%, ' + g + '%, ' + b + '%)'\n\t\t: 'rgba(' + r + '%, ' + g + '%, ' + b + '%, ' + rgba[3] + ')';\n};\n\ncs.to.hsl = function () {\n\tvar hsla = swizzle(arguments);\n\treturn hsla.length < 4 || hsla[3] === 1\n\t\t? 'hsl(' + hsla[0] + ', ' + hsla[1] + '%, ' + hsla[2] + '%)'\n\t\t: 'hsla(' + hsla[0] + ', ' + hsla[1] + '%, ' + hsla[2] + '%, ' + hsla[3] + ')';\n};\n\n// hwb is a bit different than rgb(a) & hsl(a) since there is no alpha specific syntax\n// (hwb have alpha optional & 1 is default value)\ncs.to.hwb = function () {\n\tvar hwba = swizzle(arguments);\n\n\tvar a = '';\n\tif (hwba.length >= 4 && hwba[3] !== 1) {\n\t\ta = ', ' + hwba[3];\n\t}\n\n\treturn 'hwb(' + hwba[0] + ', ' + hwba[1] + '%, ' + hwba[2] + '%' + a + ')';\n};\n\ncs.to.keyword = function (rgb) {\n\treturn reverseNames[rgb.slice(0, 3)];\n};\n\n// helpers\nfunction clamp(num, min, max) {\n\treturn Math.min(Math.max(min, num), max);\n}\n\nfunction hexDouble(num) {\n\tvar str = Math.round(num).toString(16).toUpperCase();\n\treturn (str.length < 2) ? '0' + str : str;\n}\n","/* MIT license */\n/* eslint-disable no-mixed-operators */\nconst cssKeywords = require('color-name');\n\n// NOTE: conversions should only return primitive values (i.e. arrays, or\n// values that give correct `typeof` results).\n// do not use box values types (i.e. Number(), String(), etc.)\n\nconst reverseKeywords = {};\nfor (const key of Object.keys(cssKeywords)) {\n\treverseKeywords[cssKeywords[key]] = key;\n}\n\nconst convert = {\n\trgb: {channels: 3, labels: 'rgb'},\n\thsl: {channels: 3, labels: 'hsl'},\n\thsv: {channels: 3, labels: 'hsv'},\n\thwb: {channels: 3, labels: 'hwb'},\n\tcmyk: {channels: 4, labels: 'cmyk'},\n\txyz: {channels: 3, labels: 'xyz'},\n\tlab: {channels: 3, labels: 'lab'},\n\tlch: {channels: 3, labels: 'lch'},\n\thex: {channels: 1, labels: ['hex']},\n\tkeyword: {channels: 1, labels: ['keyword']},\n\tansi16: {channels: 1, labels: ['ansi16']},\n\tansi256: {channels: 1, labels: ['ansi256']},\n\thcg: {channels: 3, labels: ['h', 'c', 'g']},\n\tapple: {channels: 3, labels: ['r16', 'g16', 'b16']},\n\tgray: {channels: 1, labels: ['gray']}\n};\n\nmodule.exports = convert;\n\n// Hide .channels and .labels properties\nfor (const model of Object.keys(convert)) {\n\tif (!('channels' in convert[model])) {\n\t\tthrow new Error('missing channels property: ' + model);\n\t}\n\n\tif (!('labels' in convert[model])) {\n\t\tthrow new Error('missing channel labels property: ' + model);\n\t}\n\n\tif (convert[model].labels.length !== convert[model].channels) {\n\t\tthrow new Error('channel and label counts mismatch: ' + model);\n\t}\n\n\tconst {channels, labels} = convert[model];\n\tdelete convert[model].channels;\n\tdelete convert[model].labels;\n\tObject.defineProperty(convert[model], 'channels', {value: channels});\n\tObject.defineProperty(convert[model], 'labels', {value: labels});\n}\n\nconvert.rgb.hsl = function (rgb) {\n\tconst r = rgb[0] / 255;\n\tconst g = rgb[1] / 255;\n\tconst b = rgb[2] / 255;\n\tconst min = Math.min(r, g, b);\n\tconst max = Math.max(r, g, b);\n\tconst delta = max - min;\n\tlet h;\n\tlet s;\n\n\tif (max === min) {\n\t\th = 0;\n\t} else if (r === max) {\n\t\th = (g - b) / delta;\n\t} else if (g === max) {\n\t\th = 2 + (b - r) / delta;\n\t} else if (b === max) {\n\t\th = 4 + (r - g) / delta;\n\t}\n\n\th = Math.min(h * 60, 360);\n\n\tif (h < 0) {\n\t\th += 360;\n\t}\n\n\tconst l = (min + max) / 2;\n\n\tif (max === min) {\n\t\ts = 0;\n\t} else if (l <= 0.5) {\n\t\ts = delta / (max + min);\n\t} else {\n\t\ts = delta / (2 - max - min);\n\t}\n\n\treturn [h, s * 100, l * 100];\n};\n\nconvert.rgb.hsv = function (rgb) {\n\tlet rdif;\n\tlet gdif;\n\tlet bdif;\n\tlet h;\n\tlet s;\n\n\tconst r = rgb[0] / 255;\n\tconst g = rgb[1] / 255;\n\tconst b = rgb[2] / 255;\n\tconst v = Math.max(r, g, b);\n\tconst diff = v - Math.min(r, g, b);\n\tconst diffc = function (c) {\n\t\treturn (v - c) / 6 / diff + 1 / 2;\n\t};\n\n\tif (diff === 0) {\n\t\th = 0;\n\t\ts = 0;\n\t} else {\n\t\ts = diff / v;\n\t\trdif = diffc(r);\n\t\tgdif = diffc(g);\n\t\tbdif = diffc(b);\n\n\t\tif (r === v) {\n\t\t\th = bdif - gdif;\n\t\t} else if (g === v) {\n\t\t\th = (1 / 3) + rdif - bdif;\n\t\t} else if (b === v) {\n\t\t\th = (2 / 3) + gdif - rdif;\n\t\t}\n\n\t\tif (h < 0) {\n\t\t\th += 1;\n\t\t} else if (h > 1) {\n\t\t\th -= 1;\n\t\t}\n\t}\n\n\treturn [\n\t\th * 360,\n\t\ts * 100,\n\t\tv * 100\n\t];\n};\n\nconvert.rgb.hwb = function (rgb) {\n\tconst r = rgb[0];\n\tconst g = rgb[1];\n\tlet b = rgb[2];\n\tconst h = convert.rgb.hsl(rgb)[0];\n\tconst w = 1 / 255 * Math.min(r, Math.min(g, b));\n\n\tb = 1 - 1 / 255 * Math.max(r, Math.max(g, b));\n\n\treturn [h, w * 100, b * 100];\n};\n\nconvert.rgb.cmyk = function (rgb) {\n\tconst r = rgb[0] / 255;\n\tconst g = rgb[1] / 255;\n\tconst b = rgb[2] / 255;\n\n\tconst k = Math.min(1 - r, 1 - g, 1 - b);\n\tconst c = (1 - r - k) / (1 - k) || 0;\n\tconst m = (1 - g - k) / (1 - k) || 0;\n\tconst y = (1 - b - k) / (1 - k) || 0;\n\n\treturn [c * 100, m * 100, y * 100, k * 100];\n};\n\nfunction comparativeDistance(x, y) {\n\t/*\n\t\tSee https://en.m.wikipedia.org/wiki/Euclidean_distance#Squared_Euclidean_distance\n\t*/\n\treturn (\n\t\t((x[0] - y[0]) ** 2) +\n\t\t((x[1] - y[1]) ** 2) +\n\t\t((x[2] - y[2]) ** 2)\n\t);\n}\n\nconvert.rgb.keyword = function (rgb) {\n\tconst reversed = reverseKeywords[rgb];\n\tif (reversed) {\n\t\treturn reversed;\n\t}\n\n\tlet currentClosestDistance = Infinity;\n\tlet currentClosestKeyword;\n\n\tfor (const keyword of Object.keys(cssKeywords)) {\n\t\tconst value = cssKeywords[keyword];\n\n\t\t// Compute comparative distance\n\t\tconst distance = comparativeDistance(rgb, value);\n\n\t\t// Check if its less, if so set as closest\n\t\tif (distance < currentClosestDistance) {\n\t\t\tcurrentClosestDistance = distance;\n\t\t\tcurrentClosestKeyword = keyword;\n\t\t}\n\t}\n\n\treturn currentClosestKeyword;\n};\n\nconvert.keyword.rgb = function (keyword) {\n\treturn cssKeywords[keyword];\n};\n\nconvert.rgb.xyz = function (rgb) {\n\tlet r = rgb[0] / 255;\n\tlet g = rgb[1] / 255;\n\tlet b = rgb[2] / 255;\n\n\t// Assume sRGB\n\tr = r > 0.04045 ? (((r + 0.055) / 1.055) ** 2.4) : (r / 12.92);\n\tg = g > 0.04045 ? (((g + 0.055) / 1.055) ** 2.4) : (g / 12.92);\n\tb = b > 0.04045 ? (((b + 0.055) / 1.055) ** 2.4) : (b / 12.92);\n\n\tconst x = (r * 0.4124) + (g * 0.3576) + (b * 0.1805);\n\tconst y = (r * 0.2126) + (g * 0.7152) + (b * 0.0722);\n\tconst z = (r * 0.0193) + (g * 0.1192) + (b * 0.9505);\n\n\treturn [x * 100, y * 100, z * 100];\n};\n\nconvert.rgb.lab = function (rgb) {\n\tconst xyz = convert.rgb.xyz(rgb);\n\tlet x = xyz[0];\n\tlet y = xyz[1];\n\tlet z = xyz[2];\n\n\tx /= 95.047;\n\ty /= 100;\n\tz /= 108.883;\n\n\tx = x > 0.008856 ? (x ** (1 / 3)) : (7.787 * x) + (16 / 116);\n\ty = y > 0.008856 ? (y ** (1 / 3)) : (7.787 * y) + (16 / 116);\n\tz = z > 0.008856 ? (z ** (1 / 3)) : (7.787 * z) + (16 / 116);\n\n\tconst l = (116 * y) - 16;\n\tconst a = 500 * (x - y);\n\tconst b = 200 * (y - z);\n\n\treturn [l, a, b];\n};\n\nconvert.hsl.rgb = function (hsl) {\n\tconst h = hsl[0] / 360;\n\tconst s = hsl[1] / 100;\n\tconst l = hsl[2] / 100;\n\tlet t2;\n\tlet t3;\n\tlet val;\n\n\tif (s === 0) {\n\t\tval = l * 255;\n\t\treturn [val, val, val];\n\t}\n\n\tif (l < 0.5) {\n\t\tt2 = l * (1 + s);\n\t} else {\n\t\tt2 = l + s - l * s;\n\t}\n\n\tconst t1 = 2 * l - t2;\n\n\tconst rgb = [0, 0, 0];\n\tfor (let i = 0; i < 3; i++) {\n\t\tt3 = h + 1 / 3 * -(i - 1);\n\t\tif (t3 < 0) {\n\t\t\tt3++;\n\t\t}\n\n\t\tif (t3 > 1) {\n\t\t\tt3--;\n\t\t}\n\n\t\tif (6 * t3 < 1) {\n\t\t\tval = t1 + (t2 - t1) * 6 * t3;\n\t\t} else if (2 * t3 < 1) {\n\t\t\tval = t2;\n\t\t} else if (3 * t3 < 2) {\n\t\t\tval = t1 + (t2 - t1) * (2 / 3 - t3) * 6;\n\t\t} else {\n\t\t\tval = t1;\n\t\t}\n\n\t\trgb[i] = val * 255;\n\t}\n\n\treturn rgb;\n};\n\nconvert.hsl.hsv = function (hsl) {\n\tconst h = hsl[0];\n\tlet s = hsl[1] / 100;\n\tlet l = hsl[2] / 100;\n\tlet smin = s;\n\tconst lmin = Math.max(l, 0.01);\n\n\tl *= 2;\n\ts *= (l <= 1) ? l : 2 - l;\n\tsmin *= lmin <= 1 ? lmin : 2 - lmin;\n\tconst v = (l + s) / 2;\n\tconst sv = l === 0 ? (2 * smin) / (lmin + smin) : (2 * s) / (l + s);\n\n\treturn [h, sv * 100, v * 100];\n};\n\nconvert.hsv.rgb = function (hsv) {\n\tconst h = hsv[0] / 60;\n\tconst s = hsv[1] / 100;\n\tlet v = hsv[2] / 100;\n\tconst hi = Math.floor(h) % 6;\n\n\tconst f = h - Math.floor(h);\n\tconst p = 255 * v * (1 - s);\n\tconst q = 255 * v * (1 - (s * f));\n\tconst t = 255 * v * (1 - (s * (1 - f)));\n\tv *= 255;\n\n\tswitch (hi) {\n\t\tcase 0:\n\t\t\treturn [v, t, p];\n\t\tcase 1:\n\t\t\treturn [q, v, p];\n\t\tcase 2:\n\t\t\treturn [p, v, t];\n\t\tcase 3:\n\t\t\treturn [p, q, v];\n\t\tcase 4:\n\t\t\treturn [t, p, v];\n\t\tcase 5:\n\t\t\treturn [v, p, q];\n\t}\n};\n\nconvert.hsv.hsl = function (hsv) {\n\tconst h = hsv[0];\n\tconst s = hsv[1] / 100;\n\tconst v = hsv[2] / 100;\n\tconst vmin = Math.max(v, 0.01);\n\tlet sl;\n\tlet l;\n\n\tl = (2 - s) * v;\n\tconst lmin = (2 - s) * vmin;\n\tsl = s * vmin;\n\tsl /= (lmin <= 1) ? lmin : 2 - lmin;\n\tsl = sl || 0;\n\tl /= 2;\n\n\treturn [h, sl * 100, l * 100];\n};\n\n// http://dev.w3.org/csswg/css-color/#hwb-to-rgb\nconvert.hwb.rgb = function (hwb) {\n\tconst h = hwb[0] / 360;\n\tlet wh = hwb[1] / 100;\n\tlet bl = hwb[2] / 100;\n\tconst ratio = wh + bl;\n\tlet f;\n\n\t// Wh + bl cant be > 1\n\tif (ratio > 1) {\n\t\twh /= ratio;\n\t\tbl /= ratio;\n\t}\n\n\tconst i = Math.floor(6 * h);\n\tconst v = 1 - bl;\n\tf = 6 * h - i;\n\n\tif ((i & 0x01) !== 0) {\n\t\tf = 1 - f;\n\t}\n\n\tconst n = wh + f * (v - wh); // Linear interpolation\n\n\tlet r;\n\tlet g;\n\tlet b;\n\t/* eslint-disable max-statements-per-line,no-multi-spaces */\n\tswitch (i) {\n\t\tdefault:\n\t\tcase 6:\n\t\tcase 0: r = v; g = n; b = wh; break;\n\t\tcase 1: r = n; g = v; b = wh; break;\n\t\tcase 2: r = wh; g = v; b = n; break;\n\t\tcase 3: r = wh; g = n; b = v; break;\n\t\tcase 4: r = n; g = wh; b = v; break;\n\t\tcase 5: r = v; g = wh; b = n; break;\n\t}\n\t/* eslint-enable max-statements-per-line,no-multi-spaces */\n\n\treturn [r * 255, g * 255, b * 255];\n};\n\nconvert.cmyk.rgb = function (cmyk) {\n\tconst c = cmyk[0] / 100;\n\tconst m = cmyk[1] / 100;\n\tconst y = cmyk[2] / 100;\n\tconst k = cmyk[3] / 100;\n\n\tconst r = 1 - Math.min(1, c * (1 - k) + k);\n\tconst g = 1 - Math.min(1, m * (1 - k) + k);\n\tconst b = 1 - Math.min(1, y * (1 - k) + k);\n\n\treturn [r * 255, g * 255, b * 255];\n};\n\nconvert.xyz.rgb = function (xyz) {\n\tconst x = xyz[0] / 100;\n\tconst y = xyz[1] / 100;\n\tconst z = xyz[2] / 100;\n\tlet r;\n\tlet g;\n\tlet b;\n\n\tr = (x * 3.2406) + (y * -1.5372) + (z * -0.4986);\n\tg = (x * -0.9689) + (y * 1.8758) + (z * 0.0415);\n\tb = (x * 0.0557) + (y * -0.2040) + (z * 1.0570);\n\n\t// Assume sRGB\n\tr = r > 0.0031308\n\t\t? ((1.055 * (r ** (1.0 / 2.4))) - 0.055)\n\t\t: r * 12.92;\n\n\tg = g > 0.0031308\n\t\t? ((1.055 * (g ** (1.0 / 2.4))) - 0.055)\n\t\t: g * 12.92;\n\n\tb = b > 0.0031308\n\t\t? ((1.055 * (b ** (1.0 / 2.4))) - 0.055)\n\t\t: b * 12.92;\n\n\tr = Math.min(Math.max(0, r), 1);\n\tg = Math.min(Math.max(0, g), 1);\n\tb = Math.min(Math.max(0, b), 1);\n\n\treturn [r * 255, g * 255, b * 255];\n};\n\nconvert.xyz.lab = function (xyz) {\n\tlet x = xyz[0];\n\tlet y = xyz[1];\n\tlet z = xyz[2];\n\n\tx /= 95.047;\n\ty /= 100;\n\tz /= 108.883;\n\n\tx = x > 0.008856 ? (x ** (1 / 3)) : (7.787 * x) + (16 / 116);\n\ty = y > 0.008856 ? (y ** (1 / 3)) : (7.787 * y) + (16 / 116);\n\tz = z > 0.008856 ? (z ** (1 / 3)) : (7.787 * z) + (16 / 116);\n\n\tconst l = (116 * y) - 16;\n\tconst a = 500 * (x - y);\n\tconst b = 200 * (y - z);\n\n\treturn [l, a, b];\n};\n\nconvert.lab.xyz = function (lab) {\n\tconst l = lab[0];\n\tconst a = lab[1];\n\tconst b = lab[2];\n\tlet x;\n\tlet y;\n\tlet z;\n\n\ty = (l + 16) / 116;\n\tx = a / 500 + y;\n\tz = y - b / 200;\n\n\tconst y2 = y ** 3;\n\tconst x2 = x ** 3;\n\tconst z2 = z ** 3;\n\ty = y2 > 0.008856 ? y2 : (y - 16 / 116) / 7.787;\n\tx = x2 > 0.008856 ? x2 : (x - 16 / 116) / 7.787;\n\tz = z2 > 0.008856 ? z2 : (z - 16 / 116) / 7.787;\n\n\tx *= 95.047;\n\ty *= 100;\n\tz *= 108.883;\n\n\treturn [x, y, z];\n};\n\nconvert.lab.lch = function (lab) {\n\tconst l = lab[0];\n\tconst a = lab[1];\n\tconst b = lab[2];\n\tlet h;\n\n\tconst hr = Math.atan2(b, a);\n\th = hr * 360 / 2 / Math.PI;\n\n\tif (h < 0) {\n\t\th += 360;\n\t}\n\n\tconst c = Math.sqrt(a * a + b * b);\n\n\treturn [l, c, h];\n};\n\nconvert.lch.lab = function (lch) {\n\tconst l = lch[0];\n\tconst c = lch[1];\n\tconst h = lch[2];\n\n\tconst hr = h / 360 * 2 * Math.PI;\n\tconst a = c * Math.cos(hr);\n\tconst b = c * Math.sin(hr);\n\n\treturn [l, a, b];\n};\n\nconvert.rgb.ansi16 = function (args, saturation = null) {\n\tconst [r, g, b] = args;\n\tlet value = saturation === null ? convert.rgb.hsv(args)[2] : saturation; // Hsv -> ansi16 optimization\n\n\tvalue = Math.round(value / 50);\n\n\tif (value === 0) {\n\t\treturn 30;\n\t}\n\n\tlet ansi = 30\n\t\t+ ((Math.round(b / 255) << 2)\n\t\t| (Math.round(g / 255) << 1)\n\t\t| Math.round(r / 255));\n\n\tif (value === 2) {\n\t\tansi += 60;\n\t}\n\n\treturn ansi;\n};\n\nconvert.hsv.ansi16 = function (args) {\n\t// Optimization here; we already know the value and don't need to get\n\t// it converted for us.\n\treturn convert.rgb.ansi16(convert.hsv.rgb(args), args[2]);\n};\n\nconvert.rgb.ansi256 = function (args) {\n\tconst r = args[0];\n\tconst g = args[1];\n\tconst b = args[2];\n\n\t// We use the extended greyscale palette here, with the exception of\n\t// black and white. normal palette only has 4 greyscale shades.\n\tif (r === g && g === b) {\n\t\tif (r < 8) {\n\t\t\treturn 16;\n\t\t}\n\n\t\tif (r > 248) {\n\t\t\treturn 231;\n\t\t}\n\n\t\treturn Math.round(((r - 8) / 247) * 24) + 232;\n\t}\n\n\tconst ansi = 16\n\t\t+ (36 * Math.round(r / 255 * 5))\n\t\t+ (6 * Math.round(g / 255 * 5))\n\t\t+ Math.round(b / 255 * 5);\n\n\treturn ansi;\n};\n\nconvert.ansi16.rgb = function (args) {\n\tlet color = args % 10;\n\n\t// Handle greyscale\n\tif (color === 0 || color === 7) {\n\t\tif (args > 50) {\n\t\t\tcolor += 3.5;\n\t\t}\n\n\t\tcolor = color / 10.5 * 255;\n\n\t\treturn [color, color, color];\n\t}\n\n\tconst mult = (~~(args > 50) + 1) * 0.5;\n\tconst r = ((color & 1) * mult) * 255;\n\tconst g = (((color >> 1) & 1) * mult) * 255;\n\tconst b = (((color >> 2) & 1) * mult) * 255;\n\n\treturn [r, g, b];\n};\n\nconvert.ansi256.rgb = function (args) {\n\t// Handle greyscale\n\tif (args >= 232) {\n\t\tconst c = (args - 232) * 10 + 8;\n\t\treturn [c, c, c];\n\t}\n\n\targs -= 16;\n\n\tlet rem;\n\tconst r = Math.floor(args / 36) / 5 * 255;\n\tconst g = Math.floor((rem = args % 36) / 6) / 5 * 255;\n\tconst b = (rem % 6) / 5 * 255;\n\n\treturn [r, g, b];\n};\n\nconvert.rgb.hex = function (args) {\n\tconst integer = ((Math.round(args[0]) & 0xFF) << 16)\n\t\t+ ((Math.round(args[1]) & 0xFF) << 8)\n\t\t+ (Math.round(args[2]) & 0xFF);\n\n\tconst string = integer.toString(16).toUpperCase();\n\treturn '000000'.substring(string.length) + string;\n};\n\nconvert.hex.rgb = function (args) {\n\tconst match = args.toString(16).match(/[a-f0-9]{6}|[a-f0-9]{3}/i);\n\tif (!match) {\n\t\treturn [0, 0, 0];\n\t}\n\n\tlet colorString = match[0];\n\n\tif (match[0].length === 3) {\n\t\tcolorString = colorString.split('').map(char => {\n\t\t\treturn char + char;\n\t\t}).join('');\n\t}\n\n\tconst integer = parseInt(colorString, 16);\n\tconst r = (integer >> 16) & 0xFF;\n\tconst g = (integer >> 8) & 0xFF;\n\tconst b = integer & 0xFF;\n\n\treturn [r, g, b];\n};\n\nconvert.rgb.hcg = function (rgb) {\n\tconst r = rgb[0] / 255;\n\tconst g = rgb[1] / 255;\n\tconst b = rgb[2] / 255;\n\tconst max = Math.max(Math.max(r, g), b);\n\tconst min = Math.min(Math.min(r, g), b);\n\tconst chroma = (max - min);\n\tlet grayscale;\n\tlet hue;\n\n\tif (chroma < 1) {\n\t\tgrayscale = min / (1 - chroma);\n\t} else {\n\t\tgrayscale = 0;\n\t}\n\n\tif (chroma <= 0) {\n\t\thue = 0;\n\t} else\n\tif (max === r) {\n\t\thue = ((g - b) / chroma) % 6;\n\t} else\n\tif (max === g) {\n\t\thue = 2 + (b - r) / chroma;\n\t} else {\n\t\thue = 4 + (r - g) / chroma;\n\t}\n\n\thue /= 6;\n\thue %= 1;\n\n\treturn [hue * 360, chroma * 100, grayscale * 100];\n};\n\nconvert.hsl.hcg = function (hsl) {\n\tconst s = hsl[1] / 100;\n\tconst l = hsl[2] / 100;\n\n\tconst c = l < 0.5 ? (2.0 * s * l) : (2.0 * s * (1.0 - l));\n\n\tlet f = 0;\n\tif (c < 1.0) {\n\t\tf = (l - 0.5 * c) / (1.0 - c);\n\t}\n\n\treturn [hsl[0], c * 100, f * 100];\n};\n\nconvert.hsv.hcg = function (hsv) {\n\tconst s = hsv[1] / 100;\n\tconst v = hsv[2] / 100;\n\n\tconst c = s * v;\n\tlet f = 0;\n\n\tif (c < 1.0) {\n\t\tf = (v - c) / (1 - c);\n\t}\n\n\treturn [hsv[0], c * 100, f * 100];\n};\n\nconvert.hcg.rgb = function (hcg) {\n\tconst h = hcg[0] / 360;\n\tconst c = hcg[1] / 100;\n\tconst g = hcg[2] / 100;\n\n\tif (c === 0.0) {\n\t\treturn [g * 255, g * 255, g * 255];\n\t}\n\n\tconst pure = [0, 0, 0];\n\tconst hi = (h % 1) * 6;\n\tconst v = hi % 1;\n\tconst w = 1 - v;\n\tlet mg = 0;\n\n\t/* eslint-disable max-statements-per-line */\n\tswitch (Math.floor(hi)) {\n\t\tcase 0:\n\t\t\tpure[0] = 1; pure[1] = v; pure[2] = 0; break;\n\t\tcase 1:\n\t\t\tpure[0] = w; pure[1] = 1; pure[2] = 0; break;\n\t\tcase 2:\n\t\t\tpure[0] = 0; pure[1] = 1; pure[2] = v; break;\n\t\tcase 3:\n\t\t\tpure[0] = 0; pure[1] = w; pure[2] = 1; break;\n\t\tcase 4:\n\t\t\tpure[0] = v; pure[1] = 0; pure[2] = 1; break;\n\t\tdefault:\n\t\t\tpure[0] = 1; pure[1] = 0; pure[2] = w;\n\t}\n\t/* eslint-enable max-statements-per-line */\n\n\tmg = (1.0 - c) * g;\n\n\treturn [\n\t\t(c * pure[0] + mg) * 255,\n\t\t(c * pure[1] + mg) * 255,\n\t\t(c * pure[2] + mg) * 255\n\t];\n};\n\nconvert.hcg.hsv = function (hcg) {\n\tconst c = hcg[1] / 100;\n\tconst g = hcg[2] / 100;\n\n\tconst v = c + g * (1.0 - c);\n\tlet f = 0;\n\n\tif (v > 0.0) {\n\t\tf = c / v;\n\t}\n\n\treturn [hcg[0], f * 100, v * 100];\n};\n\nconvert.hcg.hsl = function (hcg) {\n\tconst c = hcg[1] / 100;\n\tconst g = hcg[2] / 100;\n\n\tconst l = g * (1.0 - c) + 0.5 * c;\n\tlet s = 0;\n\n\tif (l > 0.0 && l < 0.5) {\n\t\ts = c / (2 * l);\n\t} else\n\tif (l >= 0.5 && l < 1.0) {\n\t\ts = c / (2 * (1 - l));\n\t}\n\n\treturn [hcg[0], s * 100, l * 100];\n};\n\nconvert.hcg.hwb = function (hcg) {\n\tconst c = hcg[1] / 100;\n\tconst g = hcg[2] / 100;\n\tconst v = c + g * (1.0 - c);\n\treturn [hcg[0], (v - c) * 100, (1 - v) * 100];\n};\n\nconvert.hwb.hcg = function (hwb) {\n\tconst w = hwb[1] / 100;\n\tconst b = hwb[2] / 100;\n\tconst v = 1 - b;\n\tconst c = v - w;\n\tlet g = 0;\n\n\tif (c < 1) {\n\t\tg = (v - c) / (1 - c);\n\t}\n\n\treturn [hwb[0], c * 100, g * 100];\n};\n\nconvert.apple.rgb = function (apple) {\n\treturn [(apple[0] / 65535) * 255, (apple[1] / 65535) * 255, (apple[2] / 65535) * 255];\n};\n\nconvert.rgb.apple = function (rgb) {\n\treturn [(rgb[0] / 255) * 65535, (rgb[1] / 255) * 65535, (rgb[2] / 255) * 65535];\n};\n\nconvert.gray.rgb = function (args) {\n\treturn [args[0] / 100 * 255, args[0] / 100 * 255, args[0] / 100 * 255];\n};\n\nconvert.gray.hsl = function (args) {\n\treturn [0, 0, args[0]];\n};\n\nconvert.gray.hsv = convert.gray.hsl;\n\nconvert.gray.hwb = function (gray) {\n\treturn [0, 100, gray[0]];\n};\n\nconvert.gray.cmyk = function (gray) {\n\treturn [0, 0, 0, gray[0]];\n};\n\nconvert.gray.lab = function (gray) {\n\treturn [gray[0], 0, 0];\n};\n\nconvert.gray.hex = function (gray) {\n\tconst val = Math.round(gray[0] / 100 * 255) & 0xFF;\n\tconst integer = (val << 16) + (val << 8) + val;\n\n\tconst string = integer.toString(16).toUpperCase();\n\treturn '000000'.substring(string.length) + string;\n};\n\nconvert.rgb.gray = function (rgb) {\n\tconst val = (rgb[0] + rgb[1] + rgb[2]) / 3;\n\treturn [val / 255 * 100];\n};\n","const conversions = require('./conversions');\n\n/*\n\tThis function routes a model to all other models.\n\n\tall functions that are routed have a property `.conversion` attached\n\tto the returned synthetic function. This property is an array\n\tof strings, each with the steps in between the 'from' and 'to'\n\tcolor models (inclusive).\n\n\tconversions that are not possible simply are not included.\n*/\n\nfunction buildGraph() {\n\tconst graph = {};\n\t// https://jsperf.com/object-keys-vs-for-in-with-closure/3\n\tconst models = Object.keys(conversions);\n\n\tfor (let len = models.length, i = 0; i < len; i++) {\n\t\tgraph[models[i]] = {\n\t\t\t// http://jsperf.com/1-vs-infinity\n\t\t\t// micro-opt, but this is simple.\n\t\t\tdistance: -1,\n\t\t\tparent: null\n\t\t};\n\t}\n\n\treturn graph;\n}\n\n// https://en.wikipedia.org/wiki/Breadth-first_search\nfunction deriveBFS(fromModel) {\n\tconst graph = buildGraph();\n\tconst queue = [fromModel]; // Unshift -> queue -> pop\n\n\tgraph[fromModel].distance = 0;\n\n\twhile (queue.length) {\n\t\tconst current = queue.pop();\n\t\tconst adjacents = Object.keys(conversions[current]);\n\n\t\tfor (let len = adjacents.length, i = 0; i < len; i++) {\n\t\t\tconst adjacent = adjacents[i];\n\t\t\tconst node = graph[adjacent];\n\n\t\t\tif (node.distance === -1) {\n\t\t\t\tnode.distance = graph[current].distance + 1;\n\t\t\t\tnode.parent = current;\n\t\t\t\tqueue.unshift(adjacent);\n\t\t\t}\n\t\t}\n\t}\n\n\treturn graph;\n}\n\nfunction link(from, to) {\n\treturn function (args) {\n\t\treturn to(from(args));\n\t};\n}\n\nfunction wrapConversion(toModel, graph) {\n\tconst path = [graph[toModel].parent, toModel];\n\tlet fn = conversions[graph[toModel].parent][toModel];\n\n\tlet cur = graph[toModel].parent;\n\twhile (graph[cur].parent) {\n\t\tpath.unshift(graph[cur].parent);\n\t\tfn = link(conversions[graph[cur].parent][cur], fn);\n\t\tcur = graph[cur].parent;\n\t}\n\n\tfn.conversion = path;\n\treturn fn;\n}\n\nmodule.exports = function (fromModel) {\n\tconst graph = deriveBFS(fromModel);\n\tconst conversion = {};\n\n\tconst models = Object.keys(graph);\n\tfor (let len = models.length, i = 0; i < len; i++) {\n\t\tconst toModel = models[i];\n\t\tconst node = graph[toModel];\n\n\t\tif (node.parent === null) {\n\t\t\t// No possible conversion, or this node is the source model.\n\t\t\tcontinue;\n\t\t}\n\n\t\tconversion[toModel] = wrapConversion(toModel, graph);\n\t}\n\n\treturn conversion;\n};\n\n","const conversions = require('./conversions');\nconst route = require('./route');\n\nconst convert = {};\n\nconst models = Object.keys(conversions);\n\nfunction wrapRaw(fn) {\n\tconst wrappedFn = function (...args) {\n\t\tconst arg0 = args[0];\n\t\tif (arg0 === undefined || arg0 === null) {\n\t\t\treturn arg0;\n\t\t}\n\n\t\tif (arg0.length > 1) {\n\t\t\targs = arg0;\n\t\t}\n\n\t\treturn fn(args);\n\t};\n\n\t// Preserve .conversion property if there is one\n\tif ('conversion' in fn) {\n\t\twrappedFn.conversion = fn.conversion;\n\t}\n\n\treturn wrappedFn;\n}\n\nfunction wrapRounded(fn) {\n\tconst wrappedFn = function (...args) {\n\t\tconst arg0 = args[0];\n\n\t\tif (arg0 === undefined || arg0 === null) {\n\t\t\treturn arg0;\n\t\t}\n\n\t\tif (arg0.length > 1) {\n\t\t\targs = arg0;\n\t\t}\n\n\t\tconst result = fn(args);\n\n\t\t// We're assuming the result is an array here.\n\t\t// see notice in conversions.js; don't use box types\n\t\t// in conversion functions.\n\t\tif (typeof result === 'object') {\n\t\t\tfor (let len = result.length, i = 0; i < len; i++) {\n\t\t\t\tresult[i] = Math.round(result[i]);\n\t\t\t}\n\t\t}\n\n\t\treturn result;\n\t};\n\n\t// Preserve .conversion property if there is one\n\tif ('conversion' in fn) {\n\t\twrappedFn.conversion = fn.conversion;\n\t}\n\n\treturn wrappedFn;\n}\n\nmodels.forEach(fromModel => {\n\tconvert[fromModel] = {};\n\n\tObject.defineProperty(convert[fromModel], 'channels', {value: conversions[fromModel].channels});\n\tObject.defineProperty(convert[fromModel], 'labels', {value: conversions[fromModel].labels});\n\n\tconst routes = route(fromModel);\n\tconst routeModels = Object.keys(routes);\n\n\trouteModels.forEach(toModel => {\n\t\tconst fn = routes[toModel];\n\n\t\tconvert[fromModel][toModel] = wrapRounded(fn);\n\t\tconvert[fromModel][toModel].raw = wrapRaw(fn);\n\t});\n});\n\nmodule.exports = convert;\n","const colorString = require('color-string');\nconst convert = require('color-convert');\n\nconst skippedModels = [\n\t// To be honest, I don't really feel like keyword belongs in color convert, but eh.\n\t'keyword',\n\n\t// Gray conflicts with some method names, and has its own method defined.\n\t'gray',\n\n\t// Shouldn't really be in color-convert either...\n\t'hex',\n];\n\nconst hashedModelKeys = {};\nfor (const model of Object.keys(convert)) {\n\thashedModelKeys[[...convert[model].labels].sort().join('')] = model;\n}\n\nconst limiters = {};\n\nfunction Color(object, model) {\n\tif (!(this instanceof Color)) {\n\t\treturn new Color(object, model);\n\t}\n\n\tif (model && model in skippedModels) {\n\t\tmodel = null;\n\t}\n\n\tif (model && !(model in convert)) {\n\t\tthrow new Error('Unknown model: ' + model);\n\t}\n\n\tlet i;\n\tlet channels;\n\n\tif (object == null) { // eslint-disable-line no-eq-null,eqeqeq\n\t\tthis.model = 'rgb';\n\t\tthis.color = [0, 0, 0];\n\t\tthis.valpha = 1;\n\t} else if (object instanceof Color) {\n\t\tthis.model = object.model;\n\t\tthis.color = [...object.color];\n\t\tthis.valpha = object.valpha;\n\t} else if (typeof object === 'string') {\n\t\tconst result = colorString.get(object);\n\t\tif (result === null) {\n\t\t\tthrow new Error('Unable to parse color from string: ' + object);\n\t\t}\n\n\t\tthis.model = result.model;\n\t\tchannels = convert[this.model].channels;\n\t\tthis.color = result.value.slice(0, channels);\n\t\tthis.valpha = typeof result.value[channels] === 'number' ? result.value[channels] : 1;\n\t} else if (object.length > 0) {\n\t\tthis.model = model || 'rgb';\n\t\tchannels = convert[this.model].channels;\n\t\tconst newArray = Array.prototype.slice.call(object, 0, channels);\n\t\tthis.color = zeroArray(newArray, channels);\n\t\tthis.valpha = typeof object[channels] === 'number' ? object[channels] : 1;\n\t} else if (typeof object === 'number') {\n\t\t// This is always RGB - can be converted later on.\n\t\tthis.model = 'rgb';\n\t\tthis.color = [\n\t\t\t(object >> 16) & 0xFF,\n\t\t\t(object >> 8) & 0xFF,\n\t\t\tobject & 0xFF,\n\t\t];\n\t\tthis.valpha = 1;\n\t} else {\n\t\tthis.valpha = 1;\n\n\t\tconst keys = Object.keys(object);\n\t\tif ('alpha' in object) {\n\t\t\tkeys.splice(keys.indexOf('alpha'), 1);\n\t\t\tthis.valpha = typeof object.alpha === 'number' ? object.alpha : 0;\n\t\t}\n\n\t\tconst hashedKeys = keys.sort().join('');\n\t\tif (!(hashedKeys in hashedModelKeys)) {\n\t\t\tthrow new Error('Unable to parse color from object: ' + JSON.stringify(object));\n\t\t}\n\n\t\tthis.model = hashedModelKeys[hashedKeys];\n\n\t\tconst {labels} = convert[this.model];\n\t\tconst color = [];\n\t\tfor (i = 0; i < labels.length; i++) {\n\t\t\tcolor.push(object[labels[i]]);\n\t\t}\n\n\t\tthis.color = zeroArray(color);\n\t}\n\n\t// Perform limitations (clamping, etc.)\n\tif (limiters[this.model]) {\n\t\tchannels = convert[this.model].channels;\n\t\tfor (i = 0; i < channels; i++) {\n\t\t\tconst limit = limiters[this.model][i];\n\t\t\tif (limit) {\n\t\t\t\tthis.color[i] = limit(this.color[i]);\n\t\t\t}\n\t\t}\n\t}\n\n\tthis.valpha = Math.max(0, Math.min(1, this.valpha));\n\n\tif (Object.freeze) {\n\t\tObject.freeze(this);\n\t}\n}\n\nColor.prototype = {\n\ttoString() {\n\t\treturn this.string();\n\t},\n\n\ttoJSON() {\n\t\treturn this[this.model]();\n\t},\n\n\tstring(places) {\n\t\tlet self = this.model in colorString.to ? this : this.rgb();\n\t\tself = self.round(typeof places === 'number' ? places : 1);\n\t\tconst args = self.valpha === 1 ? self.color : [...self.color, this.valpha];\n\t\treturn colorString.to[self.model](args);\n\t},\n\n\tpercentString(places) {\n\t\tconst self = this.rgb().round(typeof places === 'number' ? places : 1);\n\t\tconst args = self.valpha === 1 ? self.color : [...self.color, this.valpha];\n\t\treturn colorString.to.rgb.percent(args);\n\t},\n\n\tarray() {\n\t\treturn this.valpha === 1 ? [...this.color] : [...this.color, this.valpha];\n\t},\n\n\tobject() {\n\t\tconst result = {};\n\t\tconst {channels} = convert[this.model];\n\t\tconst {labels} = convert[this.model];\n\n\t\tfor (let i = 0; i < channels; i++) {\n\t\t\tresult[labels[i]] = this.color[i];\n\t\t}\n\n\t\tif (this.valpha !== 1) {\n\t\t\tresult.alpha = this.valpha;\n\t\t}\n\n\t\treturn result;\n\t},\n\n\tunitArray() {\n\t\tconst rgb = this.rgb().color;\n\t\trgb[0] /= 255;\n\t\trgb[1] /= 255;\n\t\trgb[2] /= 255;\n\n\t\tif (this.valpha !== 1) {\n\t\t\trgb.push(this.valpha);\n\t\t}\n\n\t\treturn rgb;\n\t},\n\n\tunitObject() {\n\t\tconst rgb = this.rgb().object();\n\t\trgb.r /= 255;\n\t\trgb.g /= 255;\n\t\trgb.b /= 255;\n\n\t\tif (this.valpha !== 1) {\n\t\t\trgb.alpha = this.valpha;\n\t\t}\n\n\t\treturn rgb;\n\t},\n\n\tround(places) {\n\t\tplaces = Math.max(places || 0, 0);\n\t\treturn new Color([...this.color.map(roundToPlace(places)), this.valpha], this.model);\n\t},\n\n\talpha(value) {\n\t\tif (value !== undefined) {\n\t\t\treturn new Color([...this.color, Math.max(0, Math.min(1, value))], this.model);\n\t\t}\n\n\t\treturn this.valpha;\n\t},\n\n\t// Rgb\n\tred: getset('rgb', 0, maxfn(255)),\n\tgreen: getset('rgb', 1, maxfn(255)),\n\tblue: getset('rgb', 2, maxfn(255)),\n\n\thue: getset(['hsl', 'hsv', 'hsl', 'hwb', 'hcg'], 0, value => ((value % 360) + 360) % 360),\n\n\tsaturationl: getset('hsl', 1, maxfn(100)),\n\tlightness: getset('hsl', 2, maxfn(100)),\n\n\tsaturationv: getset('hsv', 1, maxfn(100)),\n\tvalue: getset('hsv', 2, maxfn(100)),\n\n\tchroma: getset('hcg', 1, maxfn(100)),\n\tgray: getset('hcg', 2, maxfn(100)),\n\n\twhite: getset('hwb', 1, maxfn(100)),\n\twblack: getset('hwb', 2, maxfn(100)),\n\n\tcyan: getset('cmyk', 0, maxfn(100)),\n\tmagenta: getset('cmyk', 1, maxfn(100)),\n\tyellow: getset('cmyk', 2, maxfn(100)),\n\tblack: getset('cmyk', 3, maxfn(100)),\n\n\tx: getset('xyz', 0, maxfn(95.047)),\n\ty: getset('xyz', 1, maxfn(100)),\n\tz: getset('xyz', 2, maxfn(108.833)),\n\n\tl: getset('lab', 0, maxfn(100)),\n\ta: getset('lab', 1),\n\tb: getset('lab', 2),\n\n\tkeyword(value) {\n\t\tif (value !== undefined) {\n\t\t\treturn new Color(value);\n\t\t}\n\n\t\treturn convert[this.model].keyword(this.color);\n\t},\n\n\thex(value) {\n\t\tif (value !== undefined) {\n\t\t\treturn new Color(value);\n\t\t}\n\n\t\treturn colorString.to.hex(this.rgb().round().color);\n\t},\n\n\thexa(value) {\n\t\tif (value !== undefined) {\n\t\t\treturn new Color(value);\n\t\t}\n\n\t\tconst rgbArray = this.rgb().round().color;\n\n\t\tlet alphaHex = Math.round(this.valpha * 255).toString(16).toUpperCase();\n\t\tif (alphaHex.length === 1) {\n\t\t\talphaHex = '0' + alphaHex;\n\t\t}\n\n\t\treturn colorString.to.hex(rgbArray) + alphaHex;\n\t},\n\n\trgbNumber() {\n\t\tconst rgb = this.rgb().color;\n\t\treturn ((rgb[0] & 0xFF) << 16) | ((rgb[1] & 0xFF) << 8) | (rgb[2] & 0xFF);\n\t},\n\n\tluminosity() {\n\t\t// http://www.w3.org/TR/WCAG20/#relativeluminancedef\n\t\tconst rgb = this.rgb().color;\n\n\t\tconst lum = [];\n\t\tfor (const [i, element] of rgb.entries()) {\n\t\t\tconst chan = element / 255;\n\t\t\tlum[i] = (chan <= 0.04045) ? chan / 12.92 : ((chan + 0.055) / 1.055) ** 2.4;\n\t\t}\n\n\t\treturn 0.2126 * lum[0] + 0.7152 * lum[1] + 0.0722 * lum[2];\n\t},\n\n\tcontrast(color2) {\n\t\t// http://www.w3.org/TR/WCAG20/#contrast-ratiodef\n\t\tconst lum1 = this.luminosity();\n\t\tconst lum2 = color2.luminosity();\n\n\t\tif (lum1 > lum2) {\n\t\t\treturn (lum1 + 0.05) / (lum2 + 0.05);\n\t\t}\n\n\t\treturn (lum2 + 0.05) / (lum1 + 0.05);\n\t},\n\n\tlevel(color2) {\n\t\t// https://www.w3.org/TR/WCAG/#contrast-enhanced\n\t\tconst contrastRatio = this.contrast(color2);\n\t\tif (contrastRatio >= 7) {\n\t\t\treturn 'AAA';\n\t\t}\n\n\t\treturn (contrastRatio >= 4.5) ? 'AA' : '';\n\t},\n\n\tisDark() {\n\t\t// YIQ equation from http://24ways.org/2010/calculating-color-contrast\n\t\tconst rgb = this.rgb().color;\n\t\tconst yiq = (rgb[0] * 2126 + rgb[1] * 7152 + rgb[2] * 722) / 10000;\n\t\treturn yiq < 128;\n\t},\n\n\tisLight() {\n\t\treturn !this.isDark();\n\t},\n\n\tnegate() {\n\t\tconst rgb = this.rgb();\n\t\tfor (let i = 0; i < 3; i++) {\n\t\t\trgb.color[i] = 255 - rgb.color[i];\n\t\t}\n\n\t\treturn rgb;\n\t},\n\n\tlighten(ratio) {\n\t\tconst hsl = this.hsl();\n\t\thsl.color[2] += hsl.color[2] * ratio;\n\t\treturn hsl;\n\t},\n\n\tdarken(ratio) {\n\t\tconst hsl = this.hsl();\n\t\thsl.color[2] -= hsl.color[2] * ratio;\n\t\treturn hsl;\n\t},\n\n\tsaturate(ratio) {\n\t\tconst hsl = this.hsl();\n\t\thsl.color[1] += hsl.color[1] * ratio;\n\t\treturn hsl;\n\t},\n\n\tdesaturate(ratio) {\n\t\tconst hsl = this.hsl();\n\t\thsl.color[1] -= hsl.color[1] * ratio;\n\t\treturn hsl;\n\t},\n\n\twhiten(ratio) {\n\t\tconst hwb = this.hwb();\n\t\thwb.color[1] += hwb.color[1] * ratio;\n\t\treturn hwb;\n\t},\n\n\tblacken(ratio) {\n\t\tconst hwb = this.hwb();\n\t\thwb.color[2] += hwb.color[2] * ratio;\n\t\treturn hwb;\n\t},\n\n\tgrayscale() {\n\t\t// http://en.wikipedia.org/wiki/Grayscale#Converting_color_to_grayscale\n\t\tconst rgb = this.rgb().color;\n\t\tconst value = rgb[0] * 0.3 + rgb[1] * 0.59 + rgb[2] * 0.11;\n\t\treturn Color.rgb(value, value, value);\n\t},\n\n\tfade(ratio) {\n\t\treturn this.alpha(this.valpha - (this.valpha * ratio));\n\t},\n\n\topaquer(ratio) {\n\t\treturn this.alpha(this.valpha + (this.valpha * ratio));\n\t},\n\n\trotate(degrees) {\n\t\tconst hsl = this.hsl();\n\t\tlet hue = hsl.color[0];\n\t\thue = (hue + degrees) % 360;\n\t\thue = hue < 0 ? 360 + hue : hue;\n\t\thsl.color[0] = hue;\n\t\treturn hsl;\n\t},\n\n\tmix(mixinColor, weight) {\n\t\t// Ported from sass implementation in C\n\t\t// https://github.com/sass/libsass/blob/0e6b4a2850092356aa3ece07c6b249f0221caced/functions.cpp#L209\n\t\tif (!mixinColor || !mixinColor.rgb) {\n\t\t\tthrow new Error('Argument to \"mix\" was not a Color instance, but rather an instance of ' + typeof mixinColor);\n\t\t}\n\n\t\tconst color1 = mixinColor.rgb();\n\t\tconst color2 = this.rgb();\n\t\tconst p = weight === undefined ? 0.5 : weight;\n\n\t\tconst w = 2 * p - 1;\n\t\tconst a = color1.alpha() - color2.alpha();\n\n\t\tconst w1 = (((w * a === -1) ? w : (w + a) / (1 + w * a)) + 1) / 2;\n\t\tconst w2 = 1 - w1;\n\n\t\treturn Color.rgb(\n\t\t\tw1 * color1.red() + w2 * color2.red(),\n\t\t\tw1 * color1.green() + w2 * color2.green(),\n\t\t\tw1 * color1.blue() + w2 * color2.blue(),\n\t\t\tcolor1.alpha() * p + color2.alpha() * (1 - p));\n\t},\n};\n\n// Model conversion methods and static constructors\nfor (const model of Object.keys(convert)) {\n\tif (skippedModels.includes(model)) {\n\t\tcontinue;\n\t}\n\n\tconst {channels} = convert[model];\n\n\t// Conversion methods\n\tColor.prototype[model] = function (...args) {\n\t\tif (this.model === model) {\n\t\t\treturn new Color(this);\n\t\t}\n\n\t\tif (args.length > 0) {\n\t\t\treturn new Color(args, model);\n\t\t}\n\n\t\treturn new Color([...assertArray(convert[this.model][model].raw(this.color)), this.valpha], model);\n\t};\n\n\t// 'static' construction methods\n\tColor[model] = function (...args) {\n\t\tlet color = args[0];\n\t\tif (typeof color === 'number') {\n\t\t\tcolor = zeroArray(args, channels);\n\t\t}\n\n\t\treturn new Color(color, model);\n\t};\n}\n\nfunction roundTo(number, places) {\n\treturn Number(number.toFixed(places));\n}\n\nfunction roundToPlace(places) {\n\treturn function (number) {\n\t\treturn roundTo(number, places);\n\t};\n}\n\nfunction getset(model, channel, modifier) {\n\tmodel = Array.isArray(model) ? model : [model];\n\n\tfor (const m of model) {\n\t\t(limiters[m] || (limiters[m] = []))[channel] = modifier;\n\t}\n\n\tmodel = model[0];\n\n\treturn function (value) {\n\t\tlet result;\n\n\t\tif (value !== undefined) {\n\t\t\tif (modifier) {\n\t\t\t\tvalue = modifier(value);\n\t\t\t}\n\n\t\t\tresult = this[model]();\n\t\t\tresult.color[channel] = value;\n\t\t\treturn result;\n\t\t}\n\n\t\tresult = this[model]().color[channel];\n\t\tif (modifier) {\n\t\t\tresult = modifier(result);\n\t\t}\n\n\t\treturn result;\n\t};\n}\n\nfunction maxfn(max) {\n\treturn function (v) {\n\t\treturn Math.max(0, Math.min(max, v));\n\t};\n}\n\nfunction assertArray(value) {\n\treturn Array.isArray(value) ? value : [value];\n}\n\nfunction zeroArray(array, length) {\n\tfor (let i = 0; i < length; i++) {\n\t\tif (typeof array[i] !== 'number') {\n\t\t\tarray[i] = 0;\n\t\t}\n\t}\n\n\treturn array;\n}\n\nmodule.exports = Color;\n","// package/cleveref/provides.ts\nvar macros = {\n cref: { signature: \"s m\" },\n Cref: { signature: \"s m\" },\n crefrange: { signature: \"s m m\" },\n Crefrange: { signature: \"s m m\" },\n cpageref: { signature: \"s m\" },\n Cpageref: { signature: \"s m\" },\n ref: { signature: \"m\" },\n pageref: { signature: \"m\" },\n namecref: { signature: \"m\" },\n nameCref: { signature: \"m\" },\n lcnamecref: { signature: \"m\" },\n namecrefs: { signature: \"m\" },\n nameCrefs: { signature: \"m\" },\n lcnamecrefs: { signature: \"m\" },\n labelcref: { signature: \"m\" },\n labelcpageref: { signature: \"m\" },\n crefalias: { signature: \"m m\" },\n crefname: { signature: \"m m m\" },\n // XXX there are many more obscure commands to add here\n // https://ctan.org/pkg/cleveref\n crefdefaultlabelformat: { signature: \"m\" },\n crefrangeconjunction: { signature: \"m\" }\n};\nvar environments = {};\n\n// utils/enumerate.ts\nimport { arg } from \"@unified-latex/unified-latex-builder\";\nimport { match } from \"@unified-latex/unified-latex-util-match\";\nimport { updateRenderInfo } from \"@unified-latex/unified-latex-util-render-info\";\nimport {\n lastSignificantNodeIndex\n} from \"@unified-latex/unified-latex-util-replace\";\nimport { splitOnMacro } from \"@unified-latex/unified-latex-util-split\";\nimport { trim, trimEnd } from \"@unified-latex/unified-latex-util-trim\";\nfunction cleanEnumerateBody(ast, itemName = \"item\") {\n let { segments, macros: macros17 } = splitOnMacro(ast, itemName);\n for (let i = 0; i < segments.length; i++) {\n const segment = segments[i];\n if (i === 0) {\n trimEnd(segment);\n } else {\n trim(segment);\n }\n if (segment.length > 0 && i > 0) {\n segment.unshift({ type: \"whitespace\" });\n }\n }\n let insertParbreakBefore = /* @__PURE__ */ new WeakSet();\n let body = macros17.flatMap((node, i) => {\n var _a;\n const segment = segments[i + 1];\n const trailingComments = popTrailingComments(segment);\n node.args = node.args || [];\n node.args.push(arg(segment, { openMark: \"\", closeMark: \"\" }));\n updateRenderInfo(node, { inParMode: true });\n if (i > 0 || ((_a = segments[0]) == null ? void 0 : _a.length) > 0) {\n insertParbreakBefore.add(node);\n }\n return [node, ...trailingComments];\n });\n body = body.flatMap(\n (node) => insertParbreakBefore.has(node) ? [{ type: \"parbreak\" }, node] : node\n );\n body.unshift(...segments[0]);\n for (let i = 0; i < body.length - 1; i++) {\n const node = body[i];\n const nextNode = body[i + 1];\n if (!match.parbreak(nextNode)) {\n continue;\n }\n if (match.comment(node)) {\n node.suffixParbreak = true;\n }\n if (match.macro(node) && node.args && node.args[node.args.length - 1].closeMark === \"\") {\n const args = node.args[node.args.length - 1].content;\n const lastArg = args[args.length - 1];\n if (match.comment(lastArg)) {\n lastArg.suffixParbreak = true;\n }\n }\n }\n return body;\n}\nfunction popTrailingComments(nodes) {\n let lastNodeIndex = lastSignificantNodeIndex(nodes, true);\n if (lastNodeIndex === nodes.length - 1 || lastNodeIndex == null && nodes.length === 0) {\n return [];\n }\n if (lastNodeIndex == null) {\n lastNodeIndex = -1;\n }\n return nodes.splice(lastNodeIndex + 1);\n}\n\n// package/exam/provides.ts\nvar macros2 = {\n answerline: { signature: \"o\" },\n fillin: { signature: \"o o\" },\n fullwidth: { signature: \"m\" },\n fillwidthlines: { signature: \"m\" },\n fillwidthdottedlines: { signature: \"m\" },\n fillwidthgrid: { signature: \"m\" },\n makeemptybox: { signature: \"m\" },\n CorrectChoiceEmphasis: {\n signature: \"m\",\n renderInfo: { breakAround: true }\n },\n SolutionEmphasis: { signature: \"m\", renderInfo: { breakAround: true } },\n uplevel: { signature: \"m\", renderInfo: { breakAround: true } },\n checkboxchar: { signature: \"m\", renderInfo: { breakAround: true } },\n checkedchar: { signature: \"m\", renderInfo: { breakAround: true } },\n pointname: { signature: \"m\", renderInfo: { breakAround: true } },\n marginpointname: { signature: \"m\", renderInfo: { breakAround: true } },\n extrawidth: { signature: \"m\", renderInfo: { breakAround: true } },\n pointformat: { signature: \"m\", renderInfo: { breakAround: true } },\n bonuspointformat: { signature: \"m\", renderInfo: { breakAround: true } },\n totalformat: { signature: \"m\", renderInfo: { breakAround: true } },\n qformat: { signature: \"m\", renderInfo: { breakAround: true } },\n titledquestion: { signature: \"m o\", renderInfo: { breakAround: true } },\n pointpoints: { signature: \"m m\", renderInfo: { breakAround: true } },\n bonuspointpoints: { signature: \"m m\", renderInfo: { breakAround: true } }\n};\nvar environments2 = {\n choices: {\n signature: \"o\",\n processContent: (nodes) => cleanEnumerateBody(nodes, \"choice\")\n },\n checkboxes: {\n signature: \"o\",\n processContent: (nodes) => cleanEnumerateBody(nodes, \"choice\")\n },\n oneparchoices: {\n signature: \"o\",\n processContent: (nodes) => cleanEnumerateBody(nodes, \"choice\")\n },\n oneparcheckboxes: {\n signature: \"o\",\n processContent: (nodes) => cleanEnumerateBody(nodes, \"choice\")\n },\n parts: {\n signature: \"o\",\n processContent: (nodes) => cleanEnumerateBody(nodes, \"part\")\n },\n subparts: {\n signature: \"o\",\n processContent: (nodes) => cleanEnumerateBody(nodes, \"subpart\")\n },\n subsubparts: {\n signature: \"o\",\n processContent: (nodes) => cleanEnumerateBody(nodes, \"subsubpart\")\n },\n questions: {\n signature: \"o\",\n processContent: (nodes) => cleanEnumerateBody(nodes, \"question\")\n }\n};\n\n// package/geometry/provides.ts\nvar macros3 = {\n geometry: {\n signature: \"m\",\n renderInfo: { breakAround: true, pgfkeysArgs: true }\n }\n};\nvar environments3 = {};\n\n// package/hyperref/provides.ts\nvar macros4 = {\n hypersetup: {\n signature: \"m\",\n renderInfo: { breakAround: true, pgfkeysArgs: true }\n },\n href: { signature: \"o m m\" },\n url: { signature: \"m\" },\n nolinkurl: { signature: \"m\" },\n hyperbaseurl: { signature: \"m\" },\n hyperimage: { signature: \"m m\" },\n hyperdef: { signature: \"m m m\" },\n hyperref: { signature: \"o m\" },\n hyperlink: { signature: \"m m\" },\n hypertarget: { signature: \"m m\" },\n autoref: { signature: \"s m\" },\n pageref: { signature: \"s m\" },\n autopageref: { signature: \"s m\" },\n pdfstringdef: { signature: \"m m\" },\n pdfbookmark: { signature: \"o m m\" },\n currentpdfbookmark: { signature: \"m m\" },\n subpdfbookmark: { signature: \"m m\" },\n belowpdfbookmark: { signature: \"m m\" },\n texorpdfstring: { signature: \"m m\" },\n thispdfpagelabel: { signature: \"m\" },\n hypercalcbp: { signature: \"m\" }\n};\nvar environments4 = {};\n\n// package/latex2e/provides.ts\nimport { trim as trim2 } from \"@unified-latex/unified-latex-util-trim\";\nvar macros5 = {\n // Special\n \"\\\\\": { signature: \"!s !o\" },\n _: { signature: \"m\", escapeToken: \"\" },\n \"^\": { signature: \"m\", escapeToken: \"\" },\n // \\newcommand arg signature from https://www.texdev.net/2020/08/19/the-good-the-bad-and-the-ugly-creating-document-commands\n // List can be found in latex2e.pdf \"An unofficial reference manual\"\n newcommand: {\n signature: \"s +m o +o +m\",\n renderInfo: {\n breakAround: true,\n namedArguments: [\"starred\", \"name\", \"numArgs\", \"default\", \"body\"]\n }\n },\n renewcommand: {\n signature: \"s +m o +o +m\",\n renderInfo: {\n breakAround: true,\n namedArguments: [\"starred\", \"name\", \"numArgs\", \"default\", \"body\"]\n }\n },\n providecommand: {\n signature: \"s +m o +o +m\",\n renderInfo: { breakAround: true }\n },\n // Counters\n newcounter: {\n signature: \"m o\",\n renderInfo: { breakAround: true }\n },\n usecounter: {\n signature: \"m\"\n },\n setcounter: {\n signature: \"m m\",\n renderInfo: { breakAround: true }\n },\n addtocounter: {\n signature: \"m m\",\n renderInfo: { breakAround: true }\n },\n stepcounter: {\n signature: \"m\",\n renderInfo: { breakAround: true }\n },\n refstepcounter: {\n signature: \"m\",\n renderInfo: { breakAround: true }\n },\n // Lengths\n newlength: {\n signature: \"m\",\n renderInfo: { breakAround: true }\n },\n addtolength: {\n signature: \"m m\",\n renderInfo: { breakAround: true }\n },\n settodepth: {\n signature: \"m m\",\n renderInfo: { breakAround: true }\n },\n settoheight: {\n signature: \"m m\",\n renderInfo: { breakAround: true }\n },\n settowidth: {\n signature: \"m m\",\n renderInfo: { breakAround: true }\n },\n // Spaces\n stretch: { signature: \"m\" },\n hspace: { signature: \"s m\" },\n vspace: { signature: \"s m\", renderInfo: { breakAround: true } },\n vfill: { renderInfo: { breakAround: true } },\n indent: { renderInfo: { breakAround: true } },\n phantom: { signature: \"m\" },\n vphantom: { signature: \"m\" },\n hphantom: { signature: \"m\" },\n noindent: { renderInfo: { breakAround: true } },\n smallskip: { renderInfo: { breakAround: true } },\n medskip: { renderInfo: { breakAround: true } },\n bigskip: { renderInfo: { breakAround: true } },\n smallbreak: { renderInfo: { breakAround: true } },\n medbreak: { renderInfo: { breakAround: true } },\n bigbreak: { renderInfo: { breakAround: true } },\n newline: { renderInfo: { breakAround: true } },\n linebreak: { signature: \"o\", renderInfo: { breakAround: true } },\n nolinebreak: { signature: \"o\", renderInfo: { breakAround: true } },\n clearpage: { renderInfo: { breakAround: true } },\n cleardoublepage: { renderInfo: { breakAround: true } },\n newpage: { renderInfo: { breakAround: true } },\n enlargethispage: { signature: \"s\", renderInfo: { breakAround: true } },\n pagebreak: { signature: \"o\", renderInfo: { breakAround: true } },\n nopagebreak: { signature: \"o\", renderInfo: { breakAround: true } },\n // Boxes\n newsavebox: {\n signature: \"m\",\n renderInfo: { breakAround: true }\n },\n sbox: {\n signature: \"m m\",\n renderInfo: { breakAround: true }\n },\n savebox: {\n signature: \"m o o m\",\n renderInfo: { breakAround: true }\n },\n mbox: { signature: \"m\" },\n makebox: { signature: \"d() o o m\", renderInfo: { breakAround: true } },\n fbox: { signature: \"m\" },\n framebox: { signature: \"o o m\", renderInfo: { breakAround: true } },\n frame: { signature: \"m\", renderInfo: { breakAround: true } },\n parbox: { signature: \"o o o m m\", renderInfo: { breakAround: true } },\n raisebox: { signature: \"m o o m\" },\n marginpar: { signature: \"o m\", renderInfo: { breakAround: true } },\n colorbox: { signature: \"o m m\", renderInfo: { breakAround: true } },\n fcolorbox: { signature: \"o m m\", renderInfo: { breakAround: true } },\n rotatebox: { signature: \"o m m\" },\n scalebox: { signature: \"m o m\" },\n reflectbox: { signature: \"m\" },\n resizebox: { signature: \"s m m m\" },\n // Define environments\n newenvironment: {\n signature: \"s m o o m m\",\n renderInfo: { breakAround: true }\n },\n renewenvironment: {\n signature: \"s m o o m m\",\n renderInfo: { breakAround: true }\n },\n newtheorem: {\n signature: \"s m o m o\",\n renderInfo: { breakAround: true }\n },\n newfont: {\n signature: \"m m\",\n renderInfo: { breakAround: true }\n },\n // Counters\n alph: { signature: \"m\" },\n Alph: { signature: \"m\" },\n arabic: { signature: \"m\" },\n roman: { signature: \"m\" },\n Roman: { signature: \"m\" },\n fnsymbol: { signature: \"m\" },\n // Other\n documentclass: {\n signature: \"o m\",\n renderInfo: { breakAround: true, pgfkeysArgs: true }\n },\n usepackage: {\n signature: \"o m\",\n renderInfo: { breakAround: true, pgfkeysArgs: true }\n },\n item: {\n signature: \"o\",\n renderInfo: { hangingIndent: true, namedArguments: [\"label\"] }\n },\n value: { signature: \"m\" },\n centering: { renderInfo: { breakAround: true } },\n input: { signature: \"m\", renderInfo: { breakAround: true } },\n include: { signature: \"m\", renderInfo: { breakAround: true } },\n includeonly: {\n signature: \"m\",\n renderInfo: { breakAround: true, pgfkeysArgs: true }\n },\n discretionary: { signature: \"m m m\" },\n hyphenation: { signature: \"m m m\" },\n footnote: { signature: \"o m\", renderInfo: { inParMode: true } },\n footnotemark: { signature: \"o\" },\n footnotetext: { signature: \"o m\", renderInfo: { inParMode: true } },\n caption: {\n signature: \"o m\",\n renderInfo: { inParMode: true, breakAround: true }\n },\n // Math Commands\n sqrt: { signature: \"o m\", renderInfo: { inMathMode: true } },\n frac: { signature: \"m m\", renderInfo: { inMathMode: true } },\n stackrel: { signature: \"m m\" },\n ensuremath: { signature: \"m\", renderInfo: { inMathMode: true } },\n // Layout commands\n abstract: {\n signature: \"m\",\n renderInfo: { breakAround: true, inParMode: true }\n },\n maketitle: { renderInfo: { breakAround: true } },\n doublespacing: { renderInfo: { breakAround: true } },\n singlespacing: { renderInfo: { breakAround: true } },\n author: {\n signature: \"m\",\n renderInfo: { breakAround: true, inParMode: true }\n },\n date: { signature: \"o m\", renderInfo: { breakAround: true } },\n thanks: {\n signature: \"m\",\n renderInfo: { breakAround: true, inParMode: true }\n },\n // amsart document class adds an optional argument\n title: {\n signature: \"o m\",\n renderInfo: { breakAround: true, inParMode: true }\n },\n pagenumbering: { signature: \"m\", renderInfo: { breakAround: true } },\n pagestyle: { signature: \"m\", renderInfo: { breakAround: true } },\n thispagestyle: { signature: \"m\", renderInfo: { breakAround: true } },\n // Colors\n definecolor: { signature: \"m m m\", renderInfo: { breakAround: true } },\n pagecolor: { signature: \"o m\", renderInfo: { breakAround: true } },\n nopagecolor: { renderInfo: { breakAround: true } },\n multicolumn: { signature: \"m m m\" },\n // Graphics\n includegraphics: {\n signature: \"s o o m\",\n renderInfo: { breakAround: true, pgfkeysArgs: true }\n },\n rule: { signature: \"o m m\" },\n // Sectioning\n part: {\n signature: \"s o m\",\n renderInfo: {\n breakAround: true,\n inParMode: true,\n namedArguments: [\"starred\", \"tocTitle\", \"title\"]\n }\n },\n chapter: {\n signature: \"s o m\",\n renderInfo: {\n breakAround: true,\n inParMode: true,\n namedArguments: [\"starred\", \"tocTitle\", \"title\"]\n }\n },\n section: {\n signature: \"s o m\",\n renderInfo: {\n breakAround: true,\n inParMode: true,\n namedArguments: [\"starred\", \"tocTitle\", \"title\"]\n }\n },\n subsection: {\n signature: \"s o m\",\n renderInfo: {\n breakAround: true,\n inParMode: true,\n namedArguments: [\"starred\", \"tocTitle\", \"title\"]\n }\n },\n subsubsection: {\n signature: \"s o m\",\n renderInfo: {\n breakAround: true,\n inParMode: true,\n namedArguments: [\"starred\", \"tocTitle\", \"title\"]\n }\n },\n paragraph: {\n signature: \"s o m\",\n renderInfo: {\n breakAround: true,\n inParMode: true,\n namedArguments: [\"starred\", \"tocTitle\", \"title\"]\n }\n },\n subparagraph: {\n signature: \"s o m\",\n renderInfo: {\n breakAround: true,\n inParMode: true,\n namedArguments: [\"starred\", \"tocTitle\", \"title\"]\n }\n },\n appendix: { renderInfo: { breakAround: true, inParMode: true } },\n frontmatter: { renderInfo: { breakAround: true, inParMode: true } },\n mainmatter: { renderInfo: { breakAround: true, inParMode: true } },\n backmatter: { renderInfo: { breakAround: true, inParMode: true } },\n // Citing and references\n bibitem: { signature: \"o m\", renderInfo: { hangingIndent: true } },\n cite: { signature: \"o m\" },\n // Fonts\n textrm: { signature: \"m\", renderInfo: { inParMode: true } },\n textit: { signature: \"m\", renderInfo: { inParMode: true } },\n textmd: { signature: \"m\", renderInfo: { inParMode: true } },\n textbf: { signature: \"m\", renderInfo: { inParMode: true } },\n textup: { signature: \"m\", renderInfo: { inParMode: true } },\n textsl: { signature: \"m\", renderInfo: { inParMode: true } },\n textsf: { signature: \"m\", renderInfo: { inParMode: true } },\n textsc: { signature: \"m\", renderInfo: { inParMode: true } },\n texttt: { signature: \"m\", renderInfo: { inParMode: true } },\n emph: { signature: \"m\", renderInfo: { inParMode: true } },\n textnormal: { signature: \"m\", renderInfo: { inParMode: true } },\n uppercase: { signature: \"m\", renderInfo: { inParMode: true } },\n mathbf: { signature: \"m\" },\n mathsf: { signature: \"m\" },\n mathtt: { signature: \"m\" },\n mathit: { signature: \"m\" },\n mathnormal: { signature: \"m\" },\n mathcal: { signature: \"m\" },\n mathrm: { signature: \"m\" },\n // Other\n setlength: { signature: \"m m\", renderInfo: { breakAround: true } },\n ref: { signature: \"s m\" },\n label: { signature: \"o m\" },\n // cleveref changes \\label to have this signature\n printbibliography: { renderInfo: { breakAround: true } },\n addtocontents: { signature: \"m m\", renderInfo: { breakAround: true } },\n addcontentsline: { signature: \"m m m\", renderInfo: { breakAround: true } },\n contentsline: { signature: \"m m m\", renderInfo: { breakAround: true } },\n bibliography: { signature: \"m\", renderInfo: { breakAround: true } },\n bibliographystyle: { signature: \"m\", renderInfo: { breakAround: true } }\n};\nvar environments5 = {\n document: {\n processContent: (nodes) => {\n trim2(nodes);\n return nodes;\n }\n },\n array: { signature: \"o m\", renderInfo: { alignContent: true } },\n description: { signature: \"o\", processContent: cleanEnumerateBody },\n enumerate: {\n signature: \"o\",\n processContent: cleanEnumerateBody,\n renderInfo: { pgfkeysArgs: true }\n },\n itemize: { signature: \"o\", processContent: cleanEnumerateBody },\n trivlist: { signature: \"o\", processContent: cleanEnumerateBody },\n list: { signature: \"m m\", processContent: cleanEnumerateBody },\n figure: { signature: \"o\" },\n \"figure*\": { signature: \"o\" },\n filecontents: { signature: \"o m\" },\n \"filecontents*\": { signature: \"o m\" },\n minipage: { signature: \"o o o m\" },\n picture: { signature: \"r() d()\" },\n tabbing: { renderInfo: { alignContent: true } },\n table: { signature: \"o\" },\n tabular: { signature: \"o m\", renderInfo: { alignContent: true } },\n \"tabular*\": { signature: \"m o m\", renderInfo: { alignContent: true } },\n thebibliography: {\n signature: \"m\",\n processContent: (nodes) => cleanEnumerateBody(nodes, \"bibitem\")\n },\n // Math\n math: { renderInfo: { inMathMode: true } }\n};\n\n// package/listings/libs/argument-parser.ts\nimport { arg as arg2 } from \"@unified-latex/unified-latex-builder\";\nimport { parse as parseArgspec } from \"@unified-latex/unified-latex-util-argspec\";\nimport { gobbleSingleArgument } from \"@unified-latex/unified-latex-util-arguments\";\nimport { match as match2 } from \"@unified-latex/unified-latex-util-match\";\nvar argSpecM = parseArgspec(\"m\")[0];\nvar argSpecO = parseArgspec(\"o\")[0];\nvar argSpecRDelim = {};\nvar argumentParser = (nodes, startPos) => {\n const { argument: optionalArg, nodesRemoved: optionalArgNodesRemoved } = gobbleSingleArgument(nodes, argSpecO, startPos);\n let codeArg = null;\n let codeArgNodesRemoved = 0;\n const nextNode = nodes[startPos];\n if (match2.group(nextNode)) {\n const mandatoryArg = gobbleSingleArgument(nodes, argSpecM, startPos);\n codeArg = mandatoryArg.argument;\n codeArgNodesRemoved = mandatoryArg.nodesRemoved;\n } else if (match2.string(nextNode) && nextNode.content.length === 1) {\n const delim = nextNode.content;\n argSpecRDelim[delim] = argSpecRDelim[delim] || parseArgspec(`r${delim}${delim}`)[0];\n const delimArg = gobbleSingleArgument(\n nodes,\n argSpecRDelim[delim],\n startPos\n );\n codeArg = delimArg.argument;\n codeArgNodesRemoved = delimArg.nodesRemoved;\n }\n return {\n args: [optionalArg || arg2(null), codeArg || arg2(null)],\n nodesRemoved: optionalArgNodesRemoved + codeArgNodesRemoved\n };\n};\n\n// package/listings/provides.ts\nvar macros6 = {\n lstset: { signature: \"m\" },\n lstinline: { argumentParser },\n lstinputlisting: { signature: \"o m\" },\n lstdefinestyle: { signature: \"m m\" },\n lstnewenvironment: { signature: \"m o o m m\" },\n lstMakeShortInline: { signature: \"o m\" },\n lstDeleteShortInline: { signature: \"m\" },\n lstdefineformat: { signature: \"m m\" },\n lstdefinelanguage: { signature: \"o m o m o\" },\n lstalias: { signature: \"o m o m\" },\n lstloadlanguages: { signature: \"m\" }\n};\nvar environments6 = {};\n\n// package/makeidx/provides.ts\nvar macros7 = {\n see: { signature: \"m m\" },\n seealso: { signature: \"m m\" },\n seename: { signature: \"m\" },\n alsoname: { signature: \"m\" },\n index: { signature: \"m\" }\n};\nvar environments7 = {};\n\n// package/mathtools/provides.ts\nvar macros8 = {\n mathtoolsset: {\n signature: \"m\",\n renderInfo: { breakAround: true, pgfkeysArgs: true }\n },\n mathllap: {\n signature: \"o m\"\n },\n mathrlap: {\n signature: \"o m\"\n },\n mathclap: {\n signature: \"o m\"\n },\n clap: {\n signature: \"m\"\n },\n mathmbox: {\n signature: \"m\"\n },\n mathmakebox: {\n signature: \"o o m\"\n },\n cramped: {\n signature: \"o m\"\n },\n crampedllap: {\n signature: \"o m\"\n },\n crampedrlap: {\n signature: \"o m\"\n },\n crampedclap: {\n signature: \"o m\"\n },\n crampedsubstack: {\n signature: \"o m\"\n },\n smashoperator: {\n signature: \"o m\"\n },\n newtagform: {\n signature: \"m o m m\"\n },\n renewtagform: {\n signature: \"m o m m\"\n },\n usetagform: {\n signature: \"m\"\n },\n xleftrightarrow: { signature: \"o m\" },\n xLeftarrow: { signature: \"o m\" },\n xhookleftarrow: { signature: \"o m\" },\n xmapsto: { signature: \"o m\" },\n xRightarrow: { signature: \"o m\" },\n xLeftrightarrow: { signature: \"o m\" },\n xhookrightarrow: { signature: \"o m\" },\n underbracket: { signature: \"o o m\" },\n overbracket: { signature: \"o o m\" },\n underbrace: { signature: \"m\" },\n overbrace: { signature: \"m\" },\n shoveleft: { signature: \"o m\" },\n shoveright: { signature: \"o m\" },\n ArrowBetweenLines: { signature: \"s o\" },\n vdotswithin: { signature: \"m\" },\n shortdotswithin: { signature: \"s m\" },\n DeclarePairedDelimiter: {\n signature: \"m m m\",\n renderInfo: { breakAround: true }\n },\n DeclarePairedDelimiterX: {\n signature: \"m o m m m\",\n renderInfo: { breakAround: true }\n },\n DeclarePairedDelimiterXPP: {\n signature: \"m o m m m m m\",\n renderInfo: { breakAround: true }\n },\n prescript: { signature: \"m m m\" },\n DeclareMathSizes: { signature: \"m m m m\" },\n newgathered: { signature: \"m m m m\" },\n renewgathered: { signature: \"m m m m\" },\n splitfrac: { signature: \"m m\" },\n splitdfrac: { signature: \"m m\" },\n xmathstrut: { signature: \"o m\" },\n // amsthm\n newtheorem: { signature: \"s m o m o\", renderInfo: { breakAround: true } },\n theoremstyle: { signature: \"m\", renderInfo: { breakAround: true } },\n newtheoremstyle: {\n signature: \"m m m m m m m m m\",\n renderInfo: { breakAround: true }\n },\n // amsmath\n text: { signature: \"m\", renderInfo: { inMathMode: false } },\n // amsfonts\n mathbb: { signature: \"m\" },\n mathscr: { signature: \"m\" },\n mathfrak: { signature: \"m\" },\n frak: { signature: \"m\" },\n Bdd: { signature: \"m\" },\n bold: { signature: \"m\" },\n // amsopn\n operatorname: { signature: \"s m\" },\n DeclareMathOperator: {\n signature: \"s m m\",\n renderInfo: { breakAround: true }\n }\n};\nvar environments8 = {\n crampedsubarray: {\n signature: \"m\",\n renderInfo: { alignContent: true, inMathMode: true }\n },\n matrix: { renderInfo: { alignContent: true, inMathMode: true } },\n bmatrix: { renderInfo: { alignContent: true, inMathMode: true } },\n pmatrix: { renderInfo: { alignContent: true, inMathMode: true } },\n vmatrix: { renderInfo: { alignContent: true, inMathMode: true } },\n Bmatrix: { renderInfo: { alignContent: true, inMathMode: true } },\n Vmatrix: { renderInfo: { alignContent: true, inMathMode: true } },\n smallmatrix: { renderInfo: { alignContent: true, inMathMode: true } },\n psmallmatrix: { renderInfo: { alignContent: true, inMathMode: true } },\n vsmallmatrix: { renderInfo: { alignContent: true, inMathMode: true } },\n bsmallmatrix: { renderInfo: { alignContent: true, inMathMode: true } },\n Bsmallmatrix: { renderInfo: { alignContent: true, inMathMode: true } },\n Vsmallmatrix: { renderInfo: { alignContent: true, inMathMode: true } },\n \"matrix*\": {\n signature: \"o\",\n renderInfo: { alignContent: true, inMathMode: true }\n },\n \"bmatrix*\": {\n signature: \"o\",\n renderInfo: { alignContent: true, inMathMode: true }\n },\n \"pmatrix*\": {\n signature: \"o\",\n renderInfo: { alignContent: true, inMathMode: true }\n },\n \"vmatrix*\": {\n signature: \"o\",\n renderInfo: { alignContent: true, inMathMode: true }\n },\n \"Bmatrix*\": {\n signature: \"o\",\n renderInfo: { alignContent: true, inMathMode: true }\n },\n \"Vmatrix*\": {\n signature: \"o\",\n renderInfo: { alignContent: true, inMathMode: true }\n },\n \"smallmatrix*\": {\n signature: \"o\",\n renderInfo: { alignContent: true, inMathMode: true }\n },\n \"psmallmatrix*\": {\n signature: \"o\",\n renderInfo: { alignContent: true, inMathMode: true }\n },\n \"bsmallmatrix*\": {\n signature: \"o\",\n renderInfo: { alignContent: true, inMathMode: true }\n },\n \"vsmallmatrix*\": {\n signature: \"o\",\n renderInfo: { alignContent: true, inMathMode: true }\n },\n \"Bsmallmatrix*\": {\n signature: \"o\",\n renderInfo: { alignContent: true, inMathMode: true }\n },\n \"Vsmallmatrix*\": {\n signature: \"o\",\n renderInfo: { alignContent: true, inMathMode: true }\n },\n multilined: { signature: \"o o\", renderInfo: { inMathMode: true } },\n cases: { renderInfo: { alignContent: true, inMathMode: true } },\n \"cases*\": { renderInfo: { alignContent: true, inMathMode: true } },\n dcases: { renderInfo: { alignContent: true, inMathMode: true } },\n \"dcases*\": { renderInfo: { alignContent: true, inMathMode: true } },\n rcases: { renderInfo: { alignContent: true, inMathMode: true } },\n \"rcases*\": { renderInfo: { alignContent: true, inMathMode: true } },\n drcases: { renderInfo: { alignContent: true, inMathMode: true } },\n \"drcases*\": { renderInfo: { alignContent: true, inMathMode: true } },\n spreadlines: { signature: \"m\", renderInfo: { inMathMode: true } },\n lgathered: { signature: \"o\", renderInfo: { inMathMode: true } },\n rgathered: { signature: \"o\", renderInfo: { inMathMode: true } },\n // amsmath\n \"align*\": { renderInfo: { inMathMode: true, alignContent: true } },\n align: { renderInfo: { inMathMode: true, alignContent: true } },\n aligned: { renderInfo: { inMathMode: true, alignContent: true } },\n \"alignat*\": { renderInfo: { inMathMode: true, alignContent: true } },\n alignat: { renderInfo: { inMathMode: true, alignContent: true } },\n \"equation*\": { renderInfo: { inMathMode: true } },\n equation: { renderInfo: { inMathMode: true } },\n \"gather*\": { renderInfo: { inMathMode: true } },\n gather: { renderInfo: { inMathMode: true } },\n \"multline*\": { renderInfo: { inMathMode: true } },\n multline: { renderInfo: { inMathMode: true } },\n \"flalign*\": { renderInfo: { inMathMode: true, alignContent: true } },\n flalign: { renderInfo: { inMathMode: true, alignContent: true } },\n split: { renderInfo: { inMathMode: true } },\n // Math environments\n displaymath: { renderInfo: { inMathMode: true } },\n // Typical amsthm environments\n theorem: { signature: \"o\" },\n lemma: { signature: \"o\" },\n definition: { signature: \"o\" },\n proposition: { signature: \"o\" },\n corollary: { signature: \"o\" },\n remark: { signature: \"!o\" },\n example: { signature: \"!o\" },\n proof: { signature: \"o\" }\n};\n\n// package/minted/libs/argument-parser.ts\nimport { arg as arg3 } from \"@unified-latex/unified-latex-builder\";\nimport { parse as parseArgspec2 } from \"@unified-latex/unified-latex-util-argspec\";\nimport { gobbleSingleArgument as gobbleSingleArgument2 } from \"@unified-latex/unified-latex-util-arguments\";\nimport { match as match3 } from \"@unified-latex/unified-latex-util-match\";\nvar argSpecM2 = parseArgspec2(\"m\")[0];\nvar argSpecO2 = parseArgspec2(\"o\")[0];\nvar argSpecRDelim2 = {};\nvar argumentParser2 = (nodes, startPos) => {\n const { argument: optionalArg, nodesRemoved: optionalArgNodesRemoved } = gobbleSingleArgument2(nodes, argSpecO2, startPos);\n const { argument: languageArg, nodesRemoved: languageArgNodesRemoved } = gobbleSingleArgument2(nodes, argSpecM2, startPos);\n let codeArg = null;\n let codeArgNodesRemoved = 0;\n const nextNode = nodes[startPos];\n if (match3.group(nextNode)) {\n const mandatoryArg = gobbleSingleArgument2(nodes, argSpecM2, startPos);\n codeArg = mandatoryArg.argument;\n codeArgNodesRemoved = mandatoryArg.nodesRemoved;\n } else if (match3.string(nextNode) && nextNode.content.length === 1) {\n const delim = nextNode.content;\n argSpecRDelim2[delim] = argSpecRDelim2[delim] || parseArgspec2(`r${delim}${delim}`)[0];\n const delimArg = gobbleSingleArgument2(\n nodes,\n argSpecRDelim2[delim],\n startPos\n );\n codeArg = delimArg.argument;\n codeArgNodesRemoved = delimArg.nodesRemoved;\n }\n return {\n args: [\n optionalArg || arg3(null),\n languageArg || arg3(null),\n codeArg || arg3(null)\n ],\n nodesRemoved: optionalArgNodesRemoved + languageArgNodesRemoved + codeArgNodesRemoved\n };\n};\n\n// package/minted/provides.ts\nvar macros9 = {\n mint: { argumentParser: argumentParser2 },\n mintinline: { argumentParser: argumentParser2 },\n inputminted: { argumentParser: argumentParser2 },\n usemintedstyle: { signature: \"m\" },\n setminted: { signature: \"o m\" },\n setmintedinline: { signature: \"o m\" },\n newmint: { signature: \"o m m\" },\n newminted: { signature: \"o m m\" },\n newmintinline: { signature: \"o m m\" },\n newmintedfile: { signature: \"o m m\" }\n};\nvar environments9 = {};\n\n// package/nicematrix/provides.ts\nvar macros10 = {\n NiceMatrixOptions: {\n signature: \"m\",\n renderInfo: { pgfkeysArgs: true, breakAround: true }\n }\n};\nvar environments10 = {\n NiceTabular: {\n signature: \"o m !o\",\n renderInfo: { pgfkeysArgs: true, alignContent: true }\n },\n NiceMatrixBlock: {\n signature: \"!o\",\n renderInfo: { pgfkeysArgs: true, alignContent: true }\n },\n NiceArrayWithDelims: {\n signature: \"m m o m !o\",\n renderInfo: { pgfkeysArgs: true, alignContent: true }\n },\n NiceArray: {\n signature: \"o m !o\",\n renderInfo: { pgfkeysArgs: true, alignContent: true }\n },\n pNiceArray: {\n signature: \"o m !o\",\n renderInfo: { pgfkeysArgs: true, alignContent: true }\n },\n bNiceArray: {\n signature: \"o m !o\",\n renderInfo: { pgfkeysArgs: true, alignContent: true }\n },\n BNiceArray: {\n signature: \"o m !o\",\n renderInfo: { pgfkeysArgs: true, alignContent: true }\n },\n vNiceArray: {\n signature: \"o m !o\",\n renderInfo: { pgfkeysArgs: true, alignContent: true }\n },\n VNiceArray: {\n signature: \"o m !o\",\n renderInfo: { pgfkeysArgs: true, alignContent: true }\n },\n NiceMatrix: {\n signature: \"!o\",\n renderInfo: { pgfkeysArgs: true, alignContent: true }\n },\n pNiceMatrix: {\n signature: \"!o\",\n renderInfo: { pgfkeysArgs: true, alignContent: true }\n },\n bNiceMatrix: {\n signature: \"!o\",\n renderInfo: { pgfkeysArgs: true, alignContent: true }\n },\n BNiceMatrix: {\n signature: \"!o\",\n renderInfo: { pgfkeysArgs: true, alignContent: true }\n },\n vNiceMatrix: {\n signature: \"!o\",\n renderInfo: { pgfkeysArgs: true, alignContent: true }\n },\n VNiceMatrix: {\n signature: \"!o\",\n renderInfo: { pgfkeysArgs: true, alignContent: true }\n }\n};\n\n// package/systeme/provides.ts\nvar macros11 = {\n systeme: {\n signature: \"s o o m\",\n renderInfo: { inMathMode: true }\n },\n sysdelim: {\n signature: \"m m\"\n },\n syseqsep: { signature: \"m\" },\n sysalign: { signature: \"m\" },\n syssignspace: { signature: \"m\" },\n syseqspace: { signature: \"m\" },\n syslineskipcoeff: { signature: \"m\" },\n syseqivsign: { signature: \"m\" },\n sysaddeqsign: { signature: \"m\" },\n sysremoveeqsign: { signature: \"m\" },\n sysextracolonsign: { signature: \"m\" },\n syscodeextracol: { signature: \"m\" },\n sysautonum: { signature: \"m\" },\n syssubstitute: { signature: \"m\" }\n};\nvar environments11 = {};\n\n// package/systeme/libs/parser.ts\nimport { match as match4 } from \"@unified-latex/unified-latex-util-match\";\nimport { decorateArrayForPegjs } from \"@unified-latex/unified-latex-util-pegjs\";\nimport { SystemePegParser } from \"@unified-latex/unified-latex-util-pegjs\";\n\n// package/systeme/libs/print-raw.ts\nimport { printRaw as latexPrintRaw } from \"@unified-latex/unified-latex-util-print-raw\";\n\n// package/systeme/libs/systeme.ts\nimport { printRaw } from \"@unified-latex/unified-latex-util-print-raw\";\nimport { match as match5 } from \"@unified-latex/unified-latex-util-match\";\nimport { arrayJoin } from \"@unified-latex/unified-latex-util-split\";\n\n// ../structured-clone/dist/index.js\n(function() {\n if (typeof globalThis === \"object\")\n return;\n Object.defineProperty(Object.prototype, \"__magic__\", {\n get: function() {\n return this;\n },\n configurable: true\n // This makes it possible to `delete` the getter later.\n });\n __magic__.globalThis = __magic__;\n delete Object.prototype.__magic__;\n})();\nvar clone = typeof globalThis.structuredClone === \"function\" ? globalThis.structuredClone : (obj) => JSON.parse(JSON.stringify(obj));\n\n// package/systeme/libs/systeme.ts\nimport { deleteComments } from \"@unified-latex/unified-latex-util-comments\";\nimport { visit } from \"@unified-latex/unified-latex-util-visit\";\nimport { updateRenderInfo as updateRenderInfo2 } from \"@unified-latex/unified-latex-util-render-info\";\nimport { getArgsContent } from \"@unified-latex/unified-latex-util-arguments\";\n\n// package/tikz/provides.ts\nimport { attachMacroArgsInArray } from \"@unified-latex/unified-latex-util-arguments\";\n\n// package/tikz/libs/tikz-command-argument-parser.ts\nimport { arg as arg4 } from \"@unified-latex/unified-latex-builder\";\nimport {\n parse as parseArgspec3\n} from \"@unified-latex/unified-latex-util-argspec\";\nimport { gobbleSingleArgument as gobbleSingleArgument3 } from \"@unified-latex/unified-latex-util-arguments\";\nimport { match as match6 } from \"@unified-latex/unified-latex-util-match\";\nimport { scan } from \"@unified-latex/unified-latex-util-scan\";\nimport { trim as trim3 } from \"@unified-latex/unified-latex-util-trim\";\nvar OPTIONAL_ARGUMENT_ARG_SPEC = parseArgspec3(\"o\")[0];\nfunction blankArg() {\n return arg4([], { openMark: \"\", closeMark: \"\" });\n}\nvar tikzCommandArgumentParser = (nodes, startPos) => {\n const origStartPos = startPos;\n let pos = startPos;\n let nodesRemoved = 0;\n const cursorPosAfterAnimations = eatAllAnimationSpecs(nodes, pos);\n let animationArg = blankArg();\n if (cursorPosAfterAnimations !== pos) {\n const argContent = nodes.splice(pos, cursorPosAfterAnimations - pos);\n trim3(argContent);\n animationArg = arg4(argContent, {\n openMark: \" \",\n closeMark: \" \"\n });\n }\n nodesRemoved += cursorPosAfterAnimations - pos;\n const {\n argument: _optionalArgument,\n nodesRemoved: optionalArgumentNodesRemoved\n } = gobbleSingleArgument3(nodes, OPTIONAL_ARGUMENT_ARG_SPEC, pos);\n nodesRemoved += optionalArgumentNodesRemoved;\n const optionalArg = _optionalArgument || blankArg();\n while (match6.whitespace(nodes[pos])) {\n pos++;\n }\n const firstNode = nodes[pos];\n if (!firstNode) {\n return {\n args: [animationArg, optionalArg, blankArg()],\n nodesRemoved: 0\n };\n }\n if (match6.group(firstNode)) {\n const args = [animationArg, optionalArg, arg4(firstNode.content)];\n nodes.splice(origStartPos, pos - origStartPos + 1);\n return { args, nodesRemoved: pos - origStartPos + 1 + nodesRemoved };\n }\n const semicolonPosition = scan(nodes, \";\", { startIndex: pos });\n if (semicolonPosition != null) {\n const argNodes = nodes.splice(\n origStartPos,\n semicolonPosition - origStartPos + 1\n );\n trim3(argNodes);\n const args = [animationArg, optionalArg, arg4(argNodes)];\n return {\n args,\n nodesRemoved: origStartPos - semicolonPosition + 1 + nodesRemoved\n };\n }\n return {\n args: [animationArg, optionalArg, blankArg()],\n nodesRemoved: 0\n };\n};\nfunction eatAllAnimationSpecs(nodes, startPos) {\n const colonPos = scan(nodes, \":\", {\n startIndex: startPos,\n allowSubstringMatches: true,\n onlySkipWhitespaceAndComments: true\n });\n if (!colonPos) {\n return startPos;\n }\n let lastMatchPos = startPos;\n let i = colonPos + 1;\n for (; i < nodes.length; i++) {\n const node = nodes[i];\n if (match6.string(node, \"[\")) {\n break;\n }\n if (match6.string(node, \"=\")) {\n i++;\n while (match6.whitespace(nodes[i]) || match6.comment(nodes[i])) {\n i++;\n }\n if (!match6.group(nodes[i])) {\n break;\n }\n lastMatchPos = i + 1;\n const colonPos2 = scan(nodes, \":\", {\n startIndex: lastMatchPos,\n allowSubstringMatches: true,\n onlySkipWhitespaceAndComments: true\n });\n if (colonPos2 == null) {\n break;\n }\n i = colonPos2 + 1;\n }\n }\n return lastMatchPos;\n}\n\n// package/tikz/provides.ts\nvar macros12 = {\n pgfkeys: {\n signature: \"m\",\n renderInfo: { breakAround: true, pgfkeysArgs: true }\n },\n tikzoption: {\n signature: \"m\",\n renderInfo: { breakAround: true, pgfkeysArgs: true }\n },\n tikzstyle: {\n signature: \"m\",\n renderInfo: { breakAround: true, pgfkeysArgs: true }\n },\n usetikzlibrary: {\n signature: \"m\",\n renderInfo: { breakAround: true, pgfkeysArgs: true }\n },\n usepgfmodule: { signature: \"m\", renderInfo: { pgfkeysArgs: true } },\n usepgflibrary: { signature: \"m\", renderInfo: { pgfkeysArgs: true } },\n pgfplotsset: {\n signature: \"m\",\n renderInfo: { breakAround: true, pgfkeysArgs: true }\n },\n pgfplotstabletypeset: {\n signature: \"o m\",\n renderInfo: { breakAround: true, pgfkeysArgs: true }\n },\n tikz: {\n signature: \"o o m\",\n argumentParser: tikzCommandArgumentParser,\n renderInfo: { namedArguments: [\"animation\", \"options\", \"command\"] }\n }\n};\nvar environments12 = {\n tikzpicture: {\n signature: \"o\",\n renderInfo: { pgfkeysArgs: true, tikzEnvironment: true },\n processContent: processTikzEnvironmentContent\n },\n axis: {\n signature: \"o\",\n renderInfo: { pgfkeysArgs: true, tikzEnvironment: true },\n processContent: processTikzEnvironmentContent\n },\n scope: {\n signature: \"o\",\n renderInfo: { pgfkeysArgs: true, tikzEnvironment: true },\n processContent: processTikzEnvironmentContent\n },\n pgfonlayer: {\n signature: \"m\",\n renderInfo: { tikzEnvironment: true },\n processContent: processTikzEnvironmentContent\n },\n pgflowlevelscope: {\n signature: \"m\",\n renderInfo: { tikzEnvironment: true },\n processContent: processTikzEnvironmentContent\n },\n pgfviewboxscope: {\n signature: \"m m m m m\",\n renderInfo: { tikzEnvironment: true },\n processContent: processTikzEnvironmentContent\n },\n pgftransparencygroup: {\n signature: \"o\",\n renderInfo: { pgfkeysArgs: true, tikzEnvironment: true },\n processContent: processTikzEnvironmentContent\n },\n behindforegroundpath: {\n signature: \"m\",\n processContent: processTikzEnvironmentContent\n },\n pgfmetadecoration: {\n signature: \"m\",\n processContent: processTikzEnvironmentContent\n },\n colormixin: { signature: \"m\", renderInfo: { pgfkeysArgs: true } }\n};\nfunction processTikzEnvironmentContent(nodes) {\n attachMacroArgsInArray(nodes, conditionalMacros);\n return nodes;\n}\nvar conditionalMacros = {\n pgfextra: { signature: \"m\" },\n beginpgfgraphicnamed: { signature: \"m\" },\n pgfrealjobname: { signature: \"m\" },\n pgfplotstreampoint: { signature: \"m\" },\n pgfplotstreampointoutlier: { signature: \"m\" },\n pgfplotstreamspecial: { signature: \"m\" },\n pgfplotxyfile: { signature: \"m\" },\n pgfplotxyzfile: { signature: \"m\" },\n pgfplotfunction: { signature: \"mmm\" },\n pgfplotgnuplot: { signature: \"o m\" },\n pgfplothandlerrecord: { signature: \"m\" },\n pgfdeclareplothandler: { signature: \"m m m\" },\n pgfdeclarelayer: { signature: \"m\" },\n pgfsetlayers: { signature: \"m\", renderInfo: { pgfkeysArgs: true } },\n pgfonlayer: { signature: \"m\" },\n startpgfonlayer: { signature: \"m\" },\n pgfdeclarehorizontalshading: { signature: \"o m m m \" },\n pgfdeclareradialshading: { signature: \"o m m m\" },\n pgfdeclarefunctionalshading: { signature: \"o m m m m m\" },\n pgfshadecolortorgb: { signature: \"m m\" },\n pgfshadecolortocmyk: { signature: \"m m\" },\n pgfshadecolortogray: { signature: \"m m\" },\n pgfuseshading: { signature: \"m\" },\n pgfshadepath: { signature: \"m m\" },\n pgfsetadditionalshadetransform: { signature: \"m\" },\n pgfsetstrokeopacity: { signature: \"m\" },\n pgfsetfillopacity: { signature: \"m\" },\n pgfsetblendmode: { signature: \"m\" },\n pgfdeclarefading: { signature: \"m m\" },\n pgfsetfading: { signature: \"m m\" },\n pgfsetfadingforcurrentpath: { signature: \"m m\" },\n pgfsetfadingforcurrentpathstroked: { signature: \"m m\" },\n pgfanimateattribute: { signature: \"m m\" },\n pgfsnapshot: { signature: \"m\" },\n pgfqpoint: { signature: \"m m\" },\n pgfqpointxy: { signature: \"m m\" },\n pgfqpointxyz: { signature: \"m m m\" },\n pgfqpointscale: { signature: \"m m\" },\n pgfpathqmoveto: { signature: \"m m\" },\n pgfpathqlineto: { signature: \"m m\" },\n pgfpathqcurveto: { signature: \"m m m m m m\" },\n pgfpathqcircle: { signature: \"m\" },\n pgfqbox: { signature: \"m\" },\n pgfqboxsynced: { signature: \"m\" },\n pgfaliasimage: { signature: \"m m\" },\n pgfuseimage: { signature: \"m\" },\n pgfimage: { signature: \"o m\", renderInfo: { pgfkeysArgs: true } },\n pgfdeclaremask: { signature: \"o m m\", renderInfo: { pgfkeysArgs: true } },\n pgfdeclarepatternformonly: { signature: \"o m m m m m\" },\n pgfdeclarepatterninherentlycolored: { signature: \"o m m m m m\" },\n pgfsetfillpattern: { signature: \"m m\" },\n // Coordinate canvas and nonlinear transformations\n pgftransformshift: { signature: \"m\" },\n pgftransformxshift: { signature: \"m\" },\n pgftransformyshift: { signature: \"m\" },\n pgftransformscale: { signature: \"m\" },\n pgftransformxscale: { signature: \"m\" },\n pgftransformyscale: { signature: \"m\" },\n pgftransformxslant: { signature: \"m\" },\n pgftransformyslant: { signature: \"m\" },\n pgftransformrotate: { signature: \"m\" },\n pgftransformtriangle: { signature: \"m m m\" },\n pgftransformcm: { signature: \"m m m m m\" },\n pgftransformarrow: { signature: \"m m\" },\n pgftransformlineattime: { signature: \"m m m\" },\n pgftransformcurveattime: { signature: \"m m m m m\" },\n pgftransformarcaxesattime: { signature: \"m m m m m m\" },\n pgfgettransform: { signature: \"m\" },\n pgfsettransform: { signature: \"m\" },\n pgfgettransformentries: { signature: \"m m m m m m\" },\n pgfsettransformentries: { signature: \"m m m m m m\" },\n pgfpointtransformed: { signature: \"m\" },\n pgflowlevel: { signature: \"m\" },\n pgflowlevelobj: { signature: \"m m\" },\n pgflowlevelscope: { signature: \"m\" },\n startpgflowlevelscope: { signature: \"m\" },\n pgfviewboxscope: { signature: \"m m m m m\" },\n startpgfviewboxscope: { signature: \"m m m m m\" },\n pgftransformnonlinear: { signature: \"m\" },\n pgfpointtransformednonlinear: { signature: \"m\" },\n pgfsetcurvilinearbeziercurve: { signature: \"m m m m\" },\n pgfcurvilineardistancetotime: { signature: \"m\" },\n pgfpointcurvilinearbezierorthogonal: { signature: \"m m\" },\n pgfpointcurvilinearbezierpolar: { signature: \"m m\" },\n // Matrices\n pgfmatrix: { signature: \"m m m m m m m\" },\n pgfsetmatrixcolumnsep: { signature: \"m\" },\n pgfmatrixnextcell: { signature: \"o\" },\n pgfsetmatrixrowsep: { signature: \"m\" },\n pgfmatrixendrow: { signature: \"o\" },\n // Nodes and shapes\n pgfnode: { signature: \"m m m m m\" },\n pgfmultipartnode: { signature: \"m m m m\" },\n pgfcoordinate: { signature: \"m m\" },\n pgfnodealias: { signature: \"m m\" },\n pgfnoderename: { signature: \"m m\" },\n pgfpositionnodelater: { signature: \"m\" },\n pgfpositionnodenow: { signature: \"m\" },\n pgfnodepostsetupcode: { signature: \"m m\" },\n pgfpointanchor: { signature: \"m m\" },\n pgfpointshapeborder: { signature: \"m m\" },\n pgfdeclareshape: { signature: \"m m\" },\n saveddimen: { signature: \"m m\" },\n savedmacro: { signature: \" m\" },\n anchor: { signature: \"m m\" },\n deferredanchor: { signature: \"m m\" },\n anchorborder: { signature: \"m\" },\n backgroundpath: { signature: \"m\" },\n foregroundpath: { signature: \"m\" },\n behindbackgroundpath: { signature: \"m\" },\n beforebackgroundpath: { signature: \"m\" },\n beforeforegroundpath: { signature: \"m\" },\n behindforegroundpath: { signature: \"m\" },\n // Arrows\n pgfdeclarearrow: { signature: \"m\" },\n pgfarrowssettipend: { signature: \"m\" },\n pgfarrowssetbackend: { signature: \"m\" },\n pgfarrowssetlineend: { signature: \"m\" },\n pgfarrowssetvisualbackend: { signature: \"m\" },\n pgfarrowssetvisualtipend: { signature: \"m\" },\n pgfarrowshullpoint: { signature: \"m m\" },\n pgfarrowsupperhullpoint: { signature: \"m m\" },\n pgfarrowssave: { signature: \"m\" },\n pgfarrowssavethe: { signature: \"m\" },\n pgfarrowsaddtooptions: { signature: \"m\" },\n pgfarrowsaddtolateoptions: { signature: \"m\" },\n pgfarrowsaddtolengthscalelist: { signature: \"m\" },\n pgfarrowsaddtowidthscalelist: { signature: \"m\" },\n pgfarrowsthreeparameters: { signature: \"m\" },\n pgfarrowslinewidthdependent: { signature: \"m m m\" },\n pgfarrowslengthdependent: { signature: \"m\" },\n // Path\n pgfusepath: { signature: \"m\" },\n pgfsetlinewidth: { signature: \"m\" },\n pgfsetmiterlimit: { signature: \"m\" },\n pgfsetdash: { signature: \"m m\" },\n pgfsetstrokecolor: { signature: \"m\" },\n pgfsetcolor: { signature: \"m\" },\n pgfsetinnerlinewidth: { signature: \"m\" },\n pgfsetinnerstrokecolor: { signature: \"m\" },\n pgfsetarrowsstart: { signature: \"m\" },\n pgfsetarrowsend: { signature: \"m\" },\n pgfsetarrows: { signature: \"m\" },\n pgfsetshortenstart: { signature: \"m\" },\n pgfsetshortenend: { signature: \"m\" },\n pgfsetfillcolor: { signature: \"m\" },\n // Decorations\n pgfdeclaredecoration: { signature: \"m m m\" },\n state: { signature: \"m o m\" },\n pgfdecoratepath: { signature: \"m m\" },\n startpgfdecoration: { signature: \"m\" },\n pgfdecoration: { signature: \"m\" },\n pgfdecoratecurrentpath: { signature: \"m\" },\n pgfsetdecorationsegmenttransformation: { signature: \"m\" },\n pgfdeclaremetadecorate: { signature: \"m m m\" },\n pgfmetadecoration: { signature: \"m\" },\n startpgfmetadecoration: { signature: \"m\" },\n // Constructing paths\n pgfpathmoveto: { signature: \"m\" },\n pgfpathlineto: { signature: \"m\" },\n pgfpathcurveto: { signature: \"m m m\" },\n pgfpathquadraticcurveto: { signature: \"m m\" },\n pgfpathcurvebetweentime: { signature: \"m m m m m m\" },\n pgfpathcurvebetweentimecontinue: { signature: \"m m m m m m\" },\n pgfpatharc: { signature: \"m m m\" },\n pgfpatharcaxes: { signature: \"m m m m\" },\n pgfpatharcto: { signature: \"m m m m m m\" },\n pgfpatharctoprecomputed: { signature: \"m m m m m m m m\" },\n pgfpathellipse: { signature: \"m m m\" },\n pgfpathcircle: { signature: \"m m\" },\n pgfpathrectangle: { signature: \"m m\" },\n pgfpathrectanglecorners: { signature: \"m m\" },\n pgfpathgrid: { signature: \" o m m\" },\n pgfpathparabola: { signature: \"m m\" },\n pgfpathsine: { signature: \"m\" },\n pgfpathcosine: { signature: \"m\" },\n pgfsetcornersarced: { signature: \"m\" },\n \"pgf@protocolsizes\": { signature: \"m m\" },\n // Specifying coordinates\n pgfpoint: { signature: \"m m\" },\n pgfpointpolar: { signature: \"m m m\" },\n pgfpointxy: { signature: \"m m\" },\n pgfsetxvec: { signature: \"m\" },\n pgfsetyvec: { signature: \"m\" },\n pgfpointpolarxy: { signature: \"m m\" },\n pgfpointxyz: { signature: \"m m m\" },\n pgfsetzvec: { signature: \"m\" },\n pgfpointcylindrical: { signature: \"m m m\" },\n pgfpointspherical: { signature: \"m m m\" },\n pgfpointadd: { signature: \"m m\" },\n pgfpointscale: { signature: \"m m\" },\n pgfpointdiff: { signature: \"m m\" },\n pgfpointnormalised: { signature: \"m\" },\n pgfpointlineattime: { signature: \"m m m\" },\n pgfpointlineatdistance: { signature: \"m m m\" },\n pgfpointarcaxesattime: { signature: \"m m m m m m\" },\n pgfpointcurveattime: { signature: \"m m m m m\" },\n pgfpointborderrectangle: { signature: \"m m\" },\n pgfpointborderellipse: { signature: \"m m\" },\n pgfpointintersectionoflines: { signature: \"m m m m\" },\n pgfpointintersectionofcircles: { signature: \"m m m m m\" },\n pgfintersectionofpaths: { signature: \"m m\" },\n pgfpointintersectionsolution: { signature: \"m\" },\n pgfextractx: { signature: \"m m\" },\n pgfextracty: { signature: \"m m\" },\n pgfgetlastxy: { signature: \"m m\" },\n \"pgf@process\": { signature: \"m\" },\n // Heirarchical structres ...\n pgfsetbaseline: { signature: \"m\" },\n pgfsetbaselinepointnow: { signature: \"m\" },\n pgfsetbaselinepointlater: { signature: \"m\" },\n pgftext: { signature: \"o m\", renderInfo: { pgfkeysArgs: true } },\n pgfuseid: { signature: \"m\" },\n pgfusetype: { signature: \"m\" },\n pgfidrefnextuse: { signature: \"m m\" },\n pgfidrefprevuse: { signature: \"m m\" },\n pgfaliasid: { signature: \"m m\" },\n pgfgaliasid: { signature: \"m m\" },\n pgfifidreferenced: { signature: \"m m m\" },\n pgfrdfabout: { signature: \"m\" },\n pgfrdfcontent: { signature: \"m\" },\n pgfrdfdatatype: { signature: \"m\" },\n pgfrdfhref: { signature: \"m\" },\n pgfrdfprefix: { signature: \"m\" },\n pgfrdfproperty: { signature: \"m\" },\n pgfrdfrel: { signature: \"m\" },\n pgfrdfresource: { signature: \"m\" },\n pgfrdfrev: { signature: \"m\" },\n pgfrdfsrc: { signature: \"m\" },\n pgfrdftypeof: { signature: \"m\" },\n pgfrdfvocab: { signature: \"m\" },\n pgferror: { signature: \"m\" },\n pgfwarning: { signature: \"m\" },\n path: {\n signature: \"u;\",\n renderInfo: { breakAround: true, tikzPathCommand: true }\n },\n draw: {\n signature: \"u;\",\n renderInfo: { breakAround: true, tikzPathCommand: true }\n },\n fill: {\n signature: \"u;\",\n renderInfo: { breakAround: true, tikzPathCommand: true }\n },\n filldraw: {\n signature: \"u;\",\n renderInfo: { breakAround: true, tikzPathCommand: true }\n },\n pattern: {\n signature: \"u;\",\n renderInfo: { breakAround: true, tikzPathCommand: true }\n },\n shade: {\n signature: \"u;\",\n renderInfo: { breakAround: true, tikzPathCommand: true }\n },\n clip: {\n signature: \"u;\",\n renderInfo: { breakAround: true, tikzPathCommand: true }\n },\n useasboundingbox: {\n signature: \"u;\",\n renderInfo: { breakAround: true, tikzPathCommand: true }\n },\n node: {\n signature: \"u;\",\n renderInfo: { breakAround: true, tikzPathCommand: true }\n },\n coordinate: {\n signature: \"u;\",\n renderInfo: { breakAround: true, tikzPathCommand: true }\n },\n graph: {\n signature: \"u;\",\n renderInfo: { breakAround: true, tikzPathCommand: true }\n },\n scoped: {\n signature: \"o o m\",\n argumentParser: tikzCommandArgumentParser,\n renderInfo: {\n namedArguments: [\"animation\", \"options\", \"command\"],\n breakAround: true\n }\n }\n};\n\n// package/tikz/libs/print-raw.ts\nimport { printRaw as latexPrintRaw2 } from \"@unified-latex/unified-latex-util-print-raw\";\nimport { trim as trim4 } from \"@unified-latex/unified-latex-util-trim\";\n\n// package/tikz/libs/parser.ts\nimport { match as match7 } from \"@unified-latex/unified-latex-util-match\";\nimport { decorateArrayForPegjs as decorateArrayForPegjs2 } from \"@unified-latex/unified-latex-util-pegjs\";\nimport { TikzPegParser } from \"@unified-latex/unified-latex-util-pegjs\";\nfunction createMatchers() {\n return {\n isChar: match7.string,\n isTerminal: (node) => match7.string(node, \";\"),\n isOperation: (node) => match7.anyString(node) && node.content.match(/[a-zA-Z]/),\n isWhitespace: (node) => match7.whitespace(node) || match7.parbreak(node),\n isComment: match7.comment,\n isGroup: match7.group,\n isMacro: match7.macro,\n isAnyMacro: match7.anyMacro\n };\n}\nvar matchers = createMatchers();\n\n// package/xcolor/provides.ts\nvar macros13 = {\n substitutecolormodel: {\n signature: \"m m\",\n renderInfo: { breakAround: true }\n },\n selectcolormodel: {\n signature: \"m\",\n renderInfo: { breakAround: true }\n },\n definecolor: {\n signature: \"o m m m\",\n renderInfo: { breakAround: true }\n },\n providecolor: {\n signature: \"o m m m\",\n renderInfo: { breakAround: true }\n },\n colorlet: {\n signature: \"o m o m\",\n renderInfo: { breakAround: true }\n },\n definecolorset: {\n signature: \"o m m m\",\n renderInfo: { breakAround: true }\n },\n providecolorset: {\n signature: \"o m m m m\",\n renderInfo: { breakAround: true }\n },\n preparecolor: {\n signature: \"o m m m\",\n renderInfo: { breakAround: true }\n },\n preparecolorset: {\n signature: \"o m m m m\",\n renderInfo: { breakAround: true }\n },\n DefineNamedColor: {\n signature: \"m m m m\",\n renderInfo: { breakAround: true }\n },\n definecolors: {\n signature: \"m\",\n renderInfo: { breakAround: true }\n },\n providecolors: {\n signature: \"m\",\n renderInfo: { breakAround: true }\n },\n color: { signature: \"o m\", renderInfo: { breakAround: true } },\n textcolor: { signature: \"o m m\", renderInfo: { inParMode: true } },\n pagecolor: { signature: \"o m\" },\n colorbox: { signature: \"o m m\" },\n fcolorbox: { signature: \"o m o m m\" },\n boxframe: { signature: \"o m\" },\n testcolor: { signature: \"o m\" },\n blendcolors: { signature: \"s m\" },\n maskcolors: { signature: \"o m\" },\n definecolorseries: {\n signature: \"m m m o m o m\",\n renderInfo: { breakAround: true }\n },\n resetcolorseries: {\n signature: \"o m\",\n renderInfo: { breakAround: true }\n },\n rowcolors: { signature: \"s o m m m\" },\n extractcolorspec: { signature: \"m m\" },\n extractcolorspecs: { signature: \"m m m\" },\n convertcolorspec: { signature: \"m m m m\" }\n};\nvar environments13 = {\n testcolors: { signature: \"o\", renderInfo: { pgfkeysArgs: true } }\n};\n\n// package/xcolor/libs/xcolor.ts\nimport Color2 from \"color\";\n\n// package/xcolor/libs/predefined-colors.ts\nimport Color from \"color\";\nvar fromRgb = ([r, g, b]) => Color([r * 255, g * 255, b * 255], \"rgb\");\nvar DVI_PS_NAMES = {\n Apricot: Color(\"#FBB982\"),\n Aquamarine: Color(\"#00B5BE\"),\n Bittersweet: Color(\"#C04F17\"),\n Black: Color(\"#221E1F\"),\n Blue: Color(\"#2D2F92\"),\n BlueGreen: Color(\"#00B3B8\"),\n BlueViolet: Color(\"#473992\"),\n BrickRed: Color(\"#B6321C\"),\n Brown: Color(\"#792500\"),\n BurntOrange: Color(\"#F7921D\"),\n CadetBlue: Color(\"#74729A\"),\n CarnationPink: Color(\"#F282B4\"),\n Cerulean: Color(\"#00A2E3\"),\n CornflowerBlue: Color(\"#41B0E4\"),\n Cyan: Color(\"#00AEEF\"),\n Dandelion: Color(\"#FDBC42\"),\n DarkOrchid: Color(\"#A4538A\"),\n Emerald: Color(\"#00A99D\"),\n ForestGreen: Color(\"#009B55\"),\n Fuchsia: Color(\"#8C368C\"),\n Goldenrod: Color(\"#FFDF42\"),\n Gray: Color(\"#949698\"),\n Green: Color(\"#00A64F\"),\n GreenYellow: Color(\"#DFE674\"),\n JungleGreen: Color(\"#00A99A\"),\n Lavender: Color(\"#F49EC4\"),\n LimeGreen: Color(\"#8DC73E\"),\n Magenta: Color(\"#EC008C\"),\n Mahogany: Color(\"#A9341F\"),\n Maroon: Color(\"#AF3235\"),\n Melon: Color(\"#F89E7B\"),\n MidnightBlue: Color(\"#006795\"),\n Mulberry: Color(\"#A93C93\"),\n NavyBlue: Color(\"#006EB8\"),\n OliveGreen: Color(\"#3C8031\"),\n Orange: Color(\"#F58137\"),\n OrangeRed: Color(\"#ED135A\"),\n Orchid: Color(\"#AF72B0\"),\n Peach: Color(\"#F7965A\"),\n Periwinkle: Color(\"#7977B8\"),\n PineGreen: Color(\"#008B72\"),\n Plum: Color(\"#92268F\"),\n ProcessBlue: Color(\"#00B0F0\"),\n Purple: Color(\"#99479B\"),\n RawSienna: Color(\"#974006\"),\n Red: Color(\"#ED1B23\"),\n RedOrange: Color(\"#F26035\"),\n RedViolet: Color(\"#A1246B\"),\n Rhodamine: Color(\"#EF559F\"),\n RoyalBlue: Color(\"#0071BC\"),\n RoyalPurple: Color(\"#613F99\"),\n RubineRed: Color(\"#ED017D\"),\n Salmon: Color(\"#F69289\"),\n SeaGreen: Color(\"#3FBC9D\"),\n Sepia: Color(\"#671800\"),\n SkyBlue: Color(\"#46C5DD\"),\n SpringGreen: Color(\"#C6DC67\"),\n Tan: Color(\"#DA9D76\"),\n TealBlue: Color(\"#00AEB3\"),\n Thistle: Color(\"#D883B7\"),\n Turquoise: Color(\"#00B4CE\"),\n Violet: Color(\"#58429B\"),\n VioletRed: Color(\"#EF58A0\"),\n White: Color(\"#FFFFFF\"),\n WildStrawberry: Color(\"#EE2967\"),\n Yellow: Color(\"#FFF200\"),\n YellowGreen: Color(\"#98CC70\"),\n YellowOrange: Color(\"#FAA21A\")\n};\nvar SVG_NAMES = {\n AliceBlue: fromRgb([0.94, 0.972, 1]),\n AntiqueWhite: fromRgb([0.98, 0.92, 0.844]),\n Aqua: fromRgb([0, 1, 1]),\n Aquamarine: fromRgb([0.498, 1, 0.83]),\n Azure: fromRgb([0.94, 1, 1]),\n Beige: fromRgb([0.96, 0.96, 0.864]),\n Bisque: fromRgb([1, 0.894, 0.77]),\n Black: fromRgb([0, 0, 0]),\n BlanchedAlmond: fromRgb([1, 0.92, 0.804]),\n Blue: fromRgb([0, 0, 1]),\n BlueViolet: fromRgb([0.54, 0.17, 0.888]),\n Brown: fromRgb([0.648, 0.165, 0.165]),\n BurlyWood: fromRgb([0.87, 0.72, 0.53]),\n CadetBlue: fromRgb([0.372, 0.62, 0.628]),\n Chartreuse: fromRgb([0.498, 1, 0]),\n Chocolate: fromRgb([0.824, 0.41, 0.116]),\n Coral: fromRgb([1, 0.498, 0.312]),\n CornflowerBlue: fromRgb([0.392, 0.585, 0.93]),\n Cornsilk: fromRgb([1, 0.972, 0.864]),\n Crimson: fromRgb([0.864, 0.08, 0.235]),\n Cyan: fromRgb([0, 1, 1]),\n DarkBlue: fromRgb([0, 0, 0.545]),\n DarkCyan: fromRgb([0, 0.545, 0.545]),\n DarkGoldenrod: fromRgb([0.72, 0.525, 0.044]),\n DarkGray: fromRgb([0.664, 0.664, 0.664]),\n DarkGreen: fromRgb([0, 0.392, 0]),\n DarkGrey: fromRgb([0.664, 0.664, 0.664]),\n DarkKhaki: fromRgb([0.74, 0.716, 0.42]),\n DarkMagenta: fromRgb([0.545, 0, 0.545]),\n DarkOliveGreen: fromRgb([0.332, 0.42, 0.185]),\n DarkOrange: fromRgb([1, 0.55, 0]),\n DarkOrchid: fromRgb([0.6, 0.196, 0.8]),\n DarkRed: fromRgb([0.545, 0, 0]),\n DarkSalmon: fromRgb([0.912, 0.59, 0.48]),\n DarkSeaGreen: fromRgb([0.56, 0.736, 0.56]),\n DarkSlateBlue: fromRgb([0.284, 0.24, 0.545]),\n DarkSlateGray: fromRgb([0.185, 0.31, 0.31]),\n DarkSlateGrey: fromRgb([0.185, 0.31, 0.31]),\n DarkTurquoise: fromRgb([0, 0.808, 0.82]),\n DarkViolet: fromRgb([0.58, 0, 0.828]),\n DeepPink: fromRgb([1, 0.08, 0.576]),\n DeepSkyBlue: fromRgb([0, 0.75, 1]),\n DimGray: fromRgb([0.41, 0.41, 0.41]),\n DimGrey: fromRgb([0.41, 0.41, 0.41]),\n DodgerBlue: fromRgb([0.116, 0.565, 1]),\n FireBrick: fromRgb([0.698, 0.132, 0.132]),\n FloralWhite: fromRgb([1, 0.98, 0.94]),\n ForestGreen: fromRgb([0.132, 0.545, 0.132]),\n Fuchsia: fromRgb([1, 0, 1]),\n Gainsboro: fromRgb([0.864, 0.864, 0.864]),\n GhostWhite: fromRgb([0.972, 0.972, 1]),\n Gold: fromRgb([1, 0.844, 0]),\n Goldenrod: fromRgb([0.855, 0.648, 0.125]),\n Gray: fromRgb([0.5, 0.5, 0.5]),\n Green: fromRgb([0, 0.5, 0]),\n GreenYellow: fromRgb([0.68, 1, 0.185]),\n Grey: fromRgb([0.5, 0.5, 0.5]),\n Honeydew: fromRgb([0.94, 1, 0.94]),\n HotPink: fromRgb([1, 0.41, 0.705]),\n IndianRed: fromRgb([0.804, 0.36, 0.36]),\n Indigo: fromRgb([0.294, 0, 0.51]),\n Ivory: fromRgb([1, 1, 0.94]),\n Khaki: fromRgb([0.94, 0.9, 0.55]),\n Lavender: fromRgb([0.9, 0.9, 0.98]),\n LavenderBlush: fromRgb([1, 0.94, 0.96]),\n LawnGreen: fromRgb([0.488, 0.99, 0]),\n LemonChiffon: fromRgb([1, 0.98, 0.804]),\n LightBlue: fromRgb([0.68, 0.848, 0.9]),\n LightCoral: fromRgb([0.94, 0.5, 0.5]),\n LightCyan: fromRgb([0.88, 1, 1]),\n LightGoldenrod: fromRgb([0.933, 0.867, 0.51]),\n LightGoldenrodYellow: fromRgb([0.98, 0.98, 0.824]),\n LightGray: fromRgb([0.828, 0.828, 0.828]),\n LightGreen: fromRgb([0.565, 0.932, 0.565]),\n LightGrey: fromRgb([0.828, 0.828, 0.828]),\n LightPink: fromRgb([1, 0.712, 0.756]),\n LightSalmon: fromRgb([1, 0.628, 0.48]),\n LightSeaGreen: fromRgb([0.125, 0.698, 0.668]),\n LightSkyBlue: fromRgb([0.53, 0.808, 0.98]),\n LightSlateBlue: fromRgb([0.518, 0.44, 1]),\n LightSlateGray: fromRgb([0.468, 0.532, 0.6]),\n LightSlateGrey: fromRgb([0.468, 0.532, 0.6]),\n LightSteelBlue: fromRgb([0.69, 0.77, 0.87]),\n LightYellow: fromRgb([1, 1, 0.88]),\n Lime: fromRgb([0, 1, 0]),\n LimeGreen: fromRgb([0.196, 0.804, 0.196]),\n Linen: fromRgb([0.98, 0.94, 0.9]),\n Magenta: fromRgb([1, 0, 1]),\n Maroon: fromRgb([0.5, 0, 0]),\n MediumAquamarine: fromRgb([0.4, 0.804, 0.668]),\n MediumBlue: fromRgb([0, 0, 0.804]),\n MediumOrchid: fromRgb([0.73, 0.332, 0.828]),\n MediumPurple: fromRgb([0.576, 0.44, 0.86]),\n MediumSeaGreen: fromRgb([0.235, 0.7, 0.444]),\n MediumSlateBlue: fromRgb([0.484, 0.408, 0.932]),\n MediumSpringGreen: fromRgb([0, 0.98, 0.604]),\n MediumTurquoise: fromRgb([0.284, 0.82, 0.8]),\n MediumVioletRed: fromRgb([0.78, 0.084, 0.52]),\n MidnightBlue: fromRgb([0.098, 0.098, 0.44]),\n MintCream: fromRgb([0.96, 1, 0.98]),\n MistyRose: fromRgb([1, 0.894, 0.884]),\n Moccasin: fromRgb([1, 0.894, 0.71]),\n NavajoWhite: fromRgb([1, 0.87, 0.68]),\n Navy: fromRgb([0, 0, 0.5]),\n NavyBlue: fromRgb([0, 0, 0.5]),\n OldLace: fromRgb([0.992, 0.96, 0.9]),\n Olive: fromRgb([0.5, 0.5, 0]),\n OliveDrab: fromRgb([0.42, 0.556, 0.136]),\n Orange: fromRgb([1, 0.648, 0]),\n OrangeRed: fromRgb([1, 0.27, 0]),\n Orchid: fromRgb([0.855, 0.44, 0.84]),\n PaleGoldenrod: fromRgb([0.932, 0.91, 0.668]),\n PaleGreen: fromRgb([0.596, 0.985, 0.596]),\n PaleTurquoise: fromRgb([0.688, 0.932, 0.932]),\n PaleVioletRed: fromRgb([0.86, 0.44, 0.576]),\n PapayaWhip: fromRgb([1, 0.936, 0.835]),\n PeachPuff: fromRgb([1, 0.855, 0.725]),\n Peru: fromRgb([0.804, 0.52, 0.248]),\n Pink: fromRgb([1, 0.752, 0.796]),\n Plum: fromRgb([0.868, 0.628, 0.868]),\n PowderBlue: fromRgb([0.69, 0.88, 0.9]),\n Purple: fromRgb([0.5, 0, 0.5]),\n Red: fromRgb([1, 0, 0]),\n RosyBrown: fromRgb([0.736, 0.56, 0.56]),\n RoyalBlue: fromRgb([0.255, 0.41, 0.884]),\n SaddleBrown: fromRgb([0.545, 0.27, 0.075]),\n Salmon: fromRgb([0.98, 0.5, 0.448]),\n SandyBrown: fromRgb([0.956, 0.644, 0.376]),\n SeaGreen: fromRgb([0.18, 0.545, 0.34]),\n Seashell: fromRgb([1, 0.96, 0.932]),\n Sienna: fromRgb([0.628, 0.32, 0.176]),\n Silver: fromRgb([0.752, 0.752, 0.752]),\n SkyBlue: fromRgb([0.53, 0.808, 0.92]),\n SlateBlue: fromRgb([0.415, 0.352, 0.804]),\n SlateGray: fromRgb([0.44, 0.5, 0.565]),\n SlateGrey: fromRgb([0.44, 0.5, 0.565]),\n Snow: fromRgb([1, 0.98, 0.98]),\n SpringGreen: fromRgb([0, 1, 0.498]),\n SteelBlue: fromRgb([0.275, 0.51, 0.705]),\n Tan: fromRgb([0.824, 0.705, 0.55]),\n Teal: fromRgb([0, 0.5, 0.5]),\n Thistle: fromRgb([0.848, 0.75, 0.848]),\n Tomato: fromRgb([1, 0.39, 0.28]),\n Turquoise: fromRgb([0.25, 0.88, 0.815]),\n Violet: fromRgb([0.932, 0.51, 0.932]),\n VioletRed: fromRgb([0.816, 0.125, 0.565]),\n Wheat: fromRgb([0.96, 0.87, 0.7]),\n White: fromRgb([1, 1, 1]),\n WhiteSmoke: fromRgb([0.96, 0.96, 0.96]),\n Yellow: fromRgb([1, 1, 0]),\n YellowGreen: fromRgb([0.604, 0.804, 0.196])\n};\nvar X11_NAMES = {\n AntiqueWhite1: fromRgb([1, 0.936, 0.86]),\n AntiqueWhite2: fromRgb([0.932, 0.875, 0.8]),\n AntiqueWhite3: fromRgb([0.804, 0.752, 0.69]),\n AntiqueWhite4: fromRgb([0.545, 0.512, 0.47]),\n Aquamarine1: fromRgb([0.498, 1, 0.83]),\n Aquamarine2: fromRgb([0.464, 0.932, 0.776]),\n Aquamarine3: fromRgb([0.4, 0.804, 0.668]),\n Aquamarine4: fromRgb([0.27, 0.545, 0.455]),\n Azure1: fromRgb([0.94, 1, 1]),\n Azure2: fromRgb([0.88, 0.932, 0.932]),\n Azure3: fromRgb([0.756, 0.804, 0.804]),\n Azure4: fromRgb([0.512, 0.545, 0.545]),\n Bisque1: fromRgb([1, 0.894, 0.77]),\n Bisque2: fromRgb([0.932, 0.835, 0.716]),\n Bisque3: fromRgb([0.804, 0.716, 0.62]),\n Bisque4: fromRgb([0.545, 0.49, 0.42]),\n Blue1: fromRgb([0, 0, 1]),\n Blue2: fromRgb([0, 0, 0.932]),\n Blue3: fromRgb([0, 0, 0.804]),\n Blue4: fromRgb([0, 0, 0.545]),\n Brown1: fromRgb([1, 0.25, 0.25]),\n Brown2: fromRgb([0.932, 0.23, 0.23]),\n Brown3: fromRgb([0.804, 0.2, 0.2]),\n Brown4: fromRgb([0.545, 0.136, 0.136]),\n Burlywood1: fromRgb([1, 0.828, 0.608]),\n Burlywood2: fromRgb([0.932, 0.772, 0.57]),\n Burlywood3: fromRgb([0.804, 0.668, 0.49]),\n Burlywood4: fromRgb([0.545, 0.45, 0.332]),\n CadetBlue1: fromRgb([0.596, 0.96, 1]),\n CadetBlue2: fromRgb([0.556, 0.898, 0.932]),\n CadetBlue3: fromRgb([0.48, 0.772, 0.804]),\n CadetBlue4: fromRgb([0.325, 0.525, 0.545]),\n Chartreuse1: fromRgb([0.498, 1, 0]),\n Chartreuse2: fromRgb([0.464, 0.932, 0]),\n Chartreuse3: fromRgb([0.4, 0.804, 0]),\n Chartreuse4: fromRgb([0.27, 0.545, 0]),\n Chocolate1: fromRgb([1, 0.498, 0.14]),\n Chocolate2: fromRgb([0.932, 0.464, 0.13]),\n Chocolate3: fromRgb([0.804, 0.4, 0.112]),\n Chocolate4: fromRgb([0.545, 0.27, 0.075]),\n Coral1: fromRgb([1, 0.448, 0.336]),\n Coral2: fromRgb([0.932, 0.415, 0.312]),\n Coral3: fromRgb([0.804, 0.356, 0.27]),\n Coral4: fromRgb([0.545, 0.244, 0.185]),\n Cornsilk1: fromRgb([1, 0.972, 0.864]),\n Cornsilk2: fromRgb([0.932, 0.91, 0.804]),\n Cornsilk3: fromRgb([0.804, 0.785, 0.694]),\n Cornsilk4: fromRgb([0.545, 0.532, 0.47]),\n Cyan1: fromRgb([0, 1, 1]),\n Cyan2: fromRgb([0, 0.932, 0.932]),\n Cyan3: fromRgb([0, 0.804, 0.804]),\n Cyan4: fromRgb([0, 0.545, 0.545]),\n DarkGoldenrod1: fromRgb([1, 0.725, 0.06]),\n DarkGoldenrod2: fromRgb([0.932, 0.68, 0.055]),\n DarkGoldenrod3: fromRgb([0.804, 0.585, 0.048]),\n DarkGoldenrod4: fromRgb([0.545, 0.396, 0.03]),\n DarkOliveGreen1: fromRgb([0.792, 1, 0.44]),\n DarkOliveGreen2: fromRgb([0.736, 0.932, 0.408]),\n DarkOliveGreen3: fromRgb([0.635, 0.804, 0.352]),\n DarkOliveGreen4: fromRgb([0.43, 0.545, 0.24]),\n DarkOrange1: fromRgb([1, 0.498, 0]),\n DarkOrange2: fromRgb([0.932, 0.464, 0]),\n DarkOrange3: fromRgb([0.804, 0.4, 0]),\n DarkOrange4: fromRgb([0.545, 0.27, 0]),\n DarkOrchid1: fromRgb([0.75, 0.244, 1]),\n DarkOrchid2: fromRgb([0.698, 0.228, 0.932]),\n DarkOrchid3: fromRgb([0.604, 0.196, 0.804]),\n DarkOrchid4: fromRgb([0.408, 0.132, 0.545]),\n DarkSeaGreen1: fromRgb([0.756, 1, 0.756]),\n DarkSeaGreen2: fromRgb([0.705, 0.932, 0.705]),\n DarkSeaGreen3: fromRgb([0.608, 0.804, 0.608]),\n DarkSeaGreen4: fromRgb([0.41, 0.545, 0.41]),\n DarkSlateGray1: fromRgb([0.592, 1, 1]),\n DarkSlateGray2: fromRgb([0.552, 0.932, 0.932]),\n DarkSlateGray3: fromRgb([0.475, 0.804, 0.804]),\n DarkSlateGray4: fromRgb([0.32, 0.545, 0.545]),\n DeepPink1: fromRgb([1, 0.08, 0.576]),\n DeepPink2: fromRgb([0.932, 0.07, 0.536]),\n DeepPink3: fromRgb([0.804, 0.064, 0.464]),\n DeepPink4: fromRgb([0.545, 0.04, 0.312]),\n DeepSkyBlue1: fromRgb([0, 0.75, 1]),\n DeepSkyBlue2: fromRgb([0, 0.698, 0.932]),\n DeepSkyBlue3: fromRgb([0, 0.604, 0.804]),\n DeepSkyBlue4: fromRgb([0, 0.408, 0.545]),\n DodgerBlue1: fromRgb([0.116, 0.565, 1]),\n DodgerBlue2: fromRgb([0.11, 0.525, 0.932]),\n DodgerBlue3: fromRgb([0.094, 0.455, 0.804]),\n DodgerBlue4: fromRgb([0.064, 0.305, 0.545]),\n Firebrick1: fromRgb([1, 0.19, 0.19]),\n Firebrick2: fromRgb([0.932, 0.172, 0.172]),\n Firebrick3: fromRgb([0.804, 0.15, 0.15]),\n Firebrick4: fromRgb([0.545, 0.1, 0.1]),\n Gold1: fromRgb([1, 0.844, 0]),\n Gold2: fromRgb([0.932, 0.79, 0]),\n Gold3: fromRgb([0.804, 0.68, 0]),\n Gold4: fromRgb([0.545, 0.46, 0]),\n Goldenrod1: fromRgb([1, 0.756, 0.145]),\n Goldenrod2: fromRgb([0.932, 0.705, 0.132]),\n Goldenrod3: fromRgb([0.804, 0.608, 0.112]),\n Goldenrod4: fromRgb([0.545, 0.41, 0.08]),\n Green1: fromRgb([0, 1, 0]),\n Green2: fromRgb([0, 0.932, 0]),\n Green3: fromRgb([0, 0.804, 0]),\n Green4: fromRgb([0, 0.545, 0]),\n Honeydew1: fromRgb([0.94, 1, 0.94]),\n Honeydew2: fromRgb([0.88, 0.932, 0.88]),\n Honeydew3: fromRgb([0.756, 0.804, 0.756]),\n Honeydew4: fromRgb([0.512, 0.545, 0.512]),\n HotPink1: fromRgb([1, 0.43, 0.705]),\n HotPink2: fromRgb([0.932, 0.415, 0.655]),\n HotPink3: fromRgb([0.804, 0.376, 0.565]),\n HotPink4: fromRgb([0.545, 0.228, 0.385]),\n IndianRed1: fromRgb([1, 0.415, 0.415]),\n IndianRed2: fromRgb([0.932, 0.39, 0.39]),\n IndianRed3: fromRgb([0.804, 0.332, 0.332]),\n IndianRed4: fromRgb([0.545, 0.228, 0.228]),\n Ivory1: fromRgb([1, 1, 0.94]),\n Ivory2: fromRgb([0.932, 0.932, 0.88]),\n Ivory3: fromRgb([0.804, 0.804, 0.756]),\n Ivory4: fromRgb([0.545, 0.545, 0.512]),\n Khaki1: fromRgb([1, 0.965, 0.56]),\n Khaki2: fromRgb([0.932, 0.9, 0.52]),\n Khaki3: fromRgb([0.804, 0.776, 0.45]),\n Khaki4: fromRgb([0.545, 0.525, 0.305]),\n LavenderBlush1: fromRgb([1, 0.94, 0.96]),\n LavenderBlush2: fromRgb([0.932, 0.88, 0.898]),\n LavenderBlush3: fromRgb([0.804, 0.756, 0.772]),\n LavenderBlush4: fromRgb([0.545, 0.512, 0.525]),\n LemonChiffon1: fromRgb([1, 0.98, 0.804]),\n LemonChiffon2: fromRgb([0.932, 0.912, 0.75]),\n LemonChiffon3: fromRgb([0.804, 0.79, 0.648]),\n LemonChiffon4: fromRgb([0.545, 0.536, 0.44]),\n LightBlue1: fromRgb([0.75, 0.936, 1]),\n LightBlue2: fromRgb([0.698, 0.875, 0.932]),\n LightBlue3: fromRgb([0.604, 0.752, 0.804]),\n LightBlue4: fromRgb([0.408, 0.512, 0.545]),\n LightCyan1: fromRgb([0.88, 1, 1]),\n LightCyan2: fromRgb([0.82, 0.932, 0.932]),\n LightCyan3: fromRgb([0.705, 0.804, 0.804]),\n LightCyan4: fromRgb([0.48, 0.545, 0.545]),\n LightGoldenrod1: fromRgb([1, 0.925, 0.545]),\n LightGoldenrod2: fromRgb([0.932, 0.864, 0.51]),\n LightGoldenrod3: fromRgb([0.804, 0.745, 0.44]),\n LightGoldenrod4: fromRgb([0.545, 0.505, 0.298]),\n LightPink1: fromRgb([1, 0.684, 0.725]),\n LightPink2: fromRgb([0.932, 0.635, 0.68]),\n LightPink3: fromRgb([0.804, 0.55, 0.585]),\n LightPink4: fromRgb([0.545, 0.372, 0.396]),\n LightSalmon1: fromRgb([1, 0.628, 0.48]),\n LightSalmon2: fromRgb([0.932, 0.585, 0.448]),\n LightSalmon3: fromRgb([0.804, 0.505, 0.385]),\n LightSalmon4: fromRgb([0.545, 0.34, 0.26]),\n LightSkyBlue1: fromRgb([0.69, 0.888, 1]),\n LightSkyBlue2: fromRgb([0.644, 0.828, 0.932]),\n LightSkyBlue3: fromRgb([0.552, 0.712, 0.804]),\n LightSkyBlue4: fromRgb([0.376, 0.484, 0.545]),\n LightSteelBlue1: fromRgb([0.792, 0.884, 1]),\n LightSteelBlue2: fromRgb([0.736, 0.824, 0.932]),\n LightSteelBlue3: fromRgb([0.635, 0.71, 0.804]),\n LightSteelBlue4: fromRgb([0.43, 0.484, 0.545]),\n LightYellow1: fromRgb([1, 1, 0.88]),\n LightYellow2: fromRgb([0.932, 0.932, 0.82]),\n LightYellow3: fromRgb([0.804, 0.804, 0.705]),\n LightYellow4: fromRgb([0.545, 0.545, 0.48]),\n Magenta1: fromRgb([1, 0, 1]),\n Magenta2: fromRgb([0.932, 0, 0.932]),\n Magenta3: fromRgb([0.804, 0, 0.804]),\n Magenta4: fromRgb([0.545, 0, 0.545]),\n Maroon1: fromRgb([1, 0.204, 0.7]),\n Maroon2: fromRgb([0.932, 0.19, 0.655]),\n Maroon3: fromRgb([0.804, 0.16, 0.565]),\n Maroon4: fromRgb([0.545, 0.11, 0.385]),\n MediumOrchid1: fromRgb([0.88, 0.4, 1]),\n MediumOrchid2: fromRgb([0.82, 0.372, 0.932]),\n MediumOrchid3: fromRgb([0.705, 0.32, 0.804]),\n MediumOrchid4: fromRgb([0.48, 0.215, 0.545]),\n MediumPurple1: fromRgb([0.67, 0.51, 1]),\n MediumPurple2: fromRgb([0.624, 0.475, 0.932]),\n MediumPurple3: fromRgb([0.536, 0.408, 0.804]),\n MediumPurple4: fromRgb([0.365, 0.28, 0.545]),\n MistyRose1: fromRgb([1, 0.894, 0.884]),\n MistyRose2: fromRgb([0.932, 0.835, 0.824]),\n MistyRose3: fromRgb([0.804, 0.716, 0.71]),\n MistyRose4: fromRgb([0.545, 0.49, 0.484]),\n NavajoWhite1: fromRgb([1, 0.87, 0.68]),\n NavajoWhite2: fromRgb([0.932, 0.81, 0.63]),\n NavajoWhite3: fromRgb([0.804, 0.7, 0.545]),\n NavajoWhite4: fromRgb([0.545, 0.475, 0.37]),\n OliveDrab1: fromRgb([0.752, 1, 0.244]),\n OliveDrab2: fromRgb([0.7, 0.932, 0.228]),\n OliveDrab3: fromRgb([0.604, 0.804, 0.196]),\n OliveDrab4: fromRgb([0.41, 0.545, 0.132]),\n Orange1: fromRgb([1, 0.648, 0]),\n Orange2: fromRgb([0.932, 0.604, 0]),\n Orange3: fromRgb([0.804, 0.52, 0]),\n Orange4: fromRgb([0.545, 0.352, 0]),\n OrangeRed1: fromRgb([1, 0.27, 0]),\n OrangeRed2: fromRgb([0.932, 0.25, 0]),\n OrangeRed3: fromRgb([0.804, 0.215, 0]),\n OrangeRed4: fromRgb([0.545, 0.145, 0]),\n Orchid1: fromRgb([1, 0.512, 0.98]),\n Orchid2: fromRgb([0.932, 0.48, 0.912]),\n Orchid3: fromRgb([0.804, 0.41, 0.79]),\n Orchid4: fromRgb([0.545, 0.28, 0.536]),\n PaleGreen1: fromRgb([0.604, 1, 0.604]),\n PaleGreen2: fromRgb([0.565, 0.932, 0.565]),\n PaleGreen3: fromRgb([0.488, 0.804, 0.488]),\n PaleGreen4: fromRgb([0.33, 0.545, 0.33]),\n PaleTurquoise1: fromRgb([0.732, 1, 1]),\n PaleTurquoise2: fromRgb([0.684, 0.932, 0.932]),\n PaleTurquoise3: fromRgb([0.59, 0.804, 0.804]),\n PaleTurquoise4: fromRgb([0.4, 0.545, 0.545]),\n PaleVioletRed1: fromRgb([1, 0.51, 0.67]),\n PaleVioletRed2: fromRgb([0.932, 0.475, 0.624]),\n PaleVioletRed3: fromRgb([0.804, 0.408, 0.536]),\n PaleVioletRed4: fromRgb([0.545, 0.28, 0.365]),\n PeachPuff1: fromRgb([1, 0.855, 0.725]),\n PeachPuff2: fromRgb([0.932, 0.796, 0.68]),\n PeachPuff3: fromRgb([0.804, 0.688, 0.585]),\n PeachPuff4: fromRgb([0.545, 0.468, 0.396]),\n Pink1: fromRgb([1, 0.71, 0.772]),\n Pink2: fromRgb([0.932, 0.664, 0.72]),\n Pink3: fromRgb([0.804, 0.57, 0.62]),\n Pink4: fromRgb([0.545, 0.39, 0.424]),\n Plum1: fromRgb([1, 0.732, 1]),\n Plum2: fromRgb([0.932, 0.684, 0.932]),\n Plum3: fromRgb([0.804, 0.59, 0.804]),\n Plum4: fromRgb([0.545, 0.4, 0.545]),\n Purple1: fromRgb([0.608, 0.19, 1]),\n Purple2: fromRgb([0.57, 0.172, 0.932]),\n Purple3: fromRgb([0.49, 0.15, 0.804]),\n Purple4: fromRgb([0.332, 0.1, 0.545]),\n Red1: fromRgb([1, 0, 0]),\n Red2: fromRgb([0.932, 0, 0]),\n Red3: fromRgb([0.804, 0, 0]),\n Red4: fromRgb([0.545, 0, 0]),\n RosyBrown1: fromRgb([1, 0.756, 0.756]),\n RosyBrown2: fromRgb([0.932, 0.705, 0.705]),\n RosyBrown3: fromRgb([0.804, 0.608, 0.608]),\n RosyBrown4: fromRgb([0.545, 0.41, 0.41]),\n RoyalBlue1: fromRgb([0.284, 0.464, 1]),\n RoyalBlue2: fromRgb([0.264, 0.43, 0.932]),\n RoyalBlue3: fromRgb([0.228, 0.372, 0.804]),\n RoyalBlue4: fromRgb([0.152, 0.25, 0.545]),\n Salmon1: fromRgb([1, 0.55, 0.41]),\n Salmon2: fromRgb([0.932, 0.51, 0.385]),\n Salmon3: fromRgb([0.804, 0.44, 0.33]),\n Salmon4: fromRgb([0.545, 0.298, 0.224]),\n SeaGreen1: fromRgb([0.33, 1, 0.624]),\n SeaGreen2: fromRgb([0.305, 0.932, 0.58]),\n SeaGreen3: fromRgb([0.264, 0.804, 0.5]),\n SeaGreen4: fromRgb([0.18, 0.545, 0.34]),\n Seashell1: fromRgb([1, 0.96, 0.932]),\n Seashell2: fromRgb([0.932, 0.898, 0.87]),\n Seashell3: fromRgb([0.804, 0.772, 0.75]),\n Seashell4: fromRgb([0.545, 0.525, 0.51]),\n Sienna1: fromRgb([1, 0.51, 0.28]),\n Sienna2: fromRgb([0.932, 0.475, 0.26]),\n Sienna3: fromRgb([0.804, 0.408, 0.224]),\n Sienna4: fromRgb([0.545, 0.28, 0.15]),\n SkyBlue1: fromRgb([0.53, 0.808, 1]),\n SkyBlue2: fromRgb([0.494, 0.752, 0.932]),\n SkyBlue3: fromRgb([0.424, 0.65, 0.804]),\n SkyBlue4: fromRgb([0.29, 0.44, 0.545]),\n SlateBlue1: fromRgb([0.512, 0.435, 1]),\n SlateBlue2: fromRgb([0.48, 0.404, 0.932]),\n SlateBlue3: fromRgb([0.41, 0.35, 0.804]),\n SlateBlue4: fromRgb([0.28, 0.235, 0.545]),\n SlateGray1: fromRgb([0.776, 0.888, 1]),\n SlateGray2: fromRgb([0.725, 0.828, 0.932]),\n SlateGray3: fromRgb([0.624, 0.712, 0.804]),\n SlateGray4: fromRgb([0.424, 0.484, 0.545]),\n Snow1: fromRgb([1, 0.98, 0.98]),\n Snow2: fromRgb([0.932, 0.912, 0.912]),\n Snow3: fromRgb([0.804, 0.79, 0.79]),\n Snow4: fromRgb([0.545, 0.536, 0.536]),\n SpringGreen1: fromRgb([0, 1, 0.498]),\n SpringGreen2: fromRgb([0, 0.932, 0.464]),\n SpringGreen3: fromRgb([0, 0.804, 0.4]),\n SpringGreen4: fromRgb([0, 0.545, 0.27]),\n SteelBlue1: fromRgb([0.39, 0.72, 1]),\n SteelBlue2: fromRgb([0.36, 0.675, 0.932]),\n SteelBlue3: fromRgb([0.31, 0.58, 0.804]),\n SteelBlue4: fromRgb([0.21, 0.392, 0.545]),\n Tan1: fromRgb([1, 0.648, 0.31]),\n Tan2: fromRgb([0.932, 0.604, 0.288]),\n Tan3: fromRgb([0.804, 0.52, 0.248]),\n Tan4: fromRgb([0.545, 0.352, 0.17]),\n Thistle1: fromRgb([1, 0.884, 1]),\n Thistle2: fromRgb([0.932, 0.824, 0.932]),\n Thistle3: fromRgb([0.804, 0.71, 0.804]),\n Thistle4: fromRgb([0.545, 0.484, 0.545]),\n Tomato1: fromRgb([1, 0.39, 0.28]),\n Tomato2: fromRgb([0.932, 0.36, 0.26]),\n Tomato3: fromRgb([0.804, 0.31, 0.224]),\n Tomato4: fromRgb([0.545, 0.21, 0.15]),\n Turquoise1: fromRgb([0, 0.96, 1]),\n Turquoise2: fromRgb([0, 0.898, 0.932]),\n Turquoise3: fromRgb([0, 0.772, 0.804]),\n Turquoise4: fromRgb([0, 0.525, 0.545]),\n VioletRed1: fromRgb([1, 0.244, 0.59]),\n VioletRed2: fromRgb([0.932, 0.228, 0.55]),\n VioletRed3: fromRgb([0.804, 0.196, 0.47]),\n VioletRed4: fromRgb([0.545, 0.132, 0.32]),\n Wheat1: fromRgb([1, 0.905, 0.73]),\n Wheat2: fromRgb([0.932, 0.848, 0.684]),\n Wheat3: fromRgb([0.804, 0.73, 0.59]),\n Wheat4: fromRgb([0.545, 0.494, 0.4]),\n Yellow1: fromRgb([1, 1, 0]),\n Yellow2: fromRgb([0.932, 0.932, 0]),\n Yellow3: fromRgb([0.804, 0.804, 0]),\n Yellow4: fromRgb([0.545, 0.545, 0]),\n Gray0: fromRgb([0.745, 0.745, 0.745]),\n Green0: fromRgb([0, 1, 0]),\n Grey0: fromRgb([0.745, 0.745, 0.745]),\n Maroon0: fromRgb([0.69, 0.19, 0.376]),\n Purple0: fromRgb([0.628, 0.125, 0.94])\n};\n\n// package/xcolor/libs/parser.ts\nimport { XColorPegParser } from \"@unified-latex/unified-latex-util-pegjs\";\n\n// package/xcolor/libs/xcolor.ts\nvar XColorCoreModelToColor = {\n rgb: ([r, g, b]) => Color2([r * 255, g * 255, b * 255], \"rgb\"),\n cmy: ([c, m, y]) => XColorCoreModelToColor.rgb([1 - c, 1 - m, 1 - y]),\n cmyk: ([c, m, y, k]) => Color2([c * 255, m * 255, y * 255, k * 100], \"cmyk\"),\n hsb: ([h, s, b]) => Color2([h * 360, s * 100, b * 100], \"hsv\"),\n gray: ([v]) => Color2([v * 255, v * 255, v * 255], \"rgb\")\n};\nvar XColorModelToColor = {\n wave: ([lambda]) => {\n const gamma = 0.8;\n let baseRgb = [0, 0, 0];\n if (380 <= lambda && lambda < 440) {\n baseRgb = [(440 - lambda) / (440 - 380), 0, 1];\n }\n if (440 <= lambda && lambda < 490) {\n baseRgb = [0, (lambda - 440) / (490 - 440), 1];\n }\n if (490 <= lambda && lambda < 510) {\n baseRgb = [0, 1, (510 - lambda) / (510 - 490)];\n }\n if (510 <= lambda && lambda < 580) {\n baseRgb = [(lambda - 510) / (580 - 510), 1, 0];\n }\n if (580 <= lambda && lambda < 6450) {\n baseRgb = [1, (645 - lambda) / (645 - 580), 0];\n }\n if (645 <= lambda && lambda <= 780) {\n baseRgb = [1, 0, 0];\n }\n let f = 1;\n if (380 <= lambda && 420 < lambda) {\n f = 0.3 + 0.7 * (lambda - 380) / (420 - 380);\n }\n if (700 < lambda && lambda <= 780) {\n f = 0.3 + 0.7 * (780 - lambda) / (780 - 700);\n }\n const rgb = [\n Math.pow(baseRgb[0] * f, gamma),\n Math.pow(baseRgb[1] * f, gamma),\n Math.pow(baseRgb[2] * f, gamma)\n ];\n return Color2([rgb[0] * 255, rgb[1] * 255, rgb[2] * 255], \"rgb\");\n },\n Hsb: ([h, s, b]) => XColorCoreModelToColor.hsb([h / 360, s, b]),\n HSB: ([h, s, b]) => XColorCoreModelToColor.hsb([h / 240, s / 240, b / 240]),\n HTML: ([v]) => v.startsWith(\"#\") ? Color2(v) : Color2(`#${v}`),\n RGB: ([r, g, b]) => Color2([r, g, b], \"rgb\"),\n Gray: ([v]) => XColorCoreModelToColor.gray([v / 15]),\n ...XColorCoreModelToColor\n};\nvar PREDEFINED_XCOLOR_COLORS = {\n // Core colors\n red: XColorCoreModelToColor.rgb([1, 0, 0]),\n green: XColorCoreModelToColor.rgb([0, 1, 0]),\n blue: XColorCoreModelToColor.rgb([0, 0, 1]),\n brown: XColorCoreModelToColor.rgb([0.75, 0.5, 0.25]),\n lime: XColorCoreModelToColor.rgb([0.75, 1, 0]),\n orange: XColorCoreModelToColor.rgb([1, 0.5, 0]),\n pink: XColorCoreModelToColor.rgb([1, 0.75, 0.75]),\n purple: XColorCoreModelToColor.rgb([0.75, 0, 0.25]),\n teal: XColorCoreModelToColor.rgb([0, 0.5, 0.5]),\n violet: XColorCoreModelToColor.rgb([0.5, 0, 0.5]),\n cyan: XColorCoreModelToColor.rgb([0, 1, 1]),\n magenta: XColorCoreModelToColor.rgb([1, 0, 1]),\n yellow: XColorCoreModelToColor.rgb([1, 1, 0]),\n olive: XColorCoreModelToColor.rgb([0.5, 0.5, 0]),\n black: XColorCoreModelToColor.rgb([0, 0, 0]),\n darkgray: XColorCoreModelToColor.rgb([0.25, 0.25, 0.25]),\n gray: XColorCoreModelToColor.rgb([0.5, 0.5, 0.5]),\n lightgray: XColorCoreModelToColor.rgb([0.75, 0.75, 0.75]),\n white: XColorCoreModelToColor.rgb([1, 1, 1]),\n ...DVI_PS_NAMES,\n ...SVG_NAMES,\n ...X11_NAMES\n};\n\n// package/xcolor/libs/xcolor-macro-to-hex.ts\nimport { getArgsContent as getArgsContent2 } from \"@unified-latex/unified-latex-util-arguments\";\nimport { printRaw as printRaw2 } from \"@unified-latex/unified-latex-util-print-raw\";\nimport { deleteComments as deleteComments2 } from \"@unified-latex/unified-latex-util-comments\";\n\n// package/xcolor/libs/color-to-textcolor-macro.ts\nimport { arg as arg5 } from \"@unified-latex/unified-latex-builder\";\n\n// package/xparse/provides.ts\nvar macros14 = {\n NewDocumentCommand: {\n signature: \"m m m\",\n renderInfo: { breakAround: true }\n },\n RenewDocumentCommand: {\n signature: \"m m m\",\n renderInfo: { breakAround: true }\n },\n ProvideDocumentCommand: {\n signature: \"m m m\",\n renderInfo: { breakAround: true }\n },\n DeclareDocumentCommand: {\n signature: \"m m m\",\n renderInfo: { breakAround: true }\n },\n NewDocumentEnvironment: {\n signature: \"m m m m\",\n renderInfo: { breakAround: true }\n },\n RenewDocumentEnvironment: {\n signature: \"m m m m\",\n renderInfo: { breakAround: true }\n },\n ProvideDocumentEnvironment: {\n signature: \"m m m m\",\n renderInfo: { breakAround: true }\n },\n DeclareDocumentEnvironment: {\n signature: \"m m m m\",\n renderInfo: { breakAround: true }\n },\n NewExpandableDocumentCommand: {\n signature: \"m m m\",\n renderInfo: { breakAround: true }\n },\n RenewExpandableDocumentCommand: {\n signature: \"m m m\",\n renderInfo: { breakAround: true }\n },\n ProvideExpandableDocumentCommand: {\n signature: \"m m m\",\n renderInfo: { breakAround: true }\n },\n DeclareExpandableDocumentCommand: {\n signature: \"m m m\",\n renderInfo: { breakAround: true }\n },\n RequirePackage: {\n signature: \"o m\",\n renderInfo: { pgfkeysArgs: true, breakAround: true }\n },\n DeclareOption: { signature: \"m m\", renderInfo: { breakAround: true } }\n};\nvar environments14 = {};\n\n// package/beamer/provides.ts\nvar macros15 = {\n mode: { signature: \"s d<> d{}\", renderInfo: { breakAround: true } },\n insertnavigation: { signature: \"m\", renderInfo: { breakAround: true } },\n insertsectionnavigation: {\n signature: \"m\",\n renderInfo: { breakAround: true }\n },\n insertsectionnavigationhorizontal: {\n signature: \"m m m\",\n renderInfo: { breakAround: true }\n },\n insertauthor: { signature: \"o\", renderInfo: { breakAround: true } },\n insertshortauthor: { signature: \"o\", renderInfo: { breakAround: true } },\n insertshortdate: { signature: \"o\", renderInfo: { breakAround: true } },\n insertshortinstitute: { signature: \"o\", renderInfo: { breakAround: true } },\n insertshortpart: { signature: \"o\", renderInfo: { breakAround: true } },\n insertshorttitle: { signature: \"o\", renderInfo: { breakAround: true } },\n insertsubsectionnavigation: {\n signature: \"m\",\n renderInfo: { breakAround: true }\n },\n insertsubsectionnavigationhorizontal: {\n signature: \"m m m\",\n renderInfo: { breakAround: true }\n },\n insertverticalnavigation: {\n signature: \"m\",\n renderInfo: { breakAround: true }\n },\n usebeamercolor: { signature: \"s m\", renderInfo: { breakAround: true } },\n usebeamertemplate: { signature: \"s m\", renderInfo: { breakAround: true } },\n setbeamercolor: {\n signature: \"m m\",\n renderInfo: { breakAround: true, pgfkeysArgs: true }\n },\n setbeamersize: {\n signature: \"m o o\",\n renderInfo: { breakAround: true, pgfkeysArgs: true }\n },\n setbeamertemplate: {\n signature: \"m o o d{}\",\n renderInfo: { breakAround: true, pgfkeysArgs: true }\n },\n newcommand: {\n signature: \"s d<> +m o +o +m\",\n renderInfo: {\n breakAround: true,\n namedArguments: [\n \"starred\",\n null,\n \"name\",\n \"numArgs\",\n \"default\",\n \"body\"\n ]\n }\n },\n renewcommand: {\n signature: \"s d<> +m o +o +m\",\n renderInfo: {\n breakAround: true,\n namedArguments: [\n \"starred\",\n null,\n \"name\",\n \"numArgs\",\n \"default\",\n \"body\"\n ]\n }\n },\n newenvironment: {\n signature: \"s d<> m o o m m\",\n renderInfo: { breakAround: true }\n },\n renewenvironment: {\n signature: \"s d<> m o o m m\",\n renderInfo: { breakAround: true }\n },\n resetcounteronoverlays: {\n signature: \"m\",\n renderInfo: { breakAround: true }\n },\n resetcountonoverlays: { signature: \"m\", renderInfo: { breakAround: true } },\n logo: { signature: \"m\", renderInfo: { breakAround: true } },\n frametitle: { signature: \"d<> o m\", renderInfo: { breakAround: true } },\n framesubtitle: { signature: \"d<> m\", renderInfo: { breakAround: true } },\n pause: { signature: \"o\" },\n onslide: { signature: \"t+ t* d<> d{}\" },\n only: { signature: \"d<> m d<>\" },\n uncover: { signature: \"d<> m\" },\n visible: { signature: \"d<> m\" },\n invisible: { signature: \"d<> m\" },\n alt: { signature: \"d<> m m d<>\" },\n temporal: { signature: \"r<> m m m\" },\n item: {\n signature: \"d<> o d<>\",\n renderInfo: {\n hangingIndent: true,\n namedArguments: [null, \"label\", null]\n }\n },\n label: { signature: \"d<> o m\" },\n // cleveref adds an optional argument to label; this gives maximum compatibility.\n action: { signature: \"d<> m\" },\n beamerdefaultoverlayspecification: { signature: \"m\" },\n titlegraphic: { signature: \"m\", renderInfo: { breakAround: true } },\n subject: { signature: \"m\", renderInfo: { breakAround: true } },\n keywords: { signature: \"m\", renderInfo: { breakAround: true } },\n lecture: { signature: \"o m m\", renderInfo: { breakAround: true } },\n partpage: { renderInfo: { breakAround: true } },\n sectionpage: { renderInfo: { breakAround: true } },\n subsectionpage: { renderInfo: { breakAround: true } },\n AtBeginLecture: { signature: \"m\", renderInfo: { breakAround: true } },\n AtBeginPart: { signature: \"m\", renderInfo: { breakAround: true } },\n tableofcontents: {\n signature: \"o\",\n renderInfo: { breakAround: true, pgfkeysArgs: true }\n },\n againframe: { signature: \"d<> o o m\", renderInfo: { breakAround: true } },\n framezoom: {\n signature: \"r<> r<> o r() r()\",\n renderInfo: { breakAround: true }\n },\n column: { signature: \"d<> o m\", renderInfo: { breakAround: true } },\n animate: { signature: \"r<>\", renderInfo: { breakAround: true } },\n animatevalue: { signature: \"r<> m m m\", renderInfo: { breakAround: true } },\n sound: {\n signature: \"o m m\",\n renderInfo: { breakAround: true, pgfkeysArgs: true }\n },\n hyperlinksound: {\n signature: \"o m m\",\n renderInfo: { breakAround: true, pgfkeysArgs: true }\n },\n hyperlinkmute: { signature: \"m\", renderInfo: { breakAround: true } },\n // These signatures conflict with the default signatures.\n // Care must be taken when processing an AST.\n section: {\n signature: \"s d<> o m\",\n renderInfo: {\n breakAround: true,\n namedArguments: [\"starred\", null, \"tocTitle\", \"title\"]\n }\n },\n subsection: {\n signature: \"s d<> o m\",\n renderInfo: {\n breakAround: true,\n namedArguments: [\"starred\", null, \"tocTitle\", \"title\"]\n }\n },\n subsubsection: {\n signature: \"s d<> o m\",\n renderInfo: {\n breakAround: true,\n namedArguments: [\"starred\", null, \"tocTitle\", \"title\"]\n }\n },\n part: {\n signature: \"s d<> o m\",\n renderInfo: {\n breakAround: true,\n namedArguments: [\"starred\", null, \"tocTitle\", \"title\"]\n }\n },\n bibitem: {\n signature: \"s d<> o m\",\n renderInfo: {\n hangingIndent: true,\n namedArguments: [\"starred\", null, \"tocTitle\", \"title\"]\n }\n }\n};\nvar environments15 = {\n frame: {\n signature: \"!d<> !o !o !d{} !d{}\"\n },\n block: {\n signature: \"!d<> !d{} !d<>\"\n },\n alertblock: {\n signature: \"!d<> !d{} !d<>\"\n },\n exampleblock: {\n signature: \"!d<> !d{} !d<>\"\n },\n onlyenv: {\n signature: \"!d<>\"\n },\n altenv: {\n signature: \"!d<> m m m m !d<>\"\n },\n overlayarea: { signature: \"m m\" },\n overprint: { signature: \"o\" },\n actionenv: { signature: \"!d<>\" },\n columns: { signature: \"d<> o\" },\n column: { signature: \"d<> o m\" }\n};\n\n// package/multicol/provides.ts\nvar macros16 = {\n columnbreak: { renderInfo: { breakAround: true } }\n};\nvar environments16 = {\n multicols: {\n signature: \"m o o\"\n },\n \"multicols*\": {\n signature: \"m o o\"\n }\n};\n\n// index.ts\nvar macroInfo = {\n cleveref: macros,\n exam: macros2,\n geometry: macros3,\n hyperref: macros4,\n latex2e: macros5,\n listings: macros6,\n makeidx: macros7,\n mathtools: macros8,\n minted: macros9,\n nicematrix: macros10,\n systeme: macros11,\n tikz: macros12,\n xcolor: macros13,\n xparse: macros14,\n beamer: macros15,\n multicol: macros16\n};\nvar environmentInfo = {\n cleveref: environments,\n exam: environments2,\n geometry: environments3,\n hyperref: environments4,\n latex2e: environments5,\n listings: environments6,\n makeidx: environments7,\n mathtools: environments8,\n minted: environments9,\n nicematrix: environments10,\n systeme: environments11,\n tikz: environments12,\n xcolor: environments13,\n xparse: environments14,\n beamer: environments15,\n multicol: environments16\n};\nexport {\n environmentInfo,\n macroInfo\n};\n//# sourceMappingURL=index.js.map\n","// libs/process-environment.ts\nimport { updateRenderInfo } from \"@unified-latex/unified-latex-util-render-info\";\nimport { gobbleArguments } from \"@unified-latex/unified-latex-util-arguments\";\nimport { match } from \"@unified-latex/unified-latex-util-match\";\nimport { visit } from \"@unified-latex/unified-latex-util-visit\";\nimport { printRaw } from \"@unified-latex/unified-latex-util-print-raw\";\nfunction processEnvironment(envNode, envInfo) {\n if (envInfo.signature && envNode.args == null) {\n const { args } = gobbleArguments(envNode.content, envInfo.signature);\n envNode.args = args;\n }\n updateRenderInfo(envNode, envInfo.renderInfo);\n if (typeof envInfo.processContent === \"function\") {\n envNode.content = envInfo.processContent(envNode.content);\n }\n}\nfunction processEnvironments(tree, environments) {\n const isRelevantEnvironment = match.createEnvironmentMatcher(environments);\n visit(\n tree,\n {\n leave: (node) => {\n const envName = printRaw(node.env);\n const envInfo = environments[envName];\n if (!envInfo) {\n throw new Error(\n `Could not find environment info for environment \"${envName}\"`\n );\n }\n processEnvironment(node, envInfo);\n }\n },\n { test: isRelevantEnvironment }\n );\n}\n\n// libs/unified-latex-process-environment.ts\nimport { visit as visit2 } from \"@unified-latex/unified-latex-util-visit\";\nimport { match as match2 } from \"@unified-latex/unified-latex-util-match\";\nimport { printRaw as printRaw2 } from \"@unified-latex/unified-latex-util-print-raw\";\nvar unifiedLatexProcessEnvironments = function unifiedLatexAttachMacroArguments(options) {\n const { environments = {} } = options || {};\n const isRelevantEnvironment = match2.createEnvironmentMatcher(environments);\n return (tree) => {\n if (Object.keys(environments).length === 0) {\n console.warn(\n \"Attempting to attach macro arguments but no macros are specified.\"\n );\n }\n visit2(\n tree,\n {\n leave: (node) => {\n const envName = printRaw2(node.env);\n const envInfo = environments[envName];\n if (!envInfo) {\n throw new Error(\n `Could not find environment info for environment \"${envName}\"`\n );\n }\n processEnvironment(node, envInfo);\n }\n },\n { test: isRelevantEnvironment }\n );\n };\n};\nexport {\n processEnvironment,\n processEnvironments,\n unifiedLatexProcessEnvironments\n};\n//# sourceMappingURL=index.js.map\n","// libs/find-region.ts\nfunction findRegionInArray(tree, start, end) {\n const ret = [];\n let currRegion = { start: void 0, end: tree.length };\n for (let i = 0; i < tree.length; i++) {\n const node = tree[i];\n if (start(node)) {\n currRegion.start = i;\n }\n if (end(node)) {\n currRegion.end = i + 1;\n ret.push(currRegion);\n currRegion = { start: void 0, end: tree.length };\n }\n }\n if (currRegion.start != null) {\n ret.push(currRegion);\n }\n return ret;\n}\n\n// libs/special-regions.ts\nimport { match as match2 } from \"@unified-latex/unified-latex-util-match\";\n\n// libs/regions.ts\nfunction refineRegions(regions) {\n const _regions = [...regions];\n _regions.sort((a, b) => a.start - b.start);\n const cutPointsSet = new Set(_regions.flatMap((r) => [r.start, r.end]));\n const cutPoints = Array.from(cutPointsSet);\n cutPoints.sort((a, b) => a - b);\n const retRegions = [];\n const retRegionsContainedIn = [];\n let seekIndex = 0;\n for (let i = 0; i < cutPoints.length - 1; i++) {\n const start = cutPoints[i];\n const end = cutPoints[i + 1];\n const region = { start, end };\n const regionContainedIn = /* @__PURE__ */ new Set();\n let encounteredEndPastStart = false;\n for (let j = seekIndex; j < _regions.length; j++) {\n const superRegion = _regions[j];\n if (superRegion.end >= region.start) {\n encounteredEndPastStart = true;\n }\n if (!encounteredEndPastStart && superRegion.end < region.start) {\n seekIndex = j + 1;\n continue;\n }\n if (superRegion.start > end) {\n break;\n }\n if (superRegion.start <= region.start && superRegion.end >= region.end) {\n encounteredEndPastStart = true;\n regionContainedIn.add(superRegion);\n }\n }\n if (regionContainedIn.size > 0) {\n retRegions.push(region);\n retRegionsContainedIn.push(regionContainedIn);\n }\n }\n return { regions: retRegions, regionsContainedIn: retRegionsContainedIn };\n}\nfunction splitByRegions(array, regionsRecord) {\n const ret = [];\n const indices = [0, array.length];\n const reverseMap = {};\n for (const [key, records] of Object.entries(regionsRecord)) {\n indices.push(\n ...records.flatMap((r) => {\n reverseMap[\"\" + [r.start, r.end]] = key;\n return [r.start, r.end];\n })\n );\n }\n indices.sort((a, b) => a - b);\n for (let i = 0; i < indices.length - 1; i++) {\n const start = indices[i];\n const end = indices[i + 1];\n if (start === end) {\n continue;\n }\n const regionKey = reverseMap[\"\" + [start, end]];\n ret.push([regionKey || null, array.slice(start, end)]);\n }\n return ret;\n}\n\n// libs/special-regions.ts\nimport { SKIP, visit as visit2 } from \"@unified-latex/unified-latex-util-visit\";\n\n// libs/reparse-macro-names.ts\nimport { match } from \"@unified-latex/unified-latex-util-match\";\nimport { EXIT, visit } from \"@unified-latex/unified-latex-util-visit\";\nfunction escapeRegExp(str) {\n return str.replace(/[.*+?^${}()|[\\]\\\\]/g, \"\\\\$&\");\n}\nfunction buildWordRegex(allowedSet) {\n const regexpStr = `^(${[\"\\\\p{L}\"].concat(Array.from(allowedSet).map(escapeRegExp)).join(\"|\")})*`;\n return new RegExp(regexpStr, \"u\");\n}\nfunction hasReparsableMacroNamesInArray(tree, allowedTokens) {\n for (let i = 0; i < tree.length; i++) {\n const macro = tree[i];\n const string = tree[i + 1];\n if (match.anyMacro(macro) && match.anyString(string)) {\n if (allowedTokens.has(\n macro.content.charAt(macro.content.length - 1)\n ) || allowedTokens.has(string.content.charAt(0))) {\n return true;\n }\n }\n }\n return false;\n}\nfunction hasReparsableMacroNames(tree, allowedTokens) {\n if (typeof allowedTokens === \"string\") {\n allowedTokens = new Set(allowedTokens.split(\"\"));\n }\n const _allowedTokens = allowedTokens;\n for (const v of _allowedTokens) {\n if (v.length > 1) {\n throw new Error(\n `Only single characters are allowed as \\`allowedTokens\\` when reparsing macro names, not \\`${v}\\`.`\n );\n }\n }\n let ret = false;\n visit(\n tree,\n (nodes) => {\n if (hasReparsableMacroNamesInArray(nodes, _allowedTokens)) {\n ret = true;\n return EXIT;\n }\n },\n { includeArrays: true, test: Array.isArray }\n );\n return ret;\n}\nfunction reparseMacroNamesInArray(tree, allowedTokens) {\n var _a, _b, _c;\n const regex = buildWordRegex(allowedTokens);\n let i = 0;\n while (i < tree.length) {\n const macro = tree[i];\n const string = tree[i + 1];\n if (match.anyMacro(macro) && // The _^ macros in math mode should not be extended no-matter what;\n // So we check to make sure that the macro we're dealing with has the default escape token.\n (macro.escapeToken == null || macro.escapeToken === \"\\\\\") && match.anyString(string) && // There are two options. Either the macro ends with the special character,\n // e.g. `\\@foo` or the special character starts the next string, e.g. `\\foo@`.\n (allowedTokens.has(\n macro.content.charAt(macro.content.length - 1)\n ) || allowedTokens.has(string.content.charAt(0)))) {\n const match3 = string.content.match(regex);\n const takeable = match3 ? match3[0] : \"\";\n if (takeable.length > 0) {\n if (takeable.length === string.content.length) {\n macro.content += string.content;\n tree.splice(i + 1, 1);\n if (macro.position && ((_a = string.position) == null ? void 0 : _a.end)) {\n macro.position.end = string.position.end;\n }\n } else {\n macro.content += takeable;\n string.content = string.content.slice(takeable.length);\n if ((_b = macro.position) == null ? void 0 : _b.end) {\n macro.position.end.offset += takeable.length;\n macro.position.end.column += takeable.length;\n }\n if ((_c = string.position) == null ? void 0 : _c.start) {\n string.position.start.offset += takeable.length;\n string.position.start.column += takeable.length;\n }\n }\n } else {\n i++;\n }\n } else {\n ++i;\n }\n }\n}\nfunction reparseMacroNames(tree, allowedTokens) {\n if (typeof allowedTokens === \"string\") {\n allowedTokens = new Set(allowedTokens.split(\"\"));\n }\n const _allowedTokens = allowedTokens;\n for (const v of _allowedTokens) {\n if (v.length > 1) {\n throw new Error(\n `Only single characters are allowed as \\`allowedTokens\\` when reparsing macro names, not \\`${v}\\`.`\n );\n }\n }\n visit(\n tree,\n (nodes) => {\n reparseMacroNamesInArray(nodes, _allowedTokens);\n },\n { includeArrays: true, test: Array.isArray }\n );\n}\n\n// libs/special-regions.ts\nvar expl3Find = {\n start: match2.createMacroMatcher([\"ExplSyntaxOn\"]),\n end: match2.createMacroMatcher([\"ExplSyntaxOff\"])\n};\nvar atLetterFind = {\n start: match2.createMacroMatcher([\"makeatletter\"]),\n end: match2.createMacroMatcher([\"makeatother\"])\n};\nfunction findExpl3AndAtLetterRegionsInArray(tree) {\n const expl3 = findRegionInArray(tree, expl3Find.start, expl3Find.end);\n const atLetter = findRegionInArray(\n tree,\n atLetterFind.start,\n atLetterFind.end\n );\n const regionMap = new Map([\n ...expl3.map((x) => [x, \"expl\"]),\n ...atLetter.map((x) => [x, \"atLetter\"])\n ]);\n const all = refineRegions([...expl3, ...atLetter]);\n const ret = {\n explOnly: [],\n atLetterOnly: [],\n both: []\n };\n for (let i = 0; i < all.regions.length; i++) {\n const region = all.regions[i];\n const containedIn = all.regionsContainedIn[i];\n if (containedIn.size === 2) {\n ret.both.push(region);\n continue;\n }\n for (const v of containedIn.values()) {\n if (regionMap.get(v) === \"expl\") {\n ret.explOnly.push(region);\n }\n if (regionMap.get(v) === \"atLetter\") {\n ret.atLetterOnly.push(region);\n }\n }\n }\n ret.explOnly = ret.explOnly.filter((r) => r.end - r.start > 1);\n ret.atLetterOnly = ret.atLetterOnly.filter((r) => r.end - r.start > 1);\n ret.both = ret.both.filter((r) => r.end - r.start > 1);\n return ret;\n}\nvar atLetterSet = /* @__PURE__ */ new Set([\"@\"]);\nvar explSet = /* @__PURE__ */ new Set([\"_\", \":\"]);\nvar bothSet = /* @__PURE__ */ new Set([\"_\", \":\", \"@\"]);\nfunction reparseExpl3AndAtLetterRegions(tree) {\n visit2(\n tree,\n {\n leave: (nodes) => {\n const regions = findExpl3AndAtLetterRegionsInArray(nodes);\n const totalNumRegions = regions.both.length + regions.atLetterOnly.length + regions.explOnly.length;\n if (totalNumRegions === 0) {\n return;\n }\n const splits = splitByRegions(nodes, regions);\n const processed = [];\n for (const [key, slice] of splits) {\n switch (key) {\n case null:\n processed.push(...slice);\n continue;\n case \"atLetterOnly\":\n reparseMacroNames(slice, atLetterSet);\n processed.push(...slice);\n continue;\n case \"explOnly\":\n reparseMacroNames(slice, explSet);\n processed.push(...slice);\n continue;\n case \"both\":\n reparseMacroNames(slice, bothSet);\n processed.push(...slice);\n continue;\n default:\n throw new Error(\n `Unexpected case when splitting ${key}`\n );\n }\n }\n nodes.length = 0;\n nodes.push(...processed);\n return SKIP;\n }\n },\n { includeArrays: true, test: Array.isArray }\n );\n}\nexport {\n findExpl3AndAtLetterRegionsInArray,\n findRegionInArray,\n hasReparsableMacroNames,\n hasReparsableMacroNamesInArray,\n reparseExpl3AndAtLetterRegions,\n reparseMacroNames,\n reparseMacroNamesInArray\n};\n//# sourceMappingURL=index.js.map\n","// libs/compiler-ast.ts\nvar unifiedLatexAstComplier = function unifiedLatexAstComplier2() {\n Object.assign(this, { Compiler: (x) => x });\n};\n\n// libs/plugin-from-string.ts\nimport { unified } from \"unified\";\nimport { environmentInfo, macroInfo } from \"@unified-latex/unified-latex-ctan\";\nimport {\n unifiedLatexTrimEnvironmentContents,\n unifiedLatexTrimRoot\n} from \"@unified-latex/unified-latex-util-trim\";\n\n// libs/parse-minimal.ts\nimport { LatexPegParser } from \"@unified-latex/unified-latex-util-pegjs\";\nfunction parseMinimal(str) {\n return LatexPegParser.parse(str);\n}\nfunction parseMathMinimal(str) {\n return LatexPegParser.parse(str, { startRule: \"math\" });\n}\n\n// libs/plugin-from-string-minimal.ts\nvar unifiedLatexFromStringMinimal = function unifiedLatexFromStringMinimal2(options) {\n const parser2 = (str) => {\n if ((options == null ? void 0 : options.mode) === \"math\") {\n return {\n type: \"root\",\n content: parseMathMinimal(str),\n _renderInfo: { inMathMode: true }\n };\n }\n return parseMinimal(str);\n };\n Object.assign(this, { Parser: parser2 });\n};\n\n// libs/process-macros-and-environments.ts\nimport { visit as visit2 } from \"@unified-latex/unified-latex-util-visit\";\nimport { match as match2 } from \"@unified-latex/unified-latex-util-match\";\nimport { printRaw as printRaw2 } from \"@unified-latex/unified-latex-util-print-raw\";\n\n// libs/reparse-math.ts\nimport { match } from \"@unified-latex/unified-latex-util-match\";\nimport { printRaw } from \"@unified-latex/unified-latex-util-print-raw\";\nimport { visit } from \"@unified-latex/unified-latex-util-visit\";\nfunction unifiedLatexReparseMathConstructPlugin({\n mathEnvs,\n mathMacros\n}) {\n const isMathEnvironment = match.createEnvironmentMatcher(mathEnvs);\n const isMathMacro = match.createMacroMatcher(mathMacros);\n return (tree) => {\n visit(\n tree,\n (node) => {\n if (match.anyMacro(node)) {\n for (const arg of node.args || []) {\n if (arg.content.length > 0 && !wasParsedInMathMode(arg.content)) {\n arg.content = parseMathMinimal(\n printRaw(arg.content)\n );\n }\n }\n }\n if (match.anyEnvironment(node)) {\n if (!wasParsedInMathMode(node.content)) {\n node.content = parseMathMinimal(printRaw(node.content));\n }\n }\n },\n {\n test: (node) => isMathEnvironment(node) || isMathMacro(node)\n }\n );\n };\n}\nfunction wasParsedInMathMode(nodes) {\n return !nodes.some(\n (node) => (\n // If there are multi-char strings or ^ and _ have been parsed as strings, we know\n // that we were not parsed in math mode.\n match.anyString(node) && node.content.length > 1 || match.string(node, \"^\") || match.string(node, \"_\")\n )\n );\n}\n\n// libs/process-macros-and-environments.ts\nimport { attachMacroArgsInArray } from \"@unified-latex/unified-latex-util-arguments\";\nimport { processEnvironment } from \"@unified-latex/unified-latex-util-environments\";\nvar unifiedLatexProcessMacrosAndEnvironmentsWithMathReparse = function unifiedLatexProcessMacrosAndEnvironmentsWithMathReparse2(options) {\n const { environments = {}, macros = {} } = options || {};\n const mathMacros = Object.fromEntries(\n Object.entries(macros).filter(\n ([_, info]) => {\n var _a;\n return ((_a = info.renderInfo) == null ? void 0 : _a.inMathMode) === true;\n }\n )\n );\n const mathEnvs = Object.fromEntries(\n Object.entries(environments).filter(\n ([_, info]) => {\n var _a;\n return ((_a = info.renderInfo) == null ? void 0 : _a.inMathMode) === true;\n }\n )\n );\n const mathReparser = unifiedLatexReparseMathConstructPlugin({\n mathEnvs: Object.keys(mathEnvs),\n mathMacros: Object.keys(mathMacros)\n });\n const isRelevantEnvironment = match2.createEnvironmentMatcher(environments);\n const isRelevantMathEnvironment = match2.createEnvironmentMatcher(mathEnvs);\n return (tree) => {\n visit2(\n tree,\n {\n enter: (nodes) => {\n if (!Array.isArray(nodes)) {\n return;\n }\n attachMacroArgsInArray(nodes, mathMacros);\n },\n leave: (node) => {\n if (!isRelevantMathEnvironment(node)) {\n return;\n }\n const envName = printRaw2(node.env);\n const envInfo = environments[envName];\n if (!envInfo) {\n throw new Error(\n `Could not find environment info for environment \"${envName}\"`\n );\n }\n processEnvironment(node, envInfo);\n }\n },\n { includeArrays: true }\n );\n mathReparser(tree);\n visit2(\n tree,\n {\n enter: (nodes) => {\n if (!Array.isArray(nodes)) {\n return;\n }\n attachMacroArgsInArray(nodes, macros);\n },\n leave: (node) => {\n if (!isRelevantEnvironment(node)) {\n return;\n }\n const envName = printRaw2(node.env);\n const envInfo = environments[envName];\n if (!envInfo) {\n throw new Error(\n `Could not find environment info for environment \"${envName}\"`\n );\n }\n processEnvironment(node, envInfo);\n }\n },\n { includeArrays: true }\n );\n };\n};\n\n// libs/process-at-letter-and-expl-macros.ts\nimport { reparseExpl3AndAtLetterRegions } from \"@unified-latex/unified-latex-util-catcode\";\nimport {\n hasReparsableMacroNames,\n reparseMacroNames\n} from \"@unified-latex/unified-latex-util-catcode\";\nvar unifiedLatexProcessAtLetterAndExplMacros = function unifiedLatexProcessAtLetterAndExplMacros2(options) {\n let {\n atLetter = false,\n expl3 = false,\n autodetectExpl3AndAtLetter = false\n } = options || {};\n return (tree) => {\n reparseExpl3AndAtLetterRegions(tree);\n if (atLetter || expl3) {\n autodetectExpl3AndAtLetter = false;\n }\n if (autodetectExpl3AndAtLetter) {\n atLetter = hasReparsableMacroNames(tree, \"@\");\n expl3 = hasReparsableMacroNames(tree, \"_\");\n }\n const charSet = /* @__PURE__ */ new Set();\n if (atLetter) {\n charSet.add(\"@\");\n }\n if (expl3) {\n charSet.add(\":\");\n charSet.add(\"_\");\n }\n if (charSet.size > 0) {\n reparseMacroNames(tree, charSet);\n }\n };\n};\n\n// libs/plugin-from-string.ts\nvar unifiedLatexFromString = function unifiedLatexFromString2(options) {\n const {\n mode = \"regular\",\n macros = {},\n environments = {},\n flags: {\n atLetter = false,\n expl3 = false,\n autodetectExpl3AndAtLetter = false\n } = {}\n } = options || {};\n const allMacroInfo = Object.assign(\n {},\n ...Object.values(macroInfo),\n macros\n );\n const allEnvInfo = Object.assign(\n {},\n ...Object.values(environmentInfo),\n environments\n );\n const fullParser = unified().use(unifiedLatexFromStringMinimal, { mode }).use(unifiedLatexProcessAtLetterAndExplMacros, {\n atLetter,\n expl3,\n autodetectExpl3AndAtLetter\n }).use(unifiedLatexProcessMacrosAndEnvironmentsWithMathReparse, {\n macros: allMacroInfo,\n environments: allEnvInfo\n }).use(unifiedLatexTrimEnvironmentContents).use(unifiedLatexTrimRoot).use(unifiedLatexAstComplier);\n const parser2 = (str) => {\n const file = fullParser.processSync({ value: str });\n return file.result;\n };\n Object.assign(this, { Parser: parser2 });\n};\n\n// libs/parse.ts\nimport { unified as unified2 } from \"unified\";\nvar parser = unified2().use(unifiedLatexFromString).freeze();\nfunction parse(str) {\n return parser.parse(str);\n}\nfunction getParser(options) {\n return options ? unified2().use(unifiedLatexFromString, options).freeze() : parser;\n}\n\n// libs/parse-math.ts\nimport { unified as unified3 } from \"unified\";\nimport { printRaw as printRaw3 } from \"@unified-latex/unified-latex-util-print-raw\";\nfunction parseMath(str) {\n if (typeof str !== \"string\") {\n str = printRaw3(str);\n }\n const file = unified3().use(unifiedLatexFromString, { mode: \"math\" }).use(unifiedLatexAstComplier).processSync({ value: str });\n return file.result.content;\n}\nexport {\n getParser,\n parse,\n parseMath,\n parseMathMinimal,\n parseMinimal,\n unifiedLatexAstComplier,\n unifiedLatexFromString,\n unifiedLatexFromStringMinimal\n};\n//# sourceMappingURL=index.js.map\n","var __accessCheck = (obj, member, msg) => {\n if (!member.has(obj))\n throw TypeError(\"Cannot \" + msg);\n};\nvar __privateGet = (obj, member, getter) => {\n __accessCheck(obj, member, \"read from private field\");\n return getter ? getter.call(obj) : member.get(obj);\n};\nvar __privateAdd = (obj, member, value) => {\n if (member.has(obj))\n throw TypeError(\"Cannot add the same private member more than once\");\n member instanceof WeakSet ? member.add(obj) : member.set(obj, value);\n};\nvar __privateSet = (obj, member, value, setter) => {\n __accessCheck(obj, member, \"write to private field\");\n setter ? setter.call(obj, value) : member.set(obj, value);\n return value;\n};\n\n// node_modules/prettier/doc.mjs\nvar __defProp = Object.defineProperty;\nvar __export = (target, all) => {\n for (var name in all)\n __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar public_exports = {};\n__export(public_exports, {\n builders: () => builders,\n printer: () => printer,\n utils: () => utils\n});\nvar DOC_TYPE_STRING = \"string\";\nvar DOC_TYPE_ARRAY = \"array\";\nvar DOC_TYPE_CURSOR = \"cursor\";\nvar DOC_TYPE_INDENT = \"indent\";\nvar DOC_TYPE_ALIGN = \"align\";\nvar DOC_TYPE_TRIM = \"trim\";\nvar DOC_TYPE_GROUP = \"group\";\nvar DOC_TYPE_FILL = \"fill\";\nvar DOC_TYPE_IF_BREAK = \"if-break\";\nvar DOC_TYPE_INDENT_IF_BREAK = \"indent-if-break\";\nvar DOC_TYPE_LINE_SUFFIX = \"line-suffix\";\nvar DOC_TYPE_LINE_SUFFIX_BOUNDARY = \"line-suffix-boundary\";\nvar DOC_TYPE_LINE = \"line\";\nvar DOC_TYPE_LABEL = \"label\";\nvar DOC_TYPE_BREAK_PARENT = \"break-parent\";\nvar VALID_OBJECT_DOC_TYPES = /* @__PURE__ */ new Set([\n DOC_TYPE_CURSOR,\n DOC_TYPE_INDENT,\n DOC_TYPE_ALIGN,\n DOC_TYPE_TRIM,\n DOC_TYPE_GROUP,\n DOC_TYPE_FILL,\n DOC_TYPE_IF_BREAK,\n DOC_TYPE_INDENT_IF_BREAK,\n DOC_TYPE_LINE_SUFFIX,\n DOC_TYPE_LINE_SUFFIX_BOUNDARY,\n DOC_TYPE_LINE,\n DOC_TYPE_LABEL,\n DOC_TYPE_BREAK_PARENT\n]);\nfunction getDocType(doc) {\n if (typeof doc === \"string\") {\n return DOC_TYPE_STRING;\n }\n if (Array.isArray(doc)) {\n return DOC_TYPE_ARRAY;\n }\n if (!doc) {\n return;\n }\n const { type } = doc;\n if (VALID_OBJECT_DOC_TYPES.has(type)) {\n return type;\n }\n}\nvar get_doc_type_default = getDocType;\nvar disjunctionListFormat = (list) => new Intl.ListFormat(\"en-US\", { type: \"disjunction\" }).format(list);\nfunction getDocErrorMessage(doc) {\n const type = doc === null ? \"null\" : typeof doc;\n if (type !== \"string\" && type !== \"object\") {\n return `Unexpected doc '${type}', \nExpected it to be 'string' or 'object'.`;\n }\n if (get_doc_type_default(doc)) {\n throw new Error(\"doc is valid.\");\n }\n const objectType = Object.prototype.toString.call(doc);\n if (objectType !== \"[object Object]\") {\n return `Unexpected doc '${objectType}'.`;\n }\n const EXPECTED_TYPE_VALUES = disjunctionListFormat(\n [...VALID_OBJECT_DOC_TYPES].map((type2) => `'${type2}'`)\n );\n return `Unexpected doc.type '${doc.type}'.\nExpected it to be ${EXPECTED_TYPE_VALUES}.`;\n}\nvar InvalidDocError = class extends Error {\n name = \"InvalidDocError\";\n constructor(doc) {\n super(getDocErrorMessage(doc));\n this.doc = doc;\n }\n};\nvar invalid_doc_error_default = InvalidDocError;\nvar traverseDocOnExitStackMarker = {};\nfunction traverseDoc(doc, onEnter, onExit, shouldTraverseConditionalGroups) {\n const docsStack = [doc];\n while (docsStack.length > 0) {\n const doc2 = docsStack.pop();\n if (doc2 === traverseDocOnExitStackMarker) {\n onExit(docsStack.pop());\n continue;\n }\n if (onExit) {\n docsStack.push(doc2, traverseDocOnExitStackMarker);\n }\n const docType = get_doc_type_default(doc2);\n if (!docType) {\n throw new invalid_doc_error_default(doc2);\n }\n if ((onEnter == null ? void 0 : onEnter(doc2)) === false) {\n continue;\n }\n switch (docType) {\n case DOC_TYPE_ARRAY:\n case DOC_TYPE_FILL: {\n const parts = docType === DOC_TYPE_ARRAY ? doc2 : doc2.parts;\n for (let ic = parts.length, i = ic - 1; i >= 0; --i) {\n docsStack.push(parts[i]);\n }\n break;\n }\n case DOC_TYPE_IF_BREAK:\n docsStack.push(doc2.flatContents, doc2.breakContents);\n break;\n case DOC_TYPE_GROUP:\n if (shouldTraverseConditionalGroups && doc2.expandedStates) {\n for (let ic = doc2.expandedStates.length, i = ic - 1; i >= 0; --i) {\n docsStack.push(doc2.expandedStates[i]);\n }\n } else {\n docsStack.push(doc2.contents);\n }\n break;\n case DOC_TYPE_ALIGN:\n case DOC_TYPE_INDENT:\n case DOC_TYPE_INDENT_IF_BREAK:\n case DOC_TYPE_LABEL:\n case DOC_TYPE_LINE_SUFFIX:\n docsStack.push(doc2.contents);\n break;\n case DOC_TYPE_STRING:\n case DOC_TYPE_CURSOR:\n case DOC_TYPE_TRIM:\n case DOC_TYPE_LINE_SUFFIX_BOUNDARY:\n case DOC_TYPE_LINE:\n case DOC_TYPE_BREAK_PARENT:\n break;\n default:\n throw new invalid_doc_error_default(doc2);\n }\n }\n}\nvar traverse_doc_default = traverseDoc;\nvar noop = () => {\n};\nvar assertDoc = true ? noop : function(doc) {\n traverse_doc_default(doc, (doc2) => {\n if (checked.has(doc2)) {\n return false;\n }\n if (typeof doc2 !== \"string\") {\n checked.add(doc2);\n }\n });\n};\nvar assertDocArray = true ? noop : function(docs, optional = false) {\n if (optional && !docs) {\n return;\n }\n if (!Array.isArray(docs)) {\n throw new TypeError(\"Unexpected doc array.\");\n }\n for (const doc of docs) {\n assertDoc(doc);\n }\n};\nfunction indent(contents) {\n assertDoc(contents);\n return { type: DOC_TYPE_INDENT, contents };\n}\nfunction align(widthOrString, contents) {\n assertDoc(contents);\n return { type: DOC_TYPE_ALIGN, contents, n: widthOrString };\n}\nfunction group(contents, opts = {}) {\n assertDoc(contents);\n assertDocArray(\n opts.expandedStates,\n /* optional */\n true\n );\n return {\n type: DOC_TYPE_GROUP,\n id: opts.id,\n contents,\n break: Boolean(opts.shouldBreak),\n expandedStates: opts.expandedStates\n };\n}\nfunction dedentToRoot(contents) {\n return align(Number.NEGATIVE_INFINITY, contents);\n}\nfunction markAsRoot(contents) {\n return align({ type: \"root\" }, contents);\n}\nfunction dedent(contents) {\n return align(-1, contents);\n}\nfunction conditionalGroup(states, opts) {\n return group(states[0], { ...opts, expandedStates: states });\n}\nfunction fill(parts) {\n assertDocArray(parts);\n return { type: DOC_TYPE_FILL, parts };\n}\nfunction ifBreak(breakContents, flatContents = \"\", opts = {}) {\n assertDoc(breakContents);\n if (flatContents !== \"\") {\n assertDoc(flatContents);\n }\n return {\n type: DOC_TYPE_IF_BREAK,\n breakContents,\n flatContents,\n groupId: opts.groupId\n };\n}\nfunction indentIfBreak(contents, opts) {\n assertDoc(contents);\n return {\n type: DOC_TYPE_INDENT_IF_BREAK,\n contents,\n groupId: opts.groupId,\n negate: opts.negate\n };\n}\nfunction lineSuffix(contents) {\n assertDoc(contents);\n return { type: DOC_TYPE_LINE_SUFFIX, contents };\n}\nvar lineSuffixBoundary = { type: DOC_TYPE_LINE_SUFFIX_BOUNDARY };\nvar breakParent = { type: DOC_TYPE_BREAK_PARENT };\nvar trim = { type: DOC_TYPE_TRIM };\nvar hardlineWithoutBreakParent = { type: DOC_TYPE_LINE, hard: true };\nvar literallineWithoutBreakParent = {\n type: DOC_TYPE_LINE,\n hard: true,\n literal: true\n};\nvar line = { type: DOC_TYPE_LINE };\nvar softline = { type: DOC_TYPE_LINE, soft: true };\nvar hardline = [hardlineWithoutBreakParent, breakParent];\nvar literalline = [literallineWithoutBreakParent, breakParent];\nvar cursor = { type: DOC_TYPE_CURSOR };\nfunction join(separator, docs) {\n assertDoc(separator);\n assertDocArray(docs);\n const parts = [];\n for (let i = 0; i < docs.length; i++) {\n if (i !== 0) {\n parts.push(separator);\n }\n parts.push(docs[i]);\n }\n return parts;\n}\nfunction addAlignmentToDoc(doc, size, tabWidth) {\n assertDoc(doc);\n let aligned = doc;\n if (size > 0) {\n for (let i = 0; i < Math.floor(size / tabWidth); ++i) {\n aligned = indent(aligned);\n }\n aligned = align(size % tabWidth, aligned);\n aligned = align(Number.NEGATIVE_INFINITY, aligned);\n }\n return aligned;\n}\nfunction label(label2, contents) {\n assertDoc(contents);\n return label2 ? { type: DOC_TYPE_LABEL, label: label2, contents } : contents;\n}\nvar at = (isOptionalObject, object, index) => {\n if (isOptionalObject && (object === void 0 || object === null)) {\n return;\n }\n if (Array.isArray(object) || typeof object === \"string\") {\n return object[index < 0 ? object.length + index : index];\n }\n return object.at(index);\n};\nvar at_default = at;\nvar stringReplaceAll = (isOptionalObject, original, pattern, replacement) => {\n if (isOptionalObject && (original === void 0 || original === null)) {\n return;\n }\n if (original.replaceAll) {\n return original.replaceAll(pattern, replacement);\n }\n if (pattern.global) {\n return original.replace(pattern, replacement);\n }\n return original.split(pattern).join(replacement);\n};\nvar string_replace_all_default = stringReplaceAll;\nfunction convertEndOfLineToChars(value) {\n switch (value) {\n case \"cr\":\n return \"\\r\";\n case \"crlf\":\n return \"\\r\\n\";\n default:\n return \"\\n\";\n }\n}\nvar emoji_regex_default = () => {\n return /[#*0-9]\\uFE0F?\\u20E3|[\\xA9\\xAE\\u203C\\u2049\\u2122\\u2139\\u2194-\\u2199\\u21A9\\u21AA\\u231A\\u231B\\u2328\\u23CF\\u23ED-\\u23EF\\u23F1\\u23F2\\u23F8-\\u23FA\\u24C2\\u25AA\\u25AB\\u25B6\\u25C0\\u25FB\\u25FC\\u25FE\\u2600-\\u2604\\u260E\\u2611\\u2614\\u2615\\u2618\\u2620\\u2622\\u2623\\u2626\\u262A\\u262E\\u262F\\u2638-\\u263A\\u2640\\u2642\\u2648-\\u2653\\u265F\\u2660\\u2663\\u2665\\u2666\\u2668\\u267B\\u267E\\u267F\\u2692\\u2694-\\u2697\\u2699\\u269B\\u269C\\u26A0\\u26A7\\u26AA\\u26B0\\u26B1\\u26BD\\u26BE\\u26C4\\u26C8\\u26CF\\u26D1\\u26D3\\u26E9\\u26F0-\\u26F5\\u26F7\\u26F8\\u26FA\\u2702\\u2708\\u2709\\u270F\\u2712\\u2714\\u2716\\u271D\\u2721\\u2733\\u2734\\u2744\\u2747\\u2757\\u2763\\u27A1\\u2934\\u2935\\u2B05-\\u2B07\\u2B1B\\u2B1C\\u2B55\\u3030\\u303D\\u3297\\u3299]\\uFE0F?|[\\u261D\\u270C\\u270D](?:\\uFE0F|\\uD83C[\\uDFFB-\\uDFFF])?|[\\u270A\\u270B](?:\\uD83C[\\uDFFB-\\uDFFF])?|[\\u23E9-\\u23EC\\u23F0\\u23F3\\u25FD\\u2693\\u26A1\\u26AB\\u26C5\\u26CE\\u26D4\\u26EA\\u26FD\\u2705\\u2728\\u274C\\u274E\\u2753-\\u2755\\u2795-\\u2797\\u27B0\\u27BF\\u2B50]|\\u26F9(?:\\uFE0F|\\uD83C[\\uDFFB-\\uDFFF])?(?:\\u200D[\\u2640\\u2642]\\uFE0F?)?|\\u2764\\uFE0F?(?:\\u200D(?:\\uD83D\\uDD25|\\uD83E\\uDE79))?|\\uD83C(?:[\\uDC04\\uDD70\\uDD71\\uDD7E\\uDD7F\\uDE02\\uDE37\\uDF21\\uDF24-\\uDF2C\\uDF36\\uDF7D\\uDF96\\uDF97\\uDF99-\\uDF9B\\uDF9E\\uDF9F\\uDFCD\\uDFCE\\uDFD4-\\uDFDF\\uDFF5\\uDFF7]\\uFE0F?|[\\uDF85\\uDFC2\\uDFC7](?:\\uD83C[\\uDFFB-\\uDFFF])?|[\\uDFC3\\uDFC4\\uDFCA](?:\\uD83C[\\uDFFB-\\uDFFF])?(?:\\u200D[\\u2640\\u2642]\\uFE0F?)?|[\\uDFCB\\uDFCC](?:\\uFE0F|\\uD83C[\\uDFFB-\\uDFFF])?(?:\\u200D[\\u2640\\u2642]\\uFE0F?)?|[\\uDCCF\\uDD8E\\uDD91-\\uDD9A\\uDE01\\uDE1A\\uDE2F\\uDE32-\\uDE36\\uDE38-\\uDE3A\\uDE50\\uDE51\\uDF00-\\uDF20\\uDF2D-\\uDF35\\uDF37-\\uDF7C\\uDF7E-\\uDF84\\uDF86-\\uDF93\\uDFA0-\\uDFC1\\uDFC5\\uDFC6\\uDFC8\\uDFC9\\uDFCF-\\uDFD3\\uDFE0-\\uDFF0\\uDFF8-\\uDFFF]|\\uDDE6\\uD83C[\\uDDE8-\\uDDEC\\uDDEE\\uDDF1\\uDDF2\\uDDF4\\uDDF6-\\uDDFA\\uDDFC\\uDDFD\\uDDFF]|\\uDDE7\\uD83C[\\uDDE6\\uDDE7\\uDDE9-\\uDDEF\\uDDF1-\\uDDF4\\uDDF6-\\uDDF9\\uDDFB\\uDDFC\\uDDFE\\uDDFF]|\\uDDE8\\uD83C[\\uDDE6\\uDDE8\\uDDE9\\uDDEB-\\uDDEE\\uDDF0-\\uDDF5\\uDDF7\\uDDFA-\\uDDFF]|\\uDDE9\\uD83C[\\uDDEA\\uDDEC\\uDDEF\\uDDF0\\uDDF2\\uDDF4\\uDDFF]|\\uDDEA\\uD83C[\\uDDE6\\uDDE8\\uDDEA\\uDDEC\\uDDED\\uDDF7-\\uDDFA]|\\uDDEB\\uD83C[\\uDDEE-\\uDDF0\\uDDF2\\uDDF4\\uDDF7]|\\uDDEC\\uD83C[\\uDDE6\\uDDE7\\uDDE9-\\uDDEE\\uDDF1-\\uDDF3\\uDDF5-\\uDDFA\\uDDFC\\uDDFE]|\\uDDED\\uD83C[\\uDDF0\\uDDF2\\uDDF3\\uDDF7\\uDDF9\\uDDFA]|\\uDDEE\\uD83C[\\uDDE8-\\uDDEA\\uDDF1-\\uDDF4\\uDDF6-\\uDDF9]|\\uDDEF\\uD83C[\\uDDEA\\uDDF2\\uDDF4\\uDDF5]|\\uDDF0\\uD83C[\\uDDEA\\uDDEC-\\uDDEE\\uDDF2\\uDDF3\\uDDF5\\uDDF7\\uDDFC\\uDDFE\\uDDFF]|\\uDDF1\\uD83C[\\uDDE6-\\uDDE8\\uDDEE\\uDDF0\\uDDF7-\\uDDFB\\uDDFE]|\\uDDF2\\uD83C[\\uDDE6\\uDDE8-\\uDDED\\uDDF0-\\uDDFF]|\\uDDF3\\uD83C[\\uDDE6\\uDDE8\\uDDEA-\\uDDEC\\uDDEE\\uDDF1\\uDDF4\\uDDF5\\uDDF7\\uDDFA\\uDDFF]|\\uDDF4\\uD83C\\uDDF2|\\uDDF5\\uD83C[\\uDDE6\\uDDEA-\\uDDED\\uDDF0-\\uDDF3\\uDDF7-\\uDDF9\\uDDFC\\uDDFE]|\\uDDF6\\uD83C\\uDDE6|\\uDDF7\\uD83C[\\uDDEA\\uDDF4\\uDDF8\\uDDFA\\uDDFC]|\\uDDF8\\uD83C[\\uDDE6-\\uDDEA\\uDDEC-\\uDDF4\\uDDF7-\\uDDF9\\uDDFB\\uDDFD-\\uDDFF]|\\uDDF9\\uD83C[\\uDDE6\\uDDE8\\uDDE9\\uDDEB-\\uDDED\\uDDEF-\\uDDF4\\uDDF7\\uDDF9\\uDDFB\\uDDFC\\uDDFF]|\\uDDFA\\uD83C[\\uDDE6\\uDDEC\\uDDF2\\uDDF3\\uDDF8\\uDDFE\\uDDFF]|\\uDDFB\\uD83C[\\uDDE6\\uDDE8\\uDDEA\\uDDEC\\uDDEE\\uDDF3\\uDDFA]|\\uDDFC\\uD83C[\\uDDEB\\uDDF8]|\\uDDFD\\uD83C\\uDDF0|\\uDDFE\\uD83C[\\uDDEA\\uDDF9]|\\uDDFF\\uD83C[\\uDDE6\\uDDF2\\uDDFC]|\\uDFF3\\uFE0F?(?:\\u200D(?:\\u26A7\\uFE0F?|\\uD83C\\uDF08))?|\\uDFF4(?:\\u200D\\u2620\\uFE0F?|\\uDB40\\uDC67\\uDB40\\uDC62\\uDB40(?:\\uDC65\\uDB40\\uDC6E\\uDB40\\uDC67|\\uDC73\\uDB40\\uDC63\\uDB40\\uDC74|\\uDC77\\uDB40\\uDC6C\\uDB40\\uDC73)\\uDB40\\uDC7F)?)|\\uD83D(?:[\\uDC08\\uDC26](?:\\u200D\\u2B1B)?|[\\uDC3F\\uDCFD\\uDD49\\uDD4A\\uDD6F\\uDD70\\uDD73\\uDD76-\\uDD79\\uDD87\\uDD8A-\\uDD8D\\uDDA5\\uDDA8\\uDDB1\\uDDB2\\uDDBC\\uDDC2-\\uDDC4\\uDDD1-\\uDDD3\\uDDDC-\\uDDDE\\uDDE1\\uDDE3\\uDDE8\\uDDEF\\uDDF3\\uDDFA\\uDECB\\uDECD-\\uDECF\\uDEE0-\\uDEE5\\uDEE9\\uDEF0\\uDEF3]\\uFE0F?|[\\uDC42\\uDC43\\uDC46-\\uDC50\\uDC66\\uDC67\\uDC6B-\\uDC6D\\uDC72\\uDC74-\\uDC76\\uDC78\\uDC7C\\uDC83\\uDC85\\uDC8F\\uDC91\\uDCAA\\uDD7A\\uDD95\\uDD96\\uDE4C\\uDE4F\\uDEC0\\uDECC](?:\\uD83C[\\uDFFB-\\uDFFF])?|[\\uDC6E\\uDC70\\uDC71\\uDC73\\uDC77\\uDC81\\uDC82\\uDC86\\uDC87\\uDE45-\\uDE47\\uDE4B\\uDE4D\\uDE4E\\uDEA3\\uDEB4-\\uDEB6](?:\\uD83C[\\uDFFB-\\uDFFF])?(?:\\u200D[\\u2640\\u2642]\\uFE0F?)?|[\\uDD74\\uDD90](?:\\uFE0F|\\uD83C[\\uDFFB-\\uDFFF])?|[\\uDC00-\\uDC07\\uDC09-\\uDC14\\uDC16-\\uDC25\\uDC27-\\uDC3A\\uDC3C-\\uDC3E\\uDC40\\uDC44\\uDC45\\uDC51-\\uDC65\\uDC6A\\uDC79-\\uDC7B\\uDC7D-\\uDC80\\uDC84\\uDC88-\\uDC8E\\uDC90\\uDC92-\\uDCA9\\uDCAB-\\uDCFC\\uDCFF-\\uDD3D\\uDD4B-\\uDD4E\\uDD50-\\uDD67\\uDDA4\\uDDFB-\\uDE2D\\uDE2F-\\uDE34\\uDE37-\\uDE44\\uDE48-\\uDE4A\\uDE80-\\uDEA2\\uDEA4-\\uDEB3\\uDEB7-\\uDEBF\\uDEC1-\\uDEC5\\uDED0-\\uDED2\\uDED5-\\uDED7\\uDEDC-\\uDEDF\\uDEEB\\uDEEC\\uDEF4-\\uDEFC\\uDFE0-\\uDFEB\\uDFF0]|\\uDC15(?:\\u200D\\uD83E\\uDDBA)?|\\uDC3B(?:\\u200D\\u2744\\uFE0F?)?|\\uDC41\\uFE0F?(?:\\u200D\\uD83D\\uDDE8\\uFE0F?)?|\\uDC68(?:\\u200D(?:[\\u2695\\u2696\\u2708]\\uFE0F?|\\u2764\\uFE0F?\\u200D\\uD83D(?:\\uDC8B\\u200D\\uD83D)?\\uDC68|\\uD83C[\\uDF3E\\uDF73\\uDF7C\\uDF93\\uDFA4\\uDFA8\\uDFEB\\uDFED]|\\uD83D(?:[\\uDC68\\uDC69]\\u200D\\uD83D(?:\\uDC66(?:\\u200D\\uD83D\\uDC66)?|\\uDC67(?:\\u200D\\uD83D[\\uDC66\\uDC67])?)|[\\uDCBB\\uDCBC\\uDD27\\uDD2C\\uDE80\\uDE92]|\\uDC66(?:\\u200D\\uD83D\\uDC66)?|\\uDC67(?:\\u200D\\uD83D[\\uDC66\\uDC67])?)|\\uD83E[\\uDDAF-\\uDDB3\\uDDBC\\uDDBD])|\\uD83C(?:\\uDFFB(?:\\u200D(?:[\\u2695\\u2696\\u2708]\\uFE0F?|\\u2764\\uFE0F?\\u200D\\uD83D(?:\\uDC8B\\u200D\\uD83D)?\\uDC68\\uD83C[\\uDFFB-\\uDFFF]|\\uD83C[\\uDF3E\\uDF73\\uDF7C\\uDF93\\uDFA4\\uDFA8\\uDFEB\\uDFED]|\\uD83D[\\uDCBB\\uDCBC\\uDD27\\uDD2C\\uDE80\\uDE92]|\\uD83E(?:[\\uDDAF-\\uDDB3\\uDDBC\\uDDBD]|\\uDD1D\\u200D\\uD83D\\uDC68\\uD83C[\\uDFFC-\\uDFFF])))?|\\uDFFC(?:\\u200D(?:[\\u2695\\u2696\\u2708]\\uFE0F?|\\u2764\\uFE0F?\\u200D\\uD83D(?:\\uDC8B\\u200D\\uD83D)?\\uDC68\\uD83C[\\uDFFB-\\uDFFF]|\\uD83C[\\uDF3E\\uDF73\\uDF7C\\uDF93\\uDFA4\\uDFA8\\uDFEB\\uDFED]|\\uD83D[\\uDCBB\\uDCBC\\uDD27\\uDD2C\\uDE80\\uDE92]|\\uD83E(?:[\\uDDAF-\\uDDB3\\uDDBC\\uDDBD]|\\uDD1D\\u200D\\uD83D\\uDC68\\uD83C[\\uDFFB\\uDFFD-\\uDFFF])))?|\\uDFFD(?:\\u200D(?:[\\u2695\\u2696\\u2708]\\uFE0F?|\\u2764\\uFE0F?\\u200D\\uD83D(?:\\uDC8B\\u200D\\uD83D)?\\uDC68\\uD83C[\\uDFFB-\\uDFFF]|\\uD83C[\\uDF3E\\uDF73\\uDF7C\\uDF93\\uDFA4\\uDFA8\\uDFEB\\uDFED]|\\uD83D[\\uDCBB\\uDCBC\\uDD27\\uDD2C\\uDE80\\uDE92]|\\uD83E(?:[\\uDDAF-\\uDDB3\\uDDBC\\uDDBD]|\\uDD1D\\u200D\\uD83D\\uDC68\\uD83C[\\uDFFB\\uDFFC\\uDFFE\\uDFFF])))?|\\uDFFE(?:\\u200D(?:[\\u2695\\u2696\\u2708]\\uFE0F?|\\u2764\\uFE0F?\\u200D\\uD83D(?:\\uDC8B\\u200D\\uD83D)?\\uDC68\\uD83C[\\uDFFB-\\uDFFF]|\\uD83C[\\uDF3E\\uDF73\\uDF7C\\uDF93\\uDFA4\\uDFA8\\uDFEB\\uDFED]|\\uD83D[\\uDCBB\\uDCBC\\uDD27\\uDD2C\\uDE80\\uDE92]|\\uD83E(?:[\\uDDAF-\\uDDB3\\uDDBC\\uDDBD]|\\uDD1D\\u200D\\uD83D\\uDC68\\uD83C[\\uDFFB-\\uDFFD\\uDFFF])))?|\\uDFFF(?:\\u200D(?:[\\u2695\\u2696\\u2708]\\uFE0F?|\\u2764\\uFE0F?\\u200D\\uD83D(?:\\uDC8B\\u200D\\uD83D)?\\uDC68\\uD83C[\\uDFFB-\\uDFFF]|\\uD83C[\\uDF3E\\uDF73\\uDF7C\\uDF93\\uDFA4\\uDFA8\\uDFEB\\uDFED]|\\uD83D[\\uDCBB\\uDCBC\\uDD27\\uDD2C\\uDE80\\uDE92]|\\uD83E(?:[\\uDDAF-\\uDDB3\\uDDBC\\uDDBD]|\\uDD1D\\u200D\\uD83D\\uDC68\\uD83C[\\uDFFB-\\uDFFE])))?))?|\\uDC69(?:\\u200D(?:[\\u2695\\u2696\\u2708]\\uFE0F?|\\u2764\\uFE0F?\\u200D\\uD83D(?:\\uDC8B\\u200D\\uD83D)?[\\uDC68\\uDC69]|\\uD83C[\\uDF3E\\uDF73\\uDF7C\\uDF93\\uDFA4\\uDFA8\\uDFEB\\uDFED]|\\uD83D(?:[\\uDCBB\\uDCBC\\uDD27\\uDD2C\\uDE80\\uDE92]|\\uDC66(?:\\u200D\\uD83D\\uDC66)?|\\uDC67(?:\\u200D\\uD83D[\\uDC66\\uDC67])?|\\uDC69\\u200D\\uD83D(?:\\uDC66(?:\\u200D\\uD83D\\uDC66)?|\\uDC67(?:\\u200D\\uD83D[\\uDC66\\uDC67])?))|\\uD83E[\\uDDAF-\\uDDB3\\uDDBC\\uDDBD])|\\uD83C(?:\\uDFFB(?:\\u200D(?:[\\u2695\\u2696\\u2708]\\uFE0F?|\\u2764\\uFE0F?\\u200D\\uD83D(?:[\\uDC68\\uDC69]|\\uDC8B\\u200D\\uD83D[\\uDC68\\uDC69])\\uD83C[\\uDFFB-\\uDFFF]|\\uD83C[\\uDF3E\\uDF73\\uDF7C\\uDF93\\uDFA4\\uDFA8\\uDFEB\\uDFED]|\\uD83D[\\uDCBB\\uDCBC\\uDD27\\uDD2C\\uDE80\\uDE92]|\\uD83E(?:[\\uDDAF-\\uDDB3\\uDDBC\\uDDBD]|\\uDD1D\\u200D\\uD83D[\\uDC68\\uDC69]\\uD83C[\\uDFFC-\\uDFFF])))?|\\uDFFC(?:\\u200D(?:[\\u2695\\u2696\\u2708]\\uFE0F?|\\u2764\\uFE0F?\\u200D\\uD83D(?:[\\uDC68\\uDC69]|\\uDC8B\\u200D\\uD83D[\\uDC68\\uDC69])\\uD83C[\\uDFFB-\\uDFFF]|\\uD83C[\\uDF3E\\uDF73\\uDF7C\\uDF93\\uDFA4\\uDFA8\\uDFEB\\uDFED]|\\uD83D[\\uDCBB\\uDCBC\\uDD27\\uDD2C\\uDE80\\uDE92]|\\uD83E(?:[\\uDDAF-\\uDDB3\\uDDBC\\uDDBD]|\\uDD1D\\u200D\\uD83D[\\uDC68\\uDC69]\\uD83C[\\uDFFB\\uDFFD-\\uDFFF])))?|\\uDFFD(?:\\u200D(?:[\\u2695\\u2696\\u2708]\\uFE0F?|\\u2764\\uFE0F?\\u200D\\uD83D(?:[\\uDC68\\uDC69]|\\uDC8B\\u200D\\uD83D[\\uDC68\\uDC69])\\uD83C[\\uDFFB-\\uDFFF]|\\uD83C[\\uDF3E\\uDF73\\uDF7C\\uDF93\\uDFA4\\uDFA8\\uDFEB\\uDFED]|\\uD83D[\\uDCBB\\uDCBC\\uDD27\\uDD2C\\uDE80\\uDE92]|\\uD83E(?:[\\uDDAF-\\uDDB3\\uDDBC\\uDDBD]|\\uDD1D\\u200D\\uD83D[\\uDC68\\uDC69]\\uD83C[\\uDFFB\\uDFFC\\uDFFE\\uDFFF])))?|\\uDFFE(?:\\u200D(?:[\\u2695\\u2696\\u2708]\\uFE0F?|\\u2764\\uFE0F?\\u200D\\uD83D(?:[\\uDC68\\uDC69]|\\uDC8B\\u200D\\uD83D[\\uDC68\\uDC69])\\uD83C[\\uDFFB-\\uDFFF]|\\uD83C[\\uDF3E\\uDF73\\uDF7C\\uDF93\\uDFA4\\uDFA8\\uDFEB\\uDFED]|\\uD83D[\\uDCBB\\uDCBC\\uDD27\\uDD2C\\uDE80\\uDE92]|\\uD83E(?:[\\uDDAF-\\uDDB3\\uDDBC\\uDDBD]|\\uDD1D\\u200D\\uD83D[\\uDC68\\uDC69]\\uD83C[\\uDFFB-\\uDFFD\\uDFFF])))?|\\uDFFF(?:\\u200D(?:[\\u2695\\u2696\\u2708]\\uFE0F?|\\u2764\\uFE0F?\\u200D\\uD83D(?:[\\uDC68\\uDC69]|\\uDC8B\\u200D\\uD83D[\\uDC68\\uDC69])\\uD83C[\\uDFFB-\\uDFFF]|\\uD83C[\\uDF3E\\uDF73\\uDF7C\\uDF93\\uDFA4\\uDFA8\\uDFEB\\uDFED]|\\uD83D[\\uDCBB\\uDCBC\\uDD27\\uDD2C\\uDE80\\uDE92]|\\uD83E(?:[\\uDDAF-\\uDDB3\\uDDBC\\uDDBD]|\\uDD1D\\u200D\\uD83D[\\uDC68\\uDC69]\\uD83C[\\uDFFB-\\uDFFE])))?))?|\\uDC6F(?:\\u200D[\\u2640\\u2642]\\uFE0F?)?|\\uDD75(?:\\uFE0F|\\uD83C[\\uDFFB-\\uDFFF])?(?:\\u200D[\\u2640\\u2642]\\uFE0F?)?|\\uDE2E(?:\\u200D\\uD83D\\uDCA8)?|\\uDE35(?:\\u200D\\uD83D\\uDCAB)?|\\uDE36(?:\\u200D\\uD83C\\uDF2B\\uFE0F?)?)|\\uD83E(?:[\\uDD0C\\uDD0F\\uDD18-\\uDD1F\\uDD30-\\uDD34\\uDD36\\uDD77\\uDDB5\\uDDB6\\uDDBB\\uDDD2\\uDDD3\\uDDD5\\uDEC3-\\uDEC5\\uDEF0\\uDEF2-\\uDEF8](?:\\uD83C[\\uDFFB-\\uDFFF])?|[\\uDD26\\uDD35\\uDD37-\\uDD39\\uDD3D\\uDD3E\\uDDB8\\uDDB9\\uDDCD-\\uDDCF\\uDDD4\\uDDD6-\\uDDDD](?:\\uD83C[\\uDFFB-\\uDFFF])?(?:\\u200D[\\u2640\\u2642]\\uFE0F?)?|[\\uDDDE\\uDDDF](?:\\u200D[\\u2640\\u2642]\\uFE0F?)?|[\\uDD0D\\uDD0E\\uDD10-\\uDD17\\uDD20-\\uDD25\\uDD27-\\uDD2F\\uDD3A\\uDD3F-\\uDD45\\uDD47-\\uDD76\\uDD78-\\uDDB4\\uDDB7\\uDDBA\\uDDBC-\\uDDCC\\uDDD0\\uDDE0-\\uDDFF\\uDE70-\\uDE7C\\uDE80-\\uDE88\\uDE90-\\uDEBD\\uDEBF-\\uDEC2\\uDECE-\\uDEDB\\uDEE0-\\uDEE8]|\\uDD3C(?:\\u200D[\\u2640\\u2642]\\uFE0F?|\\uD83C[\\uDFFB-\\uDFFF])?|\\uDDD1(?:\\u200D(?:[\\u2695\\u2696\\u2708]\\uFE0F?|\\uD83C[\\uDF3E\\uDF73\\uDF7C\\uDF84\\uDF93\\uDFA4\\uDFA8\\uDFEB\\uDFED]|\\uD83D[\\uDCBB\\uDCBC\\uDD27\\uDD2C\\uDE80\\uDE92]|\\uD83E(?:[\\uDDAF-\\uDDB3\\uDDBC\\uDDBD]|\\uDD1D\\u200D\\uD83E\\uDDD1))|\\uD83C(?:\\uDFFB(?:\\u200D(?:[\\u2695\\u2696\\u2708]\\uFE0F?|\\u2764\\uFE0F?\\u200D(?:\\uD83D\\uDC8B\\u200D)?\\uD83E\\uDDD1\\uD83C[\\uDFFC-\\uDFFF]|\\uD83C[\\uDF3E\\uDF73\\uDF7C\\uDF84\\uDF93\\uDFA4\\uDFA8\\uDFEB\\uDFED]|\\uD83D[\\uDCBB\\uDCBC\\uDD27\\uDD2C\\uDE80\\uDE92]|\\uD83E(?:[\\uDDAF-\\uDDB3\\uDDBC\\uDDBD]|\\uDD1D\\u200D\\uD83E\\uDDD1\\uD83C[\\uDFFB-\\uDFFF])))?|\\uDFFC(?:\\u200D(?:[\\u2695\\u2696\\u2708]\\uFE0F?|\\u2764\\uFE0F?\\u200D(?:\\uD83D\\uDC8B\\u200D)?\\uD83E\\uDDD1\\uD83C[\\uDFFB\\uDFFD-\\uDFFF]|\\uD83C[\\uDF3E\\uDF73\\uDF7C\\uDF84\\uDF93\\uDFA4\\uDFA8\\uDFEB\\uDFED]|\\uD83D[\\uDCBB\\uDCBC\\uDD27\\uDD2C\\uDE80\\uDE92]|\\uD83E(?:[\\uDDAF-\\uDDB3\\uDDBC\\uDDBD]|\\uDD1D\\u200D\\uD83E\\uDDD1\\uD83C[\\uDFFB-\\uDFFF])))?|\\uDFFD(?:\\u200D(?:[\\u2695\\u2696\\u2708]\\uFE0F?|\\u2764\\uFE0F?\\u200D(?:\\uD83D\\uDC8B\\u200D)?\\uD83E\\uDDD1\\uD83C[\\uDFFB\\uDFFC\\uDFFE\\uDFFF]|\\uD83C[\\uDF3E\\uDF73\\uDF7C\\uDF84\\uDF93\\uDFA4\\uDFA8\\uDFEB\\uDFED]|\\uD83D[\\uDCBB\\uDCBC\\uDD27\\uDD2C\\uDE80\\uDE92]|\\uD83E(?:[\\uDDAF-\\uDDB3\\uDDBC\\uDDBD]|\\uDD1D\\u200D\\uD83E\\uDDD1\\uD83C[\\uDFFB-\\uDFFF])))?|\\uDFFE(?:\\u200D(?:[\\u2695\\u2696\\u2708]\\uFE0F?|\\u2764\\uFE0F?\\u200D(?:\\uD83D\\uDC8B\\u200D)?\\uD83E\\uDDD1\\uD83C[\\uDFFB-\\uDFFD\\uDFFF]|\\uD83C[\\uDF3E\\uDF73\\uDF7C\\uDF84\\uDF93\\uDFA4\\uDFA8\\uDFEB\\uDFED]|\\uD83D[\\uDCBB\\uDCBC\\uDD27\\uDD2C\\uDE80\\uDE92]|\\uD83E(?:[\\uDDAF-\\uDDB3\\uDDBC\\uDDBD]|\\uDD1D\\u200D\\uD83E\\uDDD1\\uD83C[\\uDFFB-\\uDFFF])))?|\\uDFFF(?:\\u200D(?:[\\u2695\\u2696\\u2708]\\uFE0F?|\\u2764\\uFE0F?\\u200D(?:\\uD83D\\uDC8B\\u200D)?\\uD83E\\uDDD1\\uD83C[\\uDFFB-\\uDFFE]|\\uD83C[\\uDF3E\\uDF73\\uDF7C\\uDF84\\uDF93\\uDFA4\\uDFA8\\uDFEB\\uDFED]|\\uD83D[\\uDCBB\\uDCBC\\uDD27\\uDD2C\\uDE80\\uDE92]|\\uD83E(?:[\\uDDAF-\\uDDB3\\uDDBC\\uDDBD]|\\uDD1D\\u200D\\uD83E\\uDDD1\\uD83C[\\uDFFB-\\uDFFF])))?))?|\\uDEF1(?:\\uD83C(?:\\uDFFB(?:\\u200D\\uD83E\\uDEF2\\uD83C[\\uDFFC-\\uDFFF])?|\\uDFFC(?:\\u200D\\uD83E\\uDEF2\\uD83C[\\uDFFB\\uDFFD-\\uDFFF])?|\\uDFFD(?:\\u200D\\uD83E\\uDEF2\\uD83C[\\uDFFB\\uDFFC\\uDFFE\\uDFFF])?|\\uDFFE(?:\\u200D\\uD83E\\uDEF2\\uD83C[\\uDFFB-\\uDFFD\\uDFFF])?|\\uDFFF(?:\\u200D\\uD83E\\uDEF2\\uD83C[\\uDFFB-\\uDFFE])?))?)/g;\n};\nvar eastasianwidth_default = {\n eastAsianWidth(character) {\n var x = character.charCodeAt(0);\n var y = character.length == 2 ? character.charCodeAt(1) : 0;\n var codePoint = x;\n if (55296 <= x && x <= 56319 && 56320 <= y && y <= 57343) {\n x &= 1023;\n y &= 1023;\n codePoint = x << 10 | y;\n codePoint += 65536;\n }\n if (12288 == codePoint || 65281 <= codePoint && codePoint <= 65376 || 65504 <= codePoint && codePoint <= 65510) {\n return \"F\";\n }\n if (4352 <= codePoint && codePoint <= 4447 || 4515 <= codePoint && codePoint <= 4519 || 4602 <= codePoint && codePoint <= 4607 || 9001 <= codePoint && codePoint <= 9002 || 11904 <= codePoint && codePoint <= 11929 || 11931 <= codePoint && codePoint <= 12019 || 12032 <= codePoint && codePoint <= 12245 || 12272 <= codePoint && codePoint <= 12283 || 12289 <= codePoint && codePoint <= 12350 || 12353 <= codePoint && codePoint <= 12438 || 12441 <= codePoint && codePoint <= 12543 || 12549 <= codePoint && codePoint <= 12589 || 12593 <= codePoint && codePoint <= 12686 || 12688 <= codePoint && codePoint <= 12730 || 12736 <= codePoint && codePoint <= 12771 || 12784 <= codePoint && codePoint <= 12830 || 12832 <= codePoint && codePoint <= 12871 || 12880 <= codePoint && codePoint <= 13054 || 13056 <= codePoint && codePoint <= 19903 || 19968 <= codePoint && codePoint <= 42124 || 42128 <= codePoint && codePoint <= 42182 || 43360 <= codePoint && codePoint <= 43388 || 44032 <= codePoint && codePoint <= 55203 || 55216 <= codePoint && codePoint <= 55238 || 55243 <= codePoint && codePoint <= 55291 || 63744 <= codePoint && codePoint <= 64255 || 65040 <= codePoint && codePoint <= 65049 || 65072 <= codePoint && codePoint <= 65106 || 65108 <= codePoint && codePoint <= 65126 || 65128 <= codePoint && codePoint <= 65131 || 110592 <= codePoint && codePoint <= 110593 || 127488 <= codePoint && codePoint <= 127490 || 127504 <= codePoint && codePoint <= 127546 || 127552 <= codePoint && codePoint <= 127560 || 127568 <= codePoint && codePoint <= 127569 || 131072 <= codePoint && codePoint <= 194367 || 177984 <= codePoint && codePoint <= 196605 || 196608 <= codePoint && codePoint <= 262141) {\n return \"W\";\n }\n return \"N\";\n }\n};\nvar notAsciiRegex = /[^\\x20-\\x7F]/;\nfunction getStringWidth(text) {\n if (!text) {\n return 0;\n }\n if (!notAsciiRegex.test(text)) {\n return text.length;\n }\n text = text.replace(emoji_regex_default(), \" \");\n let width = 0;\n for (const character of text) {\n const codePoint = character.codePointAt(0);\n if (codePoint <= 31 || codePoint >= 127 && codePoint <= 159) {\n continue;\n }\n if (codePoint >= 768 && codePoint <= 879) {\n continue;\n }\n const code = eastasianwidth_default.eastAsianWidth(character);\n width += code === \"F\" || code === \"W\" ? 2 : 1;\n }\n return width;\n}\nvar get_string_width_default = getStringWidth;\nvar getDocParts = (doc) => {\n if (Array.isArray(doc)) {\n return doc;\n }\n if (doc.type !== DOC_TYPE_FILL) {\n throw new Error(`Expect doc to be 'array' or '${DOC_TYPE_FILL}'.`);\n }\n return doc.parts;\n};\nfunction mapDoc(doc, cb) {\n if (typeof doc === \"string\") {\n return cb(doc);\n }\n const mapped = /* @__PURE__ */ new Map();\n return rec(doc);\n function rec(doc2) {\n if (mapped.has(doc2)) {\n return mapped.get(doc2);\n }\n const result = process2(doc2);\n mapped.set(doc2, result);\n return result;\n }\n function process2(doc2) {\n switch (get_doc_type_default(doc2)) {\n case DOC_TYPE_ARRAY:\n return cb(doc2.map(rec));\n case DOC_TYPE_FILL:\n return cb({\n ...doc2,\n parts: doc2.parts.map(rec)\n });\n case DOC_TYPE_IF_BREAK:\n return cb({\n ...doc2,\n breakContents: rec(doc2.breakContents),\n flatContents: rec(doc2.flatContents)\n });\n case DOC_TYPE_GROUP: {\n let {\n expandedStates,\n contents\n } = doc2;\n if (expandedStates) {\n expandedStates = expandedStates.map(rec);\n contents = expandedStates[0];\n } else {\n contents = rec(contents);\n }\n return cb({\n ...doc2,\n contents,\n expandedStates\n });\n }\n case DOC_TYPE_ALIGN:\n case DOC_TYPE_INDENT:\n case DOC_TYPE_INDENT_IF_BREAK:\n case DOC_TYPE_LABEL:\n case DOC_TYPE_LINE_SUFFIX:\n return cb({\n ...doc2,\n contents: rec(doc2.contents)\n });\n case DOC_TYPE_STRING:\n case DOC_TYPE_CURSOR:\n case DOC_TYPE_TRIM:\n case DOC_TYPE_LINE_SUFFIX_BOUNDARY:\n case DOC_TYPE_LINE:\n case DOC_TYPE_BREAK_PARENT:\n return cb(doc2);\n default:\n throw new invalid_doc_error_default(doc2);\n }\n }\n}\nfunction findInDoc(doc, fn, defaultValue) {\n let result = defaultValue;\n let shouldSkipFurtherProcessing = false;\n function findInDocOnEnterFn(doc2) {\n if (shouldSkipFurtherProcessing) {\n return false;\n }\n const maybeResult = fn(doc2);\n if (maybeResult !== void 0) {\n shouldSkipFurtherProcessing = true;\n result = maybeResult;\n }\n }\n traverse_doc_default(doc, findInDocOnEnterFn);\n return result;\n}\nfunction willBreakFn(doc) {\n if (doc.type === DOC_TYPE_GROUP && doc.break) {\n return true;\n }\n if (doc.type === DOC_TYPE_LINE && doc.hard) {\n return true;\n }\n if (doc.type === DOC_TYPE_BREAK_PARENT) {\n return true;\n }\n}\nfunction willBreak(doc) {\n return findInDoc(doc, willBreakFn, false);\n}\nfunction breakParentGroup(groupStack) {\n if (groupStack.length > 0) {\n const parentGroup = at_default(\n /* isOptionalObject*/\n false,\n groupStack,\n -1\n );\n if (!parentGroup.expandedStates && !parentGroup.break) {\n parentGroup.break = \"propagated\";\n }\n }\n return null;\n}\nfunction propagateBreaks(doc) {\n const alreadyVisitedSet = /* @__PURE__ */ new Set();\n const groupStack = [];\n function propagateBreaksOnEnterFn(doc2) {\n if (doc2.type === DOC_TYPE_BREAK_PARENT) {\n breakParentGroup(groupStack);\n }\n if (doc2.type === DOC_TYPE_GROUP) {\n groupStack.push(doc2);\n if (alreadyVisitedSet.has(doc2)) {\n return false;\n }\n alreadyVisitedSet.add(doc2);\n }\n }\n function propagateBreaksOnExitFn(doc2) {\n if (doc2.type === DOC_TYPE_GROUP) {\n const group22 = groupStack.pop();\n if (group22.break) {\n breakParentGroup(groupStack);\n }\n }\n }\n traverse_doc_default(\n doc,\n propagateBreaksOnEnterFn,\n propagateBreaksOnExitFn,\n /* shouldTraverseConditionalGroups */\n true\n );\n}\nfunction removeLinesFn(doc) {\n if (doc.type === DOC_TYPE_LINE && !doc.hard) {\n return doc.soft ? \"\" : \" \";\n }\n if (doc.type === DOC_TYPE_IF_BREAK) {\n return doc.flatContents;\n }\n return doc;\n}\nfunction removeLines(doc) {\n return mapDoc(doc, removeLinesFn);\n}\nfunction stripTrailingHardlineFromParts(parts) {\n parts = [...parts];\n while (parts.length >= 2 && at_default(\n /* isOptionalObject*/\n false,\n parts,\n -2\n ).type === DOC_TYPE_LINE && at_default(\n /* isOptionalObject*/\n false,\n parts,\n -1\n ).type === DOC_TYPE_BREAK_PARENT) {\n parts.length -= 2;\n }\n if (parts.length > 0) {\n const lastPart = stripTrailingHardlineFromDoc(at_default(\n /* isOptionalObject*/\n false,\n parts,\n -1\n ));\n parts[parts.length - 1] = lastPart;\n }\n return parts;\n}\nfunction stripTrailingHardlineFromDoc(doc) {\n switch (get_doc_type_default(doc)) {\n case DOC_TYPE_ALIGN:\n case DOC_TYPE_INDENT:\n case DOC_TYPE_INDENT_IF_BREAK:\n case DOC_TYPE_GROUP:\n case DOC_TYPE_LINE_SUFFIX:\n case DOC_TYPE_LABEL: {\n const contents = stripTrailingHardlineFromDoc(doc.contents);\n return {\n ...doc,\n contents\n };\n }\n case DOC_TYPE_IF_BREAK:\n return {\n ...doc,\n breakContents: stripTrailingHardlineFromDoc(doc.breakContents),\n flatContents: stripTrailingHardlineFromDoc(doc.flatContents)\n };\n case DOC_TYPE_FILL:\n return {\n ...doc,\n parts: stripTrailingHardlineFromParts(doc.parts)\n };\n case DOC_TYPE_ARRAY:\n return stripTrailingHardlineFromParts(doc);\n case DOC_TYPE_STRING:\n return doc.replace(/[\\n\\r]*$/, \"\");\n case DOC_TYPE_CURSOR:\n case DOC_TYPE_TRIM:\n case DOC_TYPE_LINE_SUFFIX_BOUNDARY:\n case DOC_TYPE_LINE:\n case DOC_TYPE_BREAK_PARENT:\n break;\n default:\n throw new invalid_doc_error_default(doc);\n }\n return doc;\n}\nfunction stripTrailingHardline(doc) {\n return stripTrailingHardlineFromDoc(cleanDoc(doc));\n}\nfunction cleanDocFn(doc) {\n switch (get_doc_type_default(doc)) {\n case DOC_TYPE_FILL:\n if (doc.parts.every((part) => part === \"\")) {\n return \"\";\n }\n break;\n case DOC_TYPE_GROUP:\n if (!doc.contents && !doc.id && !doc.break && !doc.expandedStates) {\n return \"\";\n }\n if (doc.contents.type === DOC_TYPE_GROUP && doc.contents.id === doc.id && doc.contents.break === doc.break && doc.contents.expandedStates === doc.expandedStates) {\n return doc.contents;\n }\n break;\n case DOC_TYPE_ALIGN:\n case DOC_TYPE_INDENT:\n case DOC_TYPE_INDENT_IF_BREAK:\n case DOC_TYPE_LINE_SUFFIX:\n if (!doc.contents) {\n return \"\";\n }\n break;\n case DOC_TYPE_IF_BREAK:\n if (!doc.flatContents && !doc.breakContents) {\n return \"\";\n }\n break;\n case DOC_TYPE_ARRAY: {\n const parts = [];\n for (const part of doc) {\n if (!part) {\n continue;\n }\n const [currentPart, ...restParts] = Array.isArray(part) ? part : [part];\n if (typeof currentPart === \"string\" && typeof at_default(\n /* isOptionalObject*/\n false,\n parts,\n -1\n ) === \"string\") {\n parts[parts.length - 1] += currentPart;\n } else {\n parts.push(currentPart);\n }\n parts.push(...restParts);\n }\n if (parts.length === 0) {\n return \"\";\n }\n if (parts.length === 1) {\n return parts[0];\n }\n return parts;\n }\n case DOC_TYPE_STRING:\n case DOC_TYPE_CURSOR:\n case DOC_TYPE_TRIM:\n case DOC_TYPE_LINE_SUFFIX_BOUNDARY:\n case DOC_TYPE_LINE:\n case DOC_TYPE_LABEL:\n case DOC_TYPE_BREAK_PARENT:\n break;\n default:\n throw new invalid_doc_error_default(doc);\n }\n return doc;\n}\nfunction cleanDoc(doc) {\n return mapDoc(doc, (currentDoc) => cleanDocFn(currentDoc));\n}\nfunction replaceEndOfLine(doc, replacement = literalline) {\n return mapDoc(doc, (currentDoc) => typeof currentDoc === \"string\" ? join(replacement, currentDoc.split(\"\\n\")) : currentDoc);\n}\nfunction canBreakFn(doc) {\n if (doc.type === DOC_TYPE_LINE) {\n return true;\n }\n}\nfunction canBreak(doc) {\n return findInDoc(doc, canBreakFn, false);\n}\nvar MODE_BREAK = Symbol(\"MODE_BREAK\");\nvar MODE_FLAT = Symbol(\"MODE_FLAT\");\nvar CURSOR_PLACEHOLDER = Symbol(\"cursor\");\nfunction rootIndent() {\n return {\n value: \"\",\n length: 0,\n queue: []\n };\n}\nfunction makeIndent(ind, options) {\n return generateInd(ind, {\n type: \"indent\"\n }, options);\n}\nfunction makeAlign(indent22, widthOrDoc, options) {\n if (widthOrDoc === Number.NEGATIVE_INFINITY) {\n return indent22.root || rootIndent();\n }\n if (widthOrDoc < 0) {\n return generateInd(indent22, {\n type: \"dedent\"\n }, options);\n }\n if (!widthOrDoc) {\n return indent22;\n }\n if (widthOrDoc.type === \"root\") {\n return {\n ...indent22,\n root: indent22\n };\n }\n const alignType = typeof widthOrDoc === \"string\" ? \"stringAlign\" : \"numberAlign\";\n return generateInd(indent22, {\n type: alignType,\n n: widthOrDoc\n }, options);\n}\nfunction generateInd(ind, newPart, options) {\n const queue = newPart.type === \"dedent\" ? ind.queue.slice(0, -1) : [...ind.queue, newPart];\n let value = \"\";\n let length = 0;\n let lastTabs = 0;\n let lastSpaces = 0;\n for (const part of queue) {\n switch (part.type) {\n case \"indent\":\n flush();\n if (options.useTabs) {\n addTabs(1);\n } else {\n addSpaces(options.tabWidth);\n }\n break;\n case \"stringAlign\":\n flush();\n value += part.n;\n length += part.n.length;\n break;\n case \"numberAlign\":\n lastTabs += 1;\n lastSpaces += part.n;\n break;\n default:\n throw new Error(`Unexpected type '${part.type}'`);\n }\n }\n flushSpaces();\n return {\n ...ind,\n value,\n length,\n queue\n };\n function addTabs(count) {\n value += \"\t\".repeat(count);\n length += options.tabWidth * count;\n }\n function addSpaces(count) {\n value += \" \".repeat(count);\n length += count;\n }\n function flush() {\n if (options.useTabs) {\n flushTabs();\n } else {\n flushSpaces();\n }\n }\n function flushTabs() {\n if (lastTabs > 0) {\n addTabs(lastTabs);\n }\n resetLast();\n }\n function flushSpaces() {\n if (lastSpaces > 0) {\n addSpaces(lastSpaces);\n }\n resetLast();\n }\n function resetLast() {\n lastTabs = 0;\n lastSpaces = 0;\n }\n}\nfunction trim2(out) {\n let trimCount = 0;\n let cursorCount = 0;\n let outIndex = out.length;\n outer:\n while (outIndex--) {\n const last = out[outIndex];\n if (last === CURSOR_PLACEHOLDER) {\n cursorCount++;\n continue;\n }\n if (false) {\n throw new Error(`Unexpected value in trim: '${typeof last}'`);\n }\n for (let charIndex = last.length - 1; charIndex >= 0; charIndex--) {\n const char = last[charIndex];\n if (char === \" \" || char === \"\t\") {\n trimCount++;\n } else {\n out[outIndex] = last.slice(0, charIndex + 1);\n break outer;\n }\n }\n }\n if (trimCount > 0 || cursorCount > 0) {\n out.length = outIndex + 1;\n while (cursorCount-- > 0) {\n out.push(CURSOR_PLACEHOLDER);\n }\n }\n return trimCount;\n}\nfunction fits(next, restCommands, width, hasLineSuffix, groupModeMap, mustBeFlat) {\n if (width === Number.POSITIVE_INFINITY) {\n return true;\n }\n let restIdx = restCommands.length;\n const cmds = [next];\n const out = [];\n while (width >= 0) {\n if (cmds.length === 0) {\n if (restIdx === 0) {\n return true;\n }\n cmds.push(restCommands[--restIdx]);\n continue;\n }\n const {\n mode,\n doc\n } = cmds.pop();\n switch (get_doc_type_default(doc)) {\n case DOC_TYPE_STRING:\n out.push(doc);\n width -= get_string_width_default(doc);\n break;\n case DOC_TYPE_ARRAY:\n case DOC_TYPE_FILL: {\n const parts = getDocParts(doc);\n for (let i = parts.length - 1; i >= 0; i--) {\n cmds.push({\n mode,\n doc: parts[i]\n });\n }\n break;\n }\n case DOC_TYPE_INDENT:\n case DOC_TYPE_ALIGN:\n case DOC_TYPE_INDENT_IF_BREAK:\n case DOC_TYPE_LABEL:\n cmds.push({\n mode,\n doc: doc.contents\n });\n break;\n case DOC_TYPE_TRIM:\n width += trim2(out);\n break;\n case DOC_TYPE_GROUP: {\n if (mustBeFlat && doc.break) {\n return false;\n }\n const groupMode = doc.break ? MODE_BREAK : mode;\n const contents = doc.expandedStates && groupMode === MODE_BREAK ? at_default(\n /* isOptionalObject*/\n false,\n doc.expandedStates,\n -1\n ) : doc.contents;\n cmds.push({\n mode: groupMode,\n doc: contents\n });\n break;\n }\n case DOC_TYPE_IF_BREAK: {\n const groupMode = doc.groupId ? groupModeMap[doc.groupId] || MODE_FLAT : mode;\n const contents = groupMode === MODE_BREAK ? doc.breakContents : doc.flatContents;\n if (contents) {\n cmds.push({\n mode,\n doc: contents\n });\n }\n break;\n }\n case DOC_TYPE_LINE:\n if (mode === MODE_BREAK || doc.hard) {\n return true;\n }\n if (!doc.soft) {\n out.push(\" \");\n width--;\n }\n break;\n case DOC_TYPE_LINE_SUFFIX:\n hasLineSuffix = true;\n break;\n case DOC_TYPE_LINE_SUFFIX_BOUNDARY:\n if (hasLineSuffix) {\n return false;\n }\n break;\n }\n }\n return false;\n}\nfunction printDocToString(doc, options) {\n const groupModeMap = {};\n const width = options.printWidth;\n const newLine = convertEndOfLineToChars(options.endOfLine);\n let pos = 0;\n const cmds = [{\n ind: rootIndent(),\n mode: MODE_BREAK,\n doc\n }];\n const out = [];\n let shouldRemeasure = false;\n const lineSuffix22 = [];\n let printedCursorCount = 0;\n propagateBreaks(doc);\n while (cmds.length > 0) {\n const {\n ind,\n mode,\n doc: doc2\n } = cmds.pop();\n switch (get_doc_type_default(doc2)) {\n case DOC_TYPE_STRING: {\n const formatted = newLine !== \"\\n\" ? string_replace_all_default(\n /* isOptionalObject*/\n false,\n doc2,\n \"\\n\",\n newLine\n ) : doc2;\n out.push(formatted);\n if (cmds.length > 0) {\n pos += get_string_width_default(formatted);\n }\n break;\n }\n case DOC_TYPE_ARRAY:\n for (let i = doc2.length - 1; i >= 0; i--) {\n cmds.push({\n ind,\n mode,\n doc: doc2[i]\n });\n }\n break;\n case DOC_TYPE_CURSOR:\n if (printedCursorCount >= 2) {\n throw new Error(\"There are too many 'cursor' in doc.\");\n }\n out.push(CURSOR_PLACEHOLDER);\n printedCursorCount++;\n break;\n case DOC_TYPE_INDENT:\n cmds.push({\n ind: makeIndent(ind, options),\n mode,\n doc: doc2.contents\n });\n break;\n case DOC_TYPE_ALIGN:\n cmds.push({\n ind: makeAlign(ind, doc2.n, options),\n mode,\n doc: doc2.contents\n });\n break;\n case DOC_TYPE_TRIM:\n pos -= trim2(out);\n break;\n case DOC_TYPE_GROUP:\n switch (mode) {\n case MODE_FLAT:\n if (!shouldRemeasure) {\n cmds.push({\n ind,\n mode: doc2.break ? MODE_BREAK : MODE_FLAT,\n doc: doc2.contents\n });\n break;\n }\n case MODE_BREAK: {\n shouldRemeasure = false;\n const next = {\n ind,\n mode: MODE_FLAT,\n doc: doc2.contents\n };\n const rem = width - pos;\n const hasLineSuffix = lineSuffix22.length > 0;\n if (!doc2.break && fits(next, cmds, rem, hasLineSuffix, groupModeMap)) {\n cmds.push(next);\n } else {\n if (doc2.expandedStates) {\n const mostExpanded = at_default(\n /* isOptionalObject*/\n false,\n doc2.expandedStates,\n -1\n );\n if (doc2.break) {\n cmds.push({\n ind,\n mode: MODE_BREAK,\n doc: mostExpanded\n });\n break;\n } else {\n for (let i = 1; i < doc2.expandedStates.length + 1; i++) {\n if (i >= doc2.expandedStates.length) {\n cmds.push({\n ind,\n mode: MODE_BREAK,\n doc: mostExpanded\n });\n break;\n } else {\n const state = doc2.expandedStates[i];\n const cmd = {\n ind,\n mode: MODE_FLAT,\n doc: state\n };\n if (fits(cmd, cmds, rem, hasLineSuffix, groupModeMap)) {\n cmds.push(cmd);\n break;\n }\n }\n }\n }\n } else {\n cmds.push({\n ind,\n mode: MODE_BREAK,\n doc: doc2.contents\n });\n }\n }\n break;\n }\n }\n if (doc2.id) {\n groupModeMap[doc2.id] = at_default(\n /* isOptionalObject*/\n false,\n cmds,\n -1\n ).mode;\n }\n break;\n case DOC_TYPE_FILL: {\n const rem = width - pos;\n const {\n parts\n } = doc2;\n if (parts.length === 0) {\n break;\n }\n const [content, whitespace] = parts;\n const contentFlatCmd = {\n ind,\n mode: MODE_FLAT,\n doc: content\n };\n const contentBreakCmd = {\n ind,\n mode: MODE_BREAK,\n doc: content\n };\n const contentFits = fits(contentFlatCmd, [], rem, lineSuffix22.length > 0, groupModeMap, true);\n if (parts.length === 1) {\n if (contentFits) {\n cmds.push(contentFlatCmd);\n } else {\n cmds.push(contentBreakCmd);\n }\n break;\n }\n const whitespaceFlatCmd = {\n ind,\n mode: MODE_FLAT,\n doc: whitespace\n };\n const whitespaceBreakCmd = {\n ind,\n mode: MODE_BREAK,\n doc: whitespace\n };\n if (parts.length === 2) {\n if (contentFits) {\n cmds.push(whitespaceFlatCmd, contentFlatCmd);\n } else {\n cmds.push(whitespaceBreakCmd, contentBreakCmd);\n }\n break;\n }\n parts.splice(0, 2);\n const remainingCmd = {\n ind,\n mode,\n doc: fill(parts)\n };\n const secondContent = parts[0];\n const firstAndSecondContentFlatCmd = {\n ind,\n mode: MODE_FLAT,\n doc: [content, whitespace, secondContent]\n };\n const firstAndSecondContentFits = fits(firstAndSecondContentFlatCmd, [], rem, lineSuffix22.length > 0, groupModeMap, true);\n if (firstAndSecondContentFits) {\n cmds.push(remainingCmd, whitespaceFlatCmd, contentFlatCmd);\n } else if (contentFits) {\n cmds.push(remainingCmd, whitespaceBreakCmd, contentFlatCmd);\n } else {\n cmds.push(remainingCmd, whitespaceBreakCmd, contentBreakCmd);\n }\n break;\n }\n case DOC_TYPE_IF_BREAK:\n case DOC_TYPE_INDENT_IF_BREAK: {\n const groupMode = doc2.groupId ? groupModeMap[doc2.groupId] : mode;\n if (groupMode === MODE_BREAK) {\n const breakContents = doc2.type === DOC_TYPE_IF_BREAK ? doc2.breakContents : doc2.negate ? doc2.contents : indent(doc2.contents);\n if (breakContents) {\n cmds.push({\n ind,\n mode,\n doc: breakContents\n });\n }\n }\n if (groupMode === MODE_FLAT) {\n const flatContents = doc2.type === DOC_TYPE_IF_BREAK ? doc2.flatContents : doc2.negate ? indent(doc2.contents) : doc2.contents;\n if (flatContents) {\n cmds.push({\n ind,\n mode,\n doc: flatContents\n });\n }\n }\n break;\n }\n case DOC_TYPE_LINE_SUFFIX:\n lineSuffix22.push({\n ind,\n mode,\n doc: doc2.contents\n });\n break;\n case DOC_TYPE_LINE_SUFFIX_BOUNDARY:\n if (lineSuffix22.length > 0) {\n cmds.push({\n ind,\n mode,\n doc: hardlineWithoutBreakParent\n });\n }\n break;\n case DOC_TYPE_LINE:\n switch (mode) {\n case MODE_FLAT:\n if (!doc2.hard) {\n if (!doc2.soft) {\n out.push(\" \");\n pos += 1;\n }\n break;\n } else {\n shouldRemeasure = true;\n }\n case MODE_BREAK:\n if (lineSuffix22.length > 0) {\n cmds.push({\n ind,\n mode,\n doc: doc2\n }, ...lineSuffix22.reverse());\n lineSuffix22.length = 0;\n break;\n }\n if (doc2.literal) {\n if (ind.root) {\n out.push(newLine, ind.root.value);\n pos = ind.root.length;\n } else {\n out.push(newLine);\n pos = 0;\n }\n } else {\n pos -= trim2(out);\n out.push(newLine + ind.value);\n pos = ind.length;\n }\n break;\n }\n break;\n case DOC_TYPE_LABEL:\n cmds.push({\n ind,\n mode,\n doc: doc2.contents\n });\n break;\n case DOC_TYPE_BREAK_PARENT:\n break;\n default:\n throw new invalid_doc_error_default(doc2);\n }\n if (cmds.length === 0 && lineSuffix22.length > 0) {\n cmds.push(...lineSuffix22.reverse());\n lineSuffix22.length = 0;\n }\n }\n const cursorPlaceholderIndex = out.indexOf(CURSOR_PLACEHOLDER);\n if (cursorPlaceholderIndex !== -1) {\n const otherCursorPlaceholderIndex = out.indexOf(CURSOR_PLACEHOLDER, cursorPlaceholderIndex + 1);\n const beforeCursor = out.slice(0, cursorPlaceholderIndex).join(\"\");\n const aroundCursor = out.slice(cursorPlaceholderIndex + 1, otherCursorPlaceholderIndex).join(\"\");\n const afterCursor = out.slice(otherCursorPlaceholderIndex + 1).join(\"\");\n return {\n formatted: beforeCursor + aroundCursor + afterCursor,\n cursorNodeStart: beforeCursor.length,\n cursorNodeText: aroundCursor\n };\n }\n return {\n formatted: out.join(\"\")\n };\n}\nvar builders = {\n join,\n line,\n softline,\n hardline,\n literalline,\n group,\n conditionalGroup,\n fill,\n lineSuffix,\n lineSuffixBoundary,\n cursor,\n breakParent,\n ifBreak,\n trim,\n indent,\n indentIfBreak,\n align,\n addAlignmentToDoc,\n markAsRoot,\n dedentToRoot,\n dedent,\n hardlineWithoutBreakParent,\n literallineWithoutBreakParent,\n label,\n // TODO: Remove this in v4\n concat: (parts) => parts\n};\nvar printer = { printDocToString };\nvar utils = {\n willBreak,\n traverseDoc: traverse_doc_default,\n findInDoc,\n mapDoc,\n removeLines,\n stripTrailingHardline,\n replaceEndOfLine,\n canBreak\n};\n\n// libs/printer/common.ts\nimport { printRaw } from \"@unified-latex/unified-latex-util-print-raw\";\nimport { match } from \"@unified-latex/unified-latex-util-match\";\nfunction formatEnvSurround(node) {\n const env = printRaw(node.env);\n return {\n envName: env,\n start: ESCAPE + \"begin{\" + env + \"}\",\n end: ESCAPE + \"end{\" + env + \"}\"\n };\n}\nfunction isLineType(elm) {\n if (elm == null || typeof elm === \"string\") {\n return false;\n }\n if (Array.isArray(elm)) {\n return isLineType(elm[0]);\n }\n if (elm.type === \"concat\") {\n return isLineType(elm.parts);\n }\n return elm.type === \"line\";\n}\nfunction joinWithSoftline(arr) {\n if (arr.length === 0 || arr.length === 1) {\n return arr;\n }\n const ret = [arr[0]];\n for (let i = 1; i < arr.length; i++) {\n const prevNode = arr[i - 1];\n const nextNode = arr[i];\n if (!isLineType(prevNode) && !isLineType(nextNode)) {\n ret.push(softline2);\n }\n ret.push(nextNode);\n }\n return ret;\n}\nfunction getNodeInfo(node, options) {\n if (!node) {\n return { renderInfo: {} };\n }\n const renderInfo = node._renderInfo || {};\n const previousNode = options.referenceMap && options.referenceMap.getPreviousNode(node);\n const nextNode = options.referenceMap && options.referenceMap.getNextNode(node);\n const renderCache = options.referenceMap && options.referenceMap.getRenderCache(node);\n return {\n renderInfo,\n renderCache,\n previousNode,\n nextNode,\n referenceMap: options.referenceMap\n };\n}\nvar ESCAPE = \"\\\\\";\nvar {\n group: group2,\n fill: fill2,\n ifBreak: ifBreak2,\n line: line2,\n softline: softline2,\n hardline: hardline2,\n lineSuffix: lineSuffix2,\n lineSuffixBoundary: lineSuffixBoundary2,\n breakParent: breakParent2,\n indent: indent2,\n markAsRoot: markAsRoot2,\n join: join2\n} = builders;\nfunction formatDocArray(nodes, docArray, options) {\n const ret = [];\n for (let i = 0; i < nodes.length; i++) {\n const rawNode = nodes[i];\n const printedNode = docArray[i];\n const { renderInfo, referenceMap, previousNode, nextNode } = getNodeInfo(rawNode, options);\n const renderCache = referenceMap && referenceMap.getRenderCache(rawNode);\n switch (rawNode.type) {\n case \"comment\":\n if (!rawNode.sameline && previousNode && !match.comment(previousNode) && !match.parbreak(previousNode)) {\n ret.push(hardline2);\n }\n ret.push(printedNode);\n if (nextNode && !rawNode.suffixParbreak) {\n ret.push(hardline2);\n }\n break;\n case \"environment\":\n case \"displaymath\":\n case \"mathenv\":\n if (previousNode && (previousNode == null ? void 0 : previousNode.type) !== \"parbreak\") {\n if (ret[ret.length - 1] === line2) {\n ret.pop();\n }\n if (ret[ret.length - 1] !== hardline2) {\n ret.push(hardline2);\n }\n }\n ret.push(printedNode);\n if ((nextNode == null ? void 0 : nextNode.type) === \"whitespace\") {\n ret.push(hardline2);\n i++;\n }\n break;\n case \"macro\":\n if (renderInfo.breakBefore || renderInfo.breakAround) {\n if (previousNode) {\n if (ret[ret.length - 1] === line2 || ret[ret.length - 1] === hardline2) {\n ret.pop();\n ret.push(hardline2);\n } else if (!match.comment(previousNode) && !match.parbreak(previousNode)) {\n ret.push(hardline2);\n }\n }\n }\n if (renderInfo.inParMode && !renderInfo.hangingIndent && renderCache) {\n ret.push(\n renderCache.content,\n ...renderCache.rawArgs || []\n );\n } else {\n ret.push(printedNode);\n }\n if (renderInfo.breakAfter || renderInfo.breakAround) {\n if (nextNode) {\n if (match.whitespace(nextNode)) {\n ret.push(hardline2);\n i++;\n } else if (match.parbreak(nextNode)) {\n } else if (!match.comment(nextNode)) {\n ret.push(hardline2);\n }\n }\n }\n break;\n case \"parbreak\":\n ret.push(hardline2, hardline2);\n break;\n default:\n ret.push(printedNode);\n break;\n }\n }\n return ret;\n}\n\n// libs/zip.ts\nfunction zip(array1, array2) {\n const ret = [];\n const len = Math.min(array1.length, array2.length);\n for (let i = 0; i < len; i++) {\n ret.push([array1[i], array2[i]]);\n }\n return ret;\n}\n\n// libs/printer/macro.ts\nfunction printMacro(path, print, options) {\n const node = path.getNode();\n const { renderInfo, previousNode, nextNode, referenceMap } = getNodeInfo(\n node,\n options\n );\n const content = (node.escapeToken != null ? node.escapeToken : ESCAPE) + node.content;\n const args = node.args ? path.map(print, \"args\") : [];\n const rawArgs = [];\n for (const [arg, printedArg] of zip(node.args || [], args)) {\n const renderCache = referenceMap && referenceMap.getRenderCache(arg);\n if (renderInfo.inParMode && renderCache) {\n rawArgs.push(...renderCache);\n } else {\n rawArgs.push(printedArg);\n }\n }\n if (referenceMap) {\n referenceMap.setRenderCache(node, { rawArgs, content });\n }\n if (renderInfo.hangingIndent) {\n return indent2(fill2([content, ...rawArgs]));\n }\n return group2([content, ...rawArgs]);\n}\n\n// libs/printer/argument.ts\nimport { match as match3 } from \"@unified-latex/unified-latex-util-match\";\nimport { trim as trim4 } from \"@unified-latex/unified-latex-util-trim\";\n\n// libs/printer/tikz.ts\nimport {\n printRaw as printRaw3\n} from \"@unified-latex/unified-latex-util-print-raw\";\nimport { match as match2 } from \"@unified-latex/unified-latex-util-match\";\nimport { trim as trim3 } from \"@unified-latex/unified-latex-util-trim\";\nimport {\n parse as parseTikz\n} from \"@unified-latex/unified-latex-ctan/package/tikz\";\n\n// libs/printer/print-argument-pgfkeys.ts\nimport {\n linebreak,\n printRaw as printRaw2\n} from \"@unified-latex/unified-latex-util-print-raw\";\nimport { parsePgfkeys } from \"@unified-latex/unified-latex-util-pgfkeys\";\nfunction printArgumentPgfkeys(nodes, options) {\n const { allowParenGroups = false } = options;\n const parsed = parsePgfkeys(nodes, { allowParenGroups });\n const content = [];\n for (const part of parsed) {\n const isLastItem = part === parsed[parsed.length - 1];\n if (part.itemParts) {\n const parts = part.itemParts.map(\n (node) => printRaw2(node, { asArray: true }).map(\n (token) => token === linebreak ? hardline2 : token\n )\n );\n const row = join2(\"=\", parts);\n content.push(row);\n if (part.trailingComma) {\n content.push(\",\");\n }\n }\n if (part.trailingComment) {\n const leadingContent = part.itemParts ? [\" \"] : [];\n if (part.leadingParbreak) {\n leadingContent.push(hardline2);\n }\n content.push(\n ...leadingContent,\n // We're carefully and manually controlling the newlines,\n // so print the comment directly without any newlines\n \"%\",\n part.trailingComment.content,\n breakParent2\n );\n }\n if (!isLastItem) {\n content.push(line2);\n }\n }\n let leadingComment = [\"\"];\n if (options.leadingComment) {\n if (options.leadingComment.leadingWhitespace) {\n leadingComment.push(\" \");\n }\n leadingComment.push(\"%\" + options.leadingComment.content, breakParent2);\n }\n return group2([\n options.openMark,\n ...leadingComment,\n // If there is no content, we don't want to push an extra `softline`.\n // This matters because the braces group could still be broken by `leadingComment`\n content.length > 0 ? indent2([softline2, ...content]) : \"\",\n softline2,\n options.closeMark\n ]);\n}\n\n// libs/printer/tikz.ts\nfunction printTikzArgument(path, print, options) {\n const node = path.getNode();\n const { renderInfo, previousNode, nextNode, referenceMap } = getNodeInfo(\n node,\n options\n );\n const content = [];\n const nodes = [...node.content];\n trim3(nodes);\n try {\n const tikzAst = parseTikz(nodes);\n if (tikzAst.content.length === 0) {\n content.push(\";\");\n return content;\n }\n const printer2 = new TikzArgumentPrinter(tikzAst, path, print);\n return printer2.toDoc();\n } catch (e) {\n console.warn(\"Encountered error when trying to parse tikz argument\", e);\n }\n content.push(\";\");\n return content;\n}\nfunction printFragment(fragment, path, print) {\n const tmpKey = Symbol();\n const currNode = path.getNode();\n if (!currNode) {\n throw new Error(\n \"tried to print a fragment, but the current node is `null`\"\n );\n }\n currNode[tmpKey] = fragment;\n const ret = print(tmpKey);\n delete currNode[tmpKey];\n return ret;\n}\nfunction printTikzPathSpecNode(node, path, print) {\n switch (node.type) {\n case \"comment\":\n return printFragment(node, path, print);\n case \"unknown\":\n return printFragment(node.content, path, print);\n case \"coordinate\":\n return [printRaw3(node.prefix), \"(\", printRaw3(node.content), \")\"];\n case \"line_to\":\n return node.command;\n case \"square_brace_group\":\n return printOptionalArgs(node.content);\n case \"operation\":\n return node.content.content;\n case \"svg_operation\": {\n const comments = node.comments.map(\n (n) => printTikzPathSpecNode(n, path, print)\n );\n const options = node.options ? printOptionalArgs(node.options) : [];\n const rest = node.options ? [group2(indent2([line2, printRaw3(node.content)]))] : [\" \", printRaw3(node.content)];\n return [...comments, \"svg\", options, ...rest];\n }\n case \"curve_to\": {\n const comments = node.comments.map(\n (n) => printTikzPathSpecNode(n, path, print)\n );\n const printedControls = node.controls.length > 1 ? [\n printTikzPathSpecNode(node.controls[0], path, print),\n \" \",\n \"and\",\n line2,\n printTikzPathSpecNode(node.controls[1], path, print)\n ] : [printTikzPathSpecNode(node.controls[0], path, print)];\n return [\n ...comments,\n \"..\",\n \" \",\n group2(\n indent2([\"controls\", line2, ...printedControls, \" \", \"..\"])\n )\n ];\n }\n case \"animation\": {\n const comments = node.comments.map(\n (n) => printTikzPathSpecNode(n, path, print)\n );\n return [\n ...comments,\n \":\",\n node.attribute,\n \" \",\n \"=\",\n \" \",\n group2(\n indent2([\n printArgumentPgfkeys(node.content, {\n openMark: \"{\",\n closeMark: \"}\"\n })\n ])\n )\n ];\n }\n case \"foreach\": {\n const comments = node.comments.map(\n (n) => printTikzPathSpecNode(n, path, print)\n );\n const variables = [...node.variables];\n trim3(variables);\n const list = node.list.type === \"macro\" ? printFragment(node.list, path, print) : printArgumentPgfkeys(node.list.content, {\n openMark: \"{\",\n closeMark: \"}\",\n allowParenGroups: true\n });\n const doc = [\n ...comments,\n printRaw3(node.start),\n \" \",\n printRaw3(variables)\n ];\n if (node.options) {\n doc.push(\" \", indent2(printOptionalArgs(node.options)));\n }\n doc.push(\" \", \"in\", \" \", group2(indent2(list)));\n const commandType = node.command.type;\n switch (commandType) {\n case \"foreach\":\n doc.push(\n indent2([\n line2,\n printTikzPathSpecNode(node.command, path, print)\n ])\n );\n break;\n case \"macro\":\n doc.push(\n indent2([line2, printFragment(node.command, path, print)])\n );\n break;\n case \"group\": {\n const groupContent = [...node.command.content];\n trim3(groupContent);\n doc.push(\n \" \",\n indent2(\n group2([\n \"{\",\n indent2([\n softline2,\n ...groupContent.map(\n (n) => printFragment(n, path, print)\n )\n ]),\n softline2,\n \"}\"\n ])\n )\n );\n break;\n }\n default:\n const invalidType = commandType;\n console.warn(\n `Unhandled command type when printing \"foreach\": ${invalidType}`\n );\n }\n return indent2(doc);\n }\n }\n console.warn(\n `Encountered unknown type when trying to print tikz PathSpec: \"${node.type}\"`\n );\n return [];\n}\nfunction printOptionalArgs(nodes) {\n return printArgumentPgfkeys(nodes, {\n openMark: \"[\",\n closeMark: \"]\"\n });\n}\nvar _path, _print;\nvar TikzArgumentPrinter = class {\n constructor(spec, path, print) {\n __privateAdd(this, _path, void 0);\n __privateAdd(this, _print, void 0);\n __privateSet(this, _path, path);\n __privateSet(this, _print, print);\n this.nodes = [...spec.content];\n }\n nodeToDoc(node) {\n return printTikzPathSpecNode(node, __privateGet(this, _path), __privateGet(this, _print));\n }\n toDoc() {\n const doc = [];\n const startArg = this.eatOptionalArg();\n if (startArg.optionalArg) {\n doc.push(\n ...startArg.comments.map(\n (c) => printFragment(c, __privateGet(this, _path), __privateGet(this, _print))\n )\n );\n doc.push(printOptionalArgs(startArg.optionalArg.content));\n }\n const innerDoc = [];\n doc.push(group2([indent2(innerDoc), \";\"]));\n let cycle = -1;\n while (this.nodes.length > 0) {\n cycle++;\n const firstSep = cycle === 0 && !startArg.optionalArg ? \" \" : line2;\n const comingUp = this.peek();\n switch (comingUp) {\n case \"short_path\": {\n const [n0, n1, n2] = this.nodes.splice(0, 3);\n innerDoc.push(\n firstSep,\n this.nodeToDoc(n0),\n \" \",\n this.nodeToDoc(n1),\n \" \",\n this.nodeToDoc(n2)\n );\n continue;\n }\n case \"long_path\": {\n const [n0, n1] = this.nodes.splice(0, 2);\n if (n1.type === \"operation\") {\n this.nodes.unshift(n1);\n innerDoc.push(\n firstSep,\n this.nodeToDoc(n0),\n \" \",\n this.eatOperation()\n );\n } else {\n innerDoc.push(\n firstSep,\n this.nodeToDoc(n0),\n \" \",\n this.nodeToDoc(n1)\n );\n }\n continue;\n }\n case \"node\":\n {\n const eatenNode = this.eatNode();\n if (eatenNode) {\n innerDoc.push(line2, ...eatenNode);\n continue;\n }\n console.warn(\n \"Expected to print a tikz `node` PathSpec but couldn't find the text `node`\"\n );\n }\n continue;\n case \"operation\":\n innerDoc.push(firstSep, this.eatOperation());\n continue;\n case \"unknown\": {\n const node = this.nodes.shift();\n innerDoc.push(firstSep, this.nodeToDoc(node));\n continue;\n }\n }\n this.nodes.shift();\n }\n return doc;\n }\n /**\n * Look at the current node and the nodes that follow. Return what\n * \"type\" is recognized.\n */\n peek() {\n const [n0, n1, n2, n3] = [\n this.nodes[0],\n this.nodes[1],\n this.nodes[2],\n this.nodes[3]\n ];\n if ((n0 == null ? void 0 : n0.type) === \"coordinate\" && isPathJoinOperation(n1)) {\n if ((n2 == null ? void 0 : n2.type) === \"coordinate\" && !((n3 == null ? void 0 : n3.type) === \"coordinate\" || isPathJoinOperation(n3))) {\n return \"short_path\";\n }\n return \"long_path\";\n }\n if ((n0 == null ? void 0 : n0.type) === \"operation\") {\n if (n0.content.content === \"node\") {\n return \"node\";\n }\n return \"operation\";\n }\n return \"unknown\";\n }\n /**\n * Eat comments and an optional arg if present. If no optional\n * arg is present, do nothing.\n */\n eatOptionalArg() {\n let i = 0;\n const comments = [];\n let optionalArg = null;\n for (; i < this.nodes.length; i++) {\n const node = this.nodes[i];\n if (node.type === \"square_brace_group\") {\n optionalArg = node;\n i++;\n break;\n }\n if (node.type === \"comment\") {\n comments.push(node);\n continue;\n }\n break;\n }\n if (optionalArg) {\n this.nodes.splice(0, i);\n }\n return { optionalArg, comments };\n }\n /**\n * Eat a `type === \"operation\"` node whose contents is `\"node\"`. I.e.,\n * the type of thing that shows up in `\\path node at (1,1) {foo};`\n */\n eatNode() {\n const firstNode = this.nodes[0];\n if ((firstNode == null ? void 0 : firstNode.type) === \"operation\" && firstNode.content.content === \"node\") {\n this.nodes.shift();\n } else {\n return null;\n }\n const innerDoc = [];\n const commentBlock = [];\n const doc = [commentBlock, \"node\", group2(indent2(innerDoc))];\n let hasNodeArgument = false;\n let shouldBail = false;\n let i = 0;\n const comments = [];\n const options = [];\n const name = [];\n const atLocations = [];\n const animations = [];\n let content = [];\n for (; i < this.nodes.length && !shouldBail; i++) {\n const node = this.nodes[i];\n switch (node.type) {\n case \"animation\":\n animations.push(this.nodeToDoc(node));\n continue;\n case \"comment\": {\n const comment = {\n ...node,\n leadingWhitespace: false\n };\n comments.push(this.nodeToDoc(comment));\n continue;\n }\n case \"square_brace_group\":\n options.push(printOptionalArgs(node.content));\n continue;\n case \"coordinate\":\n name.push(this.nodeToDoc(node));\n continue;\n case \"operation\": {\n if (node.content.content === \"at\") {\n const nextNode = this.nodes[i + 1];\n if (!nextNode || !(nextNode.type === \"coordinate\" || nextNode.type === \"unknown\" && match2.anyMacro(nextNode.content))) {\n shouldBail = true;\n continue;\n }\n atLocations.push([\"at\", \" \", this.nodeToDoc(nextNode)]);\n i++;\n continue;\n }\n shouldBail = true;\n continue;\n }\n case \"unknown\": {\n if (match2.group(node.content)) {\n hasNodeArgument = true;\n content = this.nodeToDoc(node);\n }\n }\n }\n break;\n }\n if (!hasNodeArgument) {\n return innerDoc;\n }\n this.nodes.splice(0, i + 1);\n let isFirstElement = true;\n let isNamed = !(Array.isArray(name) && name.length === 0);\n for (const comment of comments) {\n commentBlock.push(comment, hardline2);\n }\n if (options.length > 0) {\n innerDoc.push(join2(\" \", options));\n isFirstElement = false;\n }\n if (animations.length > 0) {\n innerDoc.push(isFirstElement ? \" \" : line2);\n innerDoc.push(join2(line2, animations));\n isFirstElement = false;\n }\n if (isNamed) {\n innerDoc.push(isFirstElement ? \" \" : line2);\n innerDoc.push(name);\n isFirstElement = false;\n }\n if (atLocations.length > 0) {\n innerDoc.push(isFirstElement || isNamed ? \" \" : line2);\n innerDoc.push(join2(line2, atLocations));\n isFirstElement = false;\n }\n innerDoc.push(line2, content);\n return doc;\n }\n /**\n * Eat a `type === \"operation\"` node, including its optional arguments.\n */\n eatOperation() {\n const node = this.nodes[0];\n if ((node == null ? void 0 : node.type) === \"operation\") {\n this.nodes.shift();\n } else {\n return [];\n }\n const doc = [];\n if ((node == null ? void 0 : node.type) !== \"operation\") {\n throw new Error(\"Expecting `operation` node.\");\n }\n const options = this.eatOptionalArg();\n doc.push(\n ...options.comments.map(\n (c) => printFragment(c, __privateGet(this, _path), __privateGet(this, _print))\n ),\n node.content.content\n );\n if (options.optionalArg) {\n doc.push(indent2(printOptionalArgs(options.optionalArg.content)));\n }\n return doc;\n }\n};\n_path = new WeakMap();\n_print = new WeakMap();\nvar PATH_JOIN_OPERATIONS = /* @__PURE__ */ new Set([\"rectangle\", \"grid\", \"sin\", \"cos\", \"to\"]);\nfunction isPathJoinOperation(node) {\n if (!node) {\n return false;\n }\n switch (node.type) {\n case \"line_to\":\n case \"curve_to\":\n return true;\n case \"operation\":\n return PATH_JOIN_OPERATIONS.has(node.content.content);\n }\n return false;\n}\n\n// libs/printer/argument.ts\nfunction printArgument(path, print, options) {\n const node = path.getNode();\n const { renderInfo, previousNode, nextNode, referenceMap } = getNodeInfo(\n node,\n options\n );\n if (node.openMark === \"\" && node.closeMark === \"\" && node.content.length === 0) {\n return [];\n }\n const parentNode = path.getParentNode();\n const { renderInfo: parentRenderInfo } = getNodeInfo(parentNode, options);\n if (parentRenderInfo.pgfkeysArgs) {\n const leadingComment = node.content.length > 0 && match3.comment(node.content[0]) && node.content[0].sameline ? node.content[0] : null;\n const content2 = leadingComment ? node.content.slice(1) : node.content;\n trim4(content2);\n return printArgumentPgfkeys(content2, {\n openMark: node.openMark,\n closeMark: node.closeMark,\n leadingComment\n });\n }\n if (parentRenderInfo.tikzPathCommand) {\n return printTikzArgument(path, print, options);\n }\n const openMark = node.openMark;\n const closeMark = node.closeMark;\n let content = path.map(print, \"content\");\n content = formatDocArray(node.content, content, options);\n if (match3.comment(node.content[node.content.length - 1])) {\n content.push(hardline2);\n }\n let rawRet = [openMark, fill2(content), closeMark];\n if (renderInfo.inParMode) {\n rawRet = [openMark, ...content, closeMark];\n }\n if (referenceMap) {\n referenceMap.setRenderCache(node, rawRet);\n }\n return rawRet;\n}\n\n// libs/printer/root.ts\nimport { match as match4 } from \"@unified-latex/unified-latex-util-match\";\nfunction hasPreambleCode(nodes) {\n return nodes.some((node) => match4.macro(node, \"documentclass\"));\n}\nfunction printRoot(path, print, options) {\n const node = path.getNode();\n const { renderInfo, previousNode, nextNode, referenceMap } = getNodeInfo(\n node,\n options\n );\n const content = path.map(print, \"content\");\n const rawContent = formatDocArray(node.content, content, options);\n const concatFunction = hasPreambleCode(node.content) ? (x) => x : fill2;\n return concatFunction(rawContent);\n}\n\n// libs/printer/comment.ts\nimport { printRaw as printRaw4 } from \"@unified-latex/unified-latex-util-print-raw\";\nfunction printComment(path, _print2, _options) {\n const node = path.getNode();\n let leadingWhitespace = \"\";\n if (node.leadingWhitespace && node.sameline) {\n leadingWhitespace = \" \";\n }\n const content = [leadingWhitespace, \"%\" + printRaw4(node.content)];\n return content;\n}\n\n// libs/printer/math.ts\nfunction printInlineMath(path, print, options) {\n const node = path.getNode();\n if (node.content.length === 0) {\n return [\"$\", \" \", \"$\"];\n }\n let content = path.map(print, \"content\");\n content = formatDocArray(node.content, content, options);\n content = joinWithSoftline(content);\n if (node.content[node.content.length - 1].type === \"comment\") {\n content.push(hardline2);\n }\n return fill2([\"$\", ...content, \"$\"]);\n}\nfunction printDisplayMath(path, print, options) {\n const node = path.getNode();\n let content = path.map(print, \"content\");\n content = formatDocArray(node.content, content, options);\n content = joinWithSoftline(content);\n const bodyStartToken = [hardline2];\n if (node.content.length === 0 || node.content[0].type === \"comment\" && node.content[0].sameline) {\n bodyStartToken.pop();\n }\n return [\n ESCAPE + \"[\",\n indent2(fill2(bodyStartToken.concat(content))),\n hardline2,\n ESCAPE + \"]\"\n ];\n}\n\n// libs/printer/environment.ts\nimport { printRaw as printRaw5 } from \"@unified-latex/unified-latex-util-print-raw\";\nimport { parseAlignEnvironment } from \"@unified-latex/unified-latex-util-align\";\nimport { trim as trim5 } from \"@unified-latex/unified-latex-util-trim\";\nfunction printVerbatimEnvironment(path, print, options) {\n const node = path.getNode();\n const env = formatEnvSurround(node);\n return [env.start, node.content, env.end];\n}\nfunction printEnvironment(path, print, options) {\n const node = path.getNode();\n const { renderInfo, previousNode, nextNode, referenceMap } = getNodeInfo(\n node,\n options\n );\n const args = node.args ? path.map(print, \"args\") : [];\n const env = formatEnvSurround(node);\n let content = path.map(print, \"content\");\n content = formatDocArray(node.content, content, options);\n if (renderInfo.inMathMode) {\n content = joinWithSoftline(content);\n }\n let bodyStartToken = [hardline2];\n if (node.content.length === 0 || node.content[0].type === \"comment\" && node.content[0].sameline) {\n bodyStartToken.pop();\n }\n return [\n env.start,\n ...args,\n indent2(fill2(bodyStartToken.concat(content))),\n hardline2,\n env.end\n ];\n}\nfunction printAlignedEnvironment(path, print, options) {\n const node = path.getNode();\n const { renderInfo, previousNode, nextNode, referenceMap } = getNodeInfo(\n node,\n options\n );\n const args = node.args ? path.map(print, \"args\") : [];\n const env = formatEnvSurround(node);\n const leadingComment = node.content[0] && node.content[0].type === \"comment\" && node.content[0].sameline ? node.content[0] : null;\n const { rows, rowSeps, trailingComments } = formatAlignedContent(\n leadingComment ? node.content.slice(1) : node.content\n );\n const content = [];\n for (let i = 0; i < rows.length; i++) {\n const row = rows[i];\n const rowSep = rowSeps[i];\n const trailingComment = trailingComments[i];\n content.push(row);\n if (rowSep) {\n content.push(printRaw5(rowSep));\n }\n if (rowSep && trailingComment) {\n content.push(\" \");\n }\n if (trailingComment) {\n content.push([\"%\", printRaw5(trailingComment.content)]);\n }\n if (rowSep || trailingComment) {\n content.push(hardline2);\n }\n }\n if (content[content.length - 1] === hardline2) {\n content.pop();\n }\n if (leadingComment) {\n content.unshift(\n leadingComment.leadingWhitespace ? \" \" : \"\",\n \"%\" + printRaw5(leadingComment.content),\n hardline2\n );\n return [env.start, ...args, indent2(content), hardline2, env.end];\n }\n return [\n env.start,\n ...args,\n indent2([hardline2, ...content]),\n hardline2,\n env.end\n ];\n}\nfunction formatAlignedContent(nodes) {\n function getSpace(len = 1) {\n return \" \".repeat(len);\n }\n const rows = parseAlignEnvironment(nodes);\n const numCols = Math.max(...rows.map((r) => r.cells.length));\n const rowSeps = rows.map(({ rowSep }) => printRaw5(rowSep || []));\n const trailingComments = rows.map(({ trailingComment }) => trailingComment);\n const renderedRows = rows.map(({ cells, colSeps }) => ({\n cells: cells.map((nodes2) => {\n trim5(nodes2);\n return printRaw5(nodes2);\n }),\n seps: colSeps.map((nodes2) => printRaw5(nodes2))\n }));\n const colWidths = [];\n for (let i = 0; i < numCols; i++) {\n colWidths.push(\n Math.max(\n ...renderedRows.map(\n ({ cells, seps }) => ((cells[i] || \"\") + (seps[i] || \"\")).length\n )\n )\n );\n }\n const joinedRows = renderedRows.map(({ cells, seps }) => {\n if (cells.length === 1 && cells[0] === \"\") {\n return \"\";\n }\n let ret = \"\";\n for (let i = 0; i < cells.length; i++) {\n const width = colWidths[i] - (seps[i] || \"\").length;\n ret += (i === 0 ? \"\" : \" \") + cells[i] + getSpace(width - cells[i].length + 1) + (seps[i] || \"\");\n }\n return ret;\n });\n return { rows: joinedRows, rowSeps, trailingComments };\n}\n\n// libs/printer/printer.ts\nimport {\n linebreak as linebreak2,\n printRaw as printRaw6\n} from \"@unified-latex/unified-latex-util-print-raw\";\n\n// libs/reference-map.ts\nimport { visit } from \"@unified-latex/unified-latex-util-visit\";\nvar ReferenceMap = class {\n constructor(ast) {\n this.ast = ast;\n this.map = /* @__PURE__ */ new Map();\n visit(\n this.ast,\n (nodeList) => {\n for (let i = 0; i < nodeList.length; i++) {\n this.map.set(nodeList[i], {\n previous: nodeList[i - 1],\n next: nodeList[i + 1]\n });\n }\n },\n { includeArrays: true, test: Array.isArray }\n );\n }\n /**\n * Associate render-specific data with this node. This data\n * will be overwritten if `setRenderCache` is called twice.\n *\n * @param {Ast.Ast} node\n * @param {*} data\n * @memberof ReferenceMap\n */\n setRenderCache(node, data) {\n const currData = this.map.get(node) || {};\n this.map.set(node, { ...currData, renderCache: data });\n }\n /**\n * Retrieve data associated with `node` via `setRenderCache`\n *\n * @param {Ast.Ast} node\n * @returns {(object | undefined)}\n * @memberof ReferenceMap\n */\n getRenderCache(node) {\n var _a;\n return (_a = this.map.get(node)) == null ? void 0 : _a.renderCache;\n }\n getPreviousNode(node) {\n return (this.map.get(node) || {}).previous;\n }\n getNextNode(node) {\n return (this.map.get(node) || {}).next;\n }\n};\n\n// libs/printer/printer.ts\nfunction printLatexAst(path, options, print) {\n const node = path.getValue();\n const { renderInfo } = getNodeInfo(node, options);\n if (node == null) {\n return node;\n }\n if (typeof node === \"string\") {\n return node;\n }\n switch (node.type) {\n case \"root\":\n if (options.referenceMap) {\n console.warn(\n \"Processing root node, but ReferenceMap already exists. Are there multiple nodes of type 'root'?\"\n );\n }\n options.referenceMap = new ReferenceMap(node);\n return printRoot(path, print, options);\n case \"argument\":\n return printArgument(path, print, options);\n case \"comment\":\n return printComment(path, print, options);\n case \"environment\":\n case \"mathenv\":\n if (renderInfo.alignContent) {\n return printAlignedEnvironment(path, print, options);\n }\n return printEnvironment(path, print, options);\n case \"displaymath\":\n return printDisplayMath(path, print, options);\n case \"group\":\n const content = printRaw6(node.content, {\n asArray: true\n }).map((token) => token === linebreak2 ? hardline2 : token);\n return [\"{\", ...content, \"}\"];\n case \"inlinemath\":\n return printInlineMath(path, print, options);\n case \"macro\":\n return printMacro(path, print, options);\n case \"parbreak\":\n return [hardline2, hardline2];\n case \"string\":\n return node.content;\n case \"verb\":\n return [\n ESCAPE,\n node.env,\n node.escape,\n printRaw6(node.content),\n node.escape\n ];\n case \"verbatim\":\n return printVerbatimEnvironment(path, print, options);\n case \"whitespace\":\n return line2;\n default:\n console.warn(\"Printing unknown type\", node);\n return printRaw6(node);\n }\n}\n\n// libs/prettier-plugin-latex.ts\nimport { parse } from \"@unified-latex/unified-latex-util-parse\";\nvar languages = [\n {\n name: \"latex\",\n extensions: [\".tex\"],\n parsers: [\"latex-parser\"]\n }\n];\nvar parsers = {\n \"latex-parser\": {\n parse,\n astFormat: \"latex-ast\",\n locStart: (node) => node.position ? node.position.start.offset : 0,\n locEnd: (node) => node.position ? node.position.end.offset : 1\n }\n};\nvar printers = {\n \"latex-ast\": {\n print: printLatexAst\n }\n};\nvar prettierPluginLatex = { languages, parsers, printers };\nexport {\n prettierPluginLatex,\n printLatexAst,\n printLatexAst as printer\n};\n//# sourceMappingURL=index.js.map\n","import { prettierPluginLatex } from \"@unified-latex/unified-latex-prettier\";\n\nexport const options = {};\n\nexport const defaultOptions = {\n useTabs: true,\n};\n\nexport const languages = prettierPluginLatex.languages;\nexport const parsers = prettierPluginLatex.parsers;\nexport const printers = prettierPluginLatex.printers;\n"],"names":["ESCAPE","options","macros","index","index2","trim","match2","s","line","options2","at","parse","PegParser","exports","module","append","require$$0","create","checkPrefix","recursePrefix","pushInOrder","recurseRandomWord","permutations","permute","reducer","input","require$$1","require$$2","require$$3","require$$4","require$$5","require$$6","require$$7","parseArgspec","arg2","macroInfo","createMatchers","isBuffer","isArray","isPlainObject","setProperty","getProperty","extend","point","position","join","path","assertPath","prop","dirname","basename","extname","bufferLike","value","isPlainObj","file","isArrayish","swizzle","simpleSwizzleModule","arg","colorStringModule","match","convert","conversions","color","colorString","models","route","keys","trim2","parseArgspec2","gobbleSingleArgument2","match3","arg3","parseArgspec3","arg4","trim3","gobbleSingleArgument3","match6","Color","visit2","slice","environments","printRaw2","unified2","__defProp","parseTikz","printRaw3","trim4","match4","printRaw4","printRaw5","trim5","printRaw6","linebreak2","languages","parsers","printers","prettierPluginLatex"],"mappings":"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","x_google_ignoreList":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49]} \ No newline at end of file diff --git a/node_modules/prettier-plugin-latex/dist/prettier-plugin-latex.d.ts b/node_modules/prettier-plugin-latex/dist/prettier-plugin-latex.d.ts new file mode 100644 index 0000000..e94ca4f --- /dev/null +++ b/node_modules/prettier-plugin-latex/dist/prettier-plugin-latex.d.ts @@ -0,0 +1,11 @@ +export declare const options: {}; +export declare const defaultOptions: { + useTabs: boolean; +}; +export declare const languages: import("prettier").SupportLanguage[] | undefined; +export declare const parsers: { + [parserName: string]: import("prettier").Parser; +} | undefined; +export declare const printers: { + [astFormat: string]: import("prettier").Printer; +} | undefined; diff --git a/node_modules/prettier-plugin-latex/dist/prettier-plugin-latex.js b/node_modules/prettier-plugin-latex/dist/prettier-plugin-latex.js new file mode 100644 index 0000000..7fbfeff --- /dev/null +++ b/node_modules/prettier-plugin-latex/dist/prettier-plugin-latex.js @@ -0,0 +1,9 @@ +"use strict"; +Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" }); +const prettierPluginLatex = require("./prettier-plugin-latex-f9d12326.js"); +exports.defaultOptions = prettierPluginLatex.defaultOptions; +exports.languages = prettierPluginLatex.languages; +exports.options = prettierPluginLatex.options; +exports.parsers = prettierPluginLatex.parsers; +exports.printers = prettierPluginLatex.printers; +//# sourceMappingURL=prettier-plugin-latex.js.map diff --git a/node_modules/prettier-plugin-latex/dist/prettier-plugin-latex.js.map b/node_modules/prettier-plugin-latex/dist/prettier-plugin-latex.js.map new file mode 100644 index 0000000..535f4b0 --- /dev/null +++ b/node_modules/prettier-plugin-latex/dist/prettier-plugin-latex.js.map @@ -0,0 +1 @@ +{"version":3,"file":"prettier-plugin-latex.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;"} \ No newline at end of file diff --git a/node_modules/prettier-plugin-latex/dist/prettier-plugin-latex.mjs b/node_modules/prettier-plugin-latex/dist/prettier-plugin-latex.mjs new file mode 100644 index 0000000..500769a --- /dev/null +++ b/node_modules/prettier-plugin-latex/dist/prettier-plugin-latex.mjs @@ -0,0 +1,9 @@ +import { d, l, o, a, b } from "./prettier-plugin-latex-9db821d0.mjs"; +export { + d as defaultOptions, + l as languages, + o as options, + a as parsers, + b as printers +}; +//# sourceMappingURL=prettier-plugin-latex.mjs.map diff --git a/node_modules/prettier-plugin-latex/dist/standalone.d.ts b/node_modules/prettier-plugin-latex/dist/standalone.d.ts new file mode 100644 index 0000000..3233356 --- /dev/null +++ b/node_modules/prettier-plugin-latex/dist/standalone.d.ts @@ -0,0 +1,12 @@ +import * as Prettier from "prettier/standalone"; +/** + * Format `source` LaTeX code using Prettier to format/render + * the code. + * + * @export + * @param [source=""] - code to be formatted + * @param [options={}] - Prettier options object (you can set `printWidth` here) + * @returns formatted code + */ +export declare function printPrettier(source?: string, options?: {}): Promise; +export { Prettier }; diff --git a/node_modules/prettier-plugin-latex/dist/standalone.js b/node_modules/prettier-plugin-latex/dist/standalone.js new file mode 100644 index 0000000..e94c88a --- /dev/null +++ b/node_modules/prettier-plugin-latex/dist/standalone.js @@ -0,0 +1,2459 @@ +"use strict"; +var __defProp = Object.defineProperty; +var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value; +var __publicField = (obj, key, value) => { + __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value); + return value; +}; +Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" }); +const prettierPluginLatex = require("./prettier-plugin-latex-f9d12326.js"); +var au = Object.create; +var $e = Object.defineProperty; +var Du = Object.getOwnPropertyDescriptor; +var cu = Object.getOwnPropertyNames; +var lu = Object.getPrototypeOf, fu = Object.prototype.hasOwnProperty; +var pu = (t, e) => () => (t && (e = t(t = 0)), e); +var Ue = (t, e) => () => (e || t((e = { exports: {} }).exports, e), e.exports), Me = (t, e) => { + for (var r in e) + $e(t, r, { get: e[r], enumerable: true }); +}, nr = (t, e, r, n) => { + if (e && typeof e == "object" || typeof e == "function") + for (let o of cu(e)) + !fu.call(t, o) && o !== r && $e(t, o, { get: () => e[o], enumerable: !(n = Du(e, o)) || n.enumerable }); + return t; +}; +var Ce = (t, e, r) => (r = t != null ? au(lu(t)) : {}, nr(e || !t || !t.__esModule ? $e(r, "default", { value: t, enumerable: true }) : r, t)), du = (t) => nr($e({}, "__esModule", { value: true }), t); +var Fu = (t, e, r) => { + if (!e.has(t)) + throw TypeError("Cannot " + r); +}; +var Ct = (t, e, r) => { + if (e.has(t)) + throw TypeError("Cannot add the same private member more than once"); + e instanceof WeakSet ? e.add(t) : e.set(t, r); +}; +var ce = (t, e, r) => (Fu(t, e, "access private method"), r); +var or = Ue((gt) => { + Object.defineProperty(gt, "__esModule", { value: true }); + gt.default = ur; + function ur() { + } + ur.prototype = { diff: function(e, r) { + var n = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {}, o = n.callback; + typeof n == "function" && (o = n, n = {}), this.options = n; + var u = this; + function i(p) { + return o ? (setTimeout(function() { + o(void 0, p); + }, 0), true) : p; + } + e = this.castInput(e), r = this.castInput(r), e = this.removeEmpty(this.tokenize(e)), r = this.removeEmpty(this.tokenize(r)); + var s = r.length, a = e.length, D = 1, c = s + a; + n.maxEditLength && (c = Math.min(c, n.maxEditLength)); + var F = [{ newPos: -1, components: [] }], f = this.extractCommon(F[0], r, e, 0); + if (F[0].newPos + 1 >= s && f + 1 >= a) + return i([{ value: this.join(r), count: r.length }]); + function d() { + for (var p = -1 * D; p <= D; p += 2) { + var m = void 0, E = F[p - 1], h = F[p + 1], g = (h ? h.newPos : 0) - p; + E && (F[p - 1] = void 0); + var C = E && E.newPos + 1 < s, _ = h && 0 <= g && g < a; + if (!C && !_) { + F[p] = void 0; + continue; + } + if (!C || _ && E.newPos < h.newPos ? (m = hu(h), u.pushComponent(m.components, void 0, true)) : (m = E, m.newPos++, u.pushComponent(m.components, true, void 0)), g = u.extractCommon(m, r, e, p), m.newPos + 1 >= s && g + 1 >= a) + return i(Eu(u, m.components, r, e, u.useLongestToken)); + F[p] = m; + } + D++; + } + if (o) + (function p() { + setTimeout(function() { + if (D > c) + return o(); + d() || p(); + }, 0); + })(); + else + for (; D <= c; ) { + var l = d(); + if (l) + return l; + } + }, pushComponent: function(e, r, n) { + var o = e[e.length - 1]; + o && o.added === r && o.removed === n ? e[e.length - 1] = { count: o.count + 1, added: r, removed: n } : e.push({ count: 1, added: r, removed: n }); + }, extractCommon: function(e, r, n, o) { + for (var u = r.length, i = n.length, s = e.newPos, a = s - o, D = 0; s + 1 < u && a + 1 < i && this.equals(r[s + 1], n[a + 1]); ) + s++, a++, D++; + return D && e.components.push({ count: D }), e.newPos = s, a; + }, equals: function(e, r) { + return this.options.comparator ? this.options.comparator(e, r) : e === r || this.options.ignoreCase && e.toLowerCase() === r.toLowerCase(); + }, removeEmpty: function(e) { + for (var r = [], n = 0; n < e.length; n++) + e[n] && r.push(e[n]); + return r; + }, castInput: function(e) { + return e; + }, tokenize: function(e) { + return e.split(""); + }, join: function(e) { + return e.join(""); + } }; + function Eu(t, e, r, n, o) { + for (var u = 0, i = e.length, s = 0, a = 0; u < i; u++) { + var D = e[u]; + if (D.removed) { + if (D.value = t.join(n.slice(a, a + D.count)), a += D.count, u && e[u - 1].added) { + var F = e[u - 1]; + e[u - 1] = e[u], e[u] = F; + } + } else { + if (!D.added && o) { + var c = r.slice(s, s + D.count); + c = c.map(function(d, l) { + var p = n[a + l]; + return p.length > d.length ? p : d; + }), D.value = t.join(c); + } else + D.value = t.join(r.slice(s, s + D.count)); + s += D.count, D.added || (a += D.count); + } + } + var f = e[i - 1]; + return i > 1 && typeof f.value == "string" && (f.added || f.removed) && t.equals("", f.value) && (e[i - 2].value += f.value, e.pop()), e; + } + function hu(t) { + return { newPos: t.newPos, components: t.components.slice(0) }; + } +}); +var ir = Ue((ye) => { + Object.defineProperty(ye, "__esModule", { value: true }); + ye.diffArrays = yu; + ye.arrayDiff = void 0; + var Cu = gu(or()); + function gu(t) { + return t && t.__esModule ? t : { default: t }; + } + var ge = new Cu.default(); + ye.arrayDiff = ge; + ge.tokenize = function(t) { + return t.slice(); + }; + ge.join = ge.removeEmpty = function(t) { + return t; + }; + function yu(t, e, r) { + return ge.diff(t, e, r); + } +}); +var Pe = Ue((ss, Rr) => { + var Ir = new Proxy(String, { get: () => Ir }); + Rr.exports = Ir; +}); +var ln = {}; +Me(ln, { default: () => to, shouldHighlight: () => eo }); +var eo, to, fn = pu(() => { + eo = () => false, to = String; +}); +var hn = Ue((pt) => { + Object.defineProperty(pt, "__esModule", { value: true }); + pt.codeFrameColumns = En; + pt.default = io; + var pn = (fn(), du(ln)), ro = Pe(), dn = ro, jt; + function no(t) { + if (t) { + return jt != null || (jt = new dn.constructor({ enabled: true, level: 1 })), jt; + } + return dn; + } + var Fn = false; + function uo(t) { + return { gutter: t.grey, marker: t.red.bold, message: t.red.bold }; + } + var mn = /\r\n|[\n\r\u2028\u2029]/; + function oo(t, e, r) { + let n = Object.assign({ column: 0, line: -1 }, t.start), o = Object.assign({}, n, t.end), { linesAbove: u = 2, linesBelow: i = 3 } = r || {}, s = n.line, a = n.column, D = o.line, c = o.column, F = Math.max(s - (u + 1), 0), f = Math.min(e.length, D + i); + s === -1 && (F = 0), D === -1 && (f = e.length); + let d = D - s, l = {}; + if (d) + for (let p = 0; p <= d; p++) { + let m = p + s; + if (!a) + l[m] = true; + else if (p === 0) { + let E = e[m - 1].length; + l[m] = [a, E - a + 1]; + } else if (p === d) + l[m] = [0, c]; + else { + let E = e[m - p].length; + l[m] = [0, E]; + } + } + else + a === c ? a ? l[s] = [a, 0] : l[s] = true : l[s] = [a, c - a]; + return { start: F, end: f, markerLines: l }; + } + function En(t, e, r = {}) { + let n = (r.highlightCode || r.forceColor) && (0, pn.shouldHighlight)(r), o = no(r.forceColor), u = uo(o), i = (p, m) => n ? p(m) : m, s = t.split(mn), { start: a, end: D, markerLines: c } = oo(e, s, r), F = e.start && typeof e.start.column == "number", f = String(D).length, l = (n ? (0, pn.default)(t, r) : t).split(mn, D).slice(a, D).map((p, m) => { + let E = a + 1 + m, g = ` ${` ${E}`.slice(-f)} |`, C = c[E], _ = !c[E + 1]; + if (C) { + let Z = ""; + if (Array.isArray(C)) { + let $ = p.slice(0, Math.max(C[0] - 1, 0)).replace(/[^\t]/g, " "), Q = C[1] || 1; + Z = [` + `, i(u.gutter, g.replace(/\d/g, " ")), " ", $, i(u.marker, "^").repeat(Q)].join(""), _ && r.message && (Z += " " + i(u.message, r.message)); + } + return [i(u.marker, ">"), i(u.gutter, g), p.length > 0 ? ` ${p}` : "", Z].join(""); + } else + return ` ${i(u.gutter, g)}${p.length > 0 ? ` ${p}` : ""}`; + }).join(` +`); + return r.message && !F && (l = `${" ".repeat(f + 1)}${r.message} +${l}`), n ? o.reset(l) : l; + } + function io(t, e, r, n = {}) { + if (!Fn) { + Fn = true; + let u = "Passing lineNumber and colNumber is deprecated to @babel/code-frame. Please use `codeFrameColumns`."; + { + let i = new Error(u); + i.name = "DeprecationWarning", console.warn(new Error(u)); + } + } + return r = Math.max(r, 0), En(t, { start: { column: r, line: e } }, n); + } +}); +var tr = {}; +Me(tr, { __debug: () => Qo, check: () => Xo, doc: () => er, format: () => su, formatWithCursor: () => iu, getSupportInfo: () => Zo, util: () => Qt, version: () => ou }); +var mu = (t, e, r, n) => { + if (!(t && e == null)) + return e.replaceAll ? e.replaceAll(r, n) : r.global ? e.replace(r, n) : e.split(r).join(n); +}, ee = mu; +var Wn = Ce(ir(), 1); +var U = "string", j = "array", M = "cursor", T = "indent", S = "align", v = "trim", A = "group", k = "fill", B = "if-break", P = "indent-if-break", L = "line-suffix", I = "line-suffix-boundary", x = "line", O = "label", b = "break-parent", We = /* @__PURE__ */ new Set([M, T, S, v, A, k, B, P, L, I, x, O, b]); +function xu(t) { + if (typeof t == "string") + return U; + if (Array.isArray(t)) + return j; + if (!t) + return; + let { type: e } = t; + if (We.has(e)) + return e; +} +var W = xu; +var _u = (t) => new Intl.ListFormat("en-US", { type: "disjunction" }).format(t); +function Au(t) { + let e = t === null ? "null" : typeof t; + if (e !== "string" && e !== "object") + return `Unexpected doc '${e}', +Expected it to be 'string' or 'object'.`; + if (W(t)) + throw new Error("doc is valid."); + let r = Object.prototype.toString.call(t); + if (r !== "[object Object]") + return `Unexpected doc '${r}'.`; + let n = _u([...We].map((o) => `'${o}'`)); + return `Unexpected doc.type '${t.type}'. +Expected it to be ${n}.`; +} +var yt = class extends Error { + constructor(e) { + super(Au(e)); + __publicField(this, "name", "InvalidDocError"); + this.doc = e; + } +}, q = yt; +var sr = {}; +function Bu(t, e, r, n) { + let o = [t]; + for (; o.length > 0; ) { + let u = o.pop(); + if (u === sr) { + r(o.pop()); + continue; + } + r && o.push(u, sr); + let i = W(u); + if (!i) + throw new q(u); + if ((e == null ? void 0 : e(u)) !== false) + switch (i) { + case j: + case k: { + let s = i === j ? u : u.parts; + for (let a = s.length, D = a - 1; D >= 0; --D) + o.push(s[D]); + break; + } + case B: + o.push(u.flatContents, u.breakContents); + break; + case A: + if (n && u.expandedStates) + for (let s = u.expandedStates.length, a = s - 1; a >= 0; --a) + o.push(u.expandedStates[a]); + else + o.push(u.contents); + break; + case S: + case T: + case P: + case O: + case L: + o.push(u.contents); + break; + case U: + case M: + case v: + case I: + case x: + case b: + break; + default: + throw new q(u); + } + } +} +var xe = Bu; +var ar = () => { +}, ze = ar; +function ie(t) { + return { type: T, contents: t }; +} +function oe(t, e) { + return { type: S, contents: e, n: t }; +} +function xt(t, e = {}) { + return ze(e.expandedStates), { type: A, id: e.id, contents: t, break: !!e.shouldBreak, expandedStates: e.expandedStates }; +} +function Dr(t) { + return oe(Number.NEGATIVE_INFINITY, t); +} +function cr(t) { + return oe({ type: "root" }, t); +} +function lr(t) { + return oe(-1, t); +} +function fr(t, e) { + return xt(t[0], { ...e, expandedStates: t }); +} +function Ge(t) { + return { type: k, parts: t }; +} +function pr(t, e = "", r = {}) { + return { type: B, breakContents: t, flatContents: e, groupId: r.groupId }; +} +function dr(t, e) { + return { type: P, contents: t, groupId: e.groupId, negate: e.negate }; +} +function _e(t) { + return { type: L, contents: t }; +} +var Fr = { type: I }, le = { type: b }, mr = { type: v }, Ae = { type: x, hard: true }, _t = { type: x, hard: true, literal: true }, Ke = { type: x }, Er = { type: x, soft: true }, G = [Ae, le], He = [_t, le], Be = { type: M }; +function ke(t, e) { + let r = []; + for (let n = 0; n < e.length; n++) + n !== 0 && r.push(t), r.push(e[n]); + return r; +} +function qe(t, e, r) { + let n = t; + if (e > 0) { + for (let o = 0; o < Math.floor(e / r); ++o) + n = ie(n); + n = oe(e % r, n), n = oe(Number.NEGATIVE_INFINITY, n); + } + return n; +} +function hr(t, e) { + return t ? { type: O, label: t, contents: e } : e; +} +var ku = (t, e, r) => { + if (!(t && e == null)) + return Array.isArray(e) || typeof e == "string" ? e[r < 0 ? e.length + r : r] : e.at(r); +}, y = ku; +function Cr(t) { + let e = t.indexOf("\r"); + return e >= 0 ? t.charAt(e + 1) === ` +` ? "crlf" : "cr" : "lf"; +} +function be(t) { + switch (t) { + case "cr": + return "\r"; + case "crlf": + return `\r +`; + default: + return ` +`; + } +} +function At(t, e) { + let r; + switch (e) { + case ` +`: + r = /\n/g; + break; + case "\r": + r = /\r/g; + break; + case `\r +`: + r = /\r\n/g; + break; + default: + throw new Error(`Unexpected "eol" ${JSON.stringify(e)}.`); + } + let n = t.match(r); + return n ? n.length : 0; +} +function gr(t) { + return ee(false, t, /\r\n?/g, ` +`); +} +var yr = () => /[#*0-9]\uFE0F?\u20E3|[\xA9\xAE\u203C\u2049\u2122\u2139\u2194-\u2199\u21A9\u21AA\u231A\u231B\u2328\u23CF\u23ED-\u23EF\u23F1\u23F2\u23F8-\u23FA\u24C2\u25AA\u25AB\u25B6\u25C0\u25FB\u25FC\u25FE\u2600-\u2604\u260E\u2611\u2614\u2615\u2618\u2620\u2622\u2623\u2626\u262A\u262E\u262F\u2638-\u263A\u2640\u2642\u2648-\u2653\u265F\u2660\u2663\u2665\u2666\u2668\u267B\u267E\u267F\u2692\u2694-\u2697\u2699\u269B\u269C\u26A0\u26A7\u26AA\u26B0\u26B1\u26BD\u26BE\u26C4\u26C8\u26CF\u26D1\u26D3\u26E9\u26F0-\u26F5\u26F7\u26F8\u26FA\u2702\u2708\u2709\u270F\u2712\u2714\u2716\u271D\u2721\u2733\u2734\u2744\u2747\u2757\u2763\u27A1\u2934\u2935\u2B05-\u2B07\u2B1B\u2B1C\u2B55\u3030\u303D\u3297\u3299]\uFE0F?|[\u261D\u270C\u270D](?:\uFE0F|\uD83C[\uDFFB-\uDFFF])?|[\u270A\u270B](?:\uD83C[\uDFFB-\uDFFF])?|[\u23E9-\u23EC\u23F0\u23F3\u25FD\u2693\u26A1\u26AB\u26C5\u26CE\u26D4\u26EA\u26FD\u2705\u2728\u274C\u274E\u2753-\u2755\u2795-\u2797\u27B0\u27BF\u2B50]|\u26F9(?:\uFE0F|\uD83C[\uDFFB-\uDFFF])?(?:\u200D[\u2640\u2642]\uFE0F?)?|\u2764\uFE0F?(?:\u200D(?:\uD83D\uDD25|\uD83E\uDE79))?|\uD83C(?:[\uDC04\uDD70\uDD71\uDD7E\uDD7F\uDE02\uDE37\uDF21\uDF24-\uDF2C\uDF36\uDF7D\uDF96\uDF97\uDF99-\uDF9B\uDF9E\uDF9F\uDFCD\uDFCE\uDFD4-\uDFDF\uDFF5\uDFF7]\uFE0F?|[\uDF85\uDFC2\uDFC7](?:\uD83C[\uDFFB-\uDFFF])?|[\uDFC3\uDFC4\uDFCA](?:\uD83C[\uDFFB-\uDFFF])?(?:\u200D[\u2640\u2642]\uFE0F?)?|[\uDFCB\uDFCC](?:\uFE0F|\uD83C[\uDFFB-\uDFFF])?(?:\u200D[\u2640\u2642]\uFE0F?)?|[\uDCCF\uDD8E\uDD91-\uDD9A\uDE01\uDE1A\uDE2F\uDE32-\uDE36\uDE38-\uDE3A\uDE50\uDE51\uDF00-\uDF20\uDF2D-\uDF35\uDF37-\uDF7C\uDF7E-\uDF84\uDF86-\uDF93\uDFA0-\uDFC1\uDFC5\uDFC6\uDFC8\uDFC9\uDFCF-\uDFD3\uDFE0-\uDFF0\uDFF8-\uDFFF]|\uDDE6\uD83C[\uDDE8-\uDDEC\uDDEE\uDDF1\uDDF2\uDDF4\uDDF6-\uDDFA\uDDFC\uDDFD\uDDFF]|\uDDE7\uD83C[\uDDE6\uDDE7\uDDE9-\uDDEF\uDDF1-\uDDF4\uDDF6-\uDDF9\uDDFB\uDDFC\uDDFE\uDDFF]|\uDDE8\uD83C[\uDDE6\uDDE8\uDDE9\uDDEB-\uDDEE\uDDF0-\uDDF5\uDDF7\uDDFA-\uDDFF]|\uDDE9\uD83C[\uDDEA\uDDEC\uDDEF\uDDF0\uDDF2\uDDF4\uDDFF]|\uDDEA\uD83C[\uDDE6\uDDE8\uDDEA\uDDEC\uDDED\uDDF7-\uDDFA]|\uDDEB\uD83C[\uDDEE-\uDDF0\uDDF2\uDDF4\uDDF7]|\uDDEC\uD83C[\uDDE6\uDDE7\uDDE9-\uDDEE\uDDF1-\uDDF3\uDDF5-\uDDFA\uDDFC\uDDFE]|\uDDED\uD83C[\uDDF0\uDDF2\uDDF3\uDDF7\uDDF9\uDDFA]|\uDDEE\uD83C[\uDDE8-\uDDEA\uDDF1-\uDDF4\uDDF6-\uDDF9]|\uDDEF\uD83C[\uDDEA\uDDF2\uDDF4\uDDF5]|\uDDF0\uD83C[\uDDEA\uDDEC-\uDDEE\uDDF2\uDDF3\uDDF5\uDDF7\uDDFC\uDDFE\uDDFF]|\uDDF1\uD83C[\uDDE6-\uDDE8\uDDEE\uDDF0\uDDF7-\uDDFB\uDDFE]|\uDDF2\uD83C[\uDDE6\uDDE8-\uDDED\uDDF0-\uDDFF]|\uDDF3\uD83C[\uDDE6\uDDE8\uDDEA-\uDDEC\uDDEE\uDDF1\uDDF4\uDDF5\uDDF7\uDDFA\uDDFF]|\uDDF4\uD83C\uDDF2|\uDDF5\uD83C[\uDDE6\uDDEA-\uDDED\uDDF0-\uDDF3\uDDF7-\uDDF9\uDDFC\uDDFE]|\uDDF6\uD83C\uDDE6|\uDDF7\uD83C[\uDDEA\uDDF4\uDDF8\uDDFA\uDDFC]|\uDDF8\uD83C[\uDDE6-\uDDEA\uDDEC-\uDDF4\uDDF7-\uDDF9\uDDFB\uDDFD-\uDDFF]|\uDDF9\uD83C[\uDDE6\uDDE8\uDDE9\uDDEB-\uDDED\uDDEF-\uDDF4\uDDF7\uDDF9\uDDFB\uDDFC\uDDFF]|\uDDFA\uD83C[\uDDE6\uDDEC\uDDF2\uDDF3\uDDF8\uDDFE\uDDFF]|\uDDFB\uD83C[\uDDE6\uDDE8\uDDEA\uDDEC\uDDEE\uDDF3\uDDFA]|\uDDFC\uD83C[\uDDEB\uDDF8]|\uDDFD\uD83C\uDDF0|\uDDFE\uD83C[\uDDEA\uDDF9]|\uDDFF\uD83C[\uDDE6\uDDF2\uDDFC]|\uDFF3\uFE0F?(?:\u200D(?:\u26A7\uFE0F?|\uD83C\uDF08))?|\uDFF4(?:\u200D\u2620\uFE0F?|\uDB40\uDC67\uDB40\uDC62\uDB40(?:\uDC65\uDB40\uDC6E\uDB40\uDC67|\uDC73\uDB40\uDC63\uDB40\uDC74|\uDC77\uDB40\uDC6C\uDB40\uDC73)\uDB40\uDC7F)?)|\uD83D(?:[\uDC08\uDC26](?:\u200D\u2B1B)?|[\uDC3F\uDCFD\uDD49\uDD4A\uDD6F\uDD70\uDD73\uDD76-\uDD79\uDD87\uDD8A-\uDD8D\uDDA5\uDDA8\uDDB1\uDDB2\uDDBC\uDDC2-\uDDC4\uDDD1-\uDDD3\uDDDC-\uDDDE\uDDE1\uDDE3\uDDE8\uDDEF\uDDF3\uDDFA\uDECB\uDECD-\uDECF\uDEE0-\uDEE5\uDEE9\uDEF0\uDEF3]\uFE0F?|[\uDC42\uDC43\uDC46-\uDC50\uDC66\uDC67\uDC6B-\uDC6D\uDC72\uDC74-\uDC76\uDC78\uDC7C\uDC83\uDC85\uDC8F\uDC91\uDCAA\uDD7A\uDD95\uDD96\uDE4C\uDE4F\uDEC0\uDECC](?:\uD83C[\uDFFB-\uDFFF])?|[\uDC6E\uDC70\uDC71\uDC73\uDC77\uDC81\uDC82\uDC86\uDC87\uDE45-\uDE47\uDE4B\uDE4D\uDE4E\uDEA3\uDEB4-\uDEB6](?:\uD83C[\uDFFB-\uDFFF])?(?:\u200D[\u2640\u2642]\uFE0F?)?|[\uDD74\uDD90](?:\uFE0F|\uD83C[\uDFFB-\uDFFF])?|[\uDC00-\uDC07\uDC09-\uDC14\uDC16-\uDC25\uDC27-\uDC3A\uDC3C-\uDC3E\uDC40\uDC44\uDC45\uDC51-\uDC65\uDC6A\uDC79-\uDC7B\uDC7D-\uDC80\uDC84\uDC88-\uDC8E\uDC90\uDC92-\uDCA9\uDCAB-\uDCFC\uDCFF-\uDD3D\uDD4B-\uDD4E\uDD50-\uDD67\uDDA4\uDDFB-\uDE2D\uDE2F-\uDE34\uDE37-\uDE44\uDE48-\uDE4A\uDE80-\uDEA2\uDEA4-\uDEB3\uDEB7-\uDEBF\uDEC1-\uDEC5\uDED0-\uDED2\uDED5-\uDED7\uDEDC-\uDEDF\uDEEB\uDEEC\uDEF4-\uDEFC\uDFE0-\uDFEB\uDFF0]|\uDC15(?:\u200D\uD83E\uDDBA)?|\uDC3B(?:\u200D\u2744\uFE0F?)?|\uDC41\uFE0F?(?:\u200D\uD83D\uDDE8\uFE0F?)?|\uDC68(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:\uDC8B\u200D\uD83D)?\uDC68|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D(?:[\uDC68\uDC69]\u200D\uD83D(?:\uDC66(?:\u200D\uD83D\uDC66)?|\uDC67(?:\u200D\uD83D[\uDC66\uDC67])?)|[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uDC66(?:\u200D\uD83D\uDC66)?|\uDC67(?:\u200D\uD83D[\uDC66\uDC67])?)|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\uD83C(?:\uDFFB(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:\uDC8B\u200D\uD83D)?\uDC68\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF-\uDDB3\uDDBC\uDDBD]|\uDD1D\u200D\uD83D\uDC68\uD83C[\uDFFC-\uDFFF])))?|\uDFFC(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:\uDC8B\u200D\uD83D)?\uDC68\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF-\uDDB3\uDDBC\uDDBD]|\uDD1D\u200D\uD83D\uDC68\uD83C[\uDFFB\uDFFD-\uDFFF])))?|\uDFFD(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:\uDC8B\u200D\uD83D)?\uDC68\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF-\uDDB3\uDDBC\uDDBD]|\uDD1D\u200D\uD83D\uDC68\uD83C[\uDFFB\uDFFC\uDFFE\uDFFF])))?|\uDFFE(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:\uDC8B\u200D\uD83D)?\uDC68\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF-\uDDB3\uDDBC\uDDBD]|\uDD1D\u200D\uD83D\uDC68\uD83C[\uDFFB-\uDFFD\uDFFF])))?|\uDFFF(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:\uDC8B\u200D\uD83D)?\uDC68\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF-\uDDB3\uDDBC\uDDBD]|\uDD1D\u200D\uD83D\uDC68\uD83C[\uDFFB-\uDFFE])))?))?|\uDC69(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:\uDC8B\u200D\uD83D)?[\uDC68\uDC69]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D(?:[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uDC66(?:\u200D\uD83D\uDC66)?|\uDC67(?:\u200D\uD83D[\uDC66\uDC67])?|\uDC69\u200D\uD83D(?:\uDC66(?:\u200D\uD83D\uDC66)?|\uDC67(?:\u200D\uD83D[\uDC66\uDC67])?))|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\uD83C(?:\uDFFB(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:[\uDC68\uDC69]|\uDC8B\u200D\uD83D[\uDC68\uDC69])\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF-\uDDB3\uDDBC\uDDBD]|\uDD1D\u200D\uD83D[\uDC68\uDC69]\uD83C[\uDFFC-\uDFFF])))?|\uDFFC(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:[\uDC68\uDC69]|\uDC8B\u200D\uD83D[\uDC68\uDC69])\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF-\uDDB3\uDDBC\uDDBD]|\uDD1D\u200D\uD83D[\uDC68\uDC69]\uD83C[\uDFFB\uDFFD-\uDFFF])))?|\uDFFD(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:[\uDC68\uDC69]|\uDC8B\u200D\uD83D[\uDC68\uDC69])\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF-\uDDB3\uDDBC\uDDBD]|\uDD1D\u200D\uD83D[\uDC68\uDC69]\uD83C[\uDFFB\uDFFC\uDFFE\uDFFF])))?|\uDFFE(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:[\uDC68\uDC69]|\uDC8B\u200D\uD83D[\uDC68\uDC69])\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF-\uDDB3\uDDBC\uDDBD]|\uDD1D\u200D\uD83D[\uDC68\uDC69]\uD83C[\uDFFB-\uDFFD\uDFFF])))?|\uDFFF(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:[\uDC68\uDC69]|\uDC8B\u200D\uD83D[\uDC68\uDC69])\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF-\uDDB3\uDDBC\uDDBD]|\uDD1D\u200D\uD83D[\uDC68\uDC69]\uD83C[\uDFFB-\uDFFE])))?))?|\uDC6F(?:\u200D[\u2640\u2642]\uFE0F?)?|\uDD75(?:\uFE0F|\uD83C[\uDFFB-\uDFFF])?(?:\u200D[\u2640\u2642]\uFE0F?)?|\uDE2E(?:\u200D\uD83D\uDCA8)?|\uDE35(?:\u200D\uD83D\uDCAB)?|\uDE36(?:\u200D\uD83C\uDF2B\uFE0F?)?)|\uD83E(?:[\uDD0C\uDD0F\uDD18-\uDD1F\uDD30-\uDD34\uDD36\uDD77\uDDB5\uDDB6\uDDBB\uDDD2\uDDD3\uDDD5\uDEC3-\uDEC5\uDEF0\uDEF2-\uDEF8](?:\uD83C[\uDFFB-\uDFFF])?|[\uDD26\uDD35\uDD37-\uDD39\uDD3D\uDD3E\uDDB8\uDDB9\uDDCD-\uDDCF\uDDD4\uDDD6-\uDDDD](?:\uD83C[\uDFFB-\uDFFF])?(?:\u200D[\u2640\u2642]\uFE0F?)?|[\uDDDE\uDDDF](?:\u200D[\u2640\u2642]\uFE0F?)?|[\uDD0D\uDD0E\uDD10-\uDD17\uDD20-\uDD25\uDD27-\uDD2F\uDD3A\uDD3F-\uDD45\uDD47-\uDD76\uDD78-\uDDB4\uDDB7\uDDBA\uDDBC-\uDDCC\uDDD0\uDDE0-\uDDFF\uDE70-\uDE7C\uDE80-\uDE88\uDE90-\uDEBD\uDEBF-\uDEC2\uDECE-\uDEDB\uDEE0-\uDEE8]|\uDD3C(?:\u200D[\u2640\u2642]\uFE0F?|\uD83C[\uDFFB-\uDFFF])?|\uDDD1(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\uD83C[\uDF3E\uDF73\uDF7C\uDF84\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF-\uDDB3\uDDBC\uDDBD]|\uDD1D\u200D\uD83E\uDDD1))|\uD83C(?:\uDFFB(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D(?:\uD83D\uDC8B\u200D)?\uD83E\uDDD1\uD83C[\uDFFC-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF84\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF-\uDDB3\uDDBC\uDDBD]|\uDD1D\u200D\uD83E\uDDD1\uD83C[\uDFFB-\uDFFF])))?|\uDFFC(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D(?:\uD83D\uDC8B\u200D)?\uD83E\uDDD1\uD83C[\uDFFB\uDFFD-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF84\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF-\uDDB3\uDDBC\uDDBD]|\uDD1D\u200D\uD83E\uDDD1\uD83C[\uDFFB-\uDFFF])))?|\uDFFD(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D(?:\uD83D\uDC8B\u200D)?\uD83E\uDDD1\uD83C[\uDFFB\uDFFC\uDFFE\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF84\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF-\uDDB3\uDDBC\uDDBD]|\uDD1D\u200D\uD83E\uDDD1\uD83C[\uDFFB-\uDFFF])))?|\uDFFE(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D(?:\uD83D\uDC8B\u200D)?\uD83E\uDDD1\uD83C[\uDFFB-\uDFFD\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF84\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF-\uDDB3\uDDBC\uDDBD]|\uDD1D\u200D\uD83E\uDDD1\uD83C[\uDFFB-\uDFFF])))?|\uDFFF(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D(?:\uD83D\uDC8B\u200D)?\uD83E\uDDD1\uD83C[\uDFFB-\uDFFE]|\uD83C[\uDF3E\uDF73\uDF7C\uDF84\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF-\uDDB3\uDDBC\uDDBD]|\uDD1D\u200D\uD83E\uDDD1\uD83C[\uDFFB-\uDFFF])))?))?|\uDEF1(?:\uD83C(?:\uDFFB(?:\u200D\uD83E\uDEF2\uD83C[\uDFFC-\uDFFF])?|\uDFFC(?:\u200D\uD83E\uDEF2\uD83C[\uDFFB\uDFFD-\uDFFF])?|\uDFFD(?:\u200D\uD83E\uDEF2\uD83C[\uDFFB\uDFFC\uDFFE\uDFFF])?|\uDFFE(?:\u200D\uD83E\uDEF2\uD83C[\uDFFB-\uDFFD\uDFFF])?|\uDFFF(?:\u200D\uD83E\uDEF2\uD83C[\uDFFB-\uDFFE])?))?)/g; +var xr = { eastAsianWidth(t) { + var e = t.charCodeAt(0), r = t.length == 2 ? t.charCodeAt(1) : 0, n = e; + return 55296 <= e && e <= 56319 && 56320 <= r && r <= 57343 && (e &= 1023, r &= 1023, n = e << 10 | r, n += 65536), n == 12288 || 65281 <= n && n <= 65376 || 65504 <= n && n <= 65510 ? "F" : 4352 <= n && n <= 4447 || 4515 <= n && n <= 4519 || 4602 <= n && n <= 4607 || 9001 <= n && n <= 9002 || 11904 <= n && n <= 11929 || 11931 <= n && n <= 12019 || 12032 <= n && n <= 12245 || 12272 <= n && n <= 12283 || 12289 <= n && n <= 12350 || 12353 <= n && n <= 12438 || 12441 <= n && n <= 12543 || 12549 <= n && n <= 12589 || 12593 <= n && n <= 12686 || 12688 <= n && n <= 12730 || 12736 <= n && n <= 12771 || 12784 <= n && n <= 12830 || 12832 <= n && n <= 12871 || 12880 <= n && n <= 13054 || 13056 <= n && n <= 19903 || 19968 <= n && n <= 42124 || 42128 <= n && n <= 42182 || 43360 <= n && n <= 43388 || 44032 <= n && n <= 55203 || 55216 <= n && n <= 55238 || 55243 <= n && n <= 55291 || 63744 <= n && n <= 64255 || 65040 <= n && n <= 65049 || 65072 <= n && n <= 65106 || 65108 <= n && n <= 65126 || 65128 <= n && n <= 65131 || 110592 <= n && n <= 110593 || 127488 <= n && n <= 127490 || 127504 <= n && n <= 127546 || 127552 <= n && n <= 127560 || 127568 <= n && n <= 127569 || 131072 <= n && n <= 194367 || 177984 <= n && n <= 196605 || 196608 <= n && n <= 262141 ? "W" : "N"; +} }; +var bu = /[^\x20-\x7F]/; +function wu(t) { + if (!t) + return 0; + if (!bu.test(t)) + return t.length; + t = t.replace(yr(), " "); + let e = 0; + for (let r of t) { + let n = r.codePointAt(0); + if (n <= 31 || n >= 127 && n <= 159 || n >= 768 && n <= 879) + continue; + let o = xr.eastAsianWidth(r); + e += o === "F" || o === "W" ? 2 : 1; + } + return e; +} +var we = wu; +var Br = (t) => { + if (Array.isArray(t)) + return t; + if (t.type !== k) + throw new Error(`Expect doc to be 'array' or '${k}'.`); + return t.parts; +}; +function Ne(t, e) { + if (typeof t == "string") + return e(t); + let r = /* @__PURE__ */ new Map(); + return n(t); + function n(u) { + if (r.has(u)) + return r.get(u); + let i = o(u); + return r.set(u, i), i; + } + function o(u) { + switch (W(u)) { + case j: + return e(u.map(n)); + case k: + return e({ ...u, parts: u.parts.map(n) }); + case B: + return e({ ...u, breakContents: n(u.breakContents), flatContents: n(u.flatContents) }); + case A: { + let { expandedStates: i, contents: s } = u; + return i ? (i = i.map(n), s = i[0]) : s = n(s), e({ ...u, contents: s, expandedStates: i }); + } + case S: + case T: + case P: + case O: + case L: + return e({ ...u, contents: n(u.contents) }); + case U: + case M: + case v: + case I: + case x: + case b: + return e(u); + default: + throw new q(u); + } + } +} +function Je(t, e, r) { + let n = r, o = false; + function u(i) { + if (o) + return false; + let s = e(i); + s !== void 0 && (o = true, n = s); + } + return xe(t, u), n; +} +function Ou(t) { + if (t.type === A && t.break || t.type === x && t.hard || t.type === b) + return true; +} +function kr(t) { + return Je(t, Ou, false); +} +function _r(t) { + if (t.length > 0) { + let e = y(false, t, -1); + !e.expandedStates && !e.break && (e.break = "propagated"); + } + return null; +} +function br(t) { + let e = /* @__PURE__ */ new Set(), r = []; + function n(u) { + if (u.type === b && _r(r), u.type === A) { + if (r.push(u), e.has(u)) + return false; + e.add(u); + } + } + function o(u) { + u.type === A && r.pop().break && _r(r); + } + xe(t, n, o, true); +} +function Nu(t) { + return t.type === x && !t.hard ? t.soft ? "" : " " : t.type === B ? t.flatContents : t; +} +function wr(t) { + return Ne(t, Nu); +} +function Ar(t) { + for (t = [...t]; t.length >= 2 && y(false, t, -2).type === x && y(false, t, -1).type === b; ) + t.length -= 2; + if (t.length > 0) { + let e = Oe(y(false, t, -1)); + t[t.length - 1] = e; + } + return t; +} +function Oe(t) { + switch (W(t)) { + case S: + case T: + case P: + case A: + case L: + case O: { + let e = Oe(t.contents); + return { ...t, contents: e }; + } + case B: + return { ...t, breakContents: Oe(t.breakContents), flatContents: Oe(t.flatContents) }; + case k: + return { ...t, parts: Ar(t.parts) }; + case j: + return Ar(t); + case U: + return t.replace(/[\n\r]*$/, ""); + case M: + case v: + case I: + case x: + case b: + break; + default: + throw new q(t); + } + return t; +} +function Xe(t) { + return Oe(Su(t)); +} +function Tu(t) { + switch (W(t)) { + case k: + if (t.parts.every((e) => e === "")) + return ""; + break; + case A: + if (!t.contents && !t.id && !t.break && !t.expandedStates) + return ""; + if (t.contents.type === A && t.contents.id === t.id && t.contents.break === t.break && t.contents.expandedStates === t.expandedStates) + return t.contents; + break; + case S: + case T: + case P: + case L: + if (!t.contents) + return ""; + break; + case B: + if (!t.flatContents && !t.breakContents) + return ""; + break; + case j: { + let e = []; + for (let r of t) { + if (!r) + continue; + let [n, ...o] = Array.isArray(r) ? r : [r]; + typeof n == "string" && typeof y(false, e, -1) == "string" ? e[e.length - 1] += n : e.push(n), e.push(...o); + } + return e.length === 0 ? "" : e.length === 1 ? e[0] : e; + } + case U: + case M: + case v: + case I: + case x: + case O: + case b: + break; + default: + throw new q(t); + } + return t; +} +function Su(t) { + return Ne(t, (e) => Tu(e)); +} +function Or(t, e = He) { + return Ne(t, (r) => typeof r == "string" ? ke(e, r.split(` +`)) : r); +} +function vu(t) { + if (t.type === x) + return true; +} +function Nr(t) { + return Je(t, vu, false); +} +function Ze(t, e) { + return t.type === O ? { ...t, contents: e(t.contents) } : e(t); +} +var R = Symbol("MODE_BREAK"), K = Symbol("MODE_FLAT"), Te = Symbol("cursor"); +function Tr() { + return { value: "", length: 0, queue: [] }; +} +function Pu(t, e) { + return Bt(t, { type: "indent" }, e); +} +function Lu(t, e, r) { + return e === Number.NEGATIVE_INFINITY ? t.root || Tr() : e < 0 ? Bt(t, { type: "dedent" }, r) : e ? e.type === "root" ? { ...t, root: t } : Bt(t, { type: typeof e == "string" ? "stringAlign" : "numberAlign", n: e }, r) : t; +} +function Bt(t, e, r) { + let n = e.type === "dedent" ? t.queue.slice(0, -1) : [...t.queue, e], o = "", u = 0, i = 0, s = 0; + for (let l of n) + switch (l.type) { + case "indent": + c(), r.useTabs ? a(1) : D(r.tabWidth); + break; + case "stringAlign": + c(), o += l.n, u += l.n.length; + break; + case "numberAlign": + i += 1, s += l.n; + break; + default: + throw new Error(`Unexpected type '${l.type}'`); + } + return f(), { ...t, value: o, length: u, queue: n }; + function a(l) { + o += " ".repeat(l), u += r.tabWidth * l; + } + function D(l) { + o += " ".repeat(l), u += l; + } + function c() { + r.useTabs ? F() : f(); + } + function F() { + i > 0 && a(i), d(); + } + function f() { + s > 0 && D(s), d(); + } + function d() { + i = 0, s = 0; + } +} +function kt(t) { + let e = 0, r = 0, n = t.length; + e: + for (; n--; ) { + let o = t[n]; + if (o === Te) { + r++; + continue; + } + for (let u = o.length - 1; u >= 0; u--) { + let i = o[u]; + if (i === " " || i === " ") + e++; + else { + t[n] = o.slice(0, u + 1); + break e; + } + } + } + if (e > 0 || r > 0) + for (t.length = n + 1; r-- > 0; ) + t.push(Te); + return e; +} +function Qe(t, e, r, n, o, u) { + if (r === Number.POSITIVE_INFINITY) + return true; + let i = e.length, s = [t], a = []; + for (; r >= 0; ) { + if (s.length === 0) { + if (i === 0) + return true; + s.push(e[--i]); + continue; + } + let { mode: D, doc: c } = s.pop(); + switch (W(c)) { + case U: + a.push(c), r -= we(c); + break; + case j: + case k: { + let F = Br(c); + for (let f = F.length - 1; f >= 0; f--) + s.push({ mode: D, doc: F[f] }); + break; + } + case T: + case S: + case P: + case O: + s.push({ mode: D, doc: c.contents }); + break; + case v: + r += kt(a); + break; + case A: { + if (u && c.break) + return false; + let F = c.break ? R : D, f = c.expandedStates && F === R ? y(false, c.expandedStates, -1) : c.contents; + s.push({ mode: F, doc: f }); + break; + } + case B: { + let f = (c.groupId ? o[c.groupId] || K : D) === R ? c.breakContents : c.flatContents; + f && s.push({ mode: D, doc: f }); + break; + } + case x: + if (D === R || c.hard) + return true; + c.soft || (a.push(" "), r--); + break; + case L: + n = true; + break; + case I: + if (n) + return false; + break; + } + } + return false; +} +function fe(t, e) { + let r = {}, n = e.printWidth, o = be(e.endOfLine), u = 0, i = [{ ind: Tr(), mode: R, doc: t }], s = [], a = false, D = [], c = 0; + for (br(t); i.length > 0; ) { + let { ind: f, mode: d, doc: l } = i.pop(); + switch (W(l)) { + case U: { + let p = o !== ` +` ? ee(false, l, ` +`, o) : l; + s.push(p), i.length > 0 && (u += we(p)); + break; + } + case j: + for (let p = l.length - 1; p >= 0; p--) + i.push({ ind: f, mode: d, doc: l[p] }); + break; + case M: + if (c >= 2) + throw new Error("There are too many 'cursor' in doc."); + s.push(Te), c++; + break; + case T: + i.push({ ind: Pu(f, e), mode: d, doc: l.contents }); + break; + case S: + i.push({ ind: Lu(f, l.n, e), mode: d, doc: l.contents }); + break; + case v: + u -= kt(s); + break; + case A: + switch (d) { + case K: + if (!a) { + i.push({ ind: f, mode: l.break ? R : K, doc: l.contents }); + break; + } + case R: { + a = false; + let p = { ind: f, mode: K, doc: l.contents }, m = n - u, E = D.length > 0; + if (!l.break && Qe(p, i, m, E, r)) + i.push(p); + else if (l.expandedStates) { + let h = y(false, l.expandedStates, -1); + if (l.break) { + i.push({ ind: f, mode: R, doc: h }); + break; + } else + for (let g = 1; g < l.expandedStates.length + 1; g++) + if (g >= l.expandedStates.length) { + i.push({ ind: f, mode: R, doc: h }); + break; + } else { + let C = l.expandedStates[g], _ = { ind: f, mode: K, doc: C }; + if (Qe(_, i, m, E, r)) { + i.push(_); + break; + } + } + } else + i.push({ ind: f, mode: R, doc: l.contents }); + break; + } + } + l.id && (r[l.id] = y(false, i, -1).mode); + break; + case k: { + let p = n - u, { parts: m } = l; + if (m.length === 0) + break; + let [E, h] = m, g = { ind: f, mode: K, doc: E }, C = { ind: f, mode: R, doc: E }, _ = Qe(g, [], p, D.length > 0, r, true); + if (m.length === 1) { + _ ? i.push(g) : i.push(C); + break; + } + let Z = { ind: f, mode: K, doc: h }, $ = { ind: f, mode: R, doc: h }; + if (m.length === 2) { + _ ? i.push(Z, g) : i.push($, C); + break; + } + m.splice(0, 2); + let Q = { ind: f, mode: d, doc: Ge(m) }, rr = m[0]; + Qe({ ind: f, mode: K, doc: [E, h, rr] }, [], p, D.length > 0, r, true) ? i.push(Q, Z, g) : _ ? i.push(Q, $, g) : i.push(Q, $, C); + break; + } + case B: + case P: { + let p = l.groupId ? r[l.groupId] : d; + if (p === R) { + let m = l.type === B ? l.breakContents : l.negate ? l.contents : ie(l.contents); + m && i.push({ ind: f, mode: d, doc: m }); + } + if (p === K) { + let m = l.type === B ? l.flatContents : l.negate ? ie(l.contents) : l.contents; + m && i.push({ ind: f, mode: d, doc: m }); + } + break; + } + case L: + D.push({ ind: f, mode: d, doc: l.contents }); + break; + case I: + D.length > 0 && i.push({ ind: f, mode: d, doc: Ae }); + break; + case x: + switch (d) { + case K: + if (l.hard) + a = true; + else { + l.soft || (s.push(" "), u += 1); + break; + } + case R: + if (D.length > 0) { + i.push({ ind: f, mode: d, doc: l }, ...D.reverse()), D.length = 0; + break; + } + l.literal ? f.root ? (s.push(o, f.root.value), u = f.root.length) : (s.push(o), u = 0) : (u -= kt(s), s.push(o + f.value), u = f.length); + break; + } + break; + case O: + i.push({ ind: f, mode: d, doc: l.contents }); + break; + case b: + break; + default: + throw new q(l); + } + i.length === 0 && D.length > 0 && (i.push(...D.reverse()), D.length = 0); + } + let F = s.indexOf(Te); + if (F !== -1) { + let f = s.indexOf(Te, F + 1), d = s.slice(0, F).join(""), l = s.slice(F + 1, f).join(""), p = s.slice(f + 1).join(""); + return { formatted: d + l + p, cursorNodeStart: d.length, cursorNodeText: l }; + } + return { formatted: s.join("") }; +} +function J(t) { + var e; + if (!t) + return ""; + if (Array.isArray(t)) { + let r = []; + for (let n of t) + if (Array.isArray(n)) + r.push(...J(n)); + else { + let o = J(n); + o !== "" && r.push(o); + } + return r; + } + return t.type === B ? { ...t, breakContents: J(t.breakContents), flatContents: J(t.flatContents) } : t.type === A ? { ...t, contents: J(t.contents), expandedStates: (e = t.expandedStates) == null ? void 0 : e.map(J) } : t.type === k ? { type: "fill", parts: t.parts.map(J) } : t.contents ? { ...t, contents: J(t.contents) } : t; +} +function Sr(t) { + let e = /* @__PURE__ */ Object.create(null), r = /* @__PURE__ */ new Set(); + return n(J(t)); + function n(u, i, s) { + var a, D; + if (typeof u == "string") + return JSON.stringify(u); + if (Array.isArray(u)) { + let c = u.map(n).filter(Boolean); + return c.length === 1 ? c[0] : `[${c.join(", ")}]`; + } + if (u.type === x) { + let c = ((a = s == null ? void 0 : s[i + 1]) == null ? void 0 : a.type) === b; + return u.literal ? c ? "literalline" : "literallineWithoutBreakParent" : u.hard ? c ? "hardline" : "hardlineWithoutBreakParent" : u.soft ? "softline" : "line"; + } + if (u.type === b) + return ((D = s == null ? void 0 : s[i - 1]) == null ? void 0 : D.type) === x && s[i - 1].hard ? void 0 : "breakParent"; + if (u.type === v) + return "trim"; + if (u.type === T) + return "indent(" + n(u.contents) + ")"; + if (u.type === S) + return u.n === Number.NEGATIVE_INFINITY ? "dedentToRoot(" + n(u.contents) + ")" : u.n < 0 ? "dedent(" + n(u.contents) + ")" : u.n.type === "root" ? "markAsRoot(" + n(u.contents) + ")" : "align(" + JSON.stringify(u.n) + ", " + n(u.contents) + ")"; + if (u.type === B) + return "ifBreak(" + n(u.breakContents) + (u.flatContents ? ", " + n(u.flatContents) : "") + (u.groupId ? (u.flatContents ? "" : ', ""') + `, { groupId: ${o(u.groupId)} }` : "") + ")"; + if (u.type === P) { + let c = []; + u.negate && c.push("negate: true"), u.groupId && c.push(`groupId: ${o(u.groupId)}`); + let F = c.length > 0 ? `, { ${c.join(", ")} }` : ""; + return `indentIfBreak(${n(u.contents)}${F})`; + } + if (u.type === A) { + let c = []; + u.break && u.break !== "propagated" && c.push("shouldBreak: true"), u.id && c.push(`id: ${o(u.id)}`); + let F = c.length > 0 ? `, { ${c.join(", ")} }` : ""; + return u.expandedStates ? `conditionalGroup([${u.expandedStates.map((f) => n(f)).join(",")}]${F})` : `group(${n(u.contents)}${F})`; + } + if (u.type === k) + return `fill([${u.parts.map((c) => n(c)).join(", ")}])`; + if (u.type === L) + return "lineSuffix(" + n(u.contents) + ")"; + if (u.type === I) + return "lineSuffixBoundary"; + if (u.type === O) + return `label(${JSON.stringify(u.label)}, ${n(u.contents)})`; + throw new Error("Unknown doc type " + u.type); + } + function o(u) { + if (typeof u != "symbol") + return JSON.stringify(String(u)); + if (u in e) + return e[u]; + let i = u.description || "symbol"; + for (let s = 0; ; s++) { + let a = i + (s > 0 ? ` #${s}` : ""); + if (!r.has(a)) + return r.add(a), e[u] = `Symbol.for(${JSON.stringify(a)})`; + } + } +} +function Iu(t, e, r = 0) { + let n = 0; + for (let o = r; o < t.length; ++o) + t[o] === " " ? n = n + e - n % e : n++; + return n; +} +var pe = Iu; +var Se = class extends Error { + constructor() { + super(...arguments); + __publicField(this, "name", "ConfigError"); + } +}, ve = class extends Error { + constructor() { + super(...arguments); + __publicField(this, "name", "UndefinedParserError"); + } +}; +var vr = { cursorOffset: { category: "Special", type: "int", default: -1, range: { start: -1, end: 1 / 0, step: 1 }, description: `Print (to stderr) where a cursor at the given position would move to after formatting. +This option cannot be used with --range-start and --range-end.`, cliCategory: "Editor" }, endOfLine: { category: "Global", type: "choice", default: "lf", description: "Which end of line characters to apply.", choices: [{ value: "lf", description: "Line Feed only (\\n), common on Linux and macOS as well as inside git repos" }, { value: "crlf", description: "Carriage Return + Line Feed characters (\\r\\n), common on Windows" }, { value: "cr", description: "Carriage Return character only (\\r), used very rarely" }, { value: "auto", description: `Maintain existing +(mixed values within one file are normalised by looking at what's used after the first line)` }] }, filepath: { category: "Special", type: "path", description: "Specify the input filepath. This will be used to do parser inference.", cliName: "stdin-filepath", cliCategory: "Other", cliDescription: "Path to the file to pretend that stdin comes from." }, insertPragma: { category: "Special", type: "boolean", default: false, description: "Insert @format pragma into file's first docblock comment.", cliCategory: "Other" }, parser: { category: "Global", type: "choice", default: void 0, description: "Which parser to use.", exception: (t) => typeof t == "string" || typeof t == "function", choices: [{ value: "flow", description: "Flow" }, { value: "babel", description: "JavaScript" }, { value: "babel-flow", description: "Flow" }, { value: "babel-ts", description: "TypeScript" }, { value: "typescript", description: "TypeScript" }, { value: "acorn", description: "JavaScript" }, { value: "espree", description: "JavaScript" }, { value: "meriyah", description: "JavaScript" }, { value: "css", description: "CSS" }, { value: "less", description: "Less" }, { value: "scss", description: "SCSS" }, { value: "json", description: "JSON" }, { value: "json5", description: "JSON5" }, { value: "json-stringify", description: "JSON.stringify" }, { value: "graphql", description: "GraphQL" }, { value: "markdown", description: "Markdown" }, { value: "mdx", description: "MDX" }, { value: "vue", description: "Vue" }, { value: "yaml", description: "YAML" }, { value: "glimmer", description: "Ember / Handlebars" }, { value: "html", description: "HTML" }, { value: "angular", description: "Angular" }, { value: "lwc", description: "Lightning Web Components" }] }, plugins: { type: "path", array: true, default: [{ value: [] }], category: "Global", description: "Add a plugin. Multiple plugins can be passed as separate `--plugin`s.", exception: (t) => typeof t == "string" || typeof t == "object", cliName: "plugin", cliCategory: "Config" }, printWidth: { category: "Global", type: "int", default: 80, description: "The line length where Prettier will try wrap.", range: { start: 0, end: 1 / 0, step: 1 } }, rangeEnd: { category: "Special", type: "int", default: 1 / 0, range: { start: 0, end: 1 / 0, step: 1 }, description: `Format code ending at a given character offset (exclusive). +The range will extend forwards to the end of the selected statement. +This option cannot be used with --cursor-offset.`, cliCategory: "Editor" }, rangeStart: { category: "Special", type: "int", default: 0, range: { start: 0, end: 1 / 0, step: 1 }, description: `Format code starting at a given character offset. +The range will extend backwards to the start of the first line containing the selected statement. +This option cannot be used with --cursor-offset.`, cliCategory: "Editor" }, requirePragma: { category: "Special", type: "boolean", default: false, description: `Require either '@prettier' or '@format' to be present in the file's first docblock comment +in order for it to be formatted.`, cliCategory: "Other" }, tabWidth: { type: "int", category: "Global", default: 2, description: "Number of spaces per indentation level.", range: { start: 0, end: 1 / 0, step: 1 } }, useTabs: { category: "Global", type: "boolean", default: false, description: "Indent with tabs instead of spaces." }, embeddedLanguageFormatting: { category: "Global", type: "choice", default: "auto", description: "Control how Prettier formats quoted code embedded in the file.", choices: [{ value: "auto", description: "Format embedded code if Prettier can automatically identify it." }, { value: "off", description: "Never automatically format embedded code." }] } }; +function et({ plugins: t = [], showDeprecated: e = false } = {}) { + let r = t.flatMap((o) => o.languages ?? []), n = []; + for (let o of Yu(Object.assign({}, ...t.map(({ options: u }) => u), vr))) + !e && o.deprecated || (Array.isArray(o.choices) && (e || (o.choices = o.choices.filter((u) => !u.deprecated)), o.name === "parser" && (o.choices = [...o.choices, ...Ru(o.choices, r, t)])), o.pluginDefaults = Object.fromEntries(t.filter((u) => { + var i; + return ((i = u.defaultOptions) == null ? void 0 : i[o.name]) !== void 0; + }).map((u) => [u.name, u.defaultOptions[o.name]])), n.push(o)); + return { languages: r, options: n }; +} +function* Ru(t, e, r) { + let n = new Set(t.map((o) => o.value)); + for (let o of e) + if (o.parsers) { + for (let u of o.parsers) + if (!n.has(u)) { + n.add(u); + let i = r.find((a) => a.parsers && Object.prototype.hasOwnProperty.call(a.parsers, u)), s = o.name; + i != null && i.name && (s += ` (plugin: ${i.name})`), yield { value: u, description: s }; + } + } +} +function Yu(t) { + let e = []; + for (let [r, n] of Object.entries(t)) { + let o = { name: r, ...n }; + Array.isArray(o.default) && (o.default = y(false, o.default, -1).value), e.push(o); + } + return e; +} +var ju = (t) => t.split(/[/\\]/).pop(); +function Pr(t, e) { + if (!e) + return; + let r = ju(e).toLowerCase(); + return t.find((n) => { + var o, u; + return ((o = n.extensions) == null ? void 0 : o.some((i) => r.endsWith(i))) || ((u = n.filenames) == null ? void 0 : u.some((i) => i.toLowerCase() === r)); + }); +} +function Vu(t, e) { + if (e) + return t.find(({ name: r }) => r.toLowerCase() === e) ?? t.find(({ aliases: r }) => r == null ? void 0 : r.includes(e)) ?? t.find(({ extensions: r }) => r == null ? void 0 : r.includes(`.${e}`)); +} +function $u(t, e) { + let r = t.plugins.flatMap((o) => o.languages ?? []), n = Vu(r, e.language) ?? Pr(r, e.physicalFile) ?? Pr(r, e.file) ?? (e.physicalFile, void 0); + return n == null ? void 0 : n.parsers[0]; +} +var Lr = $u; +var te = { key: (t) => /^[$_a-zA-Z][$_a-zA-Z0-9]*$/.test(t) ? t : JSON.stringify(t), value(t) { + if (t === null || typeof t != "object") + return JSON.stringify(t); + if (Array.isArray(t)) + return `[${t.map((r) => te.value(r)).join(", ")}]`; + let e = Object.keys(t); + return e.length === 0 ? "{}" : `{ ${e.map((r) => `${te.key(r)}: ${te.value(t[r])}`).join(", ")} }`; +}, pair: ({ key: t, value: e }) => te.value({ [t]: e }) }; +var bt = Ce(Pe(), 1), Yr = (t, e, { descriptor: r }) => { + let n = [`${bt.default.yellow(typeof t == "string" ? r.key(t) : r.pair(t))} is deprecated`]; + return e && n.push(`we now treat it as ${bt.default.blue(typeof e == "string" ? r.key(e) : r.pair(e))}`), n.join("; ") + "."; +}; +var se = Ce(Pe(), 1); +var tt = Symbol.for("vnopts.VALUE_NOT_EXIST"), de = Symbol.for("vnopts.VALUE_UNCHANGED"); +var jr = " ".repeat(2), $r = (t, e, r) => { + let { text: n, list: o } = r.normalizeExpectedResult(r.schemas[t].expected(r)), u = []; + return n && u.push(Vr(t, e, n, r.descriptor)), o && u.push([Vr(t, e, o.title, r.descriptor)].concat(o.values.map((i) => Ur(i, r.loggerPrintWidth))).join(` +`)), Mr(u, r.loggerPrintWidth); +}; +function Vr(t, e, r, n) { + return [`Invalid ${se.default.red(n.key(t))} value.`, `Expected ${se.default.blue(r)},`, `but received ${e === tt ? se.default.gray("nothing") : se.default.red(n.value(e))}.`].join(" "); +} +function Ur({ text: t, list: e }, r) { + let n = []; + return t && n.push(`- ${se.default.blue(t)}`), e && n.push([`- ${se.default.blue(e.title)}:`].concat(e.values.map((o) => Ur(o, r - jr.length).replace(/^|\n/g, `$&${jr}`))).join(` +`)), Mr(n, r); +} +function Mr(t, e) { + if (t.length === 1) + return t[0]; + let [r, n] = t, [o, u] = t.map((i) => i.split(` +`, 1)[0].length); + return o > e && o > u ? n : r; +} +var Nt = Ce(Pe(), 1); +var wt = [], Wr = []; +function Ot(t, e) { + if (t === e) + return 0; + let r = t; + t.length > e.length && (t = e, e = r); + let n = t.length, o = e.length; + for (; n > 0 && t.charCodeAt(~-n) === e.charCodeAt(~-o); ) + n--, o--; + let u = 0; + for (; u < n && t.charCodeAt(u) === e.charCodeAt(u); ) + u++; + if (n -= u, o -= u, n === 0) + return o; + let i, s, a, D, c = 0, F = 0; + for (; c < n; ) + Wr[c] = t.charCodeAt(u + c), wt[c] = ++c; + for (; F < o; ) + for (i = e.charCodeAt(u + F), a = F++, s = F, c = 0; c < n; c++) + D = i === Wr[c] ? a : a + 1, a = wt[c], s = wt[c] = a > s ? D > s ? s + 1 : D : D > a ? a + 1 : D; + return s; +} +var rt = (t, e, { descriptor: r, logger: n, schemas: o }) => { + let u = [`Ignored unknown option ${Nt.default.yellow(r.pair({ key: t, value: e }))}.`], i = Object.keys(o).sort().find((s) => Ot(t, s) < 3); + i && u.push(`Did you mean ${Nt.default.blue(r.key(i))}?`), n.warn(u.join(" ")); +}; +var Uu = ["default", "expected", "validate", "deprecated", "forward", "redirect", "overlap", "preprocess", "postprocess"]; +function Mu(t, e) { + let r = new t(e), n = Object.create(r); + for (let o of Uu) + o in e && (n[o] = Wu(e[o], r, w.prototype[o].length)); + return n; +} +var w = class { + static create(e) { + return Mu(this, e); + } + constructor(e) { + this.name = e.name; + } + default(e) { + } + expected(e) { + return "nothing"; + } + validate(e, r) { + return false; + } + deprecated(e, r) { + return false; + } + forward(e, r) { + } + redirect(e, r) { + } + overlap(e, r, n) { + return e; + } + preprocess(e, r) { + return e; + } + postprocess(e, r) { + return de; + } +}; +function Wu(t, e, r) { + return typeof t == "function" ? (...n) => t(...n.slice(0, r - 1), e, ...n.slice(r - 1)) : () => t; +} +var nt = class extends w { + constructor(e) { + super(e), this._sourceName = e.sourceName; + } + expected(e) { + return e.schemas[this._sourceName].expected(e); + } + validate(e, r) { + return r.schemas[this._sourceName].validate(e, r); + } + redirect(e, r) { + return this._sourceName; + } +}; +var ut = class extends w { + expected() { + return "anything"; + } + validate() { + return true; + } +}; +var ot = class extends w { + constructor({ valueSchema: e, name: r = e.name, ...n }) { + super({ ...n, name: r }), this._valueSchema = e; + } + expected(e) { + let { text: r, list: n } = e.normalizeExpectedResult(this._valueSchema.expected(e)); + return { text: r && `an array of ${r}`, list: n && { title: "an array of the following values", values: [{ list: n }] } }; + } + validate(e, r) { + if (!Array.isArray(e)) + return false; + let n = []; + for (let o of e) { + let u = r.normalizeValidateResult(this._valueSchema.validate(o, r), o); + u !== true && n.push(u.value); + } + return n.length === 0 ? true : { value: n }; + } + deprecated(e, r) { + let n = []; + for (let o of e) { + let u = r.normalizeDeprecatedResult(this._valueSchema.deprecated(o, r), o); + u !== false && n.push(...u.map(({ value: i }) => ({ value: [i] }))); + } + return n; + } + forward(e, r) { + let n = []; + for (let o of e) { + let u = r.normalizeForwardResult(this._valueSchema.forward(o, r), o); + n.push(...u.map(zr)); + } + return n; + } + redirect(e, r) { + let n = [], o = []; + for (let u of e) { + let i = r.normalizeRedirectResult(this._valueSchema.redirect(u, r), u); + "remain" in i && n.push(i.remain), o.push(...i.redirect.map(zr)); + } + return n.length === 0 ? { redirect: o } : { redirect: o, remain: n }; + } + overlap(e, r) { + return e.concat(r); + } +}; +function zr({ from: t, to: e }) { + return { from: [t], to: e }; +} +var it = class extends w { + expected() { + return "true or false"; + } + validate(e) { + return typeof e == "boolean"; + } +}; +function Kr(t, e) { + let r = /* @__PURE__ */ Object.create(null); + for (let n of t) { + let o = n[e]; + if (r[o]) + throw new Error(`Duplicate ${e} ${JSON.stringify(o)}`); + r[o] = n; + } + return r; +} +function Hr(t, e) { + let r = /* @__PURE__ */ new Map(); + for (let n of t) { + let o = n[e]; + if (r.has(o)) + throw new Error(`Duplicate ${e} ${JSON.stringify(o)}`); + r.set(o, n); + } + return r; +} +function qr() { + let t = /* @__PURE__ */ Object.create(null); + return (e) => { + let r = JSON.stringify(e); + return t[r] ? true : (t[r] = true, false); + }; +} +function Jr(t, e) { + let r = [], n = []; + for (let o of t) + e(o) ? r.push(o) : n.push(o); + return [r, n]; +} +function Xr(t) { + return t === Math.floor(t); +} +function Zr(t, e) { + if (t === e) + return 0; + let r = typeof t, n = typeof e, o = ["undefined", "object", "boolean", "number", "string"]; + return r !== n ? o.indexOf(r) - o.indexOf(n) : r !== "string" ? Number(t) - Number(e) : t.localeCompare(e); +} +function Qr(t) { + return (...e) => { + let r = t(...e); + return typeof r == "string" ? new Error(r) : r; + }; +} +function Tt(t) { + return t === void 0 ? {} : t; +} +function St(t) { + if (typeof t == "string") + return { text: t }; + let { text: e, list: r } = t; + return zu((e || r) !== void 0, "Unexpected `expected` result, there should be at least one field."), r ? { text: e, list: { title: r.title, values: r.values.map(St) } } : { text: e }; +} +function vt(t, e) { + return t === true ? true : t === false ? { value: e } : t; +} +function Pt(t, e, r = false) { + return t === false ? false : t === true ? r ? true : [{ value: e }] : "value" in t ? [t] : t.length === 0 ? false : t; +} +function Gr(t, e) { + return typeof t == "string" || "key" in t ? { from: e, to: t } : "from" in t ? { from: t.from, to: t.to } : { from: e, to: t.to }; +} +function st(t, e) { + return t === void 0 ? [] : Array.isArray(t) ? t.map((r) => Gr(r, e)) : [Gr(t, e)]; +} +function Lt(t, e) { + let r = st(typeof t == "object" && "redirect" in t ? t.redirect : t, e); + return r.length === 0 ? { remain: e, redirect: r } : typeof t == "object" && "remain" in t ? { remain: t.remain, redirect: r } : { redirect: r }; +} +function zu(t, e) { + if (!t) + throw new Error(e); +} +var at = class extends w { + constructor(e) { + super(e), this._choices = Hr(e.choices.map((r) => r && typeof r == "object" ? r : { value: r }), "value"); + } + expected({ descriptor: e }) { + let r = Array.from(this._choices.keys()).map((i) => this._choices.get(i)).filter(({ hidden: i }) => !i).map((i) => i.value).sort(Zr).map(e.value), n = r.slice(0, -2), o = r.slice(-2); + return { text: n.concat(o.join(" or ")).join(", "), list: { title: "one of the following values", values: r } }; + } + validate(e) { + return this._choices.has(e); + } + deprecated(e) { + let r = this._choices.get(e); + return r && r.deprecated ? { value: e } : false; + } + forward(e) { + let r = this._choices.get(e); + return r ? r.forward : void 0; + } + redirect(e) { + let r = this._choices.get(e); + return r ? r.redirect : void 0; + } +}; +var Dt = class extends w { + expected() { + return "a number"; + } + validate(e, r) { + return typeof e == "number"; + } +}; +var ct = class extends Dt { + expected() { + return "an integer"; + } + validate(e, r) { + return r.normalizeValidateResult(super.validate(e, r), e) === true && Xr(e); + } +}; +var Le = class extends w { + expected() { + return "a string"; + } + validate(e) { + return typeof e == "string"; + } +}; +var en = te, tn = rt, rn = $r, nn = Yr; +var lt = class { + constructor(e, r) { + let { logger: n = console, loggerPrintWidth: o = 80, descriptor: u = en, unknown: i = tn, invalid: s = rn, deprecated: a = nn, missing: D = () => false, required: c = () => false, preprocess: F = (d) => d, postprocess: f = () => de } = r || {}; + this._utils = { descriptor: u, logger: n || { warn: () => { + } }, loggerPrintWidth: o, schemas: Kr(e, "name"), normalizeDefaultResult: Tt, normalizeExpectedResult: St, normalizeDeprecatedResult: Pt, normalizeForwardResult: st, normalizeRedirectResult: Lt, normalizeValidateResult: vt }, this._unknownHandler = i, this._invalidHandler = Qr(s), this._deprecatedHandler = a, this._identifyMissing = (d, l) => !(d in l) || D(d, l), this._identifyRequired = c, this._preprocess = F, this._postprocess = f, this.cleanHistory(); + } + cleanHistory() { + this._hasDeprecationWarned = qr(); + } + normalize(e) { + let r = {}, o = [this._preprocess(e, this._utils)], u = () => { + for (; o.length !== 0; ) { + let i = o.shift(), s = this._applyNormalization(i, r); + o.push(...s); + } + }; + u(); + for (let i of Object.keys(this._utils.schemas)) { + let s = this._utils.schemas[i]; + if (!(i in r)) { + let a = Tt(s.default(this._utils)); + "value" in a && o.push({ [i]: a.value }); + } + } + u(); + for (let i of Object.keys(this._utils.schemas)) { + if (!(i in r)) + continue; + let s = this._utils.schemas[i], a = r[i], D = s.postprocess(a, this._utils); + D !== de && (this._applyValidation(D, i, s), r[i] = D); + } + return this._applyPostprocess(r), this._applyRequiredCheck(r), r; + } + _applyNormalization(e, r) { + let n = [], { knownKeys: o, unknownKeys: u } = this._partitionOptionKeys(e); + for (let i of o) { + let s = this._utils.schemas[i], a = s.preprocess(e[i], this._utils); + this._applyValidation(a, i, s); + let D = ({ from: d, to: l }) => { + n.push(typeof l == "string" ? { [l]: d } : { [l.key]: l.value }); + }, c = ({ value: d, redirectTo: l }) => { + let p = Pt(s.deprecated(d, this._utils), a, true); + if (p !== false) + if (p === true) + this._hasDeprecationWarned(i) || this._utils.logger.warn(this._deprecatedHandler(i, l, this._utils)); + else + for (let { value: m } of p) { + let E = { key: i, value: m }; + if (!this._hasDeprecationWarned(E)) { + let h = typeof l == "string" ? { key: l, value: m } : l; + this._utils.logger.warn(this._deprecatedHandler(E, h, this._utils)); + } + } + }; + st(s.forward(a, this._utils), a).forEach(D); + let f = Lt(s.redirect(a, this._utils), a); + if (f.redirect.forEach(D), "remain" in f) { + let d = f.remain; + r[i] = i in r ? s.overlap(r[i], d, this._utils) : d, c({ value: d }); + } + for (let { from: d, to: l } of f.redirect) + c({ value: d, redirectTo: l }); + } + for (let i of u) { + let s = e[i]; + this._applyUnknownHandler(i, s, r, (a, D) => { + n.push({ [a]: D }); + }); + } + return n; + } + _applyRequiredCheck(e) { + for (let r of Object.keys(this._utils.schemas)) + if (this._identifyMissing(r, e) && this._identifyRequired(r)) + throw this._invalidHandler(r, tt, this._utils); + } + _partitionOptionKeys(e) { + let [r, n] = Jr(Object.keys(e).filter((o) => !this._identifyMissing(o, e)), (o) => o in this._utils.schemas); + return { knownKeys: r, unknownKeys: n }; + } + _applyValidation(e, r, n) { + let o = vt(n.validate(e, this._utils), e); + if (o !== true) + throw this._invalidHandler(r, o.value, this._utils); + } + _applyUnknownHandler(e, r, n, o) { + let u = this._unknownHandler(e, r, this._utils); + if (u) + for (let i of Object.keys(u)) { + if (this._identifyMissing(i, u)) + continue; + let s = u[i]; + i in this._utils.schemas ? o(i, s) : n[i] = s; + } + } + _applyPostprocess(e) { + let r = this._postprocess(e, this._utils); + if (r !== de) { + if (r.delete) + for (let n of r.delete) + delete e[n]; + if (r.override) { + let { knownKeys: n, unknownKeys: o } = this._partitionOptionKeys(r.override); + for (let u of n) { + let i = r.override[u]; + this._applyValidation(i, u, this._utils.schemas[u]), e[u] = i; + } + for (let u of o) { + let i = r.override[u]; + this._applyUnknownHandler(u, i, e, (s, a) => { + let D = this._utils.schemas[s]; + this._applyValidation(a, s, D), e[s] = a; + }); + } + } + } + } +}; +var It; +function Ku(t, e, { logger: r = false, isCLI: n = false, passThrough: o = false, FlagSchema: u, descriptor: i } = {}) { + if (n) { + if (!u) + throw new Error("'FlagSchema' option is required."); + if (!i) + throw new Error("'descriptor' option is required."); + } else + i = te; + let s = o ? Array.isArray(o) ? (f, d) => o.includes(f) ? { [f]: d } : void 0 : (f, d) => ({ [f]: d }) : (f, d, l) => { + let { _: p, ...m } = l.schemas; + return rt(f, d, { ...l, schemas: m }); + }, a = Hu(e, { isCLI: n, FlagSchema: u }), D = new lt(a, { logger: r, unknown: s, descriptor: i }), c = r !== false; + c && It && (D._hasDeprecationWarned = It); + let F = D.normalize(t); + return c && (It = D._hasDeprecationWarned), F; +} +function Hu(t, { isCLI: e, FlagSchema: r }) { + let n = []; + e && n.push(ut.create({ name: "_" })); + for (let o of t) + n.push(qu(o, { isCLI: e, optionInfos: t, FlagSchema: r })), o.alias && e && n.push(nt.create({ name: o.alias, sourceName: o.name })); + return n; +} +function qu(t, { isCLI: e, optionInfos: r, FlagSchema: n }) { + let { name: o } = t, u = { name: o }, i, s = {}; + switch (t.type) { + case "int": + i = ct, e && (u.preprocess = Number); + break; + case "string": + i = Le; + break; + case "choice": + i = at, u.choices = t.choices.map((a) => a != null && a.redirect ? { ...a, redirect: { to: { key: t.name, value: a.redirect } } } : a); + break; + case "boolean": + i = it; + break; + case "flag": + i = n, u.flags = r.flatMap((a) => [a.alias, a.description && a.name, a.oppositeDescription && `no-${a.name}`].filter(Boolean)); + break; + case "path": + i = Le; + break; + default: + throw new Error(`Unexpected type ${t.type}`); + } + if (t.exception ? u.validate = (a, D, c) => t.exception(a) || D.validate(a, c) : u.validate = (a, D, c) => a === void 0 || D.validate(a, c), t.redirect && (s.redirect = (a) => a ? { to: { key: t.redirect.option, value: t.redirect.value } } : void 0), t.deprecated && (s.deprecated = true), e && !t.array) { + let a = u.preprocess || ((D) => D); + u.preprocess = (D, c, F) => c.preprocess(a(Array.isArray(D) ? y(false, D, -1) : D), F); + } + return t.array ? ot.create({ ...e ? { preprocess: (a) => Array.isArray(a) ? a : [a] } : {}, ...s, valueSchema: i.create(u) }) : i.create({ ...u, ...s }); +} +var un = Ku; +function Rt(t, e) { + if (!e) + throw new Error("parserName is required."); + for (let n = t.length - 1; n >= 0; n--) { + let o = t[n]; + if (o.parsers && Object.prototype.hasOwnProperty.call(o.parsers, e)) + return o; + } + let r = `Couldn't resolve parser "${e}".`; + throw r += " Plugins must be explicitly added to the standalone bundle.", new Se(r); +} +function on(t, e) { + if (!e) + throw new Error("astFormat is required."); + for (let n = t.length - 1; n >= 0; n--) { + let o = t[n]; + if (o.printers && Object.prototype.hasOwnProperty.call(o.printers, e)) + return o; + } + let r = `Couldn't find plugin for AST format "${e}".`; + throw r += " Plugins must be explicitly added to the standalone bundle.", new Se(r); +} +function ft({ plugins: t, parser: e }) { + let r = Rt(t, e); + return Yt(r, e); +} +function Yt(t, e) { + let r = t.parsers[e]; + return typeof r == "function" ? r() : r; +} +function sn(t, e) { + let r = t.printers[e]; + return typeof r == "function" ? r() : r; +} +var an = { astFormat: "estree", printer: {}, originalText: void 0, locStart: null, locEnd: null }; +async function Ju(t, e = {}) { + var F; + let r = { ...t }; + if (!r.parser) + if (r.filepath) { + if (r.parser = Lr(r, { physicalFile: r.filepath }), !r.parser) + throw new ve(`No parser could be inferred for file "${r.filepath}".`); + } else + throw new ve("No parser and no file path given, couldn't infer a parser."); + let n = et({ plugins: t.plugins, showDeprecated: true }).options, o = { ...an, ...Object.fromEntries(n.filter((f) => f.default !== void 0).map((f) => [f.name, f.default])) }, u = Rt(r.plugins, r.parser), i = await Yt(u, r.parser); + r.astFormat = i.astFormat, r.locEnd = i.locEnd, r.locStart = i.locStart; + let s = (F = u.printers) != null && F[i.astFormat] ? u : on(r.plugins, i.astFormat), a = await sn(s, i.astFormat); + r.printer = a; + let D = s.defaultOptions ? Object.fromEntries(Object.entries(s.defaultOptions).filter(([, f]) => f !== void 0)) : {}, c = { ...o, ...D }; + for (let [f, d] of Object.entries(c)) + (r[f] === null || r[f] === void 0) && (r[f] = d); + return r.parser === "json" && (r.trailingComma = "none"), un(r, n, { passThrough: Object.keys(an), ...e }); +} +var re = Ju; +var Dn = /* @__PURE__ */ new Set(["tokens", "comments", "parent", "enclosingNode", "precedingNode", "followingNode"]), Xu = (t) => Object.keys(t).filter((e) => !Dn.has(e)); +function Zu(t) { + return t ? (e) => t(e, Dn) : Xu; +} +var H = Zu; +function Qu(t, e) { + let { printer: { massageAstNode: r, getVisitorKeys: n } } = e; + if (!r) + return t; + let o = H(n), u = r.ignoredProperties ?? /* @__PURE__ */ new Set(); + return i(t); + function i(s, a) { + if (!(s !== null && typeof s == "object")) + return s; + if (Array.isArray(s)) + return s.map((f) => i(f, a)).filter(Boolean); + let D = {}, c = new Set(o(s)); + for (let f in s) + !Object.prototype.hasOwnProperty.call(s, f) || u.has(f) || (c.has(f) ? D[f] = i(s[f], s) : D[f] = s[f]); + let F = r(s, D, a); + if (F !== null) + return F ?? D; + } +} +var cn = Qu; +var Cn = Ce(hn(), 1); +async function so(t, e) { + let r = await ft(e), n = r.preprocess ? r.preprocess(t, e) : t; + e.originalText = n; + let o; + try { + o = await r.parse(n, e, e); + } catch (u) { + ao(u, t); + } + return { text: n, ast: o }; +} +function ao(t, e) { + let { loc: r } = t; + if (r) { + let n = (0, Cn.codeFrameColumns)(e, r, { highlightCode: true }); + throw t.message += ` +` + n, t.codeFrame = n, t; + } + throw t; +} +var ae = so; +var Ie, $t, Fe, dt, Vt = class { + constructor(e) { + Ct(this, Ie); + Ct(this, Fe); + this.stack = [e]; + } + get key() { + let { stack: e, siblings: r } = this; + return y(false, e, r === null ? -2 : -4) ?? null; + } + get index() { + return this.siblings === null ? null : y(false, this.stack, -2); + } + get node() { + return y(false, this.stack, -1); + } + get parent() { + return this.getNode(1); + } + get grandparent() { + return this.getNode(2); + } + get isInArray() { + return this.siblings !== null; + } + get siblings() { + let { stack: e } = this, r = y(false, e, -3); + return Array.isArray(r) ? r : null; + } + get next() { + let { siblings: e } = this; + return e === null ? null : e[this.index + 1]; + } + get previous() { + let { siblings: e } = this; + return e === null ? null : e[this.index - 1]; + } + get isFirst() { + return this.index === 0; + } + get isLast() { + let { siblings: e, index: r } = this; + return e !== null && r === e.length - 1; + } + get isRoot() { + return this.stack.length === 1; + } + get root() { + return this.stack[0]; + } + get ancestors() { + return [...ce(this, Fe, dt).call(this)]; + } + getName() { + let { stack: e } = this, { length: r } = e; + return r > 1 ? y(false, e, -2) : null; + } + getValue() { + return y(false, this.stack, -1); + } + getNode(e = 0) { + let r = ce(this, Ie, $t).call(this, e); + return r === -1 ? null : this.stack[r]; + } + getParentNode(e = 0) { + return this.getNode(e + 1); + } + call(e, ...r) { + let { stack: n } = this, { length: o } = n, u = y(false, n, -1); + for (let i of r) + u = u[i], n.push(i, u); + try { + return e(this); + } finally { + n.length = o; + } + } + callParent(e, r = 0) { + let n = ce(this, Ie, $t).call(this, r + 1), o = this.stack.splice(n + 1); + try { + return e(this); + } finally { + this.stack.push(...o); + } + } + each(e, ...r) { + let { stack: n } = this, { length: o } = n, u = y(false, n, -1); + for (let i of r) + u = u[i], n.push(i, u); + try { + for (let i = 0; i < u.length; ++i) + n.push(i, u[i]), e(this, i, u), n.length -= 2; + } finally { + n.length = o; + } + } + map(e, ...r) { + let n = []; + return this.each((o, u, i) => { + n[u] = e(o, u, i); + }, ...r), n; + } + match(...e) { + let r = this.stack.length - 1, n = null, o = this.stack[r--]; + for (let u of e) { + if (o === void 0) + return false; + let i = null; + if (typeof n == "number" && (i = n, n = this.stack[r--], o = this.stack[r--]), u && !u(o, n, i)) + return false; + n = this.stack[r--], o = this.stack[r--]; + } + return true; + } + findAncestor(e) { + for (let r of ce(this, Fe, dt).call(this)) + if (e(r)) + return r; + } + hasAncestor(e) { + for (let r of ce(this, Fe, dt).call(this)) + if (e(r)) + return true; + return false; + } +}; +Ie = /* @__PURE__ */ new WeakSet(), $t = function(e) { + let { stack: r } = this; + for (let n = r.length - 1; n >= 0; n -= 2) + if (!Array.isArray(r[n]) && --e < 0) + return n; + return -1; +}, Fe = /* @__PURE__ */ new WeakSet(), dt = function* () { + let { stack: e } = this; + for (let r = e.length - 3; r >= 0; r -= 2) { + let n = e[r]; + Array.isArray(n) || (yield n); + } +}; +var gn = Vt; +var yn = new Proxy(() => { +}, { get: () => yn }), Re = yn; +function me(t) { + return (e, r, n) => { + let o = !!(n != null && n.backwards); + if (r === false) + return false; + let { length: u } = e, i = r; + for (; i >= 0 && i < u; ) { + let s = e.charAt(i); + if (t instanceof RegExp) { + if (!t.test(s)) + return i; + } else if (!t.includes(s)) + return i; + o ? i-- : i++; + } + return i === -1 || i === u ? i : false; + }; +} +var xn = me(/\s/), N = me(" "), Ft = me(",; "), mt = me(/[^\n\r]/); +function Do(t, e, r) { + let n = !!(r != null && r.backwards); + if (e === false) + return false; + let o = t.charAt(e); + if (n) { + if (t.charAt(e - 1) === "\r" && o === ` +`) + return e - 2; + if (o === ` +` || o === "\r" || o === "\u2028" || o === "\u2029") + return e - 1; + } else { + if (o === "\r" && t.charAt(e + 1) === ` +`) + return e + 2; + if (o === ` +` || o === "\r" || o === "\u2028" || o === "\u2029") + return e + 1; + } + return e; +} +var Y = Do; +function co(t, e, r = {}) { + let n = N(t, r.backwards ? e - 1 : e, r), o = Y(t, n, r); + return n !== o; +} +var V = co; +function lo(t) { + return Array.isArray(t) && t.length > 0; +} +var Ut = lo; +function fo(t) { + return t !== null && typeof t == "object"; +} +var _n = fo; +function* Mt(t, e) { + let { getVisitorKeys: r, filter: n = () => true } = e, o = (u) => _n(u) && n(u); + for (let u of r(t)) { + let i = t[u]; + if (Array.isArray(i)) + for (let s of i) + o(s) && (yield s); + else + o(i) && (yield i); + } +} +function* An(t, e) { + let r = [t]; + for (let n = 0; n < r.length; n++) { + let o = r[n]; + for (let u of Mt(o, e)) + yield u, r.push(u); + } +} +function po(t) { + let e = t.type || t.kind || "(unknown type)", r = String(t.name || t.id && (typeof t.id == "object" ? t.id.name : t.id) || t.key && (typeof t.key == "object" ? t.key.name : t.key) || t.value && (typeof t.value == "object" ? "" : String(t.value)) || t.operator || ""); + return r.length > 20 && (r = r.slice(0, 19) + "…"), e + (r ? " " + r : ""); +} +function Wt(t, e) { + (t.comments ?? (t.comments = [])).push(e), e.printed = false, e.nodeDescription = po(t); +} +function ne(t, e) { + e.leading = true, e.trailing = false, Wt(t, e); +} +function X(t, e, r) { + e.leading = false, e.trailing = false, r && (e.marker = r), Wt(t, e); +} +function ue(t, e) { + e.leading = false, e.trailing = true, Wt(t, e); +} +var zt = /* @__PURE__ */ new WeakMap(); +function Et(t, e) { + if (zt.has(t)) + return zt.get(t); + let { printer: { getCommentChildNodes: r, canAttachComment: n, getVisitorKeys: o }, locStart: u, locEnd: i } = e; + if (!n) + return []; + let s = ((r == null ? void 0 : r(t, e)) ?? [...Mt(t, { getVisitorKeys: H(o) })]).flatMap((a) => n(a) ? [a] : Et(a, e)); + return s.sort((a, D) => u(a) - u(D) || i(a) - i(D)), zt.set(t, s), s; +} +function kn(t, e, r, n) { + let { locStart: o, locEnd: u } = r, i = o(e), s = u(e), a = Et(t, r), D, c, F = 0, f = a.length; + for (; F < f; ) { + let d = F + f >> 1, l = a[d], p = o(l), m = u(l); + if (p <= i && s <= m) + return kn(l, e, r, l); + if (m <= i) { + D = l, F = d + 1; + continue; + } + if (s <= p) { + c = l, f = d; + continue; + } + throw new Error("Comment location overlaps with node location"); + } + if ((n == null ? void 0 : n.type) === "TemplateLiteral") { + let { quasis: d } = n, l = Kt(d, e, r); + D && Kt(d, D, r) !== l && (D = null), c && Kt(d, c, r) !== l && (c = null); + } + return { enclosingNode: n, precedingNode: D, followingNode: c }; +} +var Gt = () => false; +function bn(t, e) { + let { comments: r } = t; + if (delete t.comments, !Ut(r) || !e.printer.canAttachComment) + return; + let n = [], { locStart: o, locEnd: u, printer: { experimentalFeatures: { avoidAstMutation: i = false } = {}, handleComments: s = {} }, originalText: a } = e, { ownLine: D = Gt, endOfLine: c = Gt, remaining: F = Gt } = s, f = r.map((d, l) => ({ ...kn(t, d, e), comment: d, text: a, options: e, ast: t, isLastComment: r.length - 1 === l })); + for (let [d, l] of f.entries()) { + let { comment: p, precedingNode: m, enclosingNode: E, followingNode: h, text: g, options: C, ast: _, isLastComment: Z } = l; + if (C.parser === "json" || C.parser === "json5" || C.parser === "__js_expression" || C.parser === "__ts_expression" || C.parser === "__vue_expression" || C.parser === "__vue_ts_expression") { + if (o(p) - o(_) <= 0) { + ne(_, p); + continue; + } + if (u(p) - u(_) >= 0) { + ue(_, p); + continue; + } + } + let $; + if (i ? $ = [l] : (p.enclosingNode = E, p.precedingNode = m, p.followingNode = h, $ = [p, g, C, _, Z]), Fo(g, C, f, d)) + p.placement = "ownLine", D(...$) || (h ? ne(h, p) : m ? ue(m, p) : E ? X(E, p) : X(_, p)); + else if (mo(g, C, f, d)) + p.placement = "endOfLine", c(...$) || (m ? ue(m, p) : h ? ne(h, p) : E ? X(E, p) : X(_, p)); + else if (p.placement = "remaining", !F(...$)) + if (m && h) { + let Q = n.length; + Q > 0 && n[Q - 1].followingNode !== h && Bn(n, C), n.push(l); + } else + m ? ue(m, p) : h ? ne(h, p) : E ? X(E, p) : X(_, p); + } + if (Bn(n, e), !i) + for (let d of r) + delete d.precedingNode, delete d.enclosingNode, delete d.followingNode; +} +var wn = (t) => !/[\S\n\u2028\u2029]/.test(t); +function Fo(t, e, r, n) { + let { comment: o, precedingNode: u } = r[n], { locStart: i, locEnd: s } = e, a = i(o); + if (u) + for (let D = n - 1; D >= 0; D--) { + let { comment: c, precedingNode: F } = r[D]; + if (F !== u || !wn(t.slice(s(c), a))) + break; + a = i(c); + } + return V(t, a, { backwards: true }); +} +function mo(t, e, r, n) { + let { comment: o, followingNode: u } = r[n], { locStart: i, locEnd: s } = e, a = s(o); + if (u) + for (let D = n + 1; D < r.length; D++) { + let { comment: c, followingNode: F } = r[D]; + if (F !== u || !wn(t.slice(a, i(c)))) + break; + a = s(c); + } + return V(t, a); +} +function Bn(t, e) { + var s, a; + let r = t.length; + if (r === 0) + return; + let { precedingNode: n, followingNode: o } = t[0], u = e.locStart(o), i; + for (i = r; i > 0; --i) { + let { comment: D, precedingNode: c, followingNode: F } = t[i - 1]; + Re.strictEqual(c, n), Re.strictEqual(F, o); + let f = e.originalText.slice(e.locEnd(D), u); + if (((a = (s = e.printer).isGap) == null ? void 0 : a.call(s, f, e)) ?? /^[\s(]*$/.test(f)) + u = e.locStart(D); + else + break; + } + for (let [D, { comment: c }] of t.entries()) + D < i ? ue(n, c) : ne(o, c); + for (let D of [n, o]) + D.comments && D.comments.length > 1 && D.comments.sort((c, F) => e.locStart(c) - e.locStart(F)); + t.length = 0; +} +function Kt(t, e, r) { + let n = r.locStart(e) - 1; + for (let o = 1; o < t.length; ++o) + if (n < r.locStart(t[o])) + return o - 1; + return 0; +} +function Eo(t, e) { + let r = e - 1; + r = N(t, r, { backwards: true }), r = Y(t, r, { backwards: true }), r = N(t, r, { backwards: true }); + let n = Y(t, r, { backwards: true }); + return r !== n; +} +var Ye = Eo; +function On(t, e) { + let r = t.node; + return r.printed = true, e.printer.printComment(t, e); +} +function ho(t, e) { + var c; + let r = t.node, n = [On(t, e)], { printer: o, originalText: u, locStart: i, locEnd: s } = e; + if ((c = o.isBlockComment) == null ? void 0 : c.call(o, r)) { + let F = V(u, s(r)) ? V(u, i(r), { backwards: true }) ? G : Ke : " "; + n.push(F); + } else + n.push(G); + let D = Y(u, N(u, s(r))); + return D !== false && V(u, D) && n.push(G), n; +} +function Co(t, e, r) { + var D; + let n = t.node, o = On(t, e), { printer: u, originalText: i, locStart: s } = e, a = (D = u.isBlockComment) == null ? void 0 : D.call(u, n); + if (r != null && r.hasLineSuffix && !(r != null && r.isBlock) || V(i, s(n), { backwards: true })) { + let c = Ye(i, s(n)); + return { doc: _e([G, c ? G : "", o]), isBlock: a, hasLineSuffix: true }; + } + return !a || r != null && r.hasLineSuffix ? { doc: [_e([" ", o]), le], isBlock: a, hasLineSuffix: true } : { doc: [" ", o], isBlock: a, hasLineSuffix: false }; +} +function go(t, e) { + let r = t.node; + if (!r) + return {}; + let n = e[Symbol.for("printedComments")]; + if ((r.comments || []).filter((a) => !n.has(a)).length === 0) + return { leading: "", trailing: "" }; + let u = [], i = [], s; + return t.each(() => { + let a = t.node; + if (n != null && n.has(a)) + return; + let { leading: D, trailing: c } = a; + D ? u.push(ho(t, e)) : c && (s = Co(t, e, s), i.push(s.doc)); + }, "comments"), { leading: u, trailing: i }; +} +function Nn(t, e, r) { + let { leading: n, trailing: o } = go(t, r); + return !n && !o ? e : Ze(e, (u) => [n, u, o]); +} +function Tn(t) { + let { [Symbol.for("comments")]: e, [Symbol.for("printedComments")]: r } = t; + for (let n of e) { + if (!n.printed && !r.has(n)) + throw new Error('Comment "' + n.value.trim() + '" was not printed. Please report this error!'); + delete n.printed; + } +} +async function Sn(t, e, r, n, o) { + let { embeddedLanguageFormatting: u, printer: { embed: i, hasPrettierIgnore: s = () => false, getVisitorKeys: a } } = r; + if (!i || u !== "auto") + return; + if (i.length > 2) + throw new Error("printer.embed has too many parameters. The API changed in Prettier v3. Please update your plugin. See https://prettier.io/docs/en/plugins.html#optional-embed"); + let D = H(i.getVisitorKeys ?? a), c = []; + d(); + let F = t.stack; + for (let { print: l, node: p, pathStack: m } of c) + try { + t.stack = m; + let E = await l(f, e, t, r); + E && o.set(p, E); + } catch (E) { + if (globalThis.PRETTIER_DEBUG) + throw E; + } + t.stack = F; + function f(l, p) { + return yo(l, p, r, n); + } + function d() { + let { node: l } = t; + if (l === null || typeof l != "object" || s(t)) + return; + for (let m of D(l)) + Array.isArray(l[m]) ? t.each(d, m) : t.call(d, m); + let p = i(t, r); + if (p) { + if (typeof p == "function") { + c.push({ print: p, node: l, pathStack: [...t.stack] }); + return; + } + o.set(l, p); + } + } +} +async function yo(t, e, r, n) { + let o = await re({ ...r, ...e, parentParser: r.parser, originalText: t }, { passThrough: true }), { ast: u } = await ae(t, o), i = await n(u, o); + return Xe(i); +} +function _o(t, e) { + let { originalText: r, [Symbol.for("comments")]: n, locStart: o, locEnd: u, [Symbol.for("printedComments")]: i } = e, { node: s } = t, a = o(s), D = u(s); + for (let c of n) + o(c) >= a && u(c) <= D && i.add(c); + return r.slice(a, D); +} +var Pn = _o; +async function je(t, e) { + ({ ast: t } = await Ht(t, e)); + let r = /* @__PURE__ */ new Map(), n = new gn(t), u = /* @__PURE__ */ new Map(); + await Sn(n, s, e, je, u); + let i = await Ln(n, e, s, void 0, u); + return Tn(e), i; + function s(D, c) { + return D === void 0 || D === n ? a(c) : Array.isArray(D) ? n.call(() => a(c), ...D) : n.call(() => a(c), D); + } + function a(D) { + let c = n.node; + if (c == null) + return ""; + let F = c && typeof c == "object" && D === void 0; + if (F && r.has(c)) + return r.get(c); + let f = Ln(n, e, s, D, u); + return F && r.set(c, f), f; + } +} +function Ln(t, e, r, n, o) { + var a; + let { node: u } = t, { printer: i } = e, s; + return (a = i.hasPrettierIgnore) != null && a.call(i, t) ? s = Pn(t, e) : o.has(u) ? s = o.get(u) : s = i.print(t, e, r, n), u === e.cursorNode && (s = Ze(s, (D) => [Be, D, Be])), i.printComment && (!i.willPrintOwnComments || !i.willPrintOwnComments(t, e)) && (s = Nn(t, s, e)), s; +} +async function Ht(t, e) { + let r = t.comments ?? []; + e[Symbol.for("comments")] = r, e[Symbol.for("tokens")] = t.tokens ?? [], e[Symbol.for("printedComments")] = /* @__PURE__ */ new Set(), bn(t, e); + let { printer: { preprocess: n } } = e; + return t = n ? await n(t, e) : t, { ast: t, comments: r }; +} +var Ao = ({ parser: t }) => t === "json" || t === "json5" || t === "json-stringify"; +function Bo(t, e) { + let r = [t.node, ...t.parentNodes], n = /* @__PURE__ */ new Set([e.node, ...e.parentNodes]); + return r.find((o) => Yn.has(o.type) && n.has(o)); +} +function In(t) { + let e = t.length - 1; + for (; ; ) { + let r = t[e]; + if ((r == null ? void 0 : r.type) === "Program" || (r == null ? void 0 : r.type) === "File") + e--; + else + break; + } + return t.slice(0, e + 1); +} +function ko(t, e, { locStart: r, locEnd: n }) { + let o = t.node, u = e.node; + if (o === u) + return { startNode: o, endNode: u }; + let i = r(t.node); + for (let a of In(e.parentNodes)) + if (r(a) >= i) + u = a; + else + break; + let s = n(e.node); + for (let a of In(t.parentNodes)) { + if (n(a) <= s) + o = a; + else + break; + if (o === u) + break; + } + return { startNode: o, endNode: u }; +} +function qt(t, e, r, n, o = [], u) { + let { locStart: i, locEnd: s } = r, a = i(t), D = s(t); + if (!(e > D || e < a || u === "rangeEnd" && e === a || u === "rangeStart" && e === D)) { + for (let c of Et(t, r)) { + let F = qt(c, e, r, n, [t, ...o], u); + if (F) + return F; + } + if (!n || n(t, o[0])) + return { node: t, parentNodes: o }; + } +} +function bo(t, e) { + return e !== "DeclareExportDeclaration" && t !== "TypeParameterDeclaration" && (t === "Directive" || t === "TypeAlias" || t === "TSExportAssignment" || t.startsWith("Declare") || t.startsWith("TSDeclare") || t.endsWith("Statement") || t.endsWith("Declaration")); +} +var Yn = /* @__PURE__ */ new Set(["JsonRoot", "ObjectExpression", "ArrayExpression", "StringLiteral", "NumericLiteral", "BooleanLiteral", "NullLiteral", "UnaryExpression", "TemplateLiteral"]), wo = /* @__PURE__ */ new Set(["OperationDefinition", "FragmentDefinition", "VariableDefinition", "TypeExtensionDefinition", "ObjectTypeDefinition", "FieldDefinition", "DirectiveDefinition", "EnumTypeDefinition", "EnumValueDefinition", "InputValueDefinition", "InputObjectTypeDefinition", "SchemaDefinition", "OperationTypeDefinition", "InterfaceTypeDefinition", "UnionTypeDefinition", "ScalarTypeDefinition"]); +function Rn(t, e, r) { + if (!e) + return false; + switch (t.parser) { + case "flow": + case "babel": + case "babel-flow": + case "babel-ts": + case "typescript": + case "acorn": + case "espree": + case "meriyah": + case "__babel_estree": + return bo(e.type, r == null ? void 0 : r.type); + case "json": + case "json5": + case "json-stringify": + return Yn.has(e.type); + case "graphql": + return wo.has(e.kind); + case "vue": + return e.tag !== "root"; + } + return false; +} +function jn(t, e, r) { + let { rangeStart: n, rangeEnd: o, locStart: u, locEnd: i } = e; + Re.ok(o > n); + let s = t.slice(n, o).search(/\S/), a = s === -1; + if (!a) + for (n += s; o > n && !/\S/.test(t[o - 1]); --o) + ; + let D = qt(r, n, e, (d, l) => Rn(e, d, l), [], "rangeStart"), c = a ? D : qt(r, o, e, (d) => Rn(e, d), [], "rangeEnd"); + if (!D || !c) + return { rangeStart: 0, rangeEnd: 0 }; + let F, f; + if (Ao(e)) { + let d = Bo(D, c); + F = d, f = d; + } else + ({ startNode: F, endNode: f } = ko(D, c, e)); + return { rangeStart: Math.min(u(F), u(f)), rangeEnd: Math.max(i(F), i(f)) }; +} +function Oo(t, e) { + let { cursorOffset: r, locStart: n, locEnd: o } = e, u = H(e.printer.getVisitorKeys), i = (a) => n(a) <= r && o(a) >= r, s = t; + for (let a of An(t, { getVisitorKeys: u, filter: i })) + s = a; + return s; +} +var Vn = Oo; +var zn = "\uFEFF", $n = Symbol("cursor"); +async function Gn(t, e, r = 0) { + if (!t || t.trim().length === 0) + return { formatted: "", cursorOffset: -1, comments: [] }; + let { ast: n, text: o } = await ae(t, e); + e.cursorOffset >= 0 && (e.cursorNode = Vn(n, e)); + let u = await je(n, e); + r > 0 && (u = qe([G, u], r, e.tabWidth)); + let i = fe(u, e); + if (r > 0) { + let a = i.formatted.trim(); + i.cursorNodeStart !== void 0 && (i.cursorNodeStart -= i.formatted.indexOf(a)), i.formatted = a + be(e.endOfLine); + } + let s = e[Symbol.for("comments")]; + if (e.cursorOffset >= 0) { + let a, D, c, F, f; + if (e.cursorNode && i.cursorNodeText ? (a = e.locStart(e.cursorNode), D = o.slice(a, e.locEnd(e.cursorNode)), c = e.cursorOffset - a, F = i.cursorNodeStart, f = i.cursorNodeText) : (a = 0, D = o, c = e.cursorOffset, F = 0, f = i.formatted), D === f) + return { formatted: i.formatted, cursorOffset: F + c, comments: s }; + let d = D.split(""); + d.splice(c, 0, $n); + let l = f.split(""), p = (0, Wn.diffArrays)(d, l), m = F; + for (let E of p) + if (E.removed) { + if (E.value.includes($n)) + break; + } else + m += E.count; + return { formatted: i.formatted, cursorOffset: m, comments: s }; + } + return { formatted: i.formatted, cursorOffset: -1, comments: s }; +} +async function No(t, e) { + let { ast: r, text: n } = await ae(t, e), { rangeStart: o, rangeEnd: u } = jn(n, e, r), i = n.slice(o, u), s = Math.min(o, n.lastIndexOf(` +`, o) + 1), a = n.slice(s, o).match(/^\s*/)[0], D = pe(a, e.tabWidth), c = await Gn(i, { ...e, rangeStart: 0, rangeEnd: Number.POSITIVE_INFINITY, cursorOffset: e.cursorOffset > o && e.cursorOffset <= u ? e.cursorOffset - o : -1, endOfLine: "lf" }, D), F = c.formatted.trimEnd(), { cursorOffset: f } = e; + f > u ? f += F.length - i.length : c.cursorOffset >= 0 && (f = c.cursorOffset + o); + let d = n.slice(0, o) + F + n.slice(u); + if (e.endOfLine !== "lf") { + let l = be(e.endOfLine); + f >= 0 && l === `\r +` && (f += At(d.slice(0, f), ` +`)), d = ee(false, d, ` +`, l); + } + return { formatted: d, cursorOffset: f, comments: c.comments }; +} +function Jt(t, e, r) { + return typeof e != "number" || Number.isNaN(e) || e < 0 || e > t.length ? r : e; +} +function Un(t, e) { + let { cursorOffset: r, rangeStart: n, rangeEnd: o } = e; + return r = Jt(t, r, -1), n = Jt(t, n, 0), o = Jt(t, o, t.length), { ...e, cursorOffset: r, rangeStart: n, rangeEnd: o }; +} +function Kn(t, e) { + let { cursorOffset: r, rangeStart: n, rangeEnd: o, endOfLine: u } = Un(t, e), i = t.charAt(0) === zn; + if (i && (t = t.slice(1), r--, n--, o--), u === "auto" && (u = Cr(t)), t.includes("\r")) { + let s = (a) => At(t.slice(0, Math.max(a, 0)), `\r +`); + r -= s(r), n -= s(n), o -= s(o), t = gr(t); + } + return { hasBOM: i, text: t, options: Un(t, { ...e, cursorOffset: r, rangeStart: n, rangeEnd: o, endOfLine: u }) }; +} +async function Mn(t, e) { + let r = await ft(e); + return !r.hasPragma || r.hasPragma(t); +} +async function Xt(t, e) { + let { hasBOM: r, text: n, options: o } = Kn(t, await re(e)); + if (o.rangeStart >= o.rangeEnd && n !== "" || o.requirePragma && !await Mn(n, o)) + return { formatted: t, cursorOffset: e.cursorOffset, comments: [] }; + let u; + return o.rangeStart > 0 || o.rangeEnd < n.length ? u = await No(n, o) : (!o.requirePragma && o.insertPragma && o.printer.insertPragma && !await Mn(n, o) && (n = o.printer.insertPragma(n)), u = await Gn(n, o)), r && (u.formatted = zn + u.formatted, u.cursorOffset >= 0 && u.cursorOffset++), u; +} +async function Hn(t, e, r) { + let { text: n, options: o } = Kn(t, await re(e)), u = await ae(n, o); + return r && (r.preprocessForPrint && (u.ast = await Ht(u.ast, o)), r.massage && (u.ast = cn(u.ast, o))), u; +} +async function qn(t, e) { + e = await re(e); + let r = await je(t, e); + return fe(r, e); +} +async function Jn(t, e) { + let r = Sr(t), { formatted: n } = await Xt(r, { ...e, parser: "__js_expression" }); + return n; +} +async function Xn(t, e) { + e = await re(e); + let { ast: r } = await ae(t, e); + return je(r, e); +} +async function Zn(t, e) { + return fe(t, await re(e)); +} +var Qt = {}; +Me(Qt, { addDanglingComment: () => X, addLeadingComment: () => ne, addTrailingComment: () => ue, getAlignmentSize: () => pe, getIndentSize: () => eu, getMaxContinuousCount: () => Qn, getNextNonSpaceNonCommentCharacter: () => nu, getNextNonSpaceNonCommentCharacterIndex: () => Mo, getStringWidth: () => we, hasNewline: () => V, hasNewlineInRange: () => tu, hasSpaces: () => ru, isNextLineEmpty: () => Ko, isNextLineEmptyAfterIndex: () => ht, isPreviousLineEmpty: () => zo, makeString: () => uu, skip: () => me, skipEverythingButNewLine: () => mt, skipInlineComment: () => Ee, skipNewline: () => Y, skipSpaces: () => N, skipToLineEnd: () => Ft, skipTrailingComment: () => he, skipWhitespace: () => xn }); +function So(t, e) { + if (e === false) + return false; + if (t.charAt(e) === "/" && t.charAt(e + 1) === "*") { + for (let r = e + 2; r < t.length; ++r) + if (t.charAt(r) === "*" && t.charAt(r + 1) === "/") + return r + 2; + } + return e; +} +var Ee = So; +function vo(t, e) { + return e === false ? false : t.charAt(e) === "/" && t.charAt(e + 1) === "/" ? mt(t, e) : e; +} +var he = vo; +function Po(t, e) { + let r = null, n = e; + for (; n !== r; ) + r = n, n = N(t, n), n = Ee(t, n), n = he(t, n), n = Y(t, n); + return n; +} +var Ve = Po; +function Lo(t, e) { + let r = null, n = e; + for (; n !== r; ) + r = n, n = Ft(t, n), n = Ee(t, n), n = N(t, n); + return n = he(t, n), n = Y(t, n), n !== false && V(t, n); +} +var ht = Lo; +function Zt(t) { + if (typeof t != "string") + throw new TypeError("Expected a string"); + return t.replace(/[|\\{}()[\]^$+*?.]/g, "\\$&").replace(/-/g, "\\x2d"); +} +function Io(t, e) { + let r = t.match(new RegExp(`(${Zt(e)})+`, "g")); + return r === null ? 0 : r.reduce((n, o) => Math.max(n, o.length / e.length), 0); +} +var Qn = Io; +function Ro(t, e) { + let r = t.lastIndexOf(` +`); + return r === -1 ? 0 : pe(t.slice(r + 1).match(/^[\t ]*/)[0], e); +} +var eu = Ro; +function Yo(t, e, r) { + for (let n = e; n < r; ++n) + if (t.charAt(n) === ` +`) + return true; + return false; +} +var tu = Yo; +function jo(t, e, r = {}) { + return N(t, r.backwards ? e - 1 : e, r) !== e; +} +var ru = jo; +function Vo(t, e) { + let r = Ve(t, e); + return r === false ? "" : t.charAt(r); +} +var nu = Vo; +function $o(t, e, r) { + let n = e === '"' ? "'" : '"', u = ee(false, t, /\\(.)|(["'])/gs, (i, s, a) => s === n ? s : a === e ? "\\" + a : a || (r && /^[^\n\r"'0-7\\bfnrt-vx\u2028\u2029]$/.test(s) ? s : "\\" + s)); + return e + u + e; +} +var uu = $o; +function Uo(t, e, r) { + return Ve(t, r(e)); +} +function Mo(t, e) { + return arguments.length === 2 || typeof e == "number" ? Ve(t, e) : Uo(...arguments); +} +function Wo(t, e, r) { + return Ye(t, r(e)); +} +function zo(t, e) { + return arguments.length === 2 || typeof e == "number" ? Ye(t, e) : Wo(...arguments); +} +function Go(t, e, r) { + return ht(t, r(e)); +} +function Ko(t, e) { + return arguments.length === 2 || typeof e == "number" ? ht(t, e) : Go(...arguments); +} +var er = {}; +Me(er, { builders: () => Ho, printer: () => qo, utils: () => Jo }); +var Ho = { join: ke, line: Ke, softline: Er, hardline: G, literalline: He, group: xt, conditionalGroup: fr, fill: Ge, lineSuffix: _e, lineSuffixBoundary: Fr, cursor: Be, breakParent: le, ifBreak: pr, trim: mr, indent: ie, indentIfBreak: dr, align: oe, addAlignmentToDoc: qe, markAsRoot: cr, dedentToRoot: Dr, dedent: lr, hardlineWithoutBreakParent: Ae, literallineWithoutBreakParent: _t, label: hr, concat: (t) => t }, qo = { printDocToString: fe }, Jo = { willBreak: kr, traverseDoc: xe, findInDoc: Je, mapDoc: Ne, removeLines: wr, stripTrailingHardline: Xe, replaceEndOfLine: Or, canBreak: Nr }; +var ou = "3.0.3"; +function De(t, e = 1) { + return async (...r) => { + let n = r[e] ?? {}, o = n.plugins ?? []; + return r[e] = { ...n, plugins: Array.isArray(o) ? o : Object.values(o) }, t(...r); + }; +} +var iu = De(Xt); +async function su(t, e) { + let { formatted: r } = await iu(t, { ...e, cursorOffset: -1 }); + return r; +} +async function Xo(t, e) { + return await su(t, e) === t; +} +var Zo = De(et, 0), Qo = { parse: De(Hn), formatAST: De(qn), formatDoc: De(Jn), printToDoc: De(Xn), printDocToString: De(Zn) }; +var Uc = tr; +const standalone = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({ + __proto__: null, + __debug: Qo, + check: Xo, + default: Uc, + doc: er, + format: su, + formatWithCursor: iu, + getSupportInfo: Zo, + util: Qt, + version: ou +}, Symbol.toStringTag, { value: "Module" })); +async function printPrettier(source = "", options = {}) { + return await su(source, { + printWidth: 80, + useTabs: true, + ...options, + parser: "latex-parser", + plugins: [prettierPluginLatex.prettierPluginLatex] + }); +} +exports.Prettier = standalone; +exports.printPrettier = printPrettier; +//# sourceMappingURL=standalone.js.map diff --git a/node_modules/prettier-plugin-latex/dist/standalone.js.map b/node_modules/prettier-plugin-latex/dist/standalone.js.map new file mode 100644 index 0000000..166efd6 --- /dev/null +++ b/node_modules/prettier-plugin-latex/dist/standalone.js.map @@ -0,0 +1 @@ +{"version":3,"file":"standalone.js","sources":["../node_modules/prettier/standalone.mjs","../src/standalone.ts"],"sourcesContent":["var au=Object.create;var $e=Object.defineProperty;var Du=Object.getOwnPropertyDescriptor;var cu=Object.getOwnPropertyNames;var lu=Object.getPrototypeOf,fu=Object.prototype.hasOwnProperty;var pu=(t,e)=>()=>(t&&(e=t(t=0)),e);var Ue=(t,e)=>()=>(e||t((e={exports:{}}).exports,e),e.exports),Me=(t,e)=>{for(var r in e)$e(t,r,{get:e[r],enumerable:!0})},nr=(t,e,r,n)=>{if(e&&typeof e==\"object\"||typeof e==\"function\")for(let o of cu(e))!fu.call(t,o)&&o!==r&&$e(t,o,{get:()=>e[o],enumerable:!(n=Du(e,o))||n.enumerable});return t};var Ce=(t,e,r)=>(r=t!=null?au(lu(t)):{},nr(e||!t||!t.__esModule?$e(r,\"default\",{value:t,enumerable:!0}):r,t)),du=t=>nr($e({},\"__esModule\",{value:!0}),t);var Fu=(t,e,r)=>{if(!e.has(t))throw TypeError(\"Cannot \"+r)};var Ct=(t,e,r)=>{if(e.has(t))throw TypeError(\"Cannot add the same private member more than once\");e instanceof WeakSet?e.add(t):e.set(t,r)};var ce=(t,e,r)=>(Fu(t,e,\"access private method\"),r);var or=Ue(gt=>{\"use strict\";Object.defineProperty(gt,\"__esModule\",{value:!0});gt.default=ur;function ur(){}ur.prototype={diff:function(e,r){var n=arguments.length>2&&arguments[2]!==void 0?arguments[2]:{},o=n.callback;typeof n==\"function\"&&(o=n,n={}),this.options=n;var u=this;function i(p){return o?(setTimeout(function(){o(void 0,p)},0),!0):p}e=this.castInput(e),r=this.castInput(r),e=this.removeEmpty(this.tokenize(e)),r=this.removeEmpty(this.tokenize(r));var s=r.length,a=e.length,D=1,c=s+a;n.maxEditLength&&(c=Math.min(c,n.maxEditLength));var F=[{newPos:-1,components:[]}],f=this.extractCommon(F[0],r,e,0);if(F[0].newPos+1>=s&&f+1>=a)return i([{value:this.join(r),count:r.length}]);function d(){for(var p=-1*D;p<=D;p+=2){var m=void 0,E=F[p-1],h=F[p+1],g=(h?h.newPos:0)-p;E&&(F[p-1]=void 0);var C=E&&E.newPos+1=s&&g+1>=a)return i(Eu(u,m.components,r,e,u.useLongestToken));F[p]=m}D++}if(o)(function p(){setTimeout(function(){if(D>c)return o();d()||p()},0)})();else for(;D<=c;){var l=d();if(l)return l}},pushComponent:function(e,r,n){var o=e[e.length-1];o&&o.added===r&&o.removed===n?e[e.length-1]={count:o.count+1,added:r,removed:n}:e.push({count:1,added:r,removed:n})},extractCommon:function(e,r,n,o){for(var u=r.length,i=n.length,s=e.newPos,a=s-o,D=0;s+1d.length?p:d}),D.value=t.join(c)}else D.value=t.join(r.slice(s,s+D.count));s+=D.count,D.added||(a+=D.count)}}var f=e[i-1];return i>1&&typeof f.value==\"string\"&&(f.added||f.removed)&&t.equals(\"\",f.value)&&(e[i-2].value+=f.value,e.pop()),e}function hu(t){return{newPos:t.newPos,components:t.components.slice(0)}}});var ir=Ue(ye=>{\"use strict\";Object.defineProperty(ye,\"__esModule\",{value:!0});ye.diffArrays=yu;ye.arrayDiff=void 0;var Cu=gu(or());function gu(t){return t&&t.__esModule?t:{default:t}}var ge=new Cu.default;ye.arrayDiff=ge;ge.tokenize=function(t){return t.slice()};ge.join=ge.removeEmpty=function(t){return t};function yu(t,e,r){return ge.diff(t,e,r)}});var Pe=Ue((ss,Rr)=>{\"use strict\";var Ir=new Proxy(String,{get:()=>Ir});Rr.exports=Ir});var ln={};Me(ln,{default:()=>to,shouldHighlight:()=>eo});var eo,to,fn=pu(()=>{eo=()=>!1,to=String});var hn=Ue(pt=>{\"use strict\";Object.defineProperty(pt,\"__esModule\",{value:!0});pt.codeFrameColumns=En;pt.default=io;var pn=(fn(),du(ln)),ro=Pe(),dn=ro,jt;function no(t){if(t){var e;return(e=jt)!=null||(jt=new dn.constructor({enabled:!0,level:1})),jt}return dn}var Fn=!1;function uo(t){return{gutter:t.grey,marker:t.red.bold,message:t.red.bold}}var mn=/\\r\\n|[\\n\\r\\u2028\\u2029]/;function oo(t,e,r){let n=Object.assign({column:0,line:-1},t.start),o=Object.assign({},n,t.end),{linesAbove:u=2,linesBelow:i=3}=r||{},s=n.line,a=n.column,D=o.line,c=o.column,F=Math.max(s-(u+1),0),f=Math.min(e.length,D+i);s===-1&&(F=0),D===-1&&(f=e.length);let d=D-s,l={};if(d)for(let p=0;p<=d;p++){let m=p+s;if(!a)l[m]=!0;else if(p===0){let E=e[m-1].length;l[m]=[a,E-a+1]}else if(p===d)l[m]=[0,c];else{let E=e[m-p].length;l[m]=[0,E]}}else a===c?a?l[s]=[a,0]:l[s]=!0:l[s]=[a,c-a];return{start:F,end:f,markerLines:l}}function En(t,e,r={}){let n=(r.highlightCode||r.forceColor)&&(0,pn.shouldHighlight)(r),o=no(r.forceColor),u=uo(o),i=(p,m)=>n?p(m):m,s=t.split(mn),{start:a,end:D,markerLines:c}=oo(e,s,r),F=e.start&&typeof e.start.column==\"number\",f=String(D).length,l=(n?(0,pn.default)(t,r):t).split(mn,D).slice(a,D).map((p,m)=>{let E=a+1+m,g=` ${` ${E}`.slice(-f)} |`,C=c[E],_=!c[E+1];if(C){let Z=\"\";if(Array.isArray(C)){let $=p.slice(0,Math.max(C[0]-1,0)).replace(/[^\\t]/g,\" \"),Q=C[1]||1;Z=[`\n `,i(u.gutter,g.replace(/\\d/g,\" \")),\" \",$,i(u.marker,\"^\").repeat(Q)].join(\"\"),_&&r.message&&(Z+=\" \"+i(u.message,r.message))}return[i(u.marker,\">\"),i(u.gutter,g),p.length>0?` ${p}`:\"\",Z].join(\"\")}else return` ${i(u.gutter,g)}${p.length>0?` ${p}`:\"\"}`}).join(`\n`);return r.message&&!F&&(l=`${\" \".repeat(f+1)}${r.message}\n${l}`),n?o.reset(l):l}function io(t,e,r,n={}){if(!Fn){Fn=!0;let u=\"Passing lineNumber and colNumber is deprecated to @babel/code-frame. Please use `codeFrameColumns`.\";{let i=new Error(u);i.name=\"DeprecationWarning\",console.warn(new Error(u))}}return r=Math.max(r,0),En(t,{start:{column:r,line:e}},n)}});var tr={};Me(tr,{__debug:()=>Qo,check:()=>Xo,doc:()=>er,format:()=>su,formatWithCursor:()=>iu,getSupportInfo:()=>Zo,util:()=>Qt,version:()=>ou});var mu=(t,e,r,n)=>{if(!(t&&e==null))return e.replaceAll?e.replaceAll(r,n):r.global?e.replace(r,n):e.split(r).join(n)},ee=mu;var Wn=Ce(ir(),1);var U=\"string\",j=\"array\",M=\"cursor\",T=\"indent\",S=\"align\",v=\"trim\",A=\"group\",k=\"fill\",B=\"if-break\",P=\"indent-if-break\",L=\"line-suffix\",I=\"line-suffix-boundary\",x=\"line\",O=\"label\",b=\"break-parent\",We=new Set([M,T,S,v,A,k,B,P,L,I,x,O,b]);function xu(t){if(typeof t==\"string\")return U;if(Array.isArray(t))return j;if(!t)return;let{type:e}=t;if(We.has(e))return e}var W=xu;var _u=t=>new Intl.ListFormat(\"en-US\",{type:\"disjunction\"}).format(t);function Au(t){let e=t===null?\"null\":typeof t;if(e!==\"string\"&&e!==\"object\")return`Unexpected doc '${e}', \nExpected it to be 'string' or 'object'.`;if(W(t))throw new Error(\"doc is valid.\");let r=Object.prototype.toString.call(t);if(r!==\"[object Object]\")return`Unexpected doc '${r}'.`;let n=_u([...We].map(o=>`'${o}'`));return`Unexpected doc.type '${t.type}'.\nExpected it to be ${n}.`}var yt=class extends Error{name=\"InvalidDocError\";constructor(e){super(Au(e)),this.doc=e}},q=yt;var sr={};function Bu(t,e,r,n){let o=[t];for(;o.length>0;){let u=o.pop();if(u===sr){r(o.pop());continue}r&&o.push(u,sr);let i=W(u);if(!i)throw new q(u);if((e==null?void 0:e(u))!==!1)switch(i){case j:case k:{let s=i===j?u:u.parts;for(let a=s.length,D=a-1;D>=0;--D)o.push(s[D]);break}case B:o.push(u.flatContents,u.breakContents);break;case A:if(n&&u.expandedStates)for(let s=u.expandedStates.length,a=s-1;a>=0;--a)o.push(u.expandedStates[a]);else o.push(u.contents);break;case S:case T:case P:case O:case L:o.push(u.contents);break;case U:case M:case v:case I:case x:case b:break;default:throw new q(u)}}}var xe=Bu;var ar=()=>{},z=ar,ze=ar;function ie(t){return z(t),{type:T,contents:t}}function oe(t,e){return z(e),{type:S,contents:e,n:t}}function xt(t,e={}){return z(t),ze(e.expandedStates,!0),{type:A,id:e.id,contents:t,break:!!e.shouldBreak,expandedStates:e.expandedStates}}function Dr(t){return oe(Number.NEGATIVE_INFINITY,t)}function cr(t){return oe({type:\"root\"},t)}function lr(t){return oe(-1,t)}function fr(t,e){return xt(t[0],{...e,expandedStates:t})}function Ge(t){return ze(t),{type:k,parts:t}}function pr(t,e=\"\",r={}){return z(t),e!==\"\"&&z(e),{type:B,breakContents:t,flatContents:e,groupId:r.groupId}}function dr(t,e){return z(t),{type:P,contents:t,groupId:e.groupId,negate:e.negate}}function _e(t){return z(t),{type:L,contents:t}}var Fr={type:I},le={type:b},mr={type:v},Ae={type:x,hard:!0},_t={type:x,hard:!0,literal:!0},Ke={type:x},Er={type:x,soft:!0},G=[Ae,le],He=[_t,le],Be={type:M};function ke(t,e){z(t),ze(e);let r=[];for(let n=0;n0){for(let o=0;o{if(!(t&&e==null))return Array.isArray(e)||typeof e==\"string\"?e[r<0?e.length+r:r]:e.at(r)},y=ku;function Cr(t){let e=t.indexOf(\"\\r\");return e>=0?t.charAt(e+1)===`\n`?\"crlf\":\"cr\":\"lf\"}function be(t){switch(t){case\"cr\":return\"\\r\";case\"crlf\":return`\\r\n`;default:return`\n`}}function At(t,e){let r;switch(e){case`\n`:r=/\\n/g;break;case\"\\r\":r=/\\r/g;break;case`\\r\n`:r=/\\r\\n/g;break;default:throw new Error(`Unexpected \"eol\" ${JSON.stringify(e)}.`)}let n=t.match(r);return n?n.length:0}function gr(t){return ee(!1,t,/\\r\\n?/g,`\n`)}var yr=()=>/[#*0-9]\\uFE0F?\\u20E3|[\\xA9\\xAE\\u203C\\u2049\\u2122\\u2139\\u2194-\\u2199\\u21A9\\u21AA\\u231A\\u231B\\u2328\\u23CF\\u23ED-\\u23EF\\u23F1\\u23F2\\u23F8-\\u23FA\\u24C2\\u25AA\\u25AB\\u25B6\\u25C0\\u25FB\\u25FC\\u25FE\\u2600-\\u2604\\u260E\\u2611\\u2614\\u2615\\u2618\\u2620\\u2622\\u2623\\u2626\\u262A\\u262E\\u262F\\u2638-\\u263A\\u2640\\u2642\\u2648-\\u2653\\u265F\\u2660\\u2663\\u2665\\u2666\\u2668\\u267B\\u267E\\u267F\\u2692\\u2694-\\u2697\\u2699\\u269B\\u269C\\u26A0\\u26A7\\u26AA\\u26B0\\u26B1\\u26BD\\u26BE\\u26C4\\u26C8\\u26CF\\u26D1\\u26D3\\u26E9\\u26F0-\\u26F5\\u26F7\\u26F8\\u26FA\\u2702\\u2708\\u2709\\u270F\\u2712\\u2714\\u2716\\u271D\\u2721\\u2733\\u2734\\u2744\\u2747\\u2757\\u2763\\u27A1\\u2934\\u2935\\u2B05-\\u2B07\\u2B1B\\u2B1C\\u2B55\\u3030\\u303D\\u3297\\u3299]\\uFE0F?|[\\u261D\\u270C\\u270D](?:\\uFE0F|\\uD83C[\\uDFFB-\\uDFFF])?|[\\u270A\\u270B](?:\\uD83C[\\uDFFB-\\uDFFF])?|[\\u23E9-\\u23EC\\u23F0\\u23F3\\u25FD\\u2693\\u26A1\\u26AB\\u26C5\\u26CE\\u26D4\\u26EA\\u26FD\\u2705\\u2728\\u274C\\u274E\\u2753-\\u2755\\u2795-\\u2797\\u27B0\\u27BF\\u2B50]|\\u26F9(?:\\uFE0F|\\uD83C[\\uDFFB-\\uDFFF])?(?:\\u200D[\\u2640\\u2642]\\uFE0F?)?|\\u2764\\uFE0F?(?:\\u200D(?:\\uD83D\\uDD25|\\uD83E\\uDE79))?|\\uD83C(?:[\\uDC04\\uDD70\\uDD71\\uDD7E\\uDD7F\\uDE02\\uDE37\\uDF21\\uDF24-\\uDF2C\\uDF36\\uDF7D\\uDF96\\uDF97\\uDF99-\\uDF9B\\uDF9E\\uDF9F\\uDFCD\\uDFCE\\uDFD4-\\uDFDF\\uDFF5\\uDFF7]\\uFE0F?|[\\uDF85\\uDFC2\\uDFC7](?:\\uD83C[\\uDFFB-\\uDFFF])?|[\\uDFC3\\uDFC4\\uDFCA](?:\\uD83C[\\uDFFB-\\uDFFF])?(?:\\u200D[\\u2640\\u2642]\\uFE0F?)?|[\\uDFCB\\uDFCC](?:\\uFE0F|\\uD83C[\\uDFFB-\\uDFFF])?(?:\\u200D[\\u2640\\u2642]\\uFE0F?)?|[\\uDCCF\\uDD8E\\uDD91-\\uDD9A\\uDE01\\uDE1A\\uDE2F\\uDE32-\\uDE36\\uDE38-\\uDE3A\\uDE50\\uDE51\\uDF00-\\uDF20\\uDF2D-\\uDF35\\uDF37-\\uDF7C\\uDF7E-\\uDF84\\uDF86-\\uDF93\\uDFA0-\\uDFC1\\uDFC5\\uDFC6\\uDFC8\\uDFC9\\uDFCF-\\uDFD3\\uDFE0-\\uDFF0\\uDFF8-\\uDFFF]|\\uDDE6\\uD83C[\\uDDE8-\\uDDEC\\uDDEE\\uDDF1\\uDDF2\\uDDF4\\uDDF6-\\uDDFA\\uDDFC\\uDDFD\\uDDFF]|\\uDDE7\\uD83C[\\uDDE6\\uDDE7\\uDDE9-\\uDDEF\\uDDF1-\\uDDF4\\uDDF6-\\uDDF9\\uDDFB\\uDDFC\\uDDFE\\uDDFF]|\\uDDE8\\uD83C[\\uDDE6\\uDDE8\\uDDE9\\uDDEB-\\uDDEE\\uDDF0-\\uDDF5\\uDDF7\\uDDFA-\\uDDFF]|\\uDDE9\\uD83C[\\uDDEA\\uDDEC\\uDDEF\\uDDF0\\uDDF2\\uDDF4\\uDDFF]|\\uDDEA\\uD83C[\\uDDE6\\uDDE8\\uDDEA\\uDDEC\\uDDED\\uDDF7-\\uDDFA]|\\uDDEB\\uD83C[\\uDDEE-\\uDDF0\\uDDF2\\uDDF4\\uDDF7]|\\uDDEC\\uD83C[\\uDDE6\\uDDE7\\uDDE9-\\uDDEE\\uDDF1-\\uDDF3\\uDDF5-\\uDDFA\\uDDFC\\uDDFE]|\\uDDED\\uD83C[\\uDDF0\\uDDF2\\uDDF3\\uDDF7\\uDDF9\\uDDFA]|\\uDDEE\\uD83C[\\uDDE8-\\uDDEA\\uDDF1-\\uDDF4\\uDDF6-\\uDDF9]|\\uDDEF\\uD83C[\\uDDEA\\uDDF2\\uDDF4\\uDDF5]|\\uDDF0\\uD83C[\\uDDEA\\uDDEC-\\uDDEE\\uDDF2\\uDDF3\\uDDF5\\uDDF7\\uDDFC\\uDDFE\\uDDFF]|\\uDDF1\\uD83C[\\uDDE6-\\uDDE8\\uDDEE\\uDDF0\\uDDF7-\\uDDFB\\uDDFE]|\\uDDF2\\uD83C[\\uDDE6\\uDDE8-\\uDDED\\uDDF0-\\uDDFF]|\\uDDF3\\uD83C[\\uDDE6\\uDDE8\\uDDEA-\\uDDEC\\uDDEE\\uDDF1\\uDDF4\\uDDF5\\uDDF7\\uDDFA\\uDDFF]|\\uDDF4\\uD83C\\uDDF2|\\uDDF5\\uD83C[\\uDDE6\\uDDEA-\\uDDED\\uDDF0-\\uDDF3\\uDDF7-\\uDDF9\\uDDFC\\uDDFE]|\\uDDF6\\uD83C\\uDDE6|\\uDDF7\\uD83C[\\uDDEA\\uDDF4\\uDDF8\\uDDFA\\uDDFC]|\\uDDF8\\uD83C[\\uDDE6-\\uDDEA\\uDDEC-\\uDDF4\\uDDF7-\\uDDF9\\uDDFB\\uDDFD-\\uDDFF]|\\uDDF9\\uD83C[\\uDDE6\\uDDE8\\uDDE9\\uDDEB-\\uDDED\\uDDEF-\\uDDF4\\uDDF7\\uDDF9\\uDDFB\\uDDFC\\uDDFF]|\\uDDFA\\uD83C[\\uDDE6\\uDDEC\\uDDF2\\uDDF3\\uDDF8\\uDDFE\\uDDFF]|\\uDDFB\\uD83C[\\uDDE6\\uDDE8\\uDDEA\\uDDEC\\uDDEE\\uDDF3\\uDDFA]|\\uDDFC\\uD83C[\\uDDEB\\uDDF8]|\\uDDFD\\uD83C\\uDDF0|\\uDDFE\\uD83C[\\uDDEA\\uDDF9]|\\uDDFF\\uD83C[\\uDDE6\\uDDF2\\uDDFC]|\\uDFF3\\uFE0F?(?:\\u200D(?:\\u26A7\\uFE0F?|\\uD83C\\uDF08))?|\\uDFF4(?:\\u200D\\u2620\\uFE0F?|\\uDB40\\uDC67\\uDB40\\uDC62\\uDB40(?:\\uDC65\\uDB40\\uDC6E\\uDB40\\uDC67|\\uDC73\\uDB40\\uDC63\\uDB40\\uDC74|\\uDC77\\uDB40\\uDC6C\\uDB40\\uDC73)\\uDB40\\uDC7F)?)|\\uD83D(?:[\\uDC08\\uDC26](?:\\u200D\\u2B1B)?|[\\uDC3F\\uDCFD\\uDD49\\uDD4A\\uDD6F\\uDD70\\uDD73\\uDD76-\\uDD79\\uDD87\\uDD8A-\\uDD8D\\uDDA5\\uDDA8\\uDDB1\\uDDB2\\uDDBC\\uDDC2-\\uDDC4\\uDDD1-\\uDDD3\\uDDDC-\\uDDDE\\uDDE1\\uDDE3\\uDDE8\\uDDEF\\uDDF3\\uDDFA\\uDECB\\uDECD-\\uDECF\\uDEE0-\\uDEE5\\uDEE9\\uDEF0\\uDEF3]\\uFE0F?|[\\uDC42\\uDC43\\uDC46-\\uDC50\\uDC66\\uDC67\\uDC6B-\\uDC6D\\uDC72\\uDC74-\\uDC76\\uDC78\\uDC7C\\uDC83\\uDC85\\uDC8F\\uDC91\\uDCAA\\uDD7A\\uDD95\\uDD96\\uDE4C\\uDE4F\\uDEC0\\uDECC](?:\\uD83C[\\uDFFB-\\uDFFF])?|[\\uDC6E\\uDC70\\uDC71\\uDC73\\uDC77\\uDC81\\uDC82\\uDC86\\uDC87\\uDE45-\\uDE47\\uDE4B\\uDE4D\\uDE4E\\uDEA3\\uDEB4-\\uDEB6](?:\\uD83C[\\uDFFB-\\uDFFF])?(?:\\u200D[\\u2640\\u2642]\\uFE0F?)?|[\\uDD74\\uDD90](?:\\uFE0F|\\uD83C[\\uDFFB-\\uDFFF])?|[\\uDC00-\\uDC07\\uDC09-\\uDC14\\uDC16-\\uDC25\\uDC27-\\uDC3A\\uDC3C-\\uDC3E\\uDC40\\uDC44\\uDC45\\uDC51-\\uDC65\\uDC6A\\uDC79-\\uDC7B\\uDC7D-\\uDC80\\uDC84\\uDC88-\\uDC8E\\uDC90\\uDC92-\\uDCA9\\uDCAB-\\uDCFC\\uDCFF-\\uDD3D\\uDD4B-\\uDD4E\\uDD50-\\uDD67\\uDDA4\\uDDFB-\\uDE2D\\uDE2F-\\uDE34\\uDE37-\\uDE44\\uDE48-\\uDE4A\\uDE80-\\uDEA2\\uDEA4-\\uDEB3\\uDEB7-\\uDEBF\\uDEC1-\\uDEC5\\uDED0-\\uDED2\\uDED5-\\uDED7\\uDEDC-\\uDEDF\\uDEEB\\uDEEC\\uDEF4-\\uDEFC\\uDFE0-\\uDFEB\\uDFF0]|\\uDC15(?:\\u200D\\uD83E\\uDDBA)?|\\uDC3B(?:\\u200D\\u2744\\uFE0F?)?|\\uDC41\\uFE0F?(?:\\u200D\\uD83D\\uDDE8\\uFE0F?)?|\\uDC68(?:\\u200D(?:[\\u2695\\u2696\\u2708]\\uFE0F?|\\u2764\\uFE0F?\\u200D\\uD83D(?:\\uDC8B\\u200D\\uD83D)?\\uDC68|\\uD83C[\\uDF3E\\uDF73\\uDF7C\\uDF93\\uDFA4\\uDFA8\\uDFEB\\uDFED]|\\uD83D(?:[\\uDC68\\uDC69]\\u200D\\uD83D(?:\\uDC66(?:\\u200D\\uD83D\\uDC66)?|\\uDC67(?:\\u200D\\uD83D[\\uDC66\\uDC67])?)|[\\uDCBB\\uDCBC\\uDD27\\uDD2C\\uDE80\\uDE92]|\\uDC66(?:\\u200D\\uD83D\\uDC66)?|\\uDC67(?:\\u200D\\uD83D[\\uDC66\\uDC67])?)|\\uD83E[\\uDDAF-\\uDDB3\\uDDBC\\uDDBD])|\\uD83C(?:\\uDFFB(?:\\u200D(?:[\\u2695\\u2696\\u2708]\\uFE0F?|\\u2764\\uFE0F?\\u200D\\uD83D(?:\\uDC8B\\u200D\\uD83D)?\\uDC68\\uD83C[\\uDFFB-\\uDFFF]|\\uD83C[\\uDF3E\\uDF73\\uDF7C\\uDF93\\uDFA4\\uDFA8\\uDFEB\\uDFED]|\\uD83D[\\uDCBB\\uDCBC\\uDD27\\uDD2C\\uDE80\\uDE92]|\\uD83E(?:[\\uDDAF-\\uDDB3\\uDDBC\\uDDBD]|\\uDD1D\\u200D\\uD83D\\uDC68\\uD83C[\\uDFFC-\\uDFFF])))?|\\uDFFC(?:\\u200D(?:[\\u2695\\u2696\\u2708]\\uFE0F?|\\u2764\\uFE0F?\\u200D\\uD83D(?:\\uDC8B\\u200D\\uD83D)?\\uDC68\\uD83C[\\uDFFB-\\uDFFF]|\\uD83C[\\uDF3E\\uDF73\\uDF7C\\uDF93\\uDFA4\\uDFA8\\uDFEB\\uDFED]|\\uD83D[\\uDCBB\\uDCBC\\uDD27\\uDD2C\\uDE80\\uDE92]|\\uD83E(?:[\\uDDAF-\\uDDB3\\uDDBC\\uDDBD]|\\uDD1D\\u200D\\uD83D\\uDC68\\uD83C[\\uDFFB\\uDFFD-\\uDFFF])))?|\\uDFFD(?:\\u200D(?:[\\u2695\\u2696\\u2708]\\uFE0F?|\\u2764\\uFE0F?\\u200D\\uD83D(?:\\uDC8B\\u200D\\uD83D)?\\uDC68\\uD83C[\\uDFFB-\\uDFFF]|\\uD83C[\\uDF3E\\uDF73\\uDF7C\\uDF93\\uDFA4\\uDFA8\\uDFEB\\uDFED]|\\uD83D[\\uDCBB\\uDCBC\\uDD27\\uDD2C\\uDE80\\uDE92]|\\uD83E(?:[\\uDDAF-\\uDDB3\\uDDBC\\uDDBD]|\\uDD1D\\u200D\\uD83D\\uDC68\\uD83C[\\uDFFB\\uDFFC\\uDFFE\\uDFFF])))?|\\uDFFE(?:\\u200D(?:[\\u2695\\u2696\\u2708]\\uFE0F?|\\u2764\\uFE0F?\\u200D\\uD83D(?:\\uDC8B\\u200D\\uD83D)?\\uDC68\\uD83C[\\uDFFB-\\uDFFF]|\\uD83C[\\uDF3E\\uDF73\\uDF7C\\uDF93\\uDFA4\\uDFA8\\uDFEB\\uDFED]|\\uD83D[\\uDCBB\\uDCBC\\uDD27\\uDD2C\\uDE80\\uDE92]|\\uD83E(?:[\\uDDAF-\\uDDB3\\uDDBC\\uDDBD]|\\uDD1D\\u200D\\uD83D\\uDC68\\uD83C[\\uDFFB-\\uDFFD\\uDFFF])))?|\\uDFFF(?:\\u200D(?:[\\u2695\\u2696\\u2708]\\uFE0F?|\\u2764\\uFE0F?\\u200D\\uD83D(?:\\uDC8B\\u200D\\uD83D)?\\uDC68\\uD83C[\\uDFFB-\\uDFFF]|\\uD83C[\\uDF3E\\uDF73\\uDF7C\\uDF93\\uDFA4\\uDFA8\\uDFEB\\uDFED]|\\uD83D[\\uDCBB\\uDCBC\\uDD27\\uDD2C\\uDE80\\uDE92]|\\uD83E(?:[\\uDDAF-\\uDDB3\\uDDBC\\uDDBD]|\\uDD1D\\u200D\\uD83D\\uDC68\\uD83C[\\uDFFB-\\uDFFE])))?))?|\\uDC69(?:\\u200D(?:[\\u2695\\u2696\\u2708]\\uFE0F?|\\u2764\\uFE0F?\\u200D\\uD83D(?:\\uDC8B\\u200D\\uD83D)?[\\uDC68\\uDC69]|\\uD83C[\\uDF3E\\uDF73\\uDF7C\\uDF93\\uDFA4\\uDFA8\\uDFEB\\uDFED]|\\uD83D(?:[\\uDCBB\\uDCBC\\uDD27\\uDD2C\\uDE80\\uDE92]|\\uDC66(?:\\u200D\\uD83D\\uDC66)?|\\uDC67(?:\\u200D\\uD83D[\\uDC66\\uDC67])?|\\uDC69\\u200D\\uD83D(?:\\uDC66(?:\\u200D\\uD83D\\uDC66)?|\\uDC67(?:\\u200D\\uD83D[\\uDC66\\uDC67])?))|\\uD83E[\\uDDAF-\\uDDB3\\uDDBC\\uDDBD])|\\uD83C(?:\\uDFFB(?:\\u200D(?:[\\u2695\\u2696\\u2708]\\uFE0F?|\\u2764\\uFE0F?\\u200D\\uD83D(?:[\\uDC68\\uDC69]|\\uDC8B\\u200D\\uD83D[\\uDC68\\uDC69])\\uD83C[\\uDFFB-\\uDFFF]|\\uD83C[\\uDF3E\\uDF73\\uDF7C\\uDF93\\uDFA4\\uDFA8\\uDFEB\\uDFED]|\\uD83D[\\uDCBB\\uDCBC\\uDD27\\uDD2C\\uDE80\\uDE92]|\\uD83E(?:[\\uDDAF-\\uDDB3\\uDDBC\\uDDBD]|\\uDD1D\\u200D\\uD83D[\\uDC68\\uDC69]\\uD83C[\\uDFFC-\\uDFFF])))?|\\uDFFC(?:\\u200D(?:[\\u2695\\u2696\\u2708]\\uFE0F?|\\u2764\\uFE0F?\\u200D\\uD83D(?:[\\uDC68\\uDC69]|\\uDC8B\\u200D\\uD83D[\\uDC68\\uDC69])\\uD83C[\\uDFFB-\\uDFFF]|\\uD83C[\\uDF3E\\uDF73\\uDF7C\\uDF93\\uDFA4\\uDFA8\\uDFEB\\uDFED]|\\uD83D[\\uDCBB\\uDCBC\\uDD27\\uDD2C\\uDE80\\uDE92]|\\uD83E(?:[\\uDDAF-\\uDDB3\\uDDBC\\uDDBD]|\\uDD1D\\u200D\\uD83D[\\uDC68\\uDC69]\\uD83C[\\uDFFB\\uDFFD-\\uDFFF])))?|\\uDFFD(?:\\u200D(?:[\\u2695\\u2696\\u2708]\\uFE0F?|\\u2764\\uFE0F?\\u200D\\uD83D(?:[\\uDC68\\uDC69]|\\uDC8B\\u200D\\uD83D[\\uDC68\\uDC69])\\uD83C[\\uDFFB-\\uDFFF]|\\uD83C[\\uDF3E\\uDF73\\uDF7C\\uDF93\\uDFA4\\uDFA8\\uDFEB\\uDFED]|\\uD83D[\\uDCBB\\uDCBC\\uDD27\\uDD2C\\uDE80\\uDE92]|\\uD83E(?:[\\uDDAF-\\uDDB3\\uDDBC\\uDDBD]|\\uDD1D\\u200D\\uD83D[\\uDC68\\uDC69]\\uD83C[\\uDFFB\\uDFFC\\uDFFE\\uDFFF])))?|\\uDFFE(?:\\u200D(?:[\\u2695\\u2696\\u2708]\\uFE0F?|\\u2764\\uFE0F?\\u200D\\uD83D(?:[\\uDC68\\uDC69]|\\uDC8B\\u200D\\uD83D[\\uDC68\\uDC69])\\uD83C[\\uDFFB-\\uDFFF]|\\uD83C[\\uDF3E\\uDF73\\uDF7C\\uDF93\\uDFA4\\uDFA8\\uDFEB\\uDFED]|\\uD83D[\\uDCBB\\uDCBC\\uDD27\\uDD2C\\uDE80\\uDE92]|\\uD83E(?:[\\uDDAF-\\uDDB3\\uDDBC\\uDDBD]|\\uDD1D\\u200D\\uD83D[\\uDC68\\uDC69]\\uD83C[\\uDFFB-\\uDFFD\\uDFFF])))?|\\uDFFF(?:\\u200D(?:[\\u2695\\u2696\\u2708]\\uFE0F?|\\u2764\\uFE0F?\\u200D\\uD83D(?:[\\uDC68\\uDC69]|\\uDC8B\\u200D\\uD83D[\\uDC68\\uDC69])\\uD83C[\\uDFFB-\\uDFFF]|\\uD83C[\\uDF3E\\uDF73\\uDF7C\\uDF93\\uDFA4\\uDFA8\\uDFEB\\uDFED]|\\uD83D[\\uDCBB\\uDCBC\\uDD27\\uDD2C\\uDE80\\uDE92]|\\uD83E(?:[\\uDDAF-\\uDDB3\\uDDBC\\uDDBD]|\\uDD1D\\u200D\\uD83D[\\uDC68\\uDC69]\\uD83C[\\uDFFB-\\uDFFE])))?))?|\\uDC6F(?:\\u200D[\\u2640\\u2642]\\uFE0F?)?|\\uDD75(?:\\uFE0F|\\uD83C[\\uDFFB-\\uDFFF])?(?:\\u200D[\\u2640\\u2642]\\uFE0F?)?|\\uDE2E(?:\\u200D\\uD83D\\uDCA8)?|\\uDE35(?:\\u200D\\uD83D\\uDCAB)?|\\uDE36(?:\\u200D\\uD83C\\uDF2B\\uFE0F?)?)|\\uD83E(?:[\\uDD0C\\uDD0F\\uDD18-\\uDD1F\\uDD30-\\uDD34\\uDD36\\uDD77\\uDDB5\\uDDB6\\uDDBB\\uDDD2\\uDDD3\\uDDD5\\uDEC3-\\uDEC5\\uDEF0\\uDEF2-\\uDEF8](?:\\uD83C[\\uDFFB-\\uDFFF])?|[\\uDD26\\uDD35\\uDD37-\\uDD39\\uDD3D\\uDD3E\\uDDB8\\uDDB9\\uDDCD-\\uDDCF\\uDDD4\\uDDD6-\\uDDDD](?:\\uD83C[\\uDFFB-\\uDFFF])?(?:\\u200D[\\u2640\\u2642]\\uFE0F?)?|[\\uDDDE\\uDDDF](?:\\u200D[\\u2640\\u2642]\\uFE0F?)?|[\\uDD0D\\uDD0E\\uDD10-\\uDD17\\uDD20-\\uDD25\\uDD27-\\uDD2F\\uDD3A\\uDD3F-\\uDD45\\uDD47-\\uDD76\\uDD78-\\uDDB4\\uDDB7\\uDDBA\\uDDBC-\\uDDCC\\uDDD0\\uDDE0-\\uDDFF\\uDE70-\\uDE7C\\uDE80-\\uDE88\\uDE90-\\uDEBD\\uDEBF-\\uDEC2\\uDECE-\\uDEDB\\uDEE0-\\uDEE8]|\\uDD3C(?:\\u200D[\\u2640\\u2642]\\uFE0F?|\\uD83C[\\uDFFB-\\uDFFF])?|\\uDDD1(?:\\u200D(?:[\\u2695\\u2696\\u2708]\\uFE0F?|\\uD83C[\\uDF3E\\uDF73\\uDF7C\\uDF84\\uDF93\\uDFA4\\uDFA8\\uDFEB\\uDFED]|\\uD83D[\\uDCBB\\uDCBC\\uDD27\\uDD2C\\uDE80\\uDE92]|\\uD83E(?:[\\uDDAF-\\uDDB3\\uDDBC\\uDDBD]|\\uDD1D\\u200D\\uD83E\\uDDD1))|\\uD83C(?:\\uDFFB(?:\\u200D(?:[\\u2695\\u2696\\u2708]\\uFE0F?|\\u2764\\uFE0F?\\u200D(?:\\uD83D\\uDC8B\\u200D)?\\uD83E\\uDDD1\\uD83C[\\uDFFC-\\uDFFF]|\\uD83C[\\uDF3E\\uDF73\\uDF7C\\uDF84\\uDF93\\uDFA4\\uDFA8\\uDFEB\\uDFED]|\\uD83D[\\uDCBB\\uDCBC\\uDD27\\uDD2C\\uDE80\\uDE92]|\\uD83E(?:[\\uDDAF-\\uDDB3\\uDDBC\\uDDBD]|\\uDD1D\\u200D\\uD83E\\uDDD1\\uD83C[\\uDFFB-\\uDFFF])))?|\\uDFFC(?:\\u200D(?:[\\u2695\\u2696\\u2708]\\uFE0F?|\\u2764\\uFE0F?\\u200D(?:\\uD83D\\uDC8B\\u200D)?\\uD83E\\uDDD1\\uD83C[\\uDFFB\\uDFFD-\\uDFFF]|\\uD83C[\\uDF3E\\uDF73\\uDF7C\\uDF84\\uDF93\\uDFA4\\uDFA8\\uDFEB\\uDFED]|\\uD83D[\\uDCBB\\uDCBC\\uDD27\\uDD2C\\uDE80\\uDE92]|\\uD83E(?:[\\uDDAF-\\uDDB3\\uDDBC\\uDDBD]|\\uDD1D\\u200D\\uD83E\\uDDD1\\uD83C[\\uDFFB-\\uDFFF])))?|\\uDFFD(?:\\u200D(?:[\\u2695\\u2696\\u2708]\\uFE0F?|\\u2764\\uFE0F?\\u200D(?:\\uD83D\\uDC8B\\u200D)?\\uD83E\\uDDD1\\uD83C[\\uDFFB\\uDFFC\\uDFFE\\uDFFF]|\\uD83C[\\uDF3E\\uDF73\\uDF7C\\uDF84\\uDF93\\uDFA4\\uDFA8\\uDFEB\\uDFED]|\\uD83D[\\uDCBB\\uDCBC\\uDD27\\uDD2C\\uDE80\\uDE92]|\\uD83E(?:[\\uDDAF-\\uDDB3\\uDDBC\\uDDBD]|\\uDD1D\\u200D\\uD83E\\uDDD1\\uD83C[\\uDFFB-\\uDFFF])))?|\\uDFFE(?:\\u200D(?:[\\u2695\\u2696\\u2708]\\uFE0F?|\\u2764\\uFE0F?\\u200D(?:\\uD83D\\uDC8B\\u200D)?\\uD83E\\uDDD1\\uD83C[\\uDFFB-\\uDFFD\\uDFFF]|\\uD83C[\\uDF3E\\uDF73\\uDF7C\\uDF84\\uDF93\\uDFA4\\uDFA8\\uDFEB\\uDFED]|\\uD83D[\\uDCBB\\uDCBC\\uDD27\\uDD2C\\uDE80\\uDE92]|\\uD83E(?:[\\uDDAF-\\uDDB3\\uDDBC\\uDDBD]|\\uDD1D\\u200D\\uD83E\\uDDD1\\uD83C[\\uDFFB-\\uDFFF])))?|\\uDFFF(?:\\u200D(?:[\\u2695\\u2696\\u2708]\\uFE0F?|\\u2764\\uFE0F?\\u200D(?:\\uD83D\\uDC8B\\u200D)?\\uD83E\\uDDD1\\uD83C[\\uDFFB-\\uDFFE]|\\uD83C[\\uDF3E\\uDF73\\uDF7C\\uDF84\\uDF93\\uDFA4\\uDFA8\\uDFEB\\uDFED]|\\uD83D[\\uDCBB\\uDCBC\\uDD27\\uDD2C\\uDE80\\uDE92]|\\uD83E(?:[\\uDDAF-\\uDDB3\\uDDBC\\uDDBD]|\\uDD1D\\u200D\\uD83E\\uDDD1\\uD83C[\\uDFFB-\\uDFFF])))?))?|\\uDEF1(?:\\uD83C(?:\\uDFFB(?:\\u200D\\uD83E\\uDEF2\\uD83C[\\uDFFC-\\uDFFF])?|\\uDFFC(?:\\u200D\\uD83E\\uDEF2\\uD83C[\\uDFFB\\uDFFD-\\uDFFF])?|\\uDFFD(?:\\u200D\\uD83E\\uDEF2\\uD83C[\\uDFFB\\uDFFC\\uDFFE\\uDFFF])?|\\uDFFE(?:\\u200D\\uD83E\\uDEF2\\uD83C[\\uDFFB-\\uDFFD\\uDFFF])?|\\uDFFF(?:\\u200D\\uD83E\\uDEF2\\uD83C[\\uDFFB-\\uDFFE])?))?)/g;var xr={eastAsianWidth(t){var e=t.charCodeAt(0),r=t.length==2?t.charCodeAt(1):0,n=e;return 55296<=e&&e<=56319&&56320<=r&&r<=57343&&(e&=1023,r&=1023,n=e<<10|r,n+=65536),n==12288||65281<=n&&n<=65376||65504<=n&&n<=65510?\"F\":4352<=n&&n<=4447||4515<=n&&n<=4519||4602<=n&&n<=4607||9001<=n&&n<=9002||11904<=n&&n<=11929||11931<=n&&n<=12019||12032<=n&&n<=12245||12272<=n&&n<=12283||12289<=n&&n<=12350||12353<=n&&n<=12438||12441<=n&&n<=12543||12549<=n&&n<=12589||12593<=n&&n<=12686||12688<=n&&n<=12730||12736<=n&&n<=12771||12784<=n&&n<=12830||12832<=n&&n<=12871||12880<=n&&n<=13054||13056<=n&&n<=19903||19968<=n&&n<=42124||42128<=n&&n<=42182||43360<=n&&n<=43388||44032<=n&&n<=55203||55216<=n&&n<=55238||55243<=n&&n<=55291||63744<=n&&n<=64255||65040<=n&&n<=65049||65072<=n&&n<=65106||65108<=n&&n<=65126||65128<=n&&n<=65131||110592<=n&&n<=110593||127488<=n&&n<=127490||127504<=n&&n<=127546||127552<=n&&n<=127560||127568<=n&&n<=127569||131072<=n&&n<=194367||177984<=n&&n<=196605||196608<=n&&n<=262141?\"W\":\"N\"}};var bu=/[^\\x20-\\x7F]/;function wu(t){if(!t)return 0;if(!bu.test(t))return t.length;t=t.replace(yr(),\" \");let e=0;for(let r of t){let n=r.codePointAt(0);if(n<=31||n>=127&&n<=159||n>=768&&n<=879)continue;let o=xr.eastAsianWidth(r);e+=o===\"F\"||o===\"W\"?2:1}return e}var we=wu;var Br=t=>{if(Array.isArray(t))return t;if(t.type!==k)throw new Error(`Expect doc to be 'array' or '${k}'.`);return t.parts};function Ne(t,e){if(typeof t==\"string\")return e(t);let r=new Map;return n(t);function n(u){if(r.has(u))return r.get(u);let i=o(u);return r.set(u,i),i}function o(u){switch(W(u)){case j:return e(u.map(n));case k:return e({...u,parts:u.parts.map(n)});case B:return e({...u,breakContents:n(u.breakContents),flatContents:n(u.flatContents)});case A:{let{expandedStates:i,contents:s}=u;return i?(i=i.map(n),s=i[0]):s=n(s),e({...u,contents:s,expandedStates:i})}case S:case T:case P:case O:case L:return e({...u,contents:n(u.contents)});case U:case M:case v:case I:case x:case b:return e(u);default:throw new q(u)}}}function Je(t,e,r){let n=r,o=!1;function u(i){if(o)return!1;let s=e(i);s!==void 0&&(o=!0,n=s)}return xe(t,u),n}function Ou(t){if(t.type===A&&t.break||t.type===x&&t.hard||t.type===b)return!0}function kr(t){return Je(t,Ou,!1)}function _r(t){if(t.length>0){let e=y(!1,t,-1);!e.expandedStates&&!e.break&&(e.break=\"propagated\")}return null}function br(t){let e=new Set,r=[];function n(u){if(u.type===b&&_r(r),u.type===A){if(r.push(u),e.has(u))return!1;e.add(u)}}function o(u){u.type===A&&r.pop().break&&_r(r)}xe(t,n,o,!0)}function Nu(t){return t.type===x&&!t.hard?t.soft?\"\":\" \":t.type===B?t.flatContents:t}function wr(t){return Ne(t,Nu)}function Ar(t){for(t=[...t];t.length>=2&&y(!1,t,-2).type===x&&y(!1,t,-1).type===b;)t.length-=2;if(t.length>0){let e=Oe(y(!1,t,-1));t[t.length-1]=e}return t}function Oe(t){switch(W(t)){case S:case T:case P:case A:case L:case O:{let e=Oe(t.contents);return{...t,contents:e}}case B:return{...t,breakContents:Oe(t.breakContents),flatContents:Oe(t.flatContents)};case k:return{...t,parts:Ar(t.parts)};case j:return Ar(t);case U:return t.replace(/[\\n\\r]*$/,\"\");case M:case v:case I:case x:case b:break;default:throw new q(t)}return t}function Xe(t){return Oe(Su(t))}function Tu(t){switch(W(t)){case k:if(t.parts.every(e=>e===\"\"))return\"\";break;case A:if(!t.contents&&!t.id&&!t.break&&!t.expandedStates)return\"\";if(t.contents.type===A&&t.contents.id===t.id&&t.contents.break===t.break&&t.contents.expandedStates===t.expandedStates)return t.contents;break;case S:case T:case P:case L:if(!t.contents)return\"\";break;case B:if(!t.flatContents&&!t.breakContents)return\"\";break;case j:{let e=[];for(let r of t){if(!r)continue;let[n,...o]=Array.isArray(r)?r:[r];typeof n==\"string\"&&typeof y(!1,e,-1)==\"string\"?e[e.length-1]+=n:e.push(n),e.push(...o)}return e.length===0?\"\":e.length===1?e[0]:e}case U:case M:case v:case I:case x:case O:case b:break;default:throw new q(t)}return t}function Su(t){return Ne(t,e=>Tu(e))}function Or(t,e=He){return Ne(t,r=>typeof r==\"string\"?ke(e,r.split(`\n`)):r)}function vu(t){if(t.type===x)return!0}function Nr(t){return Je(t,vu,!1)}function Ze(t,e){return t.type===O?{...t,contents:e(t.contents)}:e(t)}var R=Symbol(\"MODE_BREAK\"),K=Symbol(\"MODE_FLAT\"),Te=Symbol(\"cursor\");function Tr(){return{value:\"\",length:0,queue:[]}}function Pu(t,e){return Bt(t,{type:\"indent\"},e)}function Lu(t,e,r){return e===Number.NEGATIVE_INFINITY?t.root||Tr():e<0?Bt(t,{type:\"dedent\"},r):e?e.type===\"root\"?{...t,root:t}:Bt(t,{type:typeof e==\"string\"?\"stringAlign\":\"numberAlign\",n:e},r):t}function Bt(t,e,r){let n=e.type===\"dedent\"?t.queue.slice(0,-1):[...t.queue,e],o=\"\",u=0,i=0,s=0;for(let l of n)switch(l.type){case\"indent\":c(),r.useTabs?a(1):D(r.tabWidth);break;case\"stringAlign\":c(),o+=l.n,u+=l.n.length;break;case\"numberAlign\":i+=1,s+=l.n;break;default:throw new Error(`Unexpected type '${l.type}'`)}return f(),{...t,value:o,length:u,queue:n};function a(l){o+=\"\t\".repeat(l),u+=r.tabWidth*l}function D(l){o+=\" \".repeat(l),u+=l}function c(){r.useTabs?F():f()}function F(){i>0&&a(i),d()}function f(){s>0&&D(s),d()}function d(){i=0,s=0}}function kt(t){let e=0,r=0,n=t.length;e:for(;n--;){let o=t[n];if(o===Te){r++;continue}for(let u=o.length-1;u>=0;u--){let i=o[u];if(i===\" \"||i===\"\t\")e++;else{t[n]=o.slice(0,u+1);break e}}}if(e>0||r>0)for(t.length=n+1;r-- >0;)t.push(Te);return e}function Qe(t,e,r,n,o,u){if(r===Number.POSITIVE_INFINITY)return!0;let i=e.length,s=[t],a=[];for(;r>=0;){if(s.length===0){if(i===0)return!0;s.push(e[--i]);continue}let{mode:D,doc:c}=s.pop();switch(W(c)){case U:a.push(c),r-=we(c);break;case j:case k:{let F=Br(c);for(let f=F.length-1;f>=0;f--)s.push({mode:D,doc:F[f]});break}case T:case S:case P:case O:s.push({mode:D,doc:c.contents});break;case v:r+=kt(a);break;case A:{if(u&&c.break)return!1;let F=c.break?R:D,f=c.expandedStates&&F===R?y(!1,c.expandedStates,-1):c.contents;s.push({mode:F,doc:f});break}case B:{let f=(c.groupId?o[c.groupId]||K:D)===R?c.breakContents:c.flatContents;f&&s.push({mode:D,doc:f});break}case x:if(D===R||c.hard)return!0;c.soft||(a.push(\" \"),r--);break;case L:n=!0;break;case I:if(n)return!1;break}}return!1}function fe(t,e){let r={},n=e.printWidth,o=be(e.endOfLine),u=0,i=[{ind:Tr(),mode:R,doc:t}],s=[],a=!1,D=[],c=0;for(br(t);i.length>0;){let{ind:f,mode:d,doc:l}=i.pop();switch(W(l)){case U:{let p=o!==`\n`?ee(!1,l,`\n`,o):l;s.push(p),i.length>0&&(u+=we(p));break}case j:for(let p=l.length-1;p>=0;p--)i.push({ind:f,mode:d,doc:l[p]});break;case M:if(c>=2)throw new Error(\"There are too many 'cursor' in doc.\");s.push(Te),c++;break;case T:i.push({ind:Pu(f,e),mode:d,doc:l.contents});break;case S:i.push({ind:Lu(f,l.n,e),mode:d,doc:l.contents});break;case v:u-=kt(s);break;case A:switch(d){case K:if(!a){i.push({ind:f,mode:l.break?R:K,doc:l.contents});break}case R:{a=!1;let p={ind:f,mode:K,doc:l.contents},m=n-u,E=D.length>0;if(!l.break&&Qe(p,i,m,E,r))i.push(p);else if(l.expandedStates){let h=y(!1,l.expandedStates,-1);if(l.break){i.push({ind:f,mode:R,doc:h});break}else for(let g=1;g=l.expandedStates.length){i.push({ind:f,mode:R,doc:h});break}else{let C=l.expandedStates[g],_={ind:f,mode:K,doc:C};if(Qe(_,i,m,E,r)){i.push(_);break}}}else i.push({ind:f,mode:R,doc:l.contents});break}}l.id&&(r[l.id]=y(!1,i,-1).mode);break;case k:{let p=n-u,{parts:m}=l;if(m.length===0)break;let[E,h]=m,g={ind:f,mode:K,doc:E},C={ind:f,mode:R,doc:E},_=Qe(g,[],p,D.length>0,r,!0);if(m.length===1){_?i.push(g):i.push(C);break}let Z={ind:f,mode:K,doc:h},$={ind:f,mode:R,doc:h};if(m.length===2){_?i.push(Z,g):i.push($,C);break}m.splice(0,2);let Q={ind:f,mode:d,doc:Ge(m)},rr=m[0];Qe({ind:f,mode:K,doc:[E,h,rr]},[],p,D.length>0,r,!0)?i.push(Q,Z,g):_?i.push(Q,$,g):i.push(Q,$,C);break}case B:case P:{let p=l.groupId?r[l.groupId]:d;if(p===R){let m=l.type===B?l.breakContents:l.negate?l.contents:ie(l.contents);m&&i.push({ind:f,mode:d,doc:m})}if(p===K){let m=l.type===B?l.flatContents:l.negate?ie(l.contents):l.contents;m&&i.push({ind:f,mode:d,doc:m})}break}case L:D.push({ind:f,mode:d,doc:l.contents});break;case I:D.length>0&&i.push({ind:f,mode:d,doc:Ae});break;case x:switch(d){case K:if(l.hard)a=!0;else{l.soft||(s.push(\" \"),u+=1);break}case R:if(D.length>0){i.push({ind:f,mode:d,doc:l},...D.reverse()),D.length=0;break}l.literal?f.root?(s.push(o,f.root.value),u=f.root.length):(s.push(o),u=0):(u-=kt(s),s.push(o+f.value),u=f.length);break}break;case O:i.push({ind:f,mode:d,doc:l.contents});break;case b:break;default:throw new q(l)}i.length===0&&D.length>0&&(i.push(...D.reverse()),D.length=0)}let F=s.indexOf(Te);if(F!==-1){let f=s.indexOf(Te,F+1),d=s.slice(0,F).join(\"\"),l=s.slice(F+1,f).join(\"\"),p=s.slice(f+1).join(\"\");return{formatted:d+l+p,cursorNodeStart:d.length,cursorNodeText:l}}return{formatted:s.join(\"\")}}function J(t){var e;if(!t)return\"\";if(Array.isArray(t)){let r=[];for(let n of t)if(Array.isArray(n))r.push(...J(n));else{let o=J(n);o!==\"\"&&r.push(o)}return r}return t.type===B?{...t,breakContents:J(t.breakContents),flatContents:J(t.flatContents)}:t.type===A?{...t,contents:J(t.contents),expandedStates:(e=t.expandedStates)==null?void 0:e.map(J)}:t.type===k?{type:\"fill\",parts:t.parts.map(J)}:t.contents?{...t,contents:J(t.contents)}:t}function Sr(t){let e=Object.create(null),r=new Set;return n(J(t));function n(u,i,s){var a,D;if(typeof u==\"string\")return JSON.stringify(u);if(Array.isArray(u)){let c=u.map(n).filter(Boolean);return c.length===1?c[0]:`[${c.join(\", \")}]`}if(u.type===x){let c=((a=s==null?void 0:s[i+1])==null?void 0:a.type)===b;return u.literal?c?\"literalline\":\"literallineWithoutBreakParent\":u.hard?c?\"hardline\":\"hardlineWithoutBreakParent\":u.soft?\"softline\":\"line\"}if(u.type===b)return((D=s==null?void 0:s[i-1])==null?void 0:D.type)===x&&s[i-1].hard?void 0:\"breakParent\";if(u.type===v)return\"trim\";if(u.type===T)return\"indent(\"+n(u.contents)+\")\";if(u.type===S)return u.n===Number.NEGATIVE_INFINITY?\"dedentToRoot(\"+n(u.contents)+\")\":u.n<0?\"dedent(\"+n(u.contents)+\")\":u.n.type===\"root\"?\"markAsRoot(\"+n(u.contents)+\")\":\"align(\"+JSON.stringify(u.n)+\", \"+n(u.contents)+\")\";if(u.type===B)return\"ifBreak(\"+n(u.breakContents)+(u.flatContents?\", \"+n(u.flatContents):\"\")+(u.groupId?(u.flatContents?\"\":', \"\"')+`, { groupId: ${o(u.groupId)} }`:\"\")+\")\";if(u.type===P){let c=[];u.negate&&c.push(\"negate: true\"),u.groupId&&c.push(`groupId: ${o(u.groupId)}`);let F=c.length>0?`, { ${c.join(\", \")} }`:\"\";return`indentIfBreak(${n(u.contents)}${F})`}if(u.type===A){let c=[];u.break&&u.break!==\"propagated\"&&c.push(\"shouldBreak: true\"),u.id&&c.push(`id: ${o(u.id)}`);let F=c.length>0?`, { ${c.join(\", \")} }`:\"\";return u.expandedStates?`conditionalGroup([${u.expandedStates.map(f=>n(f)).join(\",\")}]${F})`:`group(${n(u.contents)}${F})`}if(u.type===k)return`fill([${u.parts.map(c=>n(c)).join(\", \")}])`;if(u.type===L)return\"lineSuffix(\"+n(u.contents)+\")\";if(u.type===I)return\"lineSuffixBoundary\";if(u.type===O)return`label(${JSON.stringify(u.label)}, ${n(u.contents)})`;throw new Error(\"Unknown doc type \"+u.type)}function o(u){if(typeof u!=\"symbol\")return JSON.stringify(String(u));if(u in e)return e[u];let i=u.description||\"symbol\";for(let s=0;;s++){let a=i+(s>0?` #${s}`:\"\");if(!r.has(a))return r.add(a),e[u]=`Symbol.for(${JSON.stringify(a)})`}}}function Iu(t,e,r=0){let n=0;for(let o=r;otypeof t==\"string\"||typeof t==\"function\",choices:[{value:\"flow\",description:\"Flow\"},{value:\"babel\",description:\"JavaScript\"},{value:\"babel-flow\",description:\"Flow\"},{value:\"babel-ts\",description:\"TypeScript\"},{value:\"typescript\",description:\"TypeScript\"},{value:\"acorn\",description:\"JavaScript\"},{value:\"espree\",description:\"JavaScript\"},{value:\"meriyah\",description:\"JavaScript\"},{value:\"css\",description:\"CSS\"},{value:\"less\",description:\"Less\"},{value:\"scss\",description:\"SCSS\"},{value:\"json\",description:\"JSON\"},{value:\"json5\",description:\"JSON5\"},{value:\"json-stringify\",description:\"JSON.stringify\"},{value:\"graphql\",description:\"GraphQL\"},{value:\"markdown\",description:\"Markdown\"},{value:\"mdx\",description:\"MDX\"},{value:\"vue\",description:\"Vue\"},{value:\"yaml\",description:\"YAML\"},{value:\"glimmer\",description:\"Ember / Handlebars\"},{value:\"html\",description:\"HTML\"},{value:\"angular\",description:\"Angular\"},{value:\"lwc\",description:\"Lightning Web Components\"}]},plugins:{type:\"path\",array:!0,default:[{value:[]}],category:\"Global\",description:\"Add a plugin. Multiple plugins can be passed as separate `--plugin`s.\",exception:t=>typeof t==\"string\"||typeof t==\"object\",cliName:\"plugin\",cliCategory:\"Config\"},printWidth:{category:\"Global\",type:\"int\",default:80,description:\"The line length where Prettier will try wrap.\",range:{start:0,end:1/0,step:1}},rangeEnd:{category:\"Special\",type:\"int\",default:1/0,range:{start:0,end:1/0,step:1},description:`Format code ending at a given character offset (exclusive).\nThe range will extend forwards to the end of the selected statement.\nThis option cannot be used with --cursor-offset.`,cliCategory:\"Editor\"},rangeStart:{category:\"Special\",type:\"int\",default:0,range:{start:0,end:1/0,step:1},description:`Format code starting at a given character offset.\nThe range will extend backwards to the start of the first line containing the selected statement.\nThis option cannot be used with --cursor-offset.`,cliCategory:\"Editor\"},requirePragma:{category:\"Special\",type:\"boolean\",default:!1,description:`Require either '@prettier' or '@format' to be present in the file's first docblock comment\nin order for it to be formatted.`,cliCategory:\"Other\"},tabWidth:{type:\"int\",category:\"Global\",default:2,description:\"Number of spaces per indentation level.\",range:{start:0,end:1/0,step:1}},useTabs:{category:\"Global\",type:\"boolean\",default:!1,description:\"Indent with tabs instead of spaces.\"},embeddedLanguageFormatting:{category:\"Global\",type:\"choice\",default:\"auto\",description:\"Control how Prettier formats quoted code embedded in the file.\",choices:[{value:\"auto\",description:\"Format embedded code if Prettier can automatically identify it.\"},{value:\"off\",description:\"Never automatically format embedded code.\"}]}};function et({plugins:t=[],showDeprecated:e=!1}={}){let r=t.flatMap(o=>o.languages??[]),n=[];for(let o of Yu(Object.assign({},...t.map(({options:u})=>u),vr)))!e&&o.deprecated||(Array.isArray(o.choices)&&(e||(o.choices=o.choices.filter(u=>!u.deprecated)),o.name===\"parser\"&&(o.choices=[...o.choices,...Ru(o.choices,r,t)])),o.pluginDefaults=Object.fromEntries(t.filter(u=>{var i;return((i=u.defaultOptions)==null?void 0:i[o.name])!==void 0}).map(u=>[u.name,u.defaultOptions[o.name]])),n.push(o));return{languages:r,options:n}}function*Ru(t,e,r){let n=new Set(t.map(o=>o.value));for(let o of e)if(o.parsers){for(let u of o.parsers)if(!n.has(u)){n.add(u);let i=r.find(a=>a.parsers&&Object.prototype.hasOwnProperty.call(a.parsers,u)),s=o.name;i!=null&&i.name&&(s+=` (plugin: ${i.name})`),yield{value:u,description:s}}}}function Yu(t){let e=[];for(let[r,n]of Object.entries(t)){let o={name:r,...n};Array.isArray(o.default)&&(o.default=y(!1,o.default,-1).value),e.push(o)}return e}var ju=t=>t.split(/[/\\\\]/).pop();function Pr(t,e){if(!e)return;let r=ju(e).toLowerCase();return t.find(n=>{var o,u;return((o=n.extensions)==null?void 0:o.some(i=>r.endsWith(i)))||((u=n.filenames)==null?void 0:u.some(i=>i.toLowerCase()===r))})}function Vu(t,e){if(e)return t.find(({name:r})=>r.toLowerCase()===e)??t.find(({aliases:r})=>r==null?void 0:r.includes(e))??t.find(({extensions:r})=>r==null?void 0:r.includes(`.${e}`))}function $u(t,e){let r=t.plugins.flatMap(o=>o.languages??[]),n=Vu(r,e.language)??Pr(r,e.physicalFile)??Pr(r,e.file)??(e.physicalFile,void 0);return n==null?void 0:n.parsers[0]}var Lr=$u;var te={key:t=>/^[$_a-zA-Z][$_a-zA-Z0-9]*$/.test(t)?t:JSON.stringify(t),value(t){if(t===null||typeof t!=\"object\")return JSON.stringify(t);if(Array.isArray(t))return`[${t.map(r=>te.value(r)).join(\", \")}]`;let e=Object.keys(t);return e.length===0?\"{}\":`{ ${e.map(r=>`${te.key(r)}: ${te.value(t[r])}`).join(\", \")} }`},pair:({key:t,value:e})=>te.value({[t]:e})};var bt=Ce(Pe(),1),Yr=(t,e,{descriptor:r})=>{let n=[`${bt.default.yellow(typeof t==\"string\"?r.key(t):r.pair(t))} is deprecated`];return e&&n.push(`we now treat it as ${bt.default.blue(typeof e==\"string\"?r.key(e):r.pair(e))}`),n.join(\"; \")+\".\"};var se=Ce(Pe(),1);var tt=Symbol.for(\"vnopts.VALUE_NOT_EXIST\"),de=Symbol.for(\"vnopts.VALUE_UNCHANGED\");var jr=\" \".repeat(2),$r=(t,e,r)=>{let{text:n,list:o}=r.normalizeExpectedResult(r.schemas[t].expected(r)),u=[];return n&&u.push(Vr(t,e,n,r.descriptor)),o&&u.push([Vr(t,e,o.title,r.descriptor)].concat(o.values.map(i=>Ur(i,r.loggerPrintWidth))).join(`\n`)),Mr(u,r.loggerPrintWidth)};function Vr(t,e,r,n){return[`Invalid ${se.default.red(n.key(t))} value.`,`Expected ${se.default.blue(r)},`,`but received ${e===tt?se.default.gray(\"nothing\"):se.default.red(n.value(e))}.`].join(\" \")}function Ur({text:t,list:e},r){let n=[];return t&&n.push(`- ${se.default.blue(t)}`),e&&n.push([`- ${se.default.blue(e.title)}:`].concat(e.values.map(o=>Ur(o,r-jr.length).replace(/^|\\n/g,`$&${jr}`))).join(`\n`)),Mr(n,r)}function Mr(t,e){if(t.length===1)return t[0];let[r,n]=t,[o,u]=t.map(i=>i.split(`\n`,1)[0].length);return o>e&&o>u?n:r}var Nt=Ce(Pe(),1);var wt=[],Wr=[];function Ot(t,e){if(t===e)return 0;let r=t;t.length>e.length&&(t=e,e=r);let n=t.length,o=e.length;for(;n>0&&t.charCodeAt(~-n)===e.charCodeAt(~-o);)n--,o--;let u=0;for(;us?D>s?s+1:D:D>a?a+1:D;return s}var rt=(t,e,{descriptor:r,logger:n,schemas:o})=>{let u=[`Ignored unknown option ${Nt.default.yellow(r.pair({key:t,value:e}))}.`],i=Object.keys(o).sort().find(s=>Ot(t,s)<3);i&&u.push(`Did you mean ${Nt.default.blue(r.key(i))}?`),n.warn(u.join(\" \"))};var Uu=[\"default\",\"expected\",\"validate\",\"deprecated\",\"forward\",\"redirect\",\"overlap\",\"preprocess\",\"postprocess\"];function Mu(t,e){let r=new t(e),n=Object.create(r);for(let o of Uu)o in e&&(n[o]=Wu(e[o],r,w.prototype[o].length));return n}var w=class{static create(e){return Mu(this,e)}constructor(e){this.name=e.name}default(e){}expected(e){return\"nothing\"}validate(e,r){return!1}deprecated(e,r){return!1}forward(e,r){}redirect(e,r){}overlap(e,r,n){return e}preprocess(e,r){return e}postprocess(e,r){return de}};function Wu(t,e,r){return typeof t==\"function\"?(...n)=>t(...n.slice(0,r-1),e,...n.slice(r-1)):()=>t}var nt=class extends w{constructor(e){super(e),this._sourceName=e.sourceName}expected(e){return e.schemas[this._sourceName].expected(e)}validate(e,r){return r.schemas[this._sourceName].validate(e,r)}redirect(e,r){return this._sourceName}};var ut=class extends w{expected(){return\"anything\"}validate(){return!0}};var ot=class extends w{constructor({valueSchema:e,name:r=e.name,...n}){super({...n,name:r}),this._valueSchema=e}expected(e){let{text:r,list:n}=e.normalizeExpectedResult(this._valueSchema.expected(e));return{text:r&&`an array of ${r}`,list:n&&{title:\"an array of the following values\",values:[{list:n}]}}}validate(e,r){if(!Array.isArray(e))return!1;let n=[];for(let o of e){let u=r.normalizeValidateResult(this._valueSchema.validate(o,r),o);u!==!0&&n.push(u.value)}return n.length===0?!0:{value:n}}deprecated(e,r){let n=[];for(let o of e){let u=r.normalizeDeprecatedResult(this._valueSchema.deprecated(o,r),o);u!==!1&&n.push(...u.map(({value:i})=>({value:[i]})))}return n}forward(e,r){let n=[];for(let o of e){let u=r.normalizeForwardResult(this._valueSchema.forward(o,r),o);n.push(...u.map(zr))}return n}redirect(e,r){let n=[],o=[];for(let u of e){let i=r.normalizeRedirectResult(this._valueSchema.redirect(u,r),u);\"remain\"in i&&n.push(i.remain),o.push(...i.redirect.map(zr))}return n.length===0?{redirect:o}:{redirect:o,remain:n}}overlap(e,r){return e.concat(r)}};function zr({from:t,to:e}){return{from:[t],to:e}}var it=class extends w{expected(){return\"true or false\"}validate(e){return typeof e==\"boolean\"}};function Kr(t,e){let r=Object.create(null);for(let n of t){let o=n[e];if(r[o])throw new Error(`Duplicate ${e} ${JSON.stringify(o)}`);r[o]=n}return r}function Hr(t,e){let r=new Map;for(let n of t){let o=n[e];if(r.has(o))throw new Error(`Duplicate ${e} ${JSON.stringify(o)}`);r.set(o,n)}return r}function qr(){let t=Object.create(null);return e=>{let r=JSON.stringify(e);return t[r]?!0:(t[r]=!0,!1)}}function Jr(t,e){let r=[],n=[];for(let o of t)e(o)?r.push(o):n.push(o);return[r,n]}function Xr(t){return t===Math.floor(t)}function Zr(t,e){if(t===e)return 0;let r=typeof t,n=typeof e,o=[\"undefined\",\"object\",\"boolean\",\"number\",\"string\"];return r!==n?o.indexOf(r)-o.indexOf(n):r!==\"string\"?Number(t)-Number(e):t.localeCompare(e)}function Qr(t){return(...e)=>{let r=t(...e);return typeof r==\"string\"?new Error(r):r}}function Tt(t){return t===void 0?{}:t}function St(t){if(typeof t==\"string\")return{text:t};let{text:e,list:r}=t;return zu((e||r)!==void 0,\"Unexpected `expected` result, there should be at least one field.\"),r?{text:e,list:{title:r.title,values:r.values.map(St)}}:{text:e}}function vt(t,e){return t===!0?!0:t===!1?{value:e}:t}function Pt(t,e,r=!1){return t===!1?!1:t===!0?r?!0:[{value:e}]:\"value\"in t?[t]:t.length===0?!1:t}function Gr(t,e){return typeof t==\"string\"||\"key\"in t?{from:e,to:t}:\"from\"in t?{from:t.from,to:t.to}:{from:e,to:t.to}}function st(t,e){return t===void 0?[]:Array.isArray(t)?t.map(r=>Gr(r,e)):[Gr(t,e)]}function Lt(t,e){let r=st(typeof t==\"object\"&&\"redirect\"in t?t.redirect:t,e);return r.length===0?{remain:e,redirect:r}:typeof t==\"object\"&&\"remain\"in t?{remain:t.remain,redirect:r}:{redirect:r}}function zu(t,e){if(!t)throw new Error(e)}var at=class extends w{constructor(e){super(e),this._choices=Hr(e.choices.map(r=>r&&typeof r==\"object\"?r:{value:r}),\"value\")}expected({descriptor:e}){let r=Array.from(this._choices.keys()).map(i=>this._choices.get(i)).filter(({hidden:i})=>!i).map(i=>i.value).sort(Zr).map(e.value),n=r.slice(0,-2),o=r.slice(-2);return{text:n.concat(o.join(\" or \")).join(\", \"),list:{title:\"one of the following values\",values:r}}}validate(e){return this._choices.has(e)}deprecated(e){let r=this._choices.get(e);return r&&r.deprecated?{value:e}:!1}forward(e){let r=this._choices.get(e);return r?r.forward:void 0}redirect(e){let r=this._choices.get(e);return r?r.redirect:void 0}};var Dt=class extends w{expected(){return\"a number\"}validate(e,r){return typeof e==\"number\"}};var ct=class extends Dt{expected(){return\"an integer\"}validate(e,r){return r.normalizeValidateResult(super.validate(e,r),e)===!0&&Xr(e)}};var Le=class extends w{expected(){return\"a string\"}validate(e){return typeof e==\"string\"}};var en=te,tn=rt,rn=$r,nn=Yr;var lt=class{constructor(e,r){let{logger:n=console,loggerPrintWidth:o=80,descriptor:u=en,unknown:i=tn,invalid:s=rn,deprecated:a=nn,missing:D=()=>!1,required:c=()=>!1,preprocess:F=d=>d,postprocess:f=()=>de}=r||{};this._utils={descriptor:u,logger:n||{warn:()=>{}},loggerPrintWidth:o,schemas:Kr(e,\"name\"),normalizeDefaultResult:Tt,normalizeExpectedResult:St,normalizeDeprecatedResult:Pt,normalizeForwardResult:st,normalizeRedirectResult:Lt,normalizeValidateResult:vt},this._unknownHandler=i,this._invalidHandler=Qr(s),this._deprecatedHandler=a,this._identifyMissing=(d,l)=>!(d in l)||D(d,l),this._identifyRequired=c,this._preprocess=F,this._postprocess=f,this.cleanHistory()}cleanHistory(){this._hasDeprecationWarned=qr()}normalize(e){let r={},o=[this._preprocess(e,this._utils)],u=()=>{for(;o.length!==0;){let i=o.shift(),s=this._applyNormalization(i,r);o.push(...s)}};u();for(let i of Object.keys(this._utils.schemas)){let s=this._utils.schemas[i];if(!(i in r)){let a=Tt(s.default(this._utils));\"value\"in a&&o.push({[i]:a.value})}}u();for(let i of Object.keys(this._utils.schemas)){if(!(i in r))continue;let s=this._utils.schemas[i],a=r[i],D=s.postprocess(a,this._utils);D!==de&&(this._applyValidation(D,i,s),r[i]=D)}return this._applyPostprocess(r),this._applyRequiredCheck(r),r}_applyNormalization(e,r){let n=[],{knownKeys:o,unknownKeys:u}=this._partitionOptionKeys(e);for(let i of o){let s=this._utils.schemas[i],a=s.preprocess(e[i],this._utils);this._applyValidation(a,i,s);let D=({from:d,to:l})=>{n.push(typeof l==\"string\"?{[l]:d}:{[l.key]:l.value})},c=({value:d,redirectTo:l})=>{let p=Pt(s.deprecated(d,this._utils),a,!0);if(p!==!1)if(p===!0)this._hasDeprecationWarned(i)||this._utils.logger.warn(this._deprecatedHandler(i,l,this._utils));else for(let{value:m}of p){let E={key:i,value:m};if(!this._hasDeprecationWarned(E)){let h=typeof l==\"string\"?{key:l,value:m}:l;this._utils.logger.warn(this._deprecatedHandler(E,h,this._utils))}}};st(s.forward(a,this._utils),a).forEach(D);let f=Lt(s.redirect(a,this._utils),a);if(f.redirect.forEach(D),\"remain\"in f){let d=f.remain;r[i]=i in r?s.overlap(r[i],d,this._utils):d,c({value:d})}for(let{from:d,to:l}of f.redirect)c({value:d,redirectTo:l})}for(let i of u){let s=e[i];this._applyUnknownHandler(i,s,r,(a,D)=>{n.push({[a]:D})})}return n}_applyRequiredCheck(e){for(let r of Object.keys(this._utils.schemas))if(this._identifyMissing(r,e)&&this._identifyRequired(r))throw this._invalidHandler(r,tt,this._utils)}_partitionOptionKeys(e){let[r,n]=Jr(Object.keys(e).filter(o=>!this._identifyMissing(o,e)),o=>o in this._utils.schemas);return{knownKeys:r,unknownKeys:n}}_applyValidation(e,r,n){let o=vt(n.validate(e,this._utils),e);if(o!==!0)throw this._invalidHandler(r,o.value,this._utils)}_applyUnknownHandler(e,r,n,o){let u=this._unknownHandler(e,r,this._utils);if(u)for(let i of Object.keys(u)){if(this._identifyMissing(i,u))continue;let s=u[i];i in this._utils.schemas?o(i,s):n[i]=s}}_applyPostprocess(e){let r=this._postprocess(e,this._utils);if(r!==de){if(r.delete)for(let n of r.delete)delete e[n];if(r.override){let{knownKeys:n,unknownKeys:o}=this._partitionOptionKeys(r.override);for(let u of n){let i=r.override[u];this._applyValidation(i,u,this._utils.schemas[u]),e[u]=i}for(let u of o){let i=r.override[u];this._applyUnknownHandler(u,i,e,(s,a)=>{let D=this._utils.schemas[s];this._applyValidation(a,s,D),e[s]=a})}}}}};var It;function Ku(t,e,{logger:r=!1,isCLI:n=!1,passThrough:o=!1,FlagSchema:u,descriptor:i}={}){if(n){if(!u)throw new Error(\"'FlagSchema' option is required.\");if(!i)throw new Error(\"'descriptor' option is required.\")}else i=te;let s=o?Array.isArray(o)?(f,d)=>o.includes(f)?{[f]:d}:void 0:(f,d)=>({[f]:d}):(f,d,l)=>{let{_:p,...m}=l.schemas;return rt(f,d,{...l,schemas:m})},a=Hu(e,{isCLI:n,FlagSchema:u}),D=new lt(a,{logger:r,unknown:s,descriptor:i}),c=r!==!1;c&&It&&(D._hasDeprecationWarned=It);let F=D.normalize(t);return c&&(It=D._hasDeprecationWarned),F}function Hu(t,{isCLI:e,FlagSchema:r}){let n=[];e&&n.push(ut.create({name:\"_\"}));for(let o of t)n.push(qu(o,{isCLI:e,optionInfos:t,FlagSchema:r})),o.alias&&e&&n.push(nt.create({name:o.alias,sourceName:o.name}));return n}function qu(t,{isCLI:e,optionInfos:r,FlagSchema:n}){let{name:o}=t,u={name:o},i,s={};switch(t.type){case\"int\":i=ct,e&&(u.preprocess=Number);break;case\"string\":i=Le;break;case\"choice\":i=at,u.choices=t.choices.map(a=>a!=null&&a.redirect?{...a,redirect:{to:{key:t.name,value:a.redirect}}}:a);break;case\"boolean\":i=it;break;case\"flag\":i=n,u.flags=r.flatMap(a=>[a.alias,a.description&&a.name,a.oppositeDescription&&`no-${a.name}`].filter(Boolean));break;case\"path\":i=Le;break;default:throw new Error(`Unexpected type ${t.type}`)}if(t.exception?u.validate=(a,D,c)=>t.exception(a)||D.validate(a,c):u.validate=(a,D,c)=>a===void 0||D.validate(a,c),t.redirect&&(s.redirect=a=>a?{to:{key:t.redirect.option,value:t.redirect.value}}:void 0),t.deprecated&&(s.deprecated=!0),e&&!t.array){let a=u.preprocess||(D=>D);u.preprocess=(D,c,F)=>c.preprocess(a(Array.isArray(D)?y(!1,D,-1):D),F)}return t.array?ot.create({...e?{preprocess:a=>Array.isArray(a)?a:[a]}:{},...s,valueSchema:i.create(u)}):i.create({...u,...s})}var un=Ku;function Rt(t,e){if(!e)throw new Error(\"parserName is required.\");for(let n=t.length-1;n>=0;n--){let o=t[n];if(o.parsers&&Object.prototype.hasOwnProperty.call(o.parsers,e))return o}let r=`Couldn't resolve parser \"${e}\".`;throw r+=\" Plugins must be explicitly added to the standalone bundle.\",new Se(r)}function on(t,e){if(!e)throw new Error(\"astFormat is required.\");for(let n=t.length-1;n>=0;n--){let o=t[n];if(o.printers&&Object.prototype.hasOwnProperty.call(o.printers,e))return o}let r=`Couldn't find plugin for AST format \"${e}\".`;throw r+=\" Plugins must be explicitly added to the standalone bundle.\",new Se(r)}function ft({plugins:t,parser:e}){let r=Rt(t,e);return Yt(r,e)}function Yt(t,e){let r=t.parsers[e];return typeof r==\"function\"?r():r}function sn(t,e){let r=t.printers[e];return typeof r==\"function\"?r():r}var an={astFormat:\"estree\",printer:{},originalText:void 0,locStart:null,locEnd:null};async function Ju(t,e={}){var F;let r={...t};if(!r.parser)if(r.filepath){if(r.parser=Lr(r,{physicalFile:r.filepath}),!r.parser)throw new ve(`No parser could be inferred for file \"${r.filepath}\".`)}else throw new ve(\"No parser and no file path given, couldn't infer a parser.\");let n=et({plugins:t.plugins,showDeprecated:!0}).options,o={...an,...Object.fromEntries(n.filter(f=>f.default!==void 0).map(f=>[f.name,f.default]))},u=Rt(r.plugins,r.parser),i=await Yt(u,r.parser);r.astFormat=i.astFormat,r.locEnd=i.locEnd,r.locStart=i.locStart;let s=(F=u.printers)!=null&&F[i.astFormat]?u:on(r.plugins,i.astFormat),a=await sn(s,i.astFormat);r.printer=a;let D=s.defaultOptions?Object.fromEntries(Object.entries(s.defaultOptions).filter(([,f])=>f!==void 0)):{},c={...o,...D};for(let[f,d]of Object.entries(c))(r[f]===null||r[f]===void 0)&&(r[f]=d);return r.parser===\"json\"&&(r.trailingComma=\"none\"),un(r,n,{passThrough:Object.keys(an),...e})}var re=Ju;var Dn=new Set([\"tokens\",\"comments\",\"parent\",\"enclosingNode\",\"precedingNode\",\"followingNode\"]),Xu=t=>Object.keys(t).filter(e=>!Dn.has(e));function Zu(t){return t?e=>t(e,Dn):Xu}var H=Zu;function Qu(t,e){let{printer:{massageAstNode:r,getVisitorKeys:n}}=e;if(!r)return t;let o=H(n),u=r.ignoredProperties??new Set;return i(t);function i(s,a){if(!(s!==null&&typeof s==\"object\"))return s;if(Array.isArray(s))return s.map(f=>i(f,a)).filter(Boolean);let D={},c=new Set(o(s));for(let f in s)!Object.prototype.hasOwnProperty.call(s,f)||u.has(f)||(c.has(f)?D[f]=i(s[f],s):D[f]=s[f]);let F=r(s,D,a);if(F!==null)return F??D}}var cn=Qu;var Cn=Ce(hn(),1);async function so(t,e){let r=await ft(e),n=r.preprocess?r.preprocess(t,e):t;e.originalText=n;let o;try{o=await r.parse(n,e,e)}catch(u){ao(u,t)}return{text:n,ast:o}}function ao(t,e){let{loc:r}=t;if(r){let n=(0,Cn.codeFrameColumns)(e,r,{highlightCode:!0});throw t.message+=`\n`+n,t.codeFrame=n,t}throw t}var ae=so;var Ie,$t,Fe,dt,Vt=class{constructor(e){Ct(this,Ie);Ct(this,Fe);this.stack=[e]}get key(){let{stack:e,siblings:r}=this;return y(!1,e,r===null?-2:-4)??null}get index(){return this.siblings===null?null:y(!1,this.stack,-2)}get node(){return y(!1,this.stack,-1)}get parent(){return this.getNode(1)}get grandparent(){return this.getNode(2)}get isInArray(){return this.siblings!==null}get siblings(){let{stack:e}=this,r=y(!1,e,-3);return Array.isArray(r)?r:null}get next(){let{siblings:e}=this;return e===null?null:e[this.index+1]}get previous(){let{siblings:e}=this;return e===null?null:e[this.index-1]}get isFirst(){return this.index===0}get isLast(){let{siblings:e,index:r}=this;return e!==null&&r===e.length-1}get isRoot(){return this.stack.length===1}get root(){return this.stack[0]}get ancestors(){return[...ce(this,Fe,dt).call(this)]}getName(){let{stack:e}=this,{length:r}=e;return r>1?y(!1,e,-2):null}getValue(){return y(!1,this.stack,-1)}getNode(e=0){let r=ce(this,Ie,$t).call(this,e);return r===-1?null:this.stack[r]}getParentNode(e=0){return this.getNode(e+1)}call(e,...r){let{stack:n}=this,{length:o}=n,u=y(!1,n,-1);for(let i of r)u=u[i],n.push(i,u);try{return e(this)}finally{n.length=o}}callParent(e,r=0){let n=ce(this,Ie,$t).call(this,r+1),o=this.stack.splice(n+1);try{return e(this)}finally{this.stack.push(...o)}}each(e,...r){let{stack:n}=this,{length:o}=n,u=y(!1,n,-1);for(let i of r)u=u[i],n.push(i,u);try{for(let i=0;i{n[u]=e(o,u,i)},...r),n}match(...e){let r=this.stack.length-1,n=null,o=this.stack[r--];for(let u of e){if(o===void 0)return!1;let i=null;if(typeof n==\"number\"&&(i=n,n=this.stack[r--],o=this.stack[r--]),u&&!u(o,n,i))return!1;n=this.stack[r--],o=this.stack[r--]}return!0}findAncestor(e){for(let r of ce(this,Fe,dt).call(this))if(e(r))return r}hasAncestor(e){for(let r of ce(this,Fe,dt).call(this))if(e(r))return!0;return!1}};Ie=new WeakSet,$t=function(e){let{stack:r}=this;for(let n=r.length-1;n>=0;n-=2)if(!Array.isArray(r[n])&&--e<0)return n;return-1},Fe=new WeakSet,dt=function*(){let{stack:e}=this;for(let r=e.length-3;r>=0;r-=2){let n=e[r];Array.isArray(n)||(yield n)}};var gn=Vt;var yn=new Proxy(()=>{},{get:()=>yn}),Re=yn;function me(t){return(e,r,n)=>{let o=!!(n!=null&&n.backwards);if(r===!1)return!1;let{length:u}=e,i=r;for(;i>=0&&i0}var Ut=lo;function fo(t){return t!==null&&typeof t==\"object\"}var _n=fo;function*Mt(t,e){let{getVisitorKeys:r,filter:n=()=>!0}=e,o=u=>_n(u)&&n(u);for(let u of r(t)){let i=t[u];if(Array.isArray(i))for(let s of i)o(s)&&(yield s);else o(i)&&(yield i)}}function*An(t,e){let r=[t];for(let n=0;n20&&(r=r.slice(0,19)+\"\\u2026\"),e+(r?\" \"+r:\"\")}function Wt(t,e){(t.comments??(t.comments=[])).push(e),e.printed=!1,e.nodeDescription=po(t)}function ne(t,e){e.leading=!0,e.trailing=!1,Wt(t,e)}function X(t,e,r){e.leading=!1,e.trailing=!1,r&&(e.marker=r),Wt(t,e)}function ue(t,e){e.leading=!1,e.trailing=!0,Wt(t,e)}var zt=new WeakMap;function Et(t,e){if(zt.has(t))return zt.get(t);let{printer:{getCommentChildNodes:r,canAttachComment:n,getVisitorKeys:o},locStart:u,locEnd:i}=e;if(!n)return[];let s=((r==null?void 0:r(t,e))??[...Mt(t,{getVisitorKeys:H(o)})]).flatMap(a=>n(a)?[a]:Et(a,e));return s.sort((a,D)=>u(a)-u(D)||i(a)-i(D)),zt.set(t,s),s}function kn(t,e,r,n){let{locStart:o,locEnd:u}=r,i=o(e),s=u(e),a=Et(t,r),D,c,F=0,f=a.length;for(;F>1,l=a[d],p=o(l),m=u(l);if(p<=i&&s<=m)return kn(l,e,r,l);if(m<=i){D=l,F=d+1;continue}if(s<=p){c=l,f=d;continue}throw new Error(\"Comment location overlaps with node location\")}if((n==null?void 0:n.type)===\"TemplateLiteral\"){let{quasis:d}=n,l=Kt(d,e,r);D&&Kt(d,D,r)!==l&&(D=null),c&&Kt(d,c,r)!==l&&(c=null)}return{enclosingNode:n,precedingNode:D,followingNode:c}}var Gt=()=>!1;function bn(t,e){let{comments:r}=t;if(delete t.comments,!Ut(r)||!e.printer.canAttachComment)return;let n=[],{locStart:o,locEnd:u,printer:{experimentalFeatures:{avoidAstMutation:i=!1}={},handleComments:s={}},originalText:a}=e,{ownLine:D=Gt,endOfLine:c=Gt,remaining:F=Gt}=s,f=r.map((d,l)=>({...kn(t,d,e),comment:d,text:a,options:e,ast:t,isLastComment:r.length-1===l}));for(let[d,l]of f.entries()){let{comment:p,precedingNode:m,enclosingNode:E,followingNode:h,text:g,options:C,ast:_,isLastComment:Z}=l;if(C.parser===\"json\"||C.parser===\"json5\"||C.parser===\"__js_expression\"||C.parser===\"__ts_expression\"||C.parser===\"__vue_expression\"||C.parser===\"__vue_ts_expression\"){if(o(p)-o(_)<=0){ne(_,p);continue}if(u(p)-u(_)>=0){ue(_,p);continue}}let $;if(i?$=[l]:(p.enclosingNode=E,p.precedingNode=m,p.followingNode=h,$=[p,g,C,_,Z]),Fo(g,C,f,d))p.placement=\"ownLine\",D(...$)||(h?ne(h,p):m?ue(m,p):E?X(E,p):X(_,p));else if(mo(g,C,f,d))p.placement=\"endOfLine\",c(...$)||(m?ue(m,p):h?ne(h,p):E?X(E,p):X(_,p));else if(p.placement=\"remaining\",!F(...$))if(m&&h){let Q=n.length;Q>0&&n[Q-1].followingNode!==h&&Bn(n,C),n.push(l)}else m?ue(m,p):h?ne(h,p):E?X(E,p):X(_,p)}if(Bn(n,e),!i)for(let d of r)delete d.precedingNode,delete d.enclosingNode,delete d.followingNode}var wn=t=>!/[\\S\\n\\u2028\\u2029]/.test(t);function Fo(t,e,r,n){let{comment:o,precedingNode:u}=r[n],{locStart:i,locEnd:s}=e,a=i(o);if(u)for(let D=n-1;D>=0;D--){let{comment:c,precedingNode:F}=r[D];if(F!==u||!wn(t.slice(s(c),a)))break;a=i(c)}return V(t,a,{backwards:!0})}function mo(t,e,r,n){let{comment:o,followingNode:u}=r[n],{locStart:i,locEnd:s}=e,a=s(o);if(u)for(let D=n+1;D0;--i){let{comment:D,precedingNode:c,followingNode:F}=t[i-1];Re.strictEqual(c,n),Re.strictEqual(F,o);let f=e.originalText.slice(e.locEnd(D),u);if(((a=(s=e.printer).isGap)==null?void 0:a.call(s,f,e))??/^[\\s(]*$/.test(f))u=e.locStart(D);else break}for(let[D,{comment:c}]of t.entries())D1&&D.comments.sort((c,F)=>e.locStart(c)-e.locStart(F));t.length=0}function Kt(t,e,r){let n=r.locStart(e)-1;for(let o=1;o!n.has(a)).length===0)return{leading:\"\",trailing:\"\"};let u=[],i=[],s;return t.each(()=>{let a=t.node;if(n!=null&&n.has(a))return;let{leading:D,trailing:c}=a;D?u.push(ho(t,e)):c&&(s=Co(t,e,s),i.push(s.doc))},\"comments\"),{leading:u,trailing:i}}function Nn(t,e,r){let{leading:n,trailing:o}=go(t,r);return!n&&!o?e:Ze(e,u=>[n,u,o])}function Tn(t){let{[Symbol.for(\"comments\")]:e,[Symbol.for(\"printedComments\")]:r}=t;for(let n of e){if(!n.printed&&!r.has(n))throw new Error('Comment \"'+n.value.trim()+'\" was not printed. Please report this error!');delete n.printed}}async function Sn(t,e,r,n,o){let{embeddedLanguageFormatting:u,printer:{embed:i,hasPrettierIgnore:s=()=>!1,getVisitorKeys:a}}=r;if(!i||u!==\"auto\")return;if(i.length>2)throw new Error(\"printer.embed has too many parameters. The API changed in Prettier v3. Please update your plugin. See https://prettier.io/docs/en/plugins.html#optional-embed\");let D=H(i.getVisitorKeys??a),c=[];d();let F=t.stack;for(let{print:l,node:p,pathStack:m}of c)try{t.stack=m;let E=await l(f,e,t,r);E&&o.set(p,E)}catch(E){if(globalThis.PRETTIER_DEBUG)throw E}t.stack=F;function f(l,p){return yo(l,p,r,n)}function d(){let{node:l}=t;if(l===null||typeof l!=\"object\"||s(t))return;for(let m of D(l))Array.isArray(l[m])?t.each(d,m):t.call(d,m);let p=i(t,r);if(p){if(typeof p==\"function\"){c.push({print:p,node:l,pathStack:[...t.stack]});return}o.set(l,p)}}}async function yo(t,e,r,n){let o=await re({...r,...e,parentParser:r.parser,originalText:t},{passThrough:!0}),{ast:u}=await ae(t,o),i=await n(u,o);return Xe(i)}function xo(t){return()=>{}}var vn=xo;function _o(t,e){let{originalText:r,[Symbol.for(\"comments\")]:n,locStart:o,locEnd:u,[Symbol.for(\"printedComments\")]:i}=e,{node:s}=t,a=o(s),D=u(s);for(let c of n)o(c)>=a&&u(c)<=D&&i.add(c);return r.slice(a,D)}var Pn=_o;async function je(t,e){({ast:t}=await Ht(t,e));let r=new Map,n=new gn(t),o=vn(e),u=new Map;await Sn(n,s,e,je,u);let i=await Ln(n,e,s,void 0,u);return Tn(e),i;function s(D,c){return D===void 0||D===n?a(c):Array.isArray(D)?n.call(()=>a(c),...D):n.call(()=>a(c),D)}function a(D){o(n);let c=n.node;if(c==null)return\"\";let F=c&&typeof c==\"object\"&&D===void 0;if(F&&r.has(c))return r.get(c);let f=Ln(n,e,s,D,u);return F&&r.set(c,f),f}}function Ln(t,e,r,n,o){var a;let{node:u}=t,{printer:i}=e,s;return(a=i.hasPrettierIgnore)!=null&&a.call(i,t)?s=Pn(t,e):o.has(u)?s=o.get(u):s=i.print(t,e,r,n),u===e.cursorNode&&(s=Ze(s,D=>[Be,D,Be])),i.printComment&&(!i.willPrintOwnComments||!i.willPrintOwnComments(t,e))&&(s=Nn(t,s,e)),s}async function Ht(t,e){let r=t.comments??[];e[Symbol.for(\"comments\")]=r,e[Symbol.for(\"tokens\")]=t.tokens??[],e[Symbol.for(\"printedComments\")]=new Set,bn(t,e);let{printer:{preprocess:n}}=e;return t=n?await n(t,e):t,{ast:t,comments:r}}var Ao=({parser:t})=>t===\"json\"||t===\"json5\"||t===\"json-stringify\";function Bo(t,e){let r=[t.node,...t.parentNodes],n=new Set([e.node,...e.parentNodes]);return r.find(o=>Yn.has(o.type)&&n.has(o))}function In(t){let e=t.length-1;for(;;){let r=t[e];if((r==null?void 0:r.type)===\"Program\"||(r==null?void 0:r.type)===\"File\")e--;else break}return t.slice(0,e+1)}function ko(t,e,{locStart:r,locEnd:n}){let o=t.node,u=e.node;if(o===u)return{startNode:o,endNode:u};let i=r(t.node);for(let a of In(e.parentNodes))if(r(a)>=i)u=a;else break;let s=n(e.node);for(let a of In(t.parentNodes)){if(n(a)<=s)o=a;else break;if(o===u)break}return{startNode:o,endNode:u}}function qt(t,e,r,n,o=[],u){let{locStart:i,locEnd:s}=r,a=i(t),D=s(t);if(!(e>D||en);let s=t.slice(n,o).search(/\\S/),a=s===-1;if(!a)for(n+=s;o>n&&!/\\S/.test(t[o-1]);--o);let D=qt(r,n,e,(d,l)=>Rn(e,d,l),[],\"rangeStart\"),c=a?D:qt(r,o,e,d=>Rn(e,d),[],\"rangeEnd\");if(!D||!c)return{rangeStart:0,rangeEnd:0};let F,f;if(Ao(e)){let d=Bo(D,c);F=d,f=d}else({startNode:F,endNode:f}=ko(D,c,e));return{rangeStart:Math.min(u(F),u(f)),rangeEnd:Math.max(i(F),i(f))}}function Oo(t,e){let{cursorOffset:r,locStart:n,locEnd:o}=e,u=H(e.printer.getVisitorKeys),i=a=>n(a)<=r&&o(a)>=r,s=t;for(let a of An(t,{getVisitorKeys:u,filter:i}))s=a;return s}var Vn=Oo;var zn=\"\\uFEFF\",$n=Symbol(\"cursor\");async function Gn(t,e,r=0){if(!t||t.trim().length===0)return{formatted:\"\",cursorOffset:-1,comments:[]};let{ast:n,text:o}=await ae(t,e);e.cursorOffset>=0&&(e.cursorNode=Vn(n,e));let u=await je(n,e,r);r>0&&(u=qe([G,u],r,e.tabWidth));let i=fe(u,e);if(r>0){let a=i.formatted.trim();i.cursorNodeStart!==void 0&&(i.cursorNodeStart-=i.formatted.indexOf(a)),i.formatted=a+be(e.endOfLine)}let s=e[Symbol.for(\"comments\")];if(e.cursorOffset>=0){let a,D,c,F,f;if(e.cursorNode&&i.cursorNodeText?(a=e.locStart(e.cursorNode),D=o.slice(a,e.locEnd(e.cursorNode)),c=e.cursorOffset-a,F=i.cursorNodeStart,f=i.cursorNodeText):(a=0,D=o,c=e.cursorOffset,F=0,f=i.formatted),D===f)return{formatted:i.formatted,cursorOffset:F+c,comments:s};let d=D.split(\"\");d.splice(c,0,$n);let l=f.split(\"\"),p=(0,Wn.diffArrays)(d,l),m=F;for(let E of p)if(E.removed){if(E.value.includes($n))break}else m+=E.count;return{formatted:i.formatted,cursorOffset:m,comments:s}}return{formatted:i.formatted,cursorOffset:-1,comments:s}}async function No(t,e){let{ast:r,text:n}=await ae(t,e),{rangeStart:o,rangeEnd:u}=jn(n,e,r),i=n.slice(o,u),s=Math.min(o,n.lastIndexOf(`\n`,o)+1),a=n.slice(s,o).match(/^\\s*/)[0],D=pe(a,e.tabWidth),c=await Gn(i,{...e,rangeStart:0,rangeEnd:Number.POSITIVE_INFINITY,cursorOffset:e.cursorOffset>o&&e.cursorOffset<=u?e.cursorOffset-o:-1,endOfLine:\"lf\"},D),F=c.formatted.trimEnd(),{cursorOffset:f}=e;f>u?f+=F.length-i.length:c.cursorOffset>=0&&(f=c.cursorOffset+o);let d=n.slice(0,o)+F+n.slice(u);if(e.endOfLine!==\"lf\"){let l=be(e.endOfLine);f>=0&&l===`\\r\n`&&(f+=At(d.slice(0,f),`\n`)),d=ee(!1,d,`\n`,l)}return{formatted:d,cursorOffset:f,comments:c.comments}}function Jt(t,e,r){return typeof e!=\"number\"||Number.isNaN(e)||e<0||e>t.length?r:e}function Un(t,e){let{cursorOffset:r,rangeStart:n,rangeEnd:o}=e;return r=Jt(t,r,-1),n=Jt(t,n,0),o=Jt(t,o,t.length),{...e,cursorOffset:r,rangeStart:n,rangeEnd:o}}function Kn(t,e){let{cursorOffset:r,rangeStart:n,rangeEnd:o,endOfLine:u}=Un(t,e),i=t.charAt(0)===zn;if(i&&(t=t.slice(1),r--,n--,o--),u===\"auto\"&&(u=Cr(t)),t.includes(\"\\r\")){let s=a=>At(t.slice(0,Math.max(a,0)),`\\r\n`);r-=s(r),n-=s(n),o-=s(o),t=gr(t)}return{hasBOM:i,text:t,options:Un(t,{...e,cursorOffset:r,rangeStart:n,rangeEnd:o,endOfLine:u})}}async function Mn(t,e){let r=await ft(e);return!r.hasPragma||r.hasPragma(t)}async function Xt(t,e){let{hasBOM:r,text:n,options:o}=Kn(t,await re(e));if(o.rangeStart>=o.rangeEnd&&n!==\"\"||o.requirePragma&&!await Mn(n,o))return{formatted:t,cursorOffset:e.cursorOffset,comments:[]};let u;return o.rangeStart>0||o.rangeEnd=0&&u.cursorOffset++),u}async function Hn(t,e,r){let{text:n,options:o}=Kn(t,await re(e)),u=await ae(n,o);return r&&(r.preprocessForPrint&&(u.ast=await Ht(u.ast,o)),r.massage&&(u.ast=cn(u.ast,o))),u}async function qn(t,e){e=await re(e);let r=await je(t,e);return fe(r,e)}async function Jn(t,e){let r=Sr(t),{formatted:n}=await Xt(r,{...e,parser:\"__js_expression\"});return n}async function Xn(t,e){e=await re(e);let{ast:r}=await ae(t,e);return je(r,e)}async function Zn(t,e){return fe(t,await re(e))}var Qt={};Me(Qt,{addDanglingComment:()=>X,addLeadingComment:()=>ne,addTrailingComment:()=>ue,getAlignmentSize:()=>pe,getIndentSize:()=>eu,getMaxContinuousCount:()=>Qn,getNextNonSpaceNonCommentCharacter:()=>nu,getNextNonSpaceNonCommentCharacterIndex:()=>Mo,getStringWidth:()=>we,hasNewline:()=>V,hasNewlineInRange:()=>tu,hasSpaces:()=>ru,isNextLineEmpty:()=>Ko,isNextLineEmptyAfterIndex:()=>ht,isPreviousLineEmpty:()=>zo,makeString:()=>uu,skip:()=>me,skipEverythingButNewLine:()=>mt,skipInlineComment:()=>Ee,skipNewline:()=>Y,skipSpaces:()=>N,skipToLineEnd:()=>Ft,skipTrailingComment:()=>he,skipWhitespace:()=>xn});function So(t,e){if(e===!1)return!1;if(t.charAt(e)===\"/\"&&t.charAt(e+1)===\"*\"){for(let r=e+2;rMath.max(n,o.length/e.length),0)}var Qn=Io;function Ro(t,e){let r=t.lastIndexOf(`\n`);return r===-1?0:pe(t.slice(r+1).match(/^[\\t ]*/)[0],e)}var eu=Ro;function Yo(t,e,r){for(let n=e;ns===n?s:a===e?\"\\\\\"+a:a||(r&&/^[^\\n\\r\"'0-7\\\\bfnrt-vx\\u2028\\u2029]$/.test(s)?s:\"\\\\\"+s));return e+u+e}var uu=$o;function Uo(t,e,r){return Ve(t,r(e))}function Mo(t,e){return arguments.length===2||typeof e==\"number\"?Ve(t,e):Uo(...arguments)}function Wo(t,e,r){return Ye(t,r(e))}function zo(t,e){return arguments.length===2||typeof e==\"number\"?Ye(t,e):Wo(...arguments)}function Go(t,e,r){return ht(t,r(e))}function Ko(t,e){return arguments.length===2||typeof e==\"number\"?ht(t,e):Go(...arguments)}var er={};Me(er,{builders:()=>Ho,printer:()=>qo,utils:()=>Jo});var Ho={join:ke,line:Ke,softline:Er,hardline:G,literalline:He,group:xt,conditionalGroup:fr,fill:Ge,lineSuffix:_e,lineSuffixBoundary:Fr,cursor:Be,breakParent:le,ifBreak:pr,trim:mr,indent:ie,indentIfBreak:dr,align:oe,addAlignmentToDoc:qe,markAsRoot:cr,dedentToRoot:Dr,dedent:lr,hardlineWithoutBreakParent:Ae,literallineWithoutBreakParent:_t,label:hr,concat:t=>t},qo={printDocToString:fe},Jo={willBreak:kr,traverseDoc:xe,findInDoc:Je,mapDoc:Ne,removeLines:wr,stripTrailingHardline:Xe,replaceEndOfLine:Or,canBreak:Nr};var ou=\"3.0.3\";function De(t,e=1){return async(...r)=>{let n=r[e]??{},o=n.plugins??[];return r[e]={...n,plugins:Array.isArray(o)?o:Object.values(o)},t(...r)}}var iu=De(Xt);async function su(t,e){let{formatted:r}=await iu(t,{...e,cursorOffset:-1});return r}async function Xo(t,e){return await su(t,e)===t}var Zo=De(et,0),Qo={parse:De(Hn),formatAST:De(qn),formatDoc:De(Jn),printToDoc:De(Xn),printDocToString:De(Zn)};var Uc=tr;export{Qo as __debug,Xo as check,Uc as default,er as doc,su as format,iu as formatWithCursor,Zo as getSupportInfo,Qt as util,ou as version};\n","import * as Prettier from \"prettier/standalone\";\nimport * as prettierPluginLatex from \"./prettier-plugin-latex\";\n\n/**\n * Format `source` LaTeX code using Prettier to format/render\n * the code.\n *\n * @export\n * @param [source=\"\"] - code to be formatted\n * @param [options={}] - Prettier options object (you can set `printWidth` here)\n * @returns formatted code\n */\nexport async function printPrettier(source = \"\", options = {}) {\n return await Prettier.format(source, {\n printWidth: 80,\n useTabs: true,\n ...options,\n parser: \"latex-parser\",\n plugins: [prettierPluginLatex],\n });\n}\n\nexport { Prettier };\n"],"names":["Prettier.format","prettierPluginLatex"],"mappings":"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","x_google_ignoreList":[0]} \ No newline at end of file diff --git a/node_modules/prettier-plugin-latex/dist/standalone.mjs b/node_modules/prettier-plugin-latex/dist/standalone.mjs new file mode 100644 index 0000000..9b51dc4 --- /dev/null +++ b/node_modules/prettier-plugin-latex/dist/standalone.mjs @@ -0,0 +1,2459 @@ +var __defProp = Object.defineProperty; +var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value; +var __publicField = (obj, key, value) => { + __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value); + return value; +}; +import { p as prettierPluginLatex } from "./prettier-plugin-latex-9db821d0.mjs"; +var au = Object.create; +var $e = Object.defineProperty; +var Du = Object.getOwnPropertyDescriptor; +var cu = Object.getOwnPropertyNames; +var lu = Object.getPrototypeOf, fu = Object.prototype.hasOwnProperty; +var pu = (t, e) => () => (t && (e = t(t = 0)), e); +var Ue = (t, e) => () => (e || t((e = { exports: {} }).exports, e), e.exports), Me = (t, e) => { + for (var r in e) + $e(t, r, { get: e[r], enumerable: true }); +}, nr = (t, e, r, n) => { + if (e && typeof e == "object" || typeof e == "function") + for (let o of cu(e)) + !fu.call(t, o) && o !== r && $e(t, o, { get: () => e[o], enumerable: !(n = Du(e, o)) || n.enumerable }); + return t; +}; +var Ce = (t, e, r) => (r = t != null ? au(lu(t)) : {}, nr(e || !t || !t.__esModule ? $e(r, "default", { value: t, enumerable: true }) : r, t)), du = (t) => nr($e({}, "__esModule", { value: true }), t); +var Fu = (t, e, r) => { + if (!e.has(t)) + throw TypeError("Cannot " + r); +}; +var Ct = (t, e, r) => { + if (e.has(t)) + throw TypeError("Cannot add the same private member more than once"); + e instanceof WeakSet ? e.add(t) : e.set(t, r); +}; +var ce = (t, e, r) => (Fu(t, e, "access private method"), r); +var or = Ue((gt) => { + Object.defineProperty(gt, "__esModule", { value: true }); + gt.default = ur; + function ur() { + } + ur.prototype = { diff: function(e, r) { + var n = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {}, o = n.callback; + typeof n == "function" && (o = n, n = {}), this.options = n; + var u = this; + function i(p) { + return o ? (setTimeout(function() { + o(void 0, p); + }, 0), true) : p; + } + e = this.castInput(e), r = this.castInput(r), e = this.removeEmpty(this.tokenize(e)), r = this.removeEmpty(this.tokenize(r)); + var s = r.length, a = e.length, D = 1, c = s + a; + n.maxEditLength && (c = Math.min(c, n.maxEditLength)); + var F = [{ newPos: -1, components: [] }], f = this.extractCommon(F[0], r, e, 0); + if (F[0].newPos + 1 >= s && f + 1 >= a) + return i([{ value: this.join(r), count: r.length }]); + function d() { + for (var p = -1 * D; p <= D; p += 2) { + var m = void 0, E = F[p - 1], h = F[p + 1], g = (h ? h.newPos : 0) - p; + E && (F[p - 1] = void 0); + var C = E && E.newPos + 1 < s, _ = h && 0 <= g && g < a; + if (!C && !_) { + F[p] = void 0; + continue; + } + if (!C || _ && E.newPos < h.newPos ? (m = hu(h), u.pushComponent(m.components, void 0, true)) : (m = E, m.newPos++, u.pushComponent(m.components, true, void 0)), g = u.extractCommon(m, r, e, p), m.newPos + 1 >= s && g + 1 >= a) + return i(Eu(u, m.components, r, e, u.useLongestToken)); + F[p] = m; + } + D++; + } + if (o) + (function p() { + setTimeout(function() { + if (D > c) + return o(); + d() || p(); + }, 0); + })(); + else + for (; D <= c; ) { + var l = d(); + if (l) + return l; + } + }, pushComponent: function(e, r, n) { + var o = e[e.length - 1]; + o && o.added === r && o.removed === n ? e[e.length - 1] = { count: o.count + 1, added: r, removed: n } : e.push({ count: 1, added: r, removed: n }); + }, extractCommon: function(e, r, n, o) { + for (var u = r.length, i = n.length, s = e.newPos, a = s - o, D = 0; s + 1 < u && a + 1 < i && this.equals(r[s + 1], n[a + 1]); ) + s++, a++, D++; + return D && e.components.push({ count: D }), e.newPos = s, a; + }, equals: function(e, r) { + return this.options.comparator ? this.options.comparator(e, r) : e === r || this.options.ignoreCase && e.toLowerCase() === r.toLowerCase(); + }, removeEmpty: function(e) { + for (var r = [], n = 0; n < e.length; n++) + e[n] && r.push(e[n]); + return r; + }, castInput: function(e) { + return e; + }, tokenize: function(e) { + return e.split(""); + }, join: function(e) { + return e.join(""); + } }; + function Eu(t, e, r, n, o) { + for (var u = 0, i = e.length, s = 0, a = 0; u < i; u++) { + var D = e[u]; + if (D.removed) { + if (D.value = t.join(n.slice(a, a + D.count)), a += D.count, u && e[u - 1].added) { + var F = e[u - 1]; + e[u - 1] = e[u], e[u] = F; + } + } else { + if (!D.added && o) { + var c = r.slice(s, s + D.count); + c = c.map(function(d, l) { + var p = n[a + l]; + return p.length > d.length ? p : d; + }), D.value = t.join(c); + } else + D.value = t.join(r.slice(s, s + D.count)); + s += D.count, D.added || (a += D.count); + } + } + var f = e[i - 1]; + return i > 1 && typeof f.value == "string" && (f.added || f.removed) && t.equals("", f.value) && (e[i - 2].value += f.value, e.pop()), e; + } + function hu(t) { + return { newPos: t.newPos, components: t.components.slice(0) }; + } +}); +var ir = Ue((ye) => { + Object.defineProperty(ye, "__esModule", { value: true }); + ye.diffArrays = yu; + ye.arrayDiff = void 0; + var Cu = gu(or()); + function gu(t) { + return t && t.__esModule ? t : { default: t }; + } + var ge = new Cu.default(); + ye.arrayDiff = ge; + ge.tokenize = function(t) { + return t.slice(); + }; + ge.join = ge.removeEmpty = function(t) { + return t; + }; + function yu(t, e, r) { + return ge.diff(t, e, r); + } +}); +var Pe = Ue((ss, Rr) => { + var Ir = new Proxy(String, { get: () => Ir }); + Rr.exports = Ir; +}); +var ln = {}; +Me(ln, { default: () => to, shouldHighlight: () => eo }); +var eo, to, fn = pu(() => { + eo = () => false, to = String; +}); +var hn = Ue((pt) => { + Object.defineProperty(pt, "__esModule", { value: true }); + pt.codeFrameColumns = En; + pt.default = io; + var pn = (fn(), du(ln)), ro = Pe(), dn = ro, jt; + function no(t) { + if (t) { + return jt != null || (jt = new dn.constructor({ enabled: true, level: 1 })), jt; + } + return dn; + } + var Fn = false; + function uo(t) { + return { gutter: t.grey, marker: t.red.bold, message: t.red.bold }; + } + var mn = /\r\n|[\n\r\u2028\u2029]/; + function oo(t, e, r) { + let n = Object.assign({ column: 0, line: -1 }, t.start), o = Object.assign({}, n, t.end), { linesAbove: u = 2, linesBelow: i = 3 } = r || {}, s = n.line, a = n.column, D = o.line, c = o.column, F = Math.max(s - (u + 1), 0), f = Math.min(e.length, D + i); + s === -1 && (F = 0), D === -1 && (f = e.length); + let d = D - s, l = {}; + if (d) + for (let p = 0; p <= d; p++) { + let m = p + s; + if (!a) + l[m] = true; + else if (p === 0) { + let E = e[m - 1].length; + l[m] = [a, E - a + 1]; + } else if (p === d) + l[m] = [0, c]; + else { + let E = e[m - p].length; + l[m] = [0, E]; + } + } + else + a === c ? a ? l[s] = [a, 0] : l[s] = true : l[s] = [a, c - a]; + return { start: F, end: f, markerLines: l }; + } + function En(t, e, r = {}) { + let n = (r.highlightCode || r.forceColor) && (0, pn.shouldHighlight)(r), o = no(r.forceColor), u = uo(o), i = (p, m) => n ? p(m) : m, s = t.split(mn), { start: a, end: D, markerLines: c } = oo(e, s, r), F = e.start && typeof e.start.column == "number", f = String(D).length, l = (n ? (0, pn.default)(t, r) : t).split(mn, D).slice(a, D).map((p, m) => { + let E = a + 1 + m, g = ` ${` ${E}`.slice(-f)} |`, C = c[E], _ = !c[E + 1]; + if (C) { + let Z = ""; + if (Array.isArray(C)) { + let $ = p.slice(0, Math.max(C[0] - 1, 0)).replace(/[^\t]/g, " "), Q = C[1] || 1; + Z = [` + `, i(u.gutter, g.replace(/\d/g, " ")), " ", $, i(u.marker, "^").repeat(Q)].join(""), _ && r.message && (Z += " " + i(u.message, r.message)); + } + return [i(u.marker, ">"), i(u.gutter, g), p.length > 0 ? ` ${p}` : "", Z].join(""); + } else + return ` ${i(u.gutter, g)}${p.length > 0 ? ` ${p}` : ""}`; + }).join(` +`); + return r.message && !F && (l = `${" ".repeat(f + 1)}${r.message} +${l}`), n ? o.reset(l) : l; + } + function io(t, e, r, n = {}) { + if (!Fn) { + Fn = true; + let u = "Passing lineNumber and colNumber is deprecated to @babel/code-frame. Please use `codeFrameColumns`."; + { + let i = new Error(u); + i.name = "DeprecationWarning", console.warn(new Error(u)); + } + } + return r = Math.max(r, 0), En(t, { start: { column: r, line: e } }, n); + } +}); +var tr = {}; +Me(tr, { __debug: () => Qo, check: () => Xo, doc: () => er, format: () => su, formatWithCursor: () => iu, getSupportInfo: () => Zo, util: () => Qt, version: () => ou }); +var mu = (t, e, r, n) => { + if (!(t && e == null)) + return e.replaceAll ? e.replaceAll(r, n) : r.global ? e.replace(r, n) : e.split(r).join(n); +}, ee = mu; +var Wn = Ce(ir(), 1); +var U = "string", j = "array", M = "cursor", T = "indent", S = "align", v = "trim", A = "group", k = "fill", B = "if-break", P = "indent-if-break", L = "line-suffix", I = "line-suffix-boundary", x = "line", O = "label", b = "break-parent", We = /* @__PURE__ */ new Set([M, T, S, v, A, k, B, P, L, I, x, O, b]); +function xu(t) { + if (typeof t == "string") + return U; + if (Array.isArray(t)) + return j; + if (!t) + return; + let { type: e } = t; + if (We.has(e)) + return e; +} +var W = xu; +var _u = (t) => new Intl.ListFormat("en-US", { type: "disjunction" }).format(t); +function Au(t) { + let e = t === null ? "null" : typeof t; + if (e !== "string" && e !== "object") + return `Unexpected doc '${e}', +Expected it to be 'string' or 'object'.`; + if (W(t)) + throw new Error("doc is valid."); + let r = Object.prototype.toString.call(t); + if (r !== "[object Object]") + return `Unexpected doc '${r}'.`; + let n = _u([...We].map((o) => `'${o}'`)); + return `Unexpected doc.type '${t.type}'. +Expected it to be ${n}.`; +} +var yt = class extends Error { + constructor(e) { + super(Au(e)); + __publicField(this, "name", "InvalidDocError"); + this.doc = e; + } +}, q = yt; +var sr = {}; +function Bu(t, e, r, n) { + let o = [t]; + for (; o.length > 0; ) { + let u = o.pop(); + if (u === sr) { + r(o.pop()); + continue; + } + r && o.push(u, sr); + let i = W(u); + if (!i) + throw new q(u); + if ((e == null ? void 0 : e(u)) !== false) + switch (i) { + case j: + case k: { + let s = i === j ? u : u.parts; + for (let a = s.length, D = a - 1; D >= 0; --D) + o.push(s[D]); + break; + } + case B: + o.push(u.flatContents, u.breakContents); + break; + case A: + if (n && u.expandedStates) + for (let s = u.expandedStates.length, a = s - 1; a >= 0; --a) + o.push(u.expandedStates[a]); + else + o.push(u.contents); + break; + case S: + case T: + case P: + case O: + case L: + o.push(u.contents); + break; + case U: + case M: + case v: + case I: + case x: + case b: + break; + default: + throw new q(u); + } + } +} +var xe = Bu; +var ar = () => { +}, ze = ar; +function ie(t) { + return { type: T, contents: t }; +} +function oe(t, e) { + return { type: S, contents: e, n: t }; +} +function xt(t, e = {}) { + return ze(e.expandedStates), { type: A, id: e.id, contents: t, break: !!e.shouldBreak, expandedStates: e.expandedStates }; +} +function Dr(t) { + return oe(Number.NEGATIVE_INFINITY, t); +} +function cr(t) { + return oe({ type: "root" }, t); +} +function lr(t) { + return oe(-1, t); +} +function fr(t, e) { + return xt(t[0], { ...e, expandedStates: t }); +} +function Ge(t) { + return { type: k, parts: t }; +} +function pr(t, e = "", r = {}) { + return { type: B, breakContents: t, flatContents: e, groupId: r.groupId }; +} +function dr(t, e) { + return { type: P, contents: t, groupId: e.groupId, negate: e.negate }; +} +function _e(t) { + return { type: L, contents: t }; +} +var Fr = { type: I }, le = { type: b }, mr = { type: v }, Ae = { type: x, hard: true }, _t = { type: x, hard: true, literal: true }, Ke = { type: x }, Er = { type: x, soft: true }, G = [Ae, le], He = [_t, le], Be = { type: M }; +function ke(t, e) { + let r = []; + for (let n = 0; n < e.length; n++) + n !== 0 && r.push(t), r.push(e[n]); + return r; +} +function qe(t, e, r) { + let n = t; + if (e > 0) { + for (let o = 0; o < Math.floor(e / r); ++o) + n = ie(n); + n = oe(e % r, n), n = oe(Number.NEGATIVE_INFINITY, n); + } + return n; +} +function hr(t, e) { + return t ? { type: O, label: t, contents: e } : e; +} +var ku = (t, e, r) => { + if (!(t && e == null)) + return Array.isArray(e) || typeof e == "string" ? e[r < 0 ? e.length + r : r] : e.at(r); +}, y = ku; +function Cr(t) { + let e = t.indexOf("\r"); + return e >= 0 ? t.charAt(e + 1) === ` +` ? "crlf" : "cr" : "lf"; +} +function be(t) { + switch (t) { + case "cr": + return "\r"; + case "crlf": + return `\r +`; + default: + return ` +`; + } +} +function At(t, e) { + let r; + switch (e) { + case ` +`: + r = /\n/g; + break; + case "\r": + r = /\r/g; + break; + case `\r +`: + r = /\r\n/g; + break; + default: + throw new Error(`Unexpected "eol" ${JSON.stringify(e)}.`); + } + let n = t.match(r); + return n ? n.length : 0; +} +function gr(t) { + return ee(false, t, /\r\n?/g, ` +`); +} +var yr = () => /[#*0-9]\uFE0F?\u20E3|[\xA9\xAE\u203C\u2049\u2122\u2139\u2194-\u2199\u21A9\u21AA\u231A\u231B\u2328\u23CF\u23ED-\u23EF\u23F1\u23F2\u23F8-\u23FA\u24C2\u25AA\u25AB\u25B6\u25C0\u25FB\u25FC\u25FE\u2600-\u2604\u260E\u2611\u2614\u2615\u2618\u2620\u2622\u2623\u2626\u262A\u262E\u262F\u2638-\u263A\u2640\u2642\u2648-\u2653\u265F\u2660\u2663\u2665\u2666\u2668\u267B\u267E\u267F\u2692\u2694-\u2697\u2699\u269B\u269C\u26A0\u26A7\u26AA\u26B0\u26B1\u26BD\u26BE\u26C4\u26C8\u26CF\u26D1\u26D3\u26E9\u26F0-\u26F5\u26F7\u26F8\u26FA\u2702\u2708\u2709\u270F\u2712\u2714\u2716\u271D\u2721\u2733\u2734\u2744\u2747\u2757\u2763\u27A1\u2934\u2935\u2B05-\u2B07\u2B1B\u2B1C\u2B55\u3030\u303D\u3297\u3299]\uFE0F?|[\u261D\u270C\u270D](?:\uFE0F|\uD83C[\uDFFB-\uDFFF])?|[\u270A\u270B](?:\uD83C[\uDFFB-\uDFFF])?|[\u23E9-\u23EC\u23F0\u23F3\u25FD\u2693\u26A1\u26AB\u26C5\u26CE\u26D4\u26EA\u26FD\u2705\u2728\u274C\u274E\u2753-\u2755\u2795-\u2797\u27B0\u27BF\u2B50]|\u26F9(?:\uFE0F|\uD83C[\uDFFB-\uDFFF])?(?:\u200D[\u2640\u2642]\uFE0F?)?|\u2764\uFE0F?(?:\u200D(?:\uD83D\uDD25|\uD83E\uDE79))?|\uD83C(?:[\uDC04\uDD70\uDD71\uDD7E\uDD7F\uDE02\uDE37\uDF21\uDF24-\uDF2C\uDF36\uDF7D\uDF96\uDF97\uDF99-\uDF9B\uDF9E\uDF9F\uDFCD\uDFCE\uDFD4-\uDFDF\uDFF5\uDFF7]\uFE0F?|[\uDF85\uDFC2\uDFC7](?:\uD83C[\uDFFB-\uDFFF])?|[\uDFC3\uDFC4\uDFCA](?:\uD83C[\uDFFB-\uDFFF])?(?:\u200D[\u2640\u2642]\uFE0F?)?|[\uDFCB\uDFCC](?:\uFE0F|\uD83C[\uDFFB-\uDFFF])?(?:\u200D[\u2640\u2642]\uFE0F?)?|[\uDCCF\uDD8E\uDD91-\uDD9A\uDE01\uDE1A\uDE2F\uDE32-\uDE36\uDE38-\uDE3A\uDE50\uDE51\uDF00-\uDF20\uDF2D-\uDF35\uDF37-\uDF7C\uDF7E-\uDF84\uDF86-\uDF93\uDFA0-\uDFC1\uDFC5\uDFC6\uDFC8\uDFC9\uDFCF-\uDFD3\uDFE0-\uDFF0\uDFF8-\uDFFF]|\uDDE6\uD83C[\uDDE8-\uDDEC\uDDEE\uDDF1\uDDF2\uDDF4\uDDF6-\uDDFA\uDDFC\uDDFD\uDDFF]|\uDDE7\uD83C[\uDDE6\uDDE7\uDDE9-\uDDEF\uDDF1-\uDDF4\uDDF6-\uDDF9\uDDFB\uDDFC\uDDFE\uDDFF]|\uDDE8\uD83C[\uDDE6\uDDE8\uDDE9\uDDEB-\uDDEE\uDDF0-\uDDF5\uDDF7\uDDFA-\uDDFF]|\uDDE9\uD83C[\uDDEA\uDDEC\uDDEF\uDDF0\uDDF2\uDDF4\uDDFF]|\uDDEA\uD83C[\uDDE6\uDDE8\uDDEA\uDDEC\uDDED\uDDF7-\uDDFA]|\uDDEB\uD83C[\uDDEE-\uDDF0\uDDF2\uDDF4\uDDF7]|\uDDEC\uD83C[\uDDE6\uDDE7\uDDE9-\uDDEE\uDDF1-\uDDF3\uDDF5-\uDDFA\uDDFC\uDDFE]|\uDDED\uD83C[\uDDF0\uDDF2\uDDF3\uDDF7\uDDF9\uDDFA]|\uDDEE\uD83C[\uDDE8-\uDDEA\uDDF1-\uDDF4\uDDF6-\uDDF9]|\uDDEF\uD83C[\uDDEA\uDDF2\uDDF4\uDDF5]|\uDDF0\uD83C[\uDDEA\uDDEC-\uDDEE\uDDF2\uDDF3\uDDF5\uDDF7\uDDFC\uDDFE\uDDFF]|\uDDF1\uD83C[\uDDE6-\uDDE8\uDDEE\uDDF0\uDDF7-\uDDFB\uDDFE]|\uDDF2\uD83C[\uDDE6\uDDE8-\uDDED\uDDF0-\uDDFF]|\uDDF3\uD83C[\uDDE6\uDDE8\uDDEA-\uDDEC\uDDEE\uDDF1\uDDF4\uDDF5\uDDF7\uDDFA\uDDFF]|\uDDF4\uD83C\uDDF2|\uDDF5\uD83C[\uDDE6\uDDEA-\uDDED\uDDF0-\uDDF3\uDDF7-\uDDF9\uDDFC\uDDFE]|\uDDF6\uD83C\uDDE6|\uDDF7\uD83C[\uDDEA\uDDF4\uDDF8\uDDFA\uDDFC]|\uDDF8\uD83C[\uDDE6-\uDDEA\uDDEC-\uDDF4\uDDF7-\uDDF9\uDDFB\uDDFD-\uDDFF]|\uDDF9\uD83C[\uDDE6\uDDE8\uDDE9\uDDEB-\uDDED\uDDEF-\uDDF4\uDDF7\uDDF9\uDDFB\uDDFC\uDDFF]|\uDDFA\uD83C[\uDDE6\uDDEC\uDDF2\uDDF3\uDDF8\uDDFE\uDDFF]|\uDDFB\uD83C[\uDDE6\uDDE8\uDDEA\uDDEC\uDDEE\uDDF3\uDDFA]|\uDDFC\uD83C[\uDDEB\uDDF8]|\uDDFD\uD83C\uDDF0|\uDDFE\uD83C[\uDDEA\uDDF9]|\uDDFF\uD83C[\uDDE6\uDDF2\uDDFC]|\uDFF3\uFE0F?(?:\u200D(?:\u26A7\uFE0F?|\uD83C\uDF08))?|\uDFF4(?:\u200D\u2620\uFE0F?|\uDB40\uDC67\uDB40\uDC62\uDB40(?:\uDC65\uDB40\uDC6E\uDB40\uDC67|\uDC73\uDB40\uDC63\uDB40\uDC74|\uDC77\uDB40\uDC6C\uDB40\uDC73)\uDB40\uDC7F)?)|\uD83D(?:[\uDC08\uDC26](?:\u200D\u2B1B)?|[\uDC3F\uDCFD\uDD49\uDD4A\uDD6F\uDD70\uDD73\uDD76-\uDD79\uDD87\uDD8A-\uDD8D\uDDA5\uDDA8\uDDB1\uDDB2\uDDBC\uDDC2-\uDDC4\uDDD1-\uDDD3\uDDDC-\uDDDE\uDDE1\uDDE3\uDDE8\uDDEF\uDDF3\uDDFA\uDECB\uDECD-\uDECF\uDEE0-\uDEE5\uDEE9\uDEF0\uDEF3]\uFE0F?|[\uDC42\uDC43\uDC46-\uDC50\uDC66\uDC67\uDC6B-\uDC6D\uDC72\uDC74-\uDC76\uDC78\uDC7C\uDC83\uDC85\uDC8F\uDC91\uDCAA\uDD7A\uDD95\uDD96\uDE4C\uDE4F\uDEC0\uDECC](?:\uD83C[\uDFFB-\uDFFF])?|[\uDC6E\uDC70\uDC71\uDC73\uDC77\uDC81\uDC82\uDC86\uDC87\uDE45-\uDE47\uDE4B\uDE4D\uDE4E\uDEA3\uDEB4-\uDEB6](?:\uD83C[\uDFFB-\uDFFF])?(?:\u200D[\u2640\u2642]\uFE0F?)?|[\uDD74\uDD90](?:\uFE0F|\uD83C[\uDFFB-\uDFFF])?|[\uDC00-\uDC07\uDC09-\uDC14\uDC16-\uDC25\uDC27-\uDC3A\uDC3C-\uDC3E\uDC40\uDC44\uDC45\uDC51-\uDC65\uDC6A\uDC79-\uDC7B\uDC7D-\uDC80\uDC84\uDC88-\uDC8E\uDC90\uDC92-\uDCA9\uDCAB-\uDCFC\uDCFF-\uDD3D\uDD4B-\uDD4E\uDD50-\uDD67\uDDA4\uDDFB-\uDE2D\uDE2F-\uDE34\uDE37-\uDE44\uDE48-\uDE4A\uDE80-\uDEA2\uDEA4-\uDEB3\uDEB7-\uDEBF\uDEC1-\uDEC5\uDED0-\uDED2\uDED5-\uDED7\uDEDC-\uDEDF\uDEEB\uDEEC\uDEF4-\uDEFC\uDFE0-\uDFEB\uDFF0]|\uDC15(?:\u200D\uD83E\uDDBA)?|\uDC3B(?:\u200D\u2744\uFE0F?)?|\uDC41\uFE0F?(?:\u200D\uD83D\uDDE8\uFE0F?)?|\uDC68(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:\uDC8B\u200D\uD83D)?\uDC68|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D(?:[\uDC68\uDC69]\u200D\uD83D(?:\uDC66(?:\u200D\uD83D\uDC66)?|\uDC67(?:\u200D\uD83D[\uDC66\uDC67])?)|[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uDC66(?:\u200D\uD83D\uDC66)?|\uDC67(?:\u200D\uD83D[\uDC66\uDC67])?)|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\uD83C(?:\uDFFB(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:\uDC8B\u200D\uD83D)?\uDC68\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF-\uDDB3\uDDBC\uDDBD]|\uDD1D\u200D\uD83D\uDC68\uD83C[\uDFFC-\uDFFF])))?|\uDFFC(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:\uDC8B\u200D\uD83D)?\uDC68\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF-\uDDB3\uDDBC\uDDBD]|\uDD1D\u200D\uD83D\uDC68\uD83C[\uDFFB\uDFFD-\uDFFF])))?|\uDFFD(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:\uDC8B\u200D\uD83D)?\uDC68\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF-\uDDB3\uDDBC\uDDBD]|\uDD1D\u200D\uD83D\uDC68\uD83C[\uDFFB\uDFFC\uDFFE\uDFFF])))?|\uDFFE(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:\uDC8B\u200D\uD83D)?\uDC68\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF-\uDDB3\uDDBC\uDDBD]|\uDD1D\u200D\uD83D\uDC68\uD83C[\uDFFB-\uDFFD\uDFFF])))?|\uDFFF(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:\uDC8B\u200D\uD83D)?\uDC68\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF-\uDDB3\uDDBC\uDDBD]|\uDD1D\u200D\uD83D\uDC68\uD83C[\uDFFB-\uDFFE])))?))?|\uDC69(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:\uDC8B\u200D\uD83D)?[\uDC68\uDC69]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D(?:[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uDC66(?:\u200D\uD83D\uDC66)?|\uDC67(?:\u200D\uD83D[\uDC66\uDC67])?|\uDC69\u200D\uD83D(?:\uDC66(?:\u200D\uD83D\uDC66)?|\uDC67(?:\u200D\uD83D[\uDC66\uDC67])?))|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\uD83C(?:\uDFFB(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:[\uDC68\uDC69]|\uDC8B\u200D\uD83D[\uDC68\uDC69])\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF-\uDDB3\uDDBC\uDDBD]|\uDD1D\u200D\uD83D[\uDC68\uDC69]\uD83C[\uDFFC-\uDFFF])))?|\uDFFC(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:[\uDC68\uDC69]|\uDC8B\u200D\uD83D[\uDC68\uDC69])\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF-\uDDB3\uDDBC\uDDBD]|\uDD1D\u200D\uD83D[\uDC68\uDC69]\uD83C[\uDFFB\uDFFD-\uDFFF])))?|\uDFFD(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:[\uDC68\uDC69]|\uDC8B\u200D\uD83D[\uDC68\uDC69])\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF-\uDDB3\uDDBC\uDDBD]|\uDD1D\u200D\uD83D[\uDC68\uDC69]\uD83C[\uDFFB\uDFFC\uDFFE\uDFFF])))?|\uDFFE(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:[\uDC68\uDC69]|\uDC8B\u200D\uD83D[\uDC68\uDC69])\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF-\uDDB3\uDDBC\uDDBD]|\uDD1D\u200D\uD83D[\uDC68\uDC69]\uD83C[\uDFFB-\uDFFD\uDFFF])))?|\uDFFF(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:[\uDC68\uDC69]|\uDC8B\u200D\uD83D[\uDC68\uDC69])\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF-\uDDB3\uDDBC\uDDBD]|\uDD1D\u200D\uD83D[\uDC68\uDC69]\uD83C[\uDFFB-\uDFFE])))?))?|\uDC6F(?:\u200D[\u2640\u2642]\uFE0F?)?|\uDD75(?:\uFE0F|\uD83C[\uDFFB-\uDFFF])?(?:\u200D[\u2640\u2642]\uFE0F?)?|\uDE2E(?:\u200D\uD83D\uDCA8)?|\uDE35(?:\u200D\uD83D\uDCAB)?|\uDE36(?:\u200D\uD83C\uDF2B\uFE0F?)?)|\uD83E(?:[\uDD0C\uDD0F\uDD18-\uDD1F\uDD30-\uDD34\uDD36\uDD77\uDDB5\uDDB6\uDDBB\uDDD2\uDDD3\uDDD5\uDEC3-\uDEC5\uDEF0\uDEF2-\uDEF8](?:\uD83C[\uDFFB-\uDFFF])?|[\uDD26\uDD35\uDD37-\uDD39\uDD3D\uDD3E\uDDB8\uDDB9\uDDCD-\uDDCF\uDDD4\uDDD6-\uDDDD](?:\uD83C[\uDFFB-\uDFFF])?(?:\u200D[\u2640\u2642]\uFE0F?)?|[\uDDDE\uDDDF](?:\u200D[\u2640\u2642]\uFE0F?)?|[\uDD0D\uDD0E\uDD10-\uDD17\uDD20-\uDD25\uDD27-\uDD2F\uDD3A\uDD3F-\uDD45\uDD47-\uDD76\uDD78-\uDDB4\uDDB7\uDDBA\uDDBC-\uDDCC\uDDD0\uDDE0-\uDDFF\uDE70-\uDE7C\uDE80-\uDE88\uDE90-\uDEBD\uDEBF-\uDEC2\uDECE-\uDEDB\uDEE0-\uDEE8]|\uDD3C(?:\u200D[\u2640\u2642]\uFE0F?|\uD83C[\uDFFB-\uDFFF])?|\uDDD1(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\uD83C[\uDF3E\uDF73\uDF7C\uDF84\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF-\uDDB3\uDDBC\uDDBD]|\uDD1D\u200D\uD83E\uDDD1))|\uD83C(?:\uDFFB(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D(?:\uD83D\uDC8B\u200D)?\uD83E\uDDD1\uD83C[\uDFFC-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF84\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF-\uDDB3\uDDBC\uDDBD]|\uDD1D\u200D\uD83E\uDDD1\uD83C[\uDFFB-\uDFFF])))?|\uDFFC(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D(?:\uD83D\uDC8B\u200D)?\uD83E\uDDD1\uD83C[\uDFFB\uDFFD-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF84\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF-\uDDB3\uDDBC\uDDBD]|\uDD1D\u200D\uD83E\uDDD1\uD83C[\uDFFB-\uDFFF])))?|\uDFFD(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D(?:\uD83D\uDC8B\u200D)?\uD83E\uDDD1\uD83C[\uDFFB\uDFFC\uDFFE\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF84\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF-\uDDB3\uDDBC\uDDBD]|\uDD1D\u200D\uD83E\uDDD1\uD83C[\uDFFB-\uDFFF])))?|\uDFFE(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D(?:\uD83D\uDC8B\u200D)?\uD83E\uDDD1\uD83C[\uDFFB-\uDFFD\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF84\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF-\uDDB3\uDDBC\uDDBD]|\uDD1D\u200D\uD83E\uDDD1\uD83C[\uDFFB-\uDFFF])))?|\uDFFF(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D(?:\uD83D\uDC8B\u200D)?\uD83E\uDDD1\uD83C[\uDFFB-\uDFFE]|\uD83C[\uDF3E\uDF73\uDF7C\uDF84\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF-\uDDB3\uDDBC\uDDBD]|\uDD1D\u200D\uD83E\uDDD1\uD83C[\uDFFB-\uDFFF])))?))?|\uDEF1(?:\uD83C(?:\uDFFB(?:\u200D\uD83E\uDEF2\uD83C[\uDFFC-\uDFFF])?|\uDFFC(?:\u200D\uD83E\uDEF2\uD83C[\uDFFB\uDFFD-\uDFFF])?|\uDFFD(?:\u200D\uD83E\uDEF2\uD83C[\uDFFB\uDFFC\uDFFE\uDFFF])?|\uDFFE(?:\u200D\uD83E\uDEF2\uD83C[\uDFFB-\uDFFD\uDFFF])?|\uDFFF(?:\u200D\uD83E\uDEF2\uD83C[\uDFFB-\uDFFE])?))?)/g; +var xr = { eastAsianWidth(t) { + var e = t.charCodeAt(0), r = t.length == 2 ? t.charCodeAt(1) : 0, n = e; + return 55296 <= e && e <= 56319 && 56320 <= r && r <= 57343 && (e &= 1023, r &= 1023, n = e << 10 | r, n += 65536), n == 12288 || 65281 <= n && n <= 65376 || 65504 <= n && n <= 65510 ? "F" : 4352 <= n && n <= 4447 || 4515 <= n && n <= 4519 || 4602 <= n && n <= 4607 || 9001 <= n && n <= 9002 || 11904 <= n && n <= 11929 || 11931 <= n && n <= 12019 || 12032 <= n && n <= 12245 || 12272 <= n && n <= 12283 || 12289 <= n && n <= 12350 || 12353 <= n && n <= 12438 || 12441 <= n && n <= 12543 || 12549 <= n && n <= 12589 || 12593 <= n && n <= 12686 || 12688 <= n && n <= 12730 || 12736 <= n && n <= 12771 || 12784 <= n && n <= 12830 || 12832 <= n && n <= 12871 || 12880 <= n && n <= 13054 || 13056 <= n && n <= 19903 || 19968 <= n && n <= 42124 || 42128 <= n && n <= 42182 || 43360 <= n && n <= 43388 || 44032 <= n && n <= 55203 || 55216 <= n && n <= 55238 || 55243 <= n && n <= 55291 || 63744 <= n && n <= 64255 || 65040 <= n && n <= 65049 || 65072 <= n && n <= 65106 || 65108 <= n && n <= 65126 || 65128 <= n && n <= 65131 || 110592 <= n && n <= 110593 || 127488 <= n && n <= 127490 || 127504 <= n && n <= 127546 || 127552 <= n && n <= 127560 || 127568 <= n && n <= 127569 || 131072 <= n && n <= 194367 || 177984 <= n && n <= 196605 || 196608 <= n && n <= 262141 ? "W" : "N"; +} }; +var bu = /[^\x20-\x7F]/; +function wu(t) { + if (!t) + return 0; + if (!bu.test(t)) + return t.length; + t = t.replace(yr(), " "); + let e = 0; + for (let r of t) { + let n = r.codePointAt(0); + if (n <= 31 || n >= 127 && n <= 159 || n >= 768 && n <= 879) + continue; + let o = xr.eastAsianWidth(r); + e += o === "F" || o === "W" ? 2 : 1; + } + return e; +} +var we = wu; +var Br = (t) => { + if (Array.isArray(t)) + return t; + if (t.type !== k) + throw new Error(`Expect doc to be 'array' or '${k}'.`); + return t.parts; +}; +function Ne(t, e) { + if (typeof t == "string") + return e(t); + let r = /* @__PURE__ */ new Map(); + return n(t); + function n(u) { + if (r.has(u)) + return r.get(u); + let i = o(u); + return r.set(u, i), i; + } + function o(u) { + switch (W(u)) { + case j: + return e(u.map(n)); + case k: + return e({ ...u, parts: u.parts.map(n) }); + case B: + return e({ ...u, breakContents: n(u.breakContents), flatContents: n(u.flatContents) }); + case A: { + let { expandedStates: i, contents: s } = u; + return i ? (i = i.map(n), s = i[0]) : s = n(s), e({ ...u, contents: s, expandedStates: i }); + } + case S: + case T: + case P: + case O: + case L: + return e({ ...u, contents: n(u.contents) }); + case U: + case M: + case v: + case I: + case x: + case b: + return e(u); + default: + throw new q(u); + } + } +} +function Je(t, e, r) { + let n = r, o = false; + function u(i) { + if (o) + return false; + let s = e(i); + s !== void 0 && (o = true, n = s); + } + return xe(t, u), n; +} +function Ou(t) { + if (t.type === A && t.break || t.type === x && t.hard || t.type === b) + return true; +} +function kr(t) { + return Je(t, Ou, false); +} +function _r(t) { + if (t.length > 0) { + let e = y(false, t, -1); + !e.expandedStates && !e.break && (e.break = "propagated"); + } + return null; +} +function br(t) { + let e = /* @__PURE__ */ new Set(), r = []; + function n(u) { + if (u.type === b && _r(r), u.type === A) { + if (r.push(u), e.has(u)) + return false; + e.add(u); + } + } + function o(u) { + u.type === A && r.pop().break && _r(r); + } + xe(t, n, o, true); +} +function Nu(t) { + return t.type === x && !t.hard ? t.soft ? "" : " " : t.type === B ? t.flatContents : t; +} +function wr(t) { + return Ne(t, Nu); +} +function Ar(t) { + for (t = [...t]; t.length >= 2 && y(false, t, -2).type === x && y(false, t, -1).type === b; ) + t.length -= 2; + if (t.length > 0) { + let e = Oe(y(false, t, -1)); + t[t.length - 1] = e; + } + return t; +} +function Oe(t) { + switch (W(t)) { + case S: + case T: + case P: + case A: + case L: + case O: { + let e = Oe(t.contents); + return { ...t, contents: e }; + } + case B: + return { ...t, breakContents: Oe(t.breakContents), flatContents: Oe(t.flatContents) }; + case k: + return { ...t, parts: Ar(t.parts) }; + case j: + return Ar(t); + case U: + return t.replace(/[\n\r]*$/, ""); + case M: + case v: + case I: + case x: + case b: + break; + default: + throw new q(t); + } + return t; +} +function Xe(t) { + return Oe(Su(t)); +} +function Tu(t) { + switch (W(t)) { + case k: + if (t.parts.every((e) => e === "")) + return ""; + break; + case A: + if (!t.contents && !t.id && !t.break && !t.expandedStates) + return ""; + if (t.contents.type === A && t.contents.id === t.id && t.contents.break === t.break && t.contents.expandedStates === t.expandedStates) + return t.contents; + break; + case S: + case T: + case P: + case L: + if (!t.contents) + return ""; + break; + case B: + if (!t.flatContents && !t.breakContents) + return ""; + break; + case j: { + let e = []; + for (let r of t) { + if (!r) + continue; + let [n, ...o] = Array.isArray(r) ? r : [r]; + typeof n == "string" && typeof y(false, e, -1) == "string" ? e[e.length - 1] += n : e.push(n), e.push(...o); + } + return e.length === 0 ? "" : e.length === 1 ? e[0] : e; + } + case U: + case M: + case v: + case I: + case x: + case O: + case b: + break; + default: + throw new q(t); + } + return t; +} +function Su(t) { + return Ne(t, (e) => Tu(e)); +} +function Or(t, e = He) { + return Ne(t, (r) => typeof r == "string" ? ke(e, r.split(` +`)) : r); +} +function vu(t) { + if (t.type === x) + return true; +} +function Nr(t) { + return Je(t, vu, false); +} +function Ze(t, e) { + return t.type === O ? { ...t, contents: e(t.contents) } : e(t); +} +var R = Symbol("MODE_BREAK"), K = Symbol("MODE_FLAT"), Te = Symbol("cursor"); +function Tr() { + return { value: "", length: 0, queue: [] }; +} +function Pu(t, e) { + return Bt(t, { type: "indent" }, e); +} +function Lu(t, e, r) { + return e === Number.NEGATIVE_INFINITY ? t.root || Tr() : e < 0 ? Bt(t, { type: "dedent" }, r) : e ? e.type === "root" ? { ...t, root: t } : Bt(t, { type: typeof e == "string" ? "stringAlign" : "numberAlign", n: e }, r) : t; +} +function Bt(t, e, r) { + let n = e.type === "dedent" ? t.queue.slice(0, -1) : [...t.queue, e], o = "", u = 0, i = 0, s = 0; + for (let l of n) + switch (l.type) { + case "indent": + c(), r.useTabs ? a(1) : D(r.tabWidth); + break; + case "stringAlign": + c(), o += l.n, u += l.n.length; + break; + case "numberAlign": + i += 1, s += l.n; + break; + default: + throw new Error(`Unexpected type '${l.type}'`); + } + return f(), { ...t, value: o, length: u, queue: n }; + function a(l) { + o += " ".repeat(l), u += r.tabWidth * l; + } + function D(l) { + o += " ".repeat(l), u += l; + } + function c() { + r.useTabs ? F() : f(); + } + function F() { + i > 0 && a(i), d(); + } + function f() { + s > 0 && D(s), d(); + } + function d() { + i = 0, s = 0; + } +} +function kt(t) { + let e = 0, r = 0, n = t.length; + e: + for (; n--; ) { + let o = t[n]; + if (o === Te) { + r++; + continue; + } + for (let u = o.length - 1; u >= 0; u--) { + let i = o[u]; + if (i === " " || i === " ") + e++; + else { + t[n] = o.slice(0, u + 1); + break e; + } + } + } + if (e > 0 || r > 0) + for (t.length = n + 1; r-- > 0; ) + t.push(Te); + return e; +} +function Qe(t, e, r, n, o, u) { + if (r === Number.POSITIVE_INFINITY) + return true; + let i = e.length, s = [t], a = []; + for (; r >= 0; ) { + if (s.length === 0) { + if (i === 0) + return true; + s.push(e[--i]); + continue; + } + let { mode: D, doc: c } = s.pop(); + switch (W(c)) { + case U: + a.push(c), r -= we(c); + break; + case j: + case k: { + let F = Br(c); + for (let f = F.length - 1; f >= 0; f--) + s.push({ mode: D, doc: F[f] }); + break; + } + case T: + case S: + case P: + case O: + s.push({ mode: D, doc: c.contents }); + break; + case v: + r += kt(a); + break; + case A: { + if (u && c.break) + return false; + let F = c.break ? R : D, f = c.expandedStates && F === R ? y(false, c.expandedStates, -1) : c.contents; + s.push({ mode: F, doc: f }); + break; + } + case B: { + let f = (c.groupId ? o[c.groupId] || K : D) === R ? c.breakContents : c.flatContents; + f && s.push({ mode: D, doc: f }); + break; + } + case x: + if (D === R || c.hard) + return true; + c.soft || (a.push(" "), r--); + break; + case L: + n = true; + break; + case I: + if (n) + return false; + break; + } + } + return false; +} +function fe(t, e) { + let r = {}, n = e.printWidth, o = be(e.endOfLine), u = 0, i = [{ ind: Tr(), mode: R, doc: t }], s = [], a = false, D = [], c = 0; + for (br(t); i.length > 0; ) { + let { ind: f, mode: d, doc: l } = i.pop(); + switch (W(l)) { + case U: { + let p = o !== ` +` ? ee(false, l, ` +`, o) : l; + s.push(p), i.length > 0 && (u += we(p)); + break; + } + case j: + for (let p = l.length - 1; p >= 0; p--) + i.push({ ind: f, mode: d, doc: l[p] }); + break; + case M: + if (c >= 2) + throw new Error("There are too many 'cursor' in doc."); + s.push(Te), c++; + break; + case T: + i.push({ ind: Pu(f, e), mode: d, doc: l.contents }); + break; + case S: + i.push({ ind: Lu(f, l.n, e), mode: d, doc: l.contents }); + break; + case v: + u -= kt(s); + break; + case A: + switch (d) { + case K: + if (!a) { + i.push({ ind: f, mode: l.break ? R : K, doc: l.contents }); + break; + } + case R: { + a = false; + let p = { ind: f, mode: K, doc: l.contents }, m = n - u, E = D.length > 0; + if (!l.break && Qe(p, i, m, E, r)) + i.push(p); + else if (l.expandedStates) { + let h = y(false, l.expandedStates, -1); + if (l.break) { + i.push({ ind: f, mode: R, doc: h }); + break; + } else + for (let g = 1; g < l.expandedStates.length + 1; g++) + if (g >= l.expandedStates.length) { + i.push({ ind: f, mode: R, doc: h }); + break; + } else { + let C = l.expandedStates[g], _ = { ind: f, mode: K, doc: C }; + if (Qe(_, i, m, E, r)) { + i.push(_); + break; + } + } + } else + i.push({ ind: f, mode: R, doc: l.contents }); + break; + } + } + l.id && (r[l.id] = y(false, i, -1).mode); + break; + case k: { + let p = n - u, { parts: m } = l; + if (m.length === 0) + break; + let [E, h] = m, g = { ind: f, mode: K, doc: E }, C = { ind: f, mode: R, doc: E }, _ = Qe(g, [], p, D.length > 0, r, true); + if (m.length === 1) { + _ ? i.push(g) : i.push(C); + break; + } + let Z = { ind: f, mode: K, doc: h }, $ = { ind: f, mode: R, doc: h }; + if (m.length === 2) { + _ ? i.push(Z, g) : i.push($, C); + break; + } + m.splice(0, 2); + let Q = { ind: f, mode: d, doc: Ge(m) }, rr = m[0]; + Qe({ ind: f, mode: K, doc: [E, h, rr] }, [], p, D.length > 0, r, true) ? i.push(Q, Z, g) : _ ? i.push(Q, $, g) : i.push(Q, $, C); + break; + } + case B: + case P: { + let p = l.groupId ? r[l.groupId] : d; + if (p === R) { + let m = l.type === B ? l.breakContents : l.negate ? l.contents : ie(l.contents); + m && i.push({ ind: f, mode: d, doc: m }); + } + if (p === K) { + let m = l.type === B ? l.flatContents : l.negate ? ie(l.contents) : l.contents; + m && i.push({ ind: f, mode: d, doc: m }); + } + break; + } + case L: + D.push({ ind: f, mode: d, doc: l.contents }); + break; + case I: + D.length > 0 && i.push({ ind: f, mode: d, doc: Ae }); + break; + case x: + switch (d) { + case K: + if (l.hard) + a = true; + else { + l.soft || (s.push(" "), u += 1); + break; + } + case R: + if (D.length > 0) { + i.push({ ind: f, mode: d, doc: l }, ...D.reverse()), D.length = 0; + break; + } + l.literal ? f.root ? (s.push(o, f.root.value), u = f.root.length) : (s.push(o), u = 0) : (u -= kt(s), s.push(o + f.value), u = f.length); + break; + } + break; + case O: + i.push({ ind: f, mode: d, doc: l.contents }); + break; + case b: + break; + default: + throw new q(l); + } + i.length === 0 && D.length > 0 && (i.push(...D.reverse()), D.length = 0); + } + let F = s.indexOf(Te); + if (F !== -1) { + let f = s.indexOf(Te, F + 1), d = s.slice(0, F).join(""), l = s.slice(F + 1, f).join(""), p = s.slice(f + 1).join(""); + return { formatted: d + l + p, cursorNodeStart: d.length, cursorNodeText: l }; + } + return { formatted: s.join("") }; +} +function J(t) { + var e; + if (!t) + return ""; + if (Array.isArray(t)) { + let r = []; + for (let n of t) + if (Array.isArray(n)) + r.push(...J(n)); + else { + let o = J(n); + o !== "" && r.push(o); + } + return r; + } + return t.type === B ? { ...t, breakContents: J(t.breakContents), flatContents: J(t.flatContents) } : t.type === A ? { ...t, contents: J(t.contents), expandedStates: (e = t.expandedStates) == null ? void 0 : e.map(J) } : t.type === k ? { type: "fill", parts: t.parts.map(J) } : t.contents ? { ...t, contents: J(t.contents) } : t; +} +function Sr(t) { + let e = /* @__PURE__ */ Object.create(null), r = /* @__PURE__ */ new Set(); + return n(J(t)); + function n(u, i, s) { + var a, D; + if (typeof u == "string") + return JSON.stringify(u); + if (Array.isArray(u)) { + let c = u.map(n).filter(Boolean); + return c.length === 1 ? c[0] : `[${c.join(", ")}]`; + } + if (u.type === x) { + let c = ((a = s == null ? void 0 : s[i + 1]) == null ? void 0 : a.type) === b; + return u.literal ? c ? "literalline" : "literallineWithoutBreakParent" : u.hard ? c ? "hardline" : "hardlineWithoutBreakParent" : u.soft ? "softline" : "line"; + } + if (u.type === b) + return ((D = s == null ? void 0 : s[i - 1]) == null ? void 0 : D.type) === x && s[i - 1].hard ? void 0 : "breakParent"; + if (u.type === v) + return "trim"; + if (u.type === T) + return "indent(" + n(u.contents) + ")"; + if (u.type === S) + return u.n === Number.NEGATIVE_INFINITY ? "dedentToRoot(" + n(u.contents) + ")" : u.n < 0 ? "dedent(" + n(u.contents) + ")" : u.n.type === "root" ? "markAsRoot(" + n(u.contents) + ")" : "align(" + JSON.stringify(u.n) + ", " + n(u.contents) + ")"; + if (u.type === B) + return "ifBreak(" + n(u.breakContents) + (u.flatContents ? ", " + n(u.flatContents) : "") + (u.groupId ? (u.flatContents ? "" : ', ""') + `, { groupId: ${o(u.groupId)} }` : "") + ")"; + if (u.type === P) { + let c = []; + u.negate && c.push("negate: true"), u.groupId && c.push(`groupId: ${o(u.groupId)}`); + let F = c.length > 0 ? `, { ${c.join(", ")} }` : ""; + return `indentIfBreak(${n(u.contents)}${F})`; + } + if (u.type === A) { + let c = []; + u.break && u.break !== "propagated" && c.push("shouldBreak: true"), u.id && c.push(`id: ${o(u.id)}`); + let F = c.length > 0 ? `, { ${c.join(", ")} }` : ""; + return u.expandedStates ? `conditionalGroup([${u.expandedStates.map((f) => n(f)).join(",")}]${F})` : `group(${n(u.contents)}${F})`; + } + if (u.type === k) + return `fill([${u.parts.map((c) => n(c)).join(", ")}])`; + if (u.type === L) + return "lineSuffix(" + n(u.contents) + ")"; + if (u.type === I) + return "lineSuffixBoundary"; + if (u.type === O) + return `label(${JSON.stringify(u.label)}, ${n(u.contents)})`; + throw new Error("Unknown doc type " + u.type); + } + function o(u) { + if (typeof u != "symbol") + return JSON.stringify(String(u)); + if (u in e) + return e[u]; + let i = u.description || "symbol"; + for (let s = 0; ; s++) { + let a = i + (s > 0 ? ` #${s}` : ""); + if (!r.has(a)) + return r.add(a), e[u] = `Symbol.for(${JSON.stringify(a)})`; + } + } +} +function Iu(t, e, r = 0) { + let n = 0; + for (let o = r; o < t.length; ++o) + t[o] === " " ? n = n + e - n % e : n++; + return n; +} +var pe = Iu; +var Se = class extends Error { + constructor() { + super(...arguments); + __publicField(this, "name", "ConfigError"); + } +}, ve = class extends Error { + constructor() { + super(...arguments); + __publicField(this, "name", "UndefinedParserError"); + } +}; +var vr = { cursorOffset: { category: "Special", type: "int", default: -1, range: { start: -1, end: 1 / 0, step: 1 }, description: `Print (to stderr) where a cursor at the given position would move to after formatting. +This option cannot be used with --range-start and --range-end.`, cliCategory: "Editor" }, endOfLine: { category: "Global", type: "choice", default: "lf", description: "Which end of line characters to apply.", choices: [{ value: "lf", description: "Line Feed only (\\n), common on Linux and macOS as well as inside git repos" }, { value: "crlf", description: "Carriage Return + Line Feed characters (\\r\\n), common on Windows" }, { value: "cr", description: "Carriage Return character only (\\r), used very rarely" }, { value: "auto", description: `Maintain existing +(mixed values within one file are normalised by looking at what's used after the first line)` }] }, filepath: { category: "Special", type: "path", description: "Specify the input filepath. This will be used to do parser inference.", cliName: "stdin-filepath", cliCategory: "Other", cliDescription: "Path to the file to pretend that stdin comes from." }, insertPragma: { category: "Special", type: "boolean", default: false, description: "Insert @format pragma into file's first docblock comment.", cliCategory: "Other" }, parser: { category: "Global", type: "choice", default: void 0, description: "Which parser to use.", exception: (t) => typeof t == "string" || typeof t == "function", choices: [{ value: "flow", description: "Flow" }, { value: "babel", description: "JavaScript" }, { value: "babel-flow", description: "Flow" }, { value: "babel-ts", description: "TypeScript" }, { value: "typescript", description: "TypeScript" }, { value: "acorn", description: "JavaScript" }, { value: "espree", description: "JavaScript" }, { value: "meriyah", description: "JavaScript" }, { value: "css", description: "CSS" }, { value: "less", description: "Less" }, { value: "scss", description: "SCSS" }, { value: "json", description: "JSON" }, { value: "json5", description: "JSON5" }, { value: "json-stringify", description: "JSON.stringify" }, { value: "graphql", description: "GraphQL" }, { value: "markdown", description: "Markdown" }, { value: "mdx", description: "MDX" }, { value: "vue", description: "Vue" }, { value: "yaml", description: "YAML" }, { value: "glimmer", description: "Ember / Handlebars" }, { value: "html", description: "HTML" }, { value: "angular", description: "Angular" }, { value: "lwc", description: "Lightning Web Components" }] }, plugins: { type: "path", array: true, default: [{ value: [] }], category: "Global", description: "Add a plugin. Multiple plugins can be passed as separate `--plugin`s.", exception: (t) => typeof t == "string" || typeof t == "object", cliName: "plugin", cliCategory: "Config" }, printWidth: { category: "Global", type: "int", default: 80, description: "The line length where Prettier will try wrap.", range: { start: 0, end: 1 / 0, step: 1 } }, rangeEnd: { category: "Special", type: "int", default: 1 / 0, range: { start: 0, end: 1 / 0, step: 1 }, description: `Format code ending at a given character offset (exclusive). +The range will extend forwards to the end of the selected statement. +This option cannot be used with --cursor-offset.`, cliCategory: "Editor" }, rangeStart: { category: "Special", type: "int", default: 0, range: { start: 0, end: 1 / 0, step: 1 }, description: `Format code starting at a given character offset. +The range will extend backwards to the start of the first line containing the selected statement. +This option cannot be used with --cursor-offset.`, cliCategory: "Editor" }, requirePragma: { category: "Special", type: "boolean", default: false, description: `Require either '@prettier' or '@format' to be present in the file's first docblock comment +in order for it to be formatted.`, cliCategory: "Other" }, tabWidth: { type: "int", category: "Global", default: 2, description: "Number of spaces per indentation level.", range: { start: 0, end: 1 / 0, step: 1 } }, useTabs: { category: "Global", type: "boolean", default: false, description: "Indent with tabs instead of spaces." }, embeddedLanguageFormatting: { category: "Global", type: "choice", default: "auto", description: "Control how Prettier formats quoted code embedded in the file.", choices: [{ value: "auto", description: "Format embedded code if Prettier can automatically identify it." }, { value: "off", description: "Never automatically format embedded code." }] } }; +function et({ plugins: t = [], showDeprecated: e = false } = {}) { + let r = t.flatMap((o) => o.languages ?? []), n = []; + for (let o of Yu(Object.assign({}, ...t.map(({ options: u }) => u), vr))) + !e && o.deprecated || (Array.isArray(o.choices) && (e || (o.choices = o.choices.filter((u) => !u.deprecated)), o.name === "parser" && (o.choices = [...o.choices, ...Ru(o.choices, r, t)])), o.pluginDefaults = Object.fromEntries(t.filter((u) => { + var i; + return ((i = u.defaultOptions) == null ? void 0 : i[o.name]) !== void 0; + }).map((u) => [u.name, u.defaultOptions[o.name]])), n.push(o)); + return { languages: r, options: n }; +} +function* Ru(t, e, r) { + let n = new Set(t.map((o) => o.value)); + for (let o of e) + if (o.parsers) { + for (let u of o.parsers) + if (!n.has(u)) { + n.add(u); + let i = r.find((a) => a.parsers && Object.prototype.hasOwnProperty.call(a.parsers, u)), s = o.name; + i != null && i.name && (s += ` (plugin: ${i.name})`), yield { value: u, description: s }; + } + } +} +function Yu(t) { + let e = []; + for (let [r, n] of Object.entries(t)) { + let o = { name: r, ...n }; + Array.isArray(o.default) && (o.default = y(false, o.default, -1).value), e.push(o); + } + return e; +} +var ju = (t) => t.split(/[/\\]/).pop(); +function Pr(t, e) { + if (!e) + return; + let r = ju(e).toLowerCase(); + return t.find((n) => { + var o, u; + return ((o = n.extensions) == null ? void 0 : o.some((i) => r.endsWith(i))) || ((u = n.filenames) == null ? void 0 : u.some((i) => i.toLowerCase() === r)); + }); +} +function Vu(t, e) { + if (e) + return t.find(({ name: r }) => r.toLowerCase() === e) ?? t.find(({ aliases: r }) => r == null ? void 0 : r.includes(e)) ?? t.find(({ extensions: r }) => r == null ? void 0 : r.includes(`.${e}`)); +} +function $u(t, e) { + let r = t.plugins.flatMap((o) => o.languages ?? []), n = Vu(r, e.language) ?? Pr(r, e.physicalFile) ?? Pr(r, e.file) ?? (e.physicalFile, void 0); + return n == null ? void 0 : n.parsers[0]; +} +var Lr = $u; +var te = { key: (t) => /^[$_a-zA-Z][$_a-zA-Z0-9]*$/.test(t) ? t : JSON.stringify(t), value(t) { + if (t === null || typeof t != "object") + return JSON.stringify(t); + if (Array.isArray(t)) + return `[${t.map((r) => te.value(r)).join(", ")}]`; + let e = Object.keys(t); + return e.length === 0 ? "{}" : `{ ${e.map((r) => `${te.key(r)}: ${te.value(t[r])}`).join(", ")} }`; +}, pair: ({ key: t, value: e }) => te.value({ [t]: e }) }; +var bt = Ce(Pe(), 1), Yr = (t, e, { descriptor: r }) => { + let n = [`${bt.default.yellow(typeof t == "string" ? r.key(t) : r.pair(t))} is deprecated`]; + return e && n.push(`we now treat it as ${bt.default.blue(typeof e == "string" ? r.key(e) : r.pair(e))}`), n.join("; ") + "."; +}; +var se = Ce(Pe(), 1); +var tt = Symbol.for("vnopts.VALUE_NOT_EXIST"), de = Symbol.for("vnopts.VALUE_UNCHANGED"); +var jr = " ".repeat(2), $r = (t, e, r) => { + let { text: n, list: o } = r.normalizeExpectedResult(r.schemas[t].expected(r)), u = []; + return n && u.push(Vr(t, e, n, r.descriptor)), o && u.push([Vr(t, e, o.title, r.descriptor)].concat(o.values.map((i) => Ur(i, r.loggerPrintWidth))).join(` +`)), Mr(u, r.loggerPrintWidth); +}; +function Vr(t, e, r, n) { + return [`Invalid ${se.default.red(n.key(t))} value.`, `Expected ${se.default.blue(r)},`, `but received ${e === tt ? se.default.gray("nothing") : se.default.red(n.value(e))}.`].join(" "); +} +function Ur({ text: t, list: e }, r) { + let n = []; + return t && n.push(`- ${se.default.blue(t)}`), e && n.push([`- ${se.default.blue(e.title)}:`].concat(e.values.map((o) => Ur(o, r - jr.length).replace(/^|\n/g, `$&${jr}`))).join(` +`)), Mr(n, r); +} +function Mr(t, e) { + if (t.length === 1) + return t[0]; + let [r, n] = t, [o, u] = t.map((i) => i.split(` +`, 1)[0].length); + return o > e && o > u ? n : r; +} +var Nt = Ce(Pe(), 1); +var wt = [], Wr = []; +function Ot(t, e) { + if (t === e) + return 0; + let r = t; + t.length > e.length && (t = e, e = r); + let n = t.length, o = e.length; + for (; n > 0 && t.charCodeAt(~-n) === e.charCodeAt(~-o); ) + n--, o--; + let u = 0; + for (; u < n && t.charCodeAt(u) === e.charCodeAt(u); ) + u++; + if (n -= u, o -= u, n === 0) + return o; + let i, s, a, D, c = 0, F = 0; + for (; c < n; ) + Wr[c] = t.charCodeAt(u + c), wt[c] = ++c; + for (; F < o; ) + for (i = e.charCodeAt(u + F), a = F++, s = F, c = 0; c < n; c++) + D = i === Wr[c] ? a : a + 1, a = wt[c], s = wt[c] = a > s ? D > s ? s + 1 : D : D > a ? a + 1 : D; + return s; +} +var rt = (t, e, { descriptor: r, logger: n, schemas: o }) => { + let u = [`Ignored unknown option ${Nt.default.yellow(r.pair({ key: t, value: e }))}.`], i = Object.keys(o).sort().find((s) => Ot(t, s) < 3); + i && u.push(`Did you mean ${Nt.default.blue(r.key(i))}?`), n.warn(u.join(" ")); +}; +var Uu = ["default", "expected", "validate", "deprecated", "forward", "redirect", "overlap", "preprocess", "postprocess"]; +function Mu(t, e) { + let r = new t(e), n = Object.create(r); + for (let o of Uu) + o in e && (n[o] = Wu(e[o], r, w.prototype[o].length)); + return n; +} +var w = class { + static create(e) { + return Mu(this, e); + } + constructor(e) { + this.name = e.name; + } + default(e) { + } + expected(e) { + return "nothing"; + } + validate(e, r) { + return false; + } + deprecated(e, r) { + return false; + } + forward(e, r) { + } + redirect(e, r) { + } + overlap(e, r, n) { + return e; + } + preprocess(e, r) { + return e; + } + postprocess(e, r) { + return de; + } +}; +function Wu(t, e, r) { + return typeof t == "function" ? (...n) => t(...n.slice(0, r - 1), e, ...n.slice(r - 1)) : () => t; +} +var nt = class extends w { + constructor(e) { + super(e), this._sourceName = e.sourceName; + } + expected(e) { + return e.schemas[this._sourceName].expected(e); + } + validate(e, r) { + return r.schemas[this._sourceName].validate(e, r); + } + redirect(e, r) { + return this._sourceName; + } +}; +var ut = class extends w { + expected() { + return "anything"; + } + validate() { + return true; + } +}; +var ot = class extends w { + constructor({ valueSchema: e, name: r = e.name, ...n }) { + super({ ...n, name: r }), this._valueSchema = e; + } + expected(e) { + let { text: r, list: n } = e.normalizeExpectedResult(this._valueSchema.expected(e)); + return { text: r && `an array of ${r}`, list: n && { title: "an array of the following values", values: [{ list: n }] } }; + } + validate(e, r) { + if (!Array.isArray(e)) + return false; + let n = []; + for (let o of e) { + let u = r.normalizeValidateResult(this._valueSchema.validate(o, r), o); + u !== true && n.push(u.value); + } + return n.length === 0 ? true : { value: n }; + } + deprecated(e, r) { + let n = []; + for (let o of e) { + let u = r.normalizeDeprecatedResult(this._valueSchema.deprecated(o, r), o); + u !== false && n.push(...u.map(({ value: i }) => ({ value: [i] }))); + } + return n; + } + forward(e, r) { + let n = []; + for (let o of e) { + let u = r.normalizeForwardResult(this._valueSchema.forward(o, r), o); + n.push(...u.map(zr)); + } + return n; + } + redirect(e, r) { + let n = [], o = []; + for (let u of e) { + let i = r.normalizeRedirectResult(this._valueSchema.redirect(u, r), u); + "remain" in i && n.push(i.remain), o.push(...i.redirect.map(zr)); + } + return n.length === 0 ? { redirect: o } : { redirect: o, remain: n }; + } + overlap(e, r) { + return e.concat(r); + } +}; +function zr({ from: t, to: e }) { + return { from: [t], to: e }; +} +var it = class extends w { + expected() { + return "true or false"; + } + validate(e) { + return typeof e == "boolean"; + } +}; +function Kr(t, e) { + let r = /* @__PURE__ */ Object.create(null); + for (let n of t) { + let o = n[e]; + if (r[o]) + throw new Error(`Duplicate ${e} ${JSON.stringify(o)}`); + r[o] = n; + } + return r; +} +function Hr(t, e) { + let r = /* @__PURE__ */ new Map(); + for (let n of t) { + let o = n[e]; + if (r.has(o)) + throw new Error(`Duplicate ${e} ${JSON.stringify(o)}`); + r.set(o, n); + } + return r; +} +function qr() { + let t = /* @__PURE__ */ Object.create(null); + return (e) => { + let r = JSON.stringify(e); + return t[r] ? true : (t[r] = true, false); + }; +} +function Jr(t, e) { + let r = [], n = []; + for (let o of t) + e(o) ? r.push(o) : n.push(o); + return [r, n]; +} +function Xr(t) { + return t === Math.floor(t); +} +function Zr(t, e) { + if (t === e) + return 0; + let r = typeof t, n = typeof e, o = ["undefined", "object", "boolean", "number", "string"]; + return r !== n ? o.indexOf(r) - o.indexOf(n) : r !== "string" ? Number(t) - Number(e) : t.localeCompare(e); +} +function Qr(t) { + return (...e) => { + let r = t(...e); + return typeof r == "string" ? new Error(r) : r; + }; +} +function Tt(t) { + return t === void 0 ? {} : t; +} +function St(t) { + if (typeof t == "string") + return { text: t }; + let { text: e, list: r } = t; + return zu((e || r) !== void 0, "Unexpected `expected` result, there should be at least one field."), r ? { text: e, list: { title: r.title, values: r.values.map(St) } } : { text: e }; +} +function vt(t, e) { + return t === true ? true : t === false ? { value: e } : t; +} +function Pt(t, e, r = false) { + return t === false ? false : t === true ? r ? true : [{ value: e }] : "value" in t ? [t] : t.length === 0 ? false : t; +} +function Gr(t, e) { + return typeof t == "string" || "key" in t ? { from: e, to: t } : "from" in t ? { from: t.from, to: t.to } : { from: e, to: t.to }; +} +function st(t, e) { + return t === void 0 ? [] : Array.isArray(t) ? t.map((r) => Gr(r, e)) : [Gr(t, e)]; +} +function Lt(t, e) { + let r = st(typeof t == "object" && "redirect" in t ? t.redirect : t, e); + return r.length === 0 ? { remain: e, redirect: r } : typeof t == "object" && "remain" in t ? { remain: t.remain, redirect: r } : { redirect: r }; +} +function zu(t, e) { + if (!t) + throw new Error(e); +} +var at = class extends w { + constructor(e) { + super(e), this._choices = Hr(e.choices.map((r) => r && typeof r == "object" ? r : { value: r }), "value"); + } + expected({ descriptor: e }) { + let r = Array.from(this._choices.keys()).map((i) => this._choices.get(i)).filter(({ hidden: i }) => !i).map((i) => i.value).sort(Zr).map(e.value), n = r.slice(0, -2), o = r.slice(-2); + return { text: n.concat(o.join(" or ")).join(", "), list: { title: "one of the following values", values: r } }; + } + validate(e) { + return this._choices.has(e); + } + deprecated(e) { + let r = this._choices.get(e); + return r && r.deprecated ? { value: e } : false; + } + forward(e) { + let r = this._choices.get(e); + return r ? r.forward : void 0; + } + redirect(e) { + let r = this._choices.get(e); + return r ? r.redirect : void 0; + } +}; +var Dt = class extends w { + expected() { + return "a number"; + } + validate(e, r) { + return typeof e == "number"; + } +}; +var ct = class extends Dt { + expected() { + return "an integer"; + } + validate(e, r) { + return r.normalizeValidateResult(super.validate(e, r), e) === true && Xr(e); + } +}; +var Le = class extends w { + expected() { + return "a string"; + } + validate(e) { + return typeof e == "string"; + } +}; +var en = te, tn = rt, rn = $r, nn = Yr; +var lt = class { + constructor(e, r) { + let { logger: n = console, loggerPrintWidth: o = 80, descriptor: u = en, unknown: i = tn, invalid: s = rn, deprecated: a = nn, missing: D = () => false, required: c = () => false, preprocess: F = (d) => d, postprocess: f = () => de } = r || {}; + this._utils = { descriptor: u, logger: n || { warn: () => { + } }, loggerPrintWidth: o, schemas: Kr(e, "name"), normalizeDefaultResult: Tt, normalizeExpectedResult: St, normalizeDeprecatedResult: Pt, normalizeForwardResult: st, normalizeRedirectResult: Lt, normalizeValidateResult: vt }, this._unknownHandler = i, this._invalidHandler = Qr(s), this._deprecatedHandler = a, this._identifyMissing = (d, l) => !(d in l) || D(d, l), this._identifyRequired = c, this._preprocess = F, this._postprocess = f, this.cleanHistory(); + } + cleanHistory() { + this._hasDeprecationWarned = qr(); + } + normalize(e) { + let r = {}, o = [this._preprocess(e, this._utils)], u = () => { + for (; o.length !== 0; ) { + let i = o.shift(), s = this._applyNormalization(i, r); + o.push(...s); + } + }; + u(); + for (let i of Object.keys(this._utils.schemas)) { + let s = this._utils.schemas[i]; + if (!(i in r)) { + let a = Tt(s.default(this._utils)); + "value" in a && o.push({ [i]: a.value }); + } + } + u(); + for (let i of Object.keys(this._utils.schemas)) { + if (!(i in r)) + continue; + let s = this._utils.schemas[i], a = r[i], D = s.postprocess(a, this._utils); + D !== de && (this._applyValidation(D, i, s), r[i] = D); + } + return this._applyPostprocess(r), this._applyRequiredCheck(r), r; + } + _applyNormalization(e, r) { + let n = [], { knownKeys: o, unknownKeys: u } = this._partitionOptionKeys(e); + for (let i of o) { + let s = this._utils.schemas[i], a = s.preprocess(e[i], this._utils); + this._applyValidation(a, i, s); + let D = ({ from: d, to: l }) => { + n.push(typeof l == "string" ? { [l]: d } : { [l.key]: l.value }); + }, c = ({ value: d, redirectTo: l }) => { + let p = Pt(s.deprecated(d, this._utils), a, true); + if (p !== false) + if (p === true) + this._hasDeprecationWarned(i) || this._utils.logger.warn(this._deprecatedHandler(i, l, this._utils)); + else + for (let { value: m } of p) { + let E = { key: i, value: m }; + if (!this._hasDeprecationWarned(E)) { + let h = typeof l == "string" ? { key: l, value: m } : l; + this._utils.logger.warn(this._deprecatedHandler(E, h, this._utils)); + } + } + }; + st(s.forward(a, this._utils), a).forEach(D); + let f = Lt(s.redirect(a, this._utils), a); + if (f.redirect.forEach(D), "remain" in f) { + let d = f.remain; + r[i] = i in r ? s.overlap(r[i], d, this._utils) : d, c({ value: d }); + } + for (let { from: d, to: l } of f.redirect) + c({ value: d, redirectTo: l }); + } + for (let i of u) { + let s = e[i]; + this._applyUnknownHandler(i, s, r, (a, D) => { + n.push({ [a]: D }); + }); + } + return n; + } + _applyRequiredCheck(e) { + for (let r of Object.keys(this._utils.schemas)) + if (this._identifyMissing(r, e) && this._identifyRequired(r)) + throw this._invalidHandler(r, tt, this._utils); + } + _partitionOptionKeys(e) { + let [r, n] = Jr(Object.keys(e).filter((o) => !this._identifyMissing(o, e)), (o) => o in this._utils.schemas); + return { knownKeys: r, unknownKeys: n }; + } + _applyValidation(e, r, n) { + let o = vt(n.validate(e, this._utils), e); + if (o !== true) + throw this._invalidHandler(r, o.value, this._utils); + } + _applyUnknownHandler(e, r, n, o) { + let u = this._unknownHandler(e, r, this._utils); + if (u) + for (let i of Object.keys(u)) { + if (this._identifyMissing(i, u)) + continue; + let s = u[i]; + i in this._utils.schemas ? o(i, s) : n[i] = s; + } + } + _applyPostprocess(e) { + let r = this._postprocess(e, this._utils); + if (r !== de) { + if (r.delete) + for (let n of r.delete) + delete e[n]; + if (r.override) { + let { knownKeys: n, unknownKeys: o } = this._partitionOptionKeys(r.override); + for (let u of n) { + let i = r.override[u]; + this._applyValidation(i, u, this._utils.schemas[u]), e[u] = i; + } + for (let u of o) { + let i = r.override[u]; + this._applyUnknownHandler(u, i, e, (s, a) => { + let D = this._utils.schemas[s]; + this._applyValidation(a, s, D), e[s] = a; + }); + } + } + } + } +}; +var It; +function Ku(t, e, { logger: r = false, isCLI: n = false, passThrough: o = false, FlagSchema: u, descriptor: i } = {}) { + if (n) { + if (!u) + throw new Error("'FlagSchema' option is required."); + if (!i) + throw new Error("'descriptor' option is required."); + } else + i = te; + let s = o ? Array.isArray(o) ? (f, d) => o.includes(f) ? { [f]: d } : void 0 : (f, d) => ({ [f]: d }) : (f, d, l) => { + let { _: p, ...m } = l.schemas; + return rt(f, d, { ...l, schemas: m }); + }, a = Hu(e, { isCLI: n, FlagSchema: u }), D = new lt(a, { logger: r, unknown: s, descriptor: i }), c = r !== false; + c && It && (D._hasDeprecationWarned = It); + let F = D.normalize(t); + return c && (It = D._hasDeprecationWarned), F; +} +function Hu(t, { isCLI: e, FlagSchema: r }) { + let n = []; + e && n.push(ut.create({ name: "_" })); + for (let o of t) + n.push(qu(o, { isCLI: e, optionInfos: t, FlagSchema: r })), o.alias && e && n.push(nt.create({ name: o.alias, sourceName: o.name })); + return n; +} +function qu(t, { isCLI: e, optionInfos: r, FlagSchema: n }) { + let { name: o } = t, u = { name: o }, i, s = {}; + switch (t.type) { + case "int": + i = ct, e && (u.preprocess = Number); + break; + case "string": + i = Le; + break; + case "choice": + i = at, u.choices = t.choices.map((a) => a != null && a.redirect ? { ...a, redirect: { to: { key: t.name, value: a.redirect } } } : a); + break; + case "boolean": + i = it; + break; + case "flag": + i = n, u.flags = r.flatMap((a) => [a.alias, a.description && a.name, a.oppositeDescription && `no-${a.name}`].filter(Boolean)); + break; + case "path": + i = Le; + break; + default: + throw new Error(`Unexpected type ${t.type}`); + } + if (t.exception ? u.validate = (a, D, c) => t.exception(a) || D.validate(a, c) : u.validate = (a, D, c) => a === void 0 || D.validate(a, c), t.redirect && (s.redirect = (a) => a ? { to: { key: t.redirect.option, value: t.redirect.value } } : void 0), t.deprecated && (s.deprecated = true), e && !t.array) { + let a = u.preprocess || ((D) => D); + u.preprocess = (D, c, F) => c.preprocess(a(Array.isArray(D) ? y(false, D, -1) : D), F); + } + return t.array ? ot.create({ ...e ? { preprocess: (a) => Array.isArray(a) ? a : [a] } : {}, ...s, valueSchema: i.create(u) }) : i.create({ ...u, ...s }); +} +var un = Ku; +function Rt(t, e) { + if (!e) + throw new Error("parserName is required."); + for (let n = t.length - 1; n >= 0; n--) { + let o = t[n]; + if (o.parsers && Object.prototype.hasOwnProperty.call(o.parsers, e)) + return o; + } + let r = `Couldn't resolve parser "${e}".`; + throw r += " Plugins must be explicitly added to the standalone bundle.", new Se(r); +} +function on(t, e) { + if (!e) + throw new Error("astFormat is required."); + for (let n = t.length - 1; n >= 0; n--) { + let o = t[n]; + if (o.printers && Object.prototype.hasOwnProperty.call(o.printers, e)) + return o; + } + let r = `Couldn't find plugin for AST format "${e}".`; + throw r += " Plugins must be explicitly added to the standalone bundle.", new Se(r); +} +function ft({ plugins: t, parser: e }) { + let r = Rt(t, e); + return Yt(r, e); +} +function Yt(t, e) { + let r = t.parsers[e]; + return typeof r == "function" ? r() : r; +} +function sn(t, e) { + let r = t.printers[e]; + return typeof r == "function" ? r() : r; +} +var an = { astFormat: "estree", printer: {}, originalText: void 0, locStart: null, locEnd: null }; +async function Ju(t, e = {}) { + var F; + let r = { ...t }; + if (!r.parser) + if (r.filepath) { + if (r.parser = Lr(r, { physicalFile: r.filepath }), !r.parser) + throw new ve(`No parser could be inferred for file "${r.filepath}".`); + } else + throw new ve("No parser and no file path given, couldn't infer a parser."); + let n = et({ plugins: t.plugins, showDeprecated: true }).options, o = { ...an, ...Object.fromEntries(n.filter((f) => f.default !== void 0).map((f) => [f.name, f.default])) }, u = Rt(r.plugins, r.parser), i = await Yt(u, r.parser); + r.astFormat = i.astFormat, r.locEnd = i.locEnd, r.locStart = i.locStart; + let s = (F = u.printers) != null && F[i.astFormat] ? u : on(r.plugins, i.astFormat), a = await sn(s, i.astFormat); + r.printer = a; + let D = s.defaultOptions ? Object.fromEntries(Object.entries(s.defaultOptions).filter(([, f]) => f !== void 0)) : {}, c = { ...o, ...D }; + for (let [f, d] of Object.entries(c)) + (r[f] === null || r[f] === void 0) && (r[f] = d); + return r.parser === "json" && (r.trailingComma = "none"), un(r, n, { passThrough: Object.keys(an), ...e }); +} +var re = Ju; +var Dn = /* @__PURE__ */ new Set(["tokens", "comments", "parent", "enclosingNode", "precedingNode", "followingNode"]), Xu = (t) => Object.keys(t).filter((e) => !Dn.has(e)); +function Zu(t) { + return t ? (e) => t(e, Dn) : Xu; +} +var H = Zu; +function Qu(t, e) { + let { printer: { massageAstNode: r, getVisitorKeys: n } } = e; + if (!r) + return t; + let o = H(n), u = r.ignoredProperties ?? /* @__PURE__ */ new Set(); + return i(t); + function i(s, a) { + if (!(s !== null && typeof s == "object")) + return s; + if (Array.isArray(s)) + return s.map((f) => i(f, a)).filter(Boolean); + let D = {}, c = new Set(o(s)); + for (let f in s) + !Object.prototype.hasOwnProperty.call(s, f) || u.has(f) || (c.has(f) ? D[f] = i(s[f], s) : D[f] = s[f]); + let F = r(s, D, a); + if (F !== null) + return F ?? D; + } +} +var cn = Qu; +var Cn = Ce(hn(), 1); +async function so(t, e) { + let r = await ft(e), n = r.preprocess ? r.preprocess(t, e) : t; + e.originalText = n; + let o; + try { + o = await r.parse(n, e, e); + } catch (u) { + ao(u, t); + } + return { text: n, ast: o }; +} +function ao(t, e) { + let { loc: r } = t; + if (r) { + let n = (0, Cn.codeFrameColumns)(e, r, { highlightCode: true }); + throw t.message += ` +` + n, t.codeFrame = n, t; + } + throw t; +} +var ae = so; +var Ie, $t, Fe, dt, Vt = class { + constructor(e) { + Ct(this, Ie); + Ct(this, Fe); + this.stack = [e]; + } + get key() { + let { stack: e, siblings: r } = this; + return y(false, e, r === null ? -2 : -4) ?? null; + } + get index() { + return this.siblings === null ? null : y(false, this.stack, -2); + } + get node() { + return y(false, this.stack, -1); + } + get parent() { + return this.getNode(1); + } + get grandparent() { + return this.getNode(2); + } + get isInArray() { + return this.siblings !== null; + } + get siblings() { + let { stack: e } = this, r = y(false, e, -3); + return Array.isArray(r) ? r : null; + } + get next() { + let { siblings: e } = this; + return e === null ? null : e[this.index + 1]; + } + get previous() { + let { siblings: e } = this; + return e === null ? null : e[this.index - 1]; + } + get isFirst() { + return this.index === 0; + } + get isLast() { + let { siblings: e, index: r } = this; + return e !== null && r === e.length - 1; + } + get isRoot() { + return this.stack.length === 1; + } + get root() { + return this.stack[0]; + } + get ancestors() { + return [...ce(this, Fe, dt).call(this)]; + } + getName() { + let { stack: e } = this, { length: r } = e; + return r > 1 ? y(false, e, -2) : null; + } + getValue() { + return y(false, this.stack, -1); + } + getNode(e = 0) { + let r = ce(this, Ie, $t).call(this, e); + return r === -1 ? null : this.stack[r]; + } + getParentNode(e = 0) { + return this.getNode(e + 1); + } + call(e, ...r) { + let { stack: n } = this, { length: o } = n, u = y(false, n, -1); + for (let i of r) + u = u[i], n.push(i, u); + try { + return e(this); + } finally { + n.length = o; + } + } + callParent(e, r = 0) { + let n = ce(this, Ie, $t).call(this, r + 1), o = this.stack.splice(n + 1); + try { + return e(this); + } finally { + this.stack.push(...o); + } + } + each(e, ...r) { + let { stack: n } = this, { length: o } = n, u = y(false, n, -1); + for (let i of r) + u = u[i], n.push(i, u); + try { + for (let i = 0; i < u.length; ++i) + n.push(i, u[i]), e(this, i, u), n.length -= 2; + } finally { + n.length = o; + } + } + map(e, ...r) { + let n = []; + return this.each((o, u, i) => { + n[u] = e(o, u, i); + }, ...r), n; + } + match(...e) { + let r = this.stack.length - 1, n = null, o = this.stack[r--]; + for (let u of e) { + if (o === void 0) + return false; + let i = null; + if (typeof n == "number" && (i = n, n = this.stack[r--], o = this.stack[r--]), u && !u(o, n, i)) + return false; + n = this.stack[r--], o = this.stack[r--]; + } + return true; + } + findAncestor(e) { + for (let r of ce(this, Fe, dt).call(this)) + if (e(r)) + return r; + } + hasAncestor(e) { + for (let r of ce(this, Fe, dt).call(this)) + if (e(r)) + return true; + return false; + } +}; +Ie = /* @__PURE__ */ new WeakSet(), $t = function(e) { + let { stack: r } = this; + for (let n = r.length - 1; n >= 0; n -= 2) + if (!Array.isArray(r[n]) && --e < 0) + return n; + return -1; +}, Fe = /* @__PURE__ */ new WeakSet(), dt = function* () { + let { stack: e } = this; + for (let r = e.length - 3; r >= 0; r -= 2) { + let n = e[r]; + Array.isArray(n) || (yield n); + } +}; +var gn = Vt; +var yn = new Proxy(() => { +}, { get: () => yn }), Re = yn; +function me(t) { + return (e, r, n) => { + let o = !!(n != null && n.backwards); + if (r === false) + return false; + let { length: u } = e, i = r; + for (; i >= 0 && i < u; ) { + let s = e.charAt(i); + if (t instanceof RegExp) { + if (!t.test(s)) + return i; + } else if (!t.includes(s)) + return i; + o ? i-- : i++; + } + return i === -1 || i === u ? i : false; + }; +} +var xn = me(/\s/), N = me(" "), Ft = me(",; "), mt = me(/[^\n\r]/); +function Do(t, e, r) { + let n = !!(r != null && r.backwards); + if (e === false) + return false; + let o = t.charAt(e); + if (n) { + if (t.charAt(e - 1) === "\r" && o === ` +`) + return e - 2; + if (o === ` +` || o === "\r" || o === "\u2028" || o === "\u2029") + return e - 1; + } else { + if (o === "\r" && t.charAt(e + 1) === ` +`) + return e + 2; + if (o === ` +` || o === "\r" || o === "\u2028" || o === "\u2029") + return e + 1; + } + return e; +} +var Y = Do; +function co(t, e, r = {}) { + let n = N(t, r.backwards ? e - 1 : e, r), o = Y(t, n, r); + return n !== o; +} +var V = co; +function lo(t) { + return Array.isArray(t) && t.length > 0; +} +var Ut = lo; +function fo(t) { + return t !== null && typeof t == "object"; +} +var _n = fo; +function* Mt(t, e) { + let { getVisitorKeys: r, filter: n = () => true } = e, o = (u) => _n(u) && n(u); + for (let u of r(t)) { + let i = t[u]; + if (Array.isArray(i)) + for (let s of i) + o(s) && (yield s); + else + o(i) && (yield i); + } +} +function* An(t, e) { + let r = [t]; + for (let n = 0; n < r.length; n++) { + let o = r[n]; + for (let u of Mt(o, e)) + yield u, r.push(u); + } +} +function po(t) { + let e = t.type || t.kind || "(unknown type)", r = String(t.name || t.id && (typeof t.id == "object" ? t.id.name : t.id) || t.key && (typeof t.key == "object" ? t.key.name : t.key) || t.value && (typeof t.value == "object" ? "" : String(t.value)) || t.operator || ""); + return r.length > 20 && (r = r.slice(0, 19) + "…"), e + (r ? " " + r : ""); +} +function Wt(t, e) { + (t.comments ?? (t.comments = [])).push(e), e.printed = false, e.nodeDescription = po(t); +} +function ne(t, e) { + e.leading = true, e.trailing = false, Wt(t, e); +} +function X(t, e, r) { + e.leading = false, e.trailing = false, r && (e.marker = r), Wt(t, e); +} +function ue(t, e) { + e.leading = false, e.trailing = true, Wt(t, e); +} +var zt = /* @__PURE__ */ new WeakMap(); +function Et(t, e) { + if (zt.has(t)) + return zt.get(t); + let { printer: { getCommentChildNodes: r, canAttachComment: n, getVisitorKeys: o }, locStart: u, locEnd: i } = e; + if (!n) + return []; + let s = ((r == null ? void 0 : r(t, e)) ?? [...Mt(t, { getVisitorKeys: H(o) })]).flatMap((a) => n(a) ? [a] : Et(a, e)); + return s.sort((a, D) => u(a) - u(D) || i(a) - i(D)), zt.set(t, s), s; +} +function kn(t, e, r, n) { + let { locStart: o, locEnd: u } = r, i = o(e), s = u(e), a = Et(t, r), D, c, F = 0, f = a.length; + for (; F < f; ) { + let d = F + f >> 1, l = a[d], p = o(l), m = u(l); + if (p <= i && s <= m) + return kn(l, e, r, l); + if (m <= i) { + D = l, F = d + 1; + continue; + } + if (s <= p) { + c = l, f = d; + continue; + } + throw new Error("Comment location overlaps with node location"); + } + if ((n == null ? void 0 : n.type) === "TemplateLiteral") { + let { quasis: d } = n, l = Kt(d, e, r); + D && Kt(d, D, r) !== l && (D = null), c && Kt(d, c, r) !== l && (c = null); + } + return { enclosingNode: n, precedingNode: D, followingNode: c }; +} +var Gt = () => false; +function bn(t, e) { + let { comments: r } = t; + if (delete t.comments, !Ut(r) || !e.printer.canAttachComment) + return; + let n = [], { locStart: o, locEnd: u, printer: { experimentalFeatures: { avoidAstMutation: i = false } = {}, handleComments: s = {} }, originalText: a } = e, { ownLine: D = Gt, endOfLine: c = Gt, remaining: F = Gt } = s, f = r.map((d, l) => ({ ...kn(t, d, e), comment: d, text: a, options: e, ast: t, isLastComment: r.length - 1 === l })); + for (let [d, l] of f.entries()) { + let { comment: p, precedingNode: m, enclosingNode: E, followingNode: h, text: g, options: C, ast: _, isLastComment: Z } = l; + if (C.parser === "json" || C.parser === "json5" || C.parser === "__js_expression" || C.parser === "__ts_expression" || C.parser === "__vue_expression" || C.parser === "__vue_ts_expression") { + if (o(p) - o(_) <= 0) { + ne(_, p); + continue; + } + if (u(p) - u(_) >= 0) { + ue(_, p); + continue; + } + } + let $; + if (i ? $ = [l] : (p.enclosingNode = E, p.precedingNode = m, p.followingNode = h, $ = [p, g, C, _, Z]), Fo(g, C, f, d)) + p.placement = "ownLine", D(...$) || (h ? ne(h, p) : m ? ue(m, p) : E ? X(E, p) : X(_, p)); + else if (mo(g, C, f, d)) + p.placement = "endOfLine", c(...$) || (m ? ue(m, p) : h ? ne(h, p) : E ? X(E, p) : X(_, p)); + else if (p.placement = "remaining", !F(...$)) + if (m && h) { + let Q = n.length; + Q > 0 && n[Q - 1].followingNode !== h && Bn(n, C), n.push(l); + } else + m ? ue(m, p) : h ? ne(h, p) : E ? X(E, p) : X(_, p); + } + if (Bn(n, e), !i) + for (let d of r) + delete d.precedingNode, delete d.enclosingNode, delete d.followingNode; +} +var wn = (t) => !/[\S\n\u2028\u2029]/.test(t); +function Fo(t, e, r, n) { + let { comment: o, precedingNode: u } = r[n], { locStart: i, locEnd: s } = e, a = i(o); + if (u) + for (let D = n - 1; D >= 0; D--) { + let { comment: c, precedingNode: F } = r[D]; + if (F !== u || !wn(t.slice(s(c), a))) + break; + a = i(c); + } + return V(t, a, { backwards: true }); +} +function mo(t, e, r, n) { + let { comment: o, followingNode: u } = r[n], { locStart: i, locEnd: s } = e, a = s(o); + if (u) + for (let D = n + 1; D < r.length; D++) { + let { comment: c, followingNode: F } = r[D]; + if (F !== u || !wn(t.slice(a, i(c)))) + break; + a = s(c); + } + return V(t, a); +} +function Bn(t, e) { + var s, a; + let r = t.length; + if (r === 0) + return; + let { precedingNode: n, followingNode: o } = t[0], u = e.locStart(o), i; + for (i = r; i > 0; --i) { + let { comment: D, precedingNode: c, followingNode: F } = t[i - 1]; + Re.strictEqual(c, n), Re.strictEqual(F, o); + let f = e.originalText.slice(e.locEnd(D), u); + if (((a = (s = e.printer).isGap) == null ? void 0 : a.call(s, f, e)) ?? /^[\s(]*$/.test(f)) + u = e.locStart(D); + else + break; + } + for (let [D, { comment: c }] of t.entries()) + D < i ? ue(n, c) : ne(o, c); + for (let D of [n, o]) + D.comments && D.comments.length > 1 && D.comments.sort((c, F) => e.locStart(c) - e.locStart(F)); + t.length = 0; +} +function Kt(t, e, r) { + let n = r.locStart(e) - 1; + for (let o = 1; o < t.length; ++o) + if (n < r.locStart(t[o])) + return o - 1; + return 0; +} +function Eo(t, e) { + let r = e - 1; + r = N(t, r, { backwards: true }), r = Y(t, r, { backwards: true }), r = N(t, r, { backwards: true }); + let n = Y(t, r, { backwards: true }); + return r !== n; +} +var Ye = Eo; +function On(t, e) { + let r = t.node; + return r.printed = true, e.printer.printComment(t, e); +} +function ho(t, e) { + var c; + let r = t.node, n = [On(t, e)], { printer: o, originalText: u, locStart: i, locEnd: s } = e; + if ((c = o.isBlockComment) == null ? void 0 : c.call(o, r)) { + let F = V(u, s(r)) ? V(u, i(r), { backwards: true }) ? G : Ke : " "; + n.push(F); + } else + n.push(G); + let D = Y(u, N(u, s(r))); + return D !== false && V(u, D) && n.push(G), n; +} +function Co(t, e, r) { + var D; + let n = t.node, o = On(t, e), { printer: u, originalText: i, locStart: s } = e, a = (D = u.isBlockComment) == null ? void 0 : D.call(u, n); + if (r != null && r.hasLineSuffix && !(r != null && r.isBlock) || V(i, s(n), { backwards: true })) { + let c = Ye(i, s(n)); + return { doc: _e([G, c ? G : "", o]), isBlock: a, hasLineSuffix: true }; + } + return !a || r != null && r.hasLineSuffix ? { doc: [_e([" ", o]), le], isBlock: a, hasLineSuffix: true } : { doc: [" ", o], isBlock: a, hasLineSuffix: false }; +} +function go(t, e) { + let r = t.node; + if (!r) + return {}; + let n = e[Symbol.for("printedComments")]; + if ((r.comments || []).filter((a) => !n.has(a)).length === 0) + return { leading: "", trailing: "" }; + let u = [], i = [], s; + return t.each(() => { + let a = t.node; + if (n != null && n.has(a)) + return; + let { leading: D, trailing: c } = a; + D ? u.push(ho(t, e)) : c && (s = Co(t, e, s), i.push(s.doc)); + }, "comments"), { leading: u, trailing: i }; +} +function Nn(t, e, r) { + let { leading: n, trailing: o } = go(t, r); + return !n && !o ? e : Ze(e, (u) => [n, u, o]); +} +function Tn(t) { + let { [Symbol.for("comments")]: e, [Symbol.for("printedComments")]: r } = t; + for (let n of e) { + if (!n.printed && !r.has(n)) + throw new Error('Comment "' + n.value.trim() + '" was not printed. Please report this error!'); + delete n.printed; + } +} +async function Sn(t, e, r, n, o) { + let { embeddedLanguageFormatting: u, printer: { embed: i, hasPrettierIgnore: s = () => false, getVisitorKeys: a } } = r; + if (!i || u !== "auto") + return; + if (i.length > 2) + throw new Error("printer.embed has too many parameters. The API changed in Prettier v3. Please update your plugin. See https://prettier.io/docs/en/plugins.html#optional-embed"); + let D = H(i.getVisitorKeys ?? a), c = []; + d(); + let F = t.stack; + for (let { print: l, node: p, pathStack: m } of c) + try { + t.stack = m; + let E = await l(f, e, t, r); + E && o.set(p, E); + } catch (E) { + if (globalThis.PRETTIER_DEBUG) + throw E; + } + t.stack = F; + function f(l, p) { + return yo(l, p, r, n); + } + function d() { + let { node: l } = t; + if (l === null || typeof l != "object" || s(t)) + return; + for (let m of D(l)) + Array.isArray(l[m]) ? t.each(d, m) : t.call(d, m); + let p = i(t, r); + if (p) { + if (typeof p == "function") { + c.push({ print: p, node: l, pathStack: [...t.stack] }); + return; + } + o.set(l, p); + } + } +} +async function yo(t, e, r, n) { + let o = await re({ ...r, ...e, parentParser: r.parser, originalText: t }, { passThrough: true }), { ast: u } = await ae(t, o), i = await n(u, o); + return Xe(i); +} +function _o(t, e) { + let { originalText: r, [Symbol.for("comments")]: n, locStart: o, locEnd: u, [Symbol.for("printedComments")]: i } = e, { node: s } = t, a = o(s), D = u(s); + for (let c of n) + o(c) >= a && u(c) <= D && i.add(c); + return r.slice(a, D); +} +var Pn = _o; +async function je(t, e) { + ({ ast: t } = await Ht(t, e)); + let r = /* @__PURE__ */ new Map(), n = new gn(t), u = /* @__PURE__ */ new Map(); + await Sn(n, s, e, je, u); + let i = await Ln(n, e, s, void 0, u); + return Tn(e), i; + function s(D, c) { + return D === void 0 || D === n ? a(c) : Array.isArray(D) ? n.call(() => a(c), ...D) : n.call(() => a(c), D); + } + function a(D) { + let c = n.node; + if (c == null) + return ""; + let F = c && typeof c == "object" && D === void 0; + if (F && r.has(c)) + return r.get(c); + let f = Ln(n, e, s, D, u); + return F && r.set(c, f), f; + } +} +function Ln(t, e, r, n, o) { + var a; + let { node: u } = t, { printer: i } = e, s; + return (a = i.hasPrettierIgnore) != null && a.call(i, t) ? s = Pn(t, e) : o.has(u) ? s = o.get(u) : s = i.print(t, e, r, n), u === e.cursorNode && (s = Ze(s, (D) => [Be, D, Be])), i.printComment && (!i.willPrintOwnComments || !i.willPrintOwnComments(t, e)) && (s = Nn(t, s, e)), s; +} +async function Ht(t, e) { + let r = t.comments ?? []; + e[Symbol.for("comments")] = r, e[Symbol.for("tokens")] = t.tokens ?? [], e[Symbol.for("printedComments")] = /* @__PURE__ */ new Set(), bn(t, e); + let { printer: { preprocess: n } } = e; + return t = n ? await n(t, e) : t, { ast: t, comments: r }; +} +var Ao = ({ parser: t }) => t === "json" || t === "json5" || t === "json-stringify"; +function Bo(t, e) { + let r = [t.node, ...t.parentNodes], n = /* @__PURE__ */ new Set([e.node, ...e.parentNodes]); + return r.find((o) => Yn.has(o.type) && n.has(o)); +} +function In(t) { + let e = t.length - 1; + for (; ; ) { + let r = t[e]; + if ((r == null ? void 0 : r.type) === "Program" || (r == null ? void 0 : r.type) === "File") + e--; + else + break; + } + return t.slice(0, e + 1); +} +function ko(t, e, { locStart: r, locEnd: n }) { + let o = t.node, u = e.node; + if (o === u) + return { startNode: o, endNode: u }; + let i = r(t.node); + for (let a of In(e.parentNodes)) + if (r(a) >= i) + u = a; + else + break; + let s = n(e.node); + for (let a of In(t.parentNodes)) { + if (n(a) <= s) + o = a; + else + break; + if (o === u) + break; + } + return { startNode: o, endNode: u }; +} +function qt(t, e, r, n, o = [], u) { + let { locStart: i, locEnd: s } = r, a = i(t), D = s(t); + if (!(e > D || e < a || u === "rangeEnd" && e === a || u === "rangeStart" && e === D)) { + for (let c of Et(t, r)) { + let F = qt(c, e, r, n, [t, ...o], u); + if (F) + return F; + } + if (!n || n(t, o[0])) + return { node: t, parentNodes: o }; + } +} +function bo(t, e) { + return e !== "DeclareExportDeclaration" && t !== "TypeParameterDeclaration" && (t === "Directive" || t === "TypeAlias" || t === "TSExportAssignment" || t.startsWith("Declare") || t.startsWith("TSDeclare") || t.endsWith("Statement") || t.endsWith("Declaration")); +} +var Yn = /* @__PURE__ */ new Set(["JsonRoot", "ObjectExpression", "ArrayExpression", "StringLiteral", "NumericLiteral", "BooleanLiteral", "NullLiteral", "UnaryExpression", "TemplateLiteral"]), wo = /* @__PURE__ */ new Set(["OperationDefinition", "FragmentDefinition", "VariableDefinition", "TypeExtensionDefinition", "ObjectTypeDefinition", "FieldDefinition", "DirectiveDefinition", "EnumTypeDefinition", "EnumValueDefinition", "InputValueDefinition", "InputObjectTypeDefinition", "SchemaDefinition", "OperationTypeDefinition", "InterfaceTypeDefinition", "UnionTypeDefinition", "ScalarTypeDefinition"]); +function Rn(t, e, r) { + if (!e) + return false; + switch (t.parser) { + case "flow": + case "babel": + case "babel-flow": + case "babel-ts": + case "typescript": + case "acorn": + case "espree": + case "meriyah": + case "__babel_estree": + return bo(e.type, r == null ? void 0 : r.type); + case "json": + case "json5": + case "json-stringify": + return Yn.has(e.type); + case "graphql": + return wo.has(e.kind); + case "vue": + return e.tag !== "root"; + } + return false; +} +function jn(t, e, r) { + let { rangeStart: n, rangeEnd: o, locStart: u, locEnd: i } = e; + Re.ok(o > n); + let s = t.slice(n, o).search(/\S/), a = s === -1; + if (!a) + for (n += s; o > n && !/\S/.test(t[o - 1]); --o) + ; + let D = qt(r, n, e, (d, l) => Rn(e, d, l), [], "rangeStart"), c = a ? D : qt(r, o, e, (d) => Rn(e, d), [], "rangeEnd"); + if (!D || !c) + return { rangeStart: 0, rangeEnd: 0 }; + let F, f; + if (Ao(e)) { + let d = Bo(D, c); + F = d, f = d; + } else + ({ startNode: F, endNode: f } = ko(D, c, e)); + return { rangeStart: Math.min(u(F), u(f)), rangeEnd: Math.max(i(F), i(f)) }; +} +function Oo(t, e) { + let { cursorOffset: r, locStart: n, locEnd: o } = e, u = H(e.printer.getVisitorKeys), i = (a) => n(a) <= r && o(a) >= r, s = t; + for (let a of An(t, { getVisitorKeys: u, filter: i })) + s = a; + return s; +} +var Vn = Oo; +var zn = "\uFEFF", $n = Symbol("cursor"); +async function Gn(t, e, r = 0) { + if (!t || t.trim().length === 0) + return { formatted: "", cursorOffset: -1, comments: [] }; + let { ast: n, text: o } = await ae(t, e); + e.cursorOffset >= 0 && (e.cursorNode = Vn(n, e)); + let u = await je(n, e); + r > 0 && (u = qe([G, u], r, e.tabWidth)); + let i = fe(u, e); + if (r > 0) { + let a = i.formatted.trim(); + i.cursorNodeStart !== void 0 && (i.cursorNodeStart -= i.formatted.indexOf(a)), i.formatted = a + be(e.endOfLine); + } + let s = e[Symbol.for("comments")]; + if (e.cursorOffset >= 0) { + let a, D, c, F, f; + if (e.cursorNode && i.cursorNodeText ? (a = e.locStart(e.cursorNode), D = o.slice(a, e.locEnd(e.cursorNode)), c = e.cursorOffset - a, F = i.cursorNodeStart, f = i.cursorNodeText) : (a = 0, D = o, c = e.cursorOffset, F = 0, f = i.formatted), D === f) + return { formatted: i.formatted, cursorOffset: F + c, comments: s }; + let d = D.split(""); + d.splice(c, 0, $n); + let l = f.split(""), p = (0, Wn.diffArrays)(d, l), m = F; + for (let E of p) + if (E.removed) { + if (E.value.includes($n)) + break; + } else + m += E.count; + return { formatted: i.formatted, cursorOffset: m, comments: s }; + } + return { formatted: i.formatted, cursorOffset: -1, comments: s }; +} +async function No(t, e) { + let { ast: r, text: n } = await ae(t, e), { rangeStart: o, rangeEnd: u } = jn(n, e, r), i = n.slice(o, u), s = Math.min(o, n.lastIndexOf(` +`, o) + 1), a = n.slice(s, o).match(/^\s*/)[0], D = pe(a, e.tabWidth), c = await Gn(i, { ...e, rangeStart: 0, rangeEnd: Number.POSITIVE_INFINITY, cursorOffset: e.cursorOffset > o && e.cursorOffset <= u ? e.cursorOffset - o : -1, endOfLine: "lf" }, D), F = c.formatted.trimEnd(), { cursorOffset: f } = e; + f > u ? f += F.length - i.length : c.cursorOffset >= 0 && (f = c.cursorOffset + o); + let d = n.slice(0, o) + F + n.slice(u); + if (e.endOfLine !== "lf") { + let l = be(e.endOfLine); + f >= 0 && l === `\r +` && (f += At(d.slice(0, f), ` +`)), d = ee(false, d, ` +`, l); + } + return { formatted: d, cursorOffset: f, comments: c.comments }; +} +function Jt(t, e, r) { + return typeof e != "number" || Number.isNaN(e) || e < 0 || e > t.length ? r : e; +} +function Un(t, e) { + let { cursorOffset: r, rangeStart: n, rangeEnd: o } = e; + return r = Jt(t, r, -1), n = Jt(t, n, 0), o = Jt(t, o, t.length), { ...e, cursorOffset: r, rangeStart: n, rangeEnd: o }; +} +function Kn(t, e) { + let { cursorOffset: r, rangeStart: n, rangeEnd: o, endOfLine: u } = Un(t, e), i = t.charAt(0) === zn; + if (i && (t = t.slice(1), r--, n--, o--), u === "auto" && (u = Cr(t)), t.includes("\r")) { + let s = (a) => At(t.slice(0, Math.max(a, 0)), `\r +`); + r -= s(r), n -= s(n), o -= s(o), t = gr(t); + } + return { hasBOM: i, text: t, options: Un(t, { ...e, cursorOffset: r, rangeStart: n, rangeEnd: o, endOfLine: u }) }; +} +async function Mn(t, e) { + let r = await ft(e); + return !r.hasPragma || r.hasPragma(t); +} +async function Xt(t, e) { + let { hasBOM: r, text: n, options: o } = Kn(t, await re(e)); + if (o.rangeStart >= o.rangeEnd && n !== "" || o.requirePragma && !await Mn(n, o)) + return { formatted: t, cursorOffset: e.cursorOffset, comments: [] }; + let u; + return o.rangeStart > 0 || o.rangeEnd < n.length ? u = await No(n, o) : (!o.requirePragma && o.insertPragma && o.printer.insertPragma && !await Mn(n, o) && (n = o.printer.insertPragma(n)), u = await Gn(n, o)), r && (u.formatted = zn + u.formatted, u.cursorOffset >= 0 && u.cursorOffset++), u; +} +async function Hn(t, e, r) { + let { text: n, options: o } = Kn(t, await re(e)), u = await ae(n, o); + return r && (r.preprocessForPrint && (u.ast = await Ht(u.ast, o)), r.massage && (u.ast = cn(u.ast, o))), u; +} +async function qn(t, e) { + e = await re(e); + let r = await je(t, e); + return fe(r, e); +} +async function Jn(t, e) { + let r = Sr(t), { formatted: n } = await Xt(r, { ...e, parser: "__js_expression" }); + return n; +} +async function Xn(t, e) { + e = await re(e); + let { ast: r } = await ae(t, e); + return je(r, e); +} +async function Zn(t, e) { + return fe(t, await re(e)); +} +var Qt = {}; +Me(Qt, { addDanglingComment: () => X, addLeadingComment: () => ne, addTrailingComment: () => ue, getAlignmentSize: () => pe, getIndentSize: () => eu, getMaxContinuousCount: () => Qn, getNextNonSpaceNonCommentCharacter: () => nu, getNextNonSpaceNonCommentCharacterIndex: () => Mo, getStringWidth: () => we, hasNewline: () => V, hasNewlineInRange: () => tu, hasSpaces: () => ru, isNextLineEmpty: () => Ko, isNextLineEmptyAfterIndex: () => ht, isPreviousLineEmpty: () => zo, makeString: () => uu, skip: () => me, skipEverythingButNewLine: () => mt, skipInlineComment: () => Ee, skipNewline: () => Y, skipSpaces: () => N, skipToLineEnd: () => Ft, skipTrailingComment: () => he, skipWhitespace: () => xn }); +function So(t, e) { + if (e === false) + return false; + if (t.charAt(e) === "/" && t.charAt(e + 1) === "*") { + for (let r = e + 2; r < t.length; ++r) + if (t.charAt(r) === "*" && t.charAt(r + 1) === "/") + return r + 2; + } + return e; +} +var Ee = So; +function vo(t, e) { + return e === false ? false : t.charAt(e) === "/" && t.charAt(e + 1) === "/" ? mt(t, e) : e; +} +var he = vo; +function Po(t, e) { + let r = null, n = e; + for (; n !== r; ) + r = n, n = N(t, n), n = Ee(t, n), n = he(t, n), n = Y(t, n); + return n; +} +var Ve = Po; +function Lo(t, e) { + let r = null, n = e; + for (; n !== r; ) + r = n, n = Ft(t, n), n = Ee(t, n), n = N(t, n); + return n = he(t, n), n = Y(t, n), n !== false && V(t, n); +} +var ht = Lo; +function Zt(t) { + if (typeof t != "string") + throw new TypeError("Expected a string"); + return t.replace(/[|\\{}()[\]^$+*?.]/g, "\\$&").replace(/-/g, "\\x2d"); +} +function Io(t, e) { + let r = t.match(new RegExp(`(${Zt(e)})+`, "g")); + return r === null ? 0 : r.reduce((n, o) => Math.max(n, o.length / e.length), 0); +} +var Qn = Io; +function Ro(t, e) { + let r = t.lastIndexOf(` +`); + return r === -1 ? 0 : pe(t.slice(r + 1).match(/^[\t ]*/)[0], e); +} +var eu = Ro; +function Yo(t, e, r) { + for (let n = e; n < r; ++n) + if (t.charAt(n) === ` +`) + return true; + return false; +} +var tu = Yo; +function jo(t, e, r = {}) { + return N(t, r.backwards ? e - 1 : e, r) !== e; +} +var ru = jo; +function Vo(t, e) { + let r = Ve(t, e); + return r === false ? "" : t.charAt(r); +} +var nu = Vo; +function $o(t, e, r) { + let n = e === '"' ? "'" : '"', u = ee(false, t, /\\(.)|(["'])/gs, (i, s, a) => s === n ? s : a === e ? "\\" + a : a || (r && /^[^\n\r"'0-7\\bfnrt-vx\u2028\u2029]$/.test(s) ? s : "\\" + s)); + return e + u + e; +} +var uu = $o; +function Uo(t, e, r) { + return Ve(t, r(e)); +} +function Mo(t, e) { + return arguments.length === 2 || typeof e == "number" ? Ve(t, e) : Uo(...arguments); +} +function Wo(t, e, r) { + return Ye(t, r(e)); +} +function zo(t, e) { + return arguments.length === 2 || typeof e == "number" ? Ye(t, e) : Wo(...arguments); +} +function Go(t, e, r) { + return ht(t, r(e)); +} +function Ko(t, e) { + return arguments.length === 2 || typeof e == "number" ? ht(t, e) : Go(...arguments); +} +var er = {}; +Me(er, { builders: () => Ho, printer: () => qo, utils: () => Jo }); +var Ho = { join: ke, line: Ke, softline: Er, hardline: G, literalline: He, group: xt, conditionalGroup: fr, fill: Ge, lineSuffix: _e, lineSuffixBoundary: Fr, cursor: Be, breakParent: le, ifBreak: pr, trim: mr, indent: ie, indentIfBreak: dr, align: oe, addAlignmentToDoc: qe, markAsRoot: cr, dedentToRoot: Dr, dedent: lr, hardlineWithoutBreakParent: Ae, literallineWithoutBreakParent: _t, label: hr, concat: (t) => t }, qo = { printDocToString: fe }, Jo = { willBreak: kr, traverseDoc: xe, findInDoc: Je, mapDoc: Ne, removeLines: wr, stripTrailingHardline: Xe, replaceEndOfLine: Or, canBreak: Nr }; +var ou = "3.0.3"; +function De(t, e = 1) { + return async (...r) => { + let n = r[e] ?? {}, o = n.plugins ?? []; + return r[e] = { ...n, plugins: Array.isArray(o) ? o : Object.values(o) }, t(...r); + }; +} +var iu = De(Xt); +async function su(t, e) { + let { formatted: r } = await iu(t, { ...e, cursorOffset: -1 }); + return r; +} +async function Xo(t, e) { + return await su(t, e) === t; +} +var Zo = De(et, 0), Qo = { parse: De(Hn), formatAST: De(qn), formatDoc: De(Jn), printToDoc: De(Xn), printDocToString: De(Zn) }; +var Uc = tr; +const standalone = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({ + __proto__: null, + __debug: Qo, + check: Xo, + default: Uc, + doc: er, + format: su, + formatWithCursor: iu, + getSupportInfo: Zo, + util: Qt, + version: ou +}, Symbol.toStringTag, { value: "Module" })); +async function printPrettier(source = "", options = {}) { + return await su(source, { + printWidth: 80, + useTabs: true, + ...options, + parser: "latex-parser", + plugins: [prettierPluginLatex] + }); +} +export { + standalone as Prettier, + printPrettier +}; +//# sourceMappingURL=standalone.mjs.map diff --git a/node_modules/prettier-plugin-latex/package.json b/node_modules/prettier-plugin-latex/package.json new file mode 100644 index 0000000..c8b4127 --- /dev/null +++ b/node_modules/prettier-plugin-latex/package.json @@ -0,0 +1,64 @@ +{ + "name": "prettier-plugin-latex", + "description": "A Prettier plugin for formatting LaTeX source files", + "version": "2.0.1", + "author": { + "name": "Jason Siefken", + "email": "siefkenj@gmail.com" + }, + "keywords": [ + "latex", + "parser", + "prettier" + ], + "main": "dist/prettier-plugin-latex.js", + "exports": { + ".": { + "import": "./dist/prettier-plugin-latex.mjs", + "require": "./dist/prettier-plugin-latex.js" + }, + "./*js": "./dist/*js", + "./*mjs": "./dist/*mjs", + "./*": { + "import": "./dist/*.mjs", + "require": "./dist/*.js" + } + }, + "files": [ + "dist/*.js", + "dist/*.js.map", + "dist/*.mjs", + "dist/*.d.ts" + ], + "scripts": { + "test": "vitest", + "watch": "vite build --watch", + "build": "vite build" + }, + "dependencies": { + "@unified-latex/unified-latex-prettier": "^2.4.2", + "prettier": "^3.0.3" + }, + "devDependencies": { + "eslint": "^8.48.0", + "jsdom": "^22.1.0", + "mkdirp": "3.0.1", + "resolve-cwd": "^3.0.0", + "typescript": "^5.2.2", + "vite": "^4.4.9", + "vitest": "^0.34.5", + "vite-plugin-dts": "^3.6.0" + }, + "repository": { + "type": "git", + "url": "git+https://github.com/siefkenj/prettier-plugin-latex.git" + }, + "license": "MIT", + "bugs": { + "url": "https://github.com/siefkenj/prettier-plugin-latex/issues" + }, + "homepage": "https://github.com/siefkenj/prettier-plugin-latex#readme", + "engines": { + "node": ">= 18.0" + } +} diff --git a/node_modules/prettier/LICENSE b/node_modules/prettier/LICENSE new file mode 100644 index 0000000..5767e34 --- /dev/null +++ b/node_modules/prettier/LICENSE @@ -0,0 +1,7 @@ +Copyright © James Long and contributors + +Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. diff --git a/node_modules/prettier/README.md b/node_modules/prettier/README.md new file mode 100644 index 0000000..ce24c9c --- /dev/null +++ b/node_modules/prettier/README.md @@ -0,0 +1,108 @@ +[![Prettier Banner](https://unpkg.com/prettier-logo@1.0.3/images/prettier-banner-light.svg)](https://prettier.io) + +

Opinionated Code Formatter

+ +

+ + JavaScript + · TypeScript + · Flow + · JSX + · JSON + +
+ + CSS + · SCSS + · Less + +
+ + HTML + · Vue + · Angular + +
+ + GraphQL + · Markdown + · YAML + +
+ + + Your favorite language? + + +

+ +

+ + Github Actions Build Status + + Github Actions Build Status + + Github Actions Build Status + + Codecov Coverage Status + + Blazing Fast +
+ + npm version + + weekly downloads from npm + + code style: prettier + + Follow Prettier on Twitter +

+ +## Intro + +Prettier is an opinionated code formatter. It enforces a consistent style by parsing your code and re-printing it with its own rules that take the maximum line length into account, wrapping code when necessary. + +### Input + + +```js +foo(reallyLongArg(), omgSoManyParameters(), IShouldRefactorThis(), isThereSeriouslyAnotherOne()); +``` + +### Output + +```js +foo( + reallyLongArg(), + omgSoManyParameters(), + IShouldRefactorThis(), + isThereSeriouslyAnotherOne(), +); +``` + +Prettier can be run [in your editor](https://prettier.io/docs/editors) on-save, in a [pre-commit hook](https://prettier.io/docs/precommit), or in [CI environments](https://prettier.io/docs/cli#list-different) to ensure your codebase has a consistent style without devs ever having to post a nit-picky comment on a code review ever again! + +--- + +**[Documentation](https://prettier.io/docs/)** + +[Install](https://prettier.io/docs/install) · +[Options](https://prettier.io/docs/options) · +[CLI](https://prettier.io/docs/cli) · +[API](https://prettier.io/docs/api) + +**[Playground](https://prettier.io/playground/)** + +--- + +## Badge + +Show the world you're using _Prettier_ → [![code style: prettier](https://img.shields.io/badge/code_style-prettier-ff69b4.svg?style=flat-square)](https://github.com/prettier/prettier) + +```md +[![code style: prettier](https://img.shields.io/badge/code_style-prettier-ff69b4.svg?style=flat-square)](https://github.com/prettier/prettier) +``` + +## Contributing + +See [CONTRIBUTING.md](CONTRIBUTING.md). diff --git a/node_modules/prettier/THIRD-PARTY-NOTICES.md b/node_modules/prettier/THIRD-PARTY-NOTICES.md new file mode 100644 index 0000000..90b03ea --- /dev/null +++ b/node_modules/prettier/THIRD-PARTY-NOTICES.md @@ -0,0 +1,4416 @@ +# Licenses of bundled dependencies + +The published Prettier artifact additionally contains code with the following licenses: +MIT, ISC, BSD-3-Clause, BSD-2-Clause, and Apache-2.0. + +## @angular/compiler@v19.1.2 + +> Angular - the compiler library + +License: MIT +Repository: +Author: angular + +> The MIT License +> +> Copyright (c) 2010-2025 Google LLC. https://angular.dev/license +> +> Permission is hereby granted, free of charge, to any person obtaining a copy +> of this software and associated documentation files (the "Software"), to deal +> in the Software without restriction, including without limitation the rights +> to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +> copies of the Software, and to permit persons to whom the Software is +> furnished to do so, subject to the following conditions: +> +> The above copyright notice and this permission notice shall be included in +> all copies or substantial portions of the Software. +> +> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +> FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +> AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +> LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +> OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +> THE SOFTWARE. + +---------------------------------------- + +## @babel/code-frame@v7.26.2 + +> Generate errors that contain a code frame that point to source locations. + +License: MIT +Homepage: +Repository: +Author: The Babel Team (https://babel.dev/team) + +> MIT License +> +> Copyright (c) 2014-present Sebastian McKenzie and other contributors +> +> Permission is hereby granted, free of charge, to any person obtaining +> a copy of this software and associated documentation files (the +> "Software"), to deal in the Software without restriction, including +> without limitation the rights to use, copy, modify, merge, publish, +> distribute, sublicense, and/or sell copies of the Software, and to +> permit persons to whom the Software is furnished to do so, subject to +> the following conditions: +> +> The above copyright notice and this permission notice shall be +> included in all copies or substantial portions of the Software. +> +> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +> EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +> MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +> NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE +> LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION +> OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +> WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +---------------------------------------- + +## @babel/helper-validator-identifier@v7.25.9 + +> Validate identifier/keywords name + +License: MIT +Repository: +Author: The Babel Team (https://babel.dev/team) + +> MIT License +> +> Copyright (c) 2014-present Sebastian McKenzie and other contributors +> +> Permission is hereby granted, free of charge, to any person obtaining +> a copy of this software and associated documentation files (the +> "Software"), to deal in the Software without restriction, including +> without limitation the rights to use, copy, modify, merge, publish, +> distribute, sublicense, and/or sell copies of the Software, and to +> permit persons to whom the Software is furnished to do so, subject to +> the following conditions: +> +> The above copyright notice and this permission notice shall be +> included in all copies or substantial portions of the Software. +> +> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +> EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +> MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +> NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE +> LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION +> OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +> WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +---------------------------------------- + +## @babel/parser@v7.26.9 + +> A JavaScript parser + +License: MIT +Homepage: +Repository: +Author: The Babel Team (https://babel.dev/team) + +> Copyright (C) 2012-2014 by various contributors (see AUTHORS) +> +> Permission is hereby granted, free of charge, to any person obtaining a copy +> of this software and associated documentation files (the "Software"), to deal +> in the Software without restriction, including without limitation the rights +> to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +> copies of the Software, and to permit persons to whom the Software is +> furnished to do so, subject to the following conditions: +> +> The above copyright notice and this permission notice shall be included in +> all copies or substantial portions of the Software. +> +> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +> FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +> AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +> LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +> OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +> THE SOFTWARE. + +---------------------------------------- + +## @glimmer/syntax@v0.94.7 + +License: MIT +Repository: + +> Copyright (c) 2015 Tilde, Inc. +> +> Permission is hereby granted, free of charge, to any person obtaining a copy of +> this software and associated documentation files (the "Software"), to deal in +> the Software without restriction, including without limitation the rights to +> use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies +> of the Software, and to permit persons to whom the Software is furnished to do +> so, subject to the following conditions: +> +> The above copyright notice and this permission notice shall be included in all +> copies or substantial portions of the Software. +> +> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +> FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +> AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +> LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +> OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +> SOFTWARE. + +---------------------------------------- + +## @glimmer/util@v0.94.6 + +> Common utilities used in Glimmer + +License: MIT +Repository: + +> Copyright (c) 2015 Tilde, Inc. +> +> Permission is hereby granted, free of charge, to any person obtaining a copy of +> this software and associated documentation files (the "Software"), to deal in +> the Software without restriction, including without limitation the rights to +> use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies +> of the Software, and to permit persons to whom the Software is furnished to do +> so, subject to the following conditions: +> +> The above copyright notice and this permission notice shall be included in all +> copies or substantial portions of the Software. +> +> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +> FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +> AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +> LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +> OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +> SOFTWARE. + +---------------------------------------- + +## @glimmer/wire-format@v0.94.6 + +License: MIT +Repository: + +> Copyright (c) 2015 Tilde, Inc. +> +> Permission is hereby granted, free of charge, to any person obtaining a copy of +> this software and associated documentation files (the "Software"), to deal in +> the Software without restriction, including without limitation the rights to +> use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies +> of the Software, and to permit persons to whom the Software is furnished to do +> so, subject to the following conditions: +> +> The above copyright notice and this permission notice shall be included in all +> copies or substantial portions of the Software. +> +> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +> FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +> AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +> LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +> OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +> SOFTWARE. + +---------------------------------------- + +## @handlebars/parser@v2.0.0 + +> The parser for the Handlebars language + +License: ISC +Homepage: +Repository: + +---------------------------------------- + +## @keyv/serialize@v1.0.2 + +> Serialization for Keyv + +License: MIT +Homepage: +Repository: +Author: Jared Wray (https://jaredwray.com) + +> MIT License +> +> Copyright (c) 2017-2021 Luke Childs +> Copyright (c) 2021-2022 Jared Wray +> +> Permission is hereby granted, free of charge, to any person obtaining a copy +> of this software and associated documentation files (the "Software"), to deal +> in the Software without restriction, including without limitation the rights +> to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +> copies of the Software, and to permit persons to whom the Software is +> furnished to do so, subject to the following conditions: +> +> The above copyright notice and this permission notice shall be included in all +> copies or substantial portions of the Software. +> +> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +> FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +> AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +> LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +> OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +> SOFTWARE. + +---------------------------------------- + +## @nodelib/fs.scandir@v2.1.5 + +> List files and directories inside the specified directory + +License: MIT + +> The MIT License (MIT) +> +> Copyright (c) Denis Malinochkin +> +> Permission is hereby granted, free of charge, to any person obtaining a copy +> of this software and associated documentation files (the "Software"), to deal +> in the Software without restriction, including without limitation the rights +> to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +> copies of the Software, and to permit persons to whom the Software is +> furnished to do so, subject to the following conditions: +> +> The above copyright notice and this permission notice shall be included in all +> copies or substantial portions of the Software. +> +> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +> FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +> AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +> LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +> OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +> SOFTWARE. + +---------------------------------------- + +## @nodelib/fs.stat@v2.0.5 + +> Get the status of a file with some features + +License: MIT + +> The MIT License (MIT) +> +> Copyright (c) Denis Malinochkin +> +> Permission is hereby granted, free of charge, to any person obtaining a copy +> of this software and associated documentation files (the "Software"), to deal +> in the Software without restriction, including without limitation the rights +> to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +> copies of the Software, and to permit persons to whom the Software is +> furnished to do so, subject to the following conditions: +> +> The above copyright notice and this permission notice shall be included in all +> copies or substantial portions of the Software. +> +> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +> FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +> AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +> LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +> OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +> SOFTWARE. + +---------------------------------------- + +## @nodelib/fs.walk@v1.2.8 + +> A library for efficiently walking a directory recursively + +License: MIT + +> The MIT License (MIT) +> +> Copyright (c) Denis Malinochkin +> +> Permission is hereby granted, free of charge, to any person obtaining a copy +> of this software and associated documentation files (the "Software"), to deal +> in the Software without restriction, including without limitation the rights +> to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +> copies of the Software, and to permit persons to whom the Software is +> furnished to do so, subject to the following conditions: +> +> The above copyright notice and this permission notice shall be included in all +> copies or substantial portions of the Software. +> +> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +> FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +> AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +> LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +> OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +> SOFTWARE. + +---------------------------------------- + +## @prettier/is-es5-identifier-name@v0.2.0 + +> Check if provided string is an `IdentifierName` as specified in ECMA262 edition 5.1 section 7.6. + +License: MIT +Author: fisker Cheung + +> MIT License +> +> Copyright (c) fisker Cheung (https://www.fiskercheung.com/) +> +> Permission is hereby granted, free of charge, to any person obtaining a copy +> of this software and associated documentation files (the "Software"), to deal +> in the Software without restriction, including without limitation the rights +> to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +> copies of the Software, and to permit persons to whom the Software is +> furnished to do so, subject to the following conditions: +> +> The above copyright notice and this permission notice shall be included in all +> copies or substantial portions of the Software. +> +> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +> FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +> AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +> LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +> OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +> SOFTWARE. + +---------------------------------------- + +## @prettier/parse-srcset@v3.1.0 + +> A spec-conformant JavaScript parser for the HTML5 srcset attribute + +License: MIT +Homepage: +Author: Alex Bell + +> The MIT License (MIT) +> +> Copyright (c) 2014 Alex Bell +> Copyright (c) fisker Cheung +> +> Permission is hereby granted, free of charge, to any person obtaining a copy +> of this software and associated documentation files (the "Software"), to deal +> in the Software without restriction, including without limitation the rights +> to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +> copies of the Software, and to permit persons to whom the Software is +> furnished to do so, subject to the following conditions: +> +> The above copyright notice and this permission notice shall be included in all +> copies or substantial portions of the Software. +> +> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +> FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +> AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +> LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +> OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +> SOFTWARE. + +---------------------------------------- + +## @typescript-eslint/types@v8.24.1 + +> Types for the TypeScript-ESTree AST spec + +License: MIT +Homepage: +Repository: + +> MIT License +> +> Copyright (c) 2019 typescript-eslint and other contributors +> +> Permission is hereby granted, free of charge, to any person obtaining a copy +> of this software and associated documentation files (the "Software"), to deal +> in the Software without restriction, including without limitation the rights +> to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +> copies of the Software, and to permit persons to whom the Software is +> furnished to do so, subject to the following conditions: +> +> The above copyright notice and this permission notice shall be included in all +> copies or substantial portions of the Software. +> +> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +> FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +> AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +> LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +> OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +> SOFTWARE. + +---------------------------------------- + +## @typescript-eslint/typescript-estree@v8.24.1 + +> A parser that converts TypeScript source code into an ESTree compatible form + +License: MIT +Homepage: +Repository: + +> MIT License +> +> Copyright (c) 2019 typescript-eslint and other contributors +> +> Permission is hereby granted, free of charge, to any person obtaining a copy +> of this software and associated documentation files (the "Software"), to deal +> in the Software without restriction, including without limitation the rights +> to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +> copies of the Software, and to permit persons to whom the Software is +> furnished to do so, subject to the following conditions: +> +> The above copyright notice and this permission notice shall be included in all +> copies or substantial portions of the Software. +> +> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +> FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +> AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +> LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +> OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +> SOFTWARE. + +---------------------------------------- + +## acorn@v8.14.0 + +> ECMAScript parser + +License: MIT +Homepage: +Repository: + +> MIT License +> +> Copyright (C) 2012-2022 by various contributors (see AUTHORS) +> +> Permission is hereby granted, free of charge, to any person obtaining a copy +> of this software and associated documentation files (the "Software"), to deal +> in the Software without restriction, including without limitation the rights +> to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +> copies of the Software, and to permit persons to whom the Software is +> furnished to do so, subject to the following conditions: +> +> The above copyright notice and this permission notice shall be included in +> all copies or substantial portions of the Software. +> +> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +> FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +> AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +> LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +> OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +> THE SOFTWARE. + +---------------------------------------- + +## acorn-jsx@v5.3.2 + +> Modern, fast React.js JSX parser + +License: MIT +Homepage: +Repository: + +> Copyright (C) 2012-2017 by Ingvar Stepanyan +> +> Permission is hereby granted, free of charge, to any person obtaining a copy +> of this software and associated documentation files (the "Software"), to deal +> in the Software without restriction, including without limitation the rights +> to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +> copies of the Software, and to permit persons to whom the Software is +> furnished to do so, subject to the following conditions: +> +> The above copyright notice and this permission notice shall be included in +> all copies or substantial portions of the Software. +> +> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +> FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +> AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +> LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +> OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +> THE SOFTWARE. + +---------------------------------------- + +## angular-estree-parser@v10.2.0 + +> A parser that converts Angular source code into an ESTree-compatible form + +License: MIT +Homepage: +Author: Ika (https://github.com/ikatyang) + +> MIT License +> +> Copyright (c) Ika (https://github.com/ikatyang) +> +> Permission is hereby granted, free of charge, to any person obtaining a copy +> of this software and associated documentation files (the "Software"), to deal +> in the Software without restriction, including without limitation the rights +> to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +> copies of the Software, and to permit persons to whom the Software is +> furnished to do so, subject to the following conditions: +> +> The above copyright notice and this permission notice shall be included in all +> copies or substantial portions of the Software. +> +> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +> FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +> AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +> LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +> OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +> SOFTWARE. + +---------------------------------------- + +## angular-html-parser@v8.0.1 + +> A HTML parser extracted from Angular with some modifications + +License: MIT +Homepage: +Author: Ika (https://github.com/ikatyang) + +> MIT License +> +> Copyright (c) Ika (https://github.com/ikatyang) +> +> Permission is hereby granted, free of charge, to any person obtaining a copy +> of this software and associated documentation files (the "Software"), to deal +> in the Software without restriction, including without limitation the rights +> to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +> copies of the Software, and to permit persons to whom the Software is +> furnished to do so, subject to the following conditions: +> +> The above copyright notice and this permission notice shall be included in all +> copies or substantial portions of the Software. +> +> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +> FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +> AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +> LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +> OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +> SOFTWARE. + +---------------------------------------- + +## ansi-regex@v6.1.0 + +> Regular expression for matching ANSI escape codes + +License: MIT +Author: Sindre Sorhus (https://sindresorhus.com) + +> MIT License +> +> Copyright (c) Sindre Sorhus (https://sindresorhus.com) +> +> Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: +> +> The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. +> +> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +---------------------------------------- + +## bail@v1.0.5 + +> Throw a given error + +License: MIT +Author: Titus Wormer (https://wooorm.com) +Contributors: + - Titus Wormer (https://wooorm.com) + +> (The MIT License) +> +> Copyright (c) 2015 Titus Wormer +> +> Permission is hereby granted, free of charge, to any person obtaining +> a copy of this software and associated documentation files (the +> 'Software'), to deal in the Software without restriction, including +> without limitation the rights to use, copy, modify, merge, publish, +> distribute, sublicense, and/or sell copies of the Software, and to +> permit persons to whom the Software is furnished to do so, subject to +> the following conditions: +> +> The above copyright notice and this permission notice shall be +> included in all copies or substantial portions of the Software. +> +> THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, +> EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +> MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. +> IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY +> CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, +> TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE +> SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +---------------------------------------- + +## braces@v3.0.3 + +> Bash-like brace expansion, implemented in JavaScript. Safer than other brace expansion libs, with complete support for the Bash 4.3 braces specification, without sacrificing speed. + +License: MIT +Homepage: +Author: Jon Schlinkert (https://github.com/jonschlinkert) +Contributors: + - Brian Woodward (https://twitter.com/doowb) + - Elan Shanker (https://github.com/es128) + - Eugene Sharygin (https://github.com/eush77) + - hemanth.hm (http://h3manth.com) + - Jon Schlinkert (http://twitter.com/jonschlinkert) + +> The MIT License (MIT) +> +> Copyright (c) 2014-present, Jon Schlinkert. +> +> Permission is hereby granted, free of charge, to any person obtaining a copy +> of this software and associated documentation files (the "Software"), to deal +> in the Software without restriction, including without limitation the rights +> to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +> copies of the Software, and to permit persons to whom the Software is +> furnished to do so, subject to the following conditions: +> +> The above copyright notice and this permission notice shall be included in +> all copies or substantial portions of the Software. +> +> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +> FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +> AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +> LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +> OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +> THE SOFTWARE. + +---------------------------------------- + +## cacheable@v1.8.8 + +> High Performance Layer 1 / Layer 2 Caching with Keyv Storage + +License: MIT +Repository: +Author: Jared Wray + +> MIT License & © Jared Wray +> +> Permission is hereby granted, free of charge, to any person obtaining a copy +> of this software and associated documentation files (the "Software"), to +> deal in the Software without restriction, including without limitation the +> rights to use, copy, modify, merge, publish, distribute, sublicense, and/or +> sell copies of the Software, and to permit persons to whom the Software is +> furnished to do so, subject to the following conditions: +> +> The above copyright notice and this permission notice shall be included in +> all copies or substantial portions of the Software. +> +> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +> FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +> AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +> LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +> FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +> DEALINGS IN THE SOFTWARE. + +---------------------------------------- + +## camelcase@v8.0.0 + +> Convert a dash/dot/underscore/space separated string to camelCase or PascalCase: `foo-bar` → `fooBar` + +License: MIT +Author: Sindre Sorhus (https://sindresorhus.com) + +> MIT License +> +> Copyright (c) Sindre Sorhus (https://sindresorhus.com) +> +> Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: +> +> The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. +> +> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +---------------------------------------- + +## ccount@v1.1.0 + +> Count characters + +License: MIT +Author: Titus Wormer (https://wooorm.com) +Contributors: + - Titus Wormer (https://wooorm.com) + +> (The MIT License) +> +> Copyright (c) 2015 Titus Wormer +> +> Permission is hereby granted, free of charge, to any person obtaining +> a copy of this software and associated documentation files (the +> 'Software'), to deal in the Software without restriction, including +> without limitation the rights to use, copy, modify, merge, publish, +> distribute, sublicense, and/or sell copies of the Software, and to +> permit persons to whom the Software is furnished to do so, subject to +> the following conditions: +> +> The above copyright notice and this permission notice shall be +> included in all copies or substantial portions of the Software. +> +> THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, +> EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +> MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. +> IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY +> CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, +> TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE +> SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +---------------------------------------- + +## chalk@v5.4.1 + +> Terminal string styling done right + +License: MIT + +> MIT License +> +> Copyright (c) Sindre Sorhus (https://sindresorhus.com) +> +> Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: +> +> The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. +> +> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +---------------------------------------- + +## character-entities@v1.2.4 + +> HTML character entity information + +License: MIT +Author: Titus Wormer (https://wooorm.com) +Contributors: + - Titus Wormer (https://wooorm.com) + +> (The MIT License) +> +> Copyright (c) 2015 Titus Wormer +> +> Permission is hereby granted, free of charge, to any person obtaining +> a copy of this software and associated documentation files (the +> 'Software'), to deal in the Software without restriction, including +> without limitation the rights to use, copy, modify, merge, publish, +> distribute, sublicense, and/or sell copies of the Software, and to +> permit persons to whom the Software is furnished to do so, subject to +> the following conditions: +> +> The above copyright notice and this permission notice shall be +> included in all copies or substantial portions of the Software. +> +> THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, +> EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +> MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. +> IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY +> CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, +> TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE +> SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +---------------------------------------- + +## character-entities-legacy@v1.1.4 + +> HTML legacy character entity information + +License: MIT +Author: Titus Wormer (https://wooorm.com) +Contributors: + - Titus Wormer (https://wooorm.com) + +> (The MIT License) +> +> Copyright (c) 2015 Titus Wormer +> +> Permission is hereby granted, free of charge, to any person obtaining +> a copy of this software and associated documentation files (the +> 'Software'), to deal in the Software without restriction, including +> without limitation the rights to use, copy, modify, merge, publish, +> distribute, sublicense, and/or sell copies of the Software, and to +> permit persons to whom the Software is furnished to do so, subject to +> the following conditions: +> +> The above copyright notice and this permission notice shall be +> included in all copies or substantial portions of the Software. +> +> THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, +> EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +> MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. +> IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY +> CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, +> TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE +> SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +---------------------------------------- + +## character-reference-invalid@v1.1.4 + +> HTML invalid numeric character reference information + +License: MIT +Author: Titus Wormer (https://wooorm.com) +Contributors: + - Titus Wormer (https://wooorm.com) + +> (The MIT License) +> +> Copyright (c) 2015 Titus Wormer +> +> Permission is hereby granted, free of charge, to any person obtaining +> a copy of this software and associated documentation files (the +> 'Software'), to deal in the Software without restriction, including +> without limitation the rights to use, copy, modify, merge, publish, +> distribute, sublicense, and/or sell copies of the Software, and to +> permit persons to whom the Software is furnished to do so, subject to +> the following conditions: +> +> The above copyright notice and this permission notice shall be +> included in all copies or substantial portions of the Software. +> +> THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, +> EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +> MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. +> IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY +> CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, +> TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE +> SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +---------------------------------------- + +## ci-info@v4.1.0 + +> Get details about the current Continuous Integration environment + +License: MIT +Homepage: +Author: Thomas Watson Steen (https://twitter.com/wa7son) +Contributors: + - Sibiraj (https://github.com/sibiraj-s) + +> The MIT License (MIT) +> +> Copyright (c) 2016 Thomas Watson Steen +> +> Permission is hereby granted, free of charge, to any person obtaining a copy +> of this software and associated documentation files (the "Software"), to deal +> in the Software without restriction, including without limitation the rights +> to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +> copies of the Software, and to permit persons to whom the Software is +> furnished to do so, subject to the following conditions: +> +> The above copyright notice and this permission notice shall be included in all +> copies or substantial portions of the Software. +> +> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +> FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +> AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +> LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +> OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +> SOFTWARE. + +---------------------------------------- + +## collapse-white-space@v1.0.6 + +> Replace multiple white-space characters with a single space + +License: MIT +Author: Titus Wormer (https://wooorm.com) +Contributors: + - Titus Wormer (https://wooorm.com) + +> (The MIT License) +> +> Copyright (c) 2015 Titus Wormer +> +> Permission is hereby granted, free of charge, to any person obtaining +> a copy of this software and associated documentation files (the +> 'Software'), to deal in the Software without restriction, including +> without limitation the rights to use, copy, modify, merge, publish, +> distribute, sublicense, and/or sell copies of the Software, and to +> permit persons to whom the Software is furnished to do so, subject to +> the following conditions: +> +> The above copyright notice and this permission notice shall be +> included in all copies or substantial portions of the Software. +> +> THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, +> EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +> MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. +> IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY +> CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, +> TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE +> SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +---------------------------------------- + +## common-path-prefix@v3.0.0 + +> Computes the longest prefix string that is common to each path, excluding the base component + +License: ISC +Homepage: +Repository: +Author: Mark Wubben (https://novemberborn.net/) + +> ISC License (ISC) +> Copyright (c) 2016, Mark Wubben +> +> Permission to use, copy, modify, and/or distribute this software for any purpose +> with or without fee is hereby granted, provided that the above copyright notice +> and this permission notice appear in all copies. +> +> THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH +> REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND +> FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, +> INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS +> OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER +> TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF +> THIS SOFTWARE. + +---------------------------------------- + +## dashify@v2.0.0 + +> Convert a camelcase or space-separated string to a dash-separated string. ~12 sloc, fast, supports diacritics. + +License: MIT +Homepage: +Author: Jon Schlinkert (https://github.com/jonschlinkert) +Contributors: + - Jeffrey Priebe (https://github.com/jeffreypriebe) + - Jon Schlinkert (http://twitter.com/jonschlinkert) + - Ondrej Brinkel (https://www.anzui.de) + +> The MIT License (MIT) +> +> Copyright (c) 2015-present, Jon Schlinkert. +> +> Permission is hereby granted, free of charge, to any person obtaining a copy +> of this software and associated documentation files (the "Software"), to deal +> in the Software without restriction, including without limitation the rights +> to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +> copies of the Software, and to permit persons to whom the Software is +> furnished to do so, subject to the following conditions: +> +> The above copyright notice and this permission notice shall be included in +> all copies or substantial portions of the Software. +> +> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +> FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +> AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +> LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +> OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +> THE SOFTWARE. + +---------------------------------------- + +## diff@v7.0.0 + +> A JavaScript text diff implementation. + +License: BSD-3-Clause +Repository: + +> BSD 3-Clause License +> +> Copyright (c) 2009-2015, Kevin Decker +> All rights reserved. +> +> Redistribution and use in source and binary forms, with or without +> modification, are permitted provided that the following conditions are met: +> +> 1. Redistributions of source code must retain the above copyright notice, this +> list of conditions and the following disclaimer. +> +> 2. Redistributions in binary form must reproduce the above copyright notice, +> this list of conditions and the following disclaimer in the documentation +> and/or other materials provided with the distribution. +> +> 3. Neither the name of the copyright holder nor the names of its +> contributors may be used to endorse or promote products derived from +> this software without specific prior written permission. +> +> THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +> AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +> IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +> DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE +> FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +> DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +> SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +> CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, +> OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +> OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +---------------------------------------- + +## editorconfig@v0.15.3 + +> EditorConfig File Locator and Interpreter for Node.js + +License: MIT +Repository: +Author: EditorConfig Team +Contributors: + - Hong Xu (topbug.net) + - Jed Mao (https://github.com/jedmao/) + - Trey Hunner (http://treyhunner.com) + +> Copyright © 2012 EditorConfig Team +> +> Permission is hereby granted, free of charge, to any person obtaining a copy +> of this software and associated documentation files (the “Software”), to deal +> in the Software without restriction, including without limitation the rights +> to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +> copies of the Software, and to permit persons to whom the Software is +> furnished to do so, subject to the following conditions: +> +> The above copyright notice and this permission notice shall be included in +> all copies or substantial portions of the Software. +> +> THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +> FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +> AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +> LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +> OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +> THE SOFTWARE. + +---------------------------------------- + +## emoji-regex@v10.4.0 + +> A regular expression to match all Emoji-only symbols as per the Unicode Standard. + +License: MIT +Homepage: +Repository: +Author: Mathias Bynens (https://mathiasbynens.be/) + +> Copyright Mathias Bynens +> +> Permission is hereby granted, free of charge, to any person obtaining +> a copy of this software and associated documentation files (the +> "Software"), to deal in the Software without restriction, including +> without limitation the rights to use, copy, modify, merge, publish, +> distribute, sublicense, and/or sell copies of the Software, and to +> permit persons to whom the Software is furnished to do so, subject to +> the following conditions: +> +> The above copyright notice and this permission notice shall be +> included in all copies or substantial portions of the Software. +> +> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +> EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +> MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +> NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE +> LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION +> OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +> WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +---------------------------------------- + +## escape-string-regexp@v5.0.0 + +> Escape RegExp special characters + +License: MIT +Author: Sindre Sorhus (https://sindresorhus.com) + +> MIT License +> +> Copyright (c) Sindre Sorhus (https://sindresorhus.com) +> +> Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: +> +> The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. +> +> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +---------------------------------------- + +## espree@v10.3.0 + +> An Esprima-compatible JavaScript parser built on Acorn + +License: BSD-2-Clause +Homepage: +Author: Nicholas C. Zakas + +> BSD 2-Clause License +> +> Copyright (c) Open JS Foundation +> All rights reserved. +> +> Redistribution and use in source and binary forms, with or without +> modification, are permitted provided that the following conditions are met: +> +> 1. Redistributions of source code must retain the above copyright notice, this +> list of conditions and the following disclaimer. +> +> 2. Redistributions in binary form must reproduce the above copyright notice, +> this list of conditions and the following disclaimer in the documentation +> and/or other materials provided with the distribution. +> +> THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +> AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +> IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +> DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE +> FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +> DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +> SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +> CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, +> OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +> OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +---------------------------------------- + +## extend@v3.0.2 + +> Port of jQuery.extend for node.js and the browser + +License: MIT +Repository: +Author: Stefan Thomas (http://www.justmoon.net) +Contributors: + - Jordan Harband (https://github.com/ljharb) + +> The MIT License (MIT) +> +> Copyright (c) 2014 Stefan Thomas +> +> Permission is hereby granted, free of charge, to any person obtaining +> a copy of this software and associated documentation files (the +> "Software"), to deal in the Software without restriction, including +> without limitation the rights to use, copy, modify, merge, publish, +> distribute, sublicense, and/or sell copies of the Software, and to +> permit persons to whom the Software is furnished to do so, subject to +> the following conditions: +> +> The above copyright notice and this permission notice shall be +> included in all copies or substantial portions of the Software. +> +> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +> EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +> MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +> NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE +> LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION +> OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +> WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +---------------------------------------- + +## fast-glob@v3.3.3 + +> It's a very fast and efficient glob library for Node.js + +License: MIT +Author: Denis Malinochkin (https://mrmlnc.com) + +> The MIT License (MIT) +> +> Copyright (c) Denis Malinochkin +> +> Permission is hereby granted, free of charge, to any person obtaining a copy +> of this software and associated documentation files (the "Software"), to deal +> in the Software without restriction, including without limitation the rights +> to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +> copies of the Software, and to permit persons to whom the Software is +> furnished to do so, subject to the following conditions: +> +> The above copyright notice and this permission notice shall be included in all +> copies or substantial portions of the Software. +> +> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +> FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +> AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +> LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +> OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +> SOFTWARE. + +---------------------------------------- + +## fast-json-stable-stringify@v2.1.0 + +> deterministic `JSON.stringify()` - a faster version of substack's json-stable-strigify without jsonify + +License: MIT +Homepage: +Repository: +Author: James Halliday (http://substack.net) + +> This software is released under the MIT license: +> +> Copyright (c) 2017 Evgeny Poberezkin +> Copyright (c) 2013 James Halliday +> +> Permission is hereby granted, free of charge, to any person obtaining a copy of +> this software and associated documentation files (the "Software"), to deal in +> the Software without restriction, including without limitation the rights to +> use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of +> the Software, and to permit persons to whom the Software is furnished to do so, +> subject to the following conditions: +> +> The above copyright notice and this permission notice shall be included in all +> copies or substantial portions of the Software. +> +> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS +> FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR +> COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER +> IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN +> CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +---------------------------------------- + +## fastq@v1.18.0 + +> Fast, in memory work queue + +License: ISC +Homepage: +Repository: +Author: Matteo Collina + +> Copyright (c) 2015-2020, Matteo Collina +> +> Permission to use, copy, modify, and/or distribute this software for any +> purpose with or without fee is hereby granted, provided that the above +> copyright notice and this permission notice appear in all copies. +> +> THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES +> WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF +> MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR +> ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES +> WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN +> ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF +> OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + +---------------------------------------- + +## file-entry-cache@v10.0.6 + +> A lightweight cache for file metadata, ideal for processes that work on a specific set of files and only need to reprocess files that have changed since the last run + +License: MIT +Repository: +Author: Jared Wray + +> MIT License & © Jared Wray +> +> Permission is hereby granted, free of charge, to any person obtaining a copy +> of this software and associated documentation files (the "Software"), to +> deal in the Software without restriction, including without limitation the +> rights to use, copy, modify, merge, publish, distribute, sublicense, and/or +> sell copies of the Software, and to permit persons to whom the Software is +> furnished to do so, subject to the following conditions: +> +> The above copyright notice and this permission notice shall be included in +> all copies or substantial portions of the Software. +> +> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +> FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +> AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +> LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +> FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +> DEALINGS IN THE SOFTWARE. + +---------------------------------------- + +## fill-range@v7.1.1 + +> Fill in a range of numbers or letters, optionally passing an increment or `step` to use, or create a regex-compatible range with `options.toRegex` + +License: MIT +Homepage: +Author: Jon Schlinkert (https://github.com/jonschlinkert) +Contributors: + - Edo Rivai (edo.rivai.nl) + - Jon Schlinkert (http://twitter.com/jonschlinkert) + - Paul Miller (paulmillr.com) + - Rouven Weßling (www.rouvenwessling.de) + - null (https://github.com/wtgtybhertgeghgtwtg) + +> The MIT License (MIT) +> +> Copyright (c) 2014-present, Jon Schlinkert. +> +> Permission is hereby granted, free of charge, to any person obtaining a copy +> of this software and associated documentation files (the "Software"), to deal +> in the Software without restriction, including without limitation the rights +> to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +> copies of the Software, and to permit persons to whom the Software is +> furnished to do so, subject to the following conditions: +> +> The above copyright notice and this permission notice shall be included in +> all copies or substantial portions of the Software. +> +> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +> FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +> AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +> LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +> OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +> THE SOFTWARE. + +---------------------------------------- + +## find-cache-dir@v5.0.0 + +> Finds the common standard cache directory + +License: MIT +Author: Sindre Sorhus (https://sindresorhus.com) + +> MIT License +> +> Copyright (c) Sindre Sorhus (https://sindresorhus.com) +> Copyright (c) James Talmage (https://github.com/jamestalmage) +> +> Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: +> +> The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. +> +> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +---------------------------------------- + +## find-up@v6.3.0 + +> Find a file or directory by walking up parent directories + +License: MIT +Author: Sindre Sorhus (https://sindresorhus.com) + +> MIT License +> +> Copyright (c) Sindre Sorhus (https://sindresorhus.com) +> +> Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: +> +> The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. +> +> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +---------------------------------------- + +## flat-cache@v6.1.6 + +> A simple key/value storage using files to persist the data + +License: MIT +Repository: +Author: Jared Wray + +> MIT License & © Jared Wray +> +> Permission is hereby granted, free of charge, to any person obtaining a copy +> of this software and associated documentation files (the "Software"), to +> deal in the Software without restriction, including without limitation the +> rights to use, copy, modify, merge, publish, distribute, sublicense, and/or +> sell copies of the Software, and to permit persons to whom the Software is +> furnished to do so, subject to the following conditions: +> +> The above copyright notice and this permission notice shall be included in +> all copies or substantial portions of the Software. +> +> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +> FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +> AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +> LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +> FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +> DEALINGS IN THE SOFTWARE. + +---------------------------------------- + +## flatted@v3.3.2 + +> A super light and fast circular JSON parser. + +License: ISC +Homepage: +Repository: +Author: Andrea Giammarchi + +> ISC License +> +> Copyright (c) 2018-2020, Andrea Giammarchi, @WebReflection +> +> Permission to use, copy, modify, and/or distribute this software for any +> purpose with or without fee is hereby granted, provided that the above +> copyright notice and this permission notice appear in all copies. +> +> THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH +> REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY +> AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, +> INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM +> LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE +> OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR +> PERFORMANCE OF THIS SOFTWARE. + +---------------------------------------- + +## flatten@v1.0.3 + +> Flatten arbitrarily nested arrays into a non-nested list of non-array items. Maintained for legacy compatibility. + +License: MIT +Homepage: +Repository: +Author: Joshua Holbrook (http://jesusabdullah.net) +Contributors: + - M.K. (https://github.com/mk-pmb) + +> The MIT License (MIT) +> +> Copyright (c) 2016 Joshua Holbrook +> +> Permission is hereby granted, free of charge, to any person obtaining a copy +> of this software and associated documentation files (the "Software"), to deal +> in the Software without restriction, including without limitation the rights +> to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +> copies of the Software, and to permit persons to whom the Software is +> furnished to do so, subject to the following conditions: +> +> The above copyright notice and this permission notice shall be included in +> all copies or substantial portions of the Software. +> +> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +> FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +> AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +> LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +> OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +> THE SOFTWARE. + +---------------------------------------- + +## flow-parser@v0.259.1 + +> JavaScript parser written in OCaml. Produces ESTree AST + +License: MIT +Homepage: +Repository: +Author: Flow Team + +---------------------------------------- + +## get-east-asian-width@v1.3.0 + +> Determine the East Asian Width of a Unicode character + +License: MIT +Author: Sindre Sorhus (https://sindresorhus.com) + +> MIT License +> +> Copyright (c) Sindre Sorhus (https://sindresorhus.com) +> +> Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: +> +> The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. +> +> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +---------------------------------------- + +## get-stdin@v9.0.0 + +> Get stdin as a string or buffer + +License: MIT +Author: Sindre Sorhus (https://sindresorhus.com) + +> MIT License +> +> Copyright (c) Sindre Sorhus (https://sindresorhus.com) +> +> Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: +> +> The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. +> +> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +---------------------------------------- + +## glob-parent@v5.1.2 + +> Extract the non-magic parent path from a glob string. + +License: ISC +Author: Gulp Team (https://gulpjs.com/) +Contributors: + - Elan Shanker (https://github.com/es128) + - Blaine Bublitz + +> The ISC License +> +> Copyright (c) 2015, 2019 Elan Shanker +> +> Permission to use, copy, modify, and/or distribute this software for any +> purpose with or without fee is hereby granted, provided that the above +> copyright notice and this permission notice appear in all copies. +> +> THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES +> WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF +> MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR +> ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES +> WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN +> ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR +> IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + +---------------------------------------- + +## graphql@v16.10.0 + +> A Query Language and Runtime which can target any service. + +License: MIT +Homepage: +Repository: + +> MIT License +> +> Copyright (c) GraphQL Contributors +> +> Permission is hereby granted, free of charge, to any person obtaining a copy +> of this software and associated documentation files (the "Software"), to deal +> in the Software without restriction, including without limitation the rights +> to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +> copies of the Software, and to permit persons to whom the Software is +> furnished to do so, subject to the following conditions: +> +> The above copyright notice and this permission notice shall be included in all +> copies or substantial portions of the Software. +> +> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +> FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +> AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +> LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +> OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +> SOFTWARE. + +---------------------------------------- + +## hookified@v1.7.0 + +> Event and Middleware Hooks + +License: MIT +Homepage: +Repository: +Author: Jared Wray + +> MIT License & © Jared Wray +> +> Permission is hereby granted, free of charge, to any person obtaining a copy +> of this software and associated documentation files (the "Software"), to deal +> in the Software without restriction, including without limitation the rights +> to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +> copies of the Software, and to permit persons to whom the Software is +> furnished to do so, subject to the following conditions: +> +> The above copyright notice and this permission notice shall be included in all +> copies or substantial portions of the Software. +> +> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +> FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +> AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +> LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +> OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +> SOFTWARE. + +---------------------------------------- + +## ignore@v7.0.3 + +> Ignore is a manager and filter for .gitignore rules, the one used by eslint, gitbook and many others. + +License: MIT +Repository: +Author: kael + +> Copyright (c) 2013 Kael Zhang , contributors +> http://kael.me/ +> +> Permission is hereby granted, free of charge, to any person obtaining +> a copy of this software and associated documentation files (the +> "Software"), to deal in the Software without restriction, including +> without limitation the rights to use, copy, modify, merge, publish, +> distribute, sublicense, and/or sell copies of the Software, and to +> permit persons to whom the Software is furnished to do so, subject to +> the following conditions: +> +> The above copyright notice and this permission notice shall be +> included in all copies or substantial portions of the Software. +> +> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +> EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +> MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +> NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE +> LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION +> OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +> WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +---------------------------------------- + +## import-meta-resolve@v4.1.0 + +> Resolve things like Node.js — ponyfill for `import.meta.resolve` + +License: MIT +Author: Titus Wormer (https://wooorm.com) +Contributors: + - Titus Wormer (https://wooorm.com) + +> (The MIT License) +> +> Copyright (c) 2021 Titus Wormer +> +> Permission is hereby granted, free of charge, to any person obtaining +> a copy of this software and associated documentation files (the +> 'Software'), to deal in the Software without restriction, including +> without limitation the rights to use, copy, modify, merge, publish, +> distribute, sublicense, and/or sell copies of the Software, and to +> permit persons to whom the Software is furnished to do so, subject to +> the following conditions: +> +> The above copyright notice and this permission notice shall be +> included in all copies or substantial portions of the Software. +> +> THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, +> EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +> MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. +> IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY +> CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, +> TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE +> SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +> +> --- +> +> This is a derivative work based on: +> . +> Which is licensed: +> +> """ +> Copyright Node.js contributors. All rights reserved. +> +> Permission is hereby granted, free of charge, to any person obtaining a copy +> of this software and associated documentation files (the "Software"), to +> deal in the Software without restriction, including without limitation the +> rights to use, copy, modify, merge, publish, distribute, sublicense, and/or +> sell copies of the Software, and to permit persons to whom the Software is +> furnished to do so, subject to the following conditions: +> +> The above copyright notice and this permission notice shall be included in +> all copies or substantial portions of the Software. +> +> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +> FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +> AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +> LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +> FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS +> IN THE SOFTWARE. +> """ +> +> This license applies to parts of Node.js originating from the +> https://github.com/joyent/node repository: +> +> """ +> Copyright Joyent, Inc. and other Node contributors. All rights reserved. +> Permission is hereby granted, free of charge, to any person obtaining a copy +> of this software and associated documentation files (the "Software"), to +> deal in the Software without restriction, including without limitation the +> rights to use, copy, modify, merge, publish, distribute, sublicense, and/or +> sell copies of the Software, and to permit persons to whom the Software is +> furnished to do so, subject to the following conditions: +> +> The above copyright notice and this permission notice shall be included in +> all copies or substantial portions of the Software. +> +> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +> FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +> AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +> LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +> FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS +> IN THE SOFTWARE. +> """ + +---------------------------------------- + +## index-to-position@v0.1.2 + +> Convert a string index to its line and column position + +License: MIT +Author: Sindre Sorhus (https://sindresorhus.com) + +> MIT License +> +> Copyright (c) Sindre Sorhus (https://sindresorhus.com) +> +> Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: +> +> The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. +> +> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +---------------------------------------- + +## indexes-of@v1.0.1 + +> line String/Array#indexOf but return all the indexes in an array + +License: MIT +Homepage: +Repository: +Author: Dominic Tarr (dominictarr.com) + +> Copyright (c) 2013 Dominic Tarr +> +> Permission is hereby granted, free of charge, +> to any person obtaining a copy of this software and +> associated documentation files (the "Software"), to +> deal in the Software without restriction, including +> without limitation the rights to use, copy, modify, +> merge, publish, distribute, sublicense, and/or sell +> copies of the Software, and to permit persons to whom +> the Software is furnished to do so, +> subject to the following conditions: +> +> The above copyright notice and this permission notice +> shall be included in all copies or substantial portions of the Software. +> +> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +> EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES +> OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. +> IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR +> ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, +> TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE +> SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +---------------------------------------- + +## inherits@v2.0.4 + +> Browser-friendly inheritance fully compatible with standard node.js inherits() + +License: ISC + +> The ISC License +> +> Copyright (c) Isaac Z. Schlueter +> +> Permission to use, copy, modify, and/or distribute this software for any +> purpose with or without fee is hereby granted, provided that the above +> copyright notice and this permission notice appear in all copies. +> +> THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH +> REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND +> FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, +> INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM +> LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR +> OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR +> PERFORMANCE OF THIS SOFTWARE. + +---------------------------------------- + +## is-alphabetical@v1.0.4 + +> Check if a character is alphabetical + +License: MIT +Author: Titus Wormer (https://wooorm.com) +Contributors: + - Titus Wormer (https://wooorm.com) + +> (The MIT License) +> +> Copyright (c) 2016 Titus Wormer +> +> Permission is hereby granted, free of charge, to any person obtaining +> a copy of this software and associated documentation files (the +> 'Software'), to deal in the Software without restriction, including +> without limitation the rights to use, copy, modify, merge, publish, +> distribute, sublicense, and/or sell copies of the Software, and to +> permit persons to whom the Software is furnished to do so, subject to +> the following conditions: +> +> The above copyright notice and this permission notice shall be +> included in all copies or substantial portions of the Software. +> +> THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, +> EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +> MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. +> IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY +> CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, +> TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE +> SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +---------------------------------------- + +## is-alphanumerical@v1.0.4 + +> Check if a character is alphanumerical + +License: MIT +Author: Titus Wormer (https://wooorm.com) +Contributors: + - Titus Wormer (https://wooorm.com) + +> (The MIT License) +> +> Copyright (c) 2016 Titus Wormer +> +> Permission is hereby granted, free of charge, to any person obtaining +> a copy of this software and associated documentation files (the +> 'Software'), to deal in the Software without restriction, including +> without limitation the rights to use, copy, modify, merge, publish, +> distribute, sublicense, and/or sell copies of the Software, and to +> permit persons to whom the Software is furnished to do so, subject to +> the following conditions: +> +> The above copyright notice and this permission notice shall be +> included in all copies or substantial portions of the Software. +> +> THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, +> EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +> MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. +> IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY +> CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, +> TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE +> SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +---------------------------------------- + +## is-buffer@v2.0.5 + +> Determine if an object is a Buffer + +License: MIT +Repository: +Author: Feross Aboukhadijeh (https://feross.org) + +> The MIT License (MIT) +> +> Copyright (c) Feross Aboukhadijeh +> +> Permission is hereby granted, free of charge, to any person obtaining a copy +> of this software and associated documentation files (the "Software"), to deal +> in the Software without restriction, including without limitation the rights +> to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +> copies of the Software, and to permit persons to whom the Software is +> furnished to do so, subject to the following conditions: +> +> The above copyright notice and this permission notice shall be included in +> all copies or substantial portions of the Software. +> +> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +> FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +> AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +> LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +> OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +> THE SOFTWARE. + +---------------------------------------- + +## is-decimal@v1.0.4 + +> Check if a character is decimal + +License: MIT +Author: Titus Wormer (https://wooorm.com) +Contributors: + - Titus Wormer (https://wooorm.com) + +> (The MIT License) +> +> Copyright (c) 2016 Titus Wormer +> +> Permission is hereby granted, free of charge, to any person obtaining +> a copy of this software and associated documentation files (the +> 'Software'), to deal in the Software without restriction, including +> without limitation the rights to use, copy, modify, merge, publish, +> distribute, sublicense, and/or sell copies of the Software, and to +> permit persons to whom the Software is furnished to do so, subject to +> the following conditions: +> +> The above copyright notice and this permission notice shall be +> included in all copies or substantial portions of the Software. +> +> THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, +> EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +> MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. +> IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY +> CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, +> TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE +> SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +---------------------------------------- + +## is-extglob@v2.1.1 + +> Returns true if a string has an extglob. + +License: MIT +Homepage: +Author: Jon Schlinkert (https://github.com/jonschlinkert) + +> The MIT License (MIT) +> +> Copyright (c) 2014-2016, Jon Schlinkert +> +> Permission is hereby granted, free of charge, to any person obtaining a copy +> of this software and associated documentation files (the "Software"), to deal +> in the Software without restriction, including without limitation the rights +> to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +> copies of the Software, and to permit persons to whom the Software is +> furnished to do so, subject to the following conditions: +> +> The above copyright notice and this permission notice shall be included in +> all copies or substantial portions of the Software. +> +> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +> FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +> AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +> LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +> OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +> THE SOFTWARE. + +---------------------------------------- + +## is-glob@v4.0.3 + +> Returns `true` if the given string looks like a glob pattern or an extglob pattern. This makes it easy to create code that only uses external modules like node-glob when necessary, resulting in much faster code execution and initialization time, and a better user experience. + +License: MIT +Homepage: +Author: Jon Schlinkert (https://github.com/jonschlinkert) +Contributors: + - Brian Woodward (https://twitter.com/doowb) + - Daniel Perez (https://tuvistavie.com) + - Jon Schlinkert (http://twitter.com/jonschlinkert) + +> The MIT License (MIT) +> +> Copyright (c) 2014-2017, Jon Schlinkert. +> +> Permission is hereby granted, free of charge, to any person obtaining a copy +> of this software and associated documentation files (the "Software"), to deal +> in the Software without restriction, including without limitation the rights +> to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +> copies of the Software, and to permit persons to whom the Software is +> furnished to do so, subject to the following conditions: +> +> The above copyright notice and this permission notice shall be included in +> all copies or substantial portions of the Software. +> +> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +> FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +> AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +> LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +> OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +> THE SOFTWARE. + +---------------------------------------- + +## is-hexadecimal@v1.0.4 + +> Check if a character is hexadecimal + +License: MIT +Author: Titus Wormer (https://wooorm.com) +Contributors: + - Titus Wormer (https://wooorm.com) + +> (The MIT License) +> +> Copyright (c) 2016 Titus Wormer +> +> Permission is hereby granted, free of charge, to any person obtaining +> a copy of this software and associated documentation files (the +> 'Software'), to deal in the Software without restriction, including +> without limitation the rights to use, copy, modify, merge, publish, +> distribute, sublicense, and/or sell copies of the Software, and to +> permit persons to whom the Software is furnished to do so, subject to +> the following conditions: +> +> The above copyright notice and this permission notice shall be +> included in all copies or substantial portions of the Software. +> +> THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, +> EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +> MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. +> IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY +> CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, +> TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE +> SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +---------------------------------------- + +## is-number@v7.0.0 + +> Returns true if a number or string value is a finite number. Useful for regex matches, parsing, user input, etc. + +License: MIT +Homepage: +Author: Jon Schlinkert (https://github.com/jonschlinkert) +Contributors: + - Jon Schlinkert (http://twitter.com/jonschlinkert) + - Olsten Larck (https://i.am.charlike.online) + - Rouven Weßling (www.rouvenwessling.de) + +> The MIT License (MIT) +> +> Copyright (c) 2014-present, Jon Schlinkert. +> +> Permission is hereby granted, free of charge, to any person obtaining a copy +> of this software and associated documentation files (the "Software"), to deal +> in the Software without restriction, including without limitation the rights +> to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +> copies of the Software, and to permit persons to whom the Software is +> furnished to do so, subject to the following conditions: +> +> The above copyright notice and this permission notice shall be included in +> all copies or substantial portions of the Software. +> +> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +> FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +> AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +> LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +> OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +> THE SOFTWARE. + +---------------------------------------- + +## is-plain-obj@v2.1.0 + +> Check if a value is a plain object + +License: MIT +Author: Sindre Sorhus (sindresorhus.com) + +> MIT License +> +> Copyright (c) Sindre Sorhus (sindresorhus.com) +> +> Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: +> +> The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. +> +> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +---------------------------------------- + +## is-whitespace-character@v1.0.4 + +> Check if a character is a whitespace character + +License: MIT +Author: Titus Wormer (https://wooorm.com) +Contributors: + - Titus Wormer (https://wooorm.com) + +> (The MIT License) +> +> Copyright (c) 2016 Titus Wormer +> +> Permission is hereby granted, free of charge, to any person obtaining +> a copy of this software and associated documentation files (the +> 'Software'), to deal in the Software without restriction, including +> without limitation the rights to use, copy, modify, merge, publish, +> distribute, sublicense, and/or sell copies of the Software, and to +> permit persons to whom the Software is furnished to do so, subject to +> the following conditions: +> +> The above copyright notice and this permission notice shall be +> included in all copies or substantial portions of the Software. +> +> THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, +> EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +> MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. +> IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY +> CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, +> TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE +> SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +---------------------------------------- + +## is-word-character@v1.0.4 + +> Check if a character is a word character + +License: MIT +Author: Titus Wormer (https://wooorm.com) +Contributors: + - Titus Wormer (https://wooorm.com) + +> (The MIT License) +> +> Copyright (c) 2016 Titus Wormer +> +> Permission is hereby granted, free of charge, to any person obtaining +> a copy of this software and associated documentation files (the +> 'Software'), to deal in the Software without restriction, including +> without limitation the rights to use, copy, modify, merge, publish, +> distribute, sublicense, and/or sell copies of the Software, and to +> permit persons to whom the Software is furnished to do so, subject to +> the following conditions: +> +> The above copyright notice and this permission notice shall be +> included in all copies or substantial portions of the Software. +> +> THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, +> EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +> MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. +> IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY +> CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, +> TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE +> SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +---------------------------------------- + +## iterate-directory-up@v1.1.1 + +> Iterate directory up. + +License: MIT +Homepage: +Author: fisker Cheung (https://www.fiskercheung.com/) + +> MIT License +> +> Copyright (c) fisker Cheung (https://www.fiskercheung.com/) +> +> Permission is hereby granted, free of charge, to any person obtaining a copy +> of this software and associated documentation files (the "Software"), to deal +> in the Software without restriction, including without limitation the rights +> to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +> copies of the Software, and to permit persons to whom the Software is +> furnished to do so, subject to the following conditions: +> +> The above copyright notice and this permission notice shall be included in all +> copies or substantial portions of the Software. +> +> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +> FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +> AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +> LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +> OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +> SOFTWARE. + +---------------------------------------- + +## jest-docblock@v30.0.0-alpha.7 + +License: MIT +Repository: + +> MIT License +> +> Copyright (c) Meta Platforms, Inc. and affiliates. +> Copyright Contributors to the Jest project. +> +> Permission is hereby granted, free of charge, to any person obtaining a copy +> of this software and associated documentation files (the "Software"), to deal +> in the Software without restriction, including without limitation the rights +> to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +> copies of the Software, and to permit persons to whom the Software is +> furnished to do so, subject to the following conditions: +> +> The above copyright notice and this permission notice shall be included in all +> copies or substantial portions of the Software. +> +> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +> FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +> AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +> LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +> OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +> SOFTWARE. + +---------------------------------------- + +## js-tokens@v4.0.0 + +> A regex that tokenizes JavaScript. + +License: MIT +Author: Simon Lydell + +> The MIT License (MIT) +> +> Copyright (c) 2014, 2015, 2016, 2017, 2018 Simon Lydell +> +> Permission is hereby granted, free of charge, to any person obtaining a copy +> of this software and associated documentation files (the "Software"), to deal +> in the Software without restriction, including without limitation the rights +> to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +> copies of the Software, and to permit persons to whom the Software is +> furnished to do so, subject to the following conditions: +> +> The above copyright notice and this permission notice shall be included in +> all copies or substantial portions of the Software. +> +> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +> FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +> AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +> LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +> OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +> THE SOFTWARE. + +---------------------------------------- + +## js-yaml@v4.1.0 + +> YAML 1.2 parser and serializer + +License: MIT +Author: Vladimir Zapparov +Contributors: + - Aleksey V Zapparov (http://www.ixti.net/) + - Vitaly Puzrin (https://github.com/puzrin) + - Martin Grenfell (http://got-ravings.blogspot.com) + +> (The MIT License) +> +> Copyright (C) 2011-2015 by Vitaly Puzrin +> +> Permission is hereby granted, free of charge, to any person obtaining a copy +> of this software and associated documentation files (the "Software"), to deal +> in the Software without restriction, including without limitation the rights +> to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +> copies of the Software, and to permit persons to whom the Software is +> furnished to do so, subject to the following conditions: +> +> The above copyright notice and this permission notice shall be included in +> all copies or substantial portions of the Software. +> +> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +> FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +> AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +> LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +> OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +> THE SOFTWARE. + +---------------------------------------- + +## json5@v2.2.3 + +> JSON for Humans + +License: MIT +Homepage: +Repository: +Author: Aseem Kishore +Contributors: + - Max Nanasy + - Andrew Eisenberg + - Jordan Tucker + +> MIT License +> +> Copyright (c) 2012-2018 Aseem Kishore, and [others]. +> +> Permission is hereby granted, free of charge, to any person obtaining a copy +> of this software and associated documentation files (the "Software"), to deal +> in the Software without restriction, including without limitation the rights +> to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +> copies of the Software, and to permit persons to whom the Software is +> furnished to do so, subject to the following conditions: +> +> The above copyright notice and this permission notice shall be included in all +> copies or substantial portions of the Software. +> +> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +> FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +> AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +> LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +> OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +> SOFTWARE. +> +> [others]: https://github.com/json5/json5/contributors + +---------------------------------------- + +## keyv@v5.2.3 + +> Simple key-value storage with support for multiple backends + +License: MIT +Homepage: +Repository: +Author: Jared Wray (http://jaredwray.com) + +> MIT License +> +> Copyright (c) 2017-2021 Luke Childs +> Copyright (c) 2021-2022 Jared Wray +> +> Permission is hereby granted, free of charge, to any person obtaining a copy +> of this software and associated documentation files (the "Software"), to deal +> in the Software without restriction, including without limitation the rights +> to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +> copies of the Software, and to permit persons to whom the Software is +> furnished to do so, subject to the following conditions: +> +> The above copyright notice and this permission notice shall be included in all +> copies or substantial portions of the Software. +> +> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +> FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +> AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +> LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +> OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +> SOFTWARE. + +---------------------------------------- + +## leven@v4.0.0 + +> Measure the difference between two strings using the Levenshtein distance algorithm + +License: MIT +Author: Sindre Sorhus (https://sindresorhus.com) + +> MIT License +> +> Copyright (c) Sindre Sorhus (https://sindresorhus.com) +> +> Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: +> +> The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. +> +> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +---------------------------------------- + +## lines-and-columns@v2.0.4 + +> Maps lines and columns to character offsets and back. + +License: MIT +Homepage: +Repository: +Author: Brian Donovan + +> The MIT License (MIT) +> +> Copyright (c) 2015 Brian Donovan +> +> Permission is hereby granted, free of charge, to any person obtaining a copy +> of this software and associated documentation files (the "Software"), to deal +> in the Software without restriction, including without limitation the rights +> to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +> copies of the Software, and to permit persons to whom the Software is +> furnished to do so, subject to the following conditions: +> +> The above copyright notice and this permission notice shall be included in +> all copies or substantial portions of the Software. +> +> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +> FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +> AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +> LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +> OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +> THE SOFTWARE. + +---------------------------------------- + +## locate-path@v7.2.0 + +> Get the first path that exists on disk of multiple paths + +License: MIT +Author: Sindre Sorhus (https://sindresorhus.com) + +> MIT License +> +> Copyright (c) Sindre Sorhus (https://sindresorhus.com) +> +> Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: +> +> The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. +> +> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +---------------------------------------- + +## lru-cache@v4.1.5 + +> A cache object that deletes the least-recently-used items. + +License: ISC +Author: Isaac Z. Schlueter + +> The ISC License +> +> Copyright (c) Isaac Z. Schlueter and Contributors +> +> Permission to use, copy, modify, and/or distribute this software for any +> purpose with or without fee is hereby granted, provided that the above +> copyright notice and this permission notice appear in all copies. +> +> THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES +> WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF +> MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR +> ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES +> WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN +> ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR +> IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + +---------------------------------------- + +## markdown-escapes@v1.0.4 + +> List of escapable characters in markdown + +License: MIT +Author: Titus Wormer (https://wooorm.com) +Contributors: + - Titus Wormer (https://wooorm.com) + +> (The MIT License) +> +> Copyright (c) 2016 Titus Wormer +> +> Permission is hereby granted, free of charge, to any person obtaining +> a copy of this software and associated documentation files (the +> 'Software'), to deal in the Software without restriction, including +> without limitation the rights to use, copy, modify, merge, publish, +> distribute, sublicense, and/or sell copies of the Software, and to +> permit persons to whom the Software is furnished to do so, subject to +> the following conditions: +> +> The above copyright notice and this permission notice shall be +> included in all copies or substantial portions of the Software. +> +> THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, +> EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +> MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. +> IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY +> CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, +> TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE +> SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +---------------------------------------- + +## merge2@v1.4.1 + +> Merge multiple streams into one stream in sequence or parallel. + +License: MIT +Homepage: +Repository: + +> The MIT License (MIT) +> +> Copyright (c) 2014-2020 Teambition +> +> Permission is hereby granted, free of charge, to any person obtaining a copy +> of this software and associated documentation files (the "Software"), to deal +> in the Software without restriction, including without limitation the rights +> to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +> copies of the Software, and to permit persons to whom the Software is +> furnished to do so, subject to the following conditions: +> +> The above copyright notice and this permission notice shall be included in all +> copies or substantial portions of the Software. +> +> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +> FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +> AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +> LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +> OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +> SOFTWARE. + +---------------------------------------- + +## meriyah@v6.0.5 + +> A 100% compliant, self-hosted javascript parser with high focus on both performance and stability + +License: ISC +Homepage: +Repository: +Author: Kenny F. (https://github.com/KFlash) +Contributors: + - Chunpeng Huo (https://github.com/3cp) + +> ISC License +> +> Copyright (c) 2019 and later, KFlash and others. +> +> Permission to use, copy, modify, and/or distribute this software for any purpose with or without fee is hereby granted, provided that the above copyright notice and this permission notice appear in all copies. +> +> THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + +---------------------------------------- + +## micromatch@v4.0.8 + +> Glob matching for javascript/node.js. A replacement and faster alternative to minimatch and multimatch. + +License: MIT +Homepage: +Author: Jon Schlinkert (https://github.com/jonschlinkert) +Contributors: + - null (https://github.com/DianeLooney) + - Amila Welihinda (amilajack.com) + - Bogdan Chadkin (https://github.com/TrySound) + - Brian Woodward (https://twitter.com/doowb) + - Devon Govett (http://badassjs.com) + - Elan Shanker (https://github.com/es128) + - Fabrício Matté (https://ultcombo.js.org) + - Jon Schlinkert (http://twitter.com/jonschlinkert) + - Martin Kolárik (https://kolarik.sk) + - Olsten Larck (https://i.am.charlike.online) + - Paul Miller (paulmillr.com) + - Tom Byrer (https://github.com/tomByrer) + - Tyler Akins (http://rumkin.com) + - Peter Bright (https://github.com/drpizza) + - Kuba Juszczyk (https://github.com/ku8ar) + +> The MIT License (MIT) +> +> Copyright (c) 2014-present, Jon Schlinkert. +> +> Permission is hereby granted, free of charge, to any person obtaining a copy +> of this software and associated documentation files (the "Software"), to deal +> in the Software without restriction, including without limitation the rights +> to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +> copies of the Software, and to permit persons to whom the Software is +> furnished to do so, subject to the following conditions: +> +> The above copyright notice and this permission notice shall be included in +> all copies or substantial portions of the Software. +> +> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +> FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +> AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +> LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +> OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +> THE SOFTWARE. + +---------------------------------------- + +## minimist@v1.2.8 + +> parse argument options + +License: MIT +Homepage: +Repository: +Author: James Halliday (http://substack.net) + +> This software is released under the MIT license: +> +> Permission is hereby granted, free of charge, to any person obtaining a copy of +> this software and associated documentation files (the "Software"), to deal in +> the Software without restriction, including without limitation the rights to +> use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of +> the Software, and to permit persons to whom the Software is furnished to do so, +> subject to the following conditions: +> +> The above copyright notice and this permission notice shall be included in all +> copies or substantial portions of the Software. +> +> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS +> FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR +> COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER +> IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN +> CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +---------------------------------------- + +## n-readlines@v1.0.1 + +> Read file line by line without buffering the whole file in memory. + +License: MIT +Repository: +Author: Yoan Arnaudov + +> The MIT License (MIT) +> +> Copyright (c) 2013 Liucw +> +> Permission is hereby granted, free of charge, to any person obtaining a copy of +> this software and associated documentation files (the "Software"), to deal in +> the Software without restriction, including without limitation the rights to +> use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of +> the Software, and to permit persons to whom the Software is furnished to do so, +> subject to the following conditions: +> +> The above copyright notice and this permission notice shall be included in all +> copies or substantial portions of the Software. +> +> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS +> FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR +> COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER +> IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN +> CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +---------------------------------------- + +## nanoid@v3.3.8 + +> A tiny (116 bytes), secure URL-friendly unique string ID generator + +License: MIT +Author: Andrey Sitnik + +> The MIT License (MIT) +> +> Copyright 2017 Andrey Sitnik +> +> Permission is hereby granted, free of charge, to any person obtaining a copy of +> this software and associated documentation files (the "Software"), to deal in +> the Software without restriction, including without limitation the rights to +> use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of +> the Software, and to permit persons to whom the Software is furnished to do so, +> subject to the following conditions: +> +> The above copyright notice and this permission notice shall be included in all +> copies or substantial portions of the Software. +> +> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS +> FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR +> COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER +> IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN +> CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +---------------------------------------- + +## p-limit@v4.0.0 + +> Run multiple promise-returning & async functions with limited concurrency + +License: MIT +Author: Sindre Sorhus (https://sindresorhus.com) + +> MIT License +> +> Copyright (c) Sindre Sorhus (https://sindresorhus.com) +> +> Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: +> +> The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. +> +> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +---------------------------------------- + +## p-locate@v6.0.0 + +> Get the first fulfilled promise that satisfies the provided testing function + +License: MIT +Author: Sindre Sorhus (https://sindresorhus.com) + +> MIT License +> +> Copyright (c) Sindre Sorhus (https://sindresorhus.com) +> +> Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: +> +> The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. +> +> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +---------------------------------------- + +## parse-entities@v2.0.0 + +> Parse HTML character references: fast, spec-compliant, positional information + +License: MIT +Author: Titus Wormer (https://wooorm.com) +Contributors: + - Titus Wormer (https://wooorm.com) + +> (The MIT License) +> +> Copyright (c) 2015 Titus Wormer +> +> Permission is hereby granted, free of charge, to any person obtaining +> a copy of this software and associated documentation files (the +> 'Software'), to deal in the Software without restriction, including +> without limitation the rights to use, copy, modify, merge, publish, +> distribute, sublicense, and/or sell copies of the Software, and to +> permit persons to whom the Software is furnished to do so, subject to +> the following conditions: +> +> The above copyright notice and this permission notice shall be +> included in all copies or substantial portions of the Software. +> +> THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, +> EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +> MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. +> IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY +> CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, +> TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE +> SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +---------------------------------------- + +## parse-json@v8.1.0 + +> Parse JSON with more helpful errors + +License: MIT +Author: Sindre Sorhus (https://sindresorhus.com) + +> MIT License +> +> Copyright (c) Sindre Sorhus (https://sindresorhus.com) +> +> Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: +> +> The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. +> +> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +---------------------------------------- + +## path-exists@v5.0.0 + +> Check if a path exists + +License: MIT +Author: Sindre Sorhus (https://sindresorhus.com) + +> MIT License +> +> Copyright (c) Sindre Sorhus (https://sindresorhus.com) +> +> Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: +> +> The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. +> +> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +---------------------------------------- + +## picocolors@v1.1.1 + +> The tiniest and the fastest library for terminal output formatting with ANSI colors + +License: ISC +Author: Alexey Raspopov + +> ISC License +> +> Copyright (c) 2021-2024 Oleksii Raspopov, Kostiantyn Denysov, Anton Verinov +> +> Permission to use, copy, modify, and/or distribute this software for any +> purpose with or without fee is hereby granted, provided that the above +> copyright notice and this permission notice appear in all copies. +> +> THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES +> WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF +> MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR +> ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES +> WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN +> ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF +> OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + +---------------------------------------- + +## picomatch@v2.3.1 + +> Blazing fast and accurate glob matcher written in JavaScript, with no dependencies and full support for standard and extended Bash glob features, including braces, extglobs, POSIX brackets, and regular expressions. + +License: MIT +Homepage: +Author: Jon Schlinkert (https://github.com/jonschlinkert) + +> The MIT License (MIT) +> +> Copyright (c) 2017-present, Jon Schlinkert. +> +> Permission is hereby granted, free of charge, to any person obtaining a copy +> of this software and associated documentation files (the "Software"), to deal +> in the Software without restriction, including without limitation the rights +> to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +> copies of the Software, and to permit persons to whom the Software is +> furnished to do so, subject to the following conditions: +> +> The above copyright notice and this permission notice shall be included in +> all copies or substantial portions of the Software. +> +> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +> FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +> AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +> LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +> OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +> THE SOFTWARE. + +---------------------------------------- + +## pkg-dir@v7.0.0 + +> Find the root directory of a Node.js project or npm package + +License: MIT +Author: Sindre Sorhus (https://sindresorhus.com) + +> MIT License +> +> Copyright (c) Sindre Sorhus (https://sindresorhus.com) +> +> Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: +> +> The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. +> +> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +---------------------------------------- + +## please-upgrade-node@v3.2.0 + +> Displays a beginner-friendly message telling your user to upgrade their version of Node + +License: MIT +Homepage: +Repository: +Author: typicode + +> MIT License +> +> Copyright (c) 2017 +> +> Permission is hereby granted, free of charge, to any person obtaining a copy +> of this software and associated documentation files (the "Software"), to deal +> in the Software without restriction, including without limitation the rights +> to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +> copies of the Software, and to permit persons to whom the Software is +> furnished to do so, subject to the following conditions: +> +> The above copyright notice and this permission notice shall be included in all +> copies or substantial portions of the Software. +> +> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +> FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +> AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +> LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +> OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +> SOFTWARE. + +---------------------------------------- + +## postcss@v8.5.3 + +> Tool for transforming styles with JS plugins + +License: MIT +Homepage: +Author: Andrey Sitnik + +> The MIT License (MIT) +> +> Copyright 2013 Andrey Sitnik +> +> Permission is hereby granted, free of charge, to any person obtaining a copy of +> this software and associated documentation files (the "Software"), to deal in +> the Software without restriction, including without limitation the rights to +> use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of +> the Software, and to permit persons to whom the Software is furnished to do so, +> subject to the following conditions: +> +> The above copyright notice and this permission notice shall be included in all +> copies or substantial portions of the Software. +> +> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS +> FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR +> COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER +> IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN +> CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +---------------------------------------- + +## postcss-less@v6.0.0 + +> LESS parser for PostCSS + +License: MIT +Homepage: +Author: Denys Kniazevych + +> The MIT License (MIT) +> +> Copyright (c) 2013 Andrey Sitnik +> Copyright (c) 2016 Denys Kniazevych +> Copyright (c) 2016 Pat Sissons +> Copyright (c) 2017 Andrew Powell +> +> Permission is hereby granted, free of charge, to any person obtaining a copy +> of this software and associated documentation files (the "Software"), to deal +> in the Software without restriction, including without limitation the rights +> to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +> copies of the Software, and to permit persons to whom the Software is +> furnished to do so, subject to the following conditions: +> +> The above copyright notice and this permission notice shall be included in all +> copies or substantial portions of the Software. +> +> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +> FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +> AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +> LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +> OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +> SOFTWARE. + +---------------------------------------- + +## postcss-media-query-parser@v0.2.3 + +> A tool for parsing media query lists. + +License: MIT +Homepage: +Repository: +Author: dryoma + +---------------------------------------- + +## postcss-scss@v4.0.9 + +> SCSS parser for PostCSS + +License: MIT +Author: Andrey Sitnik + +> The MIT License (MIT) +> +> Copyright 2013 Andrey Sitnik +> +> Permission is hereby granted, free of charge, to any person obtaining a copy of +> this software and associated documentation files (the "Software"), to deal in +> the Software without restriction, including without limitation the rights to +> use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of +> the Software, and to permit persons to whom the Software is furnished to do so, +> subject to the following conditions: +> +> The above copyright notice and this permission notice shall be included in all +> copies or substantial portions of the Software. +> +> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS +> FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR +> COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER +> IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN +> CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +---------------------------------------- + +## postcss-selector-parser@v2.2.3 + +License: MIT +Homepage: +Author: Ben Briggs (http://beneb.info) + +> Copyright (c) Ben Briggs (http://beneb.info) +> +> Permission is hereby granted, free of charge, to any person +> obtaining a copy of this software and associated documentation +> files (the "Software"), to deal in the Software without +> restriction, including without limitation the rights to use, +> copy, modify, merge, publish, distribute, sublicense, and/or sell +> copies of the Software, and to permit persons to whom the +> Software is furnished to do so, subject to the following +> conditions: +> +> The above copyright notice and this permission notice shall be +> included in all copies or substantial portions of the Software. +> +> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +> EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES +> OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +> NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT +> HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, +> WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +> FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR +> OTHER DEALINGS IN THE SOFTWARE. + +---------------------------------------- + +## postcss-values-parser@v2.0.1 + +> A CSS property value parser for use with PostCSS + +License: MIT +Author: Andrew Powell (shellscape) (http://shellscape.org) + +> Copyright (c) Andrew Powell +> +> Permission is hereby granted, free of charge, to any person +> obtaining a copy of this software and associated documentation +> files (the "Software"), to deal in the Software without +> restriction, including without limitation the rights to use, +> copy, modify, merge, publish, distribute, sublicense, and/or sell +> copies of the Software, and to permit persons to whom the +> Software is furnished to do so, subject to the following +> conditions: +> +> The above copyright notice and this permission notice shall be +> included in all copies or substantial portions of the Software. +> +> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +> EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES +> OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +> NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT +> HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, +> WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +> FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR +> OTHER DEALINGS IN THE SOFTWARE. + +---------------------------------------- + +## pseudomap@v1.0.2 + +> A thing that is a lot like ES6 `Map`, but without iterators, for use in environments where `for..of` syntax and `Map` are not available. + +License: ISC +Homepage: +Repository: +Author: Isaac Z. Schlueter (http://blog.izs.me/) + +> The ISC License +> +> Copyright (c) Isaac Z. Schlueter and Contributors +> +> Permission to use, copy, modify, and/or distribute this software for any +> purpose with or without fee is hereby granted, provided that the above +> copyright notice and this permission notice appear in all copies. +> +> THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES +> WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF +> MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR +> ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES +> WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN +> ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR +> IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + +---------------------------------------- + +## queue-microtask@v1.2.3 + +> fast, tiny `queueMicrotask` shim for modern engines + +License: MIT +Homepage: +Repository: +Author: Feross Aboukhadijeh (https://feross.org) + +> The MIT License (MIT) +> +> Copyright (c) Feross Aboukhadijeh +> +> Permission is hereby granted, free of charge, to any person obtaining a copy of +> this software and associated documentation files (the "Software"), to deal in +> the Software without restriction, including without limitation the rights to +> use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of +> the Software, and to permit persons to whom the Software is furnished to do so, +> subject to the following conditions: +> +> The above copyright notice and this permission notice shall be included in all +> copies or substantial portions of the Software. +> +> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS +> FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR +> COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER +> IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN +> CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +---------------------------------------- + +## remark-footnotes@v2.0.0 + +> remark plugin to add support for pandoc footnotes + +License: MIT +Author: Titus Wormer (https://wooorm.com) +Contributors: + - Titus Wormer (https://wooorm.com) + +> (The MIT License) +> +> Copyright (c) 2020 Titus Wormer +> +> Permission is hereby granted, free of charge, to any person obtaining +> a copy of this software and associated documentation files (the +> 'Software'), to deal in the Software without restriction, including +> without limitation the rights to use, copy, modify, merge, publish, +> distribute, sublicense, and/or sell copies of the Software, and to +> permit persons to whom the Software is furnished to do so, subject to +> the following conditions: +> +> The above copyright notice and this permission notice shall be +> included in all copies or substantial portions of the Software. +> +> THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, +> EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +> MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. +> IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY +> CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, +> TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE +> SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +---------------------------------------- + +## remark-math@v3.0.1 + +> remark plugin to parse and stringify math + +License: MIT +Author: Junyoung Choi (https://rokt33r.github.io) +Contributors: + - Junyoung Choi (https://rokt33r.github.io) + - Titus Wormer (https://wooorm.com) + +---------------------------------------- + +## remark-parse@v8.0.3 + +> remark plugin to parse Markdown + +License: MIT +Homepage: +Author: Titus Wormer (https://wooorm.com) +Contributors: + - Titus Wormer (https://wooorm.com) + - Eugene Sharygin + - Junyoung Choi + - Elijah Hamovitz + - Ika + +---------------------------------------- + +## repeat-string@v1.6.1 + +> Repeat the given string n times. Fastest implementation for repeating a string. + +License: MIT +Homepage: +Author: Jon Schlinkert (http://github.com/jonschlinkert) +Contributors: + - Brian Woodward (https://github.com/doowb) + - Jon Schlinkert (http://twitter.com/jonschlinkert) + - Linus Unnebäck (http://linus.unnebäck.se) + - Thijs Busser (http://tbusser.net) + - Titus (wooorm.com) + +> The MIT License (MIT) +> +> Copyright (c) 2014-2016, Jon Schlinkert. +> +> Permission is hereby granted, free of charge, to any person obtaining a copy +> of this software and associated documentation files (the "Software"), to deal +> in the Software without restriction, including without limitation the rights +> to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +> copies of the Software, and to permit persons to whom the Software is +> furnished to do so, subject to the following conditions: +> +> The above copyright notice and this permission notice shall be included in +> all copies or substantial portions of the Software. +> +> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +> FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +> AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +> LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +> OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +> THE SOFTWARE. + +---------------------------------------- + +## reusify@v1.0.4 + +> Reuse objects and functions with style + +License: MIT +Homepage: +Repository: +Author: Matteo Collina + +> The MIT License (MIT) +> +> Copyright (c) 2015 Matteo Collina +> +> Permission is hereby granted, free of charge, to any person obtaining a copy +> of this software and associated documentation files (the "Software"), to deal +> in the Software without restriction, including without limitation the rights +> to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +> copies of the Software, and to permit persons to whom the Software is +> furnished to do so, subject to the following conditions: +> +> The above copyright notice and this permission notice shall be included in all +> copies or substantial portions of the Software. +> +> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +> FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +> AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +> LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +> OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +> SOFTWARE. + +---------------------------------------- + +## run-parallel@v1.2.0 + +> Run an array of functions in parallel + +License: MIT +Homepage: +Repository: +Author: Feross Aboukhadijeh (https://feross.org) + +> The MIT License (MIT) +> +> Copyright (c) Feross Aboukhadijeh +> +> Permission is hereby granted, free of charge, to any person obtaining a copy of +> this software and associated documentation files (the "Software"), to deal in +> the Software without restriction, including without limitation the rights to +> use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of +> the Software, and to permit persons to whom the Software is furnished to do so, +> subject to the following conditions: +> +> The above copyright notice and this permission notice shall be included in all +> copies or substantial portions of the Software. +> +> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS +> FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR +> COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER +> IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN +> CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +---------------------------------------- + +## sdbm@v2.0.0 + +> SDBM non-cryptographic hash function + +License: MIT +Author: Sindre Sorhus (https://sindresorhus.com) + +> MIT License +> +> Copyright (c) Sindre Sorhus (https://sindresorhus.com) +> +> Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: +> +> The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. +> +> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +---------------------------------------- + +## semver@v7.7.1 + +> The semantic version parser used by npm. + +License: ISC +Repository: +Author: GitHub Inc. + +> The ISC License +> +> Copyright (c) Isaac Z. Schlueter and Contributors +> +> Permission to use, copy, modify, and/or distribute this software for any +> purpose with or without fee is hereby granted, provided that the above +> copyright notice and this permission notice appear in all copies. +> +> THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES +> WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF +> MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR +> ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES +> WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN +> ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR +> IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + +---------------------------------------- + +## semver-compare@v1.0.0 + +> compare two semver version strings, returning -1, 0, or 1 + +License: MIT +Homepage: +Repository: +Author: James Halliday (http://substack.net) + +> This software is released under the MIT license: +> +> Permission is hereby granted, free of charge, to any person obtaining a copy of +> this software and associated documentation files (the "Software"), to deal in +> the Software without restriction, including without limitation the rights to +> use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of +> the Software, and to permit persons to whom the Software is furnished to do so, +> subject to the following conditions: +> +> The above copyright notice and this permission notice shall be included in all +> copies or substantial portions of the Software. +> +> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS +> FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR +> COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER +> IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN +> CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +---------------------------------------- + +## sigmund@v1.0.1 + +> Quick and dirty signatures for Objects. + +License: ISC +Repository: +Author: Isaac Z. Schlueter (http://blog.izs.me/) + +> The ISC License +> +> Copyright (c) Isaac Z. Schlueter and Contributors +> +> Permission to use, copy, modify, and/or distribute this software for any +> purpose with or without fee is hereby granted, provided that the above +> copyright notice and this permission notice appear in all copies. +> +> THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES +> WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF +> MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR +> ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES +> WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN +> ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR +> IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + +---------------------------------------- + +## simple-html-tokenizer@v0.5.11 + +> Simple HTML Tokenizer is a lightweight JavaScript library that can be used to tokenize the kind of HTML normally found in templates. + +License: MIT +Repository: + +> Copyright (c) 2014 Yehuda Katz and contributors +> +> Permission is hereby granted, free of charge, to any person obtaining a copy of +> this software and associated documentation files (the "Software"), to deal in +> the Software without restriction, including without limitation the rights to +> use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies +> of the Software, and to permit persons to whom the Software is furnished to do +> so, subject to the following conditions: +> +> The above copyright notice and this permission notice shall be included in all +> copies or substantial portions of the Software. +> +> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +> FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +> AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +> LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +> OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +> SOFTWARE. + +---------------------------------------- + +## smol-toml@v1.3.1 + +> A small, fast, and correct TOML parser/serializer + +License: BSD-3-Clause +Author: Cynthia + +> Copyright (c) Squirrel Chat et al., All rights reserved. +> +> Redistribution and use in source and binary forms, with or without +> modification, are permitted provided that the following conditions are met: +> +> 1. Redistributions of source code must retain the above copyright notice, this +> list of conditions and the following disclaimer. +> 2. Redistributions in binary form must reproduce the above copyright notice, +> this list of conditions and the following disclaimer in the +> documentation and/or other materials provided with the distribution. +> 3. Neither the name of the copyright holder nor the names of its contributors +> may be used to endorse or promote products derived from this software without +> specific prior written permission. +> +> THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND +> ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +> WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +> DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE +> FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +> DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +> SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +> CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, +> OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +> OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +---------------------------------------- + +## state-toggle@v1.0.3 + +> Enter/exit a state + +License: MIT +Author: Titus Wormer (https://wooorm.com) +Contributors: + - Titus Wormer (https://wooorm.com) + +> (The MIT License) +> +> Copyright (c) 2016 Titus Wormer +> +> Permission is hereby granted, free of charge, to any person obtaining +> a copy of this software and associated documentation files (the +> 'Software'), to deal in the Software without restriction, including +> without limitation the rights to use, copy, modify, merge, publish, +> distribute, sublicense, and/or sell copies of the Software, and to +> permit persons to whom the Software is furnished to do so, subject to +> the following conditions: +> +> The above copyright notice and this permission notice shall be +> included in all copies or substantial portions of the Software. +> +> THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, +> EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +> MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. +> IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY +> CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, +> TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE +> SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +---------------------------------------- + +## strip-ansi@v7.1.0 + +> Strip ANSI escape codes from a string + +License: MIT +Author: Sindre Sorhus (https://sindresorhus.com) + +> MIT License +> +> Copyright (c) Sindre Sorhus (https://sindresorhus.com) +> +> Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: +> +> The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. +> +> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +---------------------------------------- + +## to-fast-properties@v4.0.0 + +> Force V8 to use fast properties for an object + +License: MIT +Author: Sindre Sorhus (https:/sindresorhus.com) + +> MIT License +> +> Copyright (c) Petka Antonov +> Benjamin Gruenbaum +> John-David Dalton +> Sindre Sorhus +> +> Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: +> +> The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. +> +> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +---------------------------------------- + +## to-regex-range@v5.0.1 + +> Pass two numbers, get a regex-compatible source string for matching ranges. Validated against more than 2.78 million test assertions. + +License: MIT +Homepage: +Author: Jon Schlinkert (https://github.com/jonschlinkert) +Contributors: + - Jon Schlinkert (http://twitter.com/jonschlinkert) + - Rouven Weßling (www.rouvenwessling.de) + +> The MIT License (MIT) +> +> Copyright (c) 2015-present, Jon Schlinkert. +> +> Permission is hereby granted, free of charge, to any person obtaining a copy +> of this software and associated documentation files (the "Software"), to deal +> in the Software without restriction, including without limitation the rights +> to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +> copies of the Software, and to permit persons to whom the Software is +> furnished to do so, subject to the following conditions: +> +> The above copyright notice and this permission notice shall be included in +> all copies or substantial portions of the Software. +> +> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +> FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +> AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +> LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +> OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +> THE SOFTWARE. + +---------------------------------------- + +## trim@v1.0.1 + +> Trim string whitespace + +License: MIT +Repository: +Author: TJ Holowaychuk + +---------------------------------------- + +## trim-trailing-lines@v1.1.4 + +> Remove final line feeds from a string + +License: MIT +Author: Titus Wormer (https://wooorm.com) +Contributors: + - Titus Wormer (https://wooorm.com) + +> (The MIT License) +> +> Copyright (c) 2015 Titus Wormer +> +> Permission is hereby granted, free of charge, to any person obtaining +> a copy of this software and associated documentation files (the +> 'Software'), to deal in the Software without restriction, including +> without limitation the rights to use, copy, modify, merge, publish, +> distribute, sublicense, and/or sell copies of the Software, and to +> permit persons to whom the Software is furnished to do so, subject to +> the following conditions: +> +> The above copyright notice and this permission notice shall be +> included in all copies or substantial portions of the Software. +> +> THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, +> EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +> MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. +> IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY +> CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, +> TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE +> SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +---------------------------------------- + +## trough@v1.0.5 + +> Middleware: a channel used to convey a liquid + +License: MIT +Author: Titus Wormer (https://wooorm.com) +Contributors: + - Titus Wormer (https://wooorm.com) + +> (The MIT License) +> +> Copyright (c) 2016 Titus Wormer +> +> Permission is hereby granted, free of charge, to any person obtaining a copy +> of this software and associated documentation files (the "Software"), to deal +> in the Software without restriction, including without limitation the rights +> to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +> copies of the Software, and to permit persons to whom the Software is +> furnished to do so, subject to the following conditions: +> +> The above copyright notice and this permission notice shall be included in +> all copies or substantial portions of the Software. +> +> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +> FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +> AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +> LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +> OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +> THE SOFTWARE. + +---------------------------------------- + +## ts-api-utils@v2.0.1 + +> Utility functions for working with TypeScript's API. Successor to the wonderful tsutils. 🛠️️ + +License: MIT +Repository: +Author: JoshuaKGoldberg + +> # MIT License +> +> Permission is hereby granted, free of charge, to any person obtaining +> a copy of this software and associated documentation files (the +> 'Software'), to deal in the Software without restriction, including +> without limitation the rights to use, copy, modify, merge, publish, +> distribute, sublicense, and/or sell copies of the Software, and to +> permit persons to whom the Software is furnished to do so, subject to +> the following conditions: +> +> The above copyright notice and this permission notice shall be +> included in all copies or substantial portions of the Software. +> +> THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, +> EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +> MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. +> IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY +> CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, +> TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE +> SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +---------------------------------------- + +## typescript@v5.7.3 + +> TypeScript is a language for application scale JavaScript development + +License: Apache-2.0 +Homepage: +Repository: +Author: Microsoft Corp. + +> Apache License +> +> Version 2.0, January 2004 +> +> http://www.apache.org/licenses/ +> +> TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION +> +> 1. Definitions. +> +> "License" shall mean the terms and conditions for use, reproduction, and distribution as defined by Sections 1 through 9 of this document. +> +> "Licensor" shall mean the copyright owner or entity authorized by the copyright owner that is granting the License. +> +> "Legal Entity" shall mean the union of the acting entity and all other entities that control, are controlled by, or are under common control with that entity. For the purposes of this definition, "control" means (i) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the outstanding shares, or (iii) beneficial ownership of such entity. +> +> "You" (or "Your") shall mean an individual or Legal Entity exercising permissions granted by this License. +> +> "Source" form shall mean the preferred form for making modifications, including but not limited to software source code, documentation source, and configuration files. +> +> "Object" form shall mean any form resulting from mechanical transformation or translation of a Source form, including but not limited to compiled object code, generated documentation, and conversions to other media types. +> +> "Work" shall mean the work of authorship, whether in Source or Object form, made available under the License, as indicated by a copyright notice that is included in or attached to the work (an example is provided in the Appendix below). +> +> "Derivative Works" shall mean any work, whether in Source or Object form, that is based on (or derived from) the Work and for which the editorial revisions, annotations, elaborations, or other modifications represent, as a whole, an original work of authorship. For the purposes of this License, Derivative Works shall not include works that remain separable from, or merely link (or bind by name) to the interfaces of, the Work and Derivative Works thereof. +> +> "Contribution" shall mean any work of authorship, including the original version of the Work and any modifications or additions to that Work or Derivative Works thereof, that is intentionally submitted to Licensor for inclusion in the Work by the copyright owner or by an individual or Legal Entity authorized to submit on behalf of the copyright owner. For the purposes of this definition, "submitted" means any form of electronic, verbal, or written communication sent to the Licensor or its representatives, including but not limited to communication on electronic mailing lists, source code control systems, and issue tracking systems that are managed by, or on behalf of, the Licensor for the purpose of discussing and improving the Work, but excluding communication that is conspicuously marked or otherwise designated in writing by the copyright owner as "Not a Contribution." +> +> "Contributor" shall mean Licensor and any individual or Legal Entity on behalf of whom a Contribution has been received by Licensor and subsequently incorporated within the Work. +> +> 2. Grant of Copyright License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable copyright license to reproduce, prepare Derivative Works of, publicly display, publicly perform, sublicense, and distribute the Work and such Derivative Works in Source or Object form. +> +> 3. Grant of Patent License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable (except as stated in this section) patent license to make, have made, use, offer to sell, sell, import, and otherwise transfer the Work, where such license applies only to those patent claims licensable by such Contributor that are necessarily infringed by their Contribution(s) alone or by combination of their Contribution(s) with the Work to which such Contribution(s) was submitted. If You institute patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the Work or a Contribution incorporated within the Work constitutes direct or contributory patent infringement, then any patent licenses granted to You under this License for that Work shall terminate as of the date such litigation is filed. +> +> 4. Redistribution. You may reproduce and distribute copies of the Work or Derivative Works thereof in any medium, with or without modifications, and in Source or Object form, provided that You meet the following conditions: +> +> You must give any other recipients of the Work or Derivative Works a copy of this License; and +> +> You must cause any modified files to carry prominent notices stating that You changed the files; and +> +> You must retain, in the Source form of any Derivative Works that You distribute, all copyright, patent, trademark, and attribution notices from the Source form of the Work, excluding those notices that do not pertain to any part of the Derivative Works; and +> +> If the Work includes a "NOTICE" text file as part of its distribution, then any Derivative Works that You distribute must include a readable copy of the attribution notices contained within such NOTICE file, excluding those notices that do not pertain to any part of the Derivative Works, in at least one of the following places: within a NOTICE text file distributed as part of the Derivative Works; within the Source form or documentation, if provided along with the Derivative Works; or, within a display generated by the Derivative Works, if and wherever such third-party notices normally appear. The contents of the NOTICE file are for informational purposes only and do not modify the License. You may add Your own attribution notices within Derivative Works that You distribute, alongside or as an addendum to the NOTICE text from the Work, provided that such additional attribution notices cannot be construed as modifying the License. You may add Your own copyright statement to Your modifications and may provide additional or different license terms and conditions for use, reproduction, or distribution of Your modifications, or for any such Derivative Works as a whole, provided Your use, reproduction, and distribution of the Work otherwise complies with the conditions stated in this License. +> +> 5. Submission of Contributions. Unless You explicitly state otherwise, any Contribution intentionally submitted for inclusion in the Work by You to the Licensor shall be under the terms and conditions of this License, without any additional terms or conditions. Notwithstanding the above, nothing herein shall supersede or modify the terms of any separate license agreement you may have executed with Licensor regarding such Contributions. +> +> 6. Trademarks. This License does not grant permission to use the trade names, trademarks, service marks, or product names of the Licensor, except as required for reasonable and customary use in describing the origin of the Work and reproducing the content of the NOTICE file. +> +> 7. Disclaimer of Warranty. Unless required by applicable law or agreed to in writing, Licensor provides the Work (and each Contributor provides its Contributions) on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied, including, without limitation, any warranties or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are solely responsible for determining the appropriateness of using or redistributing the Work and assume any risks associated with Your exercise of permissions under this License. +> +> 8. Limitation of Liability. In no event and under no legal theory, whether in tort (including negligence), contract, or otherwise, unless required by applicable law (such as deliberate and grossly negligent acts) or agreed to in writing, shall any Contributor be liable to You for damages, including any direct, indirect, special, incidental, or consequential damages of any character arising as a result of this License or out of the use or inability to use the Work (including but not limited to damages for loss of goodwill, work stoppage, computer failure or malfunction, or any and all other commercial damages or losses), even if such Contributor has been advised of the possibility of such damages. +> +> 9. Accepting Warranty or Additional Liability. While redistributing the Work or Derivative Works thereof, You may choose to offer, and charge a fee for, acceptance of support, warranty, indemnity, or other liability obligations and/or rights consistent with this License. However, in accepting such obligations, You may act only on Your own behalf and on Your sole responsibility, not on behalf of any other Contributor, and only if You agree to indemnify, defend, and hold each Contributor harmless for any liability incurred by, or claims asserted against, such Contributor by reason of your accepting any such warranty or additional liability. +> +> END OF TERMS AND CONDITIONS + +---------------------------------------- + +## unherit@v1.1.3 + +> Clone a constructor without affecting the super-class + +License: MIT +Author: Titus Wormer (https://wooorm.com) +Contributors: + - Titus Wormer (https://wooorm.com) + +> (The MIT License) +> +> Copyright (c) 2015 Titus Wormer +> +> Permission is hereby granted, free of charge, to any person obtaining a copy +> of this software and associated documentation files (the "Software"), to deal +> in the Software without restriction, including without limitation the rights +> to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +> copies of the Software, and to permit persons to whom the Software is +> furnished to do so, subject to the following conditions: +> +> The above copyright notice and this permission notice shall be included in +> all copies or substantial portions of the Software. +> +> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +> FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +> AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +> LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +> OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +> THE SOFTWARE. + +---------------------------------------- + +## unified@v9.2.2 + +> Interface for parsing, inspecting, transforming, and serializing content through syntax trees + +License: MIT +Homepage: +Author: Titus Wormer (https://wooorm.com) +Contributors: + - Titus Wormer (https://wooorm.com) + - Junyoung Choi + - Hernan Rajchert + - Christian Murphy + - Vse Mozhet Byt + - Richard Littauer + +> (The MIT License) +> +> Copyright (c) 2015 Titus Wormer +> +> Permission is hereby granted, free of charge, to any person obtaining a copy +> of this software and associated documentation files (the "Software"), to deal +> in the Software without restriction, including without limitation the rights +> to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +> copies of the Software, and to permit persons to whom the Software is +> furnished to do so, subject to the following conditions: +> +> The above copyright notice and this permission notice shall be included in +> all copies or substantial portions of the Software. +> +> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +> FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +> AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +> LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +> OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +> THE SOFTWARE. + +---------------------------------------- + +## uniq@v1.0.1 + +> Removes duplicates from a sorted array in place + +License: MIT +Repository: +Author: Mikola Lysenko + +> The MIT License (MIT) +> +> Copyright (c) 2013 Mikola Lysenko +> +> Permission is hereby granted, free of charge, to any person obtaining a copy +> of this software and associated documentation files (the "Software"), to deal +> in the Software without restriction, including without limitation the rights +> to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +> copies of the Software, and to permit persons to whom the Software is +> furnished to do so, subject to the following conditions: +> +> The above copyright notice and this permission notice shall be included in +> all copies or substantial portions of the Software. +> +> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +> FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +> AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +> LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +> OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +> THE SOFTWARE. + +---------------------------------------- + +## unist-util-is@v4.1.0 + +> unist utility to check if a node passes a test + +License: MIT +Author: Titus Wormer (https://wooorm.com) +Contributors: + - Titus Wormer (https://wooorm.com) + - Christian Murphy + - Lucas Brandstaetter (https://github.com/Roang-zero1) + +> (The MIT license) +> +> Copyright (c) 2015 Titus Wormer +> +> Permission is hereby granted, free of charge, to any person obtaining +> a copy of this software and associated documentation files (the +> 'Software'), to deal in the Software without restriction, including +> without limitation the rights to use, copy, modify, merge, publish, +> distribute, sublicense, and/or sell copies of the Software, and to +> permit persons to whom the Software is furnished to do so, subject to +> the following conditions: +> +> The above copyright notice and this permission notice shall be +> included in all copies or substantial portions of the Software. +> +> THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, +> EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +> MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. +> IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY +> CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, +> TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE +> SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +---------------------------------------- + +## unist-util-remove-position@v2.0.1 + +> unist utility to remove positions from a tree + +License: MIT +Author: Titus Wormer (https://wooorm.com) +Contributors: + - Titus Wormer (https://wooorm.com) + +> (The MIT License) +> +> Copyright (c) 2016 Titus Wormer +> +> Permission is hereby granted, free of charge, to any person obtaining +> a copy of this software and associated documentation files (the +> 'Software'), to deal in the Software without restriction, including +> without limitation the rights to use, copy, modify, merge, publish, +> distribute, sublicense, and/or sell copies of the Software, and to +> permit persons to whom the Software is furnished to do so, subject to +> the following conditions: +> +> The above copyright notice and this permission notice shall be +> included in all copies or substantial portions of the Software. +> +> THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, +> EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +> MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. +> IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY +> CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, +> TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE +> SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +---------------------------------------- + +## unist-util-stringify-position@v2.0.3 + +> unist utility to serialize a node, position, or point as a human readable location + +License: MIT +Author: Titus Wormer (https://wooorm.com) +Contributors: + - Titus Wormer (https://wooorm.com) + +> (The MIT License) +> +> Copyright (c) 2016 Titus Wormer +> +> Permission is hereby granted, free of charge, to any person obtaining +> a copy of this software and associated documentation files (the +> 'Software'), to deal in the Software without restriction, including +> without limitation the rights to use, copy, modify, merge, publish, +> distribute, sublicense, and/or sell copies of the Software, and to +> permit persons to whom the Software is furnished to do so, subject to +> the following conditions: +> +> The above copyright notice and this permission notice shall be +> included in all copies or substantial portions of the Software. +> +> THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, +> EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +> MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. +> IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY +> CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, +> TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE +> SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +---------------------------------------- + +## unist-util-visit@v2.0.3 + +> unist utility to visit nodes + +License: MIT +Author: Titus Wormer (https://wooorm.com) +Contributors: + - Titus Wormer (https://wooorm.com) + - Eugene Sharygin + - Richard Gibson + +> (The MIT License) +> +> Copyright (c) 2015 Titus Wormer +> +> Permission is hereby granted, free of charge, to any person obtaining +> a copy of this software and associated documentation files (the +> 'Software'), to deal in the Software without restriction, including +> without limitation the rights to use, copy, modify, merge, publish, +> distribute, sublicense, and/or sell copies of the Software, and to +> permit persons to whom the Software is furnished to do so, subject to +> the following conditions: +> +> The above copyright notice and this permission notice shall be +> included in all copies or substantial portions of the Software. +> +> THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, +> EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +> MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. +> IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY +> CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, +> TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE +> SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +---------------------------------------- + +## unist-util-visit-parents@v3.1.1 + +> unist utility to recursively walk over nodes, with ancestral information + +License: MIT +Author: Titus Wormer (https://wooorm.com) +Contributors: + - Titus Wormer (https://wooorm.com) + +> (The MIT License) +> +> Copyright (c) 2016 Titus Wormer +> +> Permission is hereby granted, free of charge, to any person obtaining +> a copy of this software and associated documentation files (the +> 'Software'), to deal in the Software without restriction, including +> without limitation the rights to use, copy, modify, merge, publish, +> distribute, sublicense, and/or sell copies of the Software, and to +> permit persons to whom the Software is furnished to do so, subject to +> the following conditions: +> +> The above copyright notice and this permission notice shall be +> included in all copies or substantial portions of the Software. +> +> THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, +> EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +> MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. +> IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY +> CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, +> TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE +> SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +---------------------------------------- + +## url-or-path@v2.3.2 + +> Convert between file URL and path. + +License: MIT +Homepage: +Author: fisker Cheung (https://www.fiskercheung.com/) + +> MIT License +> +> Copyright (c) fisker Cheung (https://www.fiskercheung.com/) +> +> Permission is hereby granted, free of charge, to any person obtaining a copy +> of this software and associated documentation files (the "Software"), to deal +> in the Software without restriction, including without limitation the rights +> to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +> copies of the Software, and to permit persons to whom the Software is +> furnished to do so, subject to the following conditions: +> +> The above copyright notice and this permission notice shall be included in all +> copies or substantial portions of the Software. +> +> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +> FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +> AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +> LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +> OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +> SOFTWARE. + +---------------------------------------- + +## vfile@v4.2.1 + +> Virtual file format for text processing + +License: MIT +Author: Titus Wormer (https://wooorm.com) +Contributors: + - Titus Wormer (https://wooorm.com) + - Brendan Abbott + - Denys Dovhan + - Kyle Mathews + - Shinnosuke Watanabe + - Sindre Sorhus + +> (The MIT License) +> +> Copyright (c) 2015 Titus Wormer +> +> Permission is hereby granted, free of charge, to any person obtaining a copy +> of this software and associated documentation files (the "Software"), to deal +> in the Software without restriction, including without limitation the rights +> to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +> copies of the Software, and to permit persons to whom the Software is +> furnished to do so, subject to the following conditions: +> +> The above copyright notice and this permission notice shall be included in +> all copies or substantial portions of the Software. +> +> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +> FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +> AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +> LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +> OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +> THE SOFTWARE. + +---------------------------------------- + +## vfile-location@v3.2.0 + +> vfile utility to convert between positional (line and column-based) and offset (range-based) locations + +License: MIT +Author: Titus Wormer (https://wooorm.com) +Contributors: + - Titus Wormer (https://wooorm.com) + - Christian Murphy + +> (The MIT License) +> +> Copyright (c) 2016 Titus Wormer +> +> Permission is hereby granted, free of charge, to any person obtaining +> a copy of this software and associated documentation files (the +> 'Software'), to deal in the Software without restriction, including +> without limitation the rights to use, copy, modify, merge, publish, +> distribute, sublicense, and/or sell copies of the Software, and to +> permit persons to whom the Software is furnished to do so, subject to +> the following conditions: +> +> The above copyright notice and this permission notice shall be +> included in all copies or substantial portions of the Software. +> +> THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, +> EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +> MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. +> IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY +> CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, +> TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE +> SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +---------------------------------------- + +## vfile-message@v2.0.4 + +> vfile utility to create a virtual message + +License: MIT +Author: Titus Wormer (https://wooorm.com) +Contributors: + - Titus Wormer (https://wooorm.com) + +> (The MIT License) +> +> Copyright (c) 2017 Titus Wormer +> +> Permission is hereby granted, free of charge, to any person obtaining +> a copy of this software and associated documentation files (the +> 'Software'), to deal in the Software without restriction, including +> without limitation the rights to use, copy, modify, merge, publish, +> distribute, sublicense, and/or sell copies of the Software, and to +> permit persons to whom the Software is furnished to do so, subject to +> the following conditions: +> +> The above copyright notice and this permission notice shall be +> included in all copies or substantial portions of the Software. +> +> THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, +> EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +> MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. +> IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY +> CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, +> TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE +> SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +---------------------------------------- + +## vnopts@v2.0.0 + +> validate and normalize options + +License: MIT +Homepage: +Author: Ika (https://github.com/ikatyang) + +> MIT License +> +> Copyright (c) Ika (https://github.com/ikatyang) +> +> Permission is hereby granted, free of charge, to any person obtaining a copy +> of this software and associated documentation files (the "Software"), to deal +> in the Software without restriction, including without limitation the rights +> to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +> copies of the Software, and to permit persons to whom the Software is +> furnished to do so, subject to the following conditions: +> +> The above copyright notice and this permission notice shall be included in all +> copies or substantial portions of the Software. +> +> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +> FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +> AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +> LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +> OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +> SOFTWARE. + +---------------------------------------- + +## wcwidth.js@v2.0.0 + +> a javascript porting of C's wcwidth() + +License: MIT +Homepage: +Repository: +Author: Woong Jun (http://code.woong.org/) +Contributors: + - Tim Oxley (http://campjs.com/) + +> wcwidth.js: a javascript portng of C's wcwidth() +> ================================================ +> +> Copyright (C) 2012-2014 by Woong Jun and Tim Oxley. +> +> This package is a javascript porting of `wcwidth()` implementation +> [by Markus Kuhn](http://www.cl.cam.ac.uk/~mgk25/ucs/wcwidth.c). +> +> Permission is hereby granted, free of charge, to any person obtaining a copy of +> this software and associated documentation files (the "Software"), to deal in +> the Software without restriction, including without limitation the rights to +> use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies +> of the Software, and to permit persons to whom the Software is furnished to do +> so, subject to the following conditions: +> +> The above copyright notice and this permission notice shall be included in all +> copies or substantial portions of the Software. +> +> +> THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, +> INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND +> FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR +> OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, +> EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT +> OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +> INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +> CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING +> IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY +> OF SUCH DAMAGE. + +---------------------------------------- + +## xtend@v4.0.2 + +> extend like a boss + +License: MIT +Homepage: +Author: Raynos +Contributors: + - Jake Verbaten + - Matt Esch + +> The MIT License (MIT) +> Copyright (c) 2012-2014 Raynos. +> +> Permission is hereby granted, free of charge, to any person obtaining a copy +> of this software and associated documentation files (the "Software"), to deal +> in the Software without restriction, including without limitation the rights +> to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +> copies of the Software, and to permit persons to whom the Software is +> furnished to do so, subject to the following conditions: +> +> The above copyright notice and this permission notice shall be included in +> all copies or substantial portions of the Software. +> +> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +> FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +> AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +> LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +> OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +> THE SOFTWARE. + +---------------------------------------- + +## yallist@v2.1.2 + +> Yet Another Linked List + +License: ISC +Repository: +Author: Isaac Z. Schlueter (http://blog.izs.me/) + +> The ISC License +> +> Copyright (c) Isaac Z. Schlueter and Contributors +> +> Permission to use, copy, modify, and/or distribute this software for any +> purpose with or without fee is hereby granted, provided that the above +> copyright notice and this permission notice appear in all copies. +> +> THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES +> WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF +> MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR +> ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES +> WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN +> ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR +> IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + +---------------------------------------- + +## yaml@v1.10.2 + +> JavaScript parser and stringifier for YAML + +License: ISC +Homepage: +Author: Eemeli Aro + +> Copyright 2018 Eemeli Aro +> +> Permission to use, copy, modify, and/or distribute this software for any purpose +> with or without fee is hereby granted, provided that the above copyright notice +> and this permission notice appear in all copies. +> +> THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH +> REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND +> FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, +> INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS +> OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER +> TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF +> THIS SOFTWARE. + +---------------------------------------- + +## yaml-unist-parser@v2.0.1 + +> A YAML parser that produces output compatible with unist + +License: MIT +Homepage: +Author: Ika (https://github.com/ikatyang) + +> MIT License +> +> Copyright (c) Ika (https://github.com/ikatyang) +> +> Permission is hereby granted, free of charge, to any person obtaining a copy +> of this software and associated documentation files (the "Software"), to deal +> in the Software without restriction, including without limitation the rights +> to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +> copies of the Software, and to permit persons to whom the Software is +> furnished to do so, subject to the following conditions: +> +> The above copyright notice and this permission notice shall be included in all +> copies or substantial portions of the Software. +> +> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +> FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +> AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +> LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +> OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +> SOFTWARE. + +---------------------------------------- + +## yocto-queue@v1.1.1 + +> Tiny queue data structure + +License: MIT +Author: Sindre Sorhus (https://sindresorhus.com) + +> MIT License +> +> Copyright (c) Sindre Sorhus (https://sindresorhus.com) +> +> Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: +> +> The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. +> +> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. diff --git a/node_modules/prettier/bin/prettier.cjs b/node_modules/prettier/bin/prettier.cjs new file mode 100644 index 0000000..08f8e3b --- /dev/null +++ b/node_modules/prettier/bin/prettier.cjs @@ -0,0 +1,68 @@ +#!/usr/bin/env node +"use strict"; +var __getOwnPropNames = Object.getOwnPropertyNames; +var __commonJS = function(cb, mod) { + return function __require() { + return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports; + }; +}; + +// node_modules/semver-compare/index.js +var require_semver_compare = __commonJS({ + "node_modules/semver-compare/index.js": function(exports2, module2) { + module2.exports = function cmp(a, b) { + var pa = a.split("."); + var pb = b.split("."); + for (var i = 0; i < 3; i++) { + var na = Number(pa[i]); + var nb = Number(pb[i]); + if (na > nb) return 1; + if (nb > na) return -1; + if (!isNaN(na) && isNaN(nb)) return 1; + if (isNaN(na) && !isNaN(nb)) return -1; + } + return 0; + }; + } +}); + +// node_modules/please-upgrade-node/index.js +var require_please_upgrade_node = __commonJS({ + "node_modules/please-upgrade-node/index.js": function(exports2, module2) { + var semverCompare = require_semver_compare(); + module2.exports = function pleaseUpgradeNode2(pkg, opts) { + var opts = opts || {}; + var requiredVersion = pkg.engines.node.replace(">=", ""); + var currentVersion = process.version.replace("v", ""); + if (semverCompare(currentVersion, requiredVersion) === -1) { + if (opts.message) { + console.error(opts.message(requiredVersion)); + } else { + console.error( + pkg.name + " requires at least version " + requiredVersion + " of Node, please upgrade" + ); + } + if (opts.hasOwnProperty("exitCode")) { + process.exit(opts.exitCode); + } else { + process.exit(1); + } + } + }; + } +}); + +// bin/prettier.cjs +var nodeModule = require("module"); +if (typeof nodeModule.enableCompileCache === "function") { + nodeModule.enableCompileCache(); +} +var pleaseUpgradeNode = require_please_upgrade_node(); +var packageJson = require("../package.json"); +pleaseUpgradeNode(packageJson); +function runCli(cli) { + return cli.run(); +} +var dynamicImport = new Function("module", "return import(module)"); +var promise = dynamicImport("../internal/cli.mjs").then(runCli); +module.exports.__promise = promise; diff --git a/node_modules/prettier/doc.d.ts b/node_modules/prettier/doc.d.ts new file mode 100644 index 0000000..5011775 --- /dev/null +++ b/node_modules/prettier/doc.d.ts @@ -0,0 +1,254 @@ +// https://github.com/prettier/prettier/blob/next/src/document/public.js +export namespace builders { + type DocCommand = + | Align + | BreakParent + | Cursor + | Fill + | Group + | IfBreak + | Indent + | IndentIfBreak + | Label + | Line + | LineSuffix + | LineSuffixBoundary + | Trim; + type Doc = string | Doc[] | DocCommand; + + interface Align { + type: "align"; + contents: Doc; + n: number | string | { type: "root" }; + } + + interface BreakParent { + type: "break-parent"; + } + + interface Cursor { + type: "cursor"; + placeholder: symbol; + } + + interface Fill { + type: "fill"; + parts: Doc[]; + } + + interface Group { + type: "group"; + id?: symbol; + contents: Doc; + break: boolean; + expandedStates: Doc[]; + } + + interface HardlineWithoutBreakParent extends Line { + hard: true; + } + + interface IfBreak { + type: "if-break"; + breakContents: Doc; + flatContents: Doc; + } + + interface Indent { + type: "indent"; + contents: Doc; + } + + interface IndentIfBreak { + type: "indent-if-break"; + } + + interface Label { + type: "label"; + label: any; + contents: Doc; + } + + interface Line { + type: "line"; + soft?: boolean | undefined; + hard?: boolean | undefined; + literal?: boolean | undefined; + } + + interface LineSuffix { + type: "line-suffix"; + contents: Doc; + } + + interface LineSuffixBoundary { + type: "line-suffix-boundary"; + } + + interface LiterallineWithoutBreakParent extends Line { + hard: true; + literal: true; + } + + type LiteralLine = [LiterallineWithoutBreakParent, BreakParent]; + + interface Softline extends Line { + soft: true; + } + + type Hardline = [HardlineWithoutBreakParent, BreakParent]; + + interface Trim { + type: "trim"; + } + + interface GroupOptions { + shouldBreak?: boolean | undefined; + id?: symbol | undefined; + } + + function addAlignmentToDoc(doc: Doc, size: number, tabWidth: number): Doc; + + /** @see [align](https://github.com/prettier/prettier/blob/main/commands.md#align) */ + function align(widthOrString: Align["n"], doc: Doc): Align; + + /** @see [breakParent](https://github.com/prettier/prettier/blob/main/commands.md#breakparent) */ + const breakParent: BreakParent; + + /** @see [conditionalGroup](https://github.com/prettier/prettier/blob/main/commands.md#conditionalgroup) */ + function conditionalGroup(alternatives: Doc[], options?: GroupOptions): Group; + + /** @see [dedent](https://github.com/prettier/prettier/blob/main/commands.md#dedent) */ + function dedent(doc: Doc): Align; + + /** @see [dedentToRoot](https://github.com/prettier/prettier/blob/main/commands.md#dedenttoroot) */ + function dedentToRoot(doc: Doc): Align; + + /** @see [fill](https://github.com/prettier/prettier/blob/main/commands.md#fill) */ + function fill(docs: Doc[]): Fill; + + /** @see [group](https://github.com/prettier/prettier/blob/main/commands.md#group) */ + function group(doc: Doc, opts?: GroupOptions): Group; + + /** @see [hardline](https://github.com/prettier/prettier/blob/main/commands.md#hardline) */ + const hardline: Hardline; + + /** @see [hardlineWithoutBreakParent](https://github.com/prettier/prettier/blob/main/commands.md#hardlinewithoutbreakparent-and-literallinewithoutbreakparent) */ + const hardlineWithoutBreakParent: HardlineWithoutBreakParent; + + /** @see [ifBreak](https://github.com/prettier/prettier/blob/main/commands.md#ifbreak) */ + function ifBreak( + ifBreak: Doc, + noBreak?: Doc, + options?: { groupId?: symbol | undefined }, + ): IfBreak; + + /** @see [indent](https://github.com/prettier/prettier/blob/main/commands.md#indent) */ + function indent(doc: Doc): Indent; + + /** @see [indentIfBreak](https://github.com/prettier/prettier/blob/main/commands.md#indentifbreak) */ + function indentIfBreak( + doc: Doc, + opts: { groupId: symbol; negate?: boolean | undefined }, + ): IndentIfBreak; + + /** @see [join](https://github.com/prettier/prettier/blob/main/commands.md#join) */ + function join(sep: Doc, docs: Doc[]): Doc[]; + + /** @see [label](https://github.com/prettier/prettier/blob/main/commands.md#label) */ + function label(label: any | undefined, contents: Doc): Doc; + + /** @see [line](https://github.com/prettier/prettier/blob/main/commands.md#line) */ + const line: Line; + + /** @see [lineSuffix](https://github.com/prettier/prettier/blob/main/commands.md#linesuffix) */ + function lineSuffix(suffix: Doc): LineSuffix; + + /** @see [lineSuffixBoundary](https://github.com/prettier/prettier/blob/main/commands.md#linesuffixboundary) */ + const lineSuffixBoundary: LineSuffixBoundary; + + /** @see [literalline](https://github.com/prettier/prettier/blob/main/commands.md#literalline) */ + const literalline: LiteralLine; + + /** @see [literallineWithoutBreakParent](https://github.com/prettier/prettier/blob/main/commands.md#hardlinewithoutbreakparent-and-literallinewithoutbreakparent) */ + const literallineWithoutBreakParent: LiterallineWithoutBreakParent; + + /** @see [markAsRoot](https://github.com/prettier/prettier/blob/main/commands.md#markasroot) */ + function markAsRoot(doc: Doc): Align; + + /** @see [softline](https://github.com/prettier/prettier/blob/main/commands.md#softline) */ + const softline: Softline; + + /** @see [trim](https://github.com/prettier/prettier/blob/main/commands.md#trim) */ + const trim: Trim; + + /** @see [cursor](https://github.com/prettier/prettier/blob/main/commands.md#cursor) */ + const cursor: Cursor; +} + +export namespace printer { + function printDocToString( + doc: builders.Doc, + options: Options, + ): { + formatted: string; + /** + * This property is a misnomer, and has been since the changes in + * https://github.com/prettier/prettier/pull/15709. + * The region of the document indicated by `cursorNodeStart` and `cursorNodeText` will + * sometimes actually be what lies BETWEEN a pair of leaf nodes in the AST, rather than a node. + */ + cursorNodeStart?: number | undefined; + + /** + * Note that, like cursorNodeStart, this is a misnomer and may actually be the text between two + * leaf nodes in the AST instead of the text of a node. + */ + cursorNodeText?: string | undefined; + }; + interface Options { + /** + * Specify the line length that the printer will wrap on. + * @default 80 + */ + printWidth: number; + /** + * Specify the number of spaces per indentation-level. + * @default 2 + */ + tabWidth: number; + /** + * Indent lines with tabs instead of spaces + * @default false + */ + useTabs?: boolean; + parentParser?: string | undefined; + __embeddedInHtml?: boolean | undefined; + } +} + +export namespace utils { + function willBreak(doc: builders.Doc): boolean; + function traverseDoc( + doc: builders.Doc, + onEnter?: (doc: builders.Doc) => void | boolean, + onExit?: (doc: builders.Doc) => void, + shouldTraverseConditionalGroups?: boolean, + ): void; + function findInDoc( + doc: builders.Doc, + callback: (doc: builders.Doc) => T, + defaultValue: T, + ): T; + function mapDoc( + doc: builders.Doc, + callback: (doc: builders.Doc) => T, + ): T; + function removeLines(doc: builders.Doc): builders.Doc; + function stripTrailingHardline(doc: builders.Doc): builders.Doc; + function replaceEndOfLine( + doc: builders.Doc, + replacement?: builders.Doc, + ): builders.Doc; + function canBreak(doc: builders.Doc): boolean; +} diff --git a/node_modules/prettier/doc.js b/node_modules/prettier/doc.js new file mode 100644 index 0000000..2923c46 --- /dev/null +++ b/node_modules/prettier/doc.js @@ -0,0 +1,1261 @@ +(function (factory) { + function interopModuleDefault() { + var module = factory(); + return module.default || module; + } + + if (typeof exports === "object" && typeof module === "object") { + module.exports = interopModuleDefault(); + } else if (typeof define === "function" && define.amd) { + define(interopModuleDefault); + } else { + var root = + typeof globalThis !== "undefined" + ? globalThis + : typeof global !== "undefined" + ? global + : typeof self !== "undefined" + ? self + : this || {}; + root.doc = interopModuleDefault(); + } +})(function () { + "use strict"; + var __defProp = Object.defineProperty; + var __getOwnPropDesc = Object.getOwnPropertyDescriptor; + var __getOwnPropNames = Object.getOwnPropertyNames; + var __hasOwnProp = Object.prototype.hasOwnProperty; + var __export = (target, all) => { + for (var name in all) + __defProp(target, name, { get: all[name], enumerable: true }); + }; + var __copyProps = (to, from, except, desc) => { + if (from && typeof from === "object" || typeof from === "function") { + for (let key of __getOwnPropNames(from)) + if (!__hasOwnProp.call(to, key) && key !== except) + __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable }); + } + return to; + }; + var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod); + + // src/document/public.js + var public_exports = {}; + __export(public_exports, { + builders: () => builders, + printer: () => printer, + utils: () => utils + }); + + // src/document/constants.js + var DOC_TYPE_STRING = "string"; + var DOC_TYPE_ARRAY = "array"; + var DOC_TYPE_CURSOR = "cursor"; + var DOC_TYPE_INDENT = "indent"; + var DOC_TYPE_ALIGN = "align"; + var DOC_TYPE_TRIM = "trim"; + var DOC_TYPE_GROUP = "group"; + var DOC_TYPE_FILL = "fill"; + var DOC_TYPE_IF_BREAK = "if-break"; + var DOC_TYPE_INDENT_IF_BREAK = "indent-if-break"; + var DOC_TYPE_LINE_SUFFIX = "line-suffix"; + var DOC_TYPE_LINE_SUFFIX_BOUNDARY = "line-suffix-boundary"; + var DOC_TYPE_LINE = "line"; + var DOC_TYPE_LABEL = "label"; + var DOC_TYPE_BREAK_PARENT = "break-parent"; + var VALID_OBJECT_DOC_TYPES = /* @__PURE__ */ new Set([ + DOC_TYPE_CURSOR, + DOC_TYPE_INDENT, + DOC_TYPE_ALIGN, + DOC_TYPE_TRIM, + DOC_TYPE_GROUP, + DOC_TYPE_FILL, + DOC_TYPE_IF_BREAK, + DOC_TYPE_INDENT_IF_BREAK, + DOC_TYPE_LINE_SUFFIX, + DOC_TYPE_LINE_SUFFIX_BOUNDARY, + DOC_TYPE_LINE, + DOC_TYPE_LABEL, + DOC_TYPE_BREAK_PARENT + ]); + + // scripts/build/shims/at.js + var at = (isOptionalObject, object, index) => { + if (isOptionalObject && (object === void 0 || object === null)) { + return; + } + if (Array.isArray(object) || typeof object === "string") { + return object[index < 0 ? object.length + index : index]; + } + return object.at(index); + }; + var at_default = at; + + // src/document/utils/get-doc-type.js + function getDocType(doc) { + if (typeof doc === "string") { + return DOC_TYPE_STRING; + } + if (Array.isArray(doc)) { + return DOC_TYPE_ARRAY; + } + if (!doc) { + return; + } + const { type } = doc; + if (VALID_OBJECT_DOC_TYPES.has(type)) { + return type; + } + } + var get_doc_type_default = getDocType; + + // src/document/invalid-doc-error.js + var disjunctionListFormat = (list) => new Intl.ListFormat("en-US", { type: "disjunction" }).format(list); + function getDocErrorMessage(doc) { + const type = doc === null ? "null" : typeof doc; + if (type !== "string" && type !== "object") { + return `Unexpected doc '${type}', +Expected it to be 'string' or 'object'.`; + } + if (get_doc_type_default(doc)) { + throw new Error("doc is valid."); + } + const objectType = Object.prototype.toString.call(doc); + if (objectType !== "[object Object]") { + return `Unexpected doc '${objectType}'.`; + } + const EXPECTED_TYPE_VALUES = disjunctionListFormat( + [...VALID_OBJECT_DOC_TYPES].map((type2) => `'${type2}'`) + ); + return `Unexpected doc.type '${doc.type}'. +Expected it to be ${EXPECTED_TYPE_VALUES}.`; + } + var InvalidDocError = class extends Error { + name = "InvalidDocError"; + constructor(doc) { + super(getDocErrorMessage(doc)); + this.doc = doc; + } + }; + var invalid_doc_error_default = InvalidDocError; + + // src/document/utils/traverse-doc.js + var traverseDocOnExitStackMarker = {}; + function traverseDoc(doc, onEnter, onExit, shouldTraverseConditionalGroups) { + const docsStack = [doc]; + while (docsStack.length > 0) { + const doc2 = docsStack.pop(); + if (doc2 === traverseDocOnExitStackMarker) { + onExit(docsStack.pop()); + continue; + } + if (onExit) { + docsStack.push(doc2, traverseDocOnExitStackMarker); + } + const docType = get_doc_type_default(doc2); + if (!docType) { + throw new invalid_doc_error_default(doc2); + } + if ((onEnter == null ? void 0 : onEnter(doc2)) === false) { + continue; + } + switch (docType) { + case DOC_TYPE_ARRAY: + case DOC_TYPE_FILL: { + const parts = docType === DOC_TYPE_ARRAY ? doc2 : doc2.parts; + for (let ic = parts.length, i = ic - 1; i >= 0; --i) { + docsStack.push(parts[i]); + } + break; + } + case DOC_TYPE_IF_BREAK: + docsStack.push(doc2.flatContents, doc2.breakContents); + break; + case DOC_TYPE_GROUP: + if (shouldTraverseConditionalGroups && doc2.expandedStates) { + for (let ic = doc2.expandedStates.length, i = ic - 1; i >= 0; --i) { + docsStack.push(doc2.expandedStates[i]); + } + } else { + docsStack.push(doc2.contents); + } + break; + case DOC_TYPE_ALIGN: + case DOC_TYPE_INDENT: + case DOC_TYPE_INDENT_IF_BREAK: + case DOC_TYPE_LABEL: + case DOC_TYPE_LINE_SUFFIX: + docsStack.push(doc2.contents); + break; + case DOC_TYPE_STRING: + case DOC_TYPE_CURSOR: + case DOC_TYPE_TRIM: + case DOC_TYPE_LINE_SUFFIX_BOUNDARY: + case DOC_TYPE_LINE: + case DOC_TYPE_BREAK_PARENT: + break; + default: + throw new invalid_doc_error_default(doc2); + } + } + } + var traverse_doc_default = traverseDoc; + + // src/document/utils.js + function mapDoc(doc, cb) { + if (typeof doc === "string") { + return cb(doc); + } + const mapped = /* @__PURE__ */ new Map(); + return rec(doc); + function rec(doc2) { + if (mapped.has(doc2)) { + return mapped.get(doc2); + } + const result = process2(doc2); + mapped.set(doc2, result); + return result; + } + function process2(doc2) { + switch (get_doc_type_default(doc2)) { + case DOC_TYPE_ARRAY: + return cb(doc2.map(rec)); + case DOC_TYPE_FILL: + return cb({ ...doc2, parts: doc2.parts.map(rec) }); + case DOC_TYPE_IF_BREAK: + return cb({ + ...doc2, + breakContents: rec(doc2.breakContents), + flatContents: rec(doc2.flatContents) + }); + case DOC_TYPE_GROUP: { + let { expandedStates, contents } = doc2; + if (expandedStates) { + expandedStates = expandedStates.map(rec); + contents = expandedStates[0]; + } else { + contents = rec(contents); + } + return cb({ ...doc2, contents, expandedStates }); + } + case DOC_TYPE_ALIGN: + case DOC_TYPE_INDENT: + case DOC_TYPE_INDENT_IF_BREAK: + case DOC_TYPE_LABEL: + case DOC_TYPE_LINE_SUFFIX: + return cb({ ...doc2, contents: rec(doc2.contents) }); + case DOC_TYPE_STRING: + case DOC_TYPE_CURSOR: + case DOC_TYPE_TRIM: + case DOC_TYPE_LINE_SUFFIX_BOUNDARY: + case DOC_TYPE_LINE: + case DOC_TYPE_BREAK_PARENT: + return cb(doc2); + default: + throw new invalid_doc_error_default(doc2); + } + } + } + function findInDoc(doc, fn, defaultValue) { + let result = defaultValue; + let shouldSkipFurtherProcessing = false; + function findInDocOnEnterFn(doc2) { + if (shouldSkipFurtherProcessing) { + return false; + } + const maybeResult = fn(doc2); + if (maybeResult !== void 0) { + shouldSkipFurtherProcessing = true; + result = maybeResult; + } + } + traverse_doc_default(doc, findInDocOnEnterFn); + return result; + } + function willBreakFn(doc) { + if (doc.type === DOC_TYPE_GROUP && doc.break) { + return true; + } + if (doc.type === DOC_TYPE_LINE && doc.hard) { + return true; + } + if (doc.type === DOC_TYPE_BREAK_PARENT) { + return true; + } + } + function willBreak(doc) { + return findInDoc(doc, willBreakFn, false); + } + function breakParentGroup(groupStack) { + if (groupStack.length > 0) { + const parentGroup = at_default( + /* isOptionalObject */ + false, + groupStack, + -1 + ); + if (!parentGroup.expandedStates && !parentGroup.break) { + parentGroup.break = "propagated"; + } + } + return null; + } + function propagateBreaks(doc) { + const alreadyVisitedSet = /* @__PURE__ */ new Set(); + const groupStack = []; + function propagateBreaksOnEnterFn(doc2) { + if (doc2.type === DOC_TYPE_BREAK_PARENT) { + breakParentGroup(groupStack); + } + if (doc2.type === DOC_TYPE_GROUP) { + groupStack.push(doc2); + if (alreadyVisitedSet.has(doc2)) { + return false; + } + alreadyVisitedSet.add(doc2); + } + } + function propagateBreaksOnExitFn(doc2) { + if (doc2.type === DOC_TYPE_GROUP) { + const group2 = groupStack.pop(); + if (group2.break) { + breakParentGroup(groupStack); + } + } + } + traverse_doc_default( + doc, + propagateBreaksOnEnterFn, + propagateBreaksOnExitFn, + /* shouldTraverseConditionalGroups */ + true + ); + } + function removeLinesFn(doc) { + if (doc.type === DOC_TYPE_LINE && !doc.hard) { + return doc.soft ? "" : " "; + } + if (doc.type === DOC_TYPE_IF_BREAK) { + return doc.flatContents; + } + return doc; + } + function removeLines(doc) { + return mapDoc(doc, removeLinesFn); + } + function stripTrailingHardlineFromParts(parts) { + parts = [...parts]; + while (parts.length >= 2 && at_default( + /* isOptionalObject */ + false, + parts, + -2 + ).type === DOC_TYPE_LINE && at_default( + /* isOptionalObject */ + false, + parts, + -1 + ).type === DOC_TYPE_BREAK_PARENT) { + parts.length -= 2; + } + if (parts.length > 0) { + const lastPart = stripTrailingHardlineFromDoc(at_default( + /* isOptionalObject */ + false, + parts, + -1 + )); + parts[parts.length - 1] = lastPart; + } + return parts; + } + function stripTrailingHardlineFromDoc(doc) { + switch (get_doc_type_default(doc)) { + case DOC_TYPE_INDENT: + case DOC_TYPE_INDENT_IF_BREAK: + case DOC_TYPE_GROUP: + case DOC_TYPE_LINE_SUFFIX: + case DOC_TYPE_LABEL: { + const contents = stripTrailingHardlineFromDoc(doc.contents); + return { ...doc, contents }; + } + case DOC_TYPE_IF_BREAK: + return { + ...doc, + breakContents: stripTrailingHardlineFromDoc(doc.breakContents), + flatContents: stripTrailingHardlineFromDoc(doc.flatContents) + }; + case DOC_TYPE_FILL: + return { ...doc, parts: stripTrailingHardlineFromParts(doc.parts) }; + case DOC_TYPE_ARRAY: + return stripTrailingHardlineFromParts(doc); + case DOC_TYPE_STRING: + return doc.replace(/[\n\r]*$/u, ""); + case DOC_TYPE_ALIGN: + case DOC_TYPE_CURSOR: + case DOC_TYPE_TRIM: + case DOC_TYPE_LINE_SUFFIX_BOUNDARY: + case DOC_TYPE_LINE: + case DOC_TYPE_BREAK_PARENT: + break; + default: + throw new invalid_doc_error_default(doc); + } + return doc; + } + function stripTrailingHardline(doc) { + return stripTrailingHardlineFromDoc(cleanDoc(doc)); + } + function cleanDocFn(doc) { + switch (get_doc_type_default(doc)) { + case DOC_TYPE_FILL: + if (doc.parts.every((part) => part === "")) { + return ""; + } + break; + case DOC_TYPE_GROUP: + if (!doc.contents && !doc.id && !doc.break && !doc.expandedStates) { + return ""; + } + if (doc.contents.type === DOC_TYPE_GROUP && doc.contents.id === doc.id && doc.contents.break === doc.break && doc.contents.expandedStates === doc.expandedStates) { + return doc.contents; + } + break; + case DOC_TYPE_ALIGN: + case DOC_TYPE_INDENT: + case DOC_TYPE_INDENT_IF_BREAK: + case DOC_TYPE_LINE_SUFFIX: + if (!doc.contents) { + return ""; + } + break; + case DOC_TYPE_IF_BREAK: + if (!doc.flatContents && !doc.breakContents) { + return ""; + } + break; + case DOC_TYPE_ARRAY: { + const parts = []; + for (const part of doc) { + if (!part) { + continue; + } + const [currentPart, ...restParts] = Array.isArray(part) ? part : [part]; + if (typeof currentPart === "string" && typeof at_default( + /* isOptionalObject */ + false, + parts, + -1 + ) === "string") { + parts[parts.length - 1] += currentPart; + } else { + parts.push(currentPart); + } + parts.push(...restParts); + } + if (parts.length === 0) { + return ""; + } + if (parts.length === 1) { + return parts[0]; + } + return parts; + } + case DOC_TYPE_STRING: + case DOC_TYPE_CURSOR: + case DOC_TYPE_TRIM: + case DOC_TYPE_LINE_SUFFIX_BOUNDARY: + case DOC_TYPE_LINE: + case DOC_TYPE_LABEL: + case DOC_TYPE_BREAK_PARENT: + break; + default: + throw new invalid_doc_error_default(doc); + } + return doc; + } + function cleanDoc(doc) { + return mapDoc(doc, (currentDoc) => cleanDocFn(currentDoc)); + } + function replaceEndOfLine(doc, replacement = literalline) { + return mapDoc( + doc, + (currentDoc) => typeof currentDoc === "string" ? join(replacement, currentDoc.split("\n")) : currentDoc + ); + } + function canBreakFn(doc) { + if (doc.type === DOC_TYPE_LINE) { + return true; + } + } + function canBreak(doc) { + return findInDoc(doc, canBreakFn, false); + } + + // src/document/utils/assert-doc.js + var noop = () => { + }; + var assertDoc = true ? noop : function(doc) { + traverse_doc_default(doc, (doc2) => { + if (checked.has(doc2)) { + return false; + } + if (typeof doc2 !== "string") { + checked.add(doc2); + } + }); + }; + var assertDocArray = true ? noop : function(docs, optional = false) { + if (optional && !docs) { + return; + } + if (!Array.isArray(docs)) { + throw new TypeError("Unexpected doc array."); + } + for (const doc of docs) { + assertDoc(doc); + } + }; + var assertDocFillParts = true ? noop : ( + /** + * @param {Doc[]} parts + */ + function(parts) { + assertDocArray(parts); + if (parts.length > 1 && isEmptyDoc(at_default( + /* isOptionalObject */ + false, + parts, + -1 + ))) { + parts = parts.slice(0, -1); + } + for (const [i, doc] of parts.entries()) { + if (i % 2 === 1 && !isValidSeparator(doc)) { + const type = get_doc_type_default(doc); + throw new Error( + `Unexpected non-line-break doc at ${i}. Doc type is ${type}.` + ); + } + } + } + ); + + // src/document/builders.js + function indent(contents) { + assertDoc(contents); + return { type: DOC_TYPE_INDENT, contents }; + } + function align(widthOrString, contents) { + assertDoc(contents); + return { type: DOC_TYPE_ALIGN, contents, n: widthOrString }; + } + function group(contents, opts = {}) { + assertDoc(contents); + assertDocArray( + opts.expandedStates, + /* optional */ + true + ); + return { + type: DOC_TYPE_GROUP, + id: opts.id, + contents, + break: Boolean(opts.shouldBreak), + expandedStates: opts.expandedStates + }; + } + function dedentToRoot(contents) { + return align(Number.NEGATIVE_INFINITY, contents); + } + function markAsRoot(contents) { + return align({ type: "root" }, contents); + } + function dedent(contents) { + return align(-1, contents); + } + function conditionalGroup(states, opts) { + return group(states[0], { ...opts, expandedStates: states }); + } + function fill(parts) { + assertDocFillParts(parts); + return { type: DOC_TYPE_FILL, parts }; + } + function ifBreak(breakContents, flatContents = "", opts = {}) { + assertDoc(breakContents); + if (flatContents !== "") { + assertDoc(flatContents); + } + return { + type: DOC_TYPE_IF_BREAK, + breakContents, + flatContents, + groupId: opts.groupId + }; + } + function indentIfBreak(contents, opts) { + assertDoc(contents); + return { + type: DOC_TYPE_INDENT_IF_BREAK, + contents, + groupId: opts.groupId, + negate: opts.negate + }; + } + function lineSuffix(contents) { + assertDoc(contents); + return { type: DOC_TYPE_LINE_SUFFIX, contents }; + } + var lineSuffixBoundary = { type: DOC_TYPE_LINE_SUFFIX_BOUNDARY }; + var breakParent = { type: DOC_TYPE_BREAK_PARENT }; + var trim = { type: DOC_TYPE_TRIM }; + var hardlineWithoutBreakParent = { type: DOC_TYPE_LINE, hard: true }; + var literallineWithoutBreakParent = { + type: DOC_TYPE_LINE, + hard: true, + literal: true + }; + var line = { type: DOC_TYPE_LINE }; + var softline = { type: DOC_TYPE_LINE, soft: true }; + var hardline = [hardlineWithoutBreakParent, breakParent]; + var literalline = [literallineWithoutBreakParent, breakParent]; + var cursor = { type: DOC_TYPE_CURSOR }; + function join(separator, docs) { + assertDoc(separator); + assertDocArray(docs); + const parts = []; + for (let i = 0; i < docs.length; i++) { + if (i !== 0) { + parts.push(separator); + } + parts.push(docs[i]); + } + return parts; + } + function addAlignmentToDoc(doc, size, tabWidth) { + assertDoc(doc); + let aligned = doc; + if (size > 0) { + for (let i = 0; i < Math.floor(size / tabWidth); ++i) { + aligned = indent(aligned); + } + aligned = align(size % tabWidth, aligned); + aligned = align(Number.NEGATIVE_INFINITY, aligned); + } + return aligned; + } + function label(label2, contents) { + assertDoc(contents); + return label2 ? { type: DOC_TYPE_LABEL, label: label2, contents } : contents; + } + + // scripts/build/shims/string-replace-all.js + var stringReplaceAll = (isOptionalObject, original, pattern, replacement) => { + if (isOptionalObject && (original === void 0 || original === null)) { + return; + } + if (original.replaceAll) { + return original.replaceAll(pattern, replacement); + } + if (pattern.global) { + return original.replace(pattern, replacement); + } + return original.split(pattern).join(replacement); + }; + var string_replace_all_default = stringReplaceAll; + + // src/common/end-of-line.js + function convertEndOfLineToChars(value) { + switch (value) { + case "cr": + return "\r"; + case "crlf": + return "\r\n"; + default: + return "\n"; + } + } + + // node_modules/emoji-regex/index.mjs + var emoji_regex_default = () => { + return /[#*0-9]\uFE0F?\u20E3|[\xA9\xAE\u203C\u2049\u2122\u2139\u2194-\u2199\u21A9\u21AA\u231A\u231B\u2328\u23CF\u23ED-\u23EF\u23F1\u23F2\u23F8-\u23FA\u24C2\u25AA\u25AB\u25B6\u25C0\u25FB\u25FC\u25FE\u2600-\u2604\u260E\u2611\u2614\u2615\u2618\u2620\u2622\u2623\u2626\u262A\u262E\u262F\u2638-\u263A\u2640\u2642\u2648-\u2653\u265F\u2660\u2663\u2665\u2666\u2668\u267B\u267E\u267F\u2692\u2694-\u2697\u2699\u269B\u269C\u26A0\u26A7\u26AA\u26B0\u26B1\u26BD\u26BE\u26C4\u26C8\u26CF\u26D1\u26E9\u26F0-\u26F5\u26F7\u26F8\u26FA\u2702\u2708\u2709\u270F\u2712\u2714\u2716\u271D\u2721\u2733\u2734\u2744\u2747\u2757\u2763\u27A1\u2934\u2935\u2B05-\u2B07\u2B1B\u2B1C\u2B55\u3030\u303D\u3297\u3299]\uFE0F?|[\u261D\u270C\u270D](?:\uD83C[\uDFFB-\uDFFF]|\uFE0F)?|[\u270A\u270B](?:\uD83C[\uDFFB-\uDFFF])?|[\u23E9-\u23EC\u23F0\u23F3\u25FD\u2693\u26A1\u26AB\u26C5\u26CE\u26D4\u26EA\u26FD\u2705\u2728\u274C\u274E\u2753-\u2755\u2795-\u2797\u27B0\u27BF\u2B50]|\u26D3\uFE0F?(?:\u200D\uD83D\uDCA5)?|\u26F9(?:\uD83C[\uDFFB-\uDFFF]|\uFE0F)?(?:\u200D[\u2640\u2642]\uFE0F?)?|\u2764\uFE0F?(?:\u200D(?:\uD83D\uDD25|\uD83E\uDE79))?|\uD83C(?:[\uDC04\uDD70\uDD71\uDD7E\uDD7F\uDE02\uDE37\uDF21\uDF24-\uDF2C\uDF36\uDF7D\uDF96\uDF97\uDF99-\uDF9B\uDF9E\uDF9F\uDFCD\uDFCE\uDFD4-\uDFDF\uDFF5\uDFF7]\uFE0F?|[\uDF85\uDFC2\uDFC7](?:\uD83C[\uDFFB-\uDFFF])?|[\uDFC4\uDFCA](?:\uD83C[\uDFFB-\uDFFF])?(?:\u200D[\u2640\u2642]\uFE0F?)?|[\uDFCB\uDFCC](?:\uD83C[\uDFFB-\uDFFF]|\uFE0F)?(?:\u200D[\u2640\u2642]\uFE0F?)?|[\uDCCF\uDD8E\uDD91-\uDD9A\uDE01\uDE1A\uDE2F\uDE32-\uDE36\uDE38-\uDE3A\uDE50\uDE51\uDF00-\uDF20\uDF2D-\uDF35\uDF37-\uDF43\uDF45-\uDF4A\uDF4C-\uDF7C\uDF7E-\uDF84\uDF86-\uDF93\uDFA0-\uDFC1\uDFC5\uDFC6\uDFC8\uDFC9\uDFCF-\uDFD3\uDFE0-\uDFF0\uDFF8-\uDFFF]|\uDDE6\uD83C[\uDDE8-\uDDEC\uDDEE\uDDF1\uDDF2\uDDF4\uDDF6-\uDDFA\uDDFC\uDDFD\uDDFF]|\uDDE7\uD83C[\uDDE6\uDDE7\uDDE9-\uDDEF\uDDF1-\uDDF4\uDDF6-\uDDF9\uDDFB\uDDFC\uDDFE\uDDFF]|\uDDE8\uD83C[\uDDE6\uDDE8\uDDE9\uDDEB-\uDDEE\uDDF0-\uDDF7\uDDFA-\uDDFF]|\uDDE9\uD83C[\uDDEA\uDDEC\uDDEF\uDDF0\uDDF2\uDDF4\uDDFF]|\uDDEA\uD83C[\uDDE6\uDDE8\uDDEA\uDDEC\uDDED\uDDF7-\uDDFA]|\uDDEB\uD83C[\uDDEE-\uDDF0\uDDF2\uDDF4\uDDF7]|\uDDEC\uD83C[\uDDE6\uDDE7\uDDE9-\uDDEE\uDDF1-\uDDF3\uDDF5-\uDDFA\uDDFC\uDDFE]|\uDDED\uD83C[\uDDF0\uDDF2\uDDF3\uDDF7\uDDF9\uDDFA]|\uDDEE\uD83C[\uDDE8-\uDDEA\uDDF1-\uDDF4\uDDF6-\uDDF9]|\uDDEF\uD83C[\uDDEA\uDDF2\uDDF4\uDDF5]|\uDDF0\uD83C[\uDDEA\uDDEC-\uDDEE\uDDF2\uDDF3\uDDF5\uDDF7\uDDFC\uDDFE\uDDFF]|\uDDF1\uD83C[\uDDE6-\uDDE8\uDDEE\uDDF0\uDDF7-\uDDFB\uDDFE]|\uDDF2\uD83C[\uDDE6\uDDE8-\uDDED\uDDF0-\uDDFF]|\uDDF3\uD83C[\uDDE6\uDDE8\uDDEA-\uDDEC\uDDEE\uDDF1\uDDF4\uDDF5\uDDF7\uDDFA\uDDFF]|\uDDF4\uD83C\uDDF2|\uDDF5\uD83C[\uDDE6\uDDEA-\uDDED\uDDF0-\uDDF3\uDDF7-\uDDF9\uDDFC\uDDFE]|\uDDF6\uD83C\uDDE6|\uDDF7\uD83C[\uDDEA\uDDF4\uDDF8\uDDFA\uDDFC]|\uDDF8\uD83C[\uDDE6-\uDDEA\uDDEC-\uDDF4\uDDF7-\uDDF9\uDDFB\uDDFD-\uDDFF]|\uDDF9\uD83C[\uDDE6\uDDE8\uDDE9\uDDEB-\uDDED\uDDEF-\uDDF4\uDDF7\uDDF9\uDDFB\uDDFC\uDDFF]|\uDDFA\uD83C[\uDDE6\uDDEC\uDDF2\uDDF3\uDDF8\uDDFE\uDDFF]|\uDDFB\uD83C[\uDDE6\uDDE8\uDDEA\uDDEC\uDDEE\uDDF3\uDDFA]|\uDDFC\uD83C[\uDDEB\uDDF8]|\uDDFD\uD83C\uDDF0|\uDDFE\uD83C[\uDDEA\uDDF9]|\uDDFF\uD83C[\uDDE6\uDDF2\uDDFC]|\uDF44(?:\u200D\uD83D\uDFEB)?|\uDF4B(?:\u200D\uD83D\uDFE9)?|\uDFC3(?:\uD83C[\uDFFB-\uDFFF])?(?:\u200D(?:[\u2640\u2642]\uFE0F?(?:\u200D\u27A1\uFE0F?)?|\u27A1\uFE0F?))?|\uDFF3\uFE0F?(?:\u200D(?:\u26A7\uFE0F?|\uD83C\uDF08))?|\uDFF4(?:\u200D\u2620\uFE0F?|\uDB40\uDC67\uDB40\uDC62\uDB40(?:\uDC65\uDB40\uDC6E\uDB40\uDC67|\uDC73\uDB40\uDC63\uDB40\uDC74|\uDC77\uDB40\uDC6C\uDB40\uDC73)\uDB40\uDC7F)?)|\uD83D(?:[\uDC3F\uDCFD\uDD49\uDD4A\uDD6F\uDD70\uDD73\uDD76-\uDD79\uDD87\uDD8A-\uDD8D\uDDA5\uDDA8\uDDB1\uDDB2\uDDBC\uDDC2-\uDDC4\uDDD1-\uDDD3\uDDDC-\uDDDE\uDDE1\uDDE3\uDDE8\uDDEF\uDDF3\uDDFA\uDECB\uDECD-\uDECF\uDEE0-\uDEE5\uDEE9\uDEF0\uDEF3]\uFE0F?|[\uDC42\uDC43\uDC46-\uDC50\uDC66\uDC67\uDC6B-\uDC6D\uDC72\uDC74-\uDC76\uDC78\uDC7C\uDC83\uDC85\uDC8F\uDC91\uDCAA\uDD7A\uDD95\uDD96\uDE4C\uDE4F\uDEC0\uDECC](?:\uD83C[\uDFFB-\uDFFF])?|[\uDC6E\uDC70\uDC71\uDC73\uDC77\uDC81\uDC82\uDC86\uDC87\uDE45-\uDE47\uDE4B\uDE4D\uDE4E\uDEA3\uDEB4\uDEB5](?:\uD83C[\uDFFB-\uDFFF])?(?:\u200D[\u2640\u2642]\uFE0F?)?|[\uDD74\uDD90](?:\uD83C[\uDFFB-\uDFFF]|\uFE0F)?|[\uDC00-\uDC07\uDC09-\uDC14\uDC16-\uDC25\uDC27-\uDC3A\uDC3C-\uDC3E\uDC40\uDC44\uDC45\uDC51-\uDC65\uDC6A\uDC79-\uDC7B\uDC7D-\uDC80\uDC84\uDC88-\uDC8E\uDC90\uDC92-\uDCA9\uDCAB-\uDCFC\uDCFF-\uDD3D\uDD4B-\uDD4E\uDD50-\uDD67\uDDA4\uDDFB-\uDE2D\uDE2F-\uDE34\uDE37-\uDE41\uDE43\uDE44\uDE48-\uDE4A\uDE80-\uDEA2\uDEA4-\uDEB3\uDEB7-\uDEBF\uDEC1-\uDEC5\uDED0-\uDED2\uDED5-\uDED7\uDEDC-\uDEDF\uDEEB\uDEEC\uDEF4-\uDEFC\uDFE0-\uDFEB\uDFF0]|\uDC08(?:\u200D\u2B1B)?|\uDC15(?:\u200D\uD83E\uDDBA)?|\uDC26(?:\u200D(?:\u2B1B|\uD83D\uDD25))?|\uDC3B(?:\u200D\u2744\uFE0F?)?|\uDC41\uFE0F?(?:\u200D\uD83D\uDDE8\uFE0F?)?|\uDC68(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:\uDC8B\u200D\uD83D)?\uDC68|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D(?:[\uDC68\uDC69]\u200D\uD83D(?:\uDC66(?:\u200D\uD83D\uDC66)?|\uDC67(?:\u200D\uD83D[\uDC66\uDC67])?)|[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uDC66(?:\u200D\uD83D\uDC66)?|\uDC67(?:\u200D\uD83D[\uDC66\uDC67])?)|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]))|\uD83C(?:\uDFFB(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:\uDC8B\u200D\uD83D)?\uDC68\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]|\uDD1D\u200D\uD83D\uDC68\uD83C[\uDFFC-\uDFFF])))?|\uDFFC(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:\uDC8B\u200D\uD83D)?\uDC68\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]|\uDD1D\u200D\uD83D\uDC68\uD83C[\uDFFB\uDFFD-\uDFFF])))?|\uDFFD(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:\uDC8B\u200D\uD83D)?\uDC68\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]|\uDD1D\u200D\uD83D\uDC68\uD83C[\uDFFB\uDFFC\uDFFE\uDFFF])))?|\uDFFE(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:\uDC8B\u200D\uD83D)?\uDC68\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]|\uDD1D\u200D\uD83D\uDC68\uD83C[\uDFFB-\uDFFD\uDFFF])))?|\uDFFF(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:\uDC8B\u200D\uD83D)?\uDC68\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]|\uDD1D\u200D\uD83D\uDC68\uD83C[\uDFFB-\uDFFE])))?))?|\uDC69(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:\uDC8B\u200D\uD83D)?[\uDC68\uDC69]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D(?:[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uDC66(?:\u200D\uD83D\uDC66)?|\uDC67(?:\u200D\uD83D[\uDC66\uDC67])?|\uDC69\u200D\uD83D(?:\uDC66(?:\u200D\uD83D\uDC66)?|\uDC67(?:\u200D\uD83D[\uDC66\uDC67])?))|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]))|\uD83C(?:\uDFFB(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:[\uDC68\uDC69]|\uDC8B\u200D\uD83D[\uDC68\uDC69])\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]|\uDD1D\u200D\uD83D[\uDC68\uDC69]\uD83C[\uDFFC-\uDFFF])))?|\uDFFC(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:[\uDC68\uDC69]|\uDC8B\u200D\uD83D[\uDC68\uDC69])\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]|\uDD1D\u200D\uD83D[\uDC68\uDC69]\uD83C[\uDFFB\uDFFD-\uDFFF])))?|\uDFFD(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:[\uDC68\uDC69]|\uDC8B\u200D\uD83D[\uDC68\uDC69])\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]|\uDD1D\u200D\uD83D[\uDC68\uDC69]\uD83C[\uDFFB\uDFFC\uDFFE\uDFFF])))?|\uDFFE(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:[\uDC68\uDC69]|\uDC8B\u200D\uD83D[\uDC68\uDC69])\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]|\uDD1D\u200D\uD83D[\uDC68\uDC69]\uD83C[\uDFFB-\uDFFD\uDFFF])))?|\uDFFF(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:[\uDC68\uDC69]|\uDC8B\u200D\uD83D[\uDC68\uDC69])\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]|\uDD1D\u200D\uD83D[\uDC68\uDC69]\uD83C[\uDFFB-\uDFFE])))?))?|\uDC6F(?:\u200D[\u2640\u2642]\uFE0F?)?|\uDD75(?:\uD83C[\uDFFB-\uDFFF]|\uFE0F)?(?:\u200D[\u2640\u2642]\uFE0F?)?|\uDE2E(?:\u200D\uD83D\uDCA8)?|\uDE35(?:\u200D\uD83D\uDCAB)?|\uDE36(?:\u200D\uD83C\uDF2B\uFE0F?)?|\uDE42(?:\u200D[\u2194\u2195]\uFE0F?)?|\uDEB6(?:\uD83C[\uDFFB-\uDFFF])?(?:\u200D(?:[\u2640\u2642]\uFE0F?(?:\u200D\u27A1\uFE0F?)?|\u27A1\uFE0F?))?)|\uD83E(?:[\uDD0C\uDD0F\uDD18-\uDD1F\uDD30-\uDD34\uDD36\uDD77\uDDB5\uDDB6\uDDBB\uDDD2\uDDD3\uDDD5\uDEC3-\uDEC5\uDEF0\uDEF2-\uDEF8](?:\uD83C[\uDFFB-\uDFFF])?|[\uDD26\uDD35\uDD37-\uDD39\uDD3D\uDD3E\uDDB8\uDDB9\uDDCD\uDDCF\uDDD4\uDDD6-\uDDDD](?:\uD83C[\uDFFB-\uDFFF])?(?:\u200D[\u2640\u2642]\uFE0F?)?|[\uDDDE\uDDDF](?:\u200D[\u2640\u2642]\uFE0F?)?|[\uDD0D\uDD0E\uDD10-\uDD17\uDD20-\uDD25\uDD27-\uDD2F\uDD3A\uDD3F-\uDD45\uDD47-\uDD76\uDD78-\uDDB4\uDDB7\uDDBA\uDDBC-\uDDCC\uDDD0\uDDE0-\uDDFF\uDE70-\uDE7C\uDE80-\uDE89\uDE8F-\uDEC2\uDEC6\uDECE-\uDEDC\uDEDF-\uDEE9]|\uDD3C(?:\u200D[\u2640\u2642]\uFE0F?|\uD83C[\uDFFB-\uDFFF])?|\uDDCE(?:\uD83C[\uDFFB-\uDFFF])?(?:\u200D(?:[\u2640\u2642]\uFE0F?(?:\u200D\u27A1\uFE0F?)?|\u27A1\uFE0F?))?|\uDDD1(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\uD83C[\uDF3E\uDF73\uDF7C\uDF84\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]|\uDD1D\u200D\uD83E\uDDD1|\uDDD1\u200D\uD83E\uDDD2(?:\u200D\uD83E\uDDD2)?|\uDDD2(?:\u200D\uD83E\uDDD2)?))|\uD83C(?:\uDFFB(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D(?:\uD83D\uDC8B\u200D)?\uD83E\uDDD1\uD83C[\uDFFC-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF84\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]|\uDD1D\u200D\uD83E\uDDD1\uD83C[\uDFFB-\uDFFF])))?|\uDFFC(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D(?:\uD83D\uDC8B\u200D)?\uD83E\uDDD1\uD83C[\uDFFB\uDFFD-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF84\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]|\uDD1D\u200D\uD83E\uDDD1\uD83C[\uDFFB-\uDFFF])))?|\uDFFD(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D(?:\uD83D\uDC8B\u200D)?\uD83E\uDDD1\uD83C[\uDFFB\uDFFC\uDFFE\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF84\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]|\uDD1D\u200D\uD83E\uDDD1\uD83C[\uDFFB-\uDFFF])))?|\uDFFE(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D(?:\uD83D\uDC8B\u200D)?\uD83E\uDDD1\uD83C[\uDFFB-\uDFFD\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF84\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]|\uDD1D\u200D\uD83E\uDDD1\uD83C[\uDFFB-\uDFFF])))?|\uDFFF(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D(?:\uD83D\uDC8B\u200D)?\uD83E\uDDD1\uD83C[\uDFFB-\uDFFE]|\uD83C[\uDF3E\uDF73\uDF7C\uDF84\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]|\uDD1D\u200D\uD83E\uDDD1\uD83C[\uDFFB-\uDFFF])))?))?|\uDEF1(?:\uD83C(?:\uDFFB(?:\u200D\uD83E\uDEF2\uD83C[\uDFFC-\uDFFF])?|\uDFFC(?:\u200D\uD83E\uDEF2\uD83C[\uDFFB\uDFFD-\uDFFF])?|\uDFFD(?:\u200D\uD83E\uDEF2\uD83C[\uDFFB\uDFFC\uDFFE\uDFFF])?|\uDFFE(?:\u200D\uD83E\uDEF2\uD83C[\uDFFB-\uDFFD\uDFFF])?|\uDFFF(?:\u200D\uD83E\uDEF2\uD83C[\uDFFB-\uDFFE])?))?)/g; + }; + + // node_modules/get-east-asian-width/lookup.js + function isFullWidth(x) { + return x === 12288 || x >= 65281 && x <= 65376 || x >= 65504 && x <= 65510; + } + function isWide(x) { + return x >= 4352 && x <= 4447 || x === 8986 || x === 8987 || x === 9001 || x === 9002 || x >= 9193 && x <= 9196 || x === 9200 || x === 9203 || x === 9725 || x === 9726 || x === 9748 || x === 9749 || x >= 9776 && x <= 9783 || x >= 9800 && x <= 9811 || x === 9855 || x >= 9866 && x <= 9871 || x === 9875 || x === 9889 || x === 9898 || x === 9899 || x === 9917 || x === 9918 || x === 9924 || x === 9925 || x === 9934 || x === 9940 || x === 9962 || x === 9970 || x === 9971 || x === 9973 || x === 9978 || x === 9981 || x === 9989 || x === 9994 || x === 9995 || x === 10024 || x === 10060 || x === 10062 || x >= 10067 && x <= 10069 || x === 10071 || x >= 10133 && x <= 10135 || x === 10160 || x === 10175 || x === 11035 || x === 11036 || x === 11088 || x === 11093 || x >= 11904 && x <= 11929 || x >= 11931 && x <= 12019 || x >= 12032 && x <= 12245 || x >= 12272 && x <= 12287 || x >= 12289 && x <= 12350 || x >= 12353 && x <= 12438 || x >= 12441 && x <= 12543 || x >= 12549 && x <= 12591 || x >= 12593 && x <= 12686 || x >= 12688 && x <= 12773 || x >= 12783 && x <= 12830 || x >= 12832 && x <= 12871 || x >= 12880 && x <= 42124 || x >= 42128 && x <= 42182 || x >= 43360 && x <= 43388 || x >= 44032 && x <= 55203 || x >= 63744 && x <= 64255 || x >= 65040 && x <= 65049 || x >= 65072 && x <= 65106 || x >= 65108 && x <= 65126 || x >= 65128 && x <= 65131 || x >= 94176 && x <= 94180 || x === 94192 || x === 94193 || x >= 94208 && x <= 100343 || x >= 100352 && x <= 101589 || x >= 101631 && x <= 101640 || x >= 110576 && x <= 110579 || x >= 110581 && x <= 110587 || x === 110589 || x === 110590 || x >= 110592 && x <= 110882 || x === 110898 || x >= 110928 && x <= 110930 || x === 110933 || x >= 110948 && x <= 110951 || x >= 110960 && x <= 111355 || x >= 119552 && x <= 119638 || x >= 119648 && x <= 119670 || x === 126980 || x === 127183 || x === 127374 || x >= 127377 && x <= 127386 || x >= 127488 && x <= 127490 || x >= 127504 && x <= 127547 || x >= 127552 && x <= 127560 || x === 127568 || x === 127569 || x >= 127584 && x <= 127589 || x >= 127744 && x <= 127776 || x >= 127789 && x <= 127797 || x >= 127799 && x <= 127868 || x >= 127870 && x <= 127891 || x >= 127904 && x <= 127946 || x >= 127951 && x <= 127955 || x >= 127968 && x <= 127984 || x === 127988 || x >= 127992 && x <= 128062 || x === 128064 || x >= 128066 && x <= 128252 || x >= 128255 && x <= 128317 || x >= 128331 && x <= 128334 || x >= 128336 && x <= 128359 || x === 128378 || x === 128405 || x === 128406 || x === 128420 || x >= 128507 && x <= 128591 || x >= 128640 && x <= 128709 || x === 128716 || x >= 128720 && x <= 128722 || x >= 128725 && x <= 128727 || x >= 128732 && x <= 128735 || x === 128747 || x === 128748 || x >= 128756 && x <= 128764 || x >= 128992 && x <= 129003 || x === 129008 || x >= 129292 && x <= 129338 || x >= 129340 && x <= 129349 || x >= 129351 && x <= 129535 || x >= 129648 && x <= 129660 || x >= 129664 && x <= 129673 || x >= 129679 && x <= 129734 || x >= 129742 && x <= 129756 || x >= 129759 && x <= 129769 || x >= 129776 && x <= 129784 || x >= 131072 && x <= 196605 || x >= 196608 && x <= 262141; + } + + // node_modules/get-east-asian-width/index.js + var _isNarrowWidth = (codePoint) => !(isFullWidth(codePoint) || isWide(codePoint)); + + // src/utils/get-string-width.js + var notAsciiRegex = /[^\x20-\x7F]/u; + function getStringWidth(text) { + if (!text) { + return 0; + } + if (!notAsciiRegex.test(text)) { + return text.length; + } + text = text.replace(emoji_regex_default(), " "); + let width = 0; + for (const character of text) { + const codePoint = character.codePointAt(0); + if (codePoint <= 31 || codePoint >= 127 && codePoint <= 159) { + continue; + } + if (codePoint >= 768 && codePoint <= 879) { + continue; + } + width += _isNarrowWidth(codePoint) ? 1 : 2; + } + return width; + } + var get_string_width_default = getStringWidth; + + // src/document/printer.js + var MODE_BREAK = Symbol("MODE_BREAK"); + var MODE_FLAT = Symbol("MODE_FLAT"); + var CURSOR_PLACEHOLDER = Symbol("cursor"); + var DOC_FILL_PRINTED_LENGTH = Symbol("DOC_FILL_PRINTED_LENGTH"); + function rootIndent() { + return { value: "", length: 0, queue: [] }; + } + function makeIndent(ind, options) { + return generateInd(ind, { type: "indent" }, options); + } + function makeAlign(indent2, widthOrDoc, options) { + if (widthOrDoc === Number.NEGATIVE_INFINITY) { + return indent2.root || rootIndent(); + } + if (widthOrDoc < 0) { + return generateInd(indent2, { type: "dedent" }, options); + } + if (!widthOrDoc) { + return indent2; + } + if (widthOrDoc.type === "root") { + return { ...indent2, root: indent2 }; + } + const alignType = typeof widthOrDoc === "string" ? "stringAlign" : "numberAlign"; + return generateInd(indent2, { type: alignType, n: widthOrDoc }, options); + } + function generateInd(ind, newPart, options) { + const queue = newPart.type === "dedent" ? ind.queue.slice(0, -1) : [...ind.queue, newPart]; + let value = ""; + let length = 0; + let lastTabs = 0; + let lastSpaces = 0; + for (const part of queue) { + switch (part.type) { + case "indent": + flush(); + if (options.useTabs) { + addTabs(1); + } else { + addSpaces(options.tabWidth); + } + break; + case "stringAlign": + flush(); + value += part.n; + length += part.n.length; + break; + case "numberAlign": + lastTabs += 1; + lastSpaces += part.n; + break; + default: + throw new Error(`Unexpected type '${part.type}'`); + } + } + flushSpaces(); + return { ...ind, value, length, queue }; + function addTabs(count) { + value += " ".repeat(count); + length += options.tabWidth * count; + } + function addSpaces(count) { + value += " ".repeat(count); + length += count; + } + function flush() { + if (options.useTabs) { + flushTabs(); + } else { + flushSpaces(); + } + } + function flushTabs() { + if (lastTabs > 0) { + addTabs(lastTabs); + } + resetLast(); + } + function flushSpaces() { + if (lastSpaces > 0) { + addSpaces(lastSpaces); + } + resetLast(); + } + function resetLast() { + lastTabs = 0; + lastSpaces = 0; + } + } + function trim2(out) { + let trimCount = 0; + let cursorCount = 0; + let outIndex = out.length; + outer: while (outIndex--) { + const last = out[outIndex]; + if (last === CURSOR_PLACEHOLDER) { + cursorCount++; + continue; + } + if (false) { + throw new Error(`Unexpected value in trim: '${typeof last}'`); + } + for (let charIndex = last.length - 1; charIndex >= 0; charIndex--) { + const char = last[charIndex]; + if (char === " " || char === " ") { + trimCount++; + } else { + out[outIndex] = last.slice(0, charIndex + 1); + break outer; + } + } + } + if (trimCount > 0 || cursorCount > 0) { + out.length = outIndex + 1; + while (cursorCount-- > 0) { + out.push(CURSOR_PLACEHOLDER); + } + } + return trimCount; + } + function fits(next, restCommands, width, hasLineSuffix, groupModeMap, mustBeFlat) { + if (width === Number.POSITIVE_INFINITY) { + return true; + } + let restIdx = restCommands.length; + const cmds = [next]; + const out = []; + while (width >= 0) { + if (cmds.length === 0) { + if (restIdx === 0) { + return true; + } + cmds.push(restCommands[--restIdx]); + continue; + } + const { mode, doc } = cmds.pop(); + const docType = get_doc_type_default(doc); + switch (docType) { + case DOC_TYPE_STRING: + out.push(doc); + width -= get_string_width_default(doc); + break; + case DOC_TYPE_ARRAY: + case DOC_TYPE_FILL: { + const parts = docType === DOC_TYPE_ARRAY ? doc : doc.parts; + const end = doc[DOC_FILL_PRINTED_LENGTH] ?? 0; + for (let i = parts.length - 1; i >= end; i--) { + cmds.push({ mode, doc: parts[i] }); + } + break; + } + case DOC_TYPE_INDENT: + case DOC_TYPE_ALIGN: + case DOC_TYPE_INDENT_IF_BREAK: + case DOC_TYPE_LABEL: + cmds.push({ mode, doc: doc.contents }); + break; + case DOC_TYPE_TRIM: + width += trim2(out); + break; + case DOC_TYPE_GROUP: { + if (mustBeFlat && doc.break) { + return false; + } + const groupMode = doc.break ? MODE_BREAK : mode; + const contents = doc.expandedStates && groupMode === MODE_BREAK ? at_default( + /* isOptionalObject */ + false, + doc.expandedStates, + -1 + ) : doc.contents; + cmds.push({ mode: groupMode, doc: contents }); + break; + } + case DOC_TYPE_IF_BREAK: { + const groupMode = doc.groupId ? groupModeMap[doc.groupId] || MODE_FLAT : mode; + const contents = groupMode === MODE_BREAK ? doc.breakContents : doc.flatContents; + if (contents) { + cmds.push({ mode, doc: contents }); + } + break; + } + case DOC_TYPE_LINE: + if (mode === MODE_BREAK || doc.hard) { + return true; + } + if (!doc.soft) { + out.push(" "); + width--; + } + break; + case DOC_TYPE_LINE_SUFFIX: + hasLineSuffix = true; + break; + case DOC_TYPE_LINE_SUFFIX_BOUNDARY: + if (hasLineSuffix) { + return false; + } + break; + } + } + return false; + } + function printDocToString(doc, options) { + const groupModeMap = {}; + const width = options.printWidth; + const newLine = convertEndOfLineToChars(options.endOfLine); + let pos = 0; + const cmds = [{ ind: rootIndent(), mode: MODE_BREAK, doc }]; + const out = []; + let shouldRemeasure = false; + const lineSuffix2 = []; + let printedCursorCount = 0; + propagateBreaks(doc); + while (cmds.length > 0) { + const { ind, mode, doc: doc2 } = cmds.pop(); + switch (get_doc_type_default(doc2)) { + case DOC_TYPE_STRING: { + const formatted = newLine !== "\n" ? string_replace_all_default( + /* isOptionalObject */ + false, + doc2, + "\n", + newLine + ) : doc2; + out.push(formatted); + if (cmds.length > 0) { + pos += get_string_width_default(formatted); + } + break; + } + case DOC_TYPE_ARRAY: + for (let i = doc2.length - 1; i >= 0; i--) { + cmds.push({ ind, mode, doc: doc2[i] }); + } + break; + case DOC_TYPE_CURSOR: + if (printedCursorCount >= 2) { + throw new Error("There are too many 'cursor' in doc."); + } + out.push(CURSOR_PLACEHOLDER); + printedCursorCount++; + break; + case DOC_TYPE_INDENT: + cmds.push({ ind: makeIndent(ind, options), mode, doc: doc2.contents }); + break; + case DOC_TYPE_ALIGN: + cmds.push({ + ind: makeAlign(ind, doc2.n, options), + mode, + doc: doc2.contents + }); + break; + case DOC_TYPE_TRIM: + pos -= trim2(out); + break; + case DOC_TYPE_GROUP: + switch (mode) { + case MODE_FLAT: + if (!shouldRemeasure) { + cmds.push({ + ind, + mode: doc2.break ? MODE_BREAK : MODE_FLAT, + doc: doc2.contents + }); + break; + } + // fallthrough + case MODE_BREAK: { + shouldRemeasure = false; + const next = { ind, mode: MODE_FLAT, doc: doc2.contents }; + const rem = width - pos; + const hasLineSuffix = lineSuffix2.length > 0; + if (!doc2.break && fits(next, cmds, rem, hasLineSuffix, groupModeMap)) { + cmds.push(next); + } else { + if (doc2.expandedStates) { + const mostExpanded = at_default( + /* isOptionalObject */ + false, + doc2.expandedStates, + -1 + ); + if (doc2.break) { + cmds.push({ ind, mode: MODE_BREAK, doc: mostExpanded }); + break; + } else { + for (let i = 1; i < doc2.expandedStates.length + 1; i++) { + if (i >= doc2.expandedStates.length) { + cmds.push({ ind, mode: MODE_BREAK, doc: mostExpanded }); + break; + } else { + const state = doc2.expandedStates[i]; + const cmd = { ind, mode: MODE_FLAT, doc: state }; + if (fits(cmd, cmds, rem, hasLineSuffix, groupModeMap)) { + cmds.push(cmd); + break; + } + } + } + } + } else { + cmds.push({ ind, mode: MODE_BREAK, doc: doc2.contents }); + } + } + break; + } + } + if (doc2.id) { + groupModeMap[doc2.id] = at_default( + /* isOptionalObject */ + false, + cmds, + -1 + ).mode; + } + break; + // Fills each line with as much code as possible before moving to a new + // line with the same indentation. + // + // Expects doc.parts to be an array of alternating content and + // whitespace. The whitespace contains the linebreaks. + // + // For example: + // ["I", line, "love", line, "monkeys"] + // or + // [{ type: group, ... }, softline, { type: group, ... }] + // + // It uses this parts structure to handle three main layout cases: + // * The first two content items fit on the same line without + // breaking + // -> output the first content item and the whitespace "flat". + // * Only the first content item fits on the line without breaking + // -> output the first content item "flat" and the whitespace with + // "break". + // * Neither content item fits on the line without breaking + // -> output the first content item and the whitespace with "break". + case DOC_TYPE_FILL: { + const rem = width - pos; + const offset = doc2[DOC_FILL_PRINTED_LENGTH] ?? 0; + const { parts } = doc2; + const length = parts.length - offset; + if (length === 0) { + break; + } + const content = parts[offset + 0]; + const whitespace = parts[offset + 1]; + const contentFlatCmd = { ind, mode: MODE_FLAT, doc: content }; + const contentBreakCmd = { ind, mode: MODE_BREAK, doc: content }; + const contentFits = fits( + contentFlatCmd, + [], + rem, + lineSuffix2.length > 0, + groupModeMap, + true + ); + if (length === 1) { + if (contentFits) { + cmds.push(contentFlatCmd); + } else { + cmds.push(contentBreakCmd); + } + break; + } + const whitespaceFlatCmd = { ind, mode: MODE_FLAT, doc: whitespace }; + const whitespaceBreakCmd = { ind, mode: MODE_BREAK, doc: whitespace }; + if (length === 2) { + if (contentFits) { + cmds.push(whitespaceFlatCmd, contentFlatCmd); + } else { + cmds.push(whitespaceBreakCmd, contentBreakCmd); + } + break; + } + const secondContent = parts[offset + 2]; + const remainingCmd = { + ind, + mode, + doc: { ...doc2, [DOC_FILL_PRINTED_LENGTH]: offset + 2 } + }; + const firstAndSecondContentFlatCmd = { + ind, + mode: MODE_FLAT, + doc: [content, whitespace, secondContent] + }; + const firstAndSecondContentFits = fits( + firstAndSecondContentFlatCmd, + [], + rem, + lineSuffix2.length > 0, + groupModeMap, + true + ); + if (firstAndSecondContentFits) { + cmds.push(remainingCmd, whitespaceFlatCmd, contentFlatCmd); + } else if (contentFits) { + cmds.push(remainingCmd, whitespaceBreakCmd, contentFlatCmd); + } else { + cmds.push(remainingCmd, whitespaceBreakCmd, contentBreakCmd); + } + break; + } + case DOC_TYPE_IF_BREAK: + case DOC_TYPE_INDENT_IF_BREAK: { + const groupMode = doc2.groupId ? groupModeMap[doc2.groupId] : mode; + if (groupMode === MODE_BREAK) { + const breakContents = doc2.type === DOC_TYPE_IF_BREAK ? doc2.breakContents : doc2.negate ? doc2.contents : indent(doc2.contents); + if (breakContents) { + cmds.push({ ind, mode, doc: breakContents }); + } + } + if (groupMode === MODE_FLAT) { + const flatContents = doc2.type === DOC_TYPE_IF_BREAK ? doc2.flatContents : doc2.negate ? indent(doc2.contents) : doc2.contents; + if (flatContents) { + cmds.push({ ind, mode, doc: flatContents }); + } + } + break; + } + case DOC_TYPE_LINE_SUFFIX: + lineSuffix2.push({ ind, mode, doc: doc2.contents }); + break; + case DOC_TYPE_LINE_SUFFIX_BOUNDARY: + if (lineSuffix2.length > 0) { + cmds.push({ ind, mode, doc: hardlineWithoutBreakParent }); + } + break; + case DOC_TYPE_LINE: + switch (mode) { + case MODE_FLAT: + if (!doc2.hard) { + if (!doc2.soft) { + out.push(" "); + pos += 1; + } + break; + } else { + shouldRemeasure = true; + } + // fallthrough + case MODE_BREAK: + if (lineSuffix2.length > 0) { + cmds.push({ ind, mode, doc: doc2 }, ...lineSuffix2.reverse()); + lineSuffix2.length = 0; + break; + } + if (doc2.literal) { + if (ind.root) { + out.push(newLine, ind.root.value); + pos = ind.root.length; + } else { + out.push(newLine); + pos = 0; + } + } else { + pos -= trim2(out); + out.push(newLine + ind.value); + pos = ind.length; + } + break; + } + break; + case DOC_TYPE_LABEL: + cmds.push({ ind, mode, doc: doc2.contents }); + break; + case DOC_TYPE_BREAK_PARENT: + break; + default: + throw new invalid_doc_error_default(doc2); + } + if (cmds.length === 0 && lineSuffix2.length > 0) { + cmds.push(...lineSuffix2.reverse()); + lineSuffix2.length = 0; + } + } + const cursorPlaceholderIndex = out.indexOf(CURSOR_PLACEHOLDER); + if (cursorPlaceholderIndex !== -1) { + const otherCursorPlaceholderIndex = out.indexOf( + CURSOR_PLACEHOLDER, + cursorPlaceholderIndex + 1 + ); + if (otherCursorPlaceholderIndex === -1) { + return { + formatted: out.filter((char) => char !== CURSOR_PLACEHOLDER).join("") + }; + } + const beforeCursor = out.slice(0, cursorPlaceholderIndex).join(""); + const aroundCursor = out.slice(cursorPlaceholderIndex + 1, otherCursorPlaceholderIndex).join(""); + const afterCursor = out.slice(otherCursorPlaceholderIndex + 1).join(""); + return { + formatted: beforeCursor + aroundCursor + afterCursor, + cursorNodeStart: beforeCursor.length, + cursorNodeText: aroundCursor + }; + } + return { formatted: out.join("") }; + } + + // src/document/public.js + var builders = { + join, + line, + softline, + hardline, + literalline, + group, + conditionalGroup, + fill, + lineSuffix, + lineSuffixBoundary, + cursor, + breakParent, + ifBreak, + trim, + indent, + indentIfBreak, + align, + addAlignmentToDoc, + markAsRoot, + dedentToRoot, + dedent, + hardlineWithoutBreakParent, + literallineWithoutBreakParent, + label, + // TODO: Remove this in v4 + concat: (parts) => parts + }; + var printer = { printDocToString }; + var utils = { + willBreak, + traverseDoc: traverse_doc_default, + findInDoc, + mapDoc, + removeLines, + stripTrailingHardline, + replaceEndOfLine, + canBreak + }; + return __toCommonJS(public_exports); +}); \ No newline at end of file diff --git a/node_modules/prettier/doc.mjs b/node_modules/prettier/doc.mjs new file mode 100644 index 0000000..6f0c81c --- /dev/null +++ b/node_modules/prettier/doc.mjs @@ -0,0 +1,1233 @@ +var __defProp = Object.defineProperty; +var __export = (target, all) => { + for (var name in all) + __defProp(target, name, { get: all[name], enumerable: true }); +}; + +// src/document/public.js +var public_exports = {}; +__export(public_exports, { + builders: () => builders, + printer: () => printer, + utils: () => utils +}); + +// src/document/constants.js +var DOC_TYPE_STRING = "string"; +var DOC_TYPE_ARRAY = "array"; +var DOC_TYPE_CURSOR = "cursor"; +var DOC_TYPE_INDENT = "indent"; +var DOC_TYPE_ALIGN = "align"; +var DOC_TYPE_TRIM = "trim"; +var DOC_TYPE_GROUP = "group"; +var DOC_TYPE_FILL = "fill"; +var DOC_TYPE_IF_BREAK = "if-break"; +var DOC_TYPE_INDENT_IF_BREAK = "indent-if-break"; +var DOC_TYPE_LINE_SUFFIX = "line-suffix"; +var DOC_TYPE_LINE_SUFFIX_BOUNDARY = "line-suffix-boundary"; +var DOC_TYPE_LINE = "line"; +var DOC_TYPE_LABEL = "label"; +var DOC_TYPE_BREAK_PARENT = "break-parent"; +var VALID_OBJECT_DOC_TYPES = /* @__PURE__ */ new Set([ + DOC_TYPE_CURSOR, + DOC_TYPE_INDENT, + DOC_TYPE_ALIGN, + DOC_TYPE_TRIM, + DOC_TYPE_GROUP, + DOC_TYPE_FILL, + DOC_TYPE_IF_BREAK, + DOC_TYPE_INDENT_IF_BREAK, + DOC_TYPE_LINE_SUFFIX, + DOC_TYPE_LINE_SUFFIX_BOUNDARY, + DOC_TYPE_LINE, + DOC_TYPE_LABEL, + DOC_TYPE_BREAK_PARENT +]); + +// scripts/build/shims/at.js +var at = (isOptionalObject, object, index) => { + if (isOptionalObject && (object === void 0 || object === null)) { + return; + } + if (Array.isArray(object) || typeof object === "string") { + return object[index < 0 ? object.length + index : index]; + } + return object.at(index); +}; +var at_default = at; + +// src/document/utils/get-doc-type.js +function getDocType(doc) { + if (typeof doc === "string") { + return DOC_TYPE_STRING; + } + if (Array.isArray(doc)) { + return DOC_TYPE_ARRAY; + } + if (!doc) { + return; + } + const { type } = doc; + if (VALID_OBJECT_DOC_TYPES.has(type)) { + return type; + } +} +var get_doc_type_default = getDocType; + +// src/document/invalid-doc-error.js +var disjunctionListFormat = (list) => new Intl.ListFormat("en-US", { type: "disjunction" }).format(list); +function getDocErrorMessage(doc) { + const type = doc === null ? "null" : typeof doc; + if (type !== "string" && type !== "object") { + return `Unexpected doc '${type}', +Expected it to be 'string' or 'object'.`; + } + if (get_doc_type_default(doc)) { + throw new Error("doc is valid."); + } + const objectType = Object.prototype.toString.call(doc); + if (objectType !== "[object Object]") { + return `Unexpected doc '${objectType}'.`; + } + const EXPECTED_TYPE_VALUES = disjunctionListFormat( + [...VALID_OBJECT_DOC_TYPES].map((type2) => `'${type2}'`) + ); + return `Unexpected doc.type '${doc.type}'. +Expected it to be ${EXPECTED_TYPE_VALUES}.`; +} +var InvalidDocError = class extends Error { + name = "InvalidDocError"; + constructor(doc) { + super(getDocErrorMessage(doc)); + this.doc = doc; + } +}; +var invalid_doc_error_default = InvalidDocError; + +// src/document/utils/traverse-doc.js +var traverseDocOnExitStackMarker = {}; +function traverseDoc(doc, onEnter, onExit, shouldTraverseConditionalGroups) { + const docsStack = [doc]; + while (docsStack.length > 0) { + const doc2 = docsStack.pop(); + if (doc2 === traverseDocOnExitStackMarker) { + onExit(docsStack.pop()); + continue; + } + if (onExit) { + docsStack.push(doc2, traverseDocOnExitStackMarker); + } + const docType = get_doc_type_default(doc2); + if (!docType) { + throw new invalid_doc_error_default(doc2); + } + if ((onEnter == null ? void 0 : onEnter(doc2)) === false) { + continue; + } + switch (docType) { + case DOC_TYPE_ARRAY: + case DOC_TYPE_FILL: { + const parts = docType === DOC_TYPE_ARRAY ? doc2 : doc2.parts; + for (let ic = parts.length, i = ic - 1; i >= 0; --i) { + docsStack.push(parts[i]); + } + break; + } + case DOC_TYPE_IF_BREAK: + docsStack.push(doc2.flatContents, doc2.breakContents); + break; + case DOC_TYPE_GROUP: + if (shouldTraverseConditionalGroups && doc2.expandedStates) { + for (let ic = doc2.expandedStates.length, i = ic - 1; i >= 0; --i) { + docsStack.push(doc2.expandedStates[i]); + } + } else { + docsStack.push(doc2.contents); + } + break; + case DOC_TYPE_ALIGN: + case DOC_TYPE_INDENT: + case DOC_TYPE_INDENT_IF_BREAK: + case DOC_TYPE_LABEL: + case DOC_TYPE_LINE_SUFFIX: + docsStack.push(doc2.contents); + break; + case DOC_TYPE_STRING: + case DOC_TYPE_CURSOR: + case DOC_TYPE_TRIM: + case DOC_TYPE_LINE_SUFFIX_BOUNDARY: + case DOC_TYPE_LINE: + case DOC_TYPE_BREAK_PARENT: + break; + default: + throw new invalid_doc_error_default(doc2); + } + } +} +var traverse_doc_default = traverseDoc; + +// src/document/utils.js +function mapDoc(doc, cb) { + if (typeof doc === "string") { + return cb(doc); + } + const mapped = /* @__PURE__ */ new Map(); + return rec(doc); + function rec(doc2) { + if (mapped.has(doc2)) { + return mapped.get(doc2); + } + const result = process2(doc2); + mapped.set(doc2, result); + return result; + } + function process2(doc2) { + switch (get_doc_type_default(doc2)) { + case DOC_TYPE_ARRAY: + return cb(doc2.map(rec)); + case DOC_TYPE_FILL: + return cb({ ...doc2, parts: doc2.parts.map(rec) }); + case DOC_TYPE_IF_BREAK: + return cb({ + ...doc2, + breakContents: rec(doc2.breakContents), + flatContents: rec(doc2.flatContents) + }); + case DOC_TYPE_GROUP: { + let { expandedStates, contents } = doc2; + if (expandedStates) { + expandedStates = expandedStates.map(rec); + contents = expandedStates[0]; + } else { + contents = rec(contents); + } + return cb({ ...doc2, contents, expandedStates }); + } + case DOC_TYPE_ALIGN: + case DOC_TYPE_INDENT: + case DOC_TYPE_INDENT_IF_BREAK: + case DOC_TYPE_LABEL: + case DOC_TYPE_LINE_SUFFIX: + return cb({ ...doc2, contents: rec(doc2.contents) }); + case DOC_TYPE_STRING: + case DOC_TYPE_CURSOR: + case DOC_TYPE_TRIM: + case DOC_TYPE_LINE_SUFFIX_BOUNDARY: + case DOC_TYPE_LINE: + case DOC_TYPE_BREAK_PARENT: + return cb(doc2); + default: + throw new invalid_doc_error_default(doc2); + } + } +} +function findInDoc(doc, fn, defaultValue) { + let result = defaultValue; + let shouldSkipFurtherProcessing = false; + function findInDocOnEnterFn(doc2) { + if (shouldSkipFurtherProcessing) { + return false; + } + const maybeResult = fn(doc2); + if (maybeResult !== void 0) { + shouldSkipFurtherProcessing = true; + result = maybeResult; + } + } + traverse_doc_default(doc, findInDocOnEnterFn); + return result; +} +function willBreakFn(doc) { + if (doc.type === DOC_TYPE_GROUP && doc.break) { + return true; + } + if (doc.type === DOC_TYPE_LINE && doc.hard) { + return true; + } + if (doc.type === DOC_TYPE_BREAK_PARENT) { + return true; + } +} +function willBreak(doc) { + return findInDoc(doc, willBreakFn, false); +} +function breakParentGroup(groupStack) { + if (groupStack.length > 0) { + const parentGroup = at_default( + /* isOptionalObject */ + false, + groupStack, + -1 + ); + if (!parentGroup.expandedStates && !parentGroup.break) { + parentGroup.break = "propagated"; + } + } + return null; +} +function propagateBreaks(doc) { + const alreadyVisitedSet = /* @__PURE__ */ new Set(); + const groupStack = []; + function propagateBreaksOnEnterFn(doc2) { + if (doc2.type === DOC_TYPE_BREAK_PARENT) { + breakParentGroup(groupStack); + } + if (doc2.type === DOC_TYPE_GROUP) { + groupStack.push(doc2); + if (alreadyVisitedSet.has(doc2)) { + return false; + } + alreadyVisitedSet.add(doc2); + } + } + function propagateBreaksOnExitFn(doc2) { + if (doc2.type === DOC_TYPE_GROUP) { + const group2 = groupStack.pop(); + if (group2.break) { + breakParentGroup(groupStack); + } + } + } + traverse_doc_default( + doc, + propagateBreaksOnEnterFn, + propagateBreaksOnExitFn, + /* shouldTraverseConditionalGroups */ + true + ); +} +function removeLinesFn(doc) { + if (doc.type === DOC_TYPE_LINE && !doc.hard) { + return doc.soft ? "" : " "; + } + if (doc.type === DOC_TYPE_IF_BREAK) { + return doc.flatContents; + } + return doc; +} +function removeLines(doc) { + return mapDoc(doc, removeLinesFn); +} +function stripTrailingHardlineFromParts(parts) { + parts = [...parts]; + while (parts.length >= 2 && at_default( + /* isOptionalObject */ + false, + parts, + -2 + ).type === DOC_TYPE_LINE && at_default( + /* isOptionalObject */ + false, + parts, + -1 + ).type === DOC_TYPE_BREAK_PARENT) { + parts.length -= 2; + } + if (parts.length > 0) { + const lastPart = stripTrailingHardlineFromDoc(at_default( + /* isOptionalObject */ + false, + parts, + -1 + )); + parts[parts.length - 1] = lastPart; + } + return parts; +} +function stripTrailingHardlineFromDoc(doc) { + switch (get_doc_type_default(doc)) { + case DOC_TYPE_INDENT: + case DOC_TYPE_INDENT_IF_BREAK: + case DOC_TYPE_GROUP: + case DOC_TYPE_LINE_SUFFIX: + case DOC_TYPE_LABEL: { + const contents = stripTrailingHardlineFromDoc(doc.contents); + return { ...doc, contents }; + } + case DOC_TYPE_IF_BREAK: + return { + ...doc, + breakContents: stripTrailingHardlineFromDoc(doc.breakContents), + flatContents: stripTrailingHardlineFromDoc(doc.flatContents) + }; + case DOC_TYPE_FILL: + return { ...doc, parts: stripTrailingHardlineFromParts(doc.parts) }; + case DOC_TYPE_ARRAY: + return stripTrailingHardlineFromParts(doc); + case DOC_TYPE_STRING: + return doc.replace(/[\n\r]*$/u, ""); + case DOC_TYPE_ALIGN: + case DOC_TYPE_CURSOR: + case DOC_TYPE_TRIM: + case DOC_TYPE_LINE_SUFFIX_BOUNDARY: + case DOC_TYPE_LINE: + case DOC_TYPE_BREAK_PARENT: + break; + default: + throw new invalid_doc_error_default(doc); + } + return doc; +} +function stripTrailingHardline(doc) { + return stripTrailingHardlineFromDoc(cleanDoc(doc)); +} +function cleanDocFn(doc) { + switch (get_doc_type_default(doc)) { + case DOC_TYPE_FILL: + if (doc.parts.every((part) => part === "")) { + return ""; + } + break; + case DOC_TYPE_GROUP: + if (!doc.contents && !doc.id && !doc.break && !doc.expandedStates) { + return ""; + } + if (doc.contents.type === DOC_TYPE_GROUP && doc.contents.id === doc.id && doc.contents.break === doc.break && doc.contents.expandedStates === doc.expandedStates) { + return doc.contents; + } + break; + case DOC_TYPE_ALIGN: + case DOC_TYPE_INDENT: + case DOC_TYPE_INDENT_IF_BREAK: + case DOC_TYPE_LINE_SUFFIX: + if (!doc.contents) { + return ""; + } + break; + case DOC_TYPE_IF_BREAK: + if (!doc.flatContents && !doc.breakContents) { + return ""; + } + break; + case DOC_TYPE_ARRAY: { + const parts = []; + for (const part of doc) { + if (!part) { + continue; + } + const [currentPart, ...restParts] = Array.isArray(part) ? part : [part]; + if (typeof currentPart === "string" && typeof at_default( + /* isOptionalObject */ + false, + parts, + -1 + ) === "string") { + parts[parts.length - 1] += currentPart; + } else { + parts.push(currentPart); + } + parts.push(...restParts); + } + if (parts.length === 0) { + return ""; + } + if (parts.length === 1) { + return parts[0]; + } + return parts; + } + case DOC_TYPE_STRING: + case DOC_TYPE_CURSOR: + case DOC_TYPE_TRIM: + case DOC_TYPE_LINE_SUFFIX_BOUNDARY: + case DOC_TYPE_LINE: + case DOC_TYPE_LABEL: + case DOC_TYPE_BREAK_PARENT: + break; + default: + throw new invalid_doc_error_default(doc); + } + return doc; +} +function cleanDoc(doc) { + return mapDoc(doc, (currentDoc) => cleanDocFn(currentDoc)); +} +function replaceEndOfLine(doc, replacement = literalline) { + return mapDoc( + doc, + (currentDoc) => typeof currentDoc === "string" ? join(replacement, currentDoc.split("\n")) : currentDoc + ); +} +function canBreakFn(doc) { + if (doc.type === DOC_TYPE_LINE) { + return true; + } +} +function canBreak(doc) { + return findInDoc(doc, canBreakFn, false); +} + +// src/document/utils/assert-doc.js +var noop = () => { +}; +var assertDoc = true ? noop : function(doc) { + traverse_doc_default(doc, (doc2) => { + if (checked.has(doc2)) { + return false; + } + if (typeof doc2 !== "string") { + checked.add(doc2); + } + }); +}; +var assertDocArray = true ? noop : function(docs, optional = false) { + if (optional && !docs) { + return; + } + if (!Array.isArray(docs)) { + throw new TypeError("Unexpected doc array."); + } + for (const doc of docs) { + assertDoc(doc); + } +}; +var assertDocFillParts = true ? noop : ( + /** + * @param {Doc[]} parts + */ + function(parts) { + assertDocArray(parts); + if (parts.length > 1 && isEmptyDoc(at_default( + /* isOptionalObject */ + false, + parts, + -1 + ))) { + parts = parts.slice(0, -1); + } + for (const [i, doc] of parts.entries()) { + if (i % 2 === 1 && !isValidSeparator(doc)) { + const type = get_doc_type_default(doc); + throw new Error( + `Unexpected non-line-break doc at ${i}. Doc type is ${type}.` + ); + } + } + } +); + +// src/document/builders.js +function indent(contents) { + assertDoc(contents); + return { type: DOC_TYPE_INDENT, contents }; +} +function align(widthOrString, contents) { + assertDoc(contents); + return { type: DOC_TYPE_ALIGN, contents, n: widthOrString }; +} +function group(contents, opts = {}) { + assertDoc(contents); + assertDocArray( + opts.expandedStates, + /* optional */ + true + ); + return { + type: DOC_TYPE_GROUP, + id: opts.id, + contents, + break: Boolean(opts.shouldBreak), + expandedStates: opts.expandedStates + }; +} +function dedentToRoot(contents) { + return align(Number.NEGATIVE_INFINITY, contents); +} +function markAsRoot(contents) { + return align({ type: "root" }, contents); +} +function dedent(contents) { + return align(-1, contents); +} +function conditionalGroup(states, opts) { + return group(states[0], { ...opts, expandedStates: states }); +} +function fill(parts) { + assertDocFillParts(parts); + return { type: DOC_TYPE_FILL, parts }; +} +function ifBreak(breakContents, flatContents = "", opts = {}) { + assertDoc(breakContents); + if (flatContents !== "") { + assertDoc(flatContents); + } + return { + type: DOC_TYPE_IF_BREAK, + breakContents, + flatContents, + groupId: opts.groupId + }; +} +function indentIfBreak(contents, opts) { + assertDoc(contents); + return { + type: DOC_TYPE_INDENT_IF_BREAK, + contents, + groupId: opts.groupId, + negate: opts.negate + }; +} +function lineSuffix(contents) { + assertDoc(contents); + return { type: DOC_TYPE_LINE_SUFFIX, contents }; +} +var lineSuffixBoundary = { type: DOC_TYPE_LINE_SUFFIX_BOUNDARY }; +var breakParent = { type: DOC_TYPE_BREAK_PARENT }; +var trim = { type: DOC_TYPE_TRIM }; +var hardlineWithoutBreakParent = { type: DOC_TYPE_LINE, hard: true }; +var literallineWithoutBreakParent = { + type: DOC_TYPE_LINE, + hard: true, + literal: true +}; +var line = { type: DOC_TYPE_LINE }; +var softline = { type: DOC_TYPE_LINE, soft: true }; +var hardline = [hardlineWithoutBreakParent, breakParent]; +var literalline = [literallineWithoutBreakParent, breakParent]; +var cursor = { type: DOC_TYPE_CURSOR }; +function join(separator, docs) { + assertDoc(separator); + assertDocArray(docs); + const parts = []; + for (let i = 0; i < docs.length; i++) { + if (i !== 0) { + parts.push(separator); + } + parts.push(docs[i]); + } + return parts; +} +function addAlignmentToDoc(doc, size, tabWidth) { + assertDoc(doc); + let aligned = doc; + if (size > 0) { + for (let i = 0; i < Math.floor(size / tabWidth); ++i) { + aligned = indent(aligned); + } + aligned = align(size % tabWidth, aligned); + aligned = align(Number.NEGATIVE_INFINITY, aligned); + } + return aligned; +} +function label(label2, contents) { + assertDoc(contents); + return label2 ? { type: DOC_TYPE_LABEL, label: label2, contents } : contents; +} + +// scripts/build/shims/string-replace-all.js +var stringReplaceAll = (isOptionalObject, original, pattern, replacement) => { + if (isOptionalObject && (original === void 0 || original === null)) { + return; + } + if (original.replaceAll) { + return original.replaceAll(pattern, replacement); + } + if (pattern.global) { + return original.replace(pattern, replacement); + } + return original.split(pattern).join(replacement); +}; +var string_replace_all_default = stringReplaceAll; + +// src/common/end-of-line.js +function convertEndOfLineToChars(value) { + switch (value) { + case "cr": + return "\r"; + case "crlf": + return "\r\n"; + default: + return "\n"; + } +} + +// node_modules/emoji-regex/index.mjs +var emoji_regex_default = () => { + return /[#*0-9]\uFE0F?\u20E3|[\xA9\xAE\u203C\u2049\u2122\u2139\u2194-\u2199\u21A9\u21AA\u231A\u231B\u2328\u23CF\u23ED-\u23EF\u23F1\u23F2\u23F8-\u23FA\u24C2\u25AA\u25AB\u25B6\u25C0\u25FB\u25FC\u25FE\u2600-\u2604\u260E\u2611\u2614\u2615\u2618\u2620\u2622\u2623\u2626\u262A\u262E\u262F\u2638-\u263A\u2640\u2642\u2648-\u2653\u265F\u2660\u2663\u2665\u2666\u2668\u267B\u267E\u267F\u2692\u2694-\u2697\u2699\u269B\u269C\u26A0\u26A7\u26AA\u26B0\u26B1\u26BD\u26BE\u26C4\u26C8\u26CF\u26D1\u26E9\u26F0-\u26F5\u26F7\u26F8\u26FA\u2702\u2708\u2709\u270F\u2712\u2714\u2716\u271D\u2721\u2733\u2734\u2744\u2747\u2757\u2763\u27A1\u2934\u2935\u2B05-\u2B07\u2B1B\u2B1C\u2B55\u3030\u303D\u3297\u3299]\uFE0F?|[\u261D\u270C\u270D](?:\uD83C[\uDFFB-\uDFFF]|\uFE0F)?|[\u270A\u270B](?:\uD83C[\uDFFB-\uDFFF])?|[\u23E9-\u23EC\u23F0\u23F3\u25FD\u2693\u26A1\u26AB\u26C5\u26CE\u26D4\u26EA\u26FD\u2705\u2728\u274C\u274E\u2753-\u2755\u2795-\u2797\u27B0\u27BF\u2B50]|\u26D3\uFE0F?(?:\u200D\uD83D\uDCA5)?|\u26F9(?:\uD83C[\uDFFB-\uDFFF]|\uFE0F)?(?:\u200D[\u2640\u2642]\uFE0F?)?|\u2764\uFE0F?(?:\u200D(?:\uD83D\uDD25|\uD83E\uDE79))?|\uD83C(?:[\uDC04\uDD70\uDD71\uDD7E\uDD7F\uDE02\uDE37\uDF21\uDF24-\uDF2C\uDF36\uDF7D\uDF96\uDF97\uDF99-\uDF9B\uDF9E\uDF9F\uDFCD\uDFCE\uDFD4-\uDFDF\uDFF5\uDFF7]\uFE0F?|[\uDF85\uDFC2\uDFC7](?:\uD83C[\uDFFB-\uDFFF])?|[\uDFC4\uDFCA](?:\uD83C[\uDFFB-\uDFFF])?(?:\u200D[\u2640\u2642]\uFE0F?)?|[\uDFCB\uDFCC](?:\uD83C[\uDFFB-\uDFFF]|\uFE0F)?(?:\u200D[\u2640\u2642]\uFE0F?)?|[\uDCCF\uDD8E\uDD91-\uDD9A\uDE01\uDE1A\uDE2F\uDE32-\uDE36\uDE38-\uDE3A\uDE50\uDE51\uDF00-\uDF20\uDF2D-\uDF35\uDF37-\uDF43\uDF45-\uDF4A\uDF4C-\uDF7C\uDF7E-\uDF84\uDF86-\uDF93\uDFA0-\uDFC1\uDFC5\uDFC6\uDFC8\uDFC9\uDFCF-\uDFD3\uDFE0-\uDFF0\uDFF8-\uDFFF]|\uDDE6\uD83C[\uDDE8-\uDDEC\uDDEE\uDDF1\uDDF2\uDDF4\uDDF6-\uDDFA\uDDFC\uDDFD\uDDFF]|\uDDE7\uD83C[\uDDE6\uDDE7\uDDE9-\uDDEF\uDDF1-\uDDF4\uDDF6-\uDDF9\uDDFB\uDDFC\uDDFE\uDDFF]|\uDDE8\uD83C[\uDDE6\uDDE8\uDDE9\uDDEB-\uDDEE\uDDF0-\uDDF7\uDDFA-\uDDFF]|\uDDE9\uD83C[\uDDEA\uDDEC\uDDEF\uDDF0\uDDF2\uDDF4\uDDFF]|\uDDEA\uD83C[\uDDE6\uDDE8\uDDEA\uDDEC\uDDED\uDDF7-\uDDFA]|\uDDEB\uD83C[\uDDEE-\uDDF0\uDDF2\uDDF4\uDDF7]|\uDDEC\uD83C[\uDDE6\uDDE7\uDDE9-\uDDEE\uDDF1-\uDDF3\uDDF5-\uDDFA\uDDFC\uDDFE]|\uDDED\uD83C[\uDDF0\uDDF2\uDDF3\uDDF7\uDDF9\uDDFA]|\uDDEE\uD83C[\uDDE8-\uDDEA\uDDF1-\uDDF4\uDDF6-\uDDF9]|\uDDEF\uD83C[\uDDEA\uDDF2\uDDF4\uDDF5]|\uDDF0\uD83C[\uDDEA\uDDEC-\uDDEE\uDDF2\uDDF3\uDDF5\uDDF7\uDDFC\uDDFE\uDDFF]|\uDDF1\uD83C[\uDDE6-\uDDE8\uDDEE\uDDF0\uDDF7-\uDDFB\uDDFE]|\uDDF2\uD83C[\uDDE6\uDDE8-\uDDED\uDDF0-\uDDFF]|\uDDF3\uD83C[\uDDE6\uDDE8\uDDEA-\uDDEC\uDDEE\uDDF1\uDDF4\uDDF5\uDDF7\uDDFA\uDDFF]|\uDDF4\uD83C\uDDF2|\uDDF5\uD83C[\uDDE6\uDDEA-\uDDED\uDDF0-\uDDF3\uDDF7-\uDDF9\uDDFC\uDDFE]|\uDDF6\uD83C\uDDE6|\uDDF7\uD83C[\uDDEA\uDDF4\uDDF8\uDDFA\uDDFC]|\uDDF8\uD83C[\uDDE6-\uDDEA\uDDEC-\uDDF4\uDDF7-\uDDF9\uDDFB\uDDFD-\uDDFF]|\uDDF9\uD83C[\uDDE6\uDDE8\uDDE9\uDDEB-\uDDED\uDDEF-\uDDF4\uDDF7\uDDF9\uDDFB\uDDFC\uDDFF]|\uDDFA\uD83C[\uDDE6\uDDEC\uDDF2\uDDF3\uDDF8\uDDFE\uDDFF]|\uDDFB\uD83C[\uDDE6\uDDE8\uDDEA\uDDEC\uDDEE\uDDF3\uDDFA]|\uDDFC\uD83C[\uDDEB\uDDF8]|\uDDFD\uD83C\uDDF0|\uDDFE\uD83C[\uDDEA\uDDF9]|\uDDFF\uD83C[\uDDE6\uDDF2\uDDFC]|\uDF44(?:\u200D\uD83D\uDFEB)?|\uDF4B(?:\u200D\uD83D\uDFE9)?|\uDFC3(?:\uD83C[\uDFFB-\uDFFF])?(?:\u200D(?:[\u2640\u2642]\uFE0F?(?:\u200D\u27A1\uFE0F?)?|\u27A1\uFE0F?))?|\uDFF3\uFE0F?(?:\u200D(?:\u26A7\uFE0F?|\uD83C\uDF08))?|\uDFF4(?:\u200D\u2620\uFE0F?|\uDB40\uDC67\uDB40\uDC62\uDB40(?:\uDC65\uDB40\uDC6E\uDB40\uDC67|\uDC73\uDB40\uDC63\uDB40\uDC74|\uDC77\uDB40\uDC6C\uDB40\uDC73)\uDB40\uDC7F)?)|\uD83D(?:[\uDC3F\uDCFD\uDD49\uDD4A\uDD6F\uDD70\uDD73\uDD76-\uDD79\uDD87\uDD8A-\uDD8D\uDDA5\uDDA8\uDDB1\uDDB2\uDDBC\uDDC2-\uDDC4\uDDD1-\uDDD3\uDDDC-\uDDDE\uDDE1\uDDE3\uDDE8\uDDEF\uDDF3\uDDFA\uDECB\uDECD-\uDECF\uDEE0-\uDEE5\uDEE9\uDEF0\uDEF3]\uFE0F?|[\uDC42\uDC43\uDC46-\uDC50\uDC66\uDC67\uDC6B-\uDC6D\uDC72\uDC74-\uDC76\uDC78\uDC7C\uDC83\uDC85\uDC8F\uDC91\uDCAA\uDD7A\uDD95\uDD96\uDE4C\uDE4F\uDEC0\uDECC](?:\uD83C[\uDFFB-\uDFFF])?|[\uDC6E\uDC70\uDC71\uDC73\uDC77\uDC81\uDC82\uDC86\uDC87\uDE45-\uDE47\uDE4B\uDE4D\uDE4E\uDEA3\uDEB4\uDEB5](?:\uD83C[\uDFFB-\uDFFF])?(?:\u200D[\u2640\u2642]\uFE0F?)?|[\uDD74\uDD90](?:\uD83C[\uDFFB-\uDFFF]|\uFE0F)?|[\uDC00-\uDC07\uDC09-\uDC14\uDC16-\uDC25\uDC27-\uDC3A\uDC3C-\uDC3E\uDC40\uDC44\uDC45\uDC51-\uDC65\uDC6A\uDC79-\uDC7B\uDC7D-\uDC80\uDC84\uDC88-\uDC8E\uDC90\uDC92-\uDCA9\uDCAB-\uDCFC\uDCFF-\uDD3D\uDD4B-\uDD4E\uDD50-\uDD67\uDDA4\uDDFB-\uDE2D\uDE2F-\uDE34\uDE37-\uDE41\uDE43\uDE44\uDE48-\uDE4A\uDE80-\uDEA2\uDEA4-\uDEB3\uDEB7-\uDEBF\uDEC1-\uDEC5\uDED0-\uDED2\uDED5-\uDED7\uDEDC-\uDEDF\uDEEB\uDEEC\uDEF4-\uDEFC\uDFE0-\uDFEB\uDFF0]|\uDC08(?:\u200D\u2B1B)?|\uDC15(?:\u200D\uD83E\uDDBA)?|\uDC26(?:\u200D(?:\u2B1B|\uD83D\uDD25))?|\uDC3B(?:\u200D\u2744\uFE0F?)?|\uDC41\uFE0F?(?:\u200D\uD83D\uDDE8\uFE0F?)?|\uDC68(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:\uDC8B\u200D\uD83D)?\uDC68|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D(?:[\uDC68\uDC69]\u200D\uD83D(?:\uDC66(?:\u200D\uD83D\uDC66)?|\uDC67(?:\u200D\uD83D[\uDC66\uDC67])?)|[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uDC66(?:\u200D\uD83D\uDC66)?|\uDC67(?:\u200D\uD83D[\uDC66\uDC67])?)|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]))|\uD83C(?:\uDFFB(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:\uDC8B\u200D\uD83D)?\uDC68\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]|\uDD1D\u200D\uD83D\uDC68\uD83C[\uDFFC-\uDFFF])))?|\uDFFC(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:\uDC8B\u200D\uD83D)?\uDC68\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]|\uDD1D\u200D\uD83D\uDC68\uD83C[\uDFFB\uDFFD-\uDFFF])))?|\uDFFD(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:\uDC8B\u200D\uD83D)?\uDC68\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]|\uDD1D\u200D\uD83D\uDC68\uD83C[\uDFFB\uDFFC\uDFFE\uDFFF])))?|\uDFFE(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:\uDC8B\u200D\uD83D)?\uDC68\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]|\uDD1D\u200D\uD83D\uDC68\uD83C[\uDFFB-\uDFFD\uDFFF])))?|\uDFFF(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:\uDC8B\u200D\uD83D)?\uDC68\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]|\uDD1D\u200D\uD83D\uDC68\uD83C[\uDFFB-\uDFFE])))?))?|\uDC69(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:\uDC8B\u200D\uD83D)?[\uDC68\uDC69]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D(?:[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uDC66(?:\u200D\uD83D\uDC66)?|\uDC67(?:\u200D\uD83D[\uDC66\uDC67])?|\uDC69\u200D\uD83D(?:\uDC66(?:\u200D\uD83D\uDC66)?|\uDC67(?:\u200D\uD83D[\uDC66\uDC67])?))|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]))|\uD83C(?:\uDFFB(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:[\uDC68\uDC69]|\uDC8B\u200D\uD83D[\uDC68\uDC69])\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]|\uDD1D\u200D\uD83D[\uDC68\uDC69]\uD83C[\uDFFC-\uDFFF])))?|\uDFFC(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:[\uDC68\uDC69]|\uDC8B\u200D\uD83D[\uDC68\uDC69])\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]|\uDD1D\u200D\uD83D[\uDC68\uDC69]\uD83C[\uDFFB\uDFFD-\uDFFF])))?|\uDFFD(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:[\uDC68\uDC69]|\uDC8B\u200D\uD83D[\uDC68\uDC69])\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]|\uDD1D\u200D\uD83D[\uDC68\uDC69]\uD83C[\uDFFB\uDFFC\uDFFE\uDFFF])))?|\uDFFE(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:[\uDC68\uDC69]|\uDC8B\u200D\uD83D[\uDC68\uDC69])\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]|\uDD1D\u200D\uD83D[\uDC68\uDC69]\uD83C[\uDFFB-\uDFFD\uDFFF])))?|\uDFFF(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:[\uDC68\uDC69]|\uDC8B\u200D\uD83D[\uDC68\uDC69])\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]|\uDD1D\u200D\uD83D[\uDC68\uDC69]\uD83C[\uDFFB-\uDFFE])))?))?|\uDC6F(?:\u200D[\u2640\u2642]\uFE0F?)?|\uDD75(?:\uD83C[\uDFFB-\uDFFF]|\uFE0F)?(?:\u200D[\u2640\u2642]\uFE0F?)?|\uDE2E(?:\u200D\uD83D\uDCA8)?|\uDE35(?:\u200D\uD83D\uDCAB)?|\uDE36(?:\u200D\uD83C\uDF2B\uFE0F?)?|\uDE42(?:\u200D[\u2194\u2195]\uFE0F?)?|\uDEB6(?:\uD83C[\uDFFB-\uDFFF])?(?:\u200D(?:[\u2640\u2642]\uFE0F?(?:\u200D\u27A1\uFE0F?)?|\u27A1\uFE0F?))?)|\uD83E(?:[\uDD0C\uDD0F\uDD18-\uDD1F\uDD30-\uDD34\uDD36\uDD77\uDDB5\uDDB6\uDDBB\uDDD2\uDDD3\uDDD5\uDEC3-\uDEC5\uDEF0\uDEF2-\uDEF8](?:\uD83C[\uDFFB-\uDFFF])?|[\uDD26\uDD35\uDD37-\uDD39\uDD3D\uDD3E\uDDB8\uDDB9\uDDCD\uDDCF\uDDD4\uDDD6-\uDDDD](?:\uD83C[\uDFFB-\uDFFF])?(?:\u200D[\u2640\u2642]\uFE0F?)?|[\uDDDE\uDDDF](?:\u200D[\u2640\u2642]\uFE0F?)?|[\uDD0D\uDD0E\uDD10-\uDD17\uDD20-\uDD25\uDD27-\uDD2F\uDD3A\uDD3F-\uDD45\uDD47-\uDD76\uDD78-\uDDB4\uDDB7\uDDBA\uDDBC-\uDDCC\uDDD0\uDDE0-\uDDFF\uDE70-\uDE7C\uDE80-\uDE89\uDE8F-\uDEC2\uDEC6\uDECE-\uDEDC\uDEDF-\uDEE9]|\uDD3C(?:\u200D[\u2640\u2642]\uFE0F?|\uD83C[\uDFFB-\uDFFF])?|\uDDCE(?:\uD83C[\uDFFB-\uDFFF])?(?:\u200D(?:[\u2640\u2642]\uFE0F?(?:\u200D\u27A1\uFE0F?)?|\u27A1\uFE0F?))?|\uDDD1(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\uD83C[\uDF3E\uDF73\uDF7C\uDF84\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]|\uDD1D\u200D\uD83E\uDDD1|\uDDD1\u200D\uD83E\uDDD2(?:\u200D\uD83E\uDDD2)?|\uDDD2(?:\u200D\uD83E\uDDD2)?))|\uD83C(?:\uDFFB(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D(?:\uD83D\uDC8B\u200D)?\uD83E\uDDD1\uD83C[\uDFFC-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF84\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]|\uDD1D\u200D\uD83E\uDDD1\uD83C[\uDFFB-\uDFFF])))?|\uDFFC(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D(?:\uD83D\uDC8B\u200D)?\uD83E\uDDD1\uD83C[\uDFFB\uDFFD-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF84\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]|\uDD1D\u200D\uD83E\uDDD1\uD83C[\uDFFB-\uDFFF])))?|\uDFFD(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D(?:\uD83D\uDC8B\u200D)?\uD83E\uDDD1\uD83C[\uDFFB\uDFFC\uDFFE\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF84\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]|\uDD1D\u200D\uD83E\uDDD1\uD83C[\uDFFB-\uDFFF])))?|\uDFFE(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D(?:\uD83D\uDC8B\u200D)?\uD83E\uDDD1\uD83C[\uDFFB-\uDFFD\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF84\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]|\uDD1D\u200D\uD83E\uDDD1\uD83C[\uDFFB-\uDFFF])))?|\uDFFF(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D(?:\uD83D\uDC8B\u200D)?\uD83E\uDDD1\uD83C[\uDFFB-\uDFFE]|\uD83C[\uDF3E\uDF73\uDF7C\uDF84\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]|\uDD1D\u200D\uD83E\uDDD1\uD83C[\uDFFB-\uDFFF])))?))?|\uDEF1(?:\uD83C(?:\uDFFB(?:\u200D\uD83E\uDEF2\uD83C[\uDFFC-\uDFFF])?|\uDFFC(?:\u200D\uD83E\uDEF2\uD83C[\uDFFB\uDFFD-\uDFFF])?|\uDFFD(?:\u200D\uD83E\uDEF2\uD83C[\uDFFB\uDFFC\uDFFE\uDFFF])?|\uDFFE(?:\u200D\uD83E\uDEF2\uD83C[\uDFFB-\uDFFD\uDFFF])?|\uDFFF(?:\u200D\uD83E\uDEF2\uD83C[\uDFFB-\uDFFE])?))?)/g; +}; + +// node_modules/get-east-asian-width/lookup.js +function isFullWidth(x) { + return x === 12288 || x >= 65281 && x <= 65376 || x >= 65504 && x <= 65510; +} +function isWide(x) { + return x >= 4352 && x <= 4447 || x === 8986 || x === 8987 || x === 9001 || x === 9002 || x >= 9193 && x <= 9196 || x === 9200 || x === 9203 || x === 9725 || x === 9726 || x === 9748 || x === 9749 || x >= 9776 && x <= 9783 || x >= 9800 && x <= 9811 || x === 9855 || x >= 9866 && x <= 9871 || x === 9875 || x === 9889 || x === 9898 || x === 9899 || x === 9917 || x === 9918 || x === 9924 || x === 9925 || x === 9934 || x === 9940 || x === 9962 || x === 9970 || x === 9971 || x === 9973 || x === 9978 || x === 9981 || x === 9989 || x === 9994 || x === 9995 || x === 10024 || x === 10060 || x === 10062 || x >= 10067 && x <= 10069 || x === 10071 || x >= 10133 && x <= 10135 || x === 10160 || x === 10175 || x === 11035 || x === 11036 || x === 11088 || x === 11093 || x >= 11904 && x <= 11929 || x >= 11931 && x <= 12019 || x >= 12032 && x <= 12245 || x >= 12272 && x <= 12287 || x >= 12289 && x <= 12350 || x >= 12353 && x <= 12438 || x >= 12441 && x <= 12543 || x >= 12549 && x <= 12591 || x >= 12593 && x <= 12686 || x >= 12688 && x <= 12773 || x >= 12783 && x <= 12830 || x >= 12832 && x <= 12871 || x >= 12880 && x <= 42124 || x >= 42128 && x <= 42182 || x >= 43360 && x <= 43388 || x >= 44032 && x <= 55203 || x >= 63744 && x <= 64255 || x >= 65040 && x <= 65049 || x >= 65072 && x <= 65106 || x >= 65108 && x <= 65126 || x >= 65128 && x <= 65131 || x >= 94176 && x <= 94180 || x === 94192 || x === 94193 || x >= 94208 && x <= 100343 || x >= 100352 && x <= 101589 || x >= 101631 && x <= 101640 || x >= 110576 && x <= 110579 || x >= 110581 && x <= 110587 || x === 110589 || x === 110590 || x >= 110592 && x <= 110882 || x === 110898 || x >= 110928 && x <= 110930 || x === 110933 || x >= 110948 && x <= 110951 || x >= 110960 && x <= 111355 || x >= 119552 && x <= 119638 || x >= 119648 && x <= 119670 || x === 126980 || x === 127183 || x === 127374 || x >= 127377 && x <= 127386 || x >= 127488 && x <= 127490 || x >= 127504 && x <= 127547 || x >= 127552 && x <= 127560 || x === 127568 || x === 127569 || x >= 127584 && x <= 127589 || x >= 127744 && x <= 127776 || x >= 127789 && x <= 127797 || x >= 127799 && x <= 127868 || x >= 127870 && x <= 127891 || x >= 127904 && x <= 127946 || x >= 127951 && x <= 127955 || x >= 127968 && x <= 127984 || x === 127988 || x >= 127992 && x <= 128062 || x === 128064 || x >= 128066 && x <= 128252 || x >= 128255 && x <= 128317 || x >= 128331 && x <= 128334 || x >= 128336 && x <= 128359 || x === 128378 || x === 128405 || x === 128406 || x === 128420 || x >= 128507 && x <= 128591 || x >= 128640 && x <= 128709 || x === 128716 || x >= 128720 && x <= 128722 || x >= 128725 && x <= 128727 || x >= 128732 && x <= 128735 || x === 128747 || x === 128748 || x >= 128756 && x <= 128764 || x >= 128992 && x <= 129003 || x === 129008 || x >= 129292 && x <= 129338 || x >= 129340 && x <= 129349 || x >= 129351 && x <= 129535 || x >= 129648 && x <= 129660 || x >= 129664 && x <= 129673 || x >= 129679 && x <= 129734 || x >= 129742 && x <= 129756 || x >= 129759 && x <= 129769 || x >= 129776 && x <= 129784 || x >= 131072 && x <= 196605 || x >= 196608 && x <= 262141; +} + +// node_modules/get-east-asian-width/index.js +var _isNarrowWidth = (codePoint) => !(isFullWidth(codePoint) || isWide(codePoint)); + +// src/utils/get-string-width.js +var notAsciiRegex = /[^\x20-\x7F]/u; +function getStringWidth(text) { + if (!text) { + return 0; + } + if (!notAsciiRegex.test(text)) { + return text.length; + } + text = text.replace(emoji_regex_default(), " "); + let width = 0; + for (const character of text) { + const codePoint = character.codePointAt(0); + if (codePoint <= 31 || codePoint >= 127 && codePoint <= 159) { + continue; + } + if (codePoint >= 768 && codePoint <= 879) { + continue; + } + width += _isNarrowWidth(codePoint) ? 1 : 2; + } + return width; +} +var get_string_width_default = getStringWidth; + +// src/document/printer.js +var MODE_BREAK = Symbol("MODE_BREAK"); +var MODE_FLAT = Symbol("MODE_FLAT"); +var CURSOR_PLACEHOLDER = Symbol("cursor"); +var DOC_FILL_PRINTED_LENGTH = Symbol("DOC_FILL_PRINTED_LENGTH"); +function rootIndent() { + return { value: "", length: 0, queue: [] }; +} +function makeIndent(ind, options) { + return generateInd(ind, { type: "indent" }, options); +} +function makeAlign(indent2, widthOrDoc, options) { + if (widthOrDoc === Number.NEGATIVE_INFINITY) { + return indent2.root || rootIndent(); + } + if (widthOrDoc < 0) { + return generateInd(indent2, { type: "dedent" }, options); + } + if (!widthOrDoc) { + return indent2; + } + if (widthOrDoc.type === "root") { + return { ...indent2, root: indent2 }; + } + const alignType = typeof widthOrDoc === "string" ? "stringAlign" : "numberAlign"; + return generateInd(indent2, { type: alignType, n: widthOrDoc }, options); +} +function generateInd(ind, newPart, options) { + const queue = newPart.type === "dedent" ? ind.queue.slice(0, -1) : [...ind.queue, newPart]; + let value = ""; + let length = 0; + let lastTabs = 0; + let lastSpaces = 0; + for (const part of queue) { + switch (part.type) { + case "indent": + flush(); + if (options.useTabs) { + addTabs(1); + } else { + addSpaces(options.tabWidth); + } + break; + case "stringAlign": + flush(); + value += part.n; + length += part.n.length; + break; + case "numberAlign": + lastTabs += 1; + lastSpaces += part.n; + break; + default: + throw new Error(`Unexpected type '${part.type}'`); + } + } + flushSpaces(); + return { ...ind, value, length, queue }; + function addTabs(count) { + value += " ".repeat(count); + length += options.tabWidth * count; + } + function addSpaces(count) { + value += " ".repeat(count); + length += count; + } + function flush() { + if (options.useTabs) { + flushTabs(); + } else { + flushSpaces(); + } + } + function flushTabs() { + if (lastTabs > 0) { + addTabs(lastTabs); + } + resetLast(); + } + function flushSpaces() { + if (lastSpaces > 0) { + addSpaces(lastSpaces); + } + resetLast(); + } + function resetLast() { + lastTabs = 0; + lastSpaces = 0; + } +} +function trim2(out) { + let trimCount = 0; + let cursorCount = 0; + let outIndex = out.length; + outer: while (outIndex--) { + const last = out[outIndex]; + if (last === CURSOR_PLACEHOLDER) { + cursorCount++; + continue; + } + if (false) { + throw new Error(`Unexpected value in trim: '${typeof last}'`); + } + for (let charIndex = last.length - 1; charIndex >= 0; charIndex--) { + const char = last[charIndex]; + if (char === " " || char === " ") { + trimCount++; + } else { + out[outIndex] = last.slice(0, charIndex + 1); + break outer; + } + } + } + if (trimCount > 0 || cursorCount > 0) { + out.length = outIndex + 1; + while (cursorCount-- > 0) { + out.push(CURSOR_PLACEHOLDER); + } + } + return trimCount; +} +function fits(next, restCommands, width, hasLineSuffix, groupModeMap, mustBeFlat) { + if (width === Number.POSITIVE_INFINITY) { + return true; + } + let restIdx = restCommands.length; + const cmds = [next]; + const out = []; + while (width >= 0) { + if (cmds.length === 0) { + if (restIdx === 0) { + return true; + } + cmds.push(restCommands[--restIdx]); + continue; + } + const { mode, doc } = cmds.pop(); + const docType = get_doc_type_default(doc); + switch (docType) { + case DOC_TYPE_STRING: + out.push(doc); + width -= get_string_width_default(doc); + break; + case DOC_TYPE_ARRAY: + case DOC_TYPE_FILL: { + const parts = docType === DOC_TYPE_ARRAY ? doc : doc.parts; + const end = doc[DOC_FILL_PRINTED_LENGTH] ?? 0; + for (let i = parts.length - 1; i >= end; i--) { + cmds.push({ mode, doc: parts[i] }); + } + break; + } + case DOC_TYPE_INDENT: + case DOC_TYPE_ALIGN: + case DOC_TYPE_INDENT_IF_BREAK: + case DOC_TYPE_LABEL: + cmds.push({ mode, doc: doc.contents }); + break; + case DOC_TYPE_TRIM: + width += trim2(out); + break; + case DOC_TYPE_GROUP: { + if (mustBeFlat && doc.break) { + return false; + } + const groupMode = doc.break ? MODE_BREAK : mode; + const contents = doc.expandedStates && groupMode === MODE_BREAK ? at_default( + /* isOptionalObject */ + false, + doc.expandedStates, + -1 + ) : doc.contents; + cmds.push({ mode: groupMode, doc: contents }); + break; + } + case DOC_TYPE_IF_BREAK: { + const groupMode = doc.groupId ? groupModeMap[doc.groupId] || MODE_FLAT : mode; + const contents = groupMode === MODE_BREAK ? doc.breakContents : doc.flatContents; + if (contents) { + cmds.push({ mode, doc: contents }); + } + break; + } + case DOC_TYPE_LINE: + if (mode === MODE_BREAK || doc.hard) { + return true; + } + if (!doc.soft) { + out.push(" "); + width--; + } + break; + case DOC_TYPE_LINE_SUFFIX: + hasLineSuffix = true; + break; + case DOC_TYPE_LINE_SUFFIX_BOUNDARY: + if (hasLineSuffix) { + return false; + } + break; + } + } + return false; +} +function printDocToString(doc, options) { + const groupModeMap = {}; + const width = options.printWidth; + const newLine = convertEndOfLineToChars(options.endOfLine); + let pos = 0; + const cmds = [{ ind: rootIndent(), mode: MODE_BREAK, doc }]; + const out = []; + let shouldRemeasure = false; + const lineSuffix2 = []; + let printedCursorCount = 0; + propagateBreaks(doc); + while (cmds.length > 0) { + const { ind, mode, doc: doc2 } = cmds.pop(); + switch (get_doc_type_default(doc2)) { + case DOC_TYPE_STRING: { + const formatted = newLine !== "\n" ? string_replace_all_default( + /* isOptionalObject */ + false, + doc2, + "\n", + newLine + ) : doc2; + out.push(formatted); + if (cmds.length > 0) { + pos += get_string_width_default(formatted); + } + break; + } + case DOC_TYPE_ARRAY: + for (let i = doc2.length - 1; i >= 0; i--) { + cmds.push({ ind, mode, doc: doc2[i] }); + } + break; + case DOC_TYPE_CURSOR: + if (printedCursorCount >= 2) { + throw new Error("There are too many 'cursor' in doc."); + } + out.push(CURSOR_PLACEHOLDER); + printedCursorCount++; + break; + case DOC_TYPE_INDENT: + cmds.push({ ind: makeIndent(ind, options), mode, doc: doc2.contents }); + break; + case DOC_TYPE_ALIGN: + cmds.push({ + ind: makeAlign(ind, doc2.n, options), + mode, + doc: doc2.contents + }); + break; + case DOC_TYPE_TRIM: + pos -= trim2(out); + break; + case DOC_TYPE_GROUP: + switch (mode) { + case MODE_FLAT: + if (!shouldRemeasure) { + cmds.push({ + ind, + mode: doc2.break ? MODE_BREAK : MODE_FLAT, + doc: doc2.contents + }); + break; + } + // fallthrough + case MODE_BREAK: { + shouldRemeasure = false; + const next = { ind, mode: MODE_FLAT, doc: doc2.contents }; + const rem = width - pos; + const hasLineSuffix = lineSuffix2.length > 0; + if (!doc2.break && fits(next, cmds, rem, hasLineSuffix, groupModeMap)) { + cmds.push(next); + } else { + if (doc2.expandedStates) { + const mostExpanded = at_default( + /* isOptionalObject */ + false, + doc2.expandedStates, + -1 + ); + if (doc2.break) { + cmds.push({ ind, mode: MODE_BREAK, doc: mostExpanded }); + break; + } else { + for (let i = 1; i < doc2.expandedStates.length + 1; i++) { + if (i >= doc2.expandedStates.length) { + cmds.push({ ind, mode: MODE_BREAK, doc: mostExpanded }); + break; + } else { + const state = doc2.expandedStates[i]; + const cmd = { ind, mode: MODE_FLAT, doc: state }; + if (fits(cmd, cmds, rem, hasLineSuffix, groupModeMap)) { + cmds.push(cmd); + break; + } + } + } + } + } else { + cmds.push({ ind, mode: MODE_BREAK, doc: doc2.contents }); + } + } + break; + } + } + if (doc2.id) { + groupModeMap[doc2.id] = at_default( + /* isOptionalObject */ + false, + cmds, + -1 + ).mode; + } + break; + // Fills each line with as much code as possible before moving to a new + // line with the same indentation. + // + // Expects doc.parts to be an array of alternating content and + // whitespace. The whitespace contains the linebreaks. + // + // For example: + // ["I", line, "love", line, "monkeys"] + // or + // [{ type: group, ... }, softline, { type: group, ... }] + // + // It uses this parts structure to handle three main layout cases: + // * The first two content items fit on the same line without + // breaking + // -> output the first content item and the whitespace "flat". + // * Only the first content item fits on the line without breaking + // -> output the first content item "flat" and the whitespace with + // "break". + // * Neither content item fits on the line without breaking + // -> output the first content item and the whitespace with "break". + case DOC_TYPE_FILL: { + const rem = width - pos; + const offset = doc2[DOC_FILL_PRINTED_LENGTH] ?? 0; + const { parts } = doc2; + const length = parts.length - offset; + if (length === 0) { + break; + } + const content = parts[offset + 0]; + const whitespace = parts[offset + 1]; + const contentFlatCmd = { ind, mode: MODE_FLAT, doc: content }; + const contentBreakCmd = { ind, mode: MODE_BREAK, doc: content }; + const contentFits = fits( + contentFlatCmd, + [], + rem, + lineSuffix2.length > 0, + groupModeMap, + true + ); + if (length === 1) { + if (contentFits) { + cmds.push(contentFlatCmd); + } else { + cmds.push(contentBreakCmd); + } + break; + } + const whitespaceFlatCmd = { ind, mode: MODE_FLAT, doc: whitespace }; + const whitespaceBreakCmd = { ind, mode: MODE_BREAK, doc: whitespace }; + if (length === 2) { + if (contentFits) { + cmds.push(whitespaceFlatCmd, contentFlatCmd); + } else { + cmds.push(whitespaceBreakCmd, contentBreakCmd); + } + break; + } + const secondContent = parts[offset + 2]; + const remainingCmd = { + ind, + mode, + doc: { ...doc2, [DOC_FILL_PRINTED_LENGTH]: offset + 2 } + }; + const firstAndSecondContentFlatCmd = { + ind, + mode: MODE_FLAT, + doc: [content, whitespace, secondContent] + }; + const firstAndSecondContentFits = fits( + firstAndSecondContentFlatCmd, + [], + rem, + lineSuffix2.length > 0, + groupModeMap, + true + ); + if (firstAndSecondContentFits) { + cmds.push(remainingCmd, whitespaceFlatCmd, contentFlatCmd); + } else if (contentFits) { + cmds.push(remainingCmd, whitespaceBreakCmd, contentFlatCmd); + } else { + cmds.push(remainingCmd, whitespaceBreakCmd, contentBreakCmd); + } + break; + } + case DOC_TYPE_IF_BREAK: + case DOC_TYPE_INDENT_IF_BREAK: { + const groupMode = doc2.groupId ? groupModeMap[doc2.groupId] : mode; + if (groupMode === MODE_BREAK) { + const breakContents = doc2.type === DOC_TYPE_IF_BREAK ? doc2.breakContents : doc2.negate ? doc2.contents : indent(doc2.contents); + if (breakContents) { + cmds.push({ ind, mode, doc: breakContents }); + } + } + if (groupMode === MODE_FLAT) { + const flatContents = doc2.type === DOC_TYPE_IF_BREAK ? doc2.flatContents : doc2.negate ? indent(doc2.contents) : doc2.contents; + if (flatContents) { + cmds.push({ ind, mode, doc: flatContents }); + } + } + break; + } + case DOC_TYPE_LINE_SUFFIX: + lineSuffix2.push({ ind, mode, doc: doc2.contents }); + break; + case DOC_TYPE_LINE_SUFFIX_BOUNDARY: + if (lineSuffix2.length > 0) { + cmds.push({ ind, mode, doc: hardlineWithoutBreakParent }); + } + break; + case DOC_TYPE_LINE: + switch (mode) { + case MODE_FLAT: + if (!doc2.hard) { + if (!doc2.soft) { + out.push(" "); + pos += 1; + } + break; + } else { + shouldRemeasure = true; + } + // fallthrough + case MODE_BREAK: + if (lineSuffix2.length > 0) { + cmds.push({ ind, mode, doc: doc2 }, ...lineSuffix2.reverse()); + lineSuffix2.length = 0; + break; + } + if (doc2.literal) { + if (ind.root) { + out.push(newLine, ind.root.value); + pos = ind.root.length; + } else { + out.push(newLine); + pos = 0; + } + } else { + pos -= trim2(out); + out.push(newLine + ind.value); + pos = ind.length; + } + break; + } + break; + case DOC_TYPE_LABEL: + cmds.push({ ind, mode, doc: doc2.contents }); + break; + case DOC_TYPE_BREAK_PARENT: + break; + default: + throw new invalid_doc_error_default(doc2); + } + if (cmds.length === 0 && lineSuffix2.length > 0) { + cmds.push(...lineSuffix2.reverse()); + lineSuffix2.length = 0; + } + } + const cursorPlaceholderIndex = out.indexOf(CURSOR_PLACEHOLDER); + if (cursorPlaceholderIndex !== -1) { + const otherCursorPlaceholderIndex = out.indexOf( + CURSOR_PLACEHOLDER, + cursorPlaceholderIndex + 1 + ); + if (otherCursorPlaceholderIndex === -1) { + return { + formatted: out.filter((char) => char !== CURSOR_PLACEHOLDER).join("") + }; + } + const beforeCursor = out.slice(0, cursorPlaceholderIndex).join(""); + const aroundCursor = out.slice(cursorPlaceholderIndex + 1, otherCursorPlaceholderIndex).join(""); + const afterCursor = out.slice(otherCursorPlaceholderIndex + 1).join(""); + return { + formatted: beforeCursor + aroundCursor + afterCursor, + cursorNodeStart: beforeCursor.length, + cursorNodeText: aroundCursor + }; + } + return { formatted: out.join("") }; +} + +// src/document/public.js +var builders = { + join, + line, + softline, + hardline, + literalline, + group, + conditionalGroup, + fill, + lineSuffix, + lineSuffixBoundary, + cursor, + breakParent, + ifBreak, + trim, + indent, + indentIfBreak, + align, + addAlignmentToDoc, + markAsRoot, + dedentToRoot, + dedent, + hardlineWithoutBreakParent, + literallineWithoutBreakParent, + label, + // TODO: Remove this in v4 + concat: (parts) => parts +}; +var printer = { printDocToString }; +var utils = { + willBreak, + traverseDoc: traverse_doc_default, + findInDoc, + mapDoc, + removeLines, + stripTrailingHardline, + replaceEndOfLine, + canBreak +}; + +// with-default-export:src/document/public.js +var public_default = public_exports; +export { + builders, + public_default as default, + printer, + utils +}; diff --git a/node_modules/prettier/index.cjs b/node_modules/prettier/index.cjs new file mode 100644 index 0000000..ec43948 --- /dev/null +++ b/node_modules/prettier/index.cjs @@ -0,0 +1,682 @@ +"use strict"; +var __create = Object.create; +var __defProp = Object.defineProperty; +var __getOwnPropDesc = Object.getOwnPropertyDescriptor; +var __getOwnPropNames = Object.getOwnPropertyNames; +var __getProtoOf = Object.getPrototypeOf; +var __hasOwnProp = Object.prototype.hasOwnProperty; +var __esm = (fn, res) => function __init() { + return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res; +}; +var __commonJS = (cb, mod) => function __require() { + return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports; +}; +var __export = (target, all) => { + for (var name in all) + __defProp(target, name, { get: all[name], enumerable: true }); +}; +var __copyProps = (to, from, except, desc) => { + if (from && typeof from === "object" || typeof from === "function") { + for (let key of __getOwnPropNames(from)) + if (!__hasOwnProp.call(to, key) && key !== except) + __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable }); + } + return to; +}; +var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps( + // If the importer is in node compatibility mode or this is not an ESM + // file that has been converted to a CommonJS file using a Babel- + // compatible transform (i.e. "__esModule" has not been set), then set + // "default" to the CommonJS "module.exports" for node compatibility. + isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target, + mod +)); +var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod); + +// src/utils/skip.js +function skip(characters) { + return (text, startIndex, options) => { + const backwards = Boolean(options == null ? void 0 : options.backwards); + if (startIndex === false) { + return false; + } + const { length } = text; + let cursor = startIndex; + while (cursor >= 0 && cursor < length) { + const character = text.charAt(cursor); + if (characters instanceof RegExp) { + if (!characters.test(character)) { + return cursor; + } + } else if (!characters.includes(character)) { + return cursor; + } + backwards ? cursor-- : cursor++; + } + if (cursor === -1 || cursor === length) { + return cursor; + } + return false; + }; +} +var skipWhitespace, skipSpaces, skipToLineEnd, skipEverythingButNewLine; +var init_skip = __esm({ + "src/utils/skip.js"() { + skipWhitespace = skip(/\s/u); + skipSpaces = skip(" "); + skipToLineEnd = skip(",; "); + skipEverythingButNewLine = skip(/[^\n\r]/u); + } +}); + +// src/utils/skip-inline-comment.js +function skipInlineComment(text, startIndex) { + if (startIndex === false) { + return false; + } + if (text.charAt(startIndex) === "/" && text.charAt(startIndex + 1) === "*") { + for (let i = startIndex + 2; i < text.length; ++i) { + if (text.charAt(i) === "*" && text.charAt(i + 1) === "/") { + return i + 2; + } + } + } + return startIndex; +} +var skip_inline_comment_default; +var init_skip_inline_comment = __esm({ + "src/utils/skip-inline-comment.js"() { + skip_inline_comment_default = skipInlineComment; + } +}); + +// src/utils/skip-newline.js +function skipNewline(text, startIndex, options) { + const backwards = Boolean(options == null ? void 0 : options.backwards); + if (startIndex === false) { + return false; + } + const character = text.charAt(startIndex); + if (backwards) { + if (text.charAt(startIndex - 1) === "\r" && character === "\n") { + return startIndex - 2; + } + if (character === "\n" || character === "\r" || character === "\u2028" || character === "\u2029") { + return startIndex - 1; + } + } else { + if (character === "\r" && text.charAt(startIndex + 1) === "\n") { + return startIndex + 2; + } + if (character === "\n" || character === "\r" || character === "\u2028" || character === "\u2029") { + return startIndex + 1; + } + } + return startIndex; +} +var skip_newline_default; +var init_skip_newline = __esm({ + "src/utils/skip-newline.js"() { + skip_newline_default = skipNewline; + } +}); + +// src/utils/skip-trailing-comment.js +function skipTrailingComment(text, startIndex) { + if (startIndex === false) { + return false; + } + if (text.charAt(startIndex) === "/" && text.charAt(startIndex + 1) === "/") { + return skipEverythingButNewLine(text, startIndex); + } + return startIndex; +} +var skip_trailing_comment_default; +var init_skip_trailing_comment = __esm({ + "src/utils/skip-trailing-comment.js"() { + init_skip(); + skip_trailing_comment_default = skipTrailingComment; + } +}); + +// src/utils/get-next-non-space-non-comment-character-index.js +function getNextNonSpaceNonCommentCharacterIndex(text, startIndex) { + let oldIdx = null; + let nextIdx = startIndex; + while (nextIdx !== oldIdx) { + oldIdx = nextIdx; + nextIdx = skipSpaces(text, nextIdx); + nextIdx = skip_inline_comment_default(text, nextIdx); + nextIdx = skip_trailing_comment_default(text, nextIdx); + nextIdx = skip_newline_default(text, nextIdx); + } + return nextIdx; +} +var get_next_non_space_non_comment_character_index_default; +var init_get_next_non_space_non_comment_character_index = __esm({ + "src/utils/get-next-non-space-non-comment-character-index.js"() { + init_skip(); + init_skip_inline_comment(); + init_skip_newline(); + init_skip_trailing_comment(); + get_next_non_space_non_comment_character_index_default = getNextNonSpaceNonCommentCharacterIndex; + } +}); + +// src/utils/has-newline.js +function hasNewline(text, startIndex, options = {}) { + const idx = skipSpaces( + text, + options.backwards ? startIndex - 1 : startIndex, + options + ); + const idx2 = skip_newline_default(text, idx, options); + return idx !== idx2; +} +var has_newline_default; +var init_has_newline = __esm({ + "src/utils/has-newline.js"() { + init_skip(); + init_skip_newline(); + has_newline_default = hasNewline; + } +}); + +// src/utils/is-next-line-empty.js +function isNextLineEmpty(text, startIndex) { + let oldIdx = null; + let idx = startIndex; + while (idx !== oldIdx) { + oldIdx = idx; + idx = skipToLineEnd(text, idx); + idx = skip_inline_comment_default(text, idx); + idx = skipSpaces(text, idx); + } + idx = skip_trailing_comment_default(text, idx); + idx = skip_newline_default(text, idx); + return idx !== false && has_newline_default(text, idx); +} +var is_next_line_empty_default; +var init_is_next_line_empty = __esm({ + "src/utils/is-next-line-empty.js"() { + init_has_newline(); + init_skip(); + init_skip_inline_comment(); + init_skip_newline(); + init_skip_trailing_comment(); + is_next_line_empty_default = isNextLineEmpty; + } +}); + +// src/utils/is-previous-line-empty.js +function isPreviousLineEmpty(text, startIndex) { + let idx = startIndex - 1; + idx = skipSpaces(text, idx, { backwards: true }); + idx = skip_newline_default(text, idx, { backwards: true }); + idx = skipSpaces(text, idx, { backwards: true }); + const idx2 = skip_newline_default(text, idx, { backwards: true }); + return idx !== idx2; +} +var is_previous_line_empty_default; +var init_is_previous_line_empty = __esm({ + "src/utils/is-previous-line-empty.js"() { + init_skip(); + init_skip_newline(); + is_previous_line_empty_default = isPreviousLineEmpty; + } +}); + +// src/main/comments/utils.js +function describeNodeForDebugging(node) { + const nodeType = node.type || node.kind || "(unknown type)"; + let nodeName = String( + node.name || node.id && (typeof node.id === "object" ? node.id.name : node.id) || node.key && (typeof node.key === "object" ? node.key.name : node.key) || node.value && (typeof node.value === "object" ? "" : String(node.value)) || node.operator || "" + ); + if (nodeName.length > 20) { + nodeName = nodeName.slice(0, 19) + "\u2026"; + } + return nodeType + (nodeName ? " " + nodeName : ""); +} +function addCommentHelper(node, comment) { + const comments = node.comments ?? (node.comments = []); + comments.push(comment); + comment.printed = false; + comment.nodeDescription = describeNodeForDebugging(node); +} +function addLeadingComment(node, comment) { + comment.leading = true; + comment.trailing = false; + addCommentHelper(node, comment); +} +function addDanglingComment(node, comment, marker) { + comment.leading = false; + comment.trailing = false; + if (marker) { + comment.marker = marker; + } + addCommentHelper(node, comment); +} +function addTrailingComment(node, comment) { + comment.leading = false; + comment.trailing = true; + addCommentHelper(node, comment); +} +var init_utils = __esm({ + "src/main/comments/utils.js"() { + } +}); + +// src/utils/get-alignment-size.js +function getAlignmentSize(text, tabWidth, startIndex = 0) { + let size = 0; + for (let i = startIndex; i < text.length; ++i) { + if (text[i] === " ") { + size = size + tabWidth - size % tabWidth; + } else { + size++; + } + } + return size; +} +var get_alignment_size_default; +var init_get_alignment_size = __esm({ + "src/utils/get-alignment-size.js"() { + get_alignment_size_default = getAlignmentSize; + } +}); + +// src/utils/get-indent-size.js +function getIndentSize(value, tabWidth) { + const lastNewlineIndex = value.lastIndexOf("\n"); + if (lastNewlineIndex === -1) { + return 0; + } + return get_alignment_size_default( + // All the leading whitespaces + value.slice(lastNewlineIndex + 1).match(/^[\t ]*/u)[0], + tabWidth + ); +} +var get_indent_size_default; +var init_get_indent_size = __esm({ + "src/utils/get-indent-size.js"() { + init_get_alignment_size(); + get_indent_size_default = getIndentSize; + } +}); + +// node_modules/escape-string-regexp/index.js +function escapeStringRegexp(string) { + if (typeof string !== "string") { + throw new TypeError("Expected a string"); + } + return string.replace(/[|\\{}()[\]^$+*?.]/g, "\\$&").replace(/-/g, "\\x2d"); +} +var init_escape_string_regexp = __esm({ + "node_modules/escape-string-regexp/index.js"() { + } +}); + +// src/utils/get-max-continuous-count.js +function getMaxContinuousCount(text, searchString) { + const results = text.match( + new RegExp(`(${escapeStringRegexp(searchString)})+`, "gu") + ); + if (results === null) { + return 0; + } + return results.reduce( + (maxCount, result) => Math.max(maxCount, result.length / searchString.length), + 0 + ); +} +var get_max_continuous_count_default; +var init_get_max_continuous_count = __esm({ + "src/utils/get-max-continuous-count.js"() { + init_escape_string_regexp(); + get_max_continuous_count_default = getMaxContinuousCount; + } +}); + +// src/utils/get-next-non-space-non-comment-character.js +function getNextNonSpaceNonCommentCharacter(text, startIndex) { + const index = get_next_non_space_non_comment_character_index_default(text, startIndex); + return index === false ? "" : text.charAt(index); +} +var get_next_non_space_non_comment_character_default; +var init_get_next_non_space_non_comment_character = __esm({ + "src/utils/get-next-non-space-non-comment-character.js"() { + init_get_next_non_space_non_comment_character_index(); + get_next_non_space_non_comment_character_default = getNextNonSpaceNonCommentCharacter; + } +}); + +// src/utils/get-preferred-quote.js +function getPreferredQuote(text, preferredQuoteOrPreferSingleQuote) { + const preferred = preferredQuoteOrPreferSingleQuote === true || preferredQuoteOrPreferSingleQuote === SINGLE_QUOTE ? SINGLE_QUOTE : DOUBLE_QUOTE; + const alternate = preferred === SINGLE_QUOTE ? DOUBLE_QUOTE : SINGLE_QUOTE; + let preferredQuoteCount = 0; + let alternateQuoteCount = 0; + for (const character of text) { + if (character === preferred) { + preferredQuoteCount++; + } else if (character === alternate) { + alternateQuoteCount++; + } + } + return preferredQuoteCount > alternateQuoteCount ? alternate : preferred; +} +var SINGLE_QUOTE, DOUBLE_QUOTE, get_preferred_quote_default; +var init_get_preferred_quote = __esm({ + "src/utils/get-preferred-quote.js"() { + SINGLE_QUOTE = "'"; + DOUBLE_QUOTE = '"'; + get_preferred_quote_default = getPreferredQuote; + } +}); + +// node_modules/emoji-regex/index.mjs +var emoji_regex_default; +var init_emoji_regex = __esm({ + "node_modules/emoji-regex/index.mjs"() { + emoji_regex_default = () => { + return /[#*0-9]\uFE0F?\u20E3|[\xA9\xAE\u203C\u2049\u2122\u2139\u2194-\u2199\u21A9\u21AA\u231A\u231B\u2328\u23CF\u23ED-\u23EF\u23F1\u23F2\u23F8-\u23FA\u24C2\u25AA\u25AB\u25B6\u25C0\u25FB\u25FC\u25FE\u2600-\u2604\u260E\u2611\u2614\u2615\u2618\u2620\u2622\u2623\u2626\u262A\u262E\u262F\u2638-\u263A\u2640\u2642\u2648-\u2653\u265F\u2660\u2663\u2665\u2666\u2668\u267B\u267E\u267F\u2692\u2694-\u2697\u2699\u269B\u269C\u26A0\u26A7\u26AA\u26B0\u26B1\u26BD\u26BE\u26C4\u26C8\u26CF\u26D1\u26E9\u26F0-\u26F5\u26F7\u26F8\u26FA\u2702\u2708\u2709\u270F\u2712\u2714\u2716\u271D\u2721\u2733\u2734\u2744\u2747\u2757\u2763\u27A1\u2934\u2935\u2B05-\u2B07\u2B1B\u2B1C\u2B55\u3030\u303D\u3297\u3299]\uFE0F?|[\u261D\u270C\u270D](?:\uD83C[\uDFFB-\uDFFF]|\uFE0F)?|[\u270A\u270B](?:\uD83C[\uDFFB-\uDFFF])?|[\u23E9-\u23EC\u23F0\u23F3\u25FD\u2693\u26A1\u26AB\u26C5\u26CE\u26D4\u26EA\u26FD\u2705\u2728\u274C\u274E\u2753-\u2755\u2795-\u2797\u27B0\u27BF\u2B50]|\u26D3\uFE0F?(?:\u200D\uD83D\uDCA5)?|\u26F9(?:\uD83C[\uDFFB-\uDFFF]|\uFE0F)?(?:\u200D[\u2640\u2642]\uFE0F?)?|\u2764\uFE0F?(?:\u200D(?:\uD83D\uDD25|\uD83E\uDE79))?|\uD83C(?:[\uDC04\uDD70\uDD71\uDD7E\uDD7F\uDE02\uDE37\uDF21\uDF24-\uDF2C\uDF36\uDF7D\uDF96\uDF97\uDF99-\uDF9B\uDF9E\uDF9F\uDFCD\uDFCE\uDFD4-\uDFDF\uDFF5\uDFF7]\uFE0F?|[\uDF85\uDFC2\uDFC7](?:\uD83C[\uDFFB-\uDFFF])?|[\uDFC4\uDFCA](?:\uD83C[\uDFFB-\uDFFF])?(?:\u200D[\u2640\u2642]\uFE0F?)?|[\uDFCB\uDFCC](?:\uD83C[\uDFFB-\uDFFF]|\uFE0F)?(?:\u200D[\u2640\u2642]\uFE0F?)?|[\uDCCF\uDD8E\uDD91-\uDD9A\uDE01\uDE1A\uDE2F\uDE32-\uDE36\uDE38-\uDE3A\uDE50\uDE51\uDF00-\uDF20\uDF2D-\uDF35\uDF37-\uDF43\uDF45-\uDF4A\uDF4C-\uDF7C\uDF7E-\uDF84\uDF86-\uDF93\uDFA0-\uDFC1\uDFC5\uDFC6\uDFC8\uDFC9\uDFCF-\uDFD3\uDFE0-\uDFF0\uDFF8-\uDFFF]|\uDDE6\uD83C[\uDDE8-\uDDEC\uDDEE\uDDF1\uDDF2\uDDF4\uDDF6-\uDDFA\uDDFC\uDDFD\uDDFF]|\uDDE7\uD83C[\uDDE6\uDDE7\uDDE9-\uDDEF\uDDF1-\uDDF4\uDDF6-\uDDF9\uDDFB\uDDFC\uDDFE\uDDFF]|\uDDE8\uD83C[\uDDE6\uDDE8\uDDE9\uDDEB-\uDDEE\uDDF0-\uDDF7\uDDFA-\uDDFF]|\uDDE9\uD83C[\uDDEA\uDDEC\uDDEF\uDDF0\uDDF2\uDDF4\uDDFF]|\uDDEA\uD83C[\uDDE6\uDDE8\uDDEA\uDDEC\uDDED\uDDF7-\uDDFA]|\uDDEB\uD83C[\uDDEE-\uDDF0\uDDF2\uDDF4\uDDF7]|\uDDEC\uD83C[\uDDE6\uDDE7\uDDE9-\uDDEE\uDDF1-\uDDF3\uDDF5-\uDDFA\uDDFC\uDDFE]|\uDDED\uD83C[\uDDF0\uDDF2\uDDF3\uDDF7\uDDF9\uDDFA]|\uDDEE\uD83C[\uDDE8-\uDDEA\uDDF1-\uDDF4\uDDF6-\uDDF9]|\uDDEF\uD83C[\uDDEA\uDDF2\uDDF4\uDDF5]|\uDDF0\uD83C[\uDDEA\uDDEC-\uDDEE\uDDF2\uDDF3\uDDF5\uDDF7\uDDFC\uDDFE\uDDFF]|\uDDF1\uD83C[\uDDE6-\uDDE8\uDDEE\uDDF0\uDDF7-\uDDFB\uDDFE]|\uDDF2\uD83C[\uDDE6\uDDE8-\uDDED\uDDF0-\uDDFF]|\uDDF3\uD83C[\uDDE6\uDDE8\uDDEA-\uDDEC\uDDEE\uDDF1\uDDF4\uDDF5\uDDF7\uDDFA\uDDFF]|\uDDF4\uD83C\uDDF2|\uDDF5\uD83C[\uDDE6\uDDEA-\uDDED\uDDF0-\uDDF3\uDDF7-\uDDF9\uDDFC\uDDFE]|\uDDF6\uD83C\uDDE6|\uDDF7\uD83C[\uDDEA\uDDF4\uDDF8\uDDFA\uDDFC]|\uDDF8\uD83C[\uDDE6-\uDDEA\uDDEC-\uDDF4\uDDF7-\uDDF9\uDDFB\uDDFD-\uDDFF]|\uDDF9\uD83C[\uDDE6\uDDE8\uDDE9\uDDEB-\uDDED\uDDEF-\uDDF4\uDDF7\uDDF9\uDDFB\uDDFC\uDDFF]|\uDDFA\uD83C[\uDDE6\uDDEC\uDDF2\uDDF3\uDDF8\uDDFE\uDDFF]|\uDDFB\uD83C[\uDDE6\uDDE8\uDDEA\uDDEC\uDDEE\uDDF3\uDDFA]|\uDDFC\uD83C[\uDDEB\uDDF8]|\uDDFD\uD83C\uDDF0|\uDDFE\uD83C[\uDDEA\uDDF9]|\uDDFF\uD83C[\uDDE6\uDDF2\uDDFC]|\uDF44(?:\u200D\uD83D\uDFEB)?|\uDF4B(?:\u200D\uD83D\uDFE9)?|\uDFC3(?:\uD83C[\uDFFB-\uDFFF])?(?:\u200D(?:[\u2640\u2642]\uFE0F?(?:\u200D\u27A1\uFE0F?)?|\u27A1\uFE0F?))?|\uDFF3\uFE0F?(?:\u200D(?:\u26A7\uFE0F?|\uD83C\uDF08))?|\uDFF4(?:\u200D\u2620\uFE0F?|\uDB40\uDC67\uDB40\uDC62\uDB40(?:\uDC65\uDB40\uDC6E\uDB40\uDC67|\uDC73\uDB40\uDC63\uDB40\uDC74|\uDC77\uDB40\uDC6C\uDB40\uDC73)\uDB40\uDC7F)?)|\uD83D(?:[\uDC3F\uDCFD\uDD49\uDD4A\uDD6F\uDD70\uDD73\uDD76-\uDD79\uDD87\uDD8A-\uDD8D\uDDA5\uDDA8\uDDB1\uDDB2\uDDBC\uDDC2-\uDDC4\uDDD1-\uDDD3\uDDDC-\uDDDE\uDDE1\uDDE3\uDDE8\uDDEF\uDDF3\uDDFA\uDECB\uDECD-\uDECF\uDEE0-\uDEE5\uDEE9\uDEF0\uDEF3]\uFE0F?|[\uDC42\uDC43\uDC46-\uDC50\uDC66\uDC67\uDC6B-\uDC6D\uDC72\uDC74-\uDC76\uDC78\uDC7C\uDC83\uDC85\uDC8F\uDC91\uDCAA\uDD7A\uDD95\uDD96\uDE4C\uDE4F\uDEC0\uDECC](?:\uD83C[\uDFFB-\uDFFF])?|[\uDC6E\uDC70\uDC71\uDC73\uDC77\uDC81\uDC82\uDC86\uDC87\uDE45-\uDE47\uDE4B\uDE4D\uDE4E\uDEA3\uDEB4\uDEB5](?:\uD83C[\uDFFB-\uDFFF])?(?:\u200D[\u2640\u2642]\uFE0F?)?|[\uDD74\uDD90](?:\uD83C[\uDFFB-\uDFFF]|\uFE0F)?|[\uDC00-\uDC07\uDC09-\uDC14\uDC16-\uDC25\uDC27-\uDC3A\uDC3C-\uDC3E\uDC40\uDC44\uDC45\uDC51-\uDC65\uDC6A\uDC79-\uDC7B\uDC7D-\uDC80\uDC84\uDC88-\uDC8E\uDC90\uDC92-\uDCA9\uDCAB-\uDCFC\uDCFF-\uDD3D\uDD4B-\uDD4E\uDD50-\uDD67\uDDA4\uDDFB-\uDE2D\uDE2F-\uDE34\uDE37-\uDE41\uDE43\uDE44\uDE48-\uDE4A\uDE80-\uDEA2\uDEA4-\uDEB3\uDEB7-\uDEBF\uDEC1-\uDEC5\uDED0-\uDED2\uDED5-\uDED7\uDEDC-\uDEDF\uDEEB\uDEEC\uDEF4-\uDEFC\uDFE0-\uDFEB\uDFF0]|\uDC08(?:\u200D\u2B1B)?|\uDC15(?:\u200D\uD83E\uDDBA)?|\uDC26(?:\u200D(?:\u2B1B|\uD83D\uDD25))?|\uDC3B(?:\u200D\u2744\uFE0F?)?|\uDC41\uFE0F?(?:\u200D\uD83D\uDDE8\uFE0F?)?|\uDC68(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:\uDC8B\u200D\uD83D)?\uDC68|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D(?:[\uDC68\uDC69]\u200D\uD83D(?:\uDC66(?:\u200D\uD83D\uDC66)?|\uDC67(?:\u200D\uD83D[\uDC66\uDC67])?)|[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uDC66(?:\u200D\uD83D\uDC66)?|\uDC67(?:\u200D\uD83D[\uDC66\uDC67])?)|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]))|\uD83C(?:\uDFFB(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:\uDC8B\u200D\uD83D)?\uDC68\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]|\uDD1D\u200D\uD83D\uDC68\uD83C[\uDFFC-\uDFFF])))?|\uDFFC(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:\uDC8B\u200D\uD83D)?\uDC68\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]|\uDD1D\u200D\uD83D\uDC68\uD83C[\uDFFB\uDFFD-\uDFFF])))?|\uDFFD(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:\uDC8B\u200D\uD83D)?\uDC68\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]|\uDD1D\u200D\uD83D\uDC68\uD83C[\uDFFB\uDFFC\uDFFE\uDFFF])))?|\uDFFE(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:\uDC8B\u200D\uD83D)?\uDC68\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]|\uDD1D\u200D\uD83D\uDC68\uD83C[\uDFFB-\uDFFD\uDFFF])))?|\uDFFF(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:\uDC8B\u200D\uD83D)?\uDC68\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]|\uDD1D\u200D\uD83D\uDC68\uD83C[\uDFFB-\uDFFE])))?))?|\uDC69(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:\uDC8B\u200D\uD83D)?[\uDC68\uDC69]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D(?:[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uDC66(?:\u200D\uD83D\uDC66)?|\uDC67(?:\u200D\uD83D[\uDC66\uDC67])?|\uDC69\u200D\uD83D(?:\uDC66(?:\u200D\uD83D\uDC66)?|\uDC67(?:\u200D\uD83D[\uDC66\uDC67])?))|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]))|\uD83C(?:\uDFFB(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:[\uDC68\uDC69]|\uDC8B\u200D\uD83D[\uDC68\uDC69])\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]|\uDD1D\u200D\uD83D[\uDC68\uDC69]\uD83C[\uDFFC-\uDFFF])))?|\uDFFC(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:[\uDC68\uDC69]|\uDC8B\u200D\uD83D[\uDC68\uDC69])\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]|\uDD1D\u200D\uD83D[\uDC68\uDC69]\uD83C[\uDFFB\uDFFD-\uDFFF])))?|\uDFFD(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:[\uDC68\uDC69]|\uDC8B\u200D\uD83D[\uDC68\uDC69])\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]|\uDD1D\u200D\uD83D[\uDC68\uDC69]\uD83C[\uDFFB\uDFFC\uDFFE\uDFFF])))?|\uDFFE(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:[\uDC68\uDC69]|\uDC8B\u200D\uD83D[\uDC68\uDC69])\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]|\uDD1D\u200D\uD83D[\uDC68\uDC69]\uD83C[\uDFFB-\uDFFD\uDFFF])))?|\uDFFF(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:[\uDC68\uDC69]|\uDC8B\u200D\uD83D[\uDC68\uDC69])\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]|\uDD1D\u200D\uD83D[\uDC68\uDC69]\uD83C[\uDFFB-\uDFFE])))?))?|\uDC6F(?:\u200D[\u2640\u2642]\uFE0F?)?|\uDD75(?:\uD83C[\uDFFB-\uDFFF]|\uFE0F)?(?:\u200D[\u2640\u2642]\uFE0F?)?|\uDE2E(?:\u200D\uD83D\uDCA8)?|\uDE35(?:\u200D\uD83D\uDCAB)?|\uDE36(?:\u200D\uD83C\uDF2B\uFE0F?)?|\uDE42(?:\u200D[\u2194\u2195]\uFE0F?)?|\uDEB6(?:\uD83C[\uDFFB-\uDFFF])?(?:\u200D(?:[\u2640\u2642]\uFE0F?(?:\u200D\u27A1\uFE0F?)?|\u27A1\uFE0F?))?)|\uD83E(?:[\uDD0C\uDD0F\uDD18-\uDD1F\uDD30-\uDD34\uDD36\uDD77\uDDB5\uDDB6\uDDBB\uDDD2\uDDD3\uDDD5\uDEC3-\uDEC5\uDEF0\uDEF2-\uDEF8](?:\uD83C[\uDFFB-\uDFFF])?|[\uDD26\uDD35\uDD37-\uDD39\uDD3D\uDD3E\uDDB8\uDDB9\uDDCD\uDDCF\uDDD4\uDDD6-\uDDDD](?:\uD83C[\uDFFB-\uDFFF])?(?:\u200D[\u2640\u2642]\uFE0F?)?|[\uDDDE\uDDDF](?:\u200D[\u2640\u2642]\uFE0F?)?|[\uDD0D\uDD0E\uDD10-\uDD17\uDD20-\uDD25\uDD27-\uDD2F\uDD3A\uDD3F-\uDD45\uDD47-\uDD76\uDD78-\uDDB4\uDDB7\uDDBA\uDDBC-\uDDCC\uDDD0\uDDE0-\uDDFF\uDE70-\uDE7C\uDE80-\uDE89\uDE8F-\uDEC2\uDEC6\uDECE-\uDEDC\uDEDF-\uDEE9]|\uDD3C(?:\u200D[\u2640\u2642]\uFE0F?|\uD83C[\uDFFB-\uDFFF])?|\uDDCE(?:\uD83C[\uDFFB-\uDFFF])?(?:\u200D(?:[\u2640\u2642]\uFE0F?(?:\u200D\u27A1\uFE0F?)?|\u27A1\uFE0F?))?|\uDDD1(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\uD83C[\uDF3E\uDF73\uDF7C\uDF84\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]|\uDD1D\u200D\uD83E\uDDD1|\uDDD1\u200D\uD83E\uDDD2(?:\u200D\uD83E\uDDD2)?|\uDDD2(?:\u200D\uD83E\uDDD2)?))|\uD83C(?:\uDFFB(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D(?:\uD83D\uDC8B\u200D)?\uD83E\uDDD1\uD83C[\uDFFC-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF84\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]|\uDD1D\u200D\uD83E\uDDD1\uD83C[\uDFFB-\uDFFF])))?|\uDFFC(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D(?:\uD83D\uDC8B\u200D)?\uD83E\uDDD1\uD83C[\uDFFB\uDFFD-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF84\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]|\uDD1D\u200D\uD83E\uDDD1\uD83C[\uDFFB-\uDFFF])))?|\uDFFD(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D(?:\uD83D\uDC8B\u200D)?\uD83E\uDDD1\uD83C[\uDFFB\uDFFC\uDFFE\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF84\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]|\uDD1D\u200D\uD83E\uDDD1\uD83C[\uDFFB-\uDFFF])))?|\uDFFE(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D(?:\uD83D\uDC8B\u200D)?\uD83E\uDDD1\uD83C[\uDFFB-\uDFFD\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF84\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]|\uDD1D\u200D\uD83E\uDDD1\uD83C[\uDFFB-\uDFFF])))?|\uDFFF(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D(?:\uD83D\uDC8B\u200D)?\uD83E\uDDD1\uD83C[\uDFFB-\uDFFE]|\uD83C[\uDF3E\uDF73\uDF7C\uDF84\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]|\uDD1D\u200D\uD83E\uDDD1\uD83C[\uDFFB-\uDFFF])))?))?|\uDEF1(?:\uD83C(?:\uDFFB(?:\u200D\uD83E\uDEF2\uD83C[\uDFFC-\uDFFF])?|\uDFFC(?:\u200D\uD83E\uDEF2\uD83C[\uDFFB\uDFFD-\uDFFF])?|\uDFFD(?:\u200D\uD83E\uDEF2\uD83C[\uDFFB\uDFFC\uDFFE\uDFFF])?|\uDFFE(?:\u200D\uD83E\uDEF2\uD83C[\uDFFB-\uDFFD\uDFFF])?|\uDFFF(?:\u200D\uD83E\uDEF2\uD83C[\uDFFB-\uDFFE])?))?)/g; + }; + } +}); + +// node_modules/get-east-asian-width/lookup.js +function isFullWidth(x) { + return x === 12288 || x >= 65281 && x <= 65376 || x >= 65504 && x <= 65510; +} +function isWide(x) { + return x >= 4352 && x <= 4447 || x === 8986 || x === 8987 || x === 9001 || x === 9002 || x >= 9193 && x <= 9196 || x === 9200 || x === 9203 || x === 9725 || x === 9726 || x === 9748 || x === 9749 || x >= 9776 && x <= 9783 || x >= 9800 && x <= 9811 || x === 9855 || x >= 9866 && x <= 9871 || x === 9875 || x === 9889 || x === 9898 || x === 9899 || x === 9917 || x === 9918 || x === 9924 || x === 9925 || x === 9934 || x === 9940 || x === 9962 || x === 9970 || x === 9971 || x === 9973 || x === 9978 || x === 9981 || x === 9989 || x === 9994 || x === 9995 || x === 10024 || x === 10060 || x === 10062 || x >= 10067 && x <= 10069 || x === 10071 || x >= 10133 && x <= 10135 || x === 10160 || x === 10175 || x === 11035 || x === 11036 || x === 11088 || x === 11093 || x >= 11904 && x <= 11929 || x >= 11931 && x <= 12019 || x >= 12032 && x <= 12245 || x >= 12272 && x <= 12287 || x >= 12289 && x <= 12350 || x >= 12353 && x <= 12438 || x >= 12441 && x <= 12543 || x >= 12549 && x <= 12591 || x >= 12593 && x <= 12686 || x >= 12688 && x <= 12773 || x >= 12783 && x <= 12830 || x >= 12832 && x <= 12871 || x >= 12880 && x <= 42124 || x >= 42128 && x <= 42182 || x >= 43360 && x <= 43388 || x >= 44032 && x <= 55203 || x >= 63744 && x <= 64255 || x >= 65040 && x <= 65049 || x >= 65072 && x <= 65106 || x >= 65108 && x <= 65126 || x >= 65128 && x <= 65131 || x >= 94176 && x <= 94180 || x === 94192 || x === 94193 || x >= 94208 && x <= 100343 || x >= 100352 && x <= 101589 || x >= 101631 && x <= 101640 || x >= 110576 && x <= 110579 || x >= 110581 && x <= 110587 || x === 110589 || x === 110590 || x >= 110592 && x <= 110882 || x === 110898 || x >= 110928 && x <= 110930 || x === 110933 || x >= 110948 && x <= 110951 || x >= 110960 && x <= 111355 || x >= 119552 && x <= 119638 || x >= 119648 && x <= 119670 || x === 126980 || x === 127183 || x === 127374 || x >= 127377 && x <= 127386 || x >= 127488 && x <= 127490 || x >= 127504 && x <= 127547 || x >= 127552 && x <= 127560 || x === 127568 || x === 127569 || x >= 127584 && x <= 127589 || x >= 127744 && x <= 127776 || x >= 127789 && x <= 127797 || x >= 127799 && x <= 127868 || x >= 127870 && x <= 127891 || x >= 127904 && x <= 127946 || x >= 127951 && x <= 127955 || x >= 127968 && x <= 127984 || x === 127988 || x >= 127992 && x <= 128062 || x === 128064 || x >= 128066 && x <= 128252 || x >= 128255 && x <= 128317 || x >= 128331 && x <= 128334 || x >= 128336 && x <= 128359 || x === 128378 || x === 128405 || x === 128406 || x === 128420 || x >= 128507 && x <= 128591 || x >= 128640 && x <= 128709 || x === 128716 || x >= 128720 && x <= 128722 || x >= 128725 && x <= 128727 || x >= 128732 && x <= 128735 || x === 128747 || x === 128748 || x >= 128756 && x <= 128764 || x >= 128992 && x <= 129003 || x === 129008 || x >= 129292 && x <= 129338 || x >= 129340 && x <= 129349 || x >= 129351 && x <= 129535 || x >= 129648 && x <= 129660 || x >= 129664 && x <= 129673 || x >= 129679 && x <= 129734 || x >= 129742 && x <= 129756 || x >= 129759 && x <= 129769 || x >= 129776 && x <= 129784 || x >= 131072 && x <= 196605 || x >= 196608 && x <= 262141; +} +var init_lookup = __esm({ + "node_modules/get-east-asian-width/lookup.js"() { + } +}); + +// node_modules/get-east-asian-width/index.js +var _isNarrowWidth; +var init_get_east_asian_width = __esm({ + "node_modules/get-east-asian-width/index.js"() { + init_lookup(); + _isNarrowWidth = (codePoint) => !(isFullWidth(codePoint) || isWide(codePoint)); + } +}); + +// src/utils/get-string-width.js +function getStringWidth(text) { + if (!text) { + return 0; + } + if (!notAsciiRegex.test(text)) { + return text.length; + } + text = text.replace(emoji_regex_default(), " "); + let width = 0; + for (const character of text) { + const codePoint = character.codePointAt(0); + if (codePoint <= 31 || codePoint >= 127 && codePoint <= 159) { + continue; + } + if (codePoint >= 768 && codePoint <= 879) { + continue; + } + width += _isNarrowWidth(codePoint) ? 1 : 2; + } + return width; +} +var notAsciiRegex, get_string_width_default; +var init_get_string_width = __esm({ + "src/utils/get-string-width.js"() { + init_emoji_regex(); + init_get_east_asian_width(); + notAsciiRegex = /[^\x20-\x7F]/u; + get_string_width_default = getStringWidth; + } +}); + +// src/utils/has-newline-in-range.js +function hasNewlineInRange(text, startIndex, endIndex) { + for (let i = startIndex; i < endIndex; ++i) { + if (text.charAt(i) === "\n") { + return true; + } + } + return false; +} +var has_newline_in_range_default; +var init_has_newline_in_range = __esm({ + "src/utils/has-newline-in-range.js"() { + has_newline_in_range_default = hasNewlineInRange; + } +}); + +// src/utils/has-spaces.js +function hasSpaces(text, startIndex, options = {}) { + const idx = skipSpaces( + text, + options.backwards ? startIndex - 1 : startIndex, + options + ); + return idx !== startIndex; +} +var has_spaces_default; +var init_has_spaces = __esm({ + "src/utils/has-spaces.js"() { + init_skip(); + has_spaces_default = hasSpaces; + } +}); + +// scripts/build/shims/string-replace-all.js +var stringReplaceAll, string_replace_all_default; +var init_string_replace_all = __esm({ + "scripts/build/shims/string-replace-all.js"() { + stringReplaceAll = (isOptionalObject, original, pattern, replacement) => { + if (isOptionalObject && (original === void 0 || original === null)) { + return; + } + if (original.replaceAll) { + return original.replaceAll(pattern, replacement); + } + if (pattern.global) { + return original.replace(pattern, replacement); + } + return original.split(pattern).join(replacement); + }; + string_replace_all_default = stringReplaceAll; + } +}); + +// src/utils/make-string.js +function makeString(rawText, enclosingQuote, unescapeUnnecessaryEscapes) { + const otherQuote = enclosingQuote === '"' ? "'" : '"'; + const regex = /\\(.)|(["'])/gsu; + const raw = string_replace_all_default( + /* isOptionalObject */ + false, + rawText, + regex, + (match, escaped, quote) => { + if (escaped === otherQuote) { + return escaped; + } + if (quote === enclosingQuote) { + return "\\" + quote; + } + if (quote) { + return quote; + } + return unescapeUnnecessaryEscapes && /^[^\n\r"'0-7\\bfnrt-vx\u2028\u2029]$/u.test(escaped) ? escaped : "\\" + escaped; + } + ); + return enclosingQuote + raw + enclosingQuote; +} +var make_string_default; +var init_make_string = __esm({ + "src/utils/make-string.js"() { + init_string_replace_all(); + make_string_default = makeString; + } +}); + +// src/utils/public.js +var public_exports = {}; +__export(public_exports, { + addDanglingComment: () => addDanglingComment, + addLeadingComment: () => addLeadingComment, + addTrailingComment: () => addTrailingComment, + getAlignmentSize: () => get_alignment_size_default, + getIndentSize: () => get_indent_size_default, + getMaxContinuousCount: () => get_max_continuous_count_default, + getNextNonSpaceNonCommentCharacter: () => get_next_non_space_non_comment_character_default, + getNextNonSpaceNonCommentCharacterIndex: () => getNextNonSpaceNonCommentCharacterIndex2, + getPreferredQuote: () => get_preferred_quote_default, + getStringWidth: () => get_string_width_default, + hasNewline: () => has_newline_default, + hasNewlineInRange: () => has_newline_in_range_default, + hasSpaces: () => has_spaces_default, + isNextLineEmpty: () => isNextLineEmpty2, + isNextLineEmptyAfterIndex: () => is_next_line_empty_default, + isPreviousLineEmpty: () => isPreviousLineEmpty2, + makeString: () => make_string_default, + skip: () => skip, + skipEverythingButNewLine: () => skipEverythingButNewLine, + skipInlineComment: () => skip_inline_comment_default, + skipNewline: () => skip_newline_default, + skipSpaces: () => skipSpaces, + skipToLineEnd: () => skipToLineEnd, + skipTrailingComment: () => skip_trailing_comment_default, + skipWhitespace: () => skipWhitespace +}); +function legacyGetNextNonSpaceNonCommentCharacterIndex(text, node, locEnd) { + return get_next_non_space_non_comment_character_index_default( + text, + locEnd(node) + ); +} +function getNextNonSpaceNonCommentCharacterIndex2(text, startIndex) { + return arguments.length === 2 || typeof startIndex === "number" ? get_next_non_space_non_comment_character_index_default(text, startIndex) : ( + // @ts-expect-error -- expected + // eslint-disable-next-line prefer-rest-params + legacyGetNextNonSpaceNonCommentCharacterIndex(...arguments) + ); +} +function legacyIsPreviousLineEmpty(text, node, locStart) { + return is_previous_line_empty_default(text, locStart(node)); +} +function isPreviousLineEmpty2(text, startIndex) { + return arguments.length === 2 || typeof startIndex === "number" ? is_previous_line_empty_default(text, startIndex) : ( + // @ts-expect-error -- expected + // eslint-disable-next-line prefer-rest-params + legacyIsPreviousLineEmpty(...arguments) + ); +} +function legacyIsNextLineEmpty(text, node, locEnd) { + return is_next_line_empty_default(text, locEnd(node)); +} +function isNextLineEmpty2(text, startIndex) { + return arguments.length === 2 || typeof startIndex === "number" ? is_next_line_empty_default(text, startIndex) : ( + // @ts-expect-error -- expected + // eslint-disable-next-line prefer-rest-params + legacyIsNextLineEmpty(...arguments) + ); +} +var init_public = __esm({ + "src/utils/public.js"() { + init_get_next_non_space_non_comment_character_index(); + init_is_next_line_empty(); + init_is_previous_line_empty(); + init_utils(); + init_get_alignment_size(); + init_get_indent_size(); + init_get_max_continuous_count(); + init_get_next_non_space_non_comment_character(); + init_get_preferred_quote(); + init_get_string_width(); + init_has_newline(); + init_has_newline_in_range(); + init_has_spaces(); + init_make_string(); + init_skip(); + init_skip_inline_comment(); + init_skip_newline(); + init_skip_trailing_comment(); + } +}); + +// src/main/version.evaluate.cjs +var require_version_evaluate = __commonJS({ + "src/main/version.evaluate.cjs"(exports2, module2) { + module2.exports = "3.5.3"; + } +}); + +// src/index.cjs +var prettierPromise = import("./index.mjs"); +var functionNames = [ + "formatWithCursor", + "format", + "check", + "resolveConfig", + "resolveConfigFile", + "clearConfigCache", + "getFileInfo", + "getSupportInfo" +]; +var prettier = /* @__PURE__ */ Object.create(null); +for (const name of functionNames) { + prettier[name] = async (...args) => { + const prettier2 = await prettierPromise; + return prettier2[name](...args); + }; +} +var debugApiFunctionNames = [ + "parse", + "formatAST", + "formatDoc", + "printToDoc", + "printDocToString" +]; +var debugApis = /* @__PURE__ */ Object.create(null); +for (const name of debugApiFunctionNames) { + debugApis[name] = async (...args) => { + const prettier2 = await prettierPromise; + return prettier2.__debug[name](...args); + }; +} +prettier.__debug = debugApis; +if (true) { + prettier.util = (init_public(), __toCommonJS(public_exports)); + prettier.doc = require("./doc.js"); +} else { + Object.defineProperties(prettier, { + util: { + get() { + try { + return null; + } catch { + } + throw new Error( + "prettier.util is not available in development CommonJS version" + ); + } + }, + doc: { + get() { + try { + return null; + } catch { + } + throw new Error( + "prettier.doc is not available in development CommonJS version" + ); + } + } + }); +} +prettier.version = require_version_evaluate(); +module.exports = prettier; diff --git a/node_modules/prettier/index.d.ts b/node_modules/prettier/index.d.ts new file mode 100644 index 0000000..589790e --- /dev/null +++ b/node_modules/prettier/index.d.ts @@ -0,0 +1,956 @@ +// Copied from `@types/prettier` +// https://github.com/DefinitelyTyped/DefinitelyTyped/blob/5bb07fc4b087cb7ee91084afa6fe750551a7bbb1/types/prettier/index.d.ts + +// Minimum TypeScript Version: 4.2 + +// Add `export {}` here to shut off automatic exporting from index.d.ts. There +// are quite a few utility types here that don't need to be shipped with the +// exported module. +export {}; + +import { builders, printer, utils } from "./doc.js"; + +export namespace doc { + export { builders, printer, utils }; +} + +// This utility is here to handle the case where you have an explicit union +// between string literals and the generic string type. It would normally +// resolve out to just the string type, but this generic LiteralUnion maintains +// the intellisense of the original union. +// +// It comes from this issue: microsoft/TypeScript#29729: +// https://github.com/microsoft/TypeScript/issues/29729#issuecomment-700527227 +export type LiteralUnion = + | T + | (Pick & { _?: never | undefined }); + +export type AST = any; +export type Doc = doc.builders.Doc; + +// The type of elements that make up the given array T. +type ArrayElement = T extends Array ? E : never; + +// A union of the properties of the given object that are arrays. +type ArrayProperties = { + [K in keyof T]: NonNullable extends readonly any[] ? K : never; +}[keyof T]; + +// A union of the properties of the given array T that can be used to index it. +// If the array is a tuple, then that's going to be the explicit indices of the +// array, otherwise it's going to just be number. +type IndexProperties = + IsTuple extends true ? Exclude["length"], T["length"]> : number; + +// Effectively performing T[P], except that it's telling TypeScript that it's +// safe to do this for tuples, arrays, or objects. +type IndexValue = T extends any[] + ? P extends number + ? T[P] + : never + : P extends keyof T + ? T[P] + : never; + +// Determines if an object T is an array like string[] (in which case this +// evaluates to false) or a tuple like [string] (in which case this evaluates to +// true). +// eslint-disable-next-line @typescript-eslint/no-unused-vars +type IsTuple = T extends [] + ? true + : T extends [infer First, ...infer Remain] + ? IsTuple + : false; + +type CallProperties = T extends any[] ? IndexProperties : keyof T; +type IterProperties = T extends any[] + ? IndexProperties + : ArrayProperties; + +type CallCallback = (path: AstPath, index: number, value: any) => U; +type EachCallback = ( + path: AstPath>, + index: number, + value: any, +) => void; +type MapCallback = ( + path: AstPath>, + index: number, + value: any, +) => U; + +// https://github.com/prettier/prettier/blob/next/src/common/ast-path.js +export class AstPath { + constructor(value: T); + + get key(): string | null; + get index(): number | null; + get node(): T; + get parent(): T | null; + get grandparent(): T | null; + get isInArray(): boolean; + get siblings(): T[] | null; + get next(): T | null; + get previous(): T | null; + get isFirst(): boolean; + get isLast(): boolean; + get isRoot(): boolean; + get root(): T; + get ancestors(): T[]; + + stack: T[]; + + callParent(callback: (path: this) => U, count?: number): U; + + /** + * @deprecated Please use `AstPath#key` or `AstPath#index` + */ + getName(): PropertyKey | null; + + /** + * @deprecated Please use `AstPath#node` or `AstPath#siblings` + */ + getValue(): T; + + getNode(count?: number): T | null; + + getParentNode(count?: number): T | null; + + match( + ...predicates: Array< + (node: any, name: string | null, number: number | null) => boolean + > + ): boolean; + + // For each of the tree walk functions (call, each, and map) this provides 5 + // strict type signatures, along with a fallback at the end if you end up + // calling more than 5 properties deep. This helps a lot with typing because + // for the majority of cases you're calling fewer than 5 properties, so the + // tree walk functions have a clearer understanding of what you're doing. + // + // Note that resolving these types is somewhat complicated, and it wasn't + // even supported until TypeScript 4.2 (before it would just say that the + // type instantiation was excessively deep and possibly infinite). + + call(callback: CallCallback): U; + call>( + callback: CallCallback, U>, + prop1: P1, + ): U; + call>( + callback: CallCallback, P2>, U>, + prop1: P1, + prop2: P2, + ): U; + call< + U, + P1 extends keyof T, + P2 extends CallProperties, + P3 extends CallProperties>, + >( + callback: CallCallback< + IndexValue, P2>, P3>, + U + >, + prop1: P1, + prop2: P2, + prop3: P3, + ): U; + call< + U, + P1 extends keyof T, + P2 extends CallProperties, + P3 extends CallProperties>, + P4 extends CallProperties, P3>>, + >( + callback: CallCallback< + IndexValue, P2>, P3>, P4>, + U + >, + prop1: P1, + prop2: P2, + prop3: P3, + prop4: P4, + ): U; + call( + callback: CallCallback, + prop1: P, + prop2: P, + prop3: P, + prop4: P, + ...props: P[] + ): U; + + each(callback: EachCallback): void; + each>( + callback: EachCallback>, + prop1: P1, + ): void; + each>( + callback: EachCallback, P2>>, + prop1: P1, + prop2: P2, + ): void; + each< + P1 extends keyof T, + P2 extends IterProperties, + P3 extends IterProperties>, + >( + callback: EachCallback, P2>, P3>>, + prop1: P1, + prop2: P2, + prop3: P3, + ): void; + each< + P1 extends keyof T, + P2 extends IterProperties, + P3 extends IterProperties>, + P4 extends IterProperties, P3>>, + >( + callback: EachCallback< + IndexValue, P2>, P3>, P4> + >, + prop1: P1, + prop2: P2, + prop3: P3, + prop4: P4, + ): void; + each( + callback: EachCallback, + prop1: PropertyKey, + prop2: PropertyKey, + prop3: PropertyKey, + prop4: PropertyKey, + ...props: PropertyKey[] + ): void; + + map(callback: MapCallback): U[]; + map>( + callback: MapCallback, U>, + prop1: P1, + ): U[]; + map>( + callback: MapCallback, P2>, U>, + prop1: P1, + prop2: P2, + ): U[]; + map< + U, + P1 extends keyof T, + P2 extends IterProperties, + P3 extends IterProperties>, + >( + callback: MapCallback, P2>, P3>, U>, + prop1: P1, + prop2: P2, + prop3: P3, + ): U[]; + map< + U, + P1 extends keyof T, + P2 extends IterProperties, + P3 extends IterProperties>, + P4 extends IterProperties, P3>>, + >( + callback: MapCallback< + IndexValue, P2>, P3>, P4>, + U + >, + prop1: P1, + prop2: P2, + prop3: P3, + prop4: P4, + ): U[]; + map( + callback: MapCallback, + prop1: PropertyKey, + prop2: PropertyKey, + prop3: PropertyKey, + prop4: PropertyKey, + ...props: PropertyKey[] + ): U[]; +} + +/** @deprecated `FastPath` was renamed to `AstPath` */ +export type FastPath = AstPath; + +export type BuiltInParser = (text: string, options?: any) => AST; +export type BuiltInParserName = + | "acorn" + | "angular" + | "babel-flow" + | "babel-ts" + | "babel" + | "css" + | "espree" + | "flow" + | "glimmer" + | "graphql" + | "html" + | "json-stringify" + | "json" + | "json5" + | "jsonc" + | "less" + | "lwc" + | "markdown" + | "mdx" + | "meriyah" + | "scss" + | "typescript" + | "vue" + | "yaml"; +export type BuiltInParsers = Record; + +/** + * For use in `.prettierrc.js`, `.prettierrc.ts`, `.prettierrc.cjs`, `.prettierrc.cts`, `prettierrc.mjs`, `prettierrc.mts`, `prettier.config.js`, `prettier.config.ts`, `prettier.config.cjs`, `prettier.config.cts`, `prettier.config.mjs`, `prettier.config.mts` + */ +export interface Config extends Options { + overrides?: Array<{ + files: string | string[]; + excludeFiles?: string | string[]; + options?: Options; + }>; +} + +export interface Options extends Partial {} + +export interface RequiredOptions extends doc.printer.Options { + /** + * Print semicolons at the ends of statements. + * @default true + */ + semi: boolean; + /** + * Use single quotes instead of double quotes. + * @default false + */ + singleQuote: boolean; + /** + * Use single quotes in JSX. + * @default false + */ + jsxSingleQuote: boolean; + /** + * Print trailing commas wherever possible. + * @default "all" + */ + trailingComma: "none" | "es5" | "all"; + /** + * Print spaces between brackets in object literals. + * @default true + */ + bracketSpacing: boolean; + /** + * How to wrap object literals. + * @default "preserve" + */ + objectWrap: "preserve" | "collapse"; + /** + * Put the `>` of a multi-line HTML (HTML, JSX, Vue, Angular) element at the end of the last line instead of being + * alone on the next line (does not apply to self closing elements). + * @default false + */ + bracketSameLine: boolean; + /** + * Format only a segment of a file. + * @default 0 + */ + rangeStart: number; + /** + * Format only a segment of a file. + * @default Number.POSITIVE_INFINITY + */ + rangeEnd: number; + /** + * Specify which parser to use. + */ + parser: LiteralUnion; + /** + * Specify the input filepath. This will be used to do parser inference. + */ + filepath: string; + /** + * Prettier can restrict itself to only format files that contain a special comment, called a pragma, at the top of the file. + * This is very useful when gradually transitioning large, unformatted codebases to prettier. + * @default false + */ + requirePragma: boolean; + /** + * Prettier can insert a special @format marker at the top of files specifying that + * the file has been formatted with prettier. This works well when used in tandem with + * the --require-pragma option. If there is already a docblock at the top of + * the file then this option will add a newline to it with the @format marker. + * @default false + */ + insertPragma: boolean; + /** + * By default, Prettier will wrap markdown text as-is since some services use a linebreak-sensitive renderer. + * In some cases you may want to rely on editor/viewer soft wrapping instead, so this option allows you to opt out. + * @default "preserve" + */ + proseWrap: "always" | "never" | "preserve"; + /** + * Include parentheses around a sole arrow function parameter. + * @default "always" + */ + arrowParens: "avoid" | "always"; + /** + * Provide ability to support new languages to prettier. + */ + plugins: Array; + /** + * How to handle whitespaces in HTML. + * @default "css" + */ + htmlWhitespaceSensitivity: "css" | "strict" | "ignore"; + /** + * Which end of line characters to apply. + * @default "lf" + */ + endOfLine: "auto" | "lf" | "crlf" | "cr"; + /** + * Change when properties in objects are quoted. + * @default "as-needed" + */ + quoteProps: "as-needed" | "consistent" | "preserve"; + /** + * Whether or not to indent the code inside +``` + +## Use + +```js +import fs from 'node:fs' +import path from 'node:path' +import process from 'node:process' +import {trough} from 'trough' + +const pipeline = trough() + .use(function (fileName) { + console.log('Checking… ' + fileName) + }) + .use(function (fileName) { + return path.join(process.cwd(), fileName) + }) + .use(function (filePath, next) { + fs.stat(filePath, function (error, stats) { + next(error, {filePath, stats}) + }) + }) + .use(function (ctx, next) { + if (ctx.stats.isFile()) { + fs.readFile(ctx.filePath, next) + } else { + next(new Error('Expected file')) + } + }) + +pipeline.run('readme.md', console.log) +pipeline.run('node_modules', console.log) +``` + +Yields: + +```txt +Checking… readme.md +Checking… node_modules +Error: Expected file + at ~/example.js:22:12 + at wrapped (~/node_modules/trough/index.js:111:16) + at next (~/node_modules/trough/index.js:62:23) + at done (~/node_modules/trough/index.js:145:7) + at ~/example.js:15:7 + at FSReqCallback.oncomplete (node:fs:199:5) +null +``` + +## API + +This package exports the identifiers +[`trough`][api-trough] and +[`wrap`][api-wrap]. +There is no default export. + +It exports the [TypeScript][] types +[`Callback`][api-callback], +[`Middleware`][api-middleware], +[`Pipeline`][api-pipeline], +[`Run`][api-run], +and [`Use`][api-use]. + +### `trough()` + +Create new middleware. + +###### Parameters + +There are no parameters. + +###### Returns + +[`Pipeline`][api-pipeline]. + +### `wrap(middleware, callback)` + +Wrap `middleware` into a uniform interface. + +You can pass all input to the resulting function. +`callback` is then called with the output of `middleware`. + +If `middleware` accepts more arguments than the later given in input, +an extra `done` function is passed to it after that input, +which must be called by `middleware`. + +The first value in `input` is the main input value. +All other input values are the rest input values. +The values given to `callback` are the input values, +merged with every non-nullish output value. + +* if `middleware` throws an error, + returns a promise that is rejected, + or calls the given `done` function with an error, + `callback` is called with that error +* if `middleware` returns a value or returns a promise that is resolved, + that value is the main output value +* if `middleware` calls `done`, + all non-nullish values except for the first one (the error) overwrite the + output values + +###### Parameters + +* `middleware` ([`Middleware`][api-middleware]) + — function to wrap +* `callback` ([`Callback`][api-callback]) + — callback called with the output of `middleware` + +###### Returns + +Wrapped middleware ([`Run`][api-run]). + +### `Callback` + +Callback function (TypeScript type). + +###### Parameters + +* `error` (`Error`, optional) + — error, if any +* `...output` (`Array`, optional) + — output values + +###### Returns + +Nothing (`undefined`). + +### `Middleware` + +A middleware function called with the output of its predecessor (TypeScript +type). + +###### Synchronous + +If `fn` returns or throws an error, +the pipeline fails and `done` is called with that error. + +If `fn` returns a value (neither `null` nor `undefined`), +the first `input` of the next function is set to that value +(all other `input` is passed through). + +The following example shows how returning an error stops the pipeline: + +```js +import {trough} from 'trough' + +trough() + .use(function (thing) { + return new Error('Got: ' + thing) + }) + .run('some value', console.log) +``` + +Yields: + +```txt +Error: Got: some value + at ~/example.js:5:12 + … +``` + +The following example shows how throwing an error stops the pipeline: + +```js +import {trough} from 'trough' + +trough() + .use(function (thing) { + throw new Error('Got: ' + thing) + }) + .run('more value', console.log) +``` + +Yields: + +```txt +Error: Got: more value + at ~/example.js:5:11 + … +``` + +The following example shows how the first output can be modified: + +```js +import {trough} from 'trough' + +trough() + .use(function (thing) { + return 'even ' + thing + }) + .run('more value', 'untouched', console.log) +``` + +Yields: + +```txt +null 'even more value' 'untouched' +``` + +###### Promise + +If `fn` returns a promise, +and that promise rejects, +the pipeline fails and `done` is called with the rejected value. + +If `fn` returns a promise, +and that promise resolves with a value (neither `null` nor `undefined`), +the first `input` of the next function is set to that value (all other `input` +is passed through). + +The following example shows how rejecting a promise stops the pipeline: + +```js +import {trough} from 'trough' + +trough() + .use(function (thing) { + return new Promise(function (resolve, reject) { + reject('Got: ' + thing) + }) + }) + .run('thing', console.log) +``` + +Yields: + +```txt +Got: thing +``` + +The following example shows how the input isn’t touched by resolving to `null`. + +```js +import {trough} from 'trough' + +trough() + .use(function () { + return new Promise(function (resolve) { + setTimeout(function () { + resolve(null) + }, 100) + }) + }) + .run('Input', console.log) +``` + +Yields: + +```txt +null 'Input' +``` + +###### Asynchronous + +If `fn` accepts one more argument than the given `input`, +a `next` function is given (after the input). +`next` must be called, but doesn’t have to be called async. + +If `next` is given a value (neither `null` nor `undefined`) as its first +argument, +the pipeline fails and `done` is called with that value. + +If `next` is given no value (either `null` or `undefined`) as the first +argument, +all following non-nullish values change the input of the following +function, +and all nullish values default to the `input`. + +The following example shows how passing a first argument stops the pipeline: + +```js +import {trough} from 'trough' + +trough() + .use(function (thing, next) { + next(new Error('Got: ' + thing)) + }) + .run('thing', console.log) +``` + +Yields: + +```txt +Error: Got: thing + at ~/example.js:5:10 +``` + +The following example shows how more values than the input are passed. + +```js +import {trough} from 'trough' + +trough() + .use(function (thing, next) { + setTimeout(function () { + next(null, null, 'values') + }, 100) + }) + .run('some', console.log) +``` + +Yields: + +```txt +null 'some' 'values' +``` + +###### Parameters + +* `...input` (`Array`, optional) + — input values + +###### Returns + +Output, promise, etc (`any`). + +### `Pipeline` + +Pipeline (TypeScript type). + +###### Properties + +* `run` ([`Run`][api-run]) + — run the pipeline +* `use` ([`Use`][api-use]) + — add middleware + +### `Run` + +Call all middleware (TypeScript type). + +Calls `done` on completion with either an error or the output of the +last middleware. + +> 👉 **Note**: as the length of input defines whether async functions get a +> `next` function, +> it’s recommended to keep `input` at one value normally. + +###### Parameters + +* `...input` (`Array`, optional) + — input values +* `done` ([`Callback`][api-callback]) + — callback called when done + +###### Returns + +Nothing (`undefined`). + +### `Use` + +Add middleware (TypeScript type). + +###### Parameters + +* `middleware` ([`Middleware`][api-middleware]) + — middleware function + +###### Returns + +Current pipeline ([`Pipeline`][api-pipeline]). + +## Compatibility + +This projects is compatible with maintained versions of Node.js. + +When we cut a new major release, +we drop support for unmaintained versions of Node. +This means we try to keep the current release line, +`trough@2`, +compatible with Node.js 12. + +## Security + +This package is safe. + +## Contribute + +Yes please! +See [How to Contribute to Open Source][open-source-guide-contribute]. + +## License + +[MIT][file-license] © [Titus Wormer][wooorm] + + + +[api-callback]: #callback + +[api-middleware]: #middleware + +[api-pipeline]: #pipeline + +[api-run]: #run + +[api-trough]: #trough + +[api-use]: #use + +[api-wrap]: #wrapmiddleware-callback + +[badge-build-image]: https://github.com/wooorm/trough/workflows/main/badge.svg + +[badge-build-url]: https://github.com/wooorm/trough/actions + +[badge-coverage-image]: https://img.shields.io/codecov/c/github/wooorm/trough.svg + +[badge-coverage-url]: https://codecov.io/github/wooorm/trough + +[badge-downloads-image]: https://img.shields.io/npm/dm/trough.svg + +[badge-downloads-url]: https://www.npmjs.com/package/trough + +[badge-size-image]: https://img.shields.io/bundlejs/size/trough + +[badge-size-url]: https://bundlejs.com/?q=trough + +[npm-install]: https://docs.npmjs.com/cli/install + +[esm-sh]: https://esm.sh + +[file-license]: license + +[github-gist-esm]: https://gist.github.com/sindresorhus/a39789f98801d908bbc7ff3ecc99d99c + +[github-segmentio-ware]: https://github.com/segmentio/ware + +[open-source-guide-contribute]: https://opensource.guide/how-to-contribute/ + +[typescript]: https://www.typescriptlang.org + +[wooorm]: https://wooorm.com diff --git a/node_modules/unified/index.d.ts b/node_modules/unified/index.d.ts new file mode 100644 index 0000000..09db6f2 --- /dev/null +++ b/node_modules/unified/index.d.ts @@ -0,0 +1,863 @@ +// TypeScript Version: 4.0 + +// Note: this is a `.d.ts` file because it is not possible to have default type +// parameters in JSDoc-based TypeScript, which is a feature we use to type that: +// +// ```js +// .use(somePlugin, theOptions) +// ``` +// +// `theOptions` matches the options that `somePlugin` expects and thus is very +// important for making unified usable in TypeScript. +// +// Furthermore, this is places in the root of the project because types that +// accept type parameters cannot be re-exported as such easily. + +import {Node} from 'unist' +import {VFile, VFileCompatible} from 'vfile' + +/* eslint-disable @typescript-eslint/naming-convention */ + +type VFileWithOutput = Result extends Uint8Array // Buffer. + ? VFile + : Result extends object // Custom result type + ? VFile & {result: Result} + : VFile + +// Get the right most non-void thing. +type Specific = Right extends void ? Left : Right + +// Create a processor based on the input/output of a plugin. +type UsePlugin< + ParseTree extends Node | void = void, + CurrentTree extends Node | void = void, + CompileTree extends Node | void = void, + CompileResult = void, + Input = void, + Output = void +> = Output extends Node + ? Input extends string + ? // If `Input` is `string` and `Output` is `Node`, then this plugin + // defines a parser, so set `ParseTree`. + Processor< + Output, + Specific, + Specific, + CompileResult + > + : Input extends Node + ? // If `Input` is `Node` and `Output` is `Node`, then this plugin defines a + // transformer, its output defines the input of the next, so set + // `CurrentTree`. + Processor< + Specific, + Output, + Specific, + CompileResult + > + : // Else, `Input` is something else and `Output` is `Node`: + never + : Input extends Node + ? // If `Input` is `Node` and `Output` is not a `Node`, then this plugin + // defines a compiler, so set `CompileTree` and `CompileResult` + Processor< + Specific, + Specific, + Input, + Output + > + : // Else, `Input` is not a `Node` and `Output` is not a `Node`. + // Maybe it’s untyped, or the plugin throws an error (`never`), so lets + // just keep it as it was. + Processor + +/* eslint-enable @typescript-eslint/naming-convention */ + +/** + * Processor allows plugins to be chained together to transform content. + * The chain of plugins defines how content flows through it. + * + * @typeParam ParseTree + * The node that the parser yields (and `run` receives). + * @typeParam CurrentTree + * The node that the last attached plugin yields. + * @typeParam CompileTree + * The node that the compiler receives (and `run` yields). + * @typeParam CompileResult + * The thing that the compiler yields. + */ +export interface Processor< + ParseTree extends Node | void = void, + CurrentTree extends Node | void = void, + CompileTree extends Node | void = void, + CompileResult = void +> extends FrozenProcessor { + /** + * Configure the processor to use a plugin. + * + * @typeParam PluginParameters + * Plugin settings. + * @typeParam Input + * Value that is accepted by the plugin. + * + * * If the plugin returns a transformer, then this should be the node + * type that the transformer expects. + * * If the plugin sets a parser, then this should be `string`. + * * If the plugin sets a compiler, then this should be the node type that + * the compiler expects. + * @typeParam Output + * Value that the plugin yields. + * + * * If the plugin returns a transformer, then this should be the node + * type that the transformer yields, and defaults to `Input`. + * * If the plugin sets a parser, then this should be the node type that + * the parser yields. + * * If the plugin sets a compiler, then this should be the result that + * the compiler yields (`string`, `Buffer`, or something else). + * @param plugin + * Plugin (function) to use. + * Plugins are deduped based on identity: passing a function in twice will + * cause it to run only once. + * @param settings + * Configuration for plugin, optional. + * Plugins typically receive one options object, but could receive other and + * more values. + * It’s also possible to pass a boolean instead of settings: `true` (to turn + * a plugin on) or `false` (to turn a plugin off). + * @returns + * Current processor. + */ + use< + PluginParameters extends any[] = any[], + Input = Specific, + Output = Input + >( + plugin: Plugin, + ...settings: PluginParameters | [boolean] + ): UsePlugin< + ParseTree, + CurrentTree, + CompileTree, + CompileResult, + Input, + Output + > + + /** + * Configure the processor with a tuple of a plugin and setting(s). + * + * @typeParam PluginParameters + * Plugin settings. + * @typeParam Input + * Value that is accepted by the plugin. + * + * * If the plugin returns a transformer, then this should be the node + * type that the transformer expects. + * * If the plugin sets a parser, then this should be `string`. + * * If the plugin sets a compiler, then this should be the node type that + * the compiler expects. + * @typeParam Output + * Value that the plugin yields. + * + * * If the plugin returns a transformer, then this should be the node + * type that the transformer yields, and defaults to `Input`. + * * If the plugin sets a parser, then this should be the node type that + * the parser yields. + * * If the plugin sets a compiler, then this should be the result that + * the compiler yields (`string`, `Buffer`, or something else). + * @param tuple + * A tuple where the first item is a plugin (function) to use and other + * items are options. + * Plugins are deduped based on identity: passing a function in twice will + * cause it to run only once. + * It’s also possible to pass a boolean instead of settings: `true` (to turn + * a plugin on) or `false` (to turn a plugin off). + * @returns + * Current processor. + */ + use< + PluginParameters extends any[] = any[], + Input = Specific, + Output = Input + >( + tuple: + | PluginTuple + | [Plugin, boolean] + ): UsePlugin< + ParseTree, + CurrentTree, + CompileTree, + CompileResult, + Input, + Output + > + + /** + * Configure the processor with a preset or list of plugins and presets. + * + * @param presetOrList + * Either a list of plugins, presets, and tuples, or a single preset: an + * object with a `plugins` (list) and/or `settings` + * (`Record`). + * @returns + * Current processor. + */ + use( + presetOrList: Preset | PluggableList + ): Processor +} + +/** + * A frozen processor is just like a regular processor, except no additional + * plugins can be added. + * A frozen processor can be created by calling `.freeze()` on a processor. + * An unfrozen processor can be created by calling a processor. + */ +export interface FrozenProcessor< + ParseTree extends Node | void = void, + CurrentTree extends Node | void = void, + CompileTree extends Node | void = void, + CompileResult = void +> { + /** + * Clone current processor + * + * @returns + * New unfrozen processor that is configured to function the same as its + * ancestor. + * But when the descendant processor is configured it does not affect the + * ancestral processor. + */ + (): Processor + + /** + * Internal list of configured plugins. + * + * @private + */ + attachers: Array<[Plugin, ...unknown[]]> + + Parser?: Parser> | undefined + Compiler?: + | Compiler, Specific> + | undefined + + /** + * Parse a file. + * + * @param file + * File to parse. + * `VFile` or anything that can be given to `new VFile()`, optional. + * @returns + * Resulting tree. + */ + parse(file?: VFileCompatible | undefined): Specific + + /** + * Compile a file. + * + * @param node + * Node to compile. + * @param file + * `VFile` or anything that can be given to `new VFile()`, optional. + * @returns + * New content: compiled text (`string` or `Buffer`) or something else. + * This depends on which plugins you use: typically text, but could for + * example be a React node. + */ + stringify( + node: Specific, + file?: VFileCompatible | undefined + ): CompileTree extends Node ? CompileResult : unknown + + /** + * Run transforms on the given tree. + * + * @param node + * Tree to transform. + * @param callback + * Callback called with an error or the resulting node. + * @returns + * Nothing. + */ + run( + node: Specific, + callback: RunCallback> + ): void + + /** + * Run transforms on the given node. + * + * @param node + * Tree to transform. + * @param file + * File associated with `node`. + * `VFile` or anything that can be given to `new VFile()`. + * @param callback + * Callback called with an error or the resulting node. + * @returns + * Nothing. + */ + run( + node: Specific, + file: VFileCompatible | undefined, + callback: RunCallback> + ): void + + /** + * Run transforms on the given node. + * + * @param node + * Tree to transform. + * @param file + * File associated with `node`. + * `VFile` or anything that can be given to `new VFile()`. + * @returns + * Promise that resolves to the resulting tree. + */ + run( + node: Specific, + file?: VFileCompatible | undefined + ): Promise> + + /** + * Run transforms on the given node, synchronously. + * Throws when asynchronous transforms are configured. + * + * @param node + * Tree to transform. + * @param file + * File associated with `node`. + * `VFile` or anything that can be given to `new VFile()`, optional. + * @returns + * Resulting tree. + */ + runSync( + node: Specific, + file?: VFileCompatible | undefined + ): Specific + + /** + * Process a file. + * + * This performs all phases of the processor: + * + * 1. Parse a file into a unist node using the configured `Parser` + * 2. Run transforms on that node + * 3. Compile the resulting node using the `Compiler` + * + * The result from the compiler is stored on the file. + * What the result is depends on which plugins you use. + * The result is typically text (`string` or `Buffer`), which can be retrieved + * with `file.toString()` (or `String(file)`). + * In some cases, such as when using `rehypeReact` to create a React node, + * the result is stored on `file.result`. + * + * @param file + * `VFile` or anything that can be given to `new VFile()`. + * @param callback + * Callback called with an error or the resulting file. + * @returns + * Nothing. + */ + process( + file: VFileCompatible | undefined, + callback: ProcessCallback> + ): void + + /** + * Process a file. + * + * This performs all phases of the processor: + * + * 1. Parse a file into a unist node using the configured `Parser` + * 2. Run transforms on that node + * 3. Compile the resulting node using the `Compiler` + * + * The result from the compiler is stored on the file. + * What the result is depends on which plugins you use. + * The result is typically text (`string` or `Buffer`), which can be retrieved + * with `file.toString()` (or `String(file)`). + * In some cases, such as when using `rehypeReact` to create a React node, + * the result is stored on `file.result`. + * + * @param file + * `VFile` or anything that can be given to `new VFile()`. + * @returns + * Promise that resolves to the resulting `VFile`. + */ + process(file: VFileCompatible): Promise> + + /** + * Process a file, synchronously. + * Throws when asynchronous transforms are configured. + * + * This performs all phases of the processor: + * + * 1. Parse a file into a unist node using the configured `Parser` + * 2. Run transforms on that node + * 3. Compile the resulting node using the `Compiler` + * + * The result from the compiler is stored on the file. + * What the result is depends on which plugins you use. + * The result is typically text (`string` or `Buffer`), which can be retrieved + * with `file.toString()` (or `String(file)`). + * In some cases, such as when using `rehypeReact` to create a React node, + * the result is stored on `file.result`. + * + * @param file + * `VFile` or anything that can be given to `new VFile()`, optional. + * @returns + * Resulting file. + */ + processSync( + file?: VFileCompatible | undefined + ): VFileWithOutput + + /** + * Get an in-memory key-value store accessible to all phases of the process. + * + * @returns + * Key-value store. + */ + data(): Record + + /** + * Set an in-memory key-value store accessible to all phases of the process. + * + * @param data + * Key-value store. + * @returns + * Current processor. + */ + data( + data: Record + ): Processor + + /** + * Get an in-memory value by key. + * + * @param key + * Key to get. + * @returns + * The value at `key`. + */ + data(key: string): unknown + + /** + * Set an in-memory value by key. + * + * @param key + * Key to set. + * @param value + * Value to set. + * @returns + * Current processor. + */ + data( + key: string, + value: unknown + ): Processor + + /** + * Freeze a processor. + * Frozen processors are meant to be extended and not to be configured or + * processed directly. + * + * Once a processor is frozen it cannot be unfrozen. + * New processors working just like it can be created by calling the + * processor. + * + * It’s possible to freeze processors explicitly, by calling `.freeze()`, but + * `.parse()`, `.run()`, `.stringify()`, and `.process()` call `.freeze()` to + * freeze a processor too. + * + * @returns + * Frozen processor. + */ + freeze(): FrozenProcessor +} + +/** + * A plugin is a function. + * It configures the processor and in turn can receive options. + * Plugins can configure processors by interacting with parsers and compilers + * (at `this.Parser` or `this.Compiler`) or by specifying how the syntax tree + * is handled (by returning a `Transformer`). + * + * @typeParam PluginParameters + * Plugin settings. + * @typeParam Input + * Value that is accepted by the plugin. + * + * * If the plugin returns a transformer, then this should be the node + * type that the transformer expects. + * * If the plugin sets a parser, then this should be `string`. + * * If the plugin sets a compiler, then this should be the node type that + * the compiler expects. + * @typeParam Output + * Value that the plugin yields. + * + * * If the plugin returns a transformer, then this should be the node + * type that the transformer yields, and defaults to `Input`. + * * If the plugin sets a parser, then this should be the node type that + * the parser yields. + * * If the plugin sets a compiler, then this should be the result that + * the compiler yields (`string`, `Buffer`, or something else). + * @this + * The current processor. + * Plugins can configure the processor by interacting with `this.Parser` or + * `this.Compiler`, or by accessing the data associated with the whole process + * (`this.data`). + * @param settings + * Configuration for plugin. + * Plugins typically receive one options object, but could receive other and + * more values. + * Users can also pass a boolean instead of settings: `true` (to turn + * a plugin on) or `false` (to turn a plugin off). + * When a plugin is turned off, it won’t be called. + * + * When creating your own plugins, please accept only a single object! + * It allows plugins to be reconfigured and it helps users to know that every + * plugin accepts one options object. + * @returns + * Plugins can return a `Transformer` to specify how the syntax tree is + * handled. + */ +export type Plugin< + PluginParameters extends any[] = any[], + Input = Node, + Output = Input +> = ( + this: Input extends Node + ? Output extends Node + ? // This is a transform, so define `Input` as the current tree. + Processor + : // Compiler. + Processor + : Output extends Node + ? // Parser. + Processor + : // No clue. + Processor, + ...settings: PluginParameters +) => // If both `Input` and `Output` are `Node`, expect an optional `Transformer`. +Input extends Node + ? Output extends Node + ? Transformer | void + : void + : void + +/** + * Presets provide a sharable way to configure processors with multiple plugins + * and/or settings. + */ +export interface Preset { + plugins?: PluggableList + settings?: Record +} + +/** + * A tuple of a plugin and its setting(s). + * The first item is a plugin (function) to use and other items are options. + * Plugins are deduped based on identity: passing a function in twice will + * cause it to run only once. + * + * @typeParam PluginParameters + * Plugin settings. + * @typeParam Input + * Value that is accepted by the plugin. + * + * * If the plugin returns a transformer, then this should be the node + * type that the transformer expects. + * * If the plugin sets a parser, then this should be `string`. + * * If the plugin sets a compiler, then this should be the node type that + * the compiler expects. + * @typeParam Output + * Value that the plugin yields. + * + * * If the plugin returns a transformer, then this should be the node + * type that the transformer yields, and defaults to `Input`. + * * If the plugin sets a parser, then this should be the node type that + * the parser yields. + * * If the plugin sets a compiler, then this should be the result that + * the compiler yields (`string`, `Buffer`, or something else). + */ +export type PluginTuple< + PluginParameters extends any[] = any[], + Input = Node, + Output = Input +> = [Plugin, ...PluginParameters] + +/** + * A union of the different ways to add plugins and settings. + * + * @typeParam PluginParameters + * Plugin settings. + */ +export type Pluggable = + | PluginTuple + | Plugin + | Preset + +/** + * A list of plugins and presets. + */ +export type PluggableList = Pluggable[] + +/** + * @deprecated + * Please use `Plugin`. + */ +export type Attacher< + PluginParameters extends any[] = any[], + Input = Node, + Output = Input +> = Plugin + +/** + * Transformers modify the syntax tree or metadata of a file. + * A transformer is a function that is called each time a file is passed + * through the transform phase. + * If an error occurs (either because it’s thrown, returned, rejected, or passed + * to `next`), the process stops. + * + * @typeParam Input + * Node type that the transformer expects. + * @typeParam Output + * Node type that the transformer yields. + * @param node + * Tree to be transformed. + * @param file + * File associated with node. + * @param next + * Callback that you must call when done. + * Note: this is given if you accept three parameters in your transformer. + * If you accept up to two parameters, it’s not given, and you can return + * a promise. + * @returns + * Any of the following: + * + * * `void` — If nothing is returned, the next transformer keeps using same + * tree. + * * `Error` — Can be returned to stop the process. + * * `Node` — Can be returned and results in further transformations and + * `stringify`s to be performed on the new tree. + * * `Promise` — If a promise is returned, the function is asynchronous, and + * must be resolved (optionally with a `Node`) or rejected (optionally with + * an `Error`). + * + * If you accept a `next` callback, nothing should be returned. + */ +export type Transformer< + Input extends Node = Node, + Output extends Node = Input +> = ( + node: Input, + file: VFile, + next: TransformCallback +) => Promise | Output | Error | undefined | void + +/** + * Callback you must call when a transformer is done. + * + * @typeParam Tree + * Node that the plugin yields. + * @param error + * Pass an error to stop the process. + * @param node + * Pass a tree to continue transformations (and `stringify`) on the new tree. + * @param file + * Pass a file to continue transformations (and `stringify`) on the new file. + * @returns + * Nothing. + */ +export type TransformCallback = ( + error?: Error | null | undefined, + node?: Tree | undefined, + file?: VFile | undefined +) => void + +/** + * Function handling the parsing of text to a syntax tree. + * Used in the parse phase in the process and called with a `string` and + * `VFile` representation of the document to parse. + * + * `Parser` can be a normal function, in which case it must return a `Node`: + * the syntax tree representation of the given file. + * + * `Parser` can also be a constructor function (a function with keys in its + * `prototype`), in which case it’s called with `new`. + * Instances must have a parse method that is called without arguments and + * must return a `Node`. + * + * @typeParam Tree + * The node that the parser yields (and `run` receives). + */ +export type Parser = + | ParserClass + | ParserFunction + +/** + * A class to parse files. + * + * @typeParam Tree + * The node that the parser yields. + */ +export class ParserClass { + prototype: { + /** + * Parse a file. + * + * @returns + * Parsed tree. + */ + parse(): Tree + } + + /** + * Constructor. + * + * @param document + * Document to parse. + * @param file + * File associated with `document`. + * @returns + * Instance. + */ + constructor(document: string, file: VFile) +} + +/** + * Normal function to parse a file. + * + * @typeParam Tree + * The node that the parser yields. + * @param document + * Document to parse. + * @param file + * File associated with `document`. + * @returns + * Node representing the given file. + */ +export type ParserFunction = ( + document: string, + file: VFile +) => Tree + +/** + * Function handling the compilation of syntax tree to a text. + * Used in the stringify phase in the process and called with a `Node` and + * `VFile` representation of the document to stringify. + * + * `Compiler` can be a normal function, in which case it must return a + * `string`: the text representation of the given syntax tree. + * + * `Compiler` can also be a constructor function (a function with keys in its + * `prototype`), in which case it’s called with `new`. + * Instances must have a `compile` method that is called without arguments + * and must return a `string`. + * + * @typeParam Tree + * The node that the compiler receives. + * @typeParam Result + * The thing that the compiler yields. + */ +export type Compiler = + | CompilerClass + | CompilerFunction + +/** + * A class to compile trees. + * + * @typeParam Tree + * The node that the compiler receives. + * @typeParam Result + * The thing that the compiler yields. + */ +export class CompilerClass { + prototype: { + /** + * Compile a tree. + * + * @returns + * New content: compiled text (`string` or `Buffer`, for `file.value`) or + * something else (for `file.result`). + */ + compile(): Result + } + + /** + * Constructor. + * + * @param tree + * Tree to compile. + * @param file + * File associated with `tree`. + * @returns + * Instance. + */ + constructor(tree: Tree, file: VFile) +} + +/** + * Normal function to compile a tree. + * + * @typeParam Tree + * The node that the compiler receives. + * @typeParam Result + * The thing that the compiler yields. + * @param tree + * Tree to compile. + * @param file + * File associated with `tree`. + * @returns + * New content: compiled text (`string` or `Buffer`, for `file.value`) or + * something else (for `file.result`). + */ +export type CompilerFunction = ( + tree: Tree, + file: VFile +) => Result + +/** + * Callback called when a done running. + * + * @typeParam Tree + * The tree that the callback receives. + * @param error + * Error passed when unsuccessful. + * @param node + * Tree to transform. + * @param file + * File passed when successful. + * @returns + * Nothing. + */ +export type RunCallback = ( + error?: Error | null | undefined, + node?: Tree | undefined, + file?: VFile | undefined +) => void + +/** + * Callback called when a done processing. + * + * @typeParam File + * The file that the callback receives. + * @param error + * Error passed when unsuccessful. + * @param file + * File passed when successful. + * @returns + * Nothing. + */ +export type ProcessCallback = ( + error?: Error | null | undefined, + file?: File | undefined +) => void + +/** + * A frozen processor. + */ +export function unified(): Processor diff --git a/node_modules/unified/index.js b/node_modules/unified/index.js new file mode 100644 index 0000000..024230e --- /dev/null +++ b/node_modules/unified/index.js @@ -0,0 +1 @@ +export {unified} from './lib/index.js' diff --git a/node_modules/unified/lib/index.d.ts b/node_modules/unified/lib/index.d.ts new file mode 100644 index 0000000..0742912 --- /dev/null +++ b/node_modules/unified/lib/index.d.ts @@ -0,0 +1,19 @@ +export const unified: import('..').FrozenProcessor +export type Node = import('unist').Node +export type VFileCompatible = import('vfile').VFileCompatible +export type VFileValue = import('vfile').VFileValue +export type Processor = import('..').Processor +export type Plugin = import('..').Plugin +export type Preset = import('..').Preset +export type Pluggable = import('..').Pluggable +export type PluggableList = import('..').PluggableList +export type Transformer = import('..').Transformer +export type Parser = import('..').Parser +export type Compiler = import('..').Compiler +export type RunCallback = import('..').RunCallback +export type ProcessCallback = import('..').ProcessCallback +export type Context = { + tree: Node + file: VFile +} +import {VFile} from 'vfile' diff --git a/node_modules/unified/lib/index.js b/node_modules/unified/lib/index.js new file mode 100644 index 0000000..ef5748e --- /dev/null +++ b/node_modules/unified/lib/index.js @@ -0,0 +1,599 @@ +/** + * @typedef {import('unist').Node} Node + * @typedef {import('vfile').VFileCompatible} VFileCompatible + * @typedef {import('vfile').VFileValue} VFileValue + * @typedef {import('..').Processor} Processor + * @typedef {import('..').Plugin} Plugin + * @typedef {import('..').Preset} Preset + * @typedef {import('..').Pluggable} Pluggable + * @typedef {import('..').PluggableList} PluggableList + * @typedef {import('..').Transformer} Transformer + * @typedef {import('..').Parser} Parser + * @typedef {import('..').Compiler} Compiler + * @typedef {import('..').RunCallback} RunCallback + * @typedef {import('..').ProcessCallback} ProcessCallback + * + * @typedef Context + * @property {Node} tree + * @property {VFile} file + */ + +import {bail} from 'bail' +import isBuffer from 'is-buffer' +import extend from 'extend' +import isPlainObj from 'is-plain-obj' +import {trough} from 'trough' +import {VFile} from 'vfile' + +// Expose a frozen processor. +export const unified = base().freeze() + +const own = {}.hasOwnProperty + +// Function to create the first processor. +/** + * @returns {Processor} + */ +function base() { + const transformers = trough() + /** @type {Processor['attachers']} */ + const attachers = [] + /** @type {Record} */ + let namespace = {} + /** @type {boolean|undefined} */ + let frozen + let freezeIndex = -1 + + // Data management. + // @ts-expect-error: overloads are handled. + processor.data = data + processor.Parser = undefined + processor.Compiler = undefined + + // Lock. + processor.freeze = freeze + + // Plugins. + processor.attachers = attachers + // @ts-expect-error: overloads are handled. + processor.use = use + + // API. + processor.parse = parse + processor.stringify = stringify + // @ts-expect-error: overloads are handled. + processor.run = run + processor.runSync = runSync + // @ts-expect-error: overloads are handled. + processor.process = process + processor.processSync = processSync + + // Expose. + return processor + + // Create a new processor based on the processor in the current scope. + /** @type {Processor} */ + function processor() { + const destination = base() + let index = -1 + + while (++index < attachers.length) { + destination.use(...attachers[index]) + } + + destination.data(extend(true, {}, namespace)) + + return destination + } + + /** + * @param {string|Record} [key] + * @param {unknown} [value] + * @returns {unknown} + */ + function data(key, value) { + if (typeof key === 'string') { + // Set `key`. + if (arguments.length === 2) { + assertUnfrozen('data', frozen) + namespace[key] = value + return processor + } + + // Get `key`. + return (own.call(namespace, key) && namespace[key]) || null + } + + // Set space. + if (key) { + assertUnfrozen('data', frozen) + namespace = key + return processor + } + + // Get space. + return namespace + } + + /** @type {Processor['freeze']} */ + function freeze() { + if (frozen) { + return processor + } + + while (++freezeIndex < attachers.length) { + const [attacher, ...options] = attachers[freezeIndex] + + if (options[0] === false) { + continue + } + + if (options[0] === true) { + options[0] = undefined + } + + /** @type {Transformer|void} */ + const transformer = attacher.call(processor, ...options) + + if (typeof transformer === 'function') { + transformers.use(transformer) + } + } + + frozen = true + freezeIndex = Number.POSITIVE_INFINITY + + return processor + } + + /** + * @param {Pluggable|null|undefined} [value] + * @param {...unknown} options + * @returns {Processor} + */ + function use(value, ...options) { + /** @type {Record|undefined} */ + let settings + + assertUnfrozen('use', frozen) + + if (value === null || value === undefined) { + // Empty. + } else if (typeof value === 'function') { + addPlugin(value, ...options) + } else if (typeof value === 'object') { + if (Array.isArray(value)) { + addList(value) + } else { + addPreset(value) + } + } else { + throw new TypeError('Expected usable value, not `' + value + '`') + } + + if (settings) { + namespace.settings = Object.assign(namespace.settings || {}, settings) + } + + return processor + + /** + * @param {import('..').Pluggable} value + * @returns {void} + */ + function add(value) { + if (typeof value === 'function') { + addPlugin(value) + } else if (typeof value === 'object') { + if (Array.isArray(value)) { + const [plugin, ...options] = value + addPlugin(plugin, ...options) + } else { + addPreset(value) + } + } else { + throw new TypeError('Expected usable value, not `' + value + '`') + } + } + + /** + * @param {Preset} result + * @returns {void} + */ + function addPreset(result) { + addList(result.plugins) + + if (result.settings) { + settings = Object.assign(settings || {}, result.settings) + } + } + + /** + * @param {PluggableList|null|undefined} [plugins] + * @returns {void} + */ + function addList(plugins) { + let index = -1 + + if (plugins === null || plugins === undefined) { + // Empty. + } else if (Array.isArray(plugins)) { + while (++index < plugins.length) { + const thing = plugins[index] + add(thing) + } + } else { + throw new TypeError('Expected a list of plugins, not `' + plugins + '`') + } + } + + /** + * @param {Plugin} plugin + * @param {...unknown} [value] + * @returns {void} + */ + function addPlugin(plugin, value) { + let index = -1 + /** @type {Processor['attachers'][number]|undefined} */ + let entry + + while (++index < attachers.length) { + if (attachers[index][0] === plugin) { + entry = attachers[index] + break + } + } + + if (entry) { + if (isPlainObj(entry[1]) && isPlainObj(value)) { + value = extend(true, entry[1], value) + } + + entry[1] = value + } else { + // @ts-expect-error: fine. + attachers.push([...arguments]) + } + } + } + + /** @type {Processor['parse']} */ + function parse(doc) { + processor.freeze() + const file = vfile(doc) + const Parser = processor.Parser + assertParser('parse', Parser) + + if (newable(Parser, 'parse')) { + // @ts-expect-error: `newable` checks this. + return new Parser(String(file), file).parse() + } + + // @ts-expect-error: `newable` checks this. + return Parser(String(file), file) // eslint-disable-line new-cap + } + + /** @type {Processor['stringify']} */ + function stringify(node, doc) { + processor.freeze() + const file = vfile(doc) + const Compiler = processor.Compiler + assertCompiler('stringify', Compiler) + assertNode(node) + + if (newable(Compiler, 'compile')) { + // @ts-expect-error: `newable` checks this. + return new Compiler(node, file).compile() + } + + // @ts-expect-error: `newable` checks this. + return Compiler(node, file) // eslint-disable-line new-cap + } + + /** + * @param {Node} node + * @param {VFileCompatible|RunCallback} [doc] + * @param {RunCallback} [callback] + * @returns {Promise|void} + */ + function run(node, doc, callback) { + assertNode(node) + processor.freeze() + + if (!callback && typeof doc === 'function') { + callback = doc + doc = undefined + } + + if (!callback) { + return new Promise(executor) + } + + executor(null, callback) + + /** + * @param {null|((node: Node) => void)} resolve + * @param {(error: Error) => void} reject + * @returns {void} + */ + function executor(resolve, reject) { + // @ts-expect-error: `doc` can’t be a callback anymore, we checked. + transformers.run(node, vfile(doc), done) + + /** + * @param {Error|null} error + * @param {Node} tree + * @param {VFile} file + * @returns {void} + */ + function done(error, tree, file) { + tree = tree || node + if (error) { + reject(error) + } else if (resolve) { + resolve(tree) + } else { + // @ts-expect-error: `callback` is defined if `resolve` is not. + callback(null, tree, file) + } + } + } + } + + /** @type {Processor['runSync']} */ + function runSync(node, file) { + /** @type {Node|undefined} */ + let result + /** @type {boolean|undefined} */ + let complete + + processor.run(node, file, done) + + assertDone('runSync', 'run', complete) + + // @ts-expect-error: we either bailed on an error or have a tree. + return result + + /** + * @param {Error|null} [error] + * @param {Node} [tree] + * @returns {void} + */ + function done(error, tree) { + bail(error) + result = tree + complete = true + } + } + + /** + * @param {VFileCompatible} doc + * @param {ProcessCallback} [callback] + * @returns {Promise|undefined} + */ + function process(doc, callback) { + processor.freeze() + assertParser('process', processor.Parser) + assertCompiler('process', processor.Compiler) + + if (!callback) { + return new Promise(executor) + } + + executor(null, callback) + + /** + * @param {null|((file: VFile) => void)} resolve + * @param {(error?: Error|null|undefined) => void} reject + * @returns {void} + */ + function executor(resolve, reject) { + const file = vfile(doc) + + processor.run(processor.parse(file), file, (error, tree, file) => { + if (error || !tree || !file) { + done(error) + } else { + /** @type {unknown} */ + const result = processor.stringify(tree, file) + + if (result === undefined || result === null) { + // Empty. + } else if (looksLikeAVFileValue(result)) { + file.value = result + } else { + file.result = result + } + + done(error, file) + } + }) + + /** + * @param {Error|null|undefined} [error] + * @param {VFile|undefined} [file] + * @returns {void} + */ + function done(error, file) { + if (error || !file) { + reject(error) + } else if (resolve) { + resolve(file) + } else { + // @ts-expect-error: `callback` is defined if `resolve` is not. + callback(null, file) + } + } + } + } + + /** @type {Processor['processSync']} */ + function processSync(doc) { + /** @type {boolean|undefined} */ + let complete + + processor.freeze() + assertParser('processSync', processor.Parser) + assertCompiler('processSync', processor.Compiler) + + const file = vfile(doc) + + processor.process(file, done) + + assertDone('processSync', 'process', complete) + + return file + + /** + * @param {Error|null|undefined} [error] + * @returns {void} + */ + function done(error) { + complete = true + bail(error) + } + } +} + +/** + * Check if `value` is a constructor. + * + * @param {unknown} value + * @param {string} name + * @returns {boolean} + */ +function newable(value, name) { + return ( + typeof value === 'function' && + // Prototypes do exist. + // type-coverage:ignore-next-line + value.prototype && + // A function with keys in its prototype is probably a constructor. + // Classes’ prototype methods are not enumerable, so we check if some value + // exists in the prototype. + // type-coverage:ignore-next-line + (keys(value.prototype) || name in value.prototype) + ) +} + +/** + * Check if `value` is an object with keys. + * + * @param {Record} value + * @returns {boolean} + */ +function keys(value) { + /** @type {string} */ + let key + + for (key in value) { + if (own.call(value, key)) { + return true + } + } + + return false +} + +/** + * Assert a parser is available. + * + * @param {string} name + * @param {unknown} value + * @returns {asserts value is Parser} + */ +function assertParser(name, value) { + if (typeof value !== 'function') { + throw new TypeError('Cannot `' + name + '` without `Parser`') + } +} + +/** + * Assert a compiler is available. + * + * @param {string} name + * @param {unknown} value + * @returns {asserts value is Compiler} + */ +function assertCompiler(name, value) { + if (typeof value !== 'function') { + throw new TypeError('Cannot `' + name + '` without `Compiler`') + } +} + +/** + * Assert the processor is not frozen. + * + * @param {string} name + * @param {unknown} frozen + * @returns {asserts frozen is false} + */ +function assertUnfrozen(name, frozen) { + if (frozen) { + throw new Error( + 'Cannot call `' + + name + + '` on a frozen processor.\nCreate a new processor first, by calling it: use `processor()` instead of `processor`.' + ) + } +} + +/** + * Assert `node` is a unist node. + * + * @param {unknown} node + * @returns {asserts node is Node} + */ +function assertNode(node) { + // `isPlainObj` unfortunately uses `any` instead of `unknown`. + // type-coverage:ignore-next-line + if (!isPlainObj(node) || typeof node.type !== 'string') { + throw new TypeError('Expected node, got `' + node + '`') + // Fine. + } +} + +/** + * Assert that `complete` is `true`. + * + * @param {string} name + * @param {string} asyncName + * @param {unknown} complete + * @returns {asserts complete is true} + */ +function assertDone(name, asyncName, complete) { + if (!complete) { + throw new Error( + '`' + name + '` finished async. Use `' + asyncName + '` instead' + ) + } +} + +/** + * @param {VFileCompatible} [value] + * @returns {VFile} + */ +function vfile(value) { + return looksLikeAVFile(value) ? value : new VFile(value) +} + +/** + * @param {VFileCompatible} [value] + * @returns {value is VFile} + */ +function looksLikeAVFile(value) { + return Boolean( + value && + typeof value === 'object' && + 'message' in value && + 'messages' in value + ) +} + +/** + * @param {unknown} [value] + * @returns {value is VFileValue} + */ +function looksLikeAVFileValue(value) { + return typeof value === 'string' || isBuffer(value) +} diff --git a/node_modules/unified/license b/node_modules/unified/license new file mode 100644 index 0000000..f3722d9 --- /dev/null +++ b/node_modules/unified/license @@ -0,0 +1,21 @@ +(The MIT License) + +Copyright (c) 2015 Titus Wormer + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +THE SOFTWARE. diff --git a/node_modules/unified/package.json b/node_modules/unified/package.json new file mode 100644 index 0000000..4be454f --- /dev/null +++ b/node_modules/unified/package.json @@ -0,0 +1,107 @@ +{ + "name": "unified", + "version": "10.1.2", + "description": "Interface for parsing, inspecting, transforming, and serializing content through syntax trees", + "license": "MIT", + "keywords": [ + "unified", + "process", + "parse", + "transform", + "compile", + "stringify", + "serialize", + "ast", + "cst", + "syntax", + "tree", + "content", + "rehype", + "retext", + "remark" + ], + "homepage": "https://unifiedjs.com", + "repository": "unifiedjs/unified", + "bugs": "https://github.com/unifiedjs/unified/issues", + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + }, + "author": "Titus Wormer (https://wooorm.com)", + "contributors": [ + "Titus Wormer (https://wooorm.com)", + "Junyoung Choi ", + "Hernan Rajchert ", + "Christian Murphy ", + "Vse Mozhet Byt ", + "Richard Littauer " + ], + "sideEffects": false, + "type": "module", + "main": "index.js", + "types": "index.d.ts", + "files": [ + "lib/", + "index.d.ts", + "index.js" + ], + "dependencies": { + "@types/unist": "^2.0.0", + "bail": "^2.0.0", + "extend": "^3.0.0", + "is-buffer": "^2.0.0", + "is-plain-obj": "^4.0.0", + "trough": "^2.0.0", + "vfile": "^5.0.0" + }, + "devDependencies": { + "@types/extend": "^3.0.0", + "@types/tape": "^4.0.0", + "c8": "^7.0.0", + "prettier": "^2.0.0", + "remark-cli": "^10.0.0", + "remark-preset-wooorm": "^9.0.0", + "rimraf": "^3.0.0", + "tape": "^5.0.0", + "tsd": "^0.19.0", + "type-coverage": "^2.0.0", + "typescript": "^4.0.0", + "xo": "^0.48.0" + }, + "scripts": { + "build": "rimraf \"test/**/*.d.ts\" && tsc && tsd && type-coverage", + "format": "remark . -qfo && prettier . -w --loglevel warn && xo --fix", + "test-api": "node --unhandled-rejections=strict --conditions development test/index.js", + "test-coverage": "c8 --check-coverage --branches 100 --functions 100 --lines 100 --statements 100 --reporter lcov node --unhandled-rejections=strict --conditions development test/index.js", + "test": "npm run build && npm run format && npm run test-coverage" + }, + "prettier": { + "tabWidth": 2, + "useTabs": false, + "singleQuote": true, + "bracketSpacing": false, + "semi": false, + "trailingComma": "none" + }, + "xo": { + "prettier": true, + "rules": { + "@typescript-eslint/ban-types": "off", + "promise/param-names": "off" + }, + "ignores": [ + "types/" + ] + }, + "remarkConfig": { + "plugins": [ + "preset-wooorm" + ] + }, + "typeCoverage": { + "atLeast": 100, + "detail": true, + "strict": true, + "ignoreCatch": true + } +} diff --git a/node_modules/unified/readme.md b/node_modules/unified/readme.md new file mode 100644 index 0000000..59eb796 --- /dev/null +++ b/node_modules/unified/readme.md @@ -0,0 +1,1450 @@ +# [![unified][logo]][site] + +[![Build][build-badge]][build] +[![Coverage][coverage-badge]][coverage] +[![Downloads][downloads-badge]][downloads] +[![Size][size-badge]][size] +[![Sponsors][sponsors-badge]][collective] +[![Backers][backers-badge]][collective] +[![Chat][chat-badge]][chat] + +**unified** is an interface for processing text using syntax trees. +It’s what powers [**remark**][remark] (Markdown), [**retext**][retext] (natural +language), and [**rehype**][rehype] (HTML), and allows for processing between +formats. + +## Intro + +**unified** enables new exciting projects like [Gatsby][] to pull in Markdown, +[MDX][] to embed [JSX][], and [Prettier][] to format it. +It’s used in about 700k projects on GitHub and has about 35m downloads each +month on npm: you’re probably using it. +Some notable users are [Node.js][], [Vercel][], [Netlify][], [GitHub][], +[Mozilla][], [WordPress][], [Adobe][], [Facebook][], [Google][], and many more. + +* To read about what we are up to, follow us [Twitter][] +* For a less technical and more practical introduction to unified, visit + [`unifiedjs.com`][site] and peruse its [Learn][] section +* Browse [awesome unified][awesome] to find out more about the ecosystem +* Questions? + Get help on [Discussions][chat]! +* Check out [Contribute][] below to find out how to help out, or become a + backer or sponsor on [OpenCollective][collective] + +## Sponsors + +Support this effort and give back by sponsoring on [OpenCollective][collective]! + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ Vercel

+ +		 + Motif

+ +		 + HashiCorp

+ +		 + American Express

+ +		 + GitBook

+ +
+ Gatsby

+ +		 + Netlify

+ + +		 + Coinbase

+ +		 + ThemeIsle

+ +		 + Expo

+ +		 + Boost Note

+ +		 + Holloway

+ +
+
+ You? +

+
+ +## Install + +This package is [ESM only](https://gist.github.com/sindresorhus/a39789f98801d908bbc7ff3ecc99d99c): +Node 12+ is needed to use it and it must be `import`ed instead of `require`d. + +[npm][]: + +```sh +npm install unified +``` + +## Use + +```js +import {unified} from 'unified' +import remarkParse from 'remark-parse' +import remarkRehype from 'remark-rehype' +import rehypeDocument from 'rehype-document' +import rehypeFormat from 'rehype-format' +import rehypeStringify from 'rehype-stringify' +import {reporter} from 'vfile-reporter' + +unified() + .use(remarkParse) + .use(remarkRehype) + .use(rehypeDocument, {title: '👋🌍'}) + .use(rehypeFormat) + .use(rehypeStringify) + .process('# Hello world!') + .then( + (file) => { + console.error(reporter(file)) + console.log(String(file)) + }, + (error) => { + // Handle your error here! + throw error + } + ) +``` + +Yields: + +```txt +no issues found +``` + +```html + + + + + 👋🌍 + + + +

Hello world!

+ + +``` + +## Contents + +* [Description](#description) +* [API](#api) + * [`processor()`](#processor) + * [`processor.use(plugin[, options])`](#processoruseplugin-options) + * [`processor.parse(file)`](#processorparsefile) + * [`processor.stringify(node[, file])`](#processorstringifynode-file) + * [`processor.run(node[, file][, done])`](#processorrunnode-file-done) + * [`processor.runSync(node[, file])`](#processorrunsyncnode-file) + * [`processor.process(file[, done])`](#processorprocessfile-done) + * [`processor.processSync(file|value)`](#processorprocesssyncfilevalue) + * [`processor.data([key[, value]])`](#processordatakey-value) + * [`processor.freeze()`](#processorfreeze) +* [`Plugin`](#plugin) + * [`function attacher([options])`](#function-attacheroptions) + * [`function transformer(node, file[, next])`](#function-transformernode-file-next) +* [`Preset`](#preset) +* [Contribute](#contribute) +* [Acknowledgments](#acknowledgments) +* [License](#license) + +## Description + +**unified** is an interface for processing text using syntax trees. +Syntax trees are a representation of text understandable to programs. +Those programs, called [*plugin*][plugin]s, take these trees and inspect and +modify them. +To get to the syntax tree from text, there is a [*parser*][parser]. +To get from that back to text, there is a [*compiler*][compiler]. +This is the [*process*][process] of a *processor*. + +```ascii +| ........................ process ........................... | +| .......... parse ... | ... run ... | ... stringify ..........| + + +--------+ +----------+ +Input ->- | Parser | ->- Syntax Tree ->- | Compiler | ->- Output + +--------+ | +----------+ + X + | + +--------------+ + | Transformers | + +--------------+ +``` + +###### Processors + +Every **processor** implements another processor. +To create a processor, call another processor. +The new processor is configured to work the same as its ancestor. +But when the descendant processor is configured in the future it does not affect +the ancestral processor. + +When processors are exposed from a module (for example, `unified` itself) they +should not be configured directly, as that would change their behavior for all +module users. +Those processors are [*frozen*][freeze] and they should be called to create a +new processor before they are used. + +###### Syntax trees + +The **syntax trees** used in **unified** are [**unist**][unist] nodes. +A [**node**][node] is a plain JavaScript objects with a `type` field. +The semantics of nodes and format of syntax trees is defined by other projects. + +There are several [*utilities*][unist-utilities] for working with nodes. + +* [**esast**][esast] — JS +* [**hast**][hast] — HTML +* [**mdast**][mdast] — Markdown +* [**nlcst**][nlcst] — Natural language +* [**xast**][xast] — XML + +###### List of processors + +The following projects process different [*syntax tree*][syntax-tree] formats. +They parse text to a syntax tree and compile that back to text. +These processors can be used as is, or their parser and compiler can be mixed +and matched with **unified** and plugins to process between different syntaxes. + +* [**rehype**][rehype] ([*hast*][hast]) — HTML +* [**remark**][remark] ([*mdast*][mdast]) — Markdown +* [**retext**][retext] ([*nlcst*][nlcst]) — Natural language + +###### List of plugins + +The below [**plugins**][plugin] work with **unified**, on all [*syntax +tree*][syntax-tree] formats: + +* [`unified-diff`](https://github.com/unifiedjs/unified-diff) + — Ignore messages for unchanged lines in Travis +* [`unified-message-control`](https://github.com/unifiedjs/unified-message-control) + — Enable, disable, and ignore messages + +See [**remark**][remark-plugins], [**rehype**][rehype-plugins], and +[**retext**][retext-plugins] for their lists of plugins. + +###### File + +When processing a document, **metadata** is often gathered about that document. +[**vfile**][vfile] is a virtual file format that stores data, metadata, and +messages about files for **unified** and its plugins. + +There are several [*utilities*][vfile-utilities] for working with these files. + +###### Configuration + +[*Processors*][processors] are configured with [*plugin*][plugin]s or +with the [`data`][data] method. + +###### Integrations + +**unified** can integrate with the file system with [`unified-engine`][engine]. +CLI apps can be created with [`unified-args`][args], Gulp plugins with +[`unified-engine-gulp`][gulp], and Atom Linters with +[`unified-engine-atom`][atom]. + +[`unified-stream`][stream] provides a streaming interface. + +###### Programming interface + +The API provided by **unified** allows multiple files to be processed and gives +access to *metadata* (such as lint messages): + +```js +import {unified} from 'unified' +import remarkParse from 'remark-parse' +import remarkPresetLintMarkdownStyleGuide from 'remark-preset-lint-markdown-style-guide' +import remarkRetext from 'remark-retext' +import retextEnglish from 'retext-english' +import retextEquality from 'retext-equality' +import remarkRehype from 'remark-rehype' +import rehypeStringify from 'rehype-stringify' +import {reporter} from 'vfile-reporter' + +unified() + .use(remarkParse) + .use(remarkPresetLintMarkdownStyleGuide) + .use(remarkRetext, unified().use(retextEnglish).use(retextEquality)) + .use(remarkRehype) + .use(rehypeStringify) + .process('*Emphasis* and _stress_, you guys!') + .then( + (file) => { + console.error(reporter(file)) + console.log(String(file)) + }, + (error) => { + // Handle your error here! + throw error + } + ) +``` + +Yields: + +```txt + 1:16-1:24 warning Emphasis should use `*` as a marker emphasis-marker remark-lint + 1:30-1:34 warning `guys` may be insensitive, use `people`, `persons`, `folks` instead gals-man retext-equality + +⚠ 2 warnings +``` + +```html +

Emphasis and stress, you guys!

+``` + +###### Processing between syntaxes + +[*Processors*][processors] can be combined in two modes. + +**Bridge** mode transforms the [*syntax tree*][syntax-tree] from one format +(*origin*) to another (*destination*). +Another processor runs on the destination tree. +Finally, the original processor continues transforming the origin tree. + +**Mutate** mode also transforms the syntax tree from one format to another. +But the original processor continues transforming the destination tree. + +In the previous example (“Programming interface”), `remark-retext` is used in +*bridge* mode: the origin syntax tree is kept after [**retext**][retext] is +done; whereas `remark-rehype` is used in *mutate* mode: it sets a new syntax +tree and discards the origin tree. + +* [`remark-retext`][remark-retext] +* [`remark-rehype`][remark-rehype] +* [`rehype-retext`][rehype-retext] +* [`rehype-remark`][rehype-remark] + +## API + +This package exports the following identifiers: `unified`. +There is no default export. + +### `processor()` + +[*Processor*][processors] describing how to *process* text. + +###### Returns + +`Function` — New [*unfrozen*][freeze] processor that is configured to work the +same as its ancestor. +When the descendant processor is configured in the future it does not affect the +ancestral processor. + +###### Example + +The following example shows how a new processor can be created (from the remark +processor) and linked to **stdin**(4) and **stdout**(4). + +```js +import {remark} from 'remark' +import concatStream from 'concat-stream' + +process.stdin.pipe( + concatStream((buf) => { + process.stdout.write(remark().processSync(buf).toString()) + }) +) +``` + +### `processor.use(plugin[, options])` + +[*Configure*][configuration] the processor to use a [*plugin*][plugin] and +optionally configure that plugin with options. + +If the processor is already using this plugin, the previous plugin configuration +is changed based on the options that are passed in. +The plugin is not added a second time. + +###### Signatures + +* `processor.use(plugin[, options])` +* `processor.use(preset)` +* `processor.use(list)` + +###### Parameters + +* `plugin` ([`Attacher`][plugin]) +* `options` (`*`, optional) — Configuration for `plugin` +* `preset` (`Object`) — Object with an optional `plugins` (set to `list`), + and/or an optional `settings` object +* `list` (`Array`) — List of plugins, presets, and pairs (`plugin` and + `options` in an array) + +###### Returns + +`processor` — The processor that `use` was called on. + +###### Note + +`use` cannot be called on [*frozen*][freeze] processors. +Call the processor first to create a new unfrozen processor. + +###### Example + +There are many ways to pass plugins to `.use()`. +The below example gives an overview. + +```js +import {unified} from 'unified' + +unified() + // Plugin with options: + .use(pluginA, {x: true, y: true}) + // Passing the same plugin again merges configuration (to `{x: true, y: false, z: true}`): + .use(pluginA, {y: false, z: true}) + // Plugins: + .use([pluginB, pluginC]) + // Two plugins, the second with options: + .use([pluginD, [pluginE, {}]]) + // Preset with plugins and settings: + .use({plugins: [pluginF, [pluginG, {}]], settings: {position: false}}) + // Settings only: + .use({settings: {position: false}}) +``` + +### `processor.parse(file)` + +Parse text to a [*syntax tree*][syntax-tree]. + +###### Parameters + +* `file` ([`VFile`][vfile]) — [*File*][file], any value accepted by `vfile()` + +###### Returns + +[`Node`][node] — Parsed [*syntax tree*][syntax-tree] representing `file`. + +###### Note + +`parse` freezes the processor if not already [*frozen*][freeze]. + +`parse` performs the [*parse phase*][description], not the *run phase* or other +phases. + +###### Example + +The below example shows how `parse` can be used to create a syntax tree from a +file. + +```js +import {unified} from 'unified' +import remarkParse from 'remark-parse' + +const tree = unified().use(remarkParse).parse('# Hello world!') + +console.log(tree) +``` + +Yields: + +```js +{ + type: 'root', + children: [ + {type: 'heading', depth: 1, children: [Array], position: [Position]} + ], + position: { + start: {line: 1, column: 1, offset: 0}, + end: {line: 1, column: 15, offset: 14} + } +} +``` + +#### `processor.Parser` + +A **parser** handles the parsing of text to a [*syntax tree*][syntax-tree]. +Used in the [*parse phase*][description] and called with a `string` and +[`VFile`][vfile] representation of the text to parse. + +`Parser` can be a function, in which case it must return a [`Node`][node]: the +syntax tree representation of the given file. + +`Parser` can also be a constructor function (a function with a `parse` field, or +other fields, in its `prototype`), in which case it’s constructed with `new`. +Instances must have a `parse` method that is called without arguments and must +return a [`Node`][node]. + +### `processor.stringify(node[, file])` + +Compile a [*syntax tree*][syntax-tree]. + +###### Parameters + +* `node` ([`Node`][node]) — [*Syntax tree*][syntax-tree] to compile +* `file` ([`VFile`][vfile], optional) — [*File*][file], any value accepted by + `vfile()` + +###### Returns + +`string` or `Buffer` (see notes) — Textual representation of the [*syntax +tree*][syntax-tree] + +###### Note + +`stringify` freezes the processor if not already [*frozen*][freeze]. + +`stringify` performs the [*stringify phase*][description], not the *run phase* +or other phases. + +unified typically compiles by serializing: most [*compiler*][compiler]s return +`string` (or `Buffer`). +Some compilers, such as the one configured with [`rehype-react`][rehype-react], +return other values (in this case, a React tree). +If you’re using a compiler doesn’t serialize, expect different result values. +When using TypeScript, cast the type on your side. + +###### Example + +The below example shows how `stringify` can be used to serialize a syntax tree. + +```js +import {unified} from 'unified' +import rehypeStringify from 'rehype-stringify' +import {h} from 'hastscript' + +const tree = h('h1', 'Hello world!') + +const doc = unified().use(rehypeStringify).stringify(tree) + +console.log(doc) +``` + +Yields: + +```html +

Hello world!

+``` + +#### `processor.Compiler` + +A **compiler** handles the compiling of a [*syntax tree*][syntax-tree] to text. +Used in the [*stringify phase*][description] and called with a [`Node`][node] +and [`VFile`][file] representation of syntax tree to compile. + +`Compiler` can be a function, in which case it should return a `string`: the +textual representation of the syntax tree. + +`Compiler` can also be a constructor function (a function with a `compile` +field, or other fields, in its `prototype`), in which case it’s constructed with +`new`. +Instances must have a `compile` method that is called without arguments and +should return a `string`. + +### `processor.run(node[, file][, done])` + +Run [*transformers*][transformer] on a [*syntax tree*][syntax-tree]. + +###### Parameters + +* `node` ([`Node`][node]) — [*Syntax tree*][syntax-tree] to run on +* `file` ([`VFile`][vfile], optional) — [*File*][file], any value accepted by + `vfile()` +* `done` ([`Function`][run-done], optional) — Callback + +###### Returns + +[`Promise`][promise] if `done` is not given. +The returned promise is rejected with a fatal error, or resolved with the +transformed [*syntax tree*][syntax-tree]. + +###### Note + +`run` freezes the processor if not already [*frozen*][freeze]. + +`run` performs the [*run phase*][description], not other phases. + +#### `function done(err[, node, file])` + +Callback called when [*transformers*][transformer] are done. +Called with either an error or results. + +###### Parameters + +* `err` (`Error`, optional) — Fatal error +* `node` ([`Node`][node], optional) — Transformed [*syntax tree*][syntax-tree] +* `file` ([`VFile`][vfile], optional) — [*File*][file] + +###### Example + +The below example shows how `run` can be used to transform a syntax tree. + +```js +import {unified} from 'unified' +import remarkReferenceLinks from 'remark-reference-links' +import {u} from 'unist-builder' + +const tree = u('root', [ + u('paragraph', [ + u('link', {href: 'https://example.com'}, [u('text', 'Example Domain')]) + ]) +]) + +unified() + .use(remarkReferenceLinks) + .run(tree) + .then( + (changedTree) => console.log(changedTree), + (error) => { + // Handle your error here! + throw error + } + ) +``` + +Yields: + +```js +{ + type: 'root', + children: [ + {type: 'paragraph', children: [Array]}, + {type: 'definition', identifier: '1', title: undefined, url: undefined} + ] +} +``` + +### `processor.runSync(node[, file])` + +Run [*transformers*][transformer] on a [*syntax tree*][syntax-tree]. + +An error is thrown if asynchronous [*plugin*][plugin]s are configured. + +###### Parameters + +* `node` ([`Node`][node]) — [*Syntax tree*][syntax-tree] to run on +* `file` ([`VFile`][vfile], optional) — [*File*][file], any value accepted by + `vfile()` + +###### Returns + +[`Node`][node] — Transformed [*syntax tree*][syntax-tree]. + +###### Note + +`runSync` freezes the processor if not already [*frozen*][freeze]. + +`runSync` performs the [*run phase*][description], not other phases. + +### `processor.process(file[, done])` + +[*Process*][description] the given [*file*][file] as configured on the +processor. + +###### Parameters + +* `file` ([`VFile`][vfile]) — [*File*][file], any value accepted by `vfile()` +* `done` ([`Function`][process-done], optional) — Callback + +###### Returns + +[`Promise`][promise] if `done` is not given. +The returned promise is rejected with a fatal error, or resolved with the +processed [*file*][file]. + +The parsed, transformed, and compiled value is exposed on +[`file.value`][vfile-value] or `file.result` (see notes). + +###### Note + +`process` freezes the processor if not already [*frozen*][freeze]. + +`process` performs the [*parse*, *run*, and *stringify* phases][description]. + +unified typically compiles by serializing: most [*compiler*][compiler]s return +`string` (or `Buffer`). +Some compilers, such as the one configured with [`rehype-react`][rehype-react], +return other values (in this case, a React tree). +If you’re using a compiler that serializes, the result is available at +`file.value`. +Otherwise, the result is available at `file.result`. + +###### Example + +The below example shows how `process` can be used to process a file, whether +transformers are asynchronous or not, with promises. + +```js +import {unified} from 'unified' +import remarkParse from 'remark-parse' +import remarkRehype from 'remark-rehype' +import rehypeDocument from 'rehype-document' +import rehypeFormat from 'rehype-format' +import rehypeStringify from 'rehype-stringify' + +unified() + .use(remarkParse) + .use(remarkRehype) + .use(rehypeDocument, {title: '👋🌍'}) + .use(rehypeFormat) + .use(rehypeStringify) + .process('# Hello world!') + .then( + (file) => console.log(String(file)), + (error) => { + // Handle your error here! + throw error + } + ) +``` + +Yields: + +```html + + + + + 👋🌍 + + + +

Hello world!

+ + +``` + +#### `function done(err, file)` + +Callback called when the [*process*][description] is done. +Called with a fatal error, if any, and a [*file*][file]. + +###### Parameters + +* `err` (`Error`, optional) — Fatal error +* `file` ([`VFile`][vfile]) — Processed [*file*][file] + +###### Example + +The below example shows how `process` can be used to process a file, whether +transformers are asynchronous or not, with a callback. + +```js +import {unified} from 'unified' +import remarkParse from 'remark-parse' +import remarkGithub from 'remark-github' +import remarkStringify from 'remark-stringify' +import {reporter} from 'vfile-reporter' + +unified() + .use(remarkParse) + .use(remarkGithub) + .use(remarkStringify) + .process('@unifiedjs') + .then( + (file) => { + console.error(reporter(file)) + console.log(String(file)) + }, + (error) => { + // Handle your error here! + throw error + } + ) +``` + +Yields: + +```txt +no issues found +``` + +```markdown +[**@unifiedjs**](https://github.com/unifiedjs) +``` + +### `processor.processSync(file|value)` + +[*Process*][description] the given [*file*][file] as configured on the +processor. + +An error is thrown if asynchronous [*plugin*][plugin]s are configured. + +###### Parameters + +* `file` ([`VFile`][vfile]) — [*File*][file], any value accepted by `vfile()` + +###### Returns + +([`VFile`][vfile]) — Processed [*file*][file] + +The parsed, transformed, and compiled value is exposed on +[`file.value`][vfile-value] or `file.result` (see notes). + +###### Note + +`processSync` freezes the processor if not already [*frozen*][freeze]. + +`processSync` performs the [*parse*, *run*, and *stringify* +phases][description]. + +unified typically compiles by serializing: most [*compiler*][compiler]s return +`string` (or `Buffer`). +Some compilers, such as the one configured with [`rehype-react`][rehype-react], +return other values (in this case, a React tree). +If you’re using a compiler that serializes, the result is available at +`file.value`. +Otherwise, the result is available at `file.result`. + +###### Example + +The below example shows how `processSync` can be used to process a file, if all +transformers are synchronous. + +```js +import {unified} from 'unified' +import remarkParse from 'remark-parse' +import remarkRehype from 'remark-rehype' +import rehypeDocument from 'rehype-document' +import rehypeFormat from 'rehype-format' +import rehypeStringify from 'rehype-stringify' + +const processor = unified() + .use(remarkParse) + .use(remarkRehype) + .use(rehypeDocument, {title: '👋🌍'}) + .use(rehypeFormat) + .use(rehypeStringify) + +console.log(processor.processSync('# Hello world!').toString()) +``` + +Yields: + +```html + + + + + 👋🌍 + + + +

Hello world!

+ + +``` + +### `processor.data([key[, value]])` + +[*Configure*][configuration] the processor with information available to all +[*plugin*][plugin]s. +Information is stored in an in-memory key-value store. + +Typically, options can be given to a specific plugin, but sometimes it makes +sense to have information shared with several plugins. +For example, a list of HTML elements that are self-closing, which is needed +during all [*phases*][description] of the *process*. + +###### Signatures + +* `processor = processor.data(key, value)` +* `processor = processor.data(values)` +* `value = processor.data(key)` +* `info = processor.data()` + +###### Parameters + +* `key` (`string`, optional) — Identifier +* `value` (`*`, optional) — Value to set +* `values` (`Object`, optional) — Values to set + +###### Returns + +* `processor` — If setting, the processor that `data` is called on +* `value` (`*`) — If getting, the value at `key` +* `info` (`Object`) — Without arguments, the key-value store + +###### Note + +Setting information cannot occur on [*frozen*][freeze] processors. +Call the processor first to create a new unfrozen processor. + +###### Example + +The following example show how to get and set information: + +```js +import {unified} from 'unified' + +const processor = unified().data('alpha', 'bravo') + +processor.data('alpha') // => 'bravo' + +processor.data() // => {alpha: 'bravo'} + +processor.data({charlie: 'delta'}) + +processor.data() // => {charlie: 'delta'} +``` + +### `processor.freeze()` + +**Freeze** a processor. +*Frozen* processors are meant to be extended and not to be configured directly. + +Once a processor is frozen it cannot be *unfrozen*. +New processors working the same way can be created by calling the processor. + +It’s possible to freeze processors explicitly by calling `.freeze()`. +Processors freeze implicitly when [`.parse()`][parse], [`.run()`][run], +[`.runSync()`][run-sync], [`.stringify()`][stringify], [`.process()`][process], +or [`.processSync()`][process-sync] are called. + +###### Returns + +`processor` — The processor that `freeze` was called on. + +###### Example + +The following example, `index.js`, shows how rehype prevents extensions to +itself: + +```js +import {unified} from 'unified' +import remarkParse from 'rehype-parse' +import remarkStringify from 'rehype-stringify' + +export const rehype = unified().use(remarkParse).use(remarkStringify).freeze() +``` + +The below example, `a.js`, shows how that processor can be used and configured. + +```js +import {rehype} from 'rehype' +import rehypeFormat from 'rehype-format' +// … + +rehype() + .use(rehypeFormat) + // … +``` + +The below example, `b.js`, shows a similar looking example that operates on the +frozen rehype interface because it does not call `rehype`. +If this behavior was allowed it would result in unexpected behavior so an +error is thrown. +**This is invalid**: + +```js +import {rehype} from 'rehype' +import rehypeFormat from 'rehype-format' +// … + +rehype + .use(rehypeFormat) + // … +``` + +Yields: + +```txt +~/node_modules/unified/index.js:426 + throw new Error( + ^ + +Error: Cannot call `use` on a frozen processor. +Create a new processor first, by calling it: use `processor()` instead of `processor`. + at assertUnfrozen (~/node_modules/unified/index.js:426:11) + at Function.use (~/node_modules/unified/index.js:165:5) + at ~/b.js:6:4 +``` + +## `Plugin` + +**Plugins** [*configure*][configuration] the processors they are applied on in +the following ways: + +* They change the processor: such as the [*parser*][parser], the + [*compiler*][compiler], or configuring [*data*][data] +* They specify how to handle [*syntax trees*][syntax-tree] and [*files*][file] + +Plugins are a concept. +They materialize as [`attacher`][attacher]s. + +###### Example + +`move.js`: + +```js +export function move(options = {}) { + const {extname} = options + + if (!extname) { + throw new Error('Missing `extname` in options') + } + + return transformer + + function transformer(tree, file) { + if (file.extname && file.extname !== extname) { + file.extname = extname + } + } +} +``` + +`index.md`: + +```markdown +# Hello, world! +``` + +`index.js`: + +```js +import {unified} from 'unified' +import remarkParse from 'remark-parse' +import remarkRehype from 'remark-rehype' +import rehypeStringify from 'rehype-stringify' +import {toVFile} from 'to-vfile' +import {reporter} from 'vfile-reporter' +import {move} from './move.js' + +unified() + .use(remarkParse) + .use(remarkRehype) + .use(move, {extname: '.html'}) + .use(rehypeStringify) + .process(toVFile.readSync('index.md')) + .then( + (file) => { + console.error(reporter(file)) + toVFile.writeSync(file) // Written to `index.html`. + }, + (error) => { + // Handle your error here! + throw error + } + ) +``` + +Yields: + +```txt +index.md: no issues found +``` + +…and in `index.html`: + +```html +

Hello, world!

+``` + +### `function attacher([options])` + +**Attachers** are materialized [*plugin*][plugin]s. +An attacher is a function that can receive options and +[*configures*][configuration] the processor. + +Attachers change the processor, such as the [*parser*][parser], the +[*compiler*][compiler], configuring [*data*][data], or by specifying how the +[*syntax tree*][syntax-tree] or [*file*][file] are handled. + +###### Context + +The context object (`this`) is set to the processor the attacher is applied on. + +###### Parameters + +* `options` (`*`, optional) — Configuration + +###### Returns + +[`transformer`][transformer] — Optional. + +###### Note + +Attachers are called when the processor is [*frozen*][freeze], not when they are +applied. + +### `function transformer(node, file[, next])` + +**Transformers** handle [*syntax tree*][syntax-tree]s and [*file*][file]s. +A transformer is a function that is called each time a syntax tree and file are +passed through the [*run phase*][description]. +If an error occurs (either because it’s thrown, returned, rejected, or passed to +[`next`][next]), the process stops. + +The *run phase* is handled by [`trough`][trough], see its documentation for the +exact semantics of these functions. + +###### Parameters + +* `node` ([`Node`][node]) — [*Syntax tree*][syntax-tree] to handle +* `file` ([`VFile`][vfile]) — [*File*][file] to handle +* `next` ([`Function`][next], optional) + +###### Returns + +* `void` — If nothing is returned, the next transformer keeps using same tree. +* `Error` — Fatal error to stop the process +* `node` ([`Node`][node]) — New [*syntax tree*][syntax-tree]. + If returned, the next transformer is given this new tree +* `Promise` — Returned to perform an asynchronous operation. + The promise **must** be resolved (optionally with a [`Node`][node]) or + rejected (optionally with an `Error`) + +#### `function next(err[, tree[, file]])` + +If the signature of a [*transformer*][transformer] includes `next` (the third +argument), the transformer **may** perform asynchronous operations, and **must** +call `next()`. + +###### Parameters + +* `err` (`Error`, optional) — Fatal error to stop the process +* `node` ([`Node`][node], optional) — New [*syntax tree*][syntax-tree]. + If given, the next transformer is given this new tree +* `file` ([`VFile`][vfile], optional) — New [*file*][file]. + If given, the next transformer is given this new file + +## `Preset` + +**Presets** are sharable [*configuration*][configuration]. +They can contain [*plugins*][plugin] and settings. + +###### Example + +`preset.js`: + +```js +import remarkPresetLintRecommended from 'remark-preset-lint-recommended' +import remarkPresetLintConsistent from 'remark-preset-lint-consistent' +import remarkCommentConfig from 'remark-comment-config' +import remarkToc from 'remark-toc' +import remarkLicense from 'remark-license' + +export const preset = { + settings: {bullet: '*', emphasis: '*', fences: true}, + plugins: [ + remarkPresetLintRecommended, + remarkPresetLintConsistent, + remarkCommentConfig, + [remarkToc, {maxDepth: 3, tight: true}], + remarkLicense + ] +} +``` + +`example.md`: + +```markdown +# Hello, world! + +_Emphasis_ and **importance**. + +## Table of contents + +## API + +## License +``` + +`index.js`: + +```js +import {remark} from 'remark' +import {toVFile} from 'to-vfile' +import {reporter} from 'vfile-reporter' +import {preset} from './preset.js' + +remark() + .use(preset) + .process(toVFile.readSync('example.md')) + .then( + (file) => { + console.error(reporter(file)) + toVFile.writeSync(file) + }, + (error) => { + // Handle your error here! + throw error + } + ) +``` + +Yields: + +```txt +example.md: no issues found +``` + +`example.md` now contains: + +```markdown +# Hello, world! + +*Emphasis* and **importance**. + +## Table of contents + +* [API](#api) +* [License](#license) + +## API + +## License + +[MIT](license) © [Titus Wormer](https://wooorm.com) +``` + +## Contribute + +See [`contributing.md`][contributing] in [`unifiedjs/.github`][health] for ways +to get started. +See [`support.md`][support] for ways to get help. +Ideas for new plugins and tools can be posted in [`unifiedjs/ideas`][ideas]. + +A curated list of awesome unified resources can be found in [**awesome +unified**][awesome]. + +This project has a [code of conduct][coc]. +By interacting with this repository, organization, or community you agree to +abide by its terms. + +## Acknowledgments + +Preliminary work for unified was done [in 2014][preliminary] for +[**retext**][retext] and inspired by [`ware`][ware]. +Further incubation happened in [**remark**][remark]. +The project was finally [externalised][] in 2015 and [published][] as `unified`. +The project was authored by [**@wooorm**](https://github.com/wooorm). + +Although `unified` since moved its plugin architecture to [`trough`][trough], +thanks to [**@calvinfo**](https://github.com/calvinfo), +[**@ianstormtaylor**](https://github.com/ianstormtaylor), and others for their +work on [`ware`][ware], as it was a huge initial inspiration. + +## License + +[MIT][license] © [Titus Wormer][author] + + + +[logo]: https://raw.githubusercontent.com/unifiedjs/unified/93862e5/logo.svg?sanitize=true + +[build-badge]: https://github.com/unifiedjs/unified/workflows/main/badge.svg + +[build]: https://github.com/unifiedjs/unified/actions + +[coverage-badge]: https://img.shields.io/codecov/c/github/unifiedjs/unified.svg + +[coverage]: https://codecov.io/github/unifiedjs/unified + +[downloads-badge]: https://img.shields.io/npm/dm/unified.svg + +[downloads]: https://www.npmjs.com/package/unified + +[size-badge]: https://img.shields.io/bundlephobia/minzip/unified.svg + +[size]: https://bundlephobia.com/result?p=unified + +[sponsors-badge]: https://opencollective.com/unified/sponsors/badge.svg + +[backers-badge]: https://opencollective.com/unified/backers/badge.svg + +[collective]: https://opencollective.com/unified + +[chat-badge]: https://img.shields.io/badge/chat-discussions-success.svg + +[chat]: https://github.com/unifiedjs/unified/discussions + +[health]: https://github.com/unifiedjs/.github + +[contributing]: https://github.com/unifiedjs/.github/blob/HEAD/contributing.md + +[support]: https://github.com/unifiedjs/.github/blob/HEAD/support.md + +[coc]: https://github.com/unifiedjs/.github/blob/HEAD/code-of-conduct.md + +[awesome]: https://github.com/unifiedjs/awesome-unified + +[license]: license + +[author]: https://wooorm.com + +[npm]: https://docs.npmjs.com/cli/install + +[site]: https://unifiedjs.com + +[twitter]: https://twitter.com/unifiedjs + +[learn]: https://unifiedjs.com/learn/ + +[rehype]: https://github.com/rehypejs/rehype + +[remark]: https://github.com/remarkjs/remark + +[retext]: https://github.com/retextjs/retext + +[esast]: https://github.com/syntax-tree/esast + +[hast]: https://github.com/syntax-tree/hast + +[mdast]: https://github.com/syntax-tree/mdast + +[nlcst]: https://github.com/syntax-tree/nlcst + +[xast]: https://github.com/syntax-tree/xast + +[unist]: https://github.com/syntax-tree/unist + +[engine]: https://github.com/unifiedjs/unified-engine + +[args]: https://github.com/unifiedjs/unified-args + +[gulp]: https://github.com/unifiedjs/unified-engine-gulp + +[atom]: https://github.com/unifiedjs/unified-engine-atom + +[remark-rehype]: https://github.com/remarkjs/remark-rehype + +[remark-retext]: https://github.com/remarkjs/remark-retext + +[rehype-retext]: https://github.com/rehypejs/rehype-retext + +[rehype-remark]: https://github.com/rehypejs/rehype-remark + +[unist-utilities]: https://github.com/syntax-tree/unist#list-of-utilities + +[vfile]: https://github.com/vfile/vfile + +[vfile-value]: https://github.com/vfile/vfile#vfilevalue + +[vfile-utilities]: https://github.com/vfile/vfile#list-of-utilities + +[node]: https://github.com/syntax-tree/unist#node + +[description]: #description + +[syntax-tree]: #syntax-trees + +[configuration]: #configuration + +[file]: #file + +[processors]: #processors + +[process]: #processorprocessfile-done + +[process-sync]: #processorprocesssyncfilevalue + +[parse]: #processorparsefile + +[parser]: #processorparser + +[stringify]: #processorstringifynode-file + +[run]: #processorrunnode-file-done + +[run-sync]: #processorrunsyncnode-file + +[compiler]: #processorcompiler + +[data]: #processordatakey-value + +[attacher]: #function-attacheroptions + +[transformer]: #function-transformernode-file-next + +[next]: #function-nexterr-tree-file + +[freeze]: #processorfreeze + +[plugin]: #plugin + +[run-done]: #function-doneerr-node-file + +[process-done]: #function-doneerr-file + +[contribute]: #contribute + +[rehype-react]: https://github.com/rehypejs/rehype-react + +[trough]: https://github.com/wooorm/trough#function-fninput-next + +[promise]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Promise + +[remark-plugins]: https://github.com/remarkjs/remark/blob/HEAD/doc/plugins.md#list-of-plugins + +[rehype-plugins]: https://github.com/rehypejs/rehype/blob/HEAD/doc/plugins.md#list-of-plugins + +[retext-plugins]: https://github.com/retextjs/retext/blob/HEAD/doc/plugins.md#list-of-plugins + +[stream]: https://github.com/unifiedjs/unified-stream + +[ideas]: https://github.com/unifiedjs/ideas + +[preliminary]: https://github.com/retextjs/retext/commit/8fcb1f#diff-168726dbe96b3ce427e7fedce31bb0bc + +[externalised]: https://github.com/remarkjs/remark/commit/9892ec#diff-168726dbe96b3ce427e7fedce31bb0bc + +[published]: https://github.com/unifiedjs/unified/commit/2ba1cf + +[ware]: https://github.com/segmentio/ware + +[gatsby]: https://www.gatsbyjs.org + +[mdx]: https://mdxjs.com + +[jsx]: https://reactjs.org/docs/jsx-in-depth.html + +[prettier]: https://prettier.io + +[node.js]: https://nodejs.org + +[vercel]: https://vercel.com + +[netlify]: https://www.netlify.com + +[github]: https://github.com + +[mozilla]: https://www.mozilla.org + +[wordpress]: https://wordpress.com + +[adobe]: https://www.adobe.com + +[facebook]: https://www.facebook.com + +[google]: https://www.google.com diff --git a/node_modules/unist-util-stringify-position/index.d.ts b/node_modules/unist-util-stringify-position/index.d.ts new file mode 100644 index 0000000..93163ea --- /dev/null +++ b/node_modules/unist-util-stringify-position/index.d.ts @@ -0,0 +1 @@ +export {stringifyPosition} from './lib/index.js' diff --git a/node_modules/unist-util-stringify-position/index.js b/node_modules/unist-util-stringify-position/index.js new file mode 100644 index 0000000..93163ea --- /dev/null +++ b/node_modules/unist-util-stringify-position/index.js @@ -0,0 +1 @@ +export {stringifyPosition} from './lib/index.js' diff --git a/node_modules/unist-util-stringify-position/lib/index.d.ts b/node_modules/unist-util-stringify-position/lib/index.d.ts new file mode 100644 index 0000000..7a64b47 --- /dev/null +++ b/node_modules/unist-util-stringify-position/lib/index.d.ts @@ -0,0 +1,61 @@ +/** + * @typedef {import('unist').Node} Node + * @typedef {import('unist').Point} Point + * @typedef {import('unist').Position} Position + */ +/** + * @typedef NodeLike + * @property {string} type + * @property {PositionLike | null | undefined} [position] + * + * @typedef PositionLike + * @property {PointLike | null | undefined} [start] + * @property {PointLike | null | undefined} [end] + * + * @typedef PointLike + * @property {number | null | undefined} [line] + * @property {number | null | undefined} [column] + * @property {number | null | undefined} [offset] + */ +/** + * Serialize the positional info of a point, position (start and end points), + * or node. + * + * @param {Node | NodeLike | Position | PositionLike | Point | PointLike | null | undefined} [value] + * Node, position, or point. + * @returns {string} + * Pretty printed positional info of a node (`string`). + * + * In the format of a range `ls:cs-le:ce` (when given `node` or `position`) + * or a point `l:c` (when given `point`), where `l` stands for line, `c` for + * column, `s` for `start`, and `e` for end. + * An empty string (`''`) is returned if the given value is neither `node`, + * `position`, nor `point`. + */ +export function stringifyPosition( + value?: + | Node + | NodeLike + | Position + | PositionLike + | Point + | PointLike + | null + | undefined +): string +export type Node = import('unist').Node +export type Point = import('unist').Point +export type Position = import('unist').Position +export type NodeLike = { + type: string + position?: PositionLike | null | undefined +} +export type PositionLike = { + start?: PointLike | null | undefined + end?: PointLike | null | undefined +} +export type PointLike = { + line?: number | null | undefined + column?: number | null | undefined + offset?: number | null | undefined +} diff --git a/node_modules/unist-util-stringify-position/lib/index.js b/node_modules/unist-util-stringify-position/lib/index.js new file mode 100644 index 0000000..7474343 --- /dev/null +++ b/node_modules/unist-util-stringify-position/lib/index.js @@ -0,0 +1,84 @@ +/** + * @typedef {import('unist').Node} Node + * @typedef {import('unist').Point} Point + * @typedef {import('unist').Position} Position + */ + +/** + * @typedef NodeLike + * @property {string} type + * @property {PositionLike | null | undefined} [position] + * + * @typedef PositionLike + * @property {PointLike | null | undefined} [start] + * @property {PointLike | null | undefined} [end] + * + * @typedef PointLike + * @property {number | null | undefined} [line] + * @property {number | null | undefined} [column] + * @property {number | null | undefined} [offset] + */ + +/** + * Serialize the positional info of a point, position (start and end points), + * or node. + * + * @param {Node | NodeLike | Position | PositionLike | Point | PointLike | null | undefined} [value] + * Node, position, or point. + * @returns {string} + * Pretty printed positional info of a node (`string`). + * + * In the format of a range `ls:cs-le:ce` (when given `node` or `position`) + * or a point `l:c` (when given `point`), where `l` stands for line, `c` for + * column, `s` for `start`, and `e` for end. + * An empty string (`''`) is returned if the given value is neither `node`, + * `position`, nor `point`. + */ +export function stringifyPosition(value) { + // Nothing. + if (!value || typeof value !== 'object') { + return '' + } + + // Node. + if ('position' in value || 'type' in value) { + return position(value.position) + } + + // Position. + if ('start' in value || 'end' in value) { + return position(value) + } + + // Point. + if ('line' in value || 'column' in value) { + return point(value) + } + + // ? + return '' +} + +/** + * @param {Point | PointLike | null | undefined} point + * @returns {string} + */ +function point(point) { + return index(point && point.line) + ':' + index(point && point.column) +} + +/** + * @param {Position | PositionLike | null | undefined} pos + * @returns {string} + */ +function position(pos) { + return point(pos && pos.start) + '-' + point(pos && pos.end) +} + +/** + * @param {number | null | undefined} value + * @returns {number} + */ +function index(value) { + return value && typeof value === 'number' ? value : 1 +} diff --git a/node_modules/unist-util-stringify-position/license b/node_modules/unist-util-stringify-position/license new file mode 100644 index 0000000..8d8660d --- /dev/null +++ b/node_modules/unist-util-stringify-position/license @@ -0,0 +1,22 @@ +(The MIT License) + +Copyright (c) 2016 Titus Wormer + +Permission is hereby granted, free of charge, to any person obtaining +a copy of this software and associated documentation files (the +'Software'), to deal in the Software without restriction, including +without limitation the rights to use, copy, modify, merge, publish, +distribute, sublicense, and/or sell copies of the Software, and to +permit persons to whom the Software is furnished to do so, subject to +the following conditions: + +The above copyright notice and this permission notice shall be +included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. +IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY +CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, +TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE +SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. diff --git a/node_modules/unist-util-stringify-position/package.json b/node_modules/unist-util-stringify-position/package.json new file mode 100644 index 0000000..51e32c2 --- /dev/null +++ b/node_modules/unist-util-stringify-position/package.json @@ -0,0 +1,80 @@ +{ + "name": "unist-util-stringify-position", + "version": "3.0.3", + "description": "unist utility to serialize a node, position, or point as a human readable location", + "license": "MIT", + "keywords": [ + "unist", + "unist-util", + "util", + "utility", + "position", + "location", + "point", + "node", + "stringify", + "tostring" + ], + "repository": "syntax-tree/unist-util-stringify-position", + "bugs": "https://github.com/syntax-tree/unist-util-stringify-position/issues", + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + }, + "author": "Titus Wormer (https://wooorm.com)", + "contributors": [ + "Titus Wormer (https://wooorm.com)" + ], + "sideEffects": false, + "type": "module", + "main": "index.js", + "types": "index.d.ts", + "files": [ + "lib/", + "index.d.ts", + "index.js" + ], + "dependencies": { + "@types/unist": "^2.0.0" + }, + "devDependencies": { + "@types/mdast": "^3.0.0", + "@types/node": "^18.0.0", + "c8": "^7.0.0", + "prettier": "^2.0.0", + "remark-cli": "^11.0.0", + "remark-preset-wooorm": "^9.0.0", + "type-coverage": "^2.0.0", + "typescript": "^4.0.0", + "xo": "^0.53.0" + }, + "scripts": { + "prepack": "npm run build && npm run format", + "build": "tsc --build --clean && tsc --build && type-coverage", + "format": "remark . -qfo && prettier . -w --loglevel warn && xo --fix", + "test-api": "node --conditions development test.js", + "test-coverage": "c8 --check-coverage --100 --reporter lcov npm run test-api", + "test": "npm run build && npm run format && npm run test-coverage" + }, + "prettier": { + "tabWidth": 2, + "useTabs": false, + "singleQuote": true, + "bracketSpacing": false, + "semi": false, + "trailingComma": "none" + }, + "xo": { + "prettier": true + }, + "remarkConfig": { + "plugins": [ + "preset-wooorm" + ] + }, + "typeCoverage": { + "atLeast": 100, + "detail": true, + "strict": true + } +} diff --git a/node_modules/unist-util-stringify-position/readme.md b/node_modules/unist-util-stringify-position/readme.md new file mode 100644 index 0000000..323f960 --- /dev/null +++ b/node_modules/unist-util-stringify-position/readme.md @@ -0,0 +1,203 @@ +# unist-util-stringify-position + +[![Build][build-badge]][build] +[![Coverage][coverage-badge]][coverage] +[![Downloads][downloads-badge]][downloads] +[![Size][size-badge]][size] +[![Sponsors][sponsors-badge]][collective] +[![Backers][backers-badge]][collective] +[![Chat][chat-badge]][chat] + +[unist][] utility to pretty print the positional info of a node. + +## Contents + +* [What is this?](#what-is-this) +* [When should I use this?](#when-should-i-use-this) +* [Install](#install) +* [Use](#use) +* [API](#api) + * [`stringifyPosition(node|position|point)`](#stringifypositionnodepositionpoint) +* [Types](#types) +* [Compatibility](#compatibility) +* [Security](#security) +* [Related](#related) +* [Contribute](#contribute) +* [License](#license) + +## What is this? + +This package is a utility that takes any [unist][] (whether mdast, hast, etc) +node, position, or point, and serializes its positional info. + +## When should I use this? + +This utility is useful to display where something occurred in the original +document, in one standard way, for humans. +For example, when throwing errors or warning messages about something. + +## Install + +This package is [ESM only][esm]. +In Node.js (version 14.14+ and 16.0+), install with [npm][]: + +```sh +npm install unist-util-stringify-position +``` + +In Deno with [`esm.sh`][esmsh]: + +```js +import {stringifyPosition} from 'https://esm.sh/unist-util-stringify-position@3' +``` + +In browsers with [`esm.sh`][esmsh]: + +```html + +``` + +## Use + +```js +import {stringifyPosition} from 'unist-util-stringify-position' + +stringifyPosition({line: 2, column: 3}) // => '2:3' (point) +stringifyPosition({start: {line: 2}, end: {line: 3}}) // => '2:1-3:1' (position) +stringifyPosition({ + type: 'text', + value: '!', + position: { + start: {line: 5, column: 11}, + end: {line: 5, column: 12} + } +}) // => '5:11-5:12' (node) +``` + +## API + +This package exports the identifier [`stringifyPosition`][stringifyposition]. +There is no default export. + +### `stringifyPosition(node|position|point)` + +Serialize the positional info of a point, position (start and end points), or +node. + +###### Parameters + +* `node` ([`Node`][node]) + — node whose `position` fields to serialize +* `position` ([`Position`][position]) + — position whose `start` and `end` points to serialize +* `point` ([`Point`][point]) + — point whose `line` and `column` fields to serialize + +###### Returns + +Pretty printed positional info of a node (`string`). + +In the format of a range `ls:cs-le:ce` (when given `node` or `position`) or a +point `l:c` (when given `point`), where `l` stands for line, `c` for column, `s` +for `start`, and `e` for end. +An empty string (`''`) is returned if the given value is neither `node`, +`position`, nor `point`. + +## Types + +This package is fully typed with [TypeScript][]. +It exports no additional types. + +## Compatibility + +Projects maintained by the unified collective are compatible with all maintained +versions of Node.js. +As of now, that is Node.js 14.14+ and 16.0+. +Our projects sometimes work with older versions, but this is not guaranteed. + +## Security + +This project is safe. + +## Related + +* [`unist-util-generated`](https://github.com/syntax-tree/unist-util-generated) + — check if a node is generated +* [`unist-util-position`](https://github.com/syntax-tree/unist-util-position) + — get positional info of nodes +* [`unist-util-remove-position`](https://github.com/syntax-tree/unist-util-remove-position) + — remove positional info from trees +* [`unist-util-source`](https://github.com/syntax-tree/unist-util-source) + — get the source of a value (node or position) in a file + +## Contribute + +See [`contributing.md` in `syntax-tree/.github`][contributing] for ways to get +started. +See [`support.md`][support] for ways to get help. + +This project has a [code of conduct][coc]. +By interacting with this repository, organization, or community you agree to +abide by its terms. + +## License + +[MIT][license] © [Titus Wormer][author] + + + +[build-badge]: https://github.com/syntax-tree/unist-util-stringify-position/workflows/main/badge.svg + +[build]: https://github.com/syntax-tree/unist-util-stringify-position/actions + +[coverage-badge]: https://img.shields.io/codecov/c/github/syntax-tree/unist-util-stringify-position.svg + +[coverage]: https://codecov.io/github/syntax-tree/unist-util-stringify-position + +[downloads-badge]: https://img.shields.io/npm/dm/unist-util-stringify-position.svg + +[downloads]: https://www.npmjs.com/package/unist-util-stringify-position + +[size-badge]: https://img.shields.io/bundlephobia/minzip/unist-util-stringify-position.svg + +[size]: https://bundlephobia.com/result?p=unist-util-stringify-position + +[sponsors-badge]: https://opencollective.com/unified/sponsors/badge.svg + +[backers-badge]: https://opencollective.com/unified/backers/badge.svg + +[collective]: https://opencollective.com/unified + +[chat-badge]: https://img.shields.io/badge/chat-discussions-success.svg + +[chat]: https://github.com/syntax-tree/unist/discussions + +[npm]: https://docs.npmjs.com/cli/install + +[license]: license + +[author]: https://wooorm.com + +[esm]: https://gist.github.com/sindresorhus/a39789f98801d908bbc7ff3ecc99d99c + +[esmsh]: https://esm.sh + +[typescript]: https://www.typescriptlang.org + +[contributing]: https://github.com/syntax-tree/.github/blob/HEAD/contributing.md + +[support]: https://github.com/syntax-tree/.github/blob/HEAD/support.md + +[coc]: https://github.com/syntax-tree/.github/blob/HEAD/code-of-conduct.md + +[unist]: https://github.com/syntax-tree/unist + +[node]: https://github.com/syntax-tree/unist#node + +[position]: https://github.com/syntax-tree/unist#position + +[point]: https://github.com/syntax-tree/unist#point + +[stringifyposition]: #stringifypositionnodepositionpoint diff --git a/node_modules/vfile-message/index.d.ts b/node_modules/vfile-message/index.d.ts new file mode 100644 index 0000000..17019f0 --- /dev/null +++ b/node_modules/vfile-message/index.d.ts @@ -0,0 +1 @@ +export {VFileMessage} from './lib/index.js' diff --git a/node_modules/vfile-message/index.js b/node_modules/vfile-message/index.js new file mode 100644 index 0000000..17019f0 --- /dev/null +++ b/node_modules/vfile-message/index.js @@ -0,0 +1 @@ +export {VFileMessage} from './lib/index.js' diff --git a/node_modules/vfile-message/lib/index.d.ts b/node_modules/vfile-message/lib/index.d.ts new file mode 100644 index 0000000..f7b61de --- /dev/null +++ b/node_modules/vfile-message/lib/index.d.ts @@ -0,0 +1,125 @@ +/** + * Message. + */ +export class VFileMessage extends Error { + /** + * Create a message for `reason` at `place` from `origin`. + * + * When an error is passed in as `reason`, the `stack` is copied. + * + * @param {string | Error | VFileMessage} reason + * Reason for message, uses the stack and message of the error if given. + * + * > 👉 **Note**: you should use markdown. + * @param {Node | NodeLike | Position | Point | null | undefined} [place] + * Place in file where the message occurred. + * @param {string | null | undefined} [origin] + * Place in code where the message originates (example: + * `'my-package:my-rule'` or `'my-rule'`). + * @returns + * Instance of `VFileMessage`. + */ + constructor( + reason: string | Error | VFileMessage, + place?: Node | NodeLike | Position | Point | null | undefined, + origin?: string | null | undefined + ) + /** + * Stack of message. + * + * This is used by normal errors to show where something happened in + * programming code, irrelevant for `VFile` messages, + * + * @type {string} + */ + stack: string + /** + * Reason for message. + * + * > 👉 **Note**: you should use markdown. + * + * @type {string} + */ + reason: string + /** + * State of problem. + * + * * `true` — marks associated file as no longer processable (error) + * * `false` — necessitates a (potential) change (warning) + * * `null | undefined` — for things that might not need changing (info) + * + * @type {boolean | null | undefined} + */ + fatal: boolean | null | undefined + /** + * Starting line of error. + * + * @type {number | null} + */ + line: number | null + /** + * Starting column of error. + * + * @type {number | null} + */ + column: number | null + /** + * Full unist position. + * + * @type {Position | null} + */ + position: Position | null + /** + * Namespace of message (example: `'my-package'`). + * + * @type {string | null} + */ + source: string | null + /** + * Category of message (example: `'my-rule'`). + * + * @type {string | null} + */ + ruleId: string | null + /** + * Path of a file (used throughout the `VFile` ecosystem). + * + * @type {string | null} + */ + file: string | null + /** + * Specify the source value that’s being reported, which is deemed + * incorrect. + * + * @type {string | null} + */ + actual: string | null + /** + * Suggest acceptable values that can be used instead of `actual`. + * + * @type {Array | null} + */ + expected: Array | null + /** + * Link to docs for the message. + * + * > 👉 **Note**: this must be an absolute URL that can be passed as `x` + * > to `new URL(x)`. + * + * @type {string | null} + */ + url: string | null + /** + * Long form description of the message (you should use markdown). + * + * @type {string | null} + */ + note: string | null +} +export type Node = import('unist').Node +export type Position = import('unist').Position +export type Point = import('unist').Point +export type NodeLike = object & { + type: string + position?: Position | undefined +} diff --git a/node_modules/vfile-message/lib/index.js b/node_modules/vfile-message/lib/index.js new file mode 100644 index 0000000..8c8bcc3 --- /dev/null +++ b/node_modules/vfile-message/lib/index.js @@ -0,0 +1,225 @@ +/** + * @typedef {import('unist').Node} Node + * @typedef {import('unist').Position} Position + * @typedef {import('unist').Point} Point + * @typedef {object & {type: string, position?: Position | undefined}} NodeLike + */ + +import {stringifyPosition} from 'unist-util-stringify-position' + +/** + * Message. + */ +export class VFileMessage extends Error { + /** + * Create a message for `reason` at `place` from `origin`. + * + * When an error is passed in as `reason`, the `stack` is copied. + * + * @param {string | Error | VFileMessage} reason + * Reason for message, uses the stack and message of the error if given. + * + * > 👉 **Note**: you should use markdown. + * @param {Node | NodeLike | Position | Point | null | undefined} [place] + * Place in file where the message occurred. + * @param {string | null | undefined} [origin] + * Place in code where the message originates (example: + * `'my-package:my-rule'` or `'my-rule'`). + * @returns + * Instance of `VFileMessage`. + */ + // To do: next major: expose `undefined` everywhere instead of `null`. + constructor(reason, place, origin) { + /** @type {[string | null, string | null]} */ + const parts = [null, null] + /** @type {Position} */ + let position = { + // @ts-expect-error: we always follows the structure of `position`. + start: {line: null, column: null}, + // @ts-expect-error: " + end: {line: null, column: null} + } + + super() + + if (typeof place === 'string') { + origin = place + place = undefined + } + + if (typeof origin === 'string') { + const index = origin.indexOf(':') + + if (index === -1) { + parts[1] = origin + } else { + parts[0] = origin.slice(0, index) + parts[1] = origin.slice(index + 1) + } + } + + if (place) { + // Node. + if ('type' in place || 'position' in place) { + if (place.position) { + // To do: next major: deep clone. + // @ts-expect-error: looks like a position. + position = place.position + } + } + // Position. + else if ('start' in place || 'end' in place) { + // @ts-expect-error: looks like a position. + // To do: next major: deep clone. + position = place + } + // Point. + else if ('line' in place || 'column' in place) { + // To do: next major: deep clone. + position.start = place + } + } + + // Fields from `Error`. + /** + * Serialized positional info of error. + * + * On normal errors, this would be something like `ParseError`, buit in + * `VFile` messages we use this space to show where an error happened. + */ + this.name = stringifyPosition(place) || '1:1' + + /** + * Reason for message. + * + * @type {string} + */ + this.message = typeof reason === 'object' ? reason.message : reason + + /** + * Stack of message. + * + * This is used by normal errors to show where something happened in + * programming code, irrelevant for `VFile` messages, + * + * @type {string} + */ + this.stack = '' + + if (typeof reason === 'object' && reason.stack) { + this.stack = reason.stack + } + + /** + * Reason for message. + * + * > 👉 **Note**: you should use markdown. + * + * @type {string} + */ + this.reason = this.message + + /* eslint-disable no-unused-expressions */ + /** + * State of problem. + * + * * `true` — marks associated file as no longer processable (error) + * * `false` — necessitates a (potential) change (warning) + * * `null | undefined` — for things that might not need changing (info) + * + * @type {boolean | null | undefined} + */ + this.fatal + + /** + * Starting line of error. + * + * @type {number | null} + */ + this.line = position.start.line + + /** + * Starting column of error. + * + * @type {number | null} + */ + this.column = position.start.column + + /** + * Full unist position. + * + * @type {Position | null} + */ + this.position = position + + /** + * Namespace of message (example: `'my-package'`). + * + * @type {string | null} + */ + this.source = parts[0] + + /** + * Category of message (example: `'my-rule'`). + * + * @type {string | null} + */ + this.ruleId = parts[1] + + /** + * Path of a file (used throughout the `VFile` ecosystem). + * + * @type {string | null} + */ + this.file + + // The following fields are “well known”. + // Not standard. + // Feel free to add other non-standard fields to your messages. + + /** + * Specify the source value that’s being reported, which is deemed + * incorrect. + * + * @type {string | null} + */ + this.actual + + /** + * Suggest acceptable values that can be used instead of `actual`. + * + * @type {Array | null} + */ + this.expected + + /** + * Link to docs for the message. + * + * > 👉 **Note**: this must be an absolute URL that can be passed as `x` + * > to `new URL(x)`. + * + * @type {string | null} + */ + this.url + + /** + * Long form description of the message (you should use markdown). + * + * @type {string | null} + */ + this.note + /* eslint-enable no-unused-expressions */ + } +} + +VFileMessage.prototype.file = '' +VFileMessage.prototype.name = '' +VFileMessage.prototype.reason = '' +VFileMessage.prototype.message = '' +VFileMessage.prototype.stack = '' +VFileMessage.prototype.fatal = null +VFileMessage.prototype.column = null +VFileMessage.prototype.line = null +VFileMessage.prototype.source = null +VFileMessage.prototype.ruleId = null +VFileMessage.prototype.position = null diff --git a/node_modules/vfile-message/license b/node_modules/vfile-message/license new file mode 100644 index 0000000..045ffe0 --- /dev/null +++ b/node_modules/vfile-message/license @@ -0,0 +1,22 @@ +(The MIT License) + +Copyright (c) 2017 Titus Wormer + +Permission is hereby granted, free of charge, to any person obtaining +a copy of this software and associated documentation files (the +'Software'), to deal in the Software without restriction, including +without limitation the rights to use, copy, modify, merge, publish, +distribute, sublicense, and/or sell copies of the Software, and to +permit persons to whom the Software is furnished to do so, subject to +the following conditions: + +The above copyright notice and this permission notice shall be +included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. +IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY +CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, +TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE +SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. diff --git a/node_modules/vfile-message/package.json b/node_modules/vfile-message/package.json new file mode 100644 index 0000000..0a58c32 --- /dev/null +++ b/node_modules/vfile-message/package.json @@ -0,0 +1,78 @@ +{ + "name": "vfile-message", + "version": "3.1.4", + "description": "vfile utility to create a virtual message", + "license": "MIT", + "keywords": [ + "vfile", + "vfile-util", + "util", + "utility", + "virtual", + "file", + "message" + ], + "repository": "vfile/vfile-message", + "bugs": "https://github.com/vfile/vfile-message/issues", + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + }, + "author": "Titus Wormer (https://wooorm.com)", + "contributors": [ + "Titus Wormer (https://wooorm.com)" + ], + "sideEffects": false, + "type": "module", + "main": "index.js", + "types": "index.d.ts", + "files": [ + "lib/", + "index.d.ts", + "index.js" + ], + "dependencies": { + "@types/unist": "^2.0.0", + "unist-util-stringify-position": "^3.0.0" + }, + "devDependencies": { + "@types/node": "^18.0.0", + "c8": "^7.0.0", + "prettier": "^2.0.0", + "remark-cli": "^11.0.0", + "remark-preset-wooorm": "^9.0.0", + "type-coverage": "^2.0.0", + "typescript": "^4.0.0", + "xo": "^0.53.0" + }, + "scripts": { + "prepack": "npm run build && npm run format", + "build": "tsc --build --clean && tsc --build && type-coverage", + "format": "remark . -qfo && prettier . -w --loglevel warn && xo --fix", + "test-api": "node --conditions development test.js", + "test-coverage": "c8 --check-coverage --100 --reporter lcov npm run test-api", + "test": "npm run build && npm run format && npm run test-coverage" + }, + "prettier": { + "tabWidth": 2, + "useTabs": false, + "singleQuote": true, + "bracketSpacing": false, + "semi": false, + "trailingComma": "none" + }, + "xo": { + "prettier": true + }, + "remarkConfig": { + "plugins": [ + "preset-wooorm" + ] + }, + "typeCoverage": { + "atLeast": 100, + "detail": true, + "strict": true, + "ignoreCatch": true + } +} diff --git a/node_modules/vfile-message/readme.md b/node_modules/vfile-message/readme.md new file mode 100644 index 0000000..35cb052 --- /dev/null +++ b/node_modules/vfile-message/readme.md @@ -0,0 +1,244 @@ +# vfile-message + +[![Build][build-badge]][build] +[![Coverage][coverage-badge]][coverage] +[![Downloads][downloads-badge]][downloads] +[![Size][size-badge]][size] +[![Sponsors][sponsors-badge]][collective] +[![Backers][backers-badge]][collective] +[![Chat][chat-badge]][chat] + +Create [vfile][] messages. + +## Contents + +* [What is this?](#what-is-this) +* [When should I use this?](#when-should-i-use-this) +* [Install](#install) +* [Use](#use) +* [API](#api) + * [`VFileMessage(reason[, place][, origin])`](#vfilemessagereason-place-origin) + * [Well-known](#well-known) +* [Types](#types) +* [Compatibility](#compatibility) +* [Contribute](#contribute) +* [License](#license) + +## What is this? + +This package provides a (lint) message format. + +## When should I use this? + +In most cases, you can use `file.message` from `VFile` itself, but in some +cases you might not have a file, and still want to emit warnings or errors, +in which case this can be used directly. + +## Install + +This package is [ESM only][esm]. +In Node.js (version 14.14+ and 16.0+), install with [npm][]: + +```sh +npm install vfile-message +``` + +In Deno with [`esm.sh`][esmsh]: + +```js +import {VFileMessage} from 'https://esm.sh/vfile-message@3' +``` + +In browsers with [`esm.sh`][esmsh]: + +```html + +``` + +## Use + +```js +import {VFileMessage} from 'vfile-message' + +const message = new VFileMessage( + 'Unexpected unknown word `braavo`, did you mean `bravo`?', + {line: 1, column: 8}, + 'spell:typo' +) + +console.log(message) +``` + +Yields: + +```txt +[1:8: Unexpected unknown word `braavo`, did you mean `bravo`?] { + reason: 'Unexpected unknown word `braavo`, did you mean `bravo`?', + line: 1, + column: 8, + source: 'spell', + ruleId: 'typo', + position: {start: {line: 1, column: 8}, end: {line: null, column: null}} +} +``` + +## API + +This package exports the identifier [`VFileMessage`][api-vfile-message]. +There is no default export. + +### `VFileMessage(reason[, place][, origin])` + +Create a message for `reason` at `place` from `origin`. + +When an error is passed in as `reason`, the `stack` is copied. + +###### Parameters + +* `reason` (`string` or `Error`) + — reason for message, uses the stack and message of the error if given +* `place` ([`Node`][node], [`Position`][position], or [`Point`][point], + optional) + — place in file where the message occurred +* `origin` (`string`, optional) + — place in code where the message originates (example: + `'my-package:my-rule'` or `'my-rule'`) + +###### Extends + +[`Error`][error]. + +###### Returns + +Instance of `VFileMessage`. + +###### Fields + +* `reason` (`string`) + — reason for message (you should use markdown) +* `fatal` (`boolean | null | undefined`) + — state of problem; `true` marks associated file as no longer processable + (error); `false` necessitates a (potential) change (warning); + `null | undefined` for things that might not need changing (info) +* `line` (`number | null`) + — starting line of error +* `column` (`number | null`) + — starting column of error +* `position` ([`Position | null`][position]) + — full unist position +* `source` (`string | null`, example: `'my-package'`) + — namespace of message +* `ruleId` (`string | null`, example: `'my-rule'`) + — category of message +* `stack` (`string | null`) + — stack of message in code +* `file` (`string | null`) + — path of a file (used throughout the `VFile` ecosystem) + +### Well-known + +It’s OK to store custom data directly on the `VFileMessage`, some of those are +handled by [utilities][util]. +The following fields are documented and typed here. + +###### Fields + +* `actual` (`string | null`) + — specify the source value that’s being reported, which is deemed incorrect +* `expected` (`Array | null`) + — suggest acceptable values that can be used instead of `actual` +* `url` (`string | null`) + — link to docs for the message (this must be an absolute URL that can be + passed as `x` to `new URL(x)`) +* `note` (`string | null`) + — long form description of the message (you should use markdown) + +## Types + +This package is fully typed with [TypeScript][]. +It exports no additional types. + +## Compatibility + +Projects maintained by the unified collective are compatible with all maintained +versions of Node.js. +As of now, that is Node.js 14.14+ and 16.0+. +Our projects sometimes work with older versions, but this is not guaranteed. + +## Contribute + +See [`contributing.md`][contributing] in [`vfile/.github`][health] for ways to +get started. +See [`support.md`][support] for ways to get help. + +This project has a [code of conduct][coc]. +By interacting with this repository, organization, or community you agree to +abide by its terms. + +## License + +[MIT][license] © [Titus Wormer][author] + + + +[build-badge]: https://github.com/vfile/vfile-message/workflows/main/badge.svg + +[build]: https://github.com/vfile/vfile-message/actions + +[coverage-badge]: https://img.shields.io/codecov/c/github/vfile/vfile-message.svg + +[coverage]: https://codecov.io/github/vfile/vfile-message + +[downloads-badge]: https://img.shields.io/npm/dm/vfile-message.svg + +[downloads]: https://www.npmjs.com/package/vfile-message + +[size-badge]: https://img.shields.io/bundlephobia/minzip/vfile-message.svg + +[size]: https://bundlephobia.com/result?p=vfile-message + +[sponsors-badge]: https://opencollective.com/unified/sponsors/badge.svg + +[backers-badge]: https://opencollective.com/unified/backers/badge.svg + +[collective]: https://opencollective.com/unified + +[chat-badge]: https://img.shields.io/badge/chat-discussions-success.svg + +[chat]: https://github.com/vfile/vfile/discussions + +[npm]: https://docs.npmjs.com/cli/install + +[contributing]: https://github.com/vfile/.github/blob/main/contributing.md + +[support]: https://github.com/vfile/.github/blob/main/support.md + +[health]: https://github.com/vfile/.github + +[coc]: https://github.com/vfile/.github/blob/main/code-of-conduct.md + +[esm]: https://gist.github.com/sindresorhus/a39789f98801d908bbc7ff3ecc99d99c + +[esmsh]: https://esm.sh + +[typescript]: https://www.typescriptlang.org + +[license]: license + +[author]: https://wooorm.com + +[error]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error + +[node]: https://github.com/syntax-tree/unist#node + +[position]: https://github.com/syntax-tree/unist#position + +[point]: https://github.com/syntax-tree/unist#point + +[vfile]: https://github.com/vfile/vfile + +[util]: https://github.com/vfile/vfile#utilities + +[api-vfile-message]: #vfilemessagereason-place-origin diff --git a/node_modules/vfile/index.d.ts b/node_modules/vfile/index.d.ts new file mode 100644 index 0000000..6b5215b --- /dev/null +++ b/node_modules/vfile/index.d.ts @@ -0,0 +1,64 @@ +import type {Reporter} from './lib/index.js' + +/** + * This is the same as `Buffer` if node types are included, `never` otherwise. + */ +// eslint-disable-next-line @typescript-eslint/ban-ts-comment, @typescript-eslint/prefer-ts-expect-error +// @ts-ignore It’s important to preserve this ignore statement. This makes sure +// it works both with and without node types. +// eslint-disable-next-line n/prefer-global/buffer +type MaybeBuffer = any extends Buffer ? never : Buffer + +/** + * Contents of the file. + * + * Can either be text or a `Buffer` structure. + */ +// Note: this does not directly use type `Buffer`, because it can also be used +// in a browser context. +// Instead this leverages `Uint8Array` which is the base type for `Buffer`, +// and a native JavaScript construct. +export type Value = string | MaybeBuffer + +/** + * This map registers the type of the `data` key of a `VFile`. + * + * This type can be augmented to register custom `data` types. + * + * @example + * declare module 'vfile' { + * interface DataMap { + * // `file.data.name` is typed as `string` + * name: string + * } + * } + */ + +// eslint-disable-next-line @typescript-eslint/consistent-type-definitions, @typescript-eslint/no-empty-interface +export interface DataMap {} + +/** + * Custom information. + * + * Known attributes can be added to @see {@link DataMap} + */ +export type Data = Record & Partial + +// Deprecated names (w/ prefix): +export type {Data as VFileData, DataMap as VFileDataMap, Value as VFileValue} + +export {VFile} from './lib/index.js' + +export type { + BufferEncoding, + Map, + Compatible, + Options, + Reporter, + ReporterSettings, + // Deprecated names (w/ prefix): + Compatible as VFileCompatible, + Options as VFileOptions, + Reporter as VFileReporter, + ReporterSettings as VFileReporterSettings +} from './lib/index.js' diff --git a/node_modules/vfile/index.js b/node_modules/vfile/index.js new file mode 100644 index 0000000..73c0d38 --- /dev/null +++ b/node_modules/vfile/index.js @@ -0,0 +1 @@ +export {VFile} from './lib/index.js' diff --git a/node_modules/vfile/lib/index.d.ts b/node_modules/vfile/lib/index.d.ts new file mode 100644 index 0000000..03ab38c --- /dev/null +++ b/node_modules/vfile/lib/index.d.ts @@ -0,0 +1,355 @@ +export class VFile { + /** + * Create a new virtual file. + * + * `options` is treated as: + * + * * `string` or `Buffer` — `{value: options}` + * * `URL` — `{path: options}` + * * `VFile` — shallow copies its data over to the new file + * * `object` — all fields are shallow copied over to the new file + * + * Path related fields are set in the following order (least specific to + * most specific): `history`, `path`, `basename`, `stem`, `extname`, + * `dirname`. + * + * You cannot set `dirname` or `extname` without setting either `history`, + * `path`, `basename`, or `stem` too. + * + * @param {Compatible | null | undefined} [value] + * File value. + * @returns + * New instance. + */ + constructor(value?: Compatible | null | undefined) + /** + * Place to store custom information (default: `{}`). + * + * It’s OK to store custom data directly on the file but moving it to + * `data` is recommended. + * + * @type {Data} + */ + data: Data + /** + * List of messages associated with the file. + * + * @type {Array} + */ + messages: Array + /** + * List of filepaths the file moved between. + * + * The first is the original path and the last is the current path. + * + * @type {Array} + */ + history: Array + /** + * Base of `path` (default: `process.cwd()` or `'/'` in browsers). + * + * @type {string} + */ + cwd: string + /** + * Raw value. + * + * @type {Value} + */ + value: Value + /** + * Whether a file was saved to disk. + * + * This is used by vfile reporters. + * + * @type {boolean} + */ + stored: boolean + /** + * Custom, non-string, compiled, representation. + * + * This is used by unified to store non-string results. + * One example is when turning markdown into React nodes. + * + * @type {unknown} + */ + result: unknown + /** + * Source map. + * + * This type is equivalent to the `RawSourceMap` type from the `source-map` + * module. + * + * @type {Map | null | undefined} + */ + map: Map | null | undefined + /** + * Set the full path (example: `'~/index.min.js'`). + * + * Cannot be nullified. + * You can set a file URL (a `URL` object with a `file:` protocol) which will + * be turned into a path with `url.fileURLToPath`. + * + * @param {string | URL} path + */ + set path(arg: string) + /** + * Get the full path (example: `'~/index.min.js'`). + * + * @returns {string} + */ + get path(): string + /** + * Set the parent path (example: `'~'`). + * + * Cannot be set if there’s no `path` yet. + */ + set dirname(arg: string | undefined) + /** + * Get the parent path (example: `'~'`). + */ + get dirname(): string | undefined + /** + * Set basename (including extname) (`'index.min.js'`). + * + * Cannot contain path separators (`'/'` on unix, macOS, and browsers, `'\'` + * on windows). + * Cannot be nullified (use `file.path = file.dirname` instead). + */ + set basename(arg: string | undefined) + /** + * Get the basename (including extname) (example: `'index.min.js'`). + */ + get basename(): string | undefined + /** + * Set the extname (including dot) (example: `'.js'`). + * + * Cannot contain path separators (`'/'` on unix, macOS, and browsers, `'\'` + * on windows). + * Cannot be set if there’s no `path` yet. + */ + set extname(arg: string | undefined) + /** + * Get the extname (including dot) (example: `'.js'`). + */ + get extname(): string | undefined + /** + * Set the stem (basename w/o extname) (example: `'index.min'`). + * + * Cannot contain path separators (`'/'` on unix, macOS, and browsers, `'\'` + * on windows). + * Cannot be nullified (use `file.path = file.dirname` instead). + */ + set stem(arg: string | undefined) + /** + * Get the stem (basename w/o extname) (example: `'index.min'`). + */ + get stem(): string | undefined + /** + * Serialize the file. + * + * @param {BufferEncoding | null | undefined} [encoding='utf8'] + * Character encoding to understand `value` as when it’s a `Buffer` + * (default: `'utf8'`). + * @returns {string} + * Serialized file. + */ + toString(encoding?: BufferEncoding | null | undefined): string + /** + * Create a warning message associated with the file. + * + * Its `fatal` is set to `false` and `file` is set to the current file path. + * Its added to `file.messages`. + * + * @param {string | Error | VFileMessage} reason + * Reason for message, uses the stack and message of the error if given. + * @param {Node | NodeLike | Position | Point | null | undefined} [place] + * Place in file where the message occurred. + * @param {string | null | undefined} [origin] + * Place in code where the message originates (example: + * `'my-package:my-rule'` or `'my-rule'`). + * @returns {VFileMessage} + * Message. + */ + message( + reason: string | Error | VFileMessage, + place?: Node | NodeLike | Position | Point | null | undefined, + origin?: string | null | undefined + ): VFileMessage + /** + * Create an info message associated with the file. + * + * Its `fatal` is set to `null` and `file` is set to the current file path. + * Its added to `file.messages`. + * + * @param {string | Error | VFileMessage} reason + * Reason for message, uses the stack and message of the error if given. + * @param {Node | NodeLike | Position | Point | null | undefined} [place] + * Place in file where the message occurred. + * @param {string | null | undefined} [origin] + * Place in code where the message originates (example: + * `'my-package:my-rule'` or `'my-rule'`). + * @returns {VFileMessage} + * Message. + */ + info( + reason: string | Error | VFileMessage, + place?: Node | NodeLike | Position | Point | null | undefined, + origin?: string | null | undefined + ): VFileMessage + /** + * Create a fatal error associated with the file. + * + * Its `fatal` is set to `true` and `file` is set to the current file path. + * Its added to `file.messages`. + * + * > 👉 **Note**: a fatal error means that a file is no longer processable. + * + * @param {string | Error | VFileMessage} reason + * Reason for message, uses the stack and message of the error if given. + * @param {Node | NodeLike | Position | Point | null | undefined} [place] + * Place in file where the message occurred. + * @param {string | null | undefined} [origin] + * Place in code where the message originates (example: + * `'my-package:my-rule'` or `'my-rule'`). + * @returns {never} + * Message. + * @throws {VFileMessage} + * Message. + */ + fail( + reason: string | Error | VFileMessage, + place?: Node | NodeLike | Position | Point | null | undefined, + origin?: string | null | undefined + ): never +} +export type Node = import('unist').Node +export type Position = import('unist').Position +export type Point = import('unist').Point +export type URL = import('./minurl.shared.js').URL +export type Data = import('../index.js').Data +export type Value = import('../index.js').Value +export type NodeLike = Record & { + type: string + position?: Position | undefined +} +/** + * Encodings supported by the buffer class. + * + * This is a copy of the types from Node, copied to prevent Node globals from + * being needed. + * Copied from: + */ +export type BufferEncoding = + | 'ascii' + | 'utf8' + | 'utf-8' + | 'utf16le' + | 'ucs2' + | 'ucs-2' + | 'base64' + | 'base64url' + | 'latin1' + | 'binary' + | 'hex' +/** + * Things that can be passed to the constructor. + */ +export type Compatible = Options | URL | Value | VFile +/** + * Set multiple values. + */ +export type VFileCoreOptions = { + /** + * Set `value`. + */ + value?: Value | null | undefined + /** + * Set `cwd`. + */ + cwd?: string | null | undefined + /** + * Set `history`. + */ + history?: Array | null | undefined + /** + * Set `path`. + */ + path?: URL | string | null | undefined + /** + * Set `basename`. + */ + basename?: string | null | undefined + /** + * Set `stem`. + */ + stem?: string | null | undefined + /** + * Set `extname`. + */ + extname?: string | null | undefined + /** + * Set `dirname`. + */ + dirname?: string | null | undefined + /** + * Set `data`. + */ + data?: Data | null | undefined +} +/** + * Raw source map. + * + * See: + * . + */ +export type Map = { + /** + * Which version of the source map spec this map is following. + */ + version: number + /** + * An array of URLs to the original source files. + */ + sources: Array + /** + * An array of identifiers which can be referenced by individual mappings. + */ + names: Array + /** + * The URL root from which all sources are relative. + */ + sourceRoot?: string | undefined + /** + * An array of contents of the original source files. + */ + sourcesContent?: Array | undefined + /** + * A string of base64 VLQs which contain the actual mappings. + */ + mappings: string + /** + * The generated file this source map is associated with. + */ + file: string +} +/** + * Configuration. + * + * A bunch of keys that will be shallow copied over to the new file. + */ +export type Options = { + [key: string]: unknown +} & VFileCoreOptions +/** + * Configuration for reporters. + */ +export type ReporterSettings = Record +/** + * Type for a reporter. + */ +export type Reporter = ( + files: Array, + options: Settings +) => string +import {VFileMessage} from 'vfile-message' diff --git a/node_modules/vfile/lib/index.js b/node_modules/vfile/lib/index.js new file mode 100644 index 0000000..e74a58c --- /dev/null +++ b/node_modules/vfile/lib/index.js @@ -0,0 +1,520 @@ +/** + * @typedef {import('unist').Node} Node + * @typedef {import('unist').Position} Position + * @typedef {import('unist').Point} Point + * @typedef {import('./minurl.shared.js').URL} URL + * @typedef {import('../index.js').Data} Data + * @typedef {import('../index.js').Value} Value + */ + +/** + * @typedef {Record & {type: string, position?: Position | undefined}} NodeLike + * + * @typedef {'ascii' | 'utf8' | 'utf-8' | 'utf16le' | 'ucs2' | 'ucs-2' | 'base64' | 'base64url' | 'latin1' | 'binary' | 'hex'} BufferEncoding + * Encodings supported by the buffer class. + * + * This is a copy of the types from Node, copied to prevent Node globals from + * being needed. + * Copied from: + * + * @typedef {Options | URL | Value | VFile} Compatible + * Things that can be passed to the constructor. + * + * @typedef VFileCoreOptions + * Set multiple values. + * @property {Value | null | undefined} [value] + * Set `value`. + * @property {string | null | undefined} [cwd] + * Set `cwd`. + * @property {Array | null | undefined} [history] + * Set `history`. + * @property {URL | string | null | undefined} [path] + * Set `path`. + * @property {string | null | undefined} [basename] + * Set `basename`. + * @property {string | null | undefined} [stem] + * Set `stem`. + * @property {string | null | undefined} [extname] + * Set `extname`. + * @property {string | null | undefined} [dirname] + * Set `dirname`. + * @property {Data | null | undefined} [data] + * Set `data`. + * + * @typedef Map + * Raw source map. + * + * See: + * . + * @property {number} version + * Which version of the source map spec this map is following. + * @property {Array} sources + * An array of URLs to the original source files. + * @property {Array} names + * An array of identifiers which can be referenced by individual mappings. + * @property {string | undefined} [sourceRoot] + * The URL root from which all sources are relative. + * @property {Array | undefined} [sourcesContent] + * An array of contents of the original source files. + * @property {string} mappings + * A string of base64 VLQs which contain the actual mappings. + * @property {string} file + * The generated file this source map is associated with. + * + * @typedef {{[key: string]: unknown} & VFileCoreOptions} Options + * Configuration. + * + * A bunch of keys that will be shallow copied over to the new file. + * + * @typedef {Record} ReporterSettings + * Configuration for reporters. + */ + +/** + * @template {ReporterSettings} Settings + * Options type. + * @callback Reporter + * Type for a reporter. + * @param {Array} files + * Files to report. + * @param {Settings} options + * Configuration. + * @returns {string} + * Report. + */ + +import bufferLike from 'is-buffer' +import {VFileMessage} from 'vfile-message' +import {path} from './minpath.js' +import {proc} from './minproc.js' +import {urlToPath, isUrl} from './minurl.js' + +/** + * Order of setting (least specific to most), we need this because otherwise + * `{stem: 'a', path: '~/b.js'}` would throw, as a path is needed before a + * stem can be set. + * + * @type {Array<'basename' | 'dirname' | 'extname' | 'history' | 'path' | 'stem'>} + */ +const order = ['history', 'path', 'basename', 'stem', 'extname', 'dirname'] + +export class VFile { + /** + * Create a new virtual file. + * + * `options` is treated as: + * + * * `string` or `Buffer` — `{value: options}` + * * `URL` — `{path: options}` + * * `VFile` — shallow copies its data over to the new file + * * `object` — all fields are shallow copied over to the new file + * + * Path related fields are set in the following order (least specific to + * most specific): `history`, `path`, `basename`, `stem`, `extname`, + * `dirname`. + * + * You cannot set `dirname` or `extname` without setting either `history`, + * `path`, `basename`, or `stem` too. + * + * @param {Compatible | null | undefined} [value] + * File value. + * @returns + * New instance. + */ + constructor(value) { + /** @type {Options | VFile} */ + let options + + if (!value) { + options = {} + } else if (typeof value === 'string' || buffer(value)) { + options = {value} + } else if (isUrl(value)) { + options = {path: value} + } else { + options = value + } + + /** + * Place to store custom information (default: `{}`). + * + * It’s OK to store custom data directly on the file but moving it to + * `data` is recommended. + * + * @type {Data} + */ + this.data = {} + + /** + * List of messages associated with the file. + * + * @type {Array} + */ + this.messages = [] + + /** + * List of filepaths the file moved between. + * + * The first is the original path and the last is the current path. + * + * @type {Array} + */ + this.history = [] + + /** + * Base of `path` (default: `process.cwd()` or `'/'` in browsers). + * + * @type {string} + */ + this.cwd = proc.cwd() + + /* eslint-disable no-unused-expressions */ + /** + * Raw value. + * + * @type {Value} + */ + this.value + + // The below are non-standard, they are “well-known”. + // As in, used in several tools. + + /** + * Whether a file was saved to disk. + * + * This is used by vfile reporters. + * + * @type {boolean} + */ + this.stored + + /** + * Custom, non-string, compiled, representation. + * + * This is used by unified to store non-string results. + * One example is when turning markdown into React nodes. + * + * @type {unknown} + */ + this.result + + /** + * Source map. + * + * This type is equivalent to the `RawSourceMap` type from the `source-map` + * module. + * + * @type {Map | null | undefined} + */ + this.map + /* eslint-enable no-unused-expressions */ + + // Set path related properties in the correct order. + let index = -1 + + while (++index < order.length) { + const prop = order[index] + + // Note: we specifically use `in` instead of `hasOwnProperty` to accept + // `vfile`s too. + if ( + prop in options && + options[prop] !== undefined && + options[prop] !== null + ) { + // @ts-expect-error: TS doesn’t understand basic reality. + this[prop] = prop === 'history' ? [...options[prop]] : options[prop] + } + } + + /** @type {string} */ + let prop + + // Set non-path related properties. + for (prop in options) { + // @ts-expect-error: fine to set other things. + if (!order.includes(prop)) { + // @ts-expect-error: fine to set other things. + this[prop] = options[prop] + } + } + } + + /** + * Get the full path (example: `'~/index.min.js'`). + * + * @returns {string} + */ + get path() { + return this.history[this.history.length - 1] + } + + /** + * Set the full path (example: `'~/index.min.js'`). + * + * Cannot be nullified. + * You can set a file URL (a `URL` object with a `file:` protocol) which will + * be turned into a path with `url.fileURLToPath`. + * + * @param {string | URL} path + */ + set path(path) { + if (isUrl(path)) { + path = urlToPath(path) + } + + assertNonEmpty(path, 'path') + + if (this.path !== path) { + this.history.push(path) + } + } + + /** + * Get the parent path (example: `'~'`). + */ + get dirname() { + return typeof this.path === 'string' ? path.dirname(this.path) : undefined + } + + /** + * Set the parent path (example: `'~'`). + * + * Cannot be set if there’s no `path` yet. + */ + set dirname(dirname) { + assertPath(this.basename, 'dirname') + this.path = path.join(dirname || '', this.basename) + } + + /** + * Get the basename (including extname) (example: `'index.min.js'`). + */ + get basename() { + return typeof this.path === 'string' ? path.basename(this.path) : undefined + } + + /** + * Set basename (including extname) (`'index.min.js'`). + * + * Cannot contain path separators (`'/'` on unix, macOS, and browsers, `'\'` + * on windows). + * Cannot be nullified (use `file.path = file.dirname` instead). + */ + set basename(basename) { + assertNonEmpty(basename, 'basename') + assertPart(basename, 'basename') + this.path = path.join(this.dirname || '', basename) + } + + /** + * Get the extname (including dot) (example: `'.js'`). + */ + get extname() { + return typeof this.path === 'string' ? path.extname(this.path) : undefined + } + + /** + * Set the extname (including dot) (example: `'.js'`). + * + * Cannot contain path separators (`'/'` on unix, macOS, and browsers, `'\'` + * on windows). + * Cannot be set if there’s no `path` yet. + */ + set extname(extname) { + assertPart(extname, 'extname') + assertPath(this.dirname, 'extname') + + if (extname) { + if (extname.charCodeAt(0) !== 46 /* `.` */) { + throw new Error('`extname` must start with `.`') + } + + if (extname.includes('.', 1)) { + throw new Error('`extname` cannot contain multiple dots') + } + } + + this.path = path.join(this.dirname, this.stem + (extname || '')) + } + + /** + * Get the stem (basename w/o extname) (example: `'index.min'`). + */ + get stem() { + return typeof this.path === 'string' + ? path.basename(this.path, this.extname) + : undefined + } + + /** + * Set the stem (basename w/o extname) (example: `'index.min'`). + * + * Cannot contain path separators (`'/'` on unix, macOS, and browsers, `'\'` + * on windows). + * Cannot be nullified (use `file.path = file.dirname` instead). + */ + set stem(stem) { + assertNonEmpty(stem, 'stem') + assertPart(stem, 'stem') + this.path = path.join(this.dirname || '', stem + (this.extname || '')) + } + + /** + * Serialize the file. + * + * @param {BufferEncoding | null | undefined} [encoding='utf8'] + * Character encoding to understand `value` as when it’s a `Buffer` + * (default: `'utf8'`). + * @returns {string} + * Serialized file. + */ + toString(encoding) { + return (this.value || '').toString(encoding || undefined) + } + + /** + * Create a warning message associated with the file. + * + * Its `fatal` is set to `false` and `file` is set to the current file path. + * Its added to `file.messages`. + * + * @param {string | Error | VFileMessage} reason + * Reason for message, uses the stack and message of the error if given. + * @param {Node | NodeLike | Position | Point | null | undefined} [place] + * Place in file where the message occurred. + * @param {string | null | undefined} [origin] + * Place in code where the message originates (example: + * `'my-package:my-rule'` or `'my-rule'`). + * @returns {VFileMessage} + * Message. + */ + message(reason, place, origin) { + const message = new VFileMessage(reason, place, origin) + + if (this.path) { + message.name = this.path + ':' + message.name + message.file = this.path + } + + message.fatal = false + + this.messages.push(message) + + return message + } + + /** + * Create an info message associated with the file. + * + * Its `fatal` is set to `null` and `file` is set to the current file path. + * Its added to `file.messages`. + * + * @param {string | Error | VFileMessage} reason + * Reason for message, uses the stack and message of the error if given. + * @param {Node | NodeLike | Position | Point | null | undefined} [place] + * Place in file where the message occurred. + * @param {string | null | undefined} [origin] + * Place in code where the message originates (example: + * `'my-package:my-rule'` or `'my-rule'`). + * @returns {VFileMessage} + * Message. + */ + info(reason, place, origin) { + const message = this.message(reason, place, origin) + + message.fatal = null + + return message + } + + /** + * Create a fatal error associated with the file. + * + * Its `fatal` is set to `true` and `file` is set to the current file path. + * Its added to `file.messages`. + * + * > 👉 **Note**: a fatal error means that a file is no longer processable. + * + * @param {string | Error | VFileMessage} reason + * Reason for message, uses the stack and message of the error if given. + * @param {Node | NodeLike | Position | Point | null | undefined} [place] + * Place in file where the message occurred. + * @param {string | null | undefined} [origin] + * Place in code where the message originates (example: + * `'my-package:my-rule'` or `'my-rule'`). + * @returns {never} + * Message. + * @throws {VFileMessage} + * Message. + */ + fail(reason, place, origin) { + const message = this.message(reason, place, origin) + + message.fatal = true + + throw message + } +} + +/** + * Assert that `part` is not a path (as in, does not contain `path.sep`). + * + * @param {string | null | undefined} part + * File path part. + * @param {string} name + * Part name. + * @returns {void} + * Nothing. + */ +function assertPart(part, name) { + if (part && part.includes(path.sep)) { + throw new Error( + '`' + name + '` cannot be a path: did not expect `' + path.sep + '`' + ) + } +} + +/** + * Assert that `part` is not empty. + * + * @param {string | undefined} part + * Thing. + * @param {string} name + * Part name. + * @returns {asserts part is string} + * Nothing. + */ +function assertNonEmpty(part, name) { + if (!part) { + throw new Error('`' + name + '` cannot be empty') + } +} + +/** + * Assert `path` exists. + * + * @param {string | undefined} path + * Path. + * @param {string} name + * Dependency name. + * @returns {asserts path is string} + * Nothing. + */ +function assertPath(path, name) { + if (!path) { + throw new Error('Setting `' + name + '` requires `path` to be set too') + } +} + +/** + * Assert `value` is a buffer. + * + * @param {unknown} value + * thing. + * @returns {value is Buffer} + * Whether `value` is a Node.js buffer. + */ +function buffer(value) { + return bufferLike(value) +} diff --git a/node_modules/vfile/lib/minpath.browser.d.ts b/node_modules/vfile/lib/minpath.browser.d.ts new file mode 100644 index 0000000..a3fa641 --- /dev/null +++ b/node_modules/vfile/lib/minpath.browser.d.ts @@ -0,0 +1,46 @@ +export namespace path { + export {basename} + export {dirname} + export {extname} + export {join} + export const sep: string +} +/** + * Get the basename from a path. + * + * @param {string} path + * File path. + * @param {string | undefined} [ext] + * Extension to strip. + * @returns {string} + * Stem or basename. + */ +declare function basename(path: string, ext?: string | undefined): string +/** + * Get the dirname from a path. + * + * @param {string} path + * File path. + * @returns {string} + * File path. + */ +declare function dirname(path: string): string +/** + * Get an extname from a path. + * + * @param {string} path + * File path. + * @returns {string} + * Extname. + */ +declare function extname(path: string): string +/** + * Join segments from a path. + * + * @param {Array} segments + * Path segments. + * @returns {string} + * File path. + */ +declare function join(...segments: Array): string +export {} diff --git a/node_modules/vfile/lib/minpath.browser.js b/node_modules/vfile/lib/minpath.browser.js new file mode 100644 index 0000000..48c23fb --- /dev/null +++ b/node_modules/vfile/lib/minpath.browser.js @@ -0,0 +1,422 @@ +// A derivative work based on: +// . +// Which is licensed: +// +// MIT License +// +// Copyright (c) 2013 James Halliday +// +// Permission is hereby granted, free of charge, to any person obtaining a copy of +// this software and associated documentation files (the "Software"), to deal in +// the Software without restriction, including without limitation the rights to +// use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of +// the Software, and to permit persons to whom the Software is furnished to do so, +// subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all +// copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS +// FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR +// COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER +// IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN +// CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +// A derivative work based on: +// +// Parts of that are extracted from Node’s internal `path` module: +// . +// Which is licensed: +// +// Copyright Joyent, Inc. and other Node contributors. +// +// Permission is hereby granted, free of charge, to any person obtaining a +// copy of this software and associated documentation files (the +// "Software"), to deal in the Software without restriction, including +// without limitation the rights to use, copy, modify, merge, publish, +// distribute, sublicense, and/or sell copies of the Software, and to permit +// persons to whom the Software is furnished to do so, subject to the +// following conditions: +// +// The above copyright notice and this permission notice shall be included +// in all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS +// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN +// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, +// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE +// USE OR OTHER DEALINGS IN THE SOFTWARE. + +export const path = {basename, dirname, extname, join, sep: '/'} + +/* eslint-disable max-depth, complexity */ + +/** + * Get the basename from a path. + * + * @param {string} path + * File path. + * @param {string | undefined} [ext] + * Extension to strip. + * @returns {string} + * Stem or basename. + */ +function basename(path, ext) { + if (ext !== undefined && typeof ext !== 'string') { + throw new TypeError('"ext" argument must be a string') + } + + assertPath(path) + let start = 0 + let end = -1 + let index = path.length + /** @type {boolean | undefined} */ + let seenNonSlash + + if (ext === undefined || ext.length === 0 || ext.length > path.length) { + while (index--) { + if (path.charCodeAt(index) === 47 /* `/` */) { + // If we reached a path separator that was not part of a set of path + // separators at the end of the string, stop now. + if (seenNonSlash) { + start = index + 1 + break + } + } else if (end < 0) { + // We saw the first non-path separator, mark this as the end of our + // path component. + seenNonSlash = true + end = index + 1 + } + } + + return end < 0 ? '' : path.slice(start, end) + } + + if (ext === path) { + return '' + } + + let firstNonSlashEnd = -1 + let extIndex = ext.length - 1 + + while (index--) { + if (path.charCodeAt(index) === 47 /* `/` */) { + // If we reached a path separator that was not part of a set of path + // separators at the end of the string, stop now. + if (seenNonSlash) { + start = index + 1 + break + } + } else { + if (firstNonSlashEnd < 0) { + // We saw the first non-path separator, remember this index in case + // we need it if the extension ends up not matching. + seenNonSlash = true + firstNonSlashEnd = index + 1 + } + + if (extIndex > -1) { + // Try to match the explicit extension. + if (path.charCodeAt(index) === ext.charCodeAt(extIndex--)) { + if (extIndex < 0) { + // We matched the extension, so mark this as the end of our path + // component + end = index + } + } else { + // Extension does not match, so our result is the entire path + // component + extIndex = -1 + end = firstNonSlashEnd + } + } + } + } + + if (start === end) { + end = firstNonSlashEnd + } else if (end < 0) { + end = path.length + } + + return path.slice(start, end) +} + +/** + * Get the dirname from a path. + * + * @param {string} path + * File path. + * @returns {string} + * File path. + */ +function dirname(path) { + assertPath(path) + + if (path.length === 0) { + return '.' + } + + let end = -1 + let index = path.length + /** @type {boolean | undefined} */ + let unmatchedSlash + + // Prefix `--` is important to not run on `0`. + while (--index) { + if (path.charCodeAt(index) === 47 /* `/` */) { + if (unmatchedSlash) { + end = index + break + } + } else if (!unmatchedSlash) { + // We saw the first non-path separator + unmatchedSlash = true + } + } + + return end < 0 + ? path.charCodeAt(0) === 47 /* `/` */ + ? '/' + : '.' + : end === 1 && path.charCodeAt(0) === 47 /* `/` */ + ? '//' + : path.slice(0, end) +} + +/** + * Get an extname from a path. + * + * @param {string} path + * File path. + * @returns {string} + * Extname. + */ +function extname(path) { + assertPath(path) + + let index = path.length + + let end = -1 + let startPart = 0 + let startDot = -1 + // Track the state of characters (if any) we see before our first dot and + // after any path separator we find. + let preDotState = 0 + /** @type {boolean | undefined} */ + let unmatchedSlash + + while (index--) { + const code = path.charCodeAt(index) + + if (code === 47 /* `/` */) { + // If we reached a path separator that was not part of a set of path + // separators at the end of the string, stop now. + if (unmatchedSlash) { + startPart = index + 1 + break + } + + continue + } + + if (end < 0) { + // We saw the first non-path separator, mark this as the end of our + // extension. + unmatchedSlash = true + end = index + 1 + } + + if (code === 46 /* `.` */) { + // If this is our first dot, mark it as the start of our extension. + if (startDot < 0) { + startDot = index + } else if (preDotState !== 1) { + preDotState = 1 + } + } else if (startDot > -1) { + // We saw a non-dot and non-path separator before our dot, so we should + // have a good chance at having a non-empty extension. + preDotState = -1 + } + } + + if ( + startDot < 0 || + end < 0 || + // We saw a non-dot character immediately before the dot. + preDotState === 0 || + // The (right-most) trimmed path component is exactly `..`. + (preDotState === 1 && startDot === end - 1 && startDot === startPart + 1) + ) { + return '' + } + + return path.slice(startDot, end) +} + +/** + * Join segments from a path. + * + * @param {Array} segments + * Path segments. + * @returns {string} + * File path. + */ +function join(...segments) { + let index = -1 + /** @type {string | undefined} */ + let joined + + while (++index < segments.length) { + assertPath(segments[index]) + + if (segments[index]) { + joined = + joined === undefined ? segments[index] : joined + '/' + segments[index] + } + } + + return joined === undefined ? '.' : normalize(joined) +} + +/** + * Normalize a basic file path. + * + * @param {string} path + * File path. + * @returns {string} + * File path. + */ +// Note: `normalize` is not exposed as `path.normalize`, so some code is +// manually removed from it. +function normalize(path) { + assertPath(path) + + const absolute = path.charCodeAt(0) === 47 /* `/` */ + + // Normalize the path according to POSIX rules. + let value = normalizeString(path, !absolute) + + if (value.length === 0 && !absolute) { + value = '.' + } + + if (value.length > 0 && path.charCodeAt(path.length - 1) === 47 /* / */) { + value += '/' + } + + return absolute ? '/' + value : value +} + +/** + * Resolve `.` and `..` elements in a path with directory names. + * + * @param {string} path + * File path. + * @param {boolean} allowAboveRoot + * Whether `..` can move above root. + * @returns {string} + * File path. + */ +function normalizeString(path, allowAboveRoot) { + let result = '' + let lastSegmentLength = 0 + let lastSlash = -1 + let dots = 0 + let index = -1 + /** @type {number | undefined} */ + let code + /** @type {number} */ + let lastSlashIndex + + while (++index <= path.length) { + if (index < path.length) { + code = path.charCodeAt(index) + } else if (code === 47 /* `/` */) { + break + } else { + code = 47 /* `/` */ + } + + if (code === 47 /* `/` */) { + if (lastSlash === index - 1 || dots === 1) { + // Empty. + } else if (lastSlash !== index - 1 && dots === 2) { + if ( + result.length < 2 || + lastSegmentLength !== 2 || + result.charCodeAt(result.length - 1) !== 46 /* `.` */ || + result.charCodeAt(result.length - 2) !== 46 /* `.` */ + ) { + if (result.length > 2) { + lastSlashIndex = result.lastIndexOf('/') + + if (lastSlashIndex !== result.length - 1) { + if (lastSlashIndex < 0) { + result = '' + lastSegmentLength = 0 + } else { + result = result.slice(0, lastSlashIndex) + lastSegmentLength = result.length - 1 - result.lastIndexOf('/') + } + + lastSlash = index + dots = 0 + continue + } + } else if (result.length > 0) { + result = '' + lastSegmentLength = 0 + lastSlash = index + dots = 0 + continue + } + } + + if (allowAboveRoot) { + result = result.length > 0 ? result + '/..' : '..' + lastSegmentLength = 2 + } + } else { + if (result.length > 0) { + result += '/' + path.slice(lastSlash + 1, index) + } else { + result = path.slice(lastSlash + 1, index) + } + + lastSegmentLength = index - lastSlash - 1 + } + + lastSlash = index + dots = 0 + } else if (code === 46 /* `.` */ && dots > -1) { + dots++ + } else { + dots = -1 + } + } + + return result +} + +/** + * Make sure `path` is a string. + * + * @param {string} path + * File path. + * @returns {asserts path is string} + * Nothing. + */ +function assertPath(path) { + if (typeof path !== 'string') { + throw new TypeError( + 'Path must be a string. Received ' + JSON.stringify(path) + ) + } +} + +/* eslint-enable max-depth, complexity */ diff --git a/node_modules/vfile/lib/minpath.d.ts b/node_modules/vfile/lib/minpath.d.ts new file mode 100644 index 0000000..80824cc --- /dev/null +++ b/node_modules/vfile/lib/minpath.d.ts @@ -0,0 +1 @@ +export {default as path} from 'path' diff --git a/node_modules/vfile/lib/minpath.js b/node_modules/vfile/lib/minpath.js new file mode 100644 index 0000000..80824cc --- /dev/null +++ b/node_modules/vfile/lib/minpath.js @@ -0,0 +1 @@ +export {default as path} from 'path' diff --git a/node_modules/vfile/lib/minproc.browser.d.ts b/node_modules/vfile/lib/minproc.browser.d.ts new file mode 100644 index 0000000..0c24c91 --- /dev/null +++ b/node_modules/vfile/lib/minproc.browser.d.ts @@ -0,0 +1,5 @@ +export namespace proc { + export {cwd} +} +declare function cwd(): string +export {} diff --git a/node_modules/vfile/lib/minproc.browser.js b/node_modules/vfile/lib/minproc.browser.js new file mode 100644 index 0000000..e40ec9e --- /dev/null +++ b/node_modules/vfile/lib/minproc.browser.js @@ -0,0 +1,8 @@ +// Somewhat based on: +// . +// But I don’t think one tiny line of code can be copyrighted. 😅 +export const proc = {cwd} + +function cwd() { + return '/' +} diff --git a/node_modules/vfile/lib/minproc.d.ts b/node_modules/vfile/lib/minproc.d.ts new file mode 100644 index 0000000..c0d1d27 --- /dev/null +++ b/node_modules/vfile/lib/minproc.d.ts @@ -0,0 +1 @@ +export {default as proc} from 'process' diff --git a/node_modules/vfile/lib/minproc.js b/node_modules/vfile/lib/minproc.js new file mode 100644 index 0000000..c0d1d27 --- /dev/null +++ b/node_modules/vfile/lib/minproc.js @@ -0,0 +1 @@ +export {default as proc} from 'process' diff --git a/node_modules/vfile/lib/minurl.browser.d.ts b/node_modules/vfile/lib/minurl.browser.d.ts new file mode 100644 index 0000000..48b85a4 --- /dev/null +++ b/node_modules/vfile/lib/minurl.browser.d.ts @@ -0,0 +1,9 @@ +/// +/** + * @param {string | URL} path + * File URL. + * @returns {string} + * File URL. + */ +export function urlToPath(path: string | URL): string +export {isUrl} from './minurl.shared.js' diff --git a/node_modules/vfile/lib/minurl.browser.js b/node_modules/vfile/lib/minurl.browser.js new file mode 100644 index 0000000..6438d0d --- /dev/null +++ b/node_modules/vfile/lib/minurl.browser.js @@ -0,0 +1,78 @@ +/// + +import {isUrl} from './minurl.shared.js' + +// See: + +/** + * @param {string | URL} path + * File URL. + * @returns {string} + * File URL. + */ +export function urlToPath(path) { + if (typeof path === 'string') { + path = new URL(path) + } else if (!isUrl(path)) { + /** @type {NodeJS.ErrnoException} */ + const error = new TypeError( + 'The "path" argument must be of type string or an instance of URL. Received `' + + path + + '`' + ) + error.code = 'ERR_INVALID_ARG_TYPE' + throw error + } + + if (path.protocol !== 'file:') { + /** @type {NodeJS.ErrnoException} */ + const error = new TypeError('The URL must be of scheme file') + error.code = 'ERR_INVALID_URL_SCHEME' + throw error + } + + return getPathFromURLPosix(path) +} + +/** + * Get a path from a POSIX URL. + * + * @param {URL} url + * URL. + * @returns {string} + * File path. + */ +function getPathFromURLPosix(url) { + if (url.hostname !== '') { + /** @type {NodeJS.ErrnoException} */ + const error = new TypeError( + 'File URL host must be "localhost" or empty on darwin' + ) + error.code = 'ERR_INVALID_FILE_URL_HOST' + throw error + } + + const pathname = url.pathname + let index = -1 + + while (++index < pathname.length) { + if ( + pathname.charCodeAt(index) === 37 /* `%` */ && + pathname.charCodeAt(index + 1) === 50 /* `2` */ + ) { + const third = pathname.charCodeAt(index + 2) + if (third === 70 /* `F` */ || third === 102 /* `f` */) { + /** @type {NodeJS.ErrnoException} */ + const error = new TypeError( + 'File URL path must not include encoded / characters' + ) + error.code = 'ERR_INVALID_FILE_URL_PATH' + throw error + } + } + } + + return decodeURIComponent(pathname) +} + +export {isUrl} from './minurl.shared.js' diff --git a/node_modules/vfile/lib/minurl.d.ts b/node_modules/vfile/lib/minurl.d.ts new file mode 100644 index 0000000..3c1da37 --- /dev/null +++ b/node_modules/vfile/lib/minurl.d.ts @@ -0,0 +1,2 @@ +export {fileURLToPath as urlToPath} from 'url' +export {isUrl} from './minurl.shared.js' diff --git a/node_modules/vfile/lib/minurl.js b/node_modules/vfile/lib/minurl.js new file mode 100644 index 0000000..3c1da37 --- /dev/null +++ b/node_modules/vfile/lib/minurl.js @@ -0,0 +1,2 @@ +export {fileURLToPath as urlToPath} from 'url' +export {isUrl} from './minurl.shared.js' diff --git a/node_modules/vfile/lib/minurl.shared.d.ts b/node_modules/vfile/lib/minurl.shared.d.ts new file mode 100644 index 0000000..5c6aff6 --- /dev/null +++ b/node_modules/vfile/lib/minurl.shared.d.ts @@ -0,0 +1,42 @@ +/** + * @typedef URL + * @property {string} hash + * @property {string} host + * @property {string} hostname + * @property {string} href + * @property {string} origin + * @property {string} password + * @property {string} pathname + * @property {string} port + * @property {string} protocol + * @property {string} search + * @property {any} searchParams + * @property {string} username + * @property {() => string} toString + * @property {() => string} toJSON + */ +/** + * Check if `fileUrlOrPath` looks like a URL. + * + * @param {unknown} fileUrlOrPath + * File path or URL. + * @returns {fileUrlOrPath is URL} + * Whether it’s a URL. + */ +export function isUrl(fileUrlOrPath: unknown): fileUrlOrPath is URL +export type URL = { + hash: string + host: string + hostname: string + href: string + origin: string + password: string + pathname: string + port: string + protocol: string + search: string + searchParams: any + username: string + toString: () => string + toJSON: () => string +} diff --git a/node_modules/vfile/lib/minurl.shared.js b/node_modules/vfile/lib/minurl.shared.js new file mode 100644 index 0000000..7954129 --- /dev/null +++ b/node_modules/vfile/lib/minurl.shared.js @@ -0,0 +1,37 @@ +/** + * @typedef URL + * @property {string} hash + * @property {string} host + * @property {string} hostname + * @property {string} href + * @property {string} origin + * @property {string} password + * @property {string} pathname + * @property {string} port + * @property {string} protocol + * @property {string} search + * @property {any} searchParams + * @property {string} username + * @property {() => string} toString + * @property {() => string} toJSON + */ + +/** + * Check if `fileUrlOrPath` looks like a URL. + * + * @param {unknown} fileUrlOrPath + * File path or URL. + * @returns {fileUrlOrPath is URL} + * Whether it’s a URL. + */ +// From: +export function isUrl(fileUrlOrPath) { + return ( + fileUrlOrPath !== null && + typeof fileUrlOrPath === 'object' && + // @ts-expect-error: indexable. + fileUrlOrPath.href && + // @ts-expect-error: indexable. + fileUrlOrPath.origin + ) +} diff --git a/node_modules/vfile/license b/node_modules/vfile/license new file mode 100644 index 0000000..f3722d9 --- /dev/null +++ b/node_modules/vfile/license @@ -0,0 +1,21 @@ +(The MIT License) + +Copyright (c) 2015 Titus Wormer + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +THE SOFTWARE. diff --git a/node_modules/vfile/package.json b/node_modules/vfile/package.json new file mode 100644 index 0000000..e6721ae --- /dev/null +++ b/node_modules/vfile/package.json @@ -0,0 +1,111 @@ +{ + "name": "vfile", + "version": "5.3.7", + "description": "Virtual file format for text processing", + "license": "MIT", + "keywords": [ + "vfile", + "virtual", + "file", + "text", + "processing", + "message", + "warning", + "error", + "remark", + "retext", + "rehype" + ], + "repository": "vfile/vfile", + "bugs": "https://github.com/vfile/vfile/issues", + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + }, + "author": "Titus Wormer (https://wooorm.com)", + "contributors": [ + "Titus Wormer (https://wooorm.com)", + "Brendan Abbott ", + "Denys Dovhan ", + "Kyle Mathews ", + "Shinnosuke Watanabe ", + "Sindre Sorhus " + ], + "sideEffects": false, + "type": "module", + "main": "index.js", + "types": "index.d.ts", + "browser": { + "./lib/minpath.js": "./lib/minpath.browser.js", + "./lib/minproc.js": "./lib/minproc.browser.js", + "./lib/minurl.js": "./lib/minurl.browser.js" + }, + "react-native": { + "./lib/minpath.js": "./lib/minpath.browser.js", + "./lib/minproc.js": "./lib/minproc.browser.js", + "./lib/minurl.js": "./lib/minurl.browser.js" + }, + "files": [ + "lib/", + "index.d.ts", + "index.js" + ], + "dependencies": { + "@types/unist": "^2.0.0", + "is-buffer": "^2.0.0", + "unist-util-stringify-position": "^3.0.0", + "vfile-message": "^3.0.0" + }, + "devDependencies": { + "@types/node": "^18.0.0", + "c8": "^7.0.0", + "prettier": "^2.0.0", + "remark-cli": "^11.0.0", + "remark-preset-wooorm": "^9.0.0", + "type-coverage": "^2.0.0", + "typescript": "^4.0.0", + "xo": "^0.53.0" + }, + "scripts": { + "prepack": "npm run build && npm run format", + "build": "tsc --build --clean && tsc --build && type-coverage", + "format": "remark . -qfo && prettier . -w --loglevel warn && xo --fix", + "test-api": "node --conditions development test.js", + "test-coverage": "c8 --check-coverage --100 --reporter lcov npm run test-api", + "test": "npm run build && npm run format && npm run test-coverage" + }, + "prettier": { + "tabWidth": 2, + "useTabs": false, + "singleQuote": true, + "bracketSpacing": false, + "semi": false, + "trailingComma": "none" + }, + "xo": { + "prettier": true, + "rules": { + "unicorn/prefer-code-point": "off", + "unicorn/prefer-node-protocol": "off" + } + }, + "remarkConfig": { + "plugins": [ + "preset-wooorm", + [ + "lint-no-html", + false + ] + ] + }, + "typeCoverage": { + "atLeast": 100, + "detail": true, + "strict": true, + "ignoreCatch": true, + "#": "needed `any`s", + "ignoreFiles": [ + "lib/minurl.shared.d.ts" + ] + } +} diff --git a/node_modules/vfile/readme.md b/node_modules/vfile/readme.md new file mode 100644 index 0000000..f6e873c --- /dev/null +++ b/node_modules/vfile/readme.md @@ -0,0 +1,786 @@ +

+ vfile +

+ +[![Build][build-badge]][build] +[![Coverage][coverage-badge]][coverage] +[![Downloads][downloads-badge]][downloads] +[![Size][size-badge]][size] +[![Sponsors][sponsors-badge]][collective] +[![Backers][backers-badge]][collective] +[![Chat][chat-badge]][chat] + +**vfile** is a small and browser friendly virtual file format that tracks +metadata about files (such as its `path` and `value`) and lint [messages][]. + +## Contents + +* [unified](#unified) +* [What is this?](#what-is-this) +* [When should I use this?](#when-should-i-use-this) +* [Install](#install) +* [Use](#use) +* [API](#api) + * [`VFile(options?)`](#vfileoptions) + * [`file.value`](#filevalue) + * [`file.cwd`](#filecwd) + * [`file.path`](#filepath) + * [`file.dirname`](#filedirname) + * [`file.basename`](#filebasename) + * [`file.extname`](#fileextname) + * [`file.stem`](#filestem) + * [`file.history`](#filehistory) + * [`file.messages`](#filemessages) + * [`file.data`](#filedata) + * [`VFile#toString(encoding?)`](#vfiletostringencoding) + * [`VFile#message(reason[, position][, origin])`](#vfilemessagereason-position-origin) + * [`VFile#info(reason[, position][, origin])`](#vfileinforeason-position-origin) + * [`VFile#fail(reason[, position][, origin])`](#vfilefailreason-position-origin) + * [`BufferEncoding`](#bufferencoding) + * [`Compatible`](#compatible) + * [`Data`](#data) + * [`DataMap`](#datamap) + * [`Map`](#map) + * [`Options`](#options) + * [`Reporter`](#reporter) + * [`ReporterSettings`](#reportersettings) + * [`Value`](#value) + * [Well-known](#well-known) +* [List of utilities](#list-of-utilities) +* [Reporters](#reporters) +* [Types](#types) +* [Compatibility](#compatibility) +* [Contribute](#contribute) +* [Sponsor](#sponsor) +* [Acknowledgments](#acknowledgments) +* [License](#license) + +## unified + +**vfile** is part of the unified collective. + +* for more about us, see [`unifiedjs.com`][site] +* for how the collective is governed, see [`unifiedjs/collective`][governance] +* for updates, see [@unifiedjs][twitter] on Twitter + +## What is this? + +This package provides a virtual file format. +It exposes an API to access the file value, path, metadata about the file, and +specifically supports attaching lint messages and errors to certain places in +these files. + +## When should I use this? + +The virtual file format is useful when dealing with the concept of files in +places where you might not be able to access the file system. +The message API is particularly useful when making things that check files (as +in, linting). + +vfile is made for [unified][], which amongst other things checks files. +However, vfile can be used in other projects that deal with parsing, +transforming, and serializing data, to build linters, compilers, static site +generators, and other build tools. + +This is different from the excellent [`vinyl`][vinyl] in that vfile has a +smaller API, a smaller size, and focuses on messages. + +## Install + +This package is [ESM only][esm]. +In Node.js (version 14.14 and 16.0+), install with [npm][]: + +```sh +npm install vfile +``` + +In Deno with [`esm.sh`][esmsh]: + +```js +import {VFile} from 'https://esm.sh/vfile@5' +``` + +In browsers with [`esm.sh`][esmsh]: + +```html + +``` + +## Use + +```js +import {VFile} from 'vfile' + +const file = new VFile({ + path: '~/example.txt', + value: 'Alpha *braavo* charlie.' +}) + +console.log(file.path) // => '~/example.txt' +console.log(file.dirname) // => '~' + +file.extname = '.md' + +console.log(file.basename) // => 'example.md' + +file.basename = 'index.text' + +console.log(file.history) // => ['~/example.txt', '~/example.md', '~/index.text'] + +file.message('Unexpected unknown word `braavo`, did you mean `bravo`?', { + line: 1, + column: 8 +}) + +console.log(file.messages) +``` + +Yields: + +```txt +[ + [~/index.text:1:8: Unexpected unknown word `braavo`, did you mean `bravo`?] { + reason: 'Unexpected unknown word `braavo`, did you mean `bravo`?', + line: 1, + column: 8, + source: null, + ruleId: null, + position: {start: [Object], end: [Object]}, + file: '~/index.text', + fatal: false + } +] +``` + +## API + +This package exports the identifier [`VFile`][api-vfile]. +There is no default export. + +### `VFile(options?)` + +Create a new virtual file. + +`options` is treated as: + +* `string` or [`Buffer`][buffer] — `{value: options}` +* `URL` — `{path: options}` +* `VFile` — shallow copies its data over to the new file +* `object` — all fields are shallow copied over to the new file + +Path related fields are set in the following order (least specific to +most specific): `history`, `path`, `basename`, `stem`, `extname`, +`dirname`. + +You cannot set `dirname` or `extname` without setting either `history`, +`path`, `basename`, or `stem` too. + +###### Parameters + +* `options` ([`Compatible`][api-compatible], optional) + — file value + +###### Returns + +New instance (`VFile`). + +###### Example + +```js +new VFile() +new VFile('console.log("alpha");') +new VFile(Buffer.from('exit 1')) +new VFile({path: path.join('path', 'to', 'readme.md')}) +new VFile({stem: 'readme', extname: '.md', dirname: path.join('path', 'to')}) +new VFile({other: 'properties', are: 'copied', ov: {e: 'r'}}) +``` + +### `file.value` + +Raw value ([`Buffer`][buffer], `string`, `null`). + +### `file.cwd` + +Base of `path` (`string`, default: `process.cwd()` or `'/'` in browsers). + +### `file.path` + +Get or set the full path (`string?`, example: `'~/index.min.js'`). + +Cannot be nullified. +You can set a file URL (a `URL` object with a `file:` protocol) which will be +turned into a path with [`url.fileURLToPath`][file-url-to-path]. + +### `file.dirname` + +Get or set the parent path (`string?`, example: `'~'`). + +Cannot be set if there’s no `path` yet. + +### `file.basename` + +Get or set the basename (including extname) (`string?`, example: `'index.min.js'`). + +Cannot contain path separators (`'/'` on unix, macOS, and browsers, `'\'` on +windows). +Cannot be nullified (use `file.path = file.dirname` instead). + +### `file.extname` + +Get or set the extname (including dot) (`string?`, example: `'.js'`). + +Cannot contain path separators (`'/'` on unix, macOS, and browsers, `'\'` on +windows). +Cannot be set if there’s no `path` yet. + +### `file.stem` + +Get or set the stem (basename w/o extname) (`string?`, example: `'index.min'`). + +Cannot contain path separators (`'/'` on unix, macOS, and browsers, `'\'` on +windows). +Cannot be nullified. + +### `file.history` + +List of filepaths the file moved between (`Array`). + +The first is the original path and the last is the current path. + +### `file.messages` + +List of messages associated with the file ([`Array`][message]). + +### `file.data` + +Place to store custom information (`Record`, default: `{}`). + +It’s OK to store custom data directly on the file but moving it to `data` is +recommended. + +### `VFile#toString(encoding?)` + +Serialize the file. + +###### Parameters + +* `encoding` ([`BufferEncoding`][api-buffer-encoding], default: `'utf8'`) + — character encoding to understand `value` as when it’s a + [`Buffer`][buffer] + +###### Returns + +Serialized file (`string`). + +### `VFile#message(reason[, position][, origin])` + +Create a warning message associated with the file. + +Its `fatal` is set to `false` and `file` is set to the current file path. +Its added to `file.messages`. + +###### Parameters + +* `reason` (`string` or `Error`) + — reason for message, uses the stack and message of the error if given +* `place` (`Node`, `Position`, or `Point`, optional) + — place in file where the message occurred +* `origin` (`string?`, optional, example: `'my-package:my-rule'` or `'my-rule'`) + — place in code where the message originates + +###### Returns + +Message ([`VFileMessage`][vmessage]). + +### `VFile#info(reason[, position][, origin])` + +Create an info message associated with the file. + +Its `fatal` is set to `null` and `file` is set to the current file path. +Its added to `file.messages`. + +###### Parameters + +* `reason` (`string` or `Error`) + — reason for message, uses the stack and message of the error if given +* `place` (`Node`, `Position`, or `Point`, optional) + — place in file where the message occurred +* `origin` (`string?`, optional, example: `'my-package:my-rule'` or `'my-rule'`) + — place in code where the message originates + +###### Returns + +Message ([`VFileMessage`][vmessage]). + +### `VFile#fail(reason[, position][, origin])` + +Create a fatal error associated with the file. + +Its `fatal` is set to `true` and `file` is set to the current file path. +Its added to `file.messages`. + +> 👉 **Note**: a fatal error means that a file is no longer processable. + +###### Parameters + +* `reason` (`string` or `Error`) + — reason for message, uses the stack and message of the error if given +* `place` (`Node`, `Position`, or `Point`, optional) + — place in file where the message occurred +* `origin` (`string?`, optional, example: `'my-package:my-rule'` or `'my-rule'`) + — place in code where the message originates + +###### Returns + +Nothing (`never`). + +###### Throws + +Message ([`VFileMessage`][vmessage]). + +### `BufferEncoding` + +[Encodings][encoding] supported by the [buffer][] class (TypeScript type). + +This is a copy of the types from Node. + +###### Type + +```ts +type BufferEncoding = + | 'ascii' + | 'utf8' + | 'utf-8' + | 'utf16le' + | 'ucs2' + | 'ucs-2' + | 'base64' + | 'base64url' + | 'latin1' + | 'binary' + | 'hex' +``` + +### `Compatible` + +Things that can be passed to the constructor (TypeScript type). + +###### Type + +```ts +type Compatible = Options | URL | Value | VFile +``` + +### `Data` + +Custom information (TypeScript type). + +Known attributes can be added to [`DataMap`][api-data-map]. + +###### Type + +```ts +type Data = Record & Partial +``` + +### `DataMap` + +This map registers the type of the `data` key of a `VFile` (TypeScript type). + +This type can be augmented to register custom `data` types. + +###### Type + +```ts +interface DataMap {} +``` + +###### Example + +```ts +declare module 'vfile' { + interface DataMap { + // `file.data.name` is typed as `string` + name: string + } +} +``` + +### `Map` + +Raw source map (TypeScript type). + +See [`source-map`][source-map]. + +###### Fields + +* `version` (`number`) + — which version of the source map spec this map is following +* `sources` (`Array`) + — an array of URLs to the original source files +* `names` (`Array`) + — an array of identifiers which can be referenced by individual mappings +* `sourceRoot` (`string`, optional) + — the URL root from which all sources are relative +* `sourcesContent` (`Array`, optional) + — an array of contents of the original source files +* `mappings` (`string`) + — a string of base64 VLQs which contain the actual mappings +* `file` (`string`) + — the generated file this source map is associated with + +### `Options` + +An object with arbitrary fields and the following known fields (TypeScript +type). + +###### Fields + +* `value` ([`Value`][api-value], optional) + — set `value` +* `cwd` (`string`, optional) + — set `cwd` +* `history` (`Array`, optional) + — set `history` +* `path` (`URL | string`, optional) + — set `path` +* `basename` (`string`, optional) + — set `basename` +* `stem` (`string`, optional) + — set `stem` +* `extname` (`string`, optional) + — set `extname` +* `dirname` (`string`, optional) + — set `dirname` +* `data` ([`Data`][api-data], optional) + — set `data` + +### `Reporter` + +Type for a reporter (TypeScript type). + +###### Type + +```ts +type Reporter = ( + files: Array, + options: Settings +) => string +``` + +### `ReporterSettings` + +Configuration for reporters (TypeScript type). + +###### Type + +```ts +type ReporterSettings = Record +``` + +### `Value` + +Contents of the file (TypeScript type). + +Can either be text or a `Buffer` structure. + +###### Type + +```ts +type Value = string | Buffer +``` + +### Well-known + +The following fields are considered “non-standard”, but they are allowed, and +some utilities use them: + +* `stored` (`boolean`) + — whether a file was saved to disk; this is used by vfile reporters +* `result` (`unknown`) + — custom, non-string, compiled, representation; this is used by unified to + store non-string results; one example is when turning markdown into React + nodes +* `map` ([`Map`][api-map]) + — source map; this type is equivalent to the `RawSourceMap` type from the + `source-map` module + +There are also well-known fields on messages, see +[them in a similar section of +`vfile-message`](https://github.com/vfile/vfile-message#well-known). + + + +## List of utilities + +* [`convert-vinyl-to-vfile`](https://github.com/dustinspecker/convert-vinyl-to-vfile) + — transform from [Vinyl][] +* [`to-vfile`](https://github.com/vfile/to-vfile) + — create a file from a filepath and read and write to the file system +* [`vfile-find-down`](https://github.com/vfile/vfile-find-down) + — find files by searching the file system downwards +* [`vfile-find-up`](https://github.com/vfile/vfile-find-up) + — find files by searching the file system upwards +* [`vfile-glob`](https://github.com/shinnn/vfile-glob) + — find files by glob patterns +* [`vfile-is`](https://github.com/vfile/vfile-is) + — check if a file passes a test +* [`vfile-location`](https://github.com/vfile/vfile-location) + — convert between positional and offset locations +* [`vfile-matter`](https://github.com/vfile/vfile-matter) + — parse the YAML front matter +* [`vfile-message`](https://github.com/vfile/vfile-message) + — create a file message +* [`vfile-messages-to-vscode-diagnostics`](https://github.com/shinnn/vfile-messages-to-vscode-diagnostics) + — transform file messages to VS Code diagnostics +* [`vfile-mkdirp`](https://github.com/vfile/vfile-mkdirp) + — make sure the directory of a file exists on the file system +* [`vfile-rename`](https://github.com/vfile/vfile-rename) + — rename the path parts of a file +* [`vfile-sort`](https://github.com/vfile/vfile-sort) + — sort messages by line/column +* [`vfile-statistics`](https://github.com/vfile/vfile-statistics) + — count messages per category: failures, warnings, etc +* [`vfile-to-eslint`](https://github.com/vfile/vfile-to-eslint) + — convert to ESLint formatter compatible output + +> 👉 **Note**: see [unist][] for projects that work with nodes. + +## Reporters + +* [`vfile-reporter`][reporter] + — create a report +* [`vfile-reporter-json`](https://github.com/vfile/vfile-reporter-json) + — create a JSON report +* [`vfile-reporter-folder-json`](https://github.com/vfile/vfile-reporter-folder-json) + — create a JSON representation of vfiles +* [`vfile-reporter-pretty`](https://github.com/vfile/vfile-reporter-pretty) + — create a pretty report +* [`vfile-reporter-junit`](https://github.com/kellyselden/vfile-reporter-junit) + — create a jUnit report +* [`vfile-reporter-position`](https://github.com/Hocdoc/vfile-reporter-position) + — create a report with content excerpts + +> 👉 **Note**: want to make your own reporter? +> Reporters *must* accept `Array` as their first argument, and return +> `string`. +> Reporters *may* accept other values too, in which case it’s suggested to stick +> to `vfile-reporter`s interface. + +## Types + +This package is fully typed with [TypeScript][]. +It exports the additional types +[`BufferEncoding`][api-buffer-encoding], +[`Compatible`][api-compatible], +[`Data`][api-data], +[`DataMap`][api-data-map], +[`Map`][api-map], +[`Options`][api-options], +[`Reporter`][api-reporter], +[`ReporterSettings`][api-reporter-settings], and +[`Value`][api-value]. + +## Compatibility + +Projects maintained by the unified collective are compatible with all maintained +versions of Node.js. +As of now, that is Node.js 14.14+ and 16.0+. +Our projects sometimes work with older versions, but this is not guaranteed. + +## Contribute + +See [`contributing.md`][contributing] in [`vfile/.github`][health] for ways to +get started. +See [`support.md`][support] for ways to get help. + +This project has a [code of conduct][coc]. +By interacting with this repository, organization, or community you agree to +abide by its terms. + +## Sponsor + +Support this effort and give back by sponsoring on [OpenCollective][collective]! + + + + + + + + + + + + + + + + + + + + + + + + + +
+ Vercel

+ +		 + Motif

+ +		 + HashiCorp

+ +		 + GitBook

+ +		 + Gatsby

+ +
+ Netlify

+ + +		 + Coinbase

+ +		 + ThemeIsle

+ +		 + Expo

+ +		 + Boost Note

+ +		 + Holloway

+ +
+
+ You? +

+
+ +## Acknowledgments + +The initial release of this project was authored by +[**@wooorm**](https://github.com/wooorm). + +Thanks to [**@contra**](https://github.com/contra), +[**@phated**](https://github.com/phated), and others for their work on +[Vinyl][], which was a huge inspiration. + +Thanks to +[**@brendo**](https://github.com/brendo), +[**@shinnn**](https://github.com/shinnn), +[**@KyleAMathews**](https://github.com/KyleAMathews), +[**@sindresorhus**](https://github.com/sindresorhus), and +[**@denysdovhan**](https://github.com/denysdovhan) +for contributing commits since! + +## License + +[MIT][license] © [Titus Wormer][author] + + + +[build-badge]: https://github.com/vfile/vfile/workflows/main/badge.svg + +[build]: https://github.com/vfile/vfile/actions + +[coverage-badge]: https://img.shields.io/codecov/c/github/vfile/vfile.svg + +[coverage]: https://codecov.io/github/vfile/vfile + +[downloads-badge]: https://img.shields.io/npm/dm/vfile.svg + +[downloads]: https://www.npmjs.com/package/vfile + +[size-badge]: https://img.shields.io/bundlephobia/minzip/vfile.svg + +[size]: https://bundlephobia.com/result?p=vfile + +[sponsors-badge]: https://opencollective.com/unified/sponsors/badge.svg + +[backers-badge]: https://opencollective.com/unified/backers/badge.svg + +[collective]: https://opencollective.com/unified + +[chat-badge]: https://img.shields.io/badge/chat-discussions-success.svg + +[chat]: https://github.com/vfile/vfile/discussions + +[npm]: https://docs.npmjs.com/cli/install + +[esm]: https://gist.github.com/sindresorhus/a39789f98801d908bbc7ff3ecc99d99c + +[esmsh]: https://esm.sh + +[typescript]: https://www.typescriptlang.org + +[health]: https://github.com/vfile/.github + +[contributing]: https://github.com/vfile/.github/blob/main/contributing.md + +[support]: https://github.com/vfile/.github/blob/main/support.md + +[coc]: https://github.com/vfile/.github/blob/main/code-of-conduct.md + +[license]: license + +[author]: https://wooorm.com + +[unified]: https://github.com/unifiedjs/unified + +[vinyl]: https://github.com/gulpjs/vinyl + +[site]: https://unifiedjs.com + +[twitter]: https://twitter.com/unifiedjs + +[unist]: https://github.com/syntax-tree/unist#list-of-utilities + +[reporter]: https://github.com/vfile/vfile-reporter + +[vmessage]: https://github.com/vfile/vfile-message + +[messages]: #filemessages + +[message]: #vfilemessagereason-position-origin + +[encoding]: https://nodejs.org/api/buffer.html#buffer_buffers_and_character_encodings + +[buffer]: https://nodejs.org/api/buffer.html + +[source-map]: https://github.com/mozilla/source-map/blob/58819f0/source-map.d.ts#L15-L23 + +[file-url-to-path]: https://nodejs.org/api/url.html#url_url_fileurltopath_url + +[governance]: https://github.com/unifiedjs/collective + +[api-vfile]: #vfileoptions + +[api-buffer-encoding]: #bufferencoding + +[api-compatible]: #compatible + +[api-data]: #data + +[api-data-map]: #datamap + +[api-map]: #map + +[api-options]: #options + +[api-reporter]: #reporter + +[api-reporter-settings]: #reportersettings + +[api-value]: #value diff --git a/package-lock.json b/package-lock.json new file mode 100644 index 0000000..e3087c2 --- /dev/null +++ b/package-lock.json @@ -0,0 +1,531 @@ +{ + "name": "srs", + "lockfileVersion": 3, + "requires": true, + "packages": { + "": { + "devDependencies": { + "prettier": "^3.5.3", + "prettier-plugin-latex": "^2.0.1" + } + }, + "node_modules/@types/unist": { + "version": "2.0.11", + "resolved": "https://registry.npmjs.org/@types/unist/-/unist-2.0.11.tgz", + "integrity": "sha512-CmBKiL6NNo/OqgmMn95Fk9Whlp2mtvIv+KNpQKN2F4SjvrEesubTRWGYSg+BnWZOnlCaSTU1sMpsBOzgbYhnsA==", + "dev": true, + "license": "MIT" + }, + "node_modules/@unified-latex/unified-latex-builder": { + "version": "1.8.0", + "resolved": "https://registry.npmjs.org/@unified-latex/unified-latex-builder/-/unified-latex-builder-1.8.0.tgz", + "integrity": "sha512-1s5MIan/qaYeqJI1Tk3bfUwdkk0jIrQXRJt0dF0j3JWT9RG60WbiXp+593eOJgFYJtn+h3FdM0bvalfa+ZzTXg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@unified-latex/unified-latex-types": "^1.8.0" + } + }, + "node_modules/@unified-latex/unified-latex-ctan": { + "version": "1.8.2", + "resolved": "https://registry.npmjs.org/@unified-latex/unified-latex-ctan/-/unified-latex-ctan-1.8.2.tgz", + "integrity": "sha512-VuOEU3Kzed/b+lm+nypYtV1IiqIuFWpwx92WNtBW1w3S+Ba/Ffolx+/LoAd8uuCcyCmygkQi3eZJNHxarzyVIg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@unified-latex/unified-latex-builder": "^1.8.0", + "@unified-latex/unified-latex-types": "^1.8.0", + "@unified-latex/unified-latex-util-argspec": "^1.8.2", + "@unified-latex/unified-latex-util-arguments": "^1.8.2", + "@unified-latex/unified-latex-util-comments": "^1.8.2", + "@unified-latex/unified-latex-util-match": "^1.8.0", + "@unified-latex/unified-latex-util-pegjs": "^1.8.1", + "@unified-latex/unified-latex-util-print-raw": "^1.8.0", + "@unified-latex/unified-latex-util-render-info": "^1.8.2", + "@unified-latex/unified-latex-util-replace": "^1.8.2", + "@unified-latex/unified-latex-util-scan": "^1.8.0", + "@unified-latex/unified-latex-util-split": "^1.8.0", + "@unified-latex/unified-latex-util-trim": "^1.8.2", + "@unified-latex/unified-latex-util-visit": "^1.8.2", + "color": "^4.2.3" + } + }, + "node_modules/@unified-latex/unified-latex-prettier": { + "version": "2.4.2", + "resolved": "https://registry.npmjs.org/@unified-latex/unified-latex-prettier/-/unified-latex-prettier-2.4.2.tgz", + "integrity": "sha512-gMvlKGiGi9zOWVHXPhzeURhPYwPIJ7MBht42et/sVb4Z2wTjhcn+bU7kookT067ywOptVZNBgJw+iAgSORAd+w==", + "deprecated": "Incorrect version number", + "dev": true, + "license": "MIT", + "dependencies": { + "@unified-latex/unified-latex-ctan": "^1.4.1", + "@unified-latex/unified-latex-types": "^1.3.1", + "@unified-latex/unified-latex-util-align": "^1.4.0", + "@unified-latex/unified-latex-util-match": "^1.4.0", + "@unified-latex/unified-latex-util-parse": "^1.4.1", + "@unified-latex/unified-latex-util-pgfkeys": "^1.4.0", + "@unified-latex/unified-latex-util-print-raw": "^1.4.0", + "@unified-latex/unified-latex-util-trim": "^1.4.0", + "@unified-latex/unified-latex-util-visit": "^1.4.0", + "prettier": "^3.0.3", + "unified": "^10.1.2" + } + }, + "node_modules/@unified-latex/unified-latex-types": { + "version": "1.8.0", + "resolved": "https://registry.npmjs.org/@unified-latex/unified-latex-types/-/unified-latex-types-1.8.0.tgz", + "integrity": "sha512-GLJbBmmfDOWtdEbpQCLb7++zPxXin36aC9XOVCuiVNMR9VYv3szOJa+ZdTilVCFHpOeFhKh6zRws96vJgz2tGA==", + "dev": true, + "license": "MIT" + }, + "node_modules/@unified-latex/unified-latex-util-align": { + "version": "1.8.1", + "resolved": "https://registry.npmjs.org/@unified-latex/unified-latex-util-align/-/unified-latex-util-align-1.8.1.tgz", + "integrity": "sha512-csJxLrvziRc5ZkhcRsYI7gSQBGC4fXucPtwNkTscbSIy7PfYF7BfWBPc61sb9jXQg4T4R6MLdG/Tz6Pgb6z1bw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@unified-latex/unified-latex-types": "^1.8.0", + "@unified-latex/unified-latex-util-match": "^1.8.0", + "@unified-latex/unified-latex-util-pegjs": "^1.8.1" + } + }, + "node_modules/@unified-latex/unified-latex-util-argspec": { + "version": "1.8.2", + "resolved": "https://registry.npmjs.org/@unified-latex/unified-latex-util-argspec/-/unified-latex-util-argspec-1.8.2.tgz", + "integrity": "sha512-ts+6Ha9JhcMCt+rbajjiG0srxCz2jHcNrIe3zma2HQzmKNOGxpoTdA7+E4sG2wJgQK1+eQ9MrjGeLBCNXH7fGg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@unified-latex/unified-latex-util-pegjs": "^1.8.1" + } + }, + "node_modules/@unified-latex/unified-latex-util-arguments": { + "version": "1.8.2", + "resolved": "https://registry.npmjs.org/@unified-latex/unified-latex-util-arguments/-/unified-latex-util-arguments-1.8.2.tgz", + "integrity": "sha512-81OqsLoVUhVFgp64z7Jrtndgl5fJGvZKV1eipNWH4IH2hFEM8RZ0fmLxyOn7S/NjYuqWeOJ3WhjOvRHtmLLf2Q==", + "dev": true, + "license": "MIT", + "dependencies": { + "@unified-latex/unified-latex-builder": "^1.8.0", + "@unified-latex/unified-latex-types": "^1.8.0", + "@unified-latex/unified-latex-util-argspec": "^1.8.2", + "@unified-latex/unified-latex-util-match": "^1.8.0", + "@unified-latex/unified-latex-util-render-info": "^1.8.2", + "@unified-latex/unified-latex-util-scan": "^1.8.0", + "@unified-latex/unified-latex-util-visit": "^1.8.2", + "unified": "^10.1.2" + } + }, + "node_modules/@unified-latex/unified-latex-util-catcode": { + "version": "1.8.2", + "resolved": "https://registry.npmjs.org/@unified-latex/unified-latex-util-catcode/-/unified-latex-util-catcode-1.8.2.tgz", + "integrity": "sha512-zChzwfcXufJ5tMkBNC06GdMFj3ldWnlL1eLszFNtcWPvB6KyXHjOPRSZ9aILjbZEd2ogBc8lOKc5ug+iBFBVxA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@unified-latex/unified-latex-types": "^1.8.0", + "@unified-latex/unified-latex-util-match": "^1.8.0", + "@unified-latex/unified-latex-util-visit": "^1.8.2" + } + }, + "node_modules/@unified-latex/unified-latex-util-comments": { + "version": "1.8.2", + "resolved": "https://registry.npmjs.org/@unified-latex/unified-latex-util-comments/-/unified-latex-util-comments-1.8.2.tgz", + "integrity": "sha512-OGeT3BYzLT6hRgyRrPqXTJBpD/JaJl5yIcpQfm5wpcDFBVfcDOCZ8/Xc7UwosOvCjM5EHVTJIxmDQ1epZg3IzA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@unified-latex/unified-latex-types": "^1.8.0", + "@unified-latex/unified-latex-util-match": "^1.8.0", + "@unified-latex/unified-latex-util-replace": "^1.8.2" + } + }, + "node_modules/@unified-latex/unified-latex-util-environments": { + "version": "1.8.2", + "resolved": "https://registry.npmjs.org/@unified-latex/unified-latex-util-environments/-/unified-latex-util-environments-1.8.2.tgz", + "integrity": "sha512-ZaL28+sUtVOSsWv2LfcGXmOJoQJ0Vu4se/7R83awutr2cS3YIZsyCIRFfhz1jYyedWfGLtq+a/2MWJfcIcd7Jg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@unified-latex/unified-latex-types": "^1.8.0", + "@unified-latex/unified-latex-util-arguments": "^1.8.2", + "@unified-latex/unified-latex-util-match": "^1.8.0", + "@unified-latex/unified-latex-util-print-raw": "^1.8.0", + "@unified-latex/unified-latex-util-render-info": "^1.8.2", + "@unified-latex/unified-latex-util-visit": "^1.8.2", + "unified": "^10.1.2" + } + }, + "node_modules/@unified-latex/unified-latex-util-match": { + "version": "1.8.0", + "resolved": "https://registry.npmjs.org/@unified-latex/unified-latex-util-match/-/unified-latex-util-match-1.8.0.tgz", + "integrity": "sha512-fjuLI1KVhWTHkfWn0kR8/RhM2oD2hxWhzgskUMLJ/IZMye9ESvVo8ItG4y+BtpwGFWpTmCtpMNXHjknIQxza9Q==", + "dev": true, + "license": "MIT", + "dependencies": { + "@unified-latex/unified-latex-types": "^1.8.0", + "@unified-latex/unified-latex-util-print-raw": "^1.8.0" + } + }, + "node_modules/@unified-latex/unified-latex-util-parse": { + "version": "1.8.2", + "resolved": "https://registry.npmjs.org/@unified-latex/unified-latex-util-parse/-/unified-latex-util-parse-1.8.2.tgz", + "integrity": "sha512-PyHQTZWS7/BCVa8ojBEmVl5a3iXs5ZSOqhp2R/bbroe7+OEmQbqULPq4GigHA6ClEbPmP8uxmgHZDFGH2cfR7A==", + "dev": true, + "license": "MIT", + "dependencies": { + "@unified-latex/unified-latex-ctan": "^1.8.2", + "@unified-latex/unified-latex-types": "^1.8.0", + "@unified-latex/unified-latex-util-arguments": "^1.8.2", + "@unified-latex/unified-latex-util-catcode": "^1.8.2", + "@unified-latex/unified-latex-util-environments": "^1.8.2", + "@unified-latex/unified-latex-util-match": "^1.8.0", + "@unified-latex/unified-latex-util-pegjs": "^1.8.1", + "@unified-latex/unified-latex-util-print-raw": "^1.8.0", + "@unified-latex/unified-latex-util-trim": "^1.8.2", + "@unified-latex/unified-latex-util-visit": "^1.8.2", + "unified": "^10.1.2" + } + }, + "node_modules/@unified-latex/unified-latex-util-pegjs": { + "version": "1.8.1", + "resolved": "https://registry.npmjs.org/@unified-latex/unified-latex-util-pegjs/-/unified-latex-util-pegjs-1.8.1.tgz", + "integrity": "sha512-1N6WknnzKGACFCmgaEZ2j89j5C2dKhmAOCfy6moD+AMm6nUb69Xp9pJ1jDfqz+Uz9+zRo5I6ksr6q5GgmAJvtw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@unified-latex/unified-latex-types": "^1.8.0", + "@unified-latex/unified-latex-util-match": "^1.8.0" + } + }, + "node_modules/@unified-latex/unified-latex-util-pgfkeys": { + "version": "1.8.1", + "resolved": "https://registry.npmjs.org/@unified-latex/unified-latex-util-pgfkeys/-/unified-latex-util-pgfkeys-1.8.1.tgz", + "integrity": "sha512-VwZeUzmPgKwO2sZ9xx4Ul0Mp82DVdWg32krOlH9dzW4ZQDOBTnRtvx6LQmg9b7Iz3F2pHLYU0LCCaJlvFNBm1A==", + "dev": true, + "license": "MIT", + "dependencies": { + "@unified-latex/unified-latex-types": "^1.8.0", + "@unified-latex/unified-latex-util-match": "^1.8.0", + "@unified-latex/unified-latex-util-pegjs": "^1.8.1", + "@unified-latex/unified-latex-util-print-raw": "^1.8.0" + } + }, + "node_modules/@unified-latex/unified-latex-util-print-raw": { + "version": "1.8.0", + "resolved": "https://registry.npmjs.org/@unified-latex/unified-latex-util-print-raw/-/unified-latex-util-print-raw-1.8.0.tgz", + "integrity": "sha512-lMuLqnHXCDNqrjslf6hBAA2McEI+oaaxvjA9zfeAeWZyZh+DUJjkmwiuxYejwHHKbQvqzregNP4wtb9OvaC21g==", + "dev": true, + "license": "MIT", + "dependencies": { + "@unified-latex/unified-latex-types": "^1.8.0" + } + }, + "node_modules/@unified-latex/unified-latex-util-render-info": { + "version": "1.8.2", + "resolved": "https://registry.npmjs.org/@unified-latex/unified-latex-util-render-info/-/unified-latex-util-render-info-1.8.2.tgz", + "integrity": "sha512-Hjqt8Kx2/pYWwd/S3H397zyenLFwoZsmo7BL/Q7mJfj5wNs35ZMdoHQa0O8tLeZjezkWB2eejODVBsu5xDDCjw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@unified-latex/unified-latex-types": "^1.8.0", + "@unified-latex/unified-latex-util-visit": "^1.8.2" + } + }, + "node_modules/@unified-latex/unified-latex-util-replace": { + "version": "1.8.2", + "resolved": "https://registry.npmjs.org/@unified-latex/unified-latex-util-replace/-/unified-latex-util-replace-1.8.2.tgz", + "integrity": "sha512-89GNj4p5wJmSUGAmdFlGnb/SaV4WykroK85bYbY3Fwppp7kO6sVYSRGfrTEIFob1S4HGL6xrYYUnCueI0+ZzhQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "@unified-latex/unified-latex-types": "^1.8.0", + "@unified-latex/unified-latex-util-match": "^1.8.0", + "@unified-latex/unified-latex-util-split": "^1.8.0", + "@unified-latex/unified-latex-util-trim": "^1.8.2", + "@unified-latex/unified-latex-util-visit": "^1.8.2", + "unified": "^10.1.2" + } + }, + "node_modules/@unified-latex/unified-latex-util-scan": { + "version": "1.8.0", + "resolved": "https://registry.npmjs.org/@unified-latex/unified-latex-util-scan/-/unified-latex-util-scan-1.8.0.tgz", + "integrity": "sha512-4WWDTcLOhlkZsGmGl/IZA0Jg2rTitVwGf6ktxs57AyuCEdzHA5ZeNwzSewW8wpHQdLfnPX+LNEnaukwEdWfF1g==", + "dev": true, + "license": "MIT", + "dependencies": { + "@unified-latex/unified-latex-types": "^1.8.0", + "@unified-latex/unified-latex-util-match": "^1.8.0", + "@unified-latex/unified-latex-util-print-raw": "^1.8.0", + "trie-prefix-tree": "^1.5.1" + } + }, + "node_modules/@unified-latex/unified-latex-util-split": { + "version": "1.8.0", + "resolved": "https://registry.npmjs.org/@unified-latex/unified-latex-util-split/-/unified-latex-util-split-1.8.0.tgz", + "integrity": "sha512-gRlRge72wcvLRs6bEoVbh0fDACbkioEPDJOr7XaCuQqjNNu1VTXlcvImZQVXCdMG6CJ4lqiaJRwnUupK4rsmsA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@unified-latex/unified-latex-types": "^1.8.0", + "@unified-latex/unified-latex-util-match": "^1.8.0" + } + }, + "node_modules/@unified-latex/unified-latex-util-trim": { + "version": "1.8.2", + "resolved": "https://registry.npmjs.org/@unified-latex/unified-latex-util-trim/-/unified-latex-util-trim-1.8.2.tgz", + "integrity": "sha512-zshEykIuLvngWNl7RnMP86KE3yieVLK2u+byPioh6JVQCwkHoz/UiPzl+fuPw/u+93LPNSJBRa16a03sviqyBA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@unified-latex/unified-latex-types": "^1.8.0", + "@unified-latex/unified-latex-util-match": "^1.8.0", + "@unified-latex/unified-latex-util-visit": "^1.8.2", + "unified": "^10.1.2" + } + }, + "node_modules/@unified-latex/unified-latex-util-visit": { + "version": "1.8.2", + "resolved": "https://registry.npmjs.org/@unified-latex/unified-latex-util-visit/-/unified-latex-util-visit-1.8.2.tgz", + "integrity": "sha512-Xq8516ZTKCfjB/txSIbUWtdIR2NdWO8/LlhjMLljFCEO4IE1KfhCCgKgwxNa7uuCkGG0e0BwVEHQIjH4TQZARQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "@unified-latex/unified-latex-types": "^1.8.0", + "@unified-latex/unified-latex-util-match": "^1.8.0" + } + }, + "node_modules/bail": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/bail/-/bail-2.0.2.tgz", + "integrity": "sha512-0xO6mYd7JB2YesxDKplafRpsiOzPt9V02ddPCLbY1xYGPOX24NTyN50qnUxgCPcSoYMhKpAuBTjQoRZCAkUDRw==", + "dev": true, + "license": "MIT", + "funding": { + "type": "github", + "url": "https://github.com/sponsors/wooorm" + } + }, + "node_modules/color": { + "version": "4.2.3", + "resolved": "https://registry.npmjs.org/color/-/color-4.2.3.tgz", + "integrity": "sha512-1rXeuUUiGGrykh+CeBdu5Ie7OJwinCgQY0bc7GCRxy5xVHy+moaqkpL/jqQq0MtQOeYcrqEz4abc5f0KtU7W4A==", + "dev": true, + "license": "MIT", + "dependencies": { + "color-convert": "^2.0.1", + "color-string": "^1.9.0" + }, + "engines": { + "node": ">=12.5.0" + } + }, + "node_modules/color-convert": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz", + "integrity": "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "color-name": "~1.1.4" + }, + "engines": { + "node": ">=7.0.0" + } + }, + "node_modules/color-name": { + "version": "1.1.4", + "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz", + "integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==", + "dev": true, + "license": "MIT" + }, + "node_modules/color-string": { + "version": "1.9.1", + "resolved": "https://registry.npmjs.org/color-string/-/color-string-1.9.1.tgz", + "integrity": "sha512-shrVawQFojnZv6xM40anx4CkoDP+fZsw/ZerEMsW/pyzsRbElpsL/DBVW7q3ExxwusdNXI3lXpuhEZkzs8p5Eg==", + "dev": true, + "license": "MIT", + "dependencies": { + "color-name": "^1.0.0", + "simple-swizzle": "^0.2.2" + } + }, + "node_modules/extend": { + "version": "3.0.2", + "resolved": "https://registry.npmjs.org/extend/-/extend-3.0.2.tgz", + "integrity": "sha512-fjquC59cD7CyW6urNXK0FBufkZcoiGG80wTuPujX590cB5Ttln20E2UB4S/WARVqhXffZl2LNgS+gQdPIIim/g==", + "dev": true, + "license": "MIT" + }, + "node_modules/is-arrayish": { + "version": "0.3.2", + "resolved": "https://registry.npmjs.org/is-arrayish/-/is-arrayish-0.3.2.tgz", + "integrity": "sha512-eVRqCvVlZbuw3GrM63ovNSNAeA1K16kaR/LRY/92w0zxQ5/1YzwblUX652i4Xs9RwAGjW9d9y6X88t8OaAJfWQ==", + "dev": true, + "license": "MIT" + }, + "node_modules/is-buffer": { + "version": "2.0.5", + "resolved": "https://registry.npmjs.org/is-buffer/-/is-buffer-2.0.5.tgz", + "integrity": "sha512-i2R6zNFDwgEHJyQUtJEk0XFi1i0dPFn/oqjK3/vPCcDeJvW5NQ83V8QbicfF1SupOaB0h8ntgBC2YiE7dfyctQ==", + "dev": true, + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/feross" + }, + { + "type": "patreon", + "url": "https://www.patreon.com/feross" + }, + { + "type": "consulting", + "url": "https://feross.org/support" + } + ], + "license": "MIT", + "engines": { + "node": ">=4" + } + }, + "node_modules/is-plain-obj": { + "version": "4.1.0", + "resolved": "https://registry.npmjs.org/is-plain-obj/-/is-plain-obj-4.1.0.tgz", + "integrity": "sha512-+Pgi+vMuUNkJyExiMBt5IlFoMyKnr5zhJ4Uspz58WOhBF5QoIZkFyNHIbBAtHwzVAgk5RtndVNsDRN61/mmDqg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=12" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/prettier": { + "version": "3.5.3", + "resolved": "https://registry.npmjs.org/prettier/-/prettier-3.5.3.tgz", + "integrity": "sha512-QQtaxnoDJeAkDvDKWCLiwIXkTgRhwYDEQCghU9Z6q03iyek/rxRh/2lC3HB7P8sWT2xC/y5JDctPLBIGzHKbhw==", + "dev": true, + "license": "MIT", + "bin": { + "prettier": "bin/prettier.cjs" + }, + "engines": { + "node": ">=14" + }, + "funding": { + "url": "https://github.com/prettier/prettier?sponsor=1" + } + }, + "node_modules/prettier-plugin-latex": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/prettier-plugin-latex/-/prettier-plugin-latex-2.0.1.tgz", + "integrity": "sha512-xIKGN0uWU+JwGHI92ixohngGLpy2nGQhYnmTtVue/jbw+K0fFPddQ3pMXx3fjtmmUhlbZisYXehJtcJ9Ford0g==", + "dev": true, + "license": "MIT", + "dependencies": { + "@unified-latex/unified-latex-prettier": "^2.4.2", + "prettier": "^3.0.3" + }, + "engines": { + "node": ">= 18.0" + } + }, + "node_modules/simple-swizzle": { + "version": "0.2.2", + "resolved": "https://registry.npmjs.org/simple-swizzle/-/simple-swizzle-0.2.2.tgz", + "integrity": "sha512-JA//kQgZtbuY83m+xT+tXJkmJncGMTFT+C+g2h2R9uxkYIrE2yy9sgmcLhCnw57/WSD+Eh3J97FPEDFnbXnDUg==", + "dev": true, + "license": "MIT", + "dependencies": { + "is-arrayish": "^0.3.1" + } + }, + "node_modules/trie-prefix-tree": { + "version": "1.5.1", + "resolved": "https://registry.npmjs.org/trie-prefix-tree/-/trie-prefix-tree-1.5.1.tgz", + "integrity": "sha512-Jjvj/dA97wXnabG/NLJUgo4IQMj6vucH+Qxm7of/omfWSmZlPqdRU6Ta4GmQqCZH+n3/iYZUwfvUoEhB0Hs83Q==", + "dev": true, + "license": "MIT" + }, + "node_modules/trough": { + "version": "2.2.0", + "resolved": "https://registry.npmjs.org/trough/-/trough-2.2.0.tgz", + "integrity": "sha512-tmMpK00BjZiUyVyvrBK7knerNgmgvcV/KLVyuma/SC+TQN167GrMRciANTz09+k3zW8L8t60jWO1GpfkZdjTaw==", + "dev": true, + "license": "MIT", + "funding": { + "type": "github", + "url": "https://github.com/sponsors/wooorm" + } + }, + "node_modules/unified": { + "version": "10.1.2", + "resolved": "https://registry.npmjs.org/unified/-/unified-10.1.2.tgz", + "integrity": "sha512-pUSWAi/RAnVy1Pif2kAoeWNBa3JVrx0MId2LASj8G+7AiHWoKZNTomq6LG326T68U7/e263X6fTdcXIy7XnF7Q==", + "dev": true, + "license": "MIT", + "dependencies": { + "@types/unist": "^2.0.0", + "bail": "^2.0.0", + "extend": "^3.0.0", + "is-buffer": "^2.0.0", + "is-plain-obj": "^4.0.0", + "trough": "^2.0.0", + "vfile": "^5.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, + "node_modules/unist-util-stringify-position": { + "version": "3.0.3", + "resolved": "https://registry.npmjs.org/unist-util-stringify-position/-/unist-util-stringify-position-3.0.3.tgz", + "integrity": "sha512-k5GzIBZ/QatR8N5X2y+drfpWG8IDBzdnVj6OInRNWm1oXrzydiaAT2OQiA8DPRRZyAKb9b6I2a6PxYklZD0gKg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@types/unist": "^2.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, + "node_modules/vfile": { + "version": "5.3.7", + "resolved": "https://registry.npmjs.org/vfile/-/vfile-5.3.7.tgz", + "integrity": "sha512-r7qlzkgErKjobAmyNIkkSpizsFPYiUPuJb5pNW1RB4JcYVZhs4lIbVqk8XPk033CV/1z8ss5pkax8SuhGpcG8g==", + "dev": true, + "license": "MIT", + "dependencies": { + "@types/unist": "^2.0.0", + "is-buffer": "^2.0.0", + "unist-util-stringify-position": "^3.0.0", + "vfile-message": "^3.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, + "node_modules/vfile-message": { + "version": "3.1.4", + "resolved": "https://registry.npmjs.org/vfile-message/-/vfile-message-3.1.4.tgz", + "integrity": "sha512-fa0Z6P8HUrQN4BZaX05SIVXic+7kE3b05PWAtPuYP9QLHsLKYR7/AlLW3NtOrpXRLeawpDLMsVkmk5DG0NXgWw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@types/unist": "^2.0.0", + "unist-util-stringify-position": "^3.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + } + } +} diff --git a/package.json b/package.json new file mode 100644 index 0000000..06ea2e9 --- /dev/null +++ b/package.json @@ -0,0 +1,6 @@ +{ + "devDependencies": { + "prettier": "^3.5.3", + "prettier-plugin-latex": "^2.0.1" + } +} diff --git a/private/approvalpage.tex b/private/approvalpage.tex new file mode 100644 index 0000000..6af7b69 --- /dev/null +++ b/private/approvalpage.tex @@ -0,0 +1,34 @@ +\thispagestyle{empty} +\begin{center} +{\Large \textbf{BorBann\\A Real Estate Information Platform\\(Project Proposal)}} + +\vspace{1cm} +{\large by} + +\vspace{0.5cm} +{\large Pattadon Loyprasert 6510545608\\ +Sirin Phungkun 6510545730} + +\vspace{2cm} +{\large \textbf{This Project Submitted in Partial Fulfillment of the Requirements\\ +for Bachelor Degree of Engineering\\ +(Software Engineering)}} + +\vspace{0.5cm} +{\large Department of Computer Engineering, Faculty of Engineering\\ +KASETSART UNIVERSITY\\ +Academic Year \graduationyear} +\end{center} + +\vspace{3cm} +\noindent Approved by: + +\vspace{1.5cm} +\noindent Advisor\dotfill Date\dots{}/\dots{}/\dots{}\\ +\indent(Assoc.Prof.Dr. Kitsana Waiyamai) + +% \vspace{1.5cm} +% \noindent Head of Department \dotfill Date\dots{}/\dots{}/\dots{}\\ +% \indent(Assoc.Prof.Dr. Panpiti Piamsa-nga) + +\clearpage \ No newline at end of file diff --git a/private/frontpage.tex b/private/frontpage.tex new file mode 100644 index 0000000..02ab715 --- /dev/null +++ b/private/frontpage.tex @@ -0,0 +1,70 @@ +% T I T L E P A G E +% ------------------- +% Last updated May 24, 2011, by Stephen Carr, IST-Client Services +% The title page is counted as page `i' but we need to suppress the +% page number. We also don't want any headers or footers. +\pagestyle{empty} +\thispagestyle{empty} % Removes the page number from the title page +\pagenumbering{roman} + +% The contents of the title page are specified in the "titlepage" +% environment. + + \begin{center} + \vspace*{1.0cm} + + \Huge + + + \begin{center} + \Huge \bfseries + \thesistitlecoverpage + \end{center} + \vskip5pt + \vfill + + + \vspace*{1.0cm} + + \normalsize + by \\ + + \vspace*{1.0cm} + + \Large + \thesisauthor \\ + \thesecondsisauthor \\ + + \vspace*{3.0cm} + + \normalsize + Submitted as\\ + Software Requirements Specification \\ + for\\ + \nameofprogram + %\nameofprogram\\ + + \vspace*{2.0cm} + + % \academicunit\\ + \faculty\\ + Kasetsart University\\ + Bangkok, Thailand + + \vspace*{2.0cm} + March \the\year\\ + % Copyright \copyright ~\the\year, \thesisauthor\\ + % All Rights Reserved + \end{center} + + +% September 2024 +% Copyright © 2024, [Student Name] +% All Rights Reserved + +% The rest of the front pages should contain no headers and be numbered using Roman numerals starting with `ii' +\pagestyle{plain} +\setcounter{page}{2} + +\cleardoublepage % Ends the current page and causes all figures and tables that have so far appeared in the input to be printed. +% In a two-sided printing style, it also makes the next page a right-hand (odd-numbered) page, producing a blank page if necessary. diff --git a/private/list-of-symbols.tex b/private/list-of-symbols.tex new file mode 100644 index 0000000..e978f63 --- /dev/null +++ b/private/list-of-symbols.tex @@ -0,0 +1,25 @@ +% L I S T O F S Y M B O L S +% ----------------------------- +% To include a Nomenclature section +\addcontentsline{toc}{chapter}{\textbf{Nomenclature}} + +\renewcommand{\nomname}{Nomenclature} +\renewcommand{\nomAname}{\textbf{\large Abbreviations}} +\renewcommand{\nomGname}{\textbf{\large Mathematical Symbols}} +\renewcommand{\nomXname}{\textbf{\large Superscripts}} +\renewcommand{\nomZname}{\textbf{\large Subscripts}} + +\printnomenclature +\cleardoublepage +\phantomsection % allows hyperref to link to the correct page +% \newpage + + + + + + +%%% Local Variables: +%%% mode: latex +%%% TeX-master: "../uottawa-thesis" +%%% End: \ No newline at end of file diff --git a/private/thesis-margins-and-spaces.tex b/private/thesis-margins-and-spaces.tex new file mode 100644 index 0000000..1dd0fc5 --- /dev/null +++ b/private/thesis-margins-and-spaces.tex @@ -0,0 +1,42 @@ +% Setting up the page margins... +% A minimum of 1 inch (72pt) margin at the +% top, bottom, and outside page edges and a 1.125 in. (81pt) gutter +% margin (on binding side). While this is not an issue for electronic +% viewing, a PDF may be printed, and so we have the same page layout for +% both printed and electronic versions, we leave the gutter margin in. +% Set margins: +\setlength{\marginparwidth}{0pt} % width of margin notes +% N.B. If margin notes are used, you must adjust \textwidth, \marginparwidth +% and \marginparsep so that the space left between the margin notes and page +% edge is less than 15 mm (0.6 in.) +\setlength{\marginparsep}{0pt} % width of space between body text and margin notes +\setlength{\evensidemargin}{0.125in} % Adds 1/8 in. to binding side of all +% even-numbered pages when the "twoside" printing option is selected +\setlength{\oddsidemargin}{0.125in} % Adds 1/8 in. to the left of all pages +% when "oneside" printing is selected, and to the left of all odd-numbered +% pages when "twoside" printing is selected +\setlength{\textwidth}{6.375in} % assuming US letter paper (8.5 in. x 11 in.) and +% side margins as above +\raggedbottom + +% The following statement specifies the amount of space between +% paragraphs. Other reasonable specifications are \bigskipamount and \smallskipamount. +\setlength{\parskip}{\medskipamount} + +% The following statement controls the line spacing. The default +% spacing corresponds to good typographic conventions and only slight +% changes (e.g., perhaps "1.2"), if any, should be made. +\renewcommand{\baselinestretch}{1} % this is the default line space setting + +% By default, each chapter will start on a recto (right-hand side) +% page. We also force each section of the front pages to start on +% a recto page by inserting \cleardoublepage commands. +% In many cases, this will require that the verso page be +% blank and, while it should be counted, a page number should not be +% printed. The following statements ensure a page number is not +% printed on an otherwise blank verso page. +\let\origdoublepage\cleardoublepage +\newcommand{\clearemptydoublepage}{% + \clearpage{\pagestyle{empty}\origdoublepage}} +\let\cleardoublepage\clearemptydoublepage + diff --git a/private/toc-lot-lof.tex b/private/toc-lot-lof.tex new file mode 100644 index 0000000..b786411 --- /dev/null +++ b/private/toc-lot-lof.tex @@ -0,0 +1,26 @@ +% % T A B L E O F C O N T E N T S +% % --------------------------------- + + +\renewcommand\contentsname{Table of Contents} +\tableofcontents +\cleardoublepage +\phantomsection +\newpage + +% L I S T O F T A B L E S +% --------------------------- +\addcontentsline{toc}{chapter}{List of Tables} +\listoftables +\cleardoublepage +\phantomsection % allows hyperref to link to the correct page +\newpage + +% % L I S T O F F I G U R E S +% % ----------------------------- +% \addcontentsline{toc}{chapter}{List of Figures} +% \listoffigures +% \cleardoublepage +% \phantomsection % allows hyperref to link to the correct page +%\newpage + diff --git a/thesis-preamble.tex b/thesis-preamble.tex new file mode 100644 index 0000000..f1e8412 --- /dev/null +++ b/thesis-preamble.tex @@ -0,0 +1,63 @@ +% Load your needed packages and other commands of yours here: +\usepackage[firstpage=true]{background} +\backgroundsetup{scale=1, angle=0, opacity=.1, contents ={ +% \includegraphics[width=14cm]{MBZUAI-Blue.eps} +}} + +%-------------------------------------------------------------------------- +% Do NOT edit the rest of the preamble UNLESS YOU KNOW WHAT YOU'RE DOING! +%-------------------------------------------------------------------------- + +\ifthenelse{\boolean{PrintVersion}}{ +\usepackage[top=1in,bottom=1in,left=0.75in,right=1.25in]{geometry} % For twoside document +}{ +\usepackage[top=1in,bottom=1in,left=0.75in,right=1.25in]{geometry} % For oneside document +} + +\usepackage{amsmath,amssymb,amstext} % Lots of math symbols and environments +\usepackage{graphicx} % For including graphics + +\usepackage{nomentbl} +\makenomenclature + +\usepackage{ifpdf} + +\newcommand{\href}[1]{#1} % does nothing, but defines the command so the print-optimized version will ignore \href tags + +\usepackage[\ifpdf pdftex,\fi pagebackref=false]{hyperref} % with basic options +\ifthenelse{\boolean{PrintVersion}}{ % for improved print quality, change some hyperref options +\hypersetup{ % override some previously defined hyperref options + citecolor=black,% + filecolor=black,% + linkcolor=black,% + urlcolor=black} +}{} % end of ifthenelse (no else) + +\usepackage{etoolbox} % For patching commands + +\makeatletter +% Redefine \tableofcontents to use \section* +\renewcommand{\tableofcontents}{% + \section*{\contentsname}% + \@mkboth{\contentsname}{\contentsname}% Set headers + \@starttoc{toc}% Generate TOC +} + +% Redefine \listoffigures to use \section* +\renewcommand{\listoffigures}{% + \section*{\listfigurename}% + \@mkboth{\listfigurename}{\listfigurename}% Set headers + \@starttoc{lof}% Generate LOF +} + +% Redefine \listoftables to use \section* +\renewcommand{\listoftables}{% + \section*{\listtablename}% + \@mkboth{\listtablename}{\listtablename}% Set headers + \@starttoc{lot}% Generate LOT +} + + +\usepackage{booktabs} +\usepackage{colortbl} +\usepackage{enumitem} \ No newline at end of file